DSRAgent Class Reference

#include <dsragent.h>

Inheritance diagram for DSRAgent:

[legend]Collaboration diagram for DSRAgent:

[legend]List of all members.

Public Member Functions
virtual int	command (int argc, const char *const *argv)
virtual void	recv (Packet *, Handler *callback=0)
void	tap (const Packet *p)
void	Terminate (void)
void	sendOutBCastPkt (Packet *p)
	DSRAgent ()
	~DSRAgent ()
	LIST_ENTRY (DSRAgent) link
virtual void	recv (Packet *p, const char *s)
void	recvOnly (Packet *)
void	send (Packet *p, Handler *h)
virtual void	send (int sz, AppData *data)
virtual void	send (int nbytes)
virtual void	timeout (int tno)
virtual void	sendmsg (int sz, AppData *, const char *flags=0)
virtual void	sendmsg (int nbytes, const char *flags=0)
virtual void	sendto (int sz, AppData *, const char *flags, nsaddr_t dst)
virtual void	sendto (int nbytes, const char *flags, nsaddr_t dst)
virtual void	connect (nsaddr_t dst)
virtual void	close ()
virtual void	listen ()
virtual void	attachApp (Application *app)
virtual int &	size ()
nsaddr_t &	addr ()
nsaddr_t &	port ()
nsaddr_t &	daddr ()
nsaddr_t &	dport ()
void	set_pkttype (packet_t pkttype)
packet_t	get_pkttype ()
NsObject *	target ()
virtual void	drop (Packet *p)
int	isdebug () const
virtual void	debug (const char *fmt,...)
Static Public Attributes
DSRAgent_List	agthead = { 0 }
Protected Member Functions
virtual void	delay_bind_init_all ()
virtual int	delay_bind_dispatch (const char *varName, const char *localName, TclObject *tracer)
virtual void	recvBytes (int bytes)
virtual void	idle ()
Packet *	allocpkt () const
Packet *	allocpkt (int) const
void	initpkt (Packet *) const
virtual void	trace (TracedVar *v)
void	deleteAgentTrace ()
void	addAgentTrace (const char *name)
void	monitorAgentTrace ()
OldValue *	lookupOldValue (TracedVar *v)
void	insertOldValue (TracedVar *v, const char *value)
void	dumpTracedVars ()
virtual void	trace_event (char *eventtype)
virtual void	drop (Packet *p, const char *s)
virtual void	reset ()
void	handle (Event *)
Protected Attributes
ns_addr_t	here_
ns_addr_t	dst_
int	size_
packet_t	type_
int	fid_
int	prio_
int	flags_
int	defttl_
Tcl_Channel	channel_
char *	traceName_
OldValue *	oldValueList_
Application *	app_
EventTrace *	et_
NsObject *	target_
NsObject *	drop_
int	debug_
Static Protected Attributes
int	uidcnt_
Private Member Functions
int	diff_subnet (ID dest, ID myid)
void	handlePktWithoutSR (SRPacket &p, bool retry)
void	handlePacketReceipt (SRPacket &p)
void	handleForwarding (SRPacket &p)
void	handleRouteRequest (SRPacket &p)
void	handleFlowForwarding (SRPacket &p)
void	handleFlowForwarding (SRPacket &p, int flowidx)
void	handleDefaultForwarding (SRPacket &p)
bool	ignoreRouteRequestp (SRPacket &p)
void	sendOutPacketWithRoute (SRPacket &p, bool fresh, Time delay=0.0)
void	sendOutRtReq (SRPacket &p, int max_prop=MAX_SR_LEN)
void	getRouteForPacket (SRPacket &p, bool retry)
void	acceptRouteReply (SRPacket &p)
void	returnSrcRouteToRequestor (SRPacket &p)
bool	replyFromRouteCache (SRPacket &p)
void	processUnknownFlowError (SRPacket &p, bool asDefault)
void	processFlowARS (const Packet *packet)
void	processBrokenRouteError (SRPacket &p)
void	sendUnknownFlow (SRPacket &p, bool asDefault, u_int16_t flowid=0)
void	xmitFailed (Packet *pkt, const char *reason="DROP_RTR_MAC_CALLBACK")
void	xmitFlowFailed (Packet *pkt, const char *reason="DROP_RTR_MAC_CALLBACK")
void	undeliverablePkt (Packet *p, int mine)
void	dropSendBuff (SRPacket &p)
void	stickPacketInSendBuffer (SRPacket &p)
void	sendBufferCheck ()
void	sendRouteShortening (SRPacket &p, int heard_at, int xmit_at)
void	testinit ()
void	trace (char *fmt,...)
Private Attributes
Trace *	logtarget
int	off_mac_
int	off_ll_
int	off_ip_
int	off_sr_
ID	net_id
ID	MAC_id
NsObject *	ll
CMUPriQueue *	ifq
Mac *	mac_
MobileNode *	node_
NsObject *	port_dmux_
int	tap_uid_cache [TAP_CACHE_SIZE]
RequestTable	request_table
RouteCache *	route_cache
SendBufEntry	send_buf [SEND_BUF_SIZE]
SendBufferTimer	send_buf_timer
int	route_request_num
int	num_heldoff_rt_replies
RtRepHoldoff	rtrep_holdoff [RTREP_HOLDOFF_SIZE]
GratReplyHoldDown	grat_hold [RTREP_HOLDOFF_SIZE]
int	grat_hold_victim
FlowTable	flow_table
ARSTable	ars_table
bool	route_error_held
ID	err_from
ID	err_to
Time	route_error_data_time
Friends
class	SendBufferTimer
void	XmitFailureCallback (Packet *pkt, void *data)
void	XmitFlowFailureCallback (Packet *pkt, void *data)
int	FilterFailure (Packet *p, void *data)

---

Constructor & Destructor Documentation

DSRAgent::DSRAgent (   )

Definition at line 315 of file dsragent.cc. References agthead, grat_hold, grat_hold_victim, ifq, invalid_addr, LIST_INSERT_HEAD, logtarget, mac_, makeRouteCache(), num_heldoff_rt_replies, GratReplyHoldDown::p, PT_DSR, RtRepHoldoff::requested_dest, Path::reset(), route_cache, route_error_held, route_request_num, rtrep_holdoff, RTREP_HOLDOFF_SIZE, GratReplyHoldDown::t, tap_uid_cache, and Connector::target_. : Agent(PT_DSR), request_table(128), route_cache(NULL), send_buf_timer(this), flow_table(), ars_table() { int c; route_request_num = 1; route_cache = makeRouteCache(); for (c = 0 ; c < RTREP_HOLDOFF_SIZE ; c++) rtrep_holdoff[c].requested_dest = invalid_addr; num_heldoff_rt_replies = 0; target_ = 0; logtarget = 0; grat_hold_victim = 0; for (c = 0; c < RTREP_HOLDOFF_SIZE ; c++) { grat_hold[c].t = 0; grat_hold[c].p.reset(); } //bind("off_SR_", &off_sr_); //bind("off_ll_", &off_ll_); //bind("off_mac_", &off_mac_); //bind("off_ip_", &off_ip_); ll = 0; ifq = 0; mac_ = 0; LIST_INSERT_HEAD(&agthead, this, link); #ifdef DSR_FILTER_TAP bzero(tap_uid_cache, sizeof(tap_uid_cache)); #endif route_error_held = false; }

Here is the call graph for this function:

DSRAgent::~DSRAgent (   )

Definition at line 352 of file dsragent.cc. { fprintf(stderr,"DFU: Don't do this! I haven't figured out ~DSRAgent\n"); exit(-1); }

---

Member Function Documentation

void DSRAgent::acceptRouteReply (  SRPacket &  p  )  [private]

Definition at line 1664 of file dsragent.cc. References abort(), hdr_sr::access(), RouteCache::addRoute(), arp_timeout, MobileNode::base_stn(), SRPacket::dest, diff_subnet(), Connector::drop(), Path::dump(), ID::dump(), RouteCache::findRoute(), RequestTable::getEntry(), HDR_CMN, God::hops(), Scheduler::instance(), God::instance(), Entry::last_rt_req, Path::length(), net_id, node_, SendBufEntry::p, SRPacket::pkt, hdr_sr::reply_addrs(), request_table, SRPacket::route, route_cache, hdr_sr::route_reply(), hdr_sr::route_reply_len(), Entry::rt_reqs_outstanding, hdr_sr::rtreq_seq(), send_buf, SEND_BUF_SIZE, sendOutPacketWithRoute(), SRPacket::src, Time, trace(), verbose, and verbose_srr. Referenced by handlePacketReceipt(). { hdr_sr *srh = hdr_sr::access(p.pkt); Path reply_route(srh->reply_addrs(), srh->route_reply_len()); if (!srh->route_reply()) { // somethings wrong... trace("SDFU non route containing packet given to acceptRouteReply"); fprintf(stderr, "dfu: non route containing packet given to acceptRouteReply\n"); } bool good_reply = true; //#ifdef USE_GOD_FEEDBACK /* check to see if this reply is valid or not using god info */ int i; for (i = 0; i < reply_route.length()-1 ; i++) if (God::instance()->hops(reply_route[i].getNSAddr_t(), reply_route[i+1].getNSAddr_t()) != 1) { good_reply = false; break; } //#endif //GOD_FEEDBACK if (verbose_srr) trace("SRR %.9f _%s_ reply-received %d from %s %s #%d -> %s %s", Scheduler::instance().clock(), net_id.dump(), good_reply ? 1 : 0, p.src.dump(), reply_route[0].dump(), srh->rtreq_seq(), reply_route[reply_route.length()-1].dump(), reply_route.dump()); // add the new route into our cache route_cache->addRoute(reply_route, Scheduler::instance().clock(), p.src); // back down the route request counters Entry *e = request_table.getEntry(reply_route[reply_route.length()-1]); e->rt_reqs_outstanding = 0; e->last_rt_req = 0.0; // see if the addtion of this route allows us to send out // any of the packets we have waiting Time delay = 0.0; ID dest; for (int c = 0; c < SEND_BUF_SIZE; c++) { if (send_buf[c].p.pkt == NULL) continue; // check if pkt is destined to outside domain if (diff_subnet(send_buf[c].p.dest,net_id)) { dest = ID(node_->base_stn(),::IP); send_buf[c].p.dest = dest; } if (route_cache->findRoute(send_buf[c].p.dest, send_buf[c].p.route, 1)) { // we have a route! #ifdef DEBUG struct hdr_cmn *ch = HDR_CMN(send_buf[c].p.pkt); if(ch->size() < 0) { drop(send_buf[c].p.pkt, "XXX"); abort(); } #endif if (verbose) trace("Sdebug %.9f _%s_ liberated from sendbuf %s->%s %s", Scheduler::instance().clock(), net_id.dump(), send_buf[c].p.src.dump(), send_buf[c].p.dest.dump(), send_buf[c].p.route.dump()); /* we need to spread out the rate at which we send packets in to the link layer to give ARP time to complete. If we dump all the packets in at once, all but the last one will be dropped. XXX THIS IS A MASSIVE HACK -dam 4/14/98 */ sendOutPacketWithRoute(send_buf[c].p, true, delay); delay += arp_timeout; send_buf[c].p.pkt = NULL; } } }

Here is the call graph for this function:

void Agent::addAgentTrace (  const char *  name  )  [protected, inherited]

Definition at line 326 of file agent.cc. References ns_addr_t::addr_, Agent::channel_, Scheduler::clock(), Agent::dst_, Agent::here_, Scheduler::instance(), TIME_FORMAT, and Agent::traceName_. Referenced by Agent::command(). { char wrk[256]; int n; double curTime = (&Scheduler::instance() == NULL ? 0 : Scheduler::instance().clock()); sprintf(wrk, "a -t "TIME_FORMAT" -s %d -d %d -n %s", curTime, here_.addr_, dst_.addr_, name); n = strlen(wrk); wrk[n] = '\n'; wrk[n+1] = 0; if (channel_) (void)Tcl_Write(channel_, wrk, n+1); // keep agent trace name if (traceName_ != NULL) delete[] traceName_; traceName_ = new char[strlen(name)+1]; strcpy(traceName_, name); }

Here is the call graph for this function:

nsaddr_t& Agent::addr (   )  [inline, inherited]

Definition at line 96 of file agent.h. References ns_addr_t::addr_, Agent::here_, and nsaddr_t. Referenced by LandmarkAgent::assign_lmaddress(), SSMSRMAgent::command(), IntTcpAgent::createTcpSession(), Agent::flushAVar(), LmsSender::handle_lms_pkt(), SSMSRMAgent::is_active(), QSNewRenoTcpAgent::recv(), TcpAsymSink::recv(), SRMAgent::recv(), SSMSRMAgent::recv(), QSAgent::recv(), MIPBSAgent::recv(), LmsAgent::recv(), HttpInvalAgent::recv(), CtrMcastEncap::recv(), SSMSRMAgent::recv_glb_sess(), SSMSRMAgent::recv_loc_sess(), SSMSRMAgent::recv_rep_sess(), SRMAgent::recv_sess(), TapAgent::recvpkt(), MIPMHAgent::reg(), MIPBSAgent::send_ads(), LmsSender::send_dmcast(), LmsReceiver::send_dmcast(), LmsAgent::send_downstream(), SSMSRMAgent::send_glb_sess(), LmsSender::send_lms_pkt(), SSMSRMAgent::send_loc_sess(), LmsReceiver::send_nak(), LmsReceiver::send_refresh(), SSMSRMAgent::send_rep_sess(), SRMAgent::send_sess(), MIPMHAgent::send_sols(), LmsSender::send_spm(), LmsAgent::send_upstream(), SRMAgent::sendmsg(), LmsSender::solicit_naks(), SRMAgent::start(), TcpAgent::trace_event(), TcpAgent::traceAll(), TcpAsymAgent::traceAll(), TcpAgent::traceVar(), TcpSessionAgent::traceVar(), and TcpAsymAgent::traceVar(). { return here_.addr_; }

Packet * Agent::allocpkt (  int   )  const [protected, inherited]

Definition at line 517 of file agent.cc. References Packet::allocdata(), and Agent::allocpkt(). { Packet* p = allocpkt(); if (n > 0) p->allocdata(n); return(p); }

Here is the call graph for this function:

Packet * Agent::allocpkt (   )  const [protected, inherited]

Definition at line 506 of file agent.cc. References Packet::alloc(), and Agent::initpkt(). Referenced by TcpSink::ack(), QSTcpSink::ack(), Agent::allocpkt(), PingAgent::command(), MessageAgent::command(), mcastControlAgent::command(), LmsAgent::command(), LDPAgent::command(), LandmarkAgent::command(), IvsReceiver::command(), DSDV_Agent::command(), OmniMcastAgent::create_packet(), FloodingAgent::create_packet(), DiffusionAgent::create_packet(), SinkAgent::create_packet(), SensorQueryAgent::generate_query(), getRouteForPacket(), LandmarkAgent::makeUpdate(), DSDV_Agent::makeUpdate(), TcpAgent::output(), VegasTcpAgent::output(), RFC793eduTcpAgent::output(), QSNewRenoTcpAgent::output(), IntTcpAgent::output(), AbsTcpAgent::output(), TCPTapAgent::processpkt(), AbsDelAckSink::recv(), AbsTcpSink::recv(), SAack_Agent::recv(), PingAgent::recv(), Encapsulator::recv(), TapAgent::recvpkt(), MIPMHAgent::reg(), replyFromRouteCache(), returnSrcRouteToRequestor(), HttpInvalAgent::send(), MIPBSAgent::send_ads(), SRMAgent::send_ctrl(), SSMSRMAgent::send_ctrl(), MFTPSndAgent::send_data(), GAFAgent::send_discovery(), LmsSender::send_dmcast(), LmsReceiver::send_dmcast(), SSMSRMAgent::send_glb_sess(), LmsSender::send_lms_pkt(), SSMSRMAgent::send_loc_sess(), MFTPRcvAgent::send_nak(), LmsReceiver::send_nak(), LmsReceiver::send_refresh(), SSMSRMAgent::send_rep_sess(), SRMAgent::send_sess(), MIPMHAgent::send_sols(), LmsSender::send_spm(), MFTPSndAgent::send_status_request(), RapAgent::SendAck(), UdpAgent::sendmsg(), SimpleTcpAgent::sendmsg(), SRMAgent::sendmsg(), SA_Agent::sendmsg(), RTPAgent::sendmsg(), PushbackAgent::sendMsg(), LmsSender::sendmsg(), FullTcpAgent::sendpacket(), BayFullTcpAgent::sendpacket(), RapAgent::SendPacket(), TfrcAgent::sendpkt(), TfrcSinkAgent::sendpkt(), SA_Agent::sendpkt(), rtProtoDV::sendpkt(), RTPAgent::sendpkt(), RTCPAgent::sendpkt(), RLM_Sender::sendpkt(), IvsSource::sendpkt(), IcmpAgent::sendredirect(), SA_Agent::sendreq(), sendRouteShortening(), SA_Agent::sendteardown(), LmsSender::solicit_naks(), and AbsDelAckSink::timeout(). { Packet* p = Packet::alloc(); initpkt(p); return (p); }

Here is the call graph for this function:

void Agent::attachApp (  Application *  app  )  [virtual, inherited]

Definition at line 372 of file agent.cc. References Agent::app_. Referenced by HttpMInvalCache::command(), Application::command(), TcpApp::TcpApp(), and TcpApp::~TcpApp(). { app_ = app; }

void Agent::close (   )  [virtual, inherited]

Reimplemented in FullTcpAgent. Definition at line 377 of file agent.cc. Referenced by Agent::command(). { }

int DSRAgent::command (  int  argc, const char *const *  argv )  [virtual]

Reimplemented from Agent. Definition at line 403 of file dsragent.cc. References ID::addr, BUFFER_CHECK, RouteCache::command(), Agent::command(), dsragent_dont_salvage_bad_replies, dsragent_propagate_last_error, dsragent_reply_from_cache_on_propagating, dsragent_ring_zero_search, dsragent_salvage_with_cache, dsragent_send_grat_replies, dsragent_snoop_forwarded_errors, dsragent_snoop_source_routes, dsragent_use_tap, flow_table, ifq, Mac::installTap(), Address::instance(), Scheduler::instance(), IP, logtarget, MAC, mac_, RouteCache::MAC_id, MAC_id, RouteCache::net_id, net_id, node_, port_dmux_, route_cache, TimerHandler::sched(), send_buf_timer, FlowTable::setNetAddr(), Address::str2addr(), Terminate(), testinit(), trace(), and Random::uniform(). { TclObject *obj; if (argc == 2) { if (strcasecmp(argv[1], "testinit") == 0) { testinit(); return TCL_OK; } if (strcasecmp(argv[1], "reset") == 0) { Terminate(); return Agent::command(argc, argv); } if (strcasecmp(argv[1], "check-cache") == 0) { return route_cache->command(argc, argv); } if (strcasecmp(argv[1], "startdsr") == 0) { if (ID(1,::IP) == net_id) { // log the configuration parameters of the dsragent trace("Sconfig %.5f tap: %s snoop: rts? %s errs? %s", Scheduler::instance().clock(), dsragent_use_tap ? "on" : "off", dsragent_snoop_source_routes ? "on" : "off", dsragent_snoop_forwarded_errors ? "on" : "off"); trace("Sconfig %.5f salvage: %s !bd replies? %s", Scheduler::instance().clock(), dsragent_salvage_with_cache ? "on" : "off", dsragent_dont_salvage_bad_replies ? "on" : "off"); trace("Sconfig %.5f grat error: %s grat reply: %s", Scheduler::instance().clock(), dsragent_propagate_last_error ? "on" : "off", dsragent_send_grat_replies ? "on" : "off"); trace("Sconfig %.5f $reply for props: %s ring 0 search: %s", Scheduler::instance().clock(), dsragent_reply_from_cache_on_propagating ? "on" : "off", dsragent_ring_zero_search ? "on" : "off"); } // cheap source of jitter send_buf_timer.sched(BUFFER_CHECK + BUFFER_CHECK * Random::uniform(1.0)); return route_cache->command(argc,argv); } } else if(argc == 3) { if (strcasecmp(argv[1], "addr") == 0) { int temp; temp = Address::instance().str2addr(argv[2]); net_id = ID(temp, ::IP); flow_table.setNetAddr(net_id.addr); route_cache->net_id = net_id; return TCL_OK; } else if(strcasecmp(argv[1], "mac-addr") == 0) { MAC_id = ID(atoi(argv[2]), ::MAC); route_cache->MAC_id = MAC_id; return TCL_OK; } if( (obj = TclObject::lookup(argv[2])) == 0) { fprintf(stderr, "DSRAgent: %s lookup of %s failed\n", argv[1], argv[2]); return TCL_ERROR; } if (strcasecmp(argv[1], "log-target") == 0) { logtarget = (Trace*) obj; return route_cache->command(argc, argv); } else if (strcasecmp(argv[1], "tracetarget") == 0 ) { logtarget = (Trace*) obj; return route_cache->command(argc, argv); } else if (strcasecmp(argv[1], "install-tap") == 0) { mac_ = (Mac*) obj; mac_->installTap(this); return TCL_OK; } else if (strcasecmp(argv[1], "node") == 0) { node_ = (MobileNode *) obj; return TCL_OK; } else if (strcasecmp (argv[1], "port-dmux") == 0) { port_dmux_ = (NsObject *) obj; return TCL_OK; } } else if (argc == 4) { if (strcasecmp(argv[1], "add-ll") == 0) { if( (obj = TclObject::lookup(argv[2])) == 0) { fprintf(stderr, "DSRAgent: %s lookup of %s failed\n", argv[1], argv[2]); return TCL_ERROR; } ll = (NsObject*) obj; if( (obj = TclObject::lookup(argv[3])) == 0) { fprintf(stderr, "DSRAgent: %s lookup of %s failed\n", argv[1], argv[3]); return TCL_ERROR; } ifq = (CMUPriQueue *) obj; return TCL_OK; } } return Agent::command(argc, argv); }

Here is the call graph for this function:

void Agent::connect (  nsaddr_t  dst  )  [virtual, inherited]

Definition at line 389 of file agent.cc. Referenced by Agent::command(). { /* dst_ = dst; */ }

nsaddr_t& Agent::daddr (   )  [inline, inherited]

Definition at line 98 of file agent.h. References ns_addr_t::addr_, Agent::dst_, and nsaddr_t. Referenced by IntTcpAgent::createTcpSession(), DSDV_Agent::lost_link(), TcpAsymSink::recv(), CtrMcastEncap::recv(), PingResponder::reflect(), IntTcpAgent::rxmit_last(), LmsSender::send_dmcast(), LmsSender::send_lms_pkt(), IntTcpAgent::send_one(), rtProtoDV::sendpkt(), LmsSender::solicit_naks(), TcpAgent::trace_event(), TcpAgent::traceAll(), TcpAsymAgent::traceAll(), TcpAgent::traceVar(), TcpSessionAgent::traceVar(), and TcpAsymAgent::traceVar(). { return dst_.addr_; }

void NsObject::debug (  const char *  fmt, ...  )  [virtual, inherited]

Definition at line 102 of file object.cc. References NsObject::debug_. { if (!debug_) return; va_list ap; va_start(ap, fmt); vprintf(fmt, ap); }

int Agent::delay_bind_dispatch (  const char *  varName, const char *  localName, TclObject *  tracer )  [protected, virtual, inherited]

Reimplemented from NsObject. Reimplemented in BayFullTcpAgent, LDPAgent, FullTcpAgent, SackFullTcpAgent, RFC793eduTcpAgent, TcpSink, TcpAgent, and VegasTcpAgent. Definition at line 93 of file agent.cc. References ns_addr_t::addr_, Agent::defttl_, NsObject::delay_bind_dispatch(), Agent::dst_, Agent::fid_, Agent::flags_, Agent::here_, ns_addr_t::port_, and Agent::prio_. Referenced by TcpAgent::delay_bind_dispatch(), TcpSink::delay_bind_dispatch(), and LDPAgent::delay_bind_dispatch(). { if (delay_bind(varName, localName, "agent_addr_", (int*)&(here_.addr_), tracer)) return TCL_OK; if (delay_bind(varName, localName, "agent_port_", (int*)&(here_.port_), tracer)) return TCL_OK; if (delay_bind(varName, localName, "dst_addr_", (int*)&(dst_.addr_), tracer)) return TCL_OK; if (delay_bind(varName, localName, "dst_port_", (int*)&(dst_.port_), tracer)) return TCL_OK; if (delay_bind(varName, localName, "fid_", (int*)&fid_, tracer)) return TCL_OK; if (delay_bind(varName, localName, "prio_", (int*)&prio_, tracer)) return TCL_OK; if (delay_bind(varName, localName, "flags_", (int*)&flags_, tracer)) return TCL_OK; if (delay_bind(varName, localName, "ttl_", &defttl_, tracer)) return TCL_OK; if (delay_bind(varName, localName, "class_", (int*)&fid_, tracer)) return TCL_OK; return Connector::delay_bind_dispatch(varName, localName, tracer); }

Here is the call graph for this function:

void Agent::delay_bind_init_all (   )  [protected, virtual, inherited]

Reimplemented from NsObject. Reimplemented in BayFullTcpAgent, LDPAgent, FullTcpAgent, SackFullTcpAgent, RFC793eduTcpAgent, TcpSink, TcpAgent, and VegasTcpAgent. Definition at line 78 of file agent.cc. References NsObject::delay_bind_init_all(). Referenced by TcpAgent::delay_bind_init_all(), TcpSink::delay_bind_init_all(), and LDPAgent::delay_bind_init_all(). { delay_bind_init_one("agent_addr_"); delay_bind_init_one("agent_port_"); delay_bind_init_one("dst_addr_"); delay_bind_init_one("dst_port_"); delay_bind_init_one("fid_"); delay_bind_init_one("prio_"); delay_bind_init_one("flags_"); delay_bind_init_one("ttl_"); delay_bind_init_one("class_"); Connector::delay_bind_init_all(); }

Here is the call graph for this function:

void Agent::deleteAgentTrace (   )  [protected, inherited]

Definition at line 222 of file agent.cc. References ns_addr_t::addr_, Agent::dst_, Agent::flushAVar(), Agent::here_, Scheduler::instance(), TIME_FORMAT, and Agent::traceName_. Referenced by Agent::command(). { char wrk[256]; // XXX we don't know InstVar outside of Tcl! Is there any // tracedvars hidden in InstVar? If so, shall we have a tclclInt.h? TracedVar* var = tracedvar_; for ( ; var != 0; var = var->next_) flushAVar(var); // we need to flush all var values to trace file, // so nam can do backtracing sprintf(wrk, "a -t "TIME_FORMAT" -s %d -d %d -n %s -x", Scheduler::instance().clock(), here_.addr_, dst_.addr_, traceName_); if (traceName_ != NULL) delete[] traceName_; traceName_ = NULL; }

Here is the call graph for this function:

int DSRAgent::diff_subnet (  ID  dest, ID  myid )  [private]

Definition at line 1642 of file dsragent.cc. References ID::addr, Address::get_subnetaddr(), and Address::instance(). Referenced by acceptRouteReply(), handlePktWithoutSR(), and sendOutPacketWithRoute(). { int dst = dest.addr; int id = myid.addr; char* dstnet = Address::instance().get_subnetaddr(dst); char * subnet = Address::instance().get_subnetaddr(id); if (subnet != NULL) { if (dstnet != NULL) { if (strcmp(dstnet, subnet) != 0) { delete [] dstnet; return 1; } delete [] dstnet; } delete [] subnet; } assert(dstnet == NULL); return 0; }

Here is the call graph for this function:

nsaddr_t& Agent::dport (   )  [inline, inherited]

Definition at line 99 of file agent.h. References Agent::dst_, nsaddr_t, and ns_addr_t::port_. Referenced by DSDV_Agent::lost_link(), TcpAsymSink::recv(), CtrMcastEncap::recv(), IntTcpAgent::rxmit_last(), IntTcpAgent::send_one(), rtProtoDV::sendpkt(), TcpAgent::trace_event(), TcpAgent::traceAll(), TcpAsymAgent::traceAll(), TcpAgent::traceVar(), TcpSessionAgent::traceVar(), and TcpAsymAgent::traceVar(). { return dst_.port_; }

void Connector::drop (  Packet *  p, const char *  s )  [protected, virtual, inherited]

Definition at line 114 of file connector.cc. References Connector::drop_, Packet::free(), and NsObject::recv(). { if (drop_ != 0) drop_->recv(p, s); else Packet::free(p); }

Here is the call graph for this function:

void Connector::drop (  Packet *  p  )  [virtual, inherited]

Definition at line 106 of file connector.cc. References Connector::drop_, Packet::free(), and NsObject::recv(). Referenced by acceptRouteReply(), ARPTable::arpresolve(), JoBS::dropFront(), Vq::dropPacketForECN(), dropSendBuff(), JoBS::dropTail(), dsREDQueue::edrop(), Vq::enque(), SRR::enque(), SimpleIntServ::enque(), SFQ::enque(), rtqueue::enque(), RIOQueue::enque(), REMQueue::enque(), REDQueue::enque(), RedPDQueue::enque(), PIQueue::enque(), Marker::enque(), GK::enque(), dsREDQueue::enque(), DRR::enque(), DropTail::enque(), Demarker::enque(), aodv_rqueue::enque(), toraAgent::forward(), AODV::forward(), LandmarkAgent::ForwardPacket(), DSDV_Agent::forwardPacket(), getRouteForPacket(), Snoop::handle(), handleFlowForwarding(), handleForwarding(), DSDV_Agent::lost_link(), TCPTapAgent::processpkt(), CMUPriQueue::prq_enqueue(), rtqueue::purge(), imepAgent::purgeReXmitQ(), SessionTTLChecker::recv(), TTLChecker::recv(), toraAgent::recv(), FullTcpAgent::recv(), BayFullTcpAgent::recv(), TBF::recv(), SatLL::recv(), LL::recv(), GAFPartner::recv(), FloodAgent::recv(), Filter::recv(), DynamicLink::recv(), DSDV_Agent::recv(), AODV::recv(), AODV::recvError(), PriQueue::recvHighPriority(), AODV::recvReply(), toraAgent::reset(), Queue< T >::reset(), LinkDelay::reset(), AODV::rt_ll_failed(), AODV::rt_purge(), AODV::rt_resolve(), toraAgent::rtRoutePacket(), TCPTapAgent::sendpkt(), TapAgent::sendpkt(), IPTapAgent::sendpkt(), AODV::sendRequest(), SatLL::sendUp(), LL::sendUp(), PriQueue::Terminate(), Terminate(), CMUPriQueue::Terminate(), ARPTable::Terminate(), and undeliverablePkt(). { if (drop_ != 0) drop_->recv(p); else Packet::free(p); }

Here is the call graph for this function:

void DSRAgent::dropSendBuff (  SRPacket &  p  )  [private]

Definition at line 202 of file dsragent.cc. References SRPacket::dest, Connector::drop(), DROP_RTR_QTIMEOUT, ID::dump(), Scheduler::instance(), net_id, SRPacket::pkt, Path::reset(), SRPacket::route, SRPacket::src, and trace(). Referenced by sendBufferCheck(), and stickPacketInSendBuffer(). { trace("Ssb %.5f _%s_ dropped %s -> %s", Scheduler::instance().clock(), net_id.dump(), p.src.dump(), p.dest.dump()); drop(p.pkt, DROP_RTR_QTIMEOUT); p.pkt = 0; p.route.reset(); }

Here is the call graph for this function:

void Agent::dumpTracedVars (   )  [protected, inherited]

packet_t Agent::get_pkttype (   )  [inline, inherited]

Definition at line 101 of file agent.h. References packet_t, and Agent::type_. Referenced by CBR_Traffic::init(). { return type_; }

void DSRAgent::getRouteForPacket (  SRPacket &  p, bool  retry )  [private]

Definition at line 1414 of file dsragent.cc. References hdr_cmn::access(), hdr_ip::access(), hdr_sr::access(), Agent::allocpkt(), arp_timeout, BackOffTest(), Scheduler::clock(), Packet::copy(), Address::create_ipaddr(), hdr_ip::daddr(), SRPacket::dest, hdr_ip::dport(), Connector::drop(), DROP_RTR_NO_ROUTE, dsr_salvage_allow_propagating, dsr_salvage_max_requests, dsragent_ring_zero_search, ID::dump(), Packet::free(), RequestTable::getEntry(), ID::getNSAddr_t(), hdr_sr::init(), Address::instance(), Scheduler::instance(), IP_HDR_LEN, Entry::last_arp, Entry::last_type, LIMIT0, MAX_SR_LEN, net_id, hdr_cmn::num_forwards(), SRPacket::pkt, PT_DSR, hdr_cmn::ptype(), request_table, RT_PORT, Entry::rt_reqs_outstanding, hdr_ip::saddr(), sendOutRtReq(), hdr_cmn::size(), Agent::size_, hdr_ip::sport(), SRPacket::src, stickPacketInSendBuffer(), Time, trace(), UNLIMIT, and verbose_srr. Referenced by handlePktWithoutSR(). { // since we'll commonly be only one hop away, we should // arp first before route discovery as an optimization... Entry *e = request_table.getEntry(p.dest); Time time = Scheduler::instance().clock(); #if 0 /* pre 4/13/98 logic -dam removed b/c it seemed more complicated than needed since we're not doing piggybacking and we're returning route replies via a reversed route (the copy in this code is critical if we need to piggyback route replies on the route request to discover the return path) */ /* make the route request packet */ SRPacket rrp = p; rrp.pkt = p.pkt->copy(); hdr_sr *srh = hdr_sr::access(rrp.pkt); hdr_ip *iph = hdr_ip::access(rrp.pkt); hdr_cmn *cmh = hdr_cmn::access(rrp.pkt); //iph->daddr() = p.dest.getNSAddr_t(); iph->daddr() = Address::instance().create_ipaddr(p.dest.getNSAddr_t(),RT_PORT); iph->dport() = RT_PORT; //iph->saddr() = net_id.getNSAddr_t(); iph->saddr() = Address::instance().create_ipaddr(net_id.getNSAddr_t(),RT_PORT); iph->sport() = RT_PORT; cmnh->ptype() = PT_DSR; cmnh->size() = size_; cmnh->num_forwards() = 0; #endif /* make the route request packet */ SRPacket rrp; rrp.dest = p.dest; rrp.src = net_id; rrp.pkt = allocpkt(); hdr_sr *srh = hdr_sr::access(rrp.pkt); hdr_ip *iph = hdr_ip::access(rrp.pkt); hdr_cmn *cmnh = hdr_cmn::access(rrp.pkt); iph->daddr() = Address::instance().create_ipaddr(p.dest.getNSAddr_t(),RT_PORT); iph->dport() = RT_PORT; iph->saddr() = Address::instance().create_ipaddr(net_id.getNSAddr_t(),RT_PORT); iph->sport() = RT_PORT; cmnh->ptype() = PT_DSR; cmnh->size() = size_ + IP_HDR_LEN; // add in IP header cmnh->num_forwards() = 0; srh->init(); if (BackOffTest(e, time)) { // it's time to start another route request cycle #ifdef NEW_SALVAGE_LOGIC if(p.src != net_id) { assert(dsr_salvage_max_requests > 0); assert(p.pkt); if(e->rt_reqs_outstanding > dsr_salvage_max_requests) { drop(p.pkt, DROP_RTR_NO_ROUTE); p.pkt = 0; // dump the route request packet we made up Packet::free(rrp.pkt); rrp.pkt = 0; return; } } #endif /* NEW_SALVAGE_LOGIC */ if (dsragent_ring_zero_search) { // do a ring zero search e->last_type = LIMIT0; sendOutRtReq(rrp, 0); } else { // do a propagating route request right now e->last_type = UNLIMIT; sendOutRtReq(rrp, MAX_SR_LEN); } e->last_arp = time; } else if (LIMIT0 == e->last_type && #ifdef NEW_SALVAGE_LOGIC (dsr_salvage_allow_propagating || p.src == net_id) && #endif (time - e->last_arp) > arp_timeout) { // try propagating rt req since we haven't heard back // from limited one e->last_type = UNLIMIT; sendOutRtReq(rrp, MAX_SR_LEN); } else { // it's not time to send another route request... if (!retry && verbose_srr) trace("SRR %.5f _%s_ RR-not-sent %s -> %s", Scheduler::instance().clock(), net_id.dump(), rrp.src.dump(), rrp.dest.dump()); Packet::free(rrp.pkt); // dump the route request packet we made up rrp.pkt = 0; } /* for now, no piggybacking at all, queue all pkts */ if (!retry) { stickPacketInSendBuffer(p); p.pkt = 0; // pkt is handled for now (it's in sendbuffer) } }

Here is the call graph for this function:

void NsObject::handle (  Event *   )  [protected, virtual, inherited]

Implements Handler. Reimplemented in LinkDelay, LL, AckRecons, and Snoop. Definition at line 91 of file object.cc. References NsObject::recv(). { recv((Packet*)e); }

Here is the call graph for this function:

void DSRAgent::handleDefaultForwarding (  SRPacket &  p  )  [private]

Definition at line 746 of file dsragent.cc. References hdr_ip::access(), ID::addr, FlowTable::defaultFlow(), SRPacket::dest, FlowTable::find(), flow_table, handleFlowForwarding(), SRPacket::pkt, sendUnknownFlow(), SRPacket::src, hdr_ip::ttl(), and u_int16_t. Referenced by handleForwarding(). { hdr_ip *iph = hdr_ip::access(p.pkt); u_int16_t flowid; int flowidx; if (!flow_table.defaultFlow(p.src.addr, p.dest.addr, flowid)) { sendUnknownFlow(p, true); assert(p.pkt == 0); return; } if ((flowidx = flow_table.find(p.src.addr, p.dest.addr, flowid)) == -1) { sendUnknownFlow(p, false, flowid); assert(p.pkt == 0); return; } if (iph->ttl() != flow_table[flowidx].expectedTTL) { sendUnknownFlow(p, true); assert(p.pkt == 0); return; } // XXX should also check prevhop handleFlowForwarding(p, flowidx); }

Here is the call graph for this function:

void DSRAgent::handleFlowForwarding (  SRPacket &  p, int  flowidx )  [private]

Definition at line 775 of file dsragent.cc. References hdr_cmn::access(), hdr_ip::access(), hdr_sr::access(), hdr_cmn::addr_type(), ars_table, Scheduler::clock(), default_flow_timeout, SRPacket::dest, hdr_cmn::direction(), hdr_cmn::DOWN, Connector::drop(), DROP_RTR_TTL, dsragent_always_reestablish, ID::dump(), ARSTable::findAndClear(), flow_table, Path::index(), Scheduler::instance(), net_id, hdr_cmn::next_hop(), hdr_sr::num_addrs(), SRPacket::pkt, SRPacket::route, hdr_sr::salvaged(), Scheduler::schedule(), sendRouteShortening(), SRPacket::src, trace(), hdr_ip::ttl(), hdr_cmn::uid(), hdr_cmn::UP, hdr_cmn::xmit_failure_, hdr_cmn::xmit_failure_data_, and XmitFlowFailureCallback. { hdr_sr *srh = hdr_sr::access(p.pkt); hdr_ip *iph = hdr_ip::access(p.pkt); hdr_cmn *cmnh = hdr_cmn::access(p.pkt); int amt; assert(flowidx >= 0); assert(!srh->num_addrs()); cmnh->next_hop() = flow_table[flowidx].nextHop; cmnh->addr_type() = ::IP; cmnh->xmit_failure_ = XmitFlowFailureCallback; cmnh->xmit_failure_data_ = (void *) this; // make sure we aren't cycling packets //assert(p.pkt->incoming == 0); // this is an outgoing packet assert(cmnh->direction() == hdr_cmn::UP); if (!iph->ttl()--) { drop(p.pkt, DROP_RTR_TTL); p.pkt = 0; return; } trace("SFf %.9f _%s_ %d [%s -> %s] %d to %d", Scheduler::instance().clock(), net_id.dump(), cmnh->uid(), p.src.dump(), p.dest.dump(), flow_table[flowidx].flowId, flow_table[flowidx].nextHop); // XXX ych 5/8/01 ARS also should check previous hop if (!srh->salvaged() && (amt = ars_table.findAndClear(cmnh->uid(), flow_table[flowidx].flowId)) && p.route.index() - amt > 0) { trace("SFARS %.9f _%s_ %d [%s -> %s] %d %d", Scheduler::instance().clock(), net_id.dump(), cmnh->uid(), p.src.dump(), p.dest.dump(), flow_table[flowidx].flowId, amt); // stamp a route in the packet... p.route = flow_table[flowidx].sourceRoute; p.route.index() -= amt; sendRouteShortening(p, p.route.index(), flow_table[flowidx].sourceRoute.index()); } if (dsragent_always_reestablish) { // XXX this is an utter hack. the flow_table needs to remember the original // timeout value specified, as well as the original time to timeout. No // establishment packets are allowed after the original time. Must make sure // flowids assigned do not overlap. ych 5/8/01 flow_table[flowidx].timeout = Scheduler::instance().clock() + default_flow_timeout; } // set the direction pkt to be down cmnh->direction() = hdr_cmn::DOWN; Scheduler::instance().schedule(ll, p.pkt, 0); p.pkt = 0; }

Here is the call graph for this function:

void DSRAgent::handleFlowForwarding (  SRPacket &  p  )  [private]

Definition at line 835 of file dsragent.cc. References hdr_ip::access(), hdr_sr::access(), ID::addr, FlowTable::cleanup(), Scheduler::clock(), FlowTable::createEntry(), hdr_sr::cur_addr(), SRPacket::dest, FlowTable::find(), hdr_sr::flow_header(), hdr_sr::flow_id(), flow_table, hdr_sr::flow_timeout(), hdr_sr::flow_timeout_time(), hdr_sr::get_next_addr(), hdr_sr::get_next_type(), hdr_sr::hopCount(), Scheduler::instance(), net_id, hdr_sr::num_addrs(), SRPacket::pkt, SRPacket::route, sendUnknownFlow(), SRPacket::src, and hdr_ip::ttl(). Referenced by handleDefaultForwarding(), and handleForwarding(). { hdr_sr *srh = hdr_sr::access(p.pkt); hdr_ip *iph = hdr_ip::access(p.pkt); int flowidx = flow_table.find(p.src.addr, p.dest.addr, srh->flow_id()); assert(srh->flow_header()); if (srh->num_addrs()) { assert(srh->flow_timeout()); if (flowidx == -1) { flow_table.cleanup(); flowidx = flow_table.createEntry(p.src.addr, p.dest.addr, srh->flow_id()); assert(flowidx != -1); flow_table[flowidx].timeout = Scheduler::instance().clock() + srh->flow_timeout_time(); flow_table[flowidx].hopCount = srh->hopCount(); flow_table[flowidx].expectedTTL = iph->ttl(); flow_table[flowidx].sourceRoute = p.route; flow_table[flowidx].nextHop = srh->get_next_addr(); assert(srh->hopCount() == srh->cur_addr()); assert(srh->get_next_type() == ::IP); assert(flow_table[flowidx].sourceRoute[flow_table[flowidx].hopCount] == net_id); flow_table[flowidx].count = 0; // shouldn't be used flow_table[flowidx].allowDefault = false; // shouldn't be used } assert(flowidx != -1); //assert(flow_table[flowidx].hopCount == srh->hopCount()); srh->hopCount()++; return; } if (flowidx == -1) { // return an error sendUnknownFlow(p, false, srh->flow_id()); assert(p.pkt == 0); return; } //assert(flow_table[flowidx].hopCount == srh->hopCount()); srh->hopCount()++; // forward the packet handleFlowForwarding(p, flowidx); }

Here is the call graph for this function:

void DSRAgent::handleForwarding (  SRPacket &  p  )  [private]

Definition at line 889 of file dsragent.cc. References hdr_cmn::access(), hdr_ip::access(), hdr_sr::access(), Scheduler::clock(), Connector::drop(), DROP_RTR_ROUTE_LOOP, DROP_RTR_TTL, dsragent_snoop_source_routes, hdr_sr::flow_header(), handleDefaultForwarding(), handleFlowForwarding(), Path::index(), Scheduler::instance(), Path::length(), MAC_id, net_id, RouteCache::noticeRouteUsed(), hdr_sr::num_addrs(), SRPacket::pkt, SRPacket::route, route_cache, sendOutPacketWithRoute(), hdr_sr::size(), hdr_cmn::size(), trace(), and hdr_ip::ttl(). Referenced by recv(). { hdr_sr *srh = hdr_sr::access(p.pkt); hdr_ip *iph = hdr_ip::access(p.pkt); hdr_cmn *ch = hdr_cmn::access(p.pkt); bool flowOnly = !srh->num_addrs(); if (srh->flow_header()) handleFlowForwarding(p); else if (!srh->num_addrs()) handleDefaultForwarding(p); if (flowOnly) return; assert(p.pkt); // make sure flow state didn't eat the pkt // first make sure we are the ``current'' host along the source route. // if we're not, the previous node set up the source route incorrectly. assert(p.route[p.route.index()] == net_id || p.route[p.route.index()] == MAC_id); if (p.route.index() >= p.route.length()) { fprintf(stderr,"dfu: ran off the end of a source route\n"); trace("SDFU: ran off the end of a source route\n"); drop(p.pkt, DROP_RTR_ROUTE_LOOP); p.pkt = 0; // maybe we should send this packet back as an error... return; } // if there's a source route, maybe we should snoop it too if (dsragent_snoop_source_routes) route_cache->noticeRouteUsed(p.route, Scheduler::instance().clock(), net_id); // sendOutPacketWithRoute will add in the size of the src hdr, so // we have to subtract it out here ch->size() -= srh->size(); // we need to manually decr this, since nothing else does. if (!iph->ttl()--) { drop(p.pkt, DROP_RTR_TTL); p.pkt = 0; return; } // now forward the packet... sendOutPacketWithRoute(p, false); }

Here is the call graph for this function:

void DSRAgent::handlePacketReceipt (  SRPacket &  p  )  [private]

Definition at line 683 of file dsragent.cc. References acceptRouteReply(), hdr_sr::access(), hdr_cmn::access(), SRPacket::dest, dsragent_reply_only_to_first_rtreq, hdr_sr::flow_default_unknown(), hdr_sr::flow_unknown(), Packet::free(), ignoreRouteRequestp(), RequestTable::insert(), Address::instance(), IP_HDR_LEN, MAC_id, net_id, SRPacket::pkt, processBrokenRouteError(), processUnknownFlowError(), NsObject::recv(), request_table, returnSrcRouteToRequestor(), hdr_sr::route_error(), hdr_sr::route_reply(), hdr_sr::route_request(), hdr_sr::rtreq_seq(), hdr_sr::size(), hdr_cmn::size(), SRPacket::src, Connector::target_, and hdr_sr::valid(). Referenced by handlePktWithoutSR(), and recv(). { hdr_cmn *cmh = hdr_cmn::access(p.pkt); hdr_sr *srh = hdr_sr::access(p.pkt); if (srh->route_reply()) { // we got a route_reply piggybacked on a route_request // accept the new source route before we do anything else // (we'll send off any packet's we have queued and waiting) acceptRouteReply(p); } if (srh->route_request()) { if (dsragent_reply_only_to_first_rtreq && ignoreRouteRequestp(p)) { //we only respond to the first route request // we receive from a host Packet::free(p.pkt); // drop silently p.pkt = 0; return; } else { // we're going to process this request now, so record the req_num request_table.insert(p.src, p.src, srh->rtreq_seq()); returnSrcRouteToRequestor(p); } } if (srh->route_error()) { // register the dead route processBrokenRouteError(p); } if (srh->flow_unknown()) processUnknownFlowError(p, false); if (srh->flow_default_unknown()) processUnknownFlowError(p, true); /* give the data in the packet to our higher layer (our port dmuxer, most likely) */ //handPktToDmux(p); assert(p.dest == net_id || p.dest == MAC_id); #if 0 if (iph->dport() == 255) { int mask = Address::instance().portmask(); int shift = Address::instance().portshift(); iph->daddr() = ((iph->dport() & mask) << shift) | ((~(mask) << shift) & iph->dst()); } #endif cmh->size() -= srh->size(); // cut off the SR header 4/7/99 -dam srh->valid() = 0; cmh->size() -= IP_HDR_LEN; // cut off IP header size 4/7/99 -dam target_->recv(p.pkt, (Handler*)0); p.pkt = 0; }

Here is the call graph for this function:

void DSRAgent::handlePktWithoutSR (  SRPacket &  p, bool  retry )  [private]

Definition at line 639 of file dsragent.cc. References hdr_sr::access(), MobileNode::base_stn(), SRPacket::dest, diff_subnet(), Path::dump(), ID::dump(), RouteCache::findRoute(), getRouteForPacket(), handlePacketReceipt(), Scheduler::instance(), net_id, node_, SRPacket::pkt, SRPacket::route, route_cache, sendOutPacketWithRoute(), SRPacket::src, trace(), hdr_sr::valid(), and verbose. Referenced by processBrokenRouteError(), processUnknownFlowError(), recv(), sendBufferCheck(), sendUnknownFlow(), and undeliverablePkt(). { hdr_sr *srh = hdr_sr::access(p.pkt); assert(srh->valid()); if (p.dest == net_id) { // it doesn't need a source route, 'cause it's for us handlePacketReceipt(p); return; } // Extensions for wired cum wireless simulation mode //if pkt dst outside my subnet, route to base_stn ID dest; if (diff_subnet(p.dest,net_id)) { dest = ID(node_->base_stn(),::IP); p.dest = dest; } if (route_cache->findRoute(p.dest, p.route, 1)) { // we've got a route... if (verbose) trace("S$hit %.5f _%s_ %s -> %s %s", Scheduler::instance().clock(), net_id.dump(), p.src.dump(), p.dest.dump(), p.route.dump()); sendOutPacketWithRoute(p, true); return; } // end if we have a route else { // we don't have a route... if (verbose) trace("S$miss %.5f _%s_ %s -> %s", Scheduler::instance().clock(), net_id.dump(), net_id.dump(), p.dest.dump()); getRouteForPacket(p, retry); return; } // end of we don't have a route }

Here is the call graph for this function:

void DSRAgent::handleRouteRequest (  SRPacket &  p  )  [private]

Definition at line 944 of file dsragent.cc. References hdr_sr::access(), Path::appendToPath(), SRPacket::dest, dsragent_reply_from_cache_on_propagating, Path::dump(), ID::dump(), Packet::free(), Path::full(), HDR_MAC, Mac::hdr_src(), ifq, ignoreRouteRequestp(), RequestTable::insert(), Scheduler::instance(), Path::length(), mac_, hdr_sr::max_propagation(), net_id, SRPacket::pkt, CMUPriQueue::prq_length(), replyFromRouteCache(), request_table, SRPacket::route, hdr_sr::route_request(), hdr_sr::rtreq_seq(), sendOutPacketWithRoute(), SRPacket::src, trace(), and verbose_srr. Referenced by recv(). { hdr_sr *srh = hdr_sr::access(p.pkt); assert (srh->route_request()); #ifdef notdef { int src = mac_->hdr_src(HDR_MAC(p.pkt)); if(mac_->is_neighbor(src) == 0) { Packet::free(p.pkt); p.pkt = 0; return; } } #endif if (ignoreRouteRequestp(p)) { if (verbose_srr) trace("SRR %.5f _%s_ dropped %s #%d (ignored)", Scheduler::instance().clock(), net_id.dump(), p.src.dump(), srh->rtreq_seq()); Packet::free(p.pkt); // pkt is a route request we've already processed p.pkt = 0; return; // drop silently } // we're going to process this request now, so record the req_num request_table.insert(p.src, p.src, srh->rtreq_seq()); /* - if it's a Ring 0 search, check the rt$ for a reply and use it if possible. There's not much point in doing Ring 0 search if you're not going to check the cache. See the comment about turning off all reply from cache behavior near the definition of d_r_f_c_o_p (if your workload had really good spatial locality, it might still make sense 'cause your target is probably sitting next to you) - if reply from cache is on, check the cache and reply if possible - otherwise, just propagate if possible. */ if ((srh->max_propagation() == 0 || dsragent_reply_from_cache_on_propagating) && replyFromRouteCache(p)) return; // all done #ifdef NEW_REQUEST_LOGIC /* * If we are congested, don't forward or answer the Route Reply */ if(ifq->prq_length() > 10) { trace("SRR %.9f _%s_ discarding %s #%d (ifq length %d)", Scheduler::instance().clock(), net_id.dump(), p.src.dump(), srh->rtreq_seq(), ifq->prq_length()); Packet::free(p.pkt); p.pkt = 0; return; } /* * If "free air time" < 15%, don't forward or answer the Route Reply */ { double atime = mac_->air_time_free(10); if(atime > 0.0 && atime < 0.15) { trace("SRR %.9f _%s_ discarding %s #%d (free air time %f)", Scheduler::instance().clock(), net_id.dump(), p.src.dump(), srh->rtreq_seq(), atime); Packet::free(p.pkt); p.pkt = 0; return; } } #endif /* NEW_REQUEST_LOGIC */ // does the orginator want us to propagate? if (p.route.length() > srh->max_propagation()) { // no propagation if (verbose_srr) trace("SRR %.5f _%s_ dropped %s #%d (prop limit exceeded)", Scheduler::instance().clock(), net_id.dump(), p.src.dump(), srh->rtreq_seq()); Packet::free(p.pkt); // pkt isn't for us, and isn't data carrying p.pkt = 0; return; } // can we propagate? if (p.route.full()) { // no propagation trace("SRR %.5f _%s_ dropped %s #%d (SR full)", Scheduler::instance().clock(), net_id.dump(), p.src.dump(), srh->rtreq_seq()); /* pkt is a rt req, even if data carrying, we don't want to log the drop using drop() since many nodes could be dropping the packet in this fashion */ Packet::free(p.pkt); p.pkt = 0; return; } // add ourselves to the source route p.route.appendToPath(net_id); if (verbose_srr) trace("SRR %.5f _%s_ rebroadcast %s #%d ->%s %s", Scheduler::instance().clock(), net_id.dump(), p.src.dump(), srh->rtreq_seq(), p.dest.dump(), p.route.dump()); sendOutPacketWithRoute(p, false); return; }

Here is the call graph for this function:

void Agent::idle (   )  [protected, virtual, inherited]

Definition at line 363 of file agent.cc. References Agent::app_, and Application::resume(). Referenced by FullTcpAgent::foutput(), TcpAgent::output(), VegasTcpAgent::output(), RFC793eduTcpAgent::output(), QSNewRenoTcpAgent::output(), IntTcpAgent::output(), BayFullTcpAgent::output(), UdpAgent::sendmsg(), SA_Agent::sendmsg(), and RTPAgent::sendmsg(). { if (app_) app_->resume(); }

Here is the call graph for this function:

bool DSRAgent::ignoreRouteRequestp (  SRPacket &  p  )  [private]

Definition at line 1066 of file dsragent.cc. References hdr_sr::access(), Path::full(), RequestTable::get(), MAC_id, Path::member(), net_id, SRPacket::pkt, request_table, SRPacket::route, hdr_sr::rtreq_seq(), and SRPacket::src. Referenced by handlePacketReceipt(), and handleRouteRequest(). { hdr_sr *srh = hdr_sr::access(p.pkt); if (request_table.get(p.src) >= srh->rtreq_seq()) { // we've already processed a copy of this reqest so // we should drop the request silently return true; } if (p.route.member(net_id,MAC_id)) { // we're already on the route, drop silently return true; } if (p.route.full()) { // there won't be room for us to put our address into // the route // so drop silently - sigh, so close, and yet so far... // Note that since we don't record the req_id of this message yet, // we'll process the request if it gets to us on a shorter path return true; } return false; }

Here is the call graph for this function:

void Agent::initpkt (  Packet *   )  const [protected, inherited]

Definition at line 446 of file agent.cc. References hdr_nv::access(), hdr_flags::access(), hdr_ip::access(), hdr_cmn::access(), ns_addr_t::addr_, Scheduler::clock(), hdr_flags::cong_action_, hdr_ip::daddr(), Agent::defttl_, hdr_cmn::direction(), hdr_ip::dport(), Agent::dst_, hdr_flags::ecn_, hdr_flags::ecn_capable_, hdr_flags::ecn_to_echo_, hdr_flags::eln_, hdr_cmn::error(), Agent::fid_, hdr_ip::flowid(), hdr_flags::fs_, NixNode::GetNixVector(), NixNode::GetNodeObject(), hdr_nv::h_used, Agent::here_, hdr_cmn::iface(), Scheduler::instance(), hdr_flags::no_ts_, hdr_cmn::NONE, hdr_nv::nv(), hdr_ip::offset(), hdr_nv::offset(), ns_addr_t::port_, hdr_flags::pri_, hdr_ip::prio(), Agent::prio_, hdr_cmn::ptype(), NixVec::Reset(), hdr_ip::saddr(), hdr_cmn::size(), Agent::size_, hdr_ip::sport(), hdr_cmn::timestamp(), hdr_ip::ttl(), Agent::type_, hdr_cmn::uid(), and Agent::uidcnt_. Referenced by Agent::allocpkt(), and PingResponder::recv(). { hdr_cmn* ch = hdr_cmn::access(p); ch->uid() = uidcnt_++; ch->ptype() = type_; ch->size() = size_; ch->timestamp() = Scheduler::instance().clock(); ch->iface() = UNKN_IFACE.value(); // from packet.h (agent is local) ch->direction() = hdr_cmn::NONE; ch->error() = 0; /* pkt not corrupt to start with */ hdr_ip* iph = hdr_ip::access(p); iph->saddr() = here_.addr_; iph->sport() = here_.port_; iph->daddr() = dst_.addr_; iph->dport() = dst_.port_; //DEBUG //if (dst_ != -1) // printf("pl break\n"); iph->flowid() = fid_; iph->prio() = prio_; iph->ttl() = defttl_; hdr_flags* hf = hdr_flags::access(p); hf->ecn_capable_ = 0; hf->ecn_ = 0; hf->eln_ = 0; hf->ecn_to_echo_ = 0; hf->fs_ = 0; hf->no_ts_ = 0; hf->pri_ = 0; hf->cong_action_ = 0; #ifdef HAVE_STL hdr_nv* nv = hdr_nv::access(p); if (0) printf("Off hdr_nv %d, ip_hdr %d myaddr %ld\n", hdr_nv::offset(), hdr_ip::offset(), here_.addr_); NixNode* pNixNode = NixNode::GetNodeObject(here_.addr_); if (0) printf("Node Object %p\n", pNixNode); if (pNixNode) { // If we get non-null, indicates nixvector routing in use // Delete any left over nv in the packet // Get a nixvector to the target (may create new) NixVec* pNv = pNixNode->GetNixVector(dst_.addr_); pNv->Reset(); nv->nv() = pNv; // And set the nixvec in the packet nv->h_used = 0; // And reset used portion to 0 } #endif //HAVE_STL }

Here is the call graph for this function:

void Agent::insertOldValue (  TracedVar *  v, const char *  value )  [protected, inherited]

Definition at line 250 of file agent.cc. References min, OldValue::next_, Agent::oldValueList_, TRACEVAR_MAXVALUELENGTH, OldValue::val_, and OldValue::var_. Referenced by Agent::trace(). { OldValue *p = new OldValue; assert(p != NULL); strncpy(p->val_, value, min(strlen(value)+1, TRACEVAR_MAXVALUELENGTH)); p->var_ = v; p->next_ = NULL; if (oldValueList_ == NULL) oldValueList_ = p; else { p->next_ = oldValueList_; oldValueList_ = p; } }

int NsObject::isdebug (   )  const [inline, inherited]

Definition at line 61 of file object.h. References NsObject::debug_. { return debug_; }

DSRAgent::LIST_ENTRY (  DSRAgent   )

void Agent::listen (   )  [virtual, inherited]

Reimplemented in BayFullTcpAgent, RapAgent, and FullTcpAgent. Definition at line 381 of file agent.cc. Referenced by Agent::command(). { }

OldValue * Agent::lookupOldValue (  TracedVar *  v  )  [protected, inherited]

Definition at line 242 of file agent.cc. References OldValue::next_, Agent::oldValueList_, and OldValue::var_. Referenced by Agent::trace(). { OldValue *p = oldValueList_; while ((p != NULL) && (p->var_ != v)) p = p->next_; return p; }

void Agent::monitorAgentTrace (   )  [protected, inherited]

Definition at line 310 of file agent.cc. References ns_addr_t::addr_, Agent::channel_, Scheduler::clock(), Agent::here_, Scheduler::instance(), TIME_FORMAT, and Agent::traceName_. Referenced by Agent::command(). { char wrk[256]; int n; double curTime = (&Scheduler::instance() == NULL ? 0 : Scheduler::instance().clock()); sprintf(wrk, "v -t "TIME_FORMAT" -e monitor_agent %d %s", curTime, here_.addr_, traceName_); n = strlen(wrk); wrk[n] = '\n'; wrk[n+1] = 0; if (channel_) (void)Tcl_Write(channel_, wrk, n+1); }

Here is the call graph for this function:

nsaddr_t& Agent::port (   )  [inline, inherited]

Definition at line 97 of file agent.h. References Agent::here_, nsaddr_t, and ns_addr_t::port_. Referenced by LmsAgent::pkt2agent(), TcpAsymSink::recv(), MIPBSAgent::recv(), LmsAgent::recv(), HttpInvalAgent::recv(), CtrMcastEncap::recv(), IntTcpAgent::rxmit_last(), IntTcpAgent::send_one(), LmsReceiver::send_refresh(), IcmpAgent::sendredirect(), TcpAgent::trace_event(), TcpAgent::traceAll(), TcpAsymAgent::traceAll(), TcpAgent::traceVar(), TcpSessionAgent::traceVar(), and TcpAsymAgent::traceVar(). { return here_.port_; }

void DSRAgent::processBrokenRouteError (  SRPacket &  p  )  [private]

Definition at line 1815 of file dsragent.cc. References hdr_ip::access(), hdr_sr::access(), link_down::addr_type, Scheduler::clock(), Packet::copy(), Address::create_ipaddr(), hdr_ip::daddr(), SRPacket::dest, hdr_sr::down_links(), hdr_ip::dport(), ID::dump(), err_from, err_to, hdr_sr::flow_header(), flow_table, hdr_sr::flow_timeout(), link_down::from_addr, ID::getNSAddr_t(), handlePktWithoutSR(), Address::instance(), Scheduler::instance(), MAC_id, net_id, FlowTable::noticeDeadLink(), RouteCache::noticeDeadLink(), NS_AF_INET, hdr_sr::num_route_errors(), SRPacket::pkt, route_cache, hdr_sr::route_error(), route_error_data_time, route_error_held, RT_PORT, hdr_ip::saddr(), hdr_ip::sport(), SRPacket::src, link_down::tell_addr, link_down::to_addr, trace(), hdr_ip::ttl(), verbose, and verbose_srr. Referenced by handlePacketReceipt(), recv(), and tap(). { hdr_sr *srh = hdr_sr::access(p.pkt); if (!srh->route_error()) return; // what happened?? /* if we hear A->B is dead, should we also run the link B->A through the cache as being dead, since 802.11 requires bidirectional links XXX -dam 4/23/98 */ // since CPU time is cheaper than network time, we'll process // all the dead links in the error packet assert(srh->num_route_errors() > 0); for (int c = 0 ; c < srh->num_route_errors() ; c++) { assert(srh->down_links()[c].addr_type == NS_AF_INET); route_cache->noticeDeadLink(ID(srh->down_links()[c].from_addr,::IP), ID(srh->down_links()[c].to_addr,::IP), Scheduler::instance().clock()); flow_table.noticeDeadLink(ID(srh->down_links()[c].from_addr,::IP), ID(srh->down_links()[c].to_addr,::IP)); // I'll assume everything's of type NS_AF_INET for the printout... XXX if (verbose_srr) trace("SRR %.9f _%s_ dead-link tell %d %d -> %d", Scheduler::instance().clock(), net_id.dump(), srh->down_links()[c].tell_addr, srh->down_links()[c].from_addr, srh->down_links()[c].to_addr); } ID who = ID(srh->down_links()[srh->num_route_errors()-1].tell_addr, ::IP); if (who != net_id && who != MAC_id) { // this error packet wasn't meant for us to deal with // since the outer entry doesn't list our name return; } // record this route error data for possible propagation on our next // route request route_error_held = true; err_from = ID(srh->down_links()[srh->num_route_errors()-1].from_addr,::IP); err_to = ID(srh->down_links()[srh->num_route_errors()-1].to_addr,::IP); route_error_data_time = Scheduler::instance().clock(); if (1 == srh->num_route_errors()) { // this error packet has done its job // it's either for us, in which case we've done what it sez // or it's not for us, in which case we still don't have to forward // it to whoever it is for return; } /* make a copy of the packet and send it to the next tell_addr on the error list. the copy is needed in case there is other data in the packet (such as nested route errors) that need to be delivered */ if (verbose) trace("Sdebug %.5f _%s_ unwrapping nested route error", Scheduler::instance().clock(), net_id.dump()); SRPacket p_copy = p; p_copy.pkt = p.pkt->copy(); hdr_sr *new_srh = hdr_sr::access(p_copy.pkt); hdr_ip *new_iph = hdr_ip::access(p_copy.pkt); // remove us from the list of errors new_srh->num_route_errors() -= 1; // send the packet to the person listed in what's now the last entry p_copy.dest = ID(new_srh->down_links()[new_srh->num_route_errors()-1].tell_addr, ::IP); p_copy.src = net_id; //new_iph->daddr() = p_copy.dest.addr; new_iph->daddr() = Address::instance().create_ipaddr(p_copy.dest.getNSAddr_t(),RT_PORT); new_iph->dport() = RT_PORT; //new_iph->saddr() = p_copy.src.addr; new_iph->saddr() = Address::instance().create_ipaddr(p_copy.src.getNSAddr_t(),RT_PORT); new_iph->sport() = RT_PORT; new_iph->ttl() = 255; new_srh->flow_header() = 0; new_srh->flow_timeout() = 0; // an error packet is a first class citizen, so we'll // use handlePktWOSR to obtain a route if needed handlePktWithoutSR(p_copy, false); }

Here is the call graph for this function:

void DSRAgent::processFlowARS (  const Packet *  packet  )  [private]

Definition at line 1914 of file dsragent.cc. References hdr_cmn::access(), hdr_ip::access(), hdr_sr::access(), ars_table, hdr_ip::daddr(), FlowTable::defaultFlow(), FlowTable::find(), hdr_sr::flow_header(), hdr_sr::flow_id(), flow_table, hdr_sr::hopCount(), ARSTable::insert(), hdr_sr::num_addrs(), hdr_ip::saddr(), hdr_ip::ttl(), u_int16_t, and hdr_cmn::uid(). Referenced by tap(). { hdr_sr *srh = hdr_sr::access(packet); hdr_ip *iph = hdr_ip::access(packet); hdr_cmn *cmh = hdr_cmn::access(packet); //hdr_sr *srh = (hdr_sr*) ((Packet *)packet)->access(off_sr_); //hdr_ip *iph = (hdr_ip*) ((Packet *)packet)->access(off_ip_); //hdr_cmn *cmh = (hdr_cmn*)((Packet *)packet)->access(off_cmn_); u_int16_t flowid; int flowidx; int shortamt; assert(!srh->num_addrs()); if (srh->flow_header()) { flowid = srh->flow_id(); // do I know about this flow? if (-1 == (flowidx = flow_table.find(iph->saddr(), iph->daddr(), flowid))) return; shortamt = flow_table[flowidx].hopCount - srh->hopCount(); } else { // do I know which flow is default? if (!flow_table.defaultFlow(iph->saddr(), iph->daddr(), flowid)) return; // do I know about this flow? if (-1 == (flowidx = flow_table.find(iph->saddr(), iph->daddr(), flowid))) return; shortamt = iph->ttl() - flow_table[flowidx].expectedTTL; } // transmitter downstream from us if (shortamt <= 0) return; // this is a _MAJOR_ problem!!! if (flow_table[flowidx].sourceRoute.length() < shortamt) return; ars_table.insert(cmh->uid(), flowid, shortamt); }

Here is the call graph for this function:

void DSRAgent::processUnknownFlowError (  SRPacket &  p, bool  asDefault )  [private]

Definition at line 1749 of file dsragent.cc. References hdr_ip::access(), hdr_sr::access(), ID::addr, Packet::copy(), Address::create_ipaddr(), hdr_ip::daddr(), FlowTable::defaultFlow(), SRPacket::dest, hdr_ip::dport(), ID::dump(), FlowTable::find(), hdr_sr::flow_default_unknown(), hdr_sr::flow_header(), flow_table, hdr_sr::flow_timeout(), hdr_sr::flow_unknown(), ID::getNSAddr_t(), handlePktWithoutSR(), Address::instance(), Scheduler::instance(), IP, net_id, hdr_sr::num_default_unknown(), hdr_sr::num_flow_unknown(), SRPacket::pkt, RT_PORT, hdr_ip::saddr(), hdr_ip::sport(), SRPacket::src, trace(), hdr_ip::ttl(), u_int16_t, hdr_sr::unknown_defaults(), and hdr_sr::unknown_flows(). Referenced by handlePacketReceipt(). { hdr_sr *srh = hdr_sr::access(p.pkt); int flowidx = -1; struct flow_error *fe; u_int16_t flowid; if (asDefault) { assert (srh->flow_default_unknown() && srh->num_default_unknown()); fe = &srh->unknown_defaults()[srh->num_default_unknown()-1]; } else { assert (srh->flow_unknown() && srh->num_flow_unknown()); fe = &srh->unknown_flows()[srh->num_flow_unknown()-1]; if (!flow_table.defaultFlow(fe->flow_src, fe->flow_dst, flowid)) goto skip_proc; } /* not for us; hope it gets the right place... */ if (fe->flow_src != (int) net_id.addr) return; if (-1 != (flowidx = flow_table.find(fe->flow_src, fe->flow_dst, asDefault ? flowid : fe->flow_id))) flow_table[flowidx].count = 0; skip_proc: trace("SFEr %.9f _%s_ from %d re %d : %d [%d]", Scheduler::instance().clock(), net_id.dump(), p.src.addr, fe->flow_dst, asDefault ? -1 : fe->flow_id, flowidx != -1 ? flow_table[flowidx].count : -1); if ((asDefault ? srh->num_default_unknown() : srh->num_flow_unknown()) == 1) return; SRPacket p_copy = p; p_copy.pkt = p.pkt->copy(); hdr_sr *new_srh = hdr_sr::access(p_copy.pkt); hdr_ip *new_iph = hdr_ip::access(p_copy.pkt); // remove us from the list of errors if (asDefault) new_srh->num_default_unknown()--; else new_srh->num_flow_unknown()--; // send the packet to the person listed in what's now the last entry p_copy.dest = ID(fe[-1].flow_src, ::IP); p_copy.src = net_id; //new_iph->daddr() = p_copy.dest.addr; new_iph->daddr() = Address::instance().create_ipaddr(p_copy.dest.getNSAddr_t(),RT_PORT); new_iph->dport() = RT_PORT; //new_iph->saddr() = p_copy.src.addr; new_iph->saddr() = Address::instance().create_ipaddr(p_copy.src.getNSAddr_t(),RT_PORT); new_iph->sport() = RT_PORT; new_iph->ttl() = 255; new_srh->flow_header() = 0; new_srh->flow_timeout() = 0; // an error packet is a first class citizen, so we'll // use handlePktWOSR to obtain a route if needed handlePktWithoutSR(p_copy, false); }

Here is the call graph for this function:

void NsObject::recv (  Packet *  p, const char *  s )  [virtual, inherited]

Reimplemented in CMUTrace. Definition at line 96 of file object.cc. References Packet::free(). { Packet::free(p); }

Here is the call graph for this function:

void DSRAgent::recv (  Packet *  , Handler *  callback = 0 )  [virtual]

Reimplemented from Agent. Definition at line 540 of file dsragent.cc. References hdr_cmn::access(), hdr_ip::access(), hdr_sr::access(), hdr_ip::daddr(), SRPacket::dest, hdr_cmn::direction(), hdr_cmn::DOWN, dsragent_snoop_forwarded_errors, ID::dump(), Packet::free(), handleForwarding(), handlePacketReceipt(), handlePktWithoutSR(), handleRouteRequest(), hdr_sr::init(), Address::instance(), Scheduler::instance(), IP_broadcast, IP_BROADCAST, IP_HDR_LEN, logtarget, net_id, hdr_cmn::next_hop(), SRPacket::pkt, port_dmux_, processBrokenRouteError(), PT_GAF, hdr_cmn::ptype(), NsObject::recv(), hdr_sr::route_error(), hdr_sr::route_request(), hdr_ip::saddr(), Scheduler::schedule(), sendOutBCastPkt(), hdr_cmn::size(), SRPacket::src, Connector::target_, trace(), hdr_cmn::UP, hdr_sr::valid(), and verbose. Referenced by sendOutPacketWithRoute(). { hdr_sr *srh = hdr_sr::access(packet); hdr_ip *iph = hdr_ip::access(packet); hdr_cmn *cmh = hdr_cmn::access(packet); // special process for GAF if (cmh->ptype() == PT_GAF) { if (iph->daddr() == (int)IP_BROADCAST) { if(cmh->direction() == hdr_cmn::UP) cmh->direction() = hdr_cmn::DOWN; Scheduler::instance().schedule(ll,packet,0); return; } else { target_->recv(packet, (Handler*)0); return; } } assert(cmh->size() >= 0); SRPacket p(packet, srh); //p.dest = ID(iph->dst(),::IP); //p.src = ID(iph->src(),::IP); p.dest = ID((Address::instance().get_nodeaddr(iph->daddr())),::IP); p.src = ID((Address::instance().get_nodeaddr(iph->saddr())),::IP); assert(logtarget != 0); if (srh->valid() != 1) { unsigned int dst = cmh->next_hop(); if (dst == IP_BROADCAST) { // extensions for mobileIP --Padma, 04/99. // Brdcast pkt - treat differently if (p.src == net_id) // I have originated this pkt sendOutBCastPkt(packet); else //hand it over to port-dmux port_dmux_->recv(packet, (Handler*)0); } else { // this must be an outgoing packet, it doesn't have a SR header on it srh->init(); // give packet an SR header now cmh->size() += IP_HDR_LEN; // add on IP header size if (verbose) trace("S %.9f _%s_ originating %s -> %s", Scheduler::instance().clock(), net_id.dump(), p.src.dump(), p.dest.dump()); handlePktWithoutSR(p, false); goto done; } } else if (srh->valid() == 1) { if (p.dest == net_id || p.dest == IP_broadcast) { // this packet is intended for us handlePacketReceipt(p); goto done; } // should we check to see if it's an error packet we're handling // and if so call processBrokenRouteError to snoop if (dsragent_snoop_forwarded_errors && srh->route_error()) { processBrokenRouteError(p); } if (srh->route_request()) { // propagate a route_request that's not for us handleRouteRequest(p); } else { // we're not the intended final recpt, but we're a hop handleForwarding(p); } } else { // some invalid pkt has reached here fprintf(stderr,"dsragent: Error-received Invalid pkt!\n"); Packet::free(p.pkt); p.pkt =0; // drop silently } done: assert(p.pkt == 0); p.pkt = 0; return; }

Here is the call graph for this function:

void Agent::recvBytes (  int  bytes  )  [protected, virtual, inherited]

Definition at line 354 of file agent.cc. References Agent::app_, and Application::recv(). Referenced by DelAckSink::recv(), TcpSink::recv(), QSTcpSink::recv(), FullTcpAgent::recv(), and TcpAsymSink::recv(). { if (app_) app_->recv(nbytes); }

Here is the call graph for this function:

void Agent::recvOnly (  Packet *   )  [inline, virtual, inherited]

Reimplemented from NsObject. Definition at line 78 of file agent.h. {};

bool DSRAgent::replyFromRouteCache (  SRPacket &  p  )  [private]

Definition at line 1094 of file dsragent.cc. References hdr_ip::access(), hdr_sr::access(), hdr_cmn::access(), ID::addr, RouteCache::addRoute(), Agent::allocpkt(), Path::appendPath(), Path::appendToPath(), Scheduler::clock(), Address::create_ipaddr(), hdr_ip::daddr(), SRPacket::dest, hdr_sr::down_links(), hdr_ip::dport(), Path::dump(), ID::dump(), RouteCache::findRoute(), Packet::free(), GRAT_ROUTE_ERROR, Path::index(), hdr_sr::init(), Address::instance(), Scheduler::instance(), IP_HDR_LEN, Path::length(), MAC_id, MAX_SR_LEN, Path::member(), net_id, hdr_sr::num_route_errors(), SRPacket::pkt, PT_DSR, hdr_cmn::ptype(), hdr_sr::reply_addrs(), Path::reverseInPlace(), SRPacket::route, route_cache, hdr_sr::route_error(), hdr_sr::route_reply(), hdr_sr::route_reply_len(), hdr_sr::route_request(), RT_PORT, hdr_sr::rtreq_seq(), hdr_ip::saddr(), sendOutPacketWithRoute(), Path::setIterator(), hdr_cmn::size(), hdr_ip::sport(), SRPacket::src, trace(), hdr_ip::ttl(), verbose, and verbose_srr. Referenced by handleRouteRequest(). { Path rest_of_route; Path complete_route = p.route; /* we shouldn't yet be on on the pkt's current source route */ assert(!p.route.member(net_id, MAC_id)); // do we have a cached route the target? /* XXX what if we have more than 1? (and one is legal for reply from cache and one isn't?) 1/28/97 -dam */ if (!route_cache->findRoute(p.dest, rest_of_route, 0)) { // no route => we're done return false; } /* but we should be on on the remainder of the route (and should be at the start of the route */ assert(rest_of_route[0] == net_id || rest_of_route[0] == MAC_id); if (rest_of_route.length() + p.route.length() > MAX_SR_LEN) return false; // too long to work with... // add our suggested completion to the route so far complete_route.appendPath(rest_of_route); // call compressPath to remove any double backs ::compressPath(complete_route); if (!complete_route.member(net_id, MAC_id)) { // we're not on the suggested route, so we can't return it return false; } // if there is any other information piggybacked into the // route request pkt, we need to forward it on to the dst hdr_cmn *cmh = hdr_cmn::access(p.pkt); hdr_sr *srh = hdr_sr::access(p.pkt); int request_seqnum = srh->rtreq_seq(); if (PT_DSR != cmh->ptype() // there's data || srh->route_reply() || (srh->route_error() && srh->down_links()[srh->num_route_errors()-1].tell_addr != GRAT_ROUTE_ERROR)) { // must forward the packet on SRPacket p_copy = p; p.pkt = 0; srh->route_request() = 0; p_copy.route = complete_route; p_copy.route.setIterator(p.route.length()); assert(p.route[p.route.index()] == net_id); if (verbose) trace("Sdebug %.9f _%s_ splitting %s to %s", Scheduler::instance().clock(), net_id.dump(), p.route.dump(), p_copy.route.dump()); sendOutPacketWithRoute(p_copy,false); } else { Packet::free(p.pkt); // free the rcvd rt req before making rt reply p.pkt = 0; } // make up and send out a route reply p.route.appendToPath(net_id); p.route.reverseInPlace(); route_cache->addRoute(p.route, Scheduler::instance().clock(), net_id); p.dest = p.src; p.src = net_id; p.pkt = allocpkt(); hdr_ip *iph = hdr_ip::access(p.pkt); iph->saddr() = Address::instance().create_ipaddr(p.src.addr, RT_PORT); iph->sport() = RT_PORT; iph->daddr() = Address::instance().create_ipaddr(p.dest.addr, RT_PORT); iph->dport() = RT_PORT; iph->ttl() = 255; srh = hdr_sr::access(p.pkt); srh->init(); for (int i = 0 ; i < complete_route.length() ; i++) complete_route[i].fillSRAddr(srh->reply_addrs()[i]); srh->route_reply_len() = complete_route.length(); srh->route_reply() = 1; // propagate the request sequence number in the reply for analysis purposes srh->rtreq_seq() = request_seqnum; hdr_cmn *cmnh = hdr_cmn::access(p.pkt); cmnh->ptype() = PT_DSR; cmnh->size() = IP_HDR_LEN; if (verbose_srr) trace("SRR %.9f _%s_ cache-reply-sent %s -> %s #%d (len %d) %s", Scheduler::instance().clock(), net_id.dump(), p.src.dump(), p.dest.dump(), request_seqnum, complete_route.length(), complete_route.dump()); sendOutPacketWithRoute(p, true); return true; }

Here is the call graph for this function:

void NsObject::reset (   )  [protected, virtual, inherited]

Reimplemented in BayFullTcpAgent, HashClassifier, IvsSource, dsREDQueue, DiffusionRate, SinkAgent, DiffusionAgent, FloodingAgent, OmniMcastAgent, LinkDelay, CBQueue, DropTail, ErrorModel, PIQueue, Queue< T >, RedPDQueue, REDQueue, REMQueue, RIOQueue, Snoop, FackTcpAgent, FullTcpAgent, SackFullTcpAgent, RFC793eduTcpAgent, Sack1TcpAgent, TcpSink, DelAckSink, TcpAgent, VegasTcpAgent, toraAgent, and Queue< T >. Definition at line 70 of file object.cc. Referenced by NsObject::command(). { }

void DSRAgent::returnSrcRouteToRequestor (  SRPacket &  p  )  [private]

Definition at line 1572 of file dsragent.cc. References hdr_cmn::access(), hdr_ip::access(), hdr_sr::access(), RouteCache::addRoute(), Agent::allocpkt(), Path::appendToPath(), Scheduler::clock(), Address::create_ipaddr(), hdr_ip::daddr(), SRPacket::dest, hdr_ip::dport(), Path::dump(), ID::dump(), Path::fillSR(), Path::full(), ID::getNSAddr_t(), hdr_sr::init(), Scheduler::instance(), Address::instance(), IP_HDR_LEN, Path::length(), net_id, SRPacket::pkt, PT_DSR, hdr_cmn::ptype(), hdr_sr::reply_addrs(), Path::resetIterator(), Path::reverseInPlace(), SRPacket::route, route_cache, hdr_sr::route_reply(), hdr_sr::route_reply_len(), RREQ_JITTER, RT_PORT, hdr_sr::rtreq_seq(), hdr_ip::saddr(), Scheduler::schedule(), hdr_sr::size(), hdr_cmn::size(), hdr_ip::sport(), SRPacket::src, trace(), hdr_ip::ttl(), Random::uniform(), and verbose_srr. Referenced by handlePacketReceipt(). { hdr_sr *old_srh = hdr_sr::access(p.pkt); if (p.route.full()) return; // alas, the route would be to long once we add ourselves SRPacket p_copy = p; p_copy.pkt = allocpkt(); p_copy.dest = p.src; p_copy.src = net_id; p_copy.route.appendToPath(net_id); hdr_ip *new_iph = hdr_ip::access(p_copy.pkt); //new_iph->daddr() = p_copy.dest.addr; new_iph->daddr() = Address::instance().create_ipaddr(p_copy.dest.getNSAddr_t(),RT_PORT); new_iph->dport() = RT_PORT; //new_iph->saddr() = p_copy.src.addr; new_iph->saddr() = Address::instance().create_ipaddr(p_copy.src.getNSAddr_t(),RT_PORT); new_iph->sport() = RT_PORT; new_iph->ttl() = 255; hdr_sr *new_srh = hdr_sr::access(p_copy.pkt); new_srh->init(); for (int i = 0 ; i < p_copy.route.length() ; i++) p_copy.route[i].fillSRAddr(new_srh->reply_addrs()[i]); new_srh->route_reply_len() = p_copy.route.length(); new_srh->route_reply() = 1; // propagate the request sequence number in the reply for analysis purposes new_srh->rtreq_seq() = old_srh->rtreq_seq(); hdr_cmn *new_cmnh = hdr_cmn::access(p_copy.pkt); new_cmnh->ptype() = PT_DSR; new_cmnh->size() = IP_HDR_LEN; if (verbose_srr) trace("SRR %.9f _%s_ reply-sent %s -> %s #%d (len %d) %s", Scheduler::instance().clock(), net_id.dump(), p_copy.src.dump(), p_copy.dest.dump(), old_srh->rtreq_seq(), p_copy.route.length(), p_copy.route.dump()); // flip the route around for the return to the requestor, and // cache the route for future use p_copy.route.reverseInPlace(); route_cache->addRoute(p_copy.route, Scheduler::instance().clock(), net_id); p_copy.route.resetIterator(); p_copy.route.fillSR(new_srh); new_cmnh->size() += new_srh->size(); /* we now want to jitter when we first originate route replies, since they are a transmission we make in response to a broadcast packet -dam 4/23/98 sendOutPacketWithRoute(p_copy, true); */ { double d = Random::uniform(RREQ_JITTER); #if 0 fprintf(stderr, "Random Delay: %f\n", d); #endif Scheduler::instance().schedule(this, p_copy.pkt, d); } }

Here is the call graph for this function:

virtual void Agent::send (  int  nbytes  )  [inline, virtual, inherited]

Reimplemented in SRMAgent. Definition at line 89 of file agent.h. References Agent::sendmsg(). { sendmsg(nbytes); }

Here is the call graph for this function:

virtual void Agent::send (  int  sz, AppData *  data )  [inline, virtual, inherited]

Reimplemented in HttpInvalAgent. Definition at line 84 of file agent.h. References Agent::sendmsg(). { sendmsg(sz, data, 0); }

Here is the call graph for this function:

void Agent::send (  Packet *  p, Handler *  h )  [inline, inherited]

Reimplemented from Connector. Definition at line 80 of file agent.h. References NsObject::recv(), and Connector::target_. Referenced by TcpSink::ack(), QSTcpSink::ack(), SinkAgent::bcast_interest(), PingAgent::command(), MessageAgent::command(), mcastControlAgent::command(), LmsAgent::command(), LDPAgent::command(), SinkAgent::data_ready(), DSDV_Agent::forwardPacket(), FullTcpAgent::foutput(), TcpAgent::output(), VegasTcpAgent::output(), RFC793eduTcpAgent::output(), QSNewRenoTcpAgent::output(), IntTcpAgent::output(), BayFullTcpAgent::output(), AbsTcpAgent::output(), AbsDelAckSink::recv(), AbsTcpSink::recv(), SRAgent::recv(), PingAgent::recv(), NatAgent::recv(), MIPBSAgent::recv(), Encapsulator::recv(), Decapsulator::recv(), MIPMHAgent::reg(), HttpInvalAgent::send(), GAFAgent::send_discovery(), RapAgent::SendAck(), SimpleTcpAgent::sendmsg(), PushbackAgent::sendMsg(), FullTcpAgent::sendpacket(), BayFullTcpAgent::sendpacket(), RapAgent::SendPacket(), TfrcAgent::sendpkt(), TfrcSinkAgent::sendpkt(), SinkAgent::sendpkt(), IcmpAgent::sendredirect(), and AbsDelAckSink::timeout(). { target_->recv(p, h); }

Here is the call graph for this function:

void DSRAgent::sendBufferCheck (   )  [private]

Definition at line 244 of file dsragent.cc. References Scheduler::clock(), SRPacket::dest, dropSendBuff(), ID::dump(), handlePktWithoutSR(), Scheduler::instance(), net_id, SendBufEntry::p, SRPacket::pkt, send_buf, SEND_BUF_SIZE, SEND_TIMEOUT, SendBufEntry::t, and trace(). Referenced by SendBufferTimer::expire(). { // this is called about once a second. run everybody through the // get route for pkt routine to see if it's time to do another // route request or what not int c; for (c = 0 ; c <SEND_BUF_SIZE ; c++) { if (send_buf[c].p.pkt == NULL) continue; if (Scheduler::instance().clock() - send_buf[c].t > SEND_TIMEOUT) { dropSendBuff(send_buf[c].p); send_buf[c].p.pkt = 0; continue; } #ifdef DEBUG trace("Sdebug %.5f _%s_ checking for route for dst %s", Scheduler::instance().clock(), net_id.dump(), send_buf[c].p.dest.dump()); #endif handlePktWithoutSR(send_buf[c].p, true); #ifdef DEBUG if (send_buf[c].p.pkt == NULL) trace("Sdebug %.5f _%s_ sendbuf pkt to %s liberated by handlePktWOSR", Scheduler::instance().clock(), net_id.dump(), send_buf[c].p.dest.dump()); #endif } }

Here is the call graph for this function:

void Agent::sendmsg (  int  nbytes, const char *  flags = 0 )  [virtual, inherited]

Reimplemented in SA_Agent, RTPAgent, UdpAgent, LmsSender, SRMAgent, FullTcpAgent, TcpAgent, TfrcAgent, and SimpleTcpAgent. Definition at line 415 of file agent.cc. { }

void Agent::sendmsg (  int  sz, AppData *  , const char *  flags = 0 )  [virtual, inherited]

Reimplemented in UdpAgent. Definition at line 400 of file agent.cc. References abort(). Referenced by Agent::command(), Application::send(), Agent::send(), TrafficTrace::timeout(), TelnetApp::timeout(), EXPOO_Traffic::timeout(), and CBR_PP_Traffic::timeout(). { fprintf(stderr, "Agent::sendmsg(int, AppData*, const char*) not implemented\n"); abort(); }

Here is the call graph for this function:

void DSRAgent::sendOutBCastPkt (  Packet *  p  )

Definition at line 528 of file dsragent.cc. References hdr_cmn::access(), hdr_cmn::direction(), hdr_cmn::DOWN, Scheduler::instance(), Scheduler::schedule(), and hdr_cmn::UP. Referenced by recv(). { hdr_cmn *cmh = hdr_cmn::access(p); if(cmh->direction() == hdr_cmn::UP) cmh->direction() = hdr_cmn::DOWN; // no jitter required Scheduler::instance().schedule(ll, p, 0.0); }

Here is the call graph for this function:

void DSRAgent::sendOutPacketWithRoute (  SRPacket &  p, bool  fresh, Time  delay = 0.0 )  [private]

Definition at line 1204 of file dsragent.cc. References hdr_ip::access(), hdr_cmn::access(), hdr_sr::access(), ID::addr, hdr_cmn::addr_type(), MobileNode::base_stn(), FlowTable::cleanup(), Scheduler::clock(), FlowTable::createEntry(), hdr_sr::cur_addr(), default_flow_timeout, FlowTable::defaultFlow(), SRPacket::dest, diff_subnet(), hdr_cmn::direction(), hdr_cmn::DOWN, DROP_IFQ_QFULL, dsragent_always_reestablish, dsragent_enable_flowstate, dsragent_prefer_default_flow, dsragent_prefer_shorter_over_default, hdr_sr::dump(), Path::dump(), ID::dump(), END_TO_END_COUNT, Path::fillSR(), FlowTable::find(), hdr_sr::flow_header(), hdr_sr::flow_id(), flow_table, hdr_sr::flow_timeout(), hdr_sr::flow_timeout_time(), FlowTable::generateNextFlowId(), hdr_sr::get_next_addr(), hdr_sr::get_next_type(), hdr_sr::hopCount(), ifq, Scheduler::instance(), Path::length(), MAC_BROADCAST, min_adv_interval, p_info::name(), net_id, hdr_cmn::next_hop(), node_, NS_AF_ILINK, hdr_sr::num_addrs(), packet_info, SRPacket::pkt, CMUPriQueue::prq_isfull(), CMUPriQueue::prq_length(), hdr_cmn::ptype(), recv(), Path::resetIterator(), SRPacket::route, hdr_sr::route_error(), hdr_sr::route_reply(), hdr_sr::route_request(), RREQ_JITTER, Scheduler::schedule(), hdr_sr::size(), hdr_cmn::size(), SRPacket::src, trace(), hdr_ip::ttl(), u_int16_t, hdr_cmn::uid(), Random::uniform(), hdr_sr::valid(), verbose, hdr_cmn::xmit_failure_, hdr_cmn::xmit_failure_data_, xmitFailed(), XmitFailureCallback, and XmitFlowFailureCallback. Referenced by acceptRouteReply(), handleForwarding(), handlePktWithoutSR(), handleRouteRequest(), replyFromRouteCache(), sendOutRtReq(), sendRouteShortening(), undeliverablePkt(), and xmitFailed(). { hdr_sr *srh = hdr_sr::access(p.pkt); hdr_cmn *cmnh = hdr_cmn::access(p.pkt); assert(srh->valid()); assert(cmnh->size() > 0); ID dest; if (diff_subnet(p.dest,net_id)) { dest = ID(node_->base_stn(),::IP); p.dest = dest; } if (p.dest == net_id) { // it doesn't need to go on the wire, 'cause it's for us recv(p.pkt, (Handler *) 0); p.pkt = 0; return; } if (fresh) { p.route.resetIterator(); if (verbose && !srh->route_request()) { trace("SO %.9f _%s_ originating %s %s", Scheduler::instance().clock(), net_id.dump(), packet_info.name(cmnh->ptype()), p.route.dump()); } } p.route.fillSR(srh); // set direction of pkt to DOWN , i.e downward cmnh->direction() = hdr_cmn::DOWN; // let's see if we can snag this packet for flow state... ych 5/2/01 if (dsragent_enable_flowstate && p.src == net_id && !srh->route_request() && !srh->cur_addr() && // can't yet decode flow errors and route errors/replies together // so don't tempt the system... ych 5/7/01 !srh->route_error() && !srh->route_reply()) { hdr_ip *iph = hdr_ip::access(p.pkt); int flowidx; u_int16_t flowid, default_flowid; double now = Scheduler::instance().clock(); // hmmm, let's see if we can save us some overhead... if (dsragent_prefer_default_flow && flow_table.defaultFlow(p.src.addr, p.dest.addr, flowid) && -1 != (flowidx = flow_table.find(p.src.addr, p.dest.addr, flowid)) && flow_table[flowidx].timeout >= now && (!dsragent_prefer_shorter_over_default || flow_table[flowidx].sourceRoute.length() <= p.route.length()) && !(p.route == flow_table[flowidx].sourceRoute)) { p.route = flow_table[flowidx].sourceRoute; p.route.fillSR(srh); } flowidx = flow_table.find(p.src.addr, p.dest.addr, p.route); if (flowidx == -1 || flow_table[flowidx].timeout < now) { // I guess we don't know about this flow; allocate it. flow_table.cleanup(); flowid = flow_table.generateNextFlowId(p.dest.addr, true); flowidx = flow_table.createEntry(p.src.addr, p.dest.addr, flowid); assert(flowidx != -1); // fill out the table flow_table[flowidx].count = 1; flow_table[flowidx].lastAdvRt = Scheduler::instance().clock(); flow_table[flowidx].timeout = now + default_flow_timeout; flow_table[flowidx].hopCount = 0; flow_table[flowidx].expectedTTL = iph->ttl(); flow_table[flowidx].allowDefault = true; flow_table[flowidx].sourceRoute = p.route; flow_table[flowidx].nextHop = srh->get_next_addr(); assert(srh->get_next_type() == ::IP); // fix up the srh for the timeout srh->flow_timeout() = 1; srh->flow_timeout_time() = default_flow_timeout; srh->cur_addr() = srh->cur_addr() + 1; } else if (flow_table[flowidx].count <= END_TO_END_COUNT || flow_table[flowidx].lastAdvRt < (Scheduler::instance().clock() - min_adv_interval)) { // I've got it, but maybe someone else doesn't if (flow_table[flowidx].expectedTTL != iph->ttl()) flow_table[flowidx].allowDefault = false; flow_table[flowidx].count++; flow_table[flowidx].lastAdvRt = Scheduler::instance().clock(); srh->flow_timeout() = 1; if (dsragent_always_reestablish) srh->flow_timeout_time() = default_flow_timeout; else srh->flow_timeout_time() = (int)(flow_table[flowidx].timeout - now); srh->cur_addr() = srh->cur_addr() + 1; } else { // flow is established end to end assert (flow_table[flowidx].sourceRoute == p.route); srh->flow_timeout() = srh->cur_addr() = srh->num_addrs() = 0; } if (dsragent_always_reestablish) { // XXX see major problems detailed above (search for dsragent_always_re..) flow_table[flowidx].timeout = now + default_flow_timeout; } cmnh->next_hop() = flow_table[flowidx].nextHop; cmnh->addr_type() = ::IP; if (flow_table.defaultFlow(p.src.addr, p.dest.addr, default_flowid) && flow_table[flowidx].flowId == default_flowid && !srh->num_addrs() && iph->ttl() == flow_table[flowidx].expectedTTL && flow_table[flowidx].allowDefault) { // we can go without anything... woo hoo! assert(!srh->flow_header()); } else { srh->flow_header() = 1; srh->flow_id() = flow_table[flowidx].flowId; srh->hopCount() = 1; } trace("SF%ss %.9f _%s_ %d [%s -> %s] %d(%d) to %d %s", srh->num_addrs() ? "EST" : "", Scheduler::instance().clock(), net_id.dump(), cmnh->uid(), p.src.dump(), p.dest.dump(), flow_table[flowidx].flowId, srh->flow_header(), flow_table[flowidx].nextHop, srh->num_addrs() ? srh->dump() : ""); cmnh->size() += srh->size(); cmnh->xmit_failure_ = srh->num_addrs() ? XmitFailureCallback : XmitFlowFailureCallback; cmnh->xmit_failure_data_ = (void *) this; assert(!srh->num_addrs() || srh->flow_timeout()); } else { // old non-flowstate stuff... assert(p.src != net_id || !srh->flow_header()); cmnh->size() += srh->size(); if (srh->route_request()) { // broadcast forward cmnh->xmit_failure_ = 0; cmnh->next_hop() = MAC_BROADCAST; cmnh->addr_type() = NS_AF_ILINK; } else { // forward according to source route cmnh->xmit_failure_ = XmitFailureCallback; cmnh->xmit_failure_data_ = (void *) this; cmnh->next_hop() = srh->get_next_addr(); cmnh->addr_type() = srh->get_next_type(); srh->cur_addr() = srh->cur_addr() + 1; } /* route_request() */ } /* can snag for path state */ /* put route errors at the head of the ifq somehow? -dam 4/13/98 */ // make sure we aren't cycling packets #ifdef notdef if (ifq->prq_length() > 25) trace("SIFQ %.5f _%s_ len %d", Scheduler::instance().clock(), net_id.dump(), ifq->prq_length()); #endif #ifdef NEW_IFQ_LOGIC /* * If the interface queue is full, there's no sense in sending * the packet. Drop it and generate a Route Error? */ /* question for the author: this seems rife with congestion/infinite loop * possibilities. you're responding to an ifq full by sending a rt err. * sounds like the source quench problem. ych 5/5/01 */ if(ifq->prq_isfull(p.pkt)) { xmitFailed(p.pkt, DROP_IFQ_QFULL); p.pkt = 0; return; } #endif /* NEW_IFQ_LOGIC */ // ych debugging assert(!srh->flow_header() || !srh->num_addrs() || srh->flow_timeout()); // off it goes! if (srh->route_request()) { // route requests need to be jittered a bit Scheduler::instance().schedule(ll, p.pkt, Random::uniform(RREQ_JITTER) + delay); } else { // no jitter required Scheduler::instance().schedule(ll, p.pkt, delay); } p.pkt = NULL; /* packet sent off */ }

Here is the call graph for this function:

void DSRAgent::sendOutRtReq (  SRPacket &  p, int  max_prop = MAX_SR_LEN )  [private]

Definition at line 1533 of file dsragent.cc. References hdr_sr::access(), link_down::addr_type, Path::appendToPath(), Scheduler::clock(), SRPacket::dest, hdr_sr::down_links(), dsragent_propagate_last_error, ID::dump(), err_from, err_to, link_down::from_addr, ID::getNSAddr_t(), GRAT_ROUTE_ERROR, Scheduler::instance(), max_err_hold, hdr_sr::max_propagation(), MAX_ROUTE_ERRORS, net_id, NS_AF_INET, hdr_sr::num_route_errors(), SRPacket::pkt, Path::reset(), SRPacket::route, hdr_sr::route_error(), route_error_data_time, route_error_held, hdr_sr::route_request(), route_request_num, hdr_sr::rtreq_seq(), sendOutPacketWithRoute(), SRPacket::src, link_down::tell_addr, link_down::to_addr, trace(), hdr_sr::valid(), and verbose_srr. Referenced by getRouteForPacket(). { hdr_sr *srh = hdr_sr::access(p.pkt); assert(srh->valid()); srh->route_request() = 1; srh->rtreq_seq() = route_request_num++; srh->max_propagation() = max_prop; p.route.reset(); p.route.appendToPath(net_id); if (dsragent_propagate_last_error && route_error_held && Scheduler::instance().clock() - route_error_data_time < max_err_hold) { assert(srh->num_route_errors() < MAX_ROUTE_ERRORS); srh->route_error() = 1; link_down *deadlink = &(srh->down_links()[srh->num_route_errors()]); deadlink->addr_type = NS_AF_INET; deadlink->from_addr = err_from.getNSAddr_t(); deadlink->to_addr = err_to.getNSAddr_t(); deadlink->tell_addr = GRAT_ROUTE_ERROR; srh->num_route_errors() += 1; /* * Make sure that the Route Error gets on a propagating request. */ if(max_prop > 0) route_error_held = false; } if (verbose_srr) trace("SRR %.5f _%s_ new-request %d %s #%d -> %s", Scheduler::instance().clock(), net_id.dump(), max_prop, p.src.dump(), srh->rtreq_seq(), p.dest.dump()); sendOutPacketWithRoute(p, false); }

Here is the call graph for this function:

void DSRAgent::sendRouteShortening (  SRPacket &  p, int  heard_at, int  xmit_at )  [private]

Definition at line 2116 of file dsragent.cc. References hdr_cmn::access(), hdr_sr::access(), hdr_ip::access(), RouteCache::addRoute(), Agent::allocpkt(), Scheduler::clock(), Address::create_ipaddr(), hdr_ip::daddr(), SRPacket::dest, hdr_ip::dport(), dsragent_send_grat_replies, Path::dump(), ID::dump(), FindGratHoldDown(), ID::getNSAddr_t(), grat_hold, grat_hold_down_time, grat_hold_victim, Path::index(), hdr_sr::init(), Address::instance(), Scheduler::instance(), IP_HDR_LEN, Path::length(), net_id, SRPacket::pkt, PT_DSR, hdr_cmn::ptype(), Path::removeSection(), hdr_sr::reply_addrs(), Path::reverseInPlace(), SRPacket::route, route_cache, hdr_sr::route_reply(), hdr_sr::route_reply_len(), RT_PORT, RTREP_HOLDOFF_SIZE, hdr_sr::rtreq_seq(), hdr_ip::saddr(), sendOutPacketWithRoute(), hdr_cmn::size(), hdr_ip::sport(), SRPacket::src, GratReplyHoldDown::t, trace(), hdr_ip::ttl(), verbose, and verbose_srr. Referenced by handleFlowForwarding(), and tap(). { // this shares code with returnSrcRouteToRequestor - factor them -dam */ if (!dsragent_send_grat_replies) return; if (verbose) trace("Sdebug %s consider grat arp for %s", net_id.dump(), p.route.dump()); GratReplyHoldDown *g = FindGratHoldDown(grat_hold, RTREP_HOLDOFF_SIZE, p.route); if (!g) { grat_hold[grat_hold_victim].p = p.route; grat_hold_victim = (grat_hold_victim + 1) % RTREP_HOLDOFF_SIZE; g = &grat_hold[grat_hold_victim]; } else if (Scheduler::instance().clock() - g->t < grat_hold_down_time) return; g->t = Scheduler::instance().clock(); SRPacket p_copy = p; p_copy.pkt = allocpkt(); p_copy.dest = p.route[0]; // tell the originator of this long source route p_copy.src = net_id; // reverse the route to get the packet back p_copy.route[p_copy.route.index()] = net_id; p_copy.route.reverseInPlace(); p_copy.route.removeSection(0,p_copy.route.index()); hdr_ip *new_iph = hdr_ip::access(p_copy.pkt); //new_iph->daddr() = p_copy.dest.addr; new_iph->daddr() = Address::instance().create_ipaddr(p_copy.dest.getNSAddr_t(),RT_PORT); new_iph->dport() = RT_PORT; //new_iph->saddr() = p_copy.src.addr; new_iph->saddr() = Address::instance().create_ipaddr(p_copy.src.getNSAddr_t(),RT_PORT); new_iph->sport() = RT_PORT; new_iph->ttl() = 255; // shorten's p's route p.route.removeSection(heard_at, xmit_at); hdr_sr *new_srh = hdr_sr::access(p_copy.pkt); new_srh->init(); for (int i = 0 ; i < p.route.length() ; i++) p.route[i].fillSRAddr(new_srh->reply_addrs()[i]); new_srh->route_reply_len() = p.route.length(); new_srh->route_reply() = 1; // grat replies will have a 0 seq num (it's only for trace analysis anyway) new_srh->rtreq_seq() = 0; hdr_cmn *new_cmnh = hdr_cmn::access(p_copy.pkt); new_cmnh->ptype() = PT_DSR; new_cmnh->size() += IP_HDR_LEN; if (verbose_srr) trace("SRR %.9f _%s_ gratuitous-reply-sent %s -> %s (len %d) %s", Scheduler::instance().clock(), net_id.dump(), p_copy.src.dump(), p_copy.dest.dump(), p.route.length(), p.route.dump()); // cache the route for future use (we learned the route from p) route_cache->addRoute(p_copy.route, Scheduler::instance().clock(), p.src); sendOutPacketWithRoute(p_copy, true); }

Here is the call graph for this function:

virtual void Agent::sendto (  int  nbytes, const char *  flags, nsaddr_t  dst )  [virtual, inherited]

void Agent::sendto (  int  sz, AppData *  , const char *  flags, nsaddr_t  dst )  [virtual, inherited]

Definition at line 407 of file agent.cc. References abort(). Referenced by Agent::command(). { fprintf(stderr, "Agent::sendmsg(int, AppData*, const char*) not implemented\n"); abort(); }

Here is the call graph for this function:

void DSRAgent::sendUnknownFlow (  SRPacket &  p, bool  asDefault, u_int16_t  flowid = 0 )  [private]

Definition at line 2404 of file dsragent.cc. References hdr_cmn::access(), hdr_ip::access(), hdr_sr::access(), ID::addr, Address::create_ipaddr(), hdr_ip::daddr(), SRPacket::dest, hdr_ip::dport(), ID::dump(), hdr_sr::flow_default_unknown(), hdr_sr::flow_header(), hdr_sr::flow_timeout(), hdr_sr::flow_unknown(), Packet::free(), ID::getNSAddr_t(), handlePktWithoutSR(), Address::instance(), Scheduler::instance(), IP_HDR_LEN, MAX_ROUTE_ERRORS, net_id, hdr_sr::num_addrs(), hdr_sr::num_default_unknown(), hdr_sr::num_flow_unknown(), hdr_cmn::num_forwards(), SRPacket::pkt, PT_DSR, hdr_cmn::ptype(), hdr_sr::route_reply(), hdr_sr::route_request(), RT_PORT, hdr_ip::saddr(), hdr_cmn::size(), hdr_ip::sport(), SRPacket::src, trace(), hdr_ip::ttl(), hdr_cmn::uid(), Agent::uidcnt_, undeliverablePkt(), hdr_sr::unknown_defaults(), and hdr_sr::unknown_flows(). Referenced by handleDefaultForwarding(), handleFlowForwarding(), and xmitFlowFailed(). { hdr_sr *srh = hdr_sr::access(p.pkt); hdr_ip *iph = hdr_ip::access(p.pkt); hdr_cmn *cmh = hdr_cmn::access(p.pkt); struct flow_error *fe; assert(!srh->num_addrs()); // flow forwarding basis only. #if 0 // this doesn't always hold true; if an xmit fails, we'll dump the // thing from our flow table, possibly before we even get here (though how // we found out, other than from this packet, is anyone's guess, considering // that underliverablePkt() should have been called in any other circumstance, // so we shouldn't go through the failed stuff. assert(p.src != net_id); // how'd it get here if it were? // this doesn't always hold true; I may be sending it default, fail, // the flow times out, but I still know the flowid (whacked paths through // the code, I know... ych 5/7/01 assert(srh->flow_header() ^ asDefault); // one or the other, not both #endif if (p.src == net_id) { Packet::free(p.pkt); p.pkt = 0; return; // gimme a break, we already know! } undeliverablePkt(p.pkt, false); // salvage, but don't molest. /* warp into an error... */ if (asDefault) { if (!srh->flow_default_unknown()) { srh->num_default_unknown() = 1; srh->flow_default_unknown() = 1; fe = srh->unknown_defaults(); } else if (srh->num_default_unknown() < MAX_ROUTE_ERRORS) { fe = srh->unknown_defaults() + srh->num_default_unknown(); srh->num_default_unknown()++; } else { trace("SYFU %.5f _%s_ dumping maximally nested Flow error %d -> %d", Scheduler::instance().clock(), net_id.dump(), p.src.addr, p.dest.addr); Packet::free(p.pkt); // no drop needed p.pkt = 0; return; } } else { if (!srh->flow_unknown()) { srh->num_flow_unknown() = 1; srh->flow_unknown() = 1; fe = srh->unknown_flows(); } else if (srh->num_default_unknown() < MAX_ROUTE_ERRORS) { fe = srh->unknown_flows() + srh->num_flow_unknown(); srh->num_flow_unknown()++; } else { trace("SYFU %.5f _%s_ dumping maximally nested Flow error %d -> %d", Scheduler::instance().clock(), net_id.dump(), p.src.addr, p.dest.addr); Packet::free(p.pkt); // no drop needed p.pkt = 0; return; } } trace("SFErr %.5f _%s_ %d -> %d : %d", Scheduler::instance().clock(), net_id.dump(), p.src.addr, p.dest.addr, flowid); srh->route_reply() = 0; srh->route_request() = 0; srh->flow_header() = 0; srh->flow_timeout() = 0; //iph->daddr() = p.src.addr; iph->daddr() = Address::instance().create_ipaddr(p.src.getNSAddr_t(),RT_PORT); iph->dport() = RT_PORT; //iph->saddr() = net_id.addr; iph->saddr() = Address::instance().create_ipaddr(net_id.getNSAddr_t(),RT_PORT); iph->sport() = RT_PORT; iph->ttl() = 255; //fe->flow_src = p.src.addr; fe->flow_src = p.src.getNSAddr_t(); //fe->flow_dst = p.dest.addr; fe->flow_dst = p.dest.getNSAddr_t(); fe->flow_id = flowid; //p.src = ID(iph->src(), ::IP); //p.dest = ID(iph->dst(), ::IP); p.dest = ID((Address::instance().get_nodeaddr(iph->daddr())),::IP); p.src = ID((Address::instance().get_nodeaddr(iph->saddr())),::IP); cmh->ptype() = PT_DSR; // cut off data cmh->size() = IP_HDR_LEN; cmh->num_forwards() = 0; // assign this packet a new uid, since we're sending it cmh->uid() = uidcnt_++; handlePktWithoutSR(p, false); assert(p.pkt == 0); }

Here is the call graph for this function:

void Agent::set_pkttype (  packet_t  pkttype  )  [inline, inherited]

Definition at line 100 of file agent.h. References Agent::type_. Referenced by Agent::command(), HttpUInvalClass::create(), RA_Traffic::init(), POO_Traffic::init(), EXPOO_Traffic::init(), CBR_Traffic::init(), and CBR_PP_Traffic::init(). { type_ = pkttype; }

virtual int& Agent::size (   )  [inline, virtual, inherited]

Reimplemented in FullTcpAgent. Definition at line 95 of file agent.h. References Agent::size_. Referenced by rtProtoDV::command(), RLM_Sender::command(), imepAgent::getResponseListSize(), LandmarkAgent::makeUpdate(), Agent::recv(), SSMSRMAgent::send_glb_sess(), SSMSRMAgent::send_loc_sess(), SSMSRMAgent::send_rep_sess(), SRMAgent::send_sess(), and TelnetApp::timeout(). { return size_; }

void DSRAgent::stickPacketInSendBuffer (  SRPacket &  p  )  [private]

Definition at line 213 of file dsragent.cc. References Scheduler::clock(), SRPacket::dest, dropSendBuff(), ID::dump(), Scheduler::instance(), min, net_id, SendBufEntry::p, SRPacket::pkt, send_buf, SEND_BUF_SIZE, SRPacket::src, SendBufEntry::t, Time, trace(), and verbose. Referenced by getRouteForPacket(), and undeliverablePkt(). { Time min = DBL_MAX; int min_index = 0; int c; if (verbose) trace("Sdebug %.5f _%s_ stuck into send buff %s -> %s", Scheduler::instance().clock(), net_id.dump(), p.src.dump(), p.dest.dump()); for (c = 0 ; c < SEND_BUF_SIZE ; c ++) if (send_buf[c].p.pkt == NULL) { send_buf[c].t = Scheduler::instance().clock(); send_buf[c].p = p; return; } else if (send_buf[c].t < min) { min = send_buf[c].t; min_index = c; } // kill somebody dropSendBuff(send_buf[min_index].p); send_buf[min_index].t = Scheduler::instance().clock(); send_buf[min_index].p = p; }

Here is the call graph for this function:

void DSRAgent::tap (  const Packet *  p  )  [virtual]

Implements Tap. Definition at line 1960 of file dsragent.cc. References hdr_cmn::access(), hdr_ip::access(), hdr_sr::access(), hdr_sr::addrs(), Scheduler::clock(), hdr_sr::cur_addr(), hdr_ip::daddr(), SRPacket::dest, dsr_tap, dsr_tap_skip, dsragent_snoop_source_routes, dsragent_use_tap, Path::dump(), ID::dump(), Path::index(), Scheduler::instance(), Address::instance(), Path::length(), MAC_id, net_id, RouteCache::noticeRouteUsed(), hdr_sr::num_addrs(), processBrokenRouteError(), processFlowARS(), PT_DSR, hdr_cmn::ptype(), hdr_sr::reply_addrs(), SRPacket::route, route_cache, hdr_sr::route_error(), hdr_sr::route_reply(), hdr_sr::route_reply_len(), hdr_sr::route_request(), hdr_ip::saddr(), sendRouteShortening(), SRPacket::src, TAP_BITMASK, tap_uid_cache, trace(), hdr_cmn::uid(), hdr_sr::valid(), and verbose. { hdr_sr *srh = hdr_sr::access(packet); hdr_ip *iph = hdr_ip::access(packet); hdr_cmn *cmh = hdr_cmn::access(packet); if (!dsragent_use_tap) return; if (!srh->valid()) return; // can't do anything with it if (!srh->num_addrs()) { processFlowARS(packet); return; } // don't trouble me with packets I'm about to receive anyway /* this change added 5/13/98 -dam */ ID next_hop(srh->addrs()[srh->cur_addr()]); if (next_hop == net_id || next_hop == MAC_id) return; SRPacket p((Packet *) packet, srh); //p.dest = ID(iph->dst(),::IP); //p.src = ID(iph->src(),::IP); p.dest = ID((Address::instance().get_nodeaddr(iph->daddr())),::IP); p.src = ID((Address::instance().get_nodeaddr(iph->saddr())),::IP); // don't trouble me with my own packets if (p.src == net_id) return; #ifdef DSR_FILTER_TAP /* * Don't process packets more than once. In real implementations * this can be done with the (IP Source, IP ID) pair, but it is * simpler to implement it with the global "uid" in simulation. */ { int uid = cmh->uid(); if(tap_uid_cache[(uid & TAP_BITMASK)] == uid) { dsr_tap_skip++; return; } dsr_tap++; tap_uid_cache[(uid & TAP_BITMASK)] = uid; } #endif /* snoop on the SR data */ if (srh->route_error()) { if (verbose) trace("Sdebug _%s_ tap saw error %d", net_id.dump(), cmh->uid()); processBrokenRouteError(p); } if (srh->route_reply()) { Path reply_path(srh->reply_addrs(), srh->route_reply_len()); if(verbose) trace("Sdebug _%s_ tap saw route reply %d %s", net_id.dump(), cmh->uid(), reply_path.dump()); route_cache->noticeRouteUsed(reply_path, Scheduler::instance().clock(), p.src); } /* we can't decide whether we should snoop on the src routes in route requests. We've seen cases where we hear a route req from a node, but can't complete an arp with that node (and so can't actually deliver packets through it if called on to do so) -dam 4/16/98 */ if (srh->route_request()) return; // don't path shorten route requests // the logic is wrong for shortening rtreq's anyway, cur_addr always = 0 if (dsragent_snoop_source_routes) { if (verbose) trace("Sdebug _%s_ tap saw route use %d %s", net_id.dump(), cmh->uid(), p.route.dump()); route_cache->noticeRouteUsed(p.route, Scheduler::instance().clock(), net_id); } if (PT_DSR == cmh->ptype()) return; // no route shortening on any // DSR packet /* I think we ended up sending grat route replies for source routes on route replies for route requests that were answered by someone else's cache, resulting in the wrong node receiving the route. For now, I outlaw it. The root of the problem is that when we salvage a pkt from a failed link using a route from our cache, we break what had been an invariant that the IP src of a packet was also the first machine listed on the source route. Here's the route of the problem that results in the simulator crashing at 8.56135 when 44 recieves a route reply that has 24 listed as the first node in the route. SSendFailure 8.52432 24 [10 |24 46 45 1 40 ] S$hit 8.52432 salvaging 10 -> 40 with [(24) 44 50 9 40 ] S$hit 8.52432 salvaging 44 -> 40 with [(24) 44 50 9 40 ] D 8.52432 [20 42 2e 18 800] 24 DSR 156 -- 10->40 6 [0] [1 9 39] [0 0 0->0] s 8.52438 [1b 45e 2c 18 0] 24 MAC 20 r 8.52446 [1b 45e 2c 18 0] 44 MAC 20 s 8.52454 [101b 27e 23 1b 0] 27 MAC 20 s 8.52564 [101b 27e 23 1b 0] 27 MAC 20 s 8.52580 [101b 45e 2c 18 0] 24 MAC 20 r 8.52588 [101b 45e 2c 18 0] 44 MAC 20 s 8.52589 [1c 41c 18 0 0] 44 MAC 14 r 8.52595 [1c 41c 18 0 0] 24 MAC 14 s 8.52600 [20 42 2c 18 800] 24 DSR 244 -- 10->40 5 [0] [1 9 39] [0 0 24->46] r 8.52698 [20 42 2c 18 800] 44 DSR 216 -- 10->40 5 [0] [1 9 39] [0 0 24->46] s 8.53947 [20 42 2c 18 800] 24 DSR 204 -- 44->40 5 [0] [1 8 39] [0 0 0->0] r 8.54029 [20 42 2c 18 800] 44 DSR 176 -- 44->40 5 [0] [1 8 39] [0 0 0->0] Sdebug 50 consider grat arp for [24 (44) 50 9 40 ] SRR 8.54029 50 gratuitous-reply-sent 50 -> 44 [24 (50) 9 40 ] SF 8.54029 44 [44 -> 40] via 0x3200 [24 |44 50 9 40 ] s 8.54030 [1d 0 18 0 0] 44 MAC 14 r 8.54036 [1d 0 18 0 0] 24 MAC 14 s 8.54044 [101b 54f 32 2c 0] 44 MAC 20 r 8.54053 [101b 54f 32 2c 0] 50 MAC 20 s 8.54054 [1c 50d 2c 0 0] 50 MAC 14 r 8.54059 [1c 50d 2c 0 0] 44 MAC 14 s 8.54064 [20 42 32 2c 800] 44 DSR 304 -- 10->40 5 [0] [1 9 39] [0 0 24->46] r 8.54186 [20 42 32 2c 800] 50 DSR 276 -- 10->40 5 [0] [1 9 39] [0 0 24->46] SF 8.54186 50 [10 -> 40] via 0x900 [24 44 |50 9 40 ] s 8.56101 [20 42 2c 18 800] 24 DSR 84 -- 50->44 2 [0] [1 4 40] [0 0 0->0] r 8.56135 [20 42 2c 18 800] 44 DSR 56 -- 50->44 2 [0] [1 4 40] [0 0 0->0] */ /* check to see if we can shorten the route being used */ if (p.route[p.route.index()] != net_id && p.route[p.route.index()] != MAC_id) { // it's not immeadiately to us for (int i = p.route.index() + 1; i < p.route.length(); i++) if (p.route[i] == net_id || p.route[i] == MAC_id) { // but it'll get here eventually... sendRouteShortening(p, p.route.index(), i); } } }

Here is the call graph for this function:

NsObject* Connector::target (   )  [inline, inherited]

Definition at line 48 of file connector.h. References Connector::target_. Referenced by JoBS::assignRateDropsADC(), FQ::deque(), QSAgent::recv(), and MIPMHAgent::reg(). { return target_; }

void DSRAgent::Terminate (  void   )

Definition at line 359 of file dsragent.cc. References Connector::drop(), DROP_END_OF_SIMULATION, SendBufEntry::p, SRPacket::pkt, send_buf, and SEND_BUF_SIZE. Referenced by command(). { int c; for (c = 0 ; c < SEND_BUF_SIZE ; c++) { if (send_buf[c].p.pkt) { drop(send_buf[c].p.pkt, DROP_END_OF_SIMULATION); send_buf[c].p.pkt = 0; } } }

Here is the call graph for this function:

void DSRAgent::testinit (   )  [private]

Definition at line 371 of file dsragent.cc. References RouteCache::addRoute(), hdr_sr::addrs(), hdr_sr::append_addr(), hdr_sr::init(), IP, net_id, NS_AF_INET, hdr_sr::num_addrs(), and route_cache. Referenced by command(). { struct hdr_sr hsr; if (net_id == ID(1,::IP)) { printf("adding route to 1\n"); hsr.init(); hsr.append_addr( 1, NS_AF_INET ); hsr.append_addr( 2, NS_AF_INET ); hsr.append_addr( 3, NS_AF_INET ); hsr.append_addr( 4, NS_AF_INET ); route_cache->addRoute(Path(hsr.addrs(), hsr.num_addrs()), 0.0, ID(1,::IP)); } if (net_id == ID(3,::IP)) { printf("adding route to 3\n"); hsr.init(); hsr.append_addr( 3, NS_AF_INET ); hsr.append_addr( 2, NS_AF_INET ); hsr.append_addr( 1, NS_AF_INET ); route_cache->addRoute(Path(hsr.addrs(), hsr.num_addrs()), 0.0, ID(3,::IP)); } }

Here is the call graph for this function:

void Agent::timeout (  int  tno  )  [virtual, inherited]

Reimplemented in SA_Agent, RTPAgent, FtpClientAgent, BayFullTcpAgent, SinkAgent, RLM_Sender, MIPBSAgent, MIPMHAgent, RapAgent, RTCPAgent, TcpAsymSink, FackTcpAgent, FullTcpAgent, QSNewRenoTcpAgent, RBPVegasTcpAgent, RBPRenoTcpAgent, SackRHTcpAgent, Sack1TcpAgent, TcpSessionAgent, DelAckSink, TcpAgent, RenoTcpAgent, VegasTcpAgent, and SimpleTcpAgent. Definition at line 347 of file agent.cc. Referenced by SimpleTimer::expire(). { }

void Agent::trace (  TracedVar *  v  )  [protected, virtual, inherited]

Reimplemented in TcpAgent. Definition at line 266 of file agent.cc. References ns_addr_t::addr_, Agent::channel_, Agent::dst_, Agent::here_, Agent::insertOldValue(), Scheduler::instance(), Agent::lookupOldValue(), min, TIME_FORMAT, Agent::traceName_, TRACEVAR_MAXVALUELENGTH, and OldValue::val_. Referenced by TcpAgent::trace(). { if (channel_ == 0) return; char wrk[256], value[128]; int n; // XXX we need to keep track of old values. What's the best way? v->value(value, 128); // XXX hack: how do I know ns has not started yet? // if there's nothing in value, return static int started = 0; if (!started) { Tcl::instance().evalc("[Simulator instance] is-started"); if (Tcl::instance().result()[0] == '0') // Simulator not started, do nothing return; // remember for next time (so we don't always have to call to tcl) started = 1; }; OldValue *ov = lookupOldValue(v); if (ov != NULL) { sprintf(wrk, "f -t "TIME_FORMAT" -s %d -d %d -n %s -a %s -v %s -o %s -T v", Scheduler::instance().clock(), here_.addr_, dst_.addr_, v->name(), traceName_, value, ov->val_); strncpy(ov->val_, value, min(strlen(value)+1, TRACEVAR_MAXVALUELENGTH)); } else { // if there is value, insert it into old value list sprintf(wrk, "f -t "TIME_FORMAT" -s %d -d %d -n %s -a %s -v %s -T v", Scheduler::instance().clock(), here_.addr_, dst_.addr_, v->name(), traceName_, value); insertOldValue(v, value); } n = strlen(wrk); wrk[n] = '\n'; wrk[n+1] = 0; (void)Tcl_Write(channel_, wrk, n+1); }

Here is the call graph for this function:

void DSRAgent::trace (  char *  fmt, ...  )  [private]

Definition at line 2188 of file dsragent.cc. References BaseTrace::buffer(), BaseTrace::dump(), logtarget, and Trace::pt_. Referenced by acceptRouteReply(), command(), dropSendBuff(), getRouteForPacket(), handleFlowForwarding(), handleForwarding(), handlePktWithoutSR(), handleRouteRequest(), processBrokenRouteError(), processUnknownFlowError(), recv(), replyFromRouteCache(), returnSrcRouteToRequestor(), sendBufferCheck(), sendOutPacketWithRoute(), sendOutRtReq(), sendRouteShortening(), sendUnknownFlow(), stickPacketInSendBuffer(), tap(), undeliverablePkt(), and xmitFailed(). { va_list ap; if (!logtarget) return; va_start(ap, fmt); vsprintf(logtarget->pt_->buffer(), fmt, ap); logtarget->pt_->dump(); va_end(ap); }

Here is the call graph for this function:

virtual void Agent::trace_event (  char *  eventtype  )  [inline, protected, virtual, inherited]

Reimplemented in TcpAgent. Definition at line 146 of file agent.h. {}

void DSRAgent::undeliverablePkt (  Packet *  p, int  mine )  [private]

Definition at line 2228 of file dsragent.cc. References hdr_cmn::access(), hdr_ip::access(), hdr_sr::access(), hdr_sr::addrs(), Path::appendPath(), Packet::copy(), hdr_sr::cur_addr(), hdr_ip::daddr(), SRPacket::dest, Connector::drop(), DROP_RTR_MAC_CALLBACK, DROP_RTR_NO_ROUTE, DROP_RTR_SALVAGE, dsr_salvage_max_attempts, dsr_salvage_max_requests, dsragent_dont_salvage_bad_replies, dsragent_require_bi_routes, dsragent_salvage_with_cache, Path::dump(), ID::dump(), RouteCache::findRoute(), hdr_sr::flow_header(), hdr_sr::flow_timeout(), handlePktWithoutSR(), ID_Type, Path::index(), Scheduler::instance(), Address::instance(), net_id, SRPacket::pkt, PT_DSR, hdr_cmn::ptype(), hdr_sr::reply_addrs(), Path::resetIterator(), SRPacket::route, route_cache, hdr_sr::route_error(), hdr_sr::route_reply(), hdr_sr::route_reply_len(), hdr_sr::route_request(), hdr_ip::saddr(), hdr_sr::salvaged(), sendOutPacketWithRoute(), Path::setIterator(), Path::setLength(), hdr_sr::size(), hdr_cmn::size(), SRPacket::src, stickPacketInSendBuffer(), trace(), hdr_cmn::uid(), verbose_srr, and verbose_ssalv. Referenced by sendUnknownFlow(), and xmitFailed(). { hdr_sr *srh = hdr_sr::access(pkt); hdr_ip *iph = hdr_ip::access(pkt); hdr_cmn *cmh; SRPacket p(pkt,srh); //p.dest = ID(iph->dst(),::IP); //p.src = ID(iph->src(),::IP); p.dest = ID((Address::instance().get_nodeaddr(iph->daddr())),::IP); p.src = ID((Address::instance().get_nodeaddr(iph->saddr())),::IP); p.pkt = mine ? pkt : pkt->copy(); srh = hdr_sr::access(p.pkt); iph = hdr_ip::access(p.pkt); cmh = hdr_cmn::access(p.pkt); // we're about to salvage. flowstate rules say we must strip all flow // state info out of this packet. ych 5/5/01 cmh->size() -= srh->size(); // changes affect size of header... srh->flow_timeout() = 0; srh->flow_header() = 0; cmh->size() += srh->size(); // done fixing flow state headers if (ID((Address::instance().get_nodeaddr(iph->saddr())),::IP) == net_id) { // it's our packet we couldn't send cmh->size() -= srh->size(); // remove size of SR header assert(cmh->size() >= 0); handlePktWithoutSR(p, false); return; } /* * Am I allowed to salvage? */ if(dsragent_salvage_with_cache == 0) { assert(mine); drop(pkt, DROP_RTR_NO_ROUTE); return; } #ifdef NEW_SALVAGE_LOGIC if(srh->salvaged() >= dsr_salvage_max_attempts) { assert(mine); drop(pkt, DROP_RTR_SALVAGE); return; } #endif /* NEW_SALVAGE_LOGIC */ // it's a packet we're forwarding for someone, save it if we can... Path salvage_route; if (route_cache->findRoute(p.dest, salvage_route, 0)) { // be nice and send the packet out #if 0 /* we'd like to create a ``proper'' source route with the IP src of the packet as the first node, but we can't actually just append the salvage route onto the route used so far, since the append creates routes with loops in them like 1 2 3 4 3 5 If we were to squish the route to remove the loop, then we'd be removing ourselves from the route, which is verboten. If we did remove ourselves, and our salvage route contained a stale link, we might never hear the route error. -dam 5/13/98 Could we perhaps allow SRs with loops in them on the air? Since it's still a finite length SR, the pkt can't loop forever... -dam 8/5/98 */ // truncate the route at the bad link and append good bit int our_index = p.route.index(); p.route.setLength(our_index); // yes this cuts us off the route, p.route.appendPath(salvage_route); // but we're at the front of s_r p.route.setIterator(our_index); #else p.route = salvage_route; p.route.resetIterator(); #endif if (dsragent_dont_salvage_bad_replies && srh->route_reply()) { // check to see if we'd be salvaging a packet // with the dead link in it ID to_id(srh->addrs()[srh->cur_addr()+1].addr, (ID_Type) srh->addrs()[srh->cur_addr()].addr_type); bool bad_reply = false; for (int i = 0 ; i < srh->route_reply_len()-1; i++) { if (net_id == ID(srh->reply_addrs()[i]) && to_id == ID(srh->reply_addrs()[i+1]) || (dsragent_require_bi_routes && to_id == ID(srh->reply_addrs()[i]) && net_id == ID(srh->reply_addrs()[i+1]))) { bad_reply = true; break; } } if (bad_reply) { // think about killing this packet srh->route_reply() = 0; if (PT_DSR == cmh->ptype() && ! srh->route_request() && ! srh->route_error()) { // this packet has no reason to live if (verbose_srr) trace("SRR %.5f _%s_ --- %d dropping bad-reply %s -> %s", Scheduler::instance().clock(), net_id.dump(), cmh->uid(), p.src.dump(), p.dest.dump()); if (mine) drop(pkt, DROP_RTR_MAC_CALLBACK); return; } } } if (verbose_ssalv) trace("Ssalv %.5f _%s_ salvaging %s -> %s --- %d with %s", Scheduler::instance().clock(), net_id.dump(), p.src.dump(), p.dest.dump(), cmh->uid(), p.route.dump()); // remove size of SR header, added back in sendOutPacketWithRoute cmh->size() -= srh->size(); assert(cmh->size() >= 0); #ifdef NEW_SALVAGE_LOGIC srh->salvaged() += 1; #endif sendOutPacketWithRoute(p, false); } #ifdef NEW_SALVAGE_LOGIC else if(dsr_salvage_max_requests > 0) { /* * Allow the node to perform route discovery for an * intermediate hop. */ if (verbose_ssalv) trace("Ssalv %.5f _%s_ adding to SB --- %d %s -> %s [%d]", Scheduler::instance().clock(), net_id.dump(), cmh->uid(), p.src.dump(), p.dest.dump(), srh->salvaged()); stickPacketInSendBuffer(p); } #endif else { // we don't have a route, and it's not worth us doing a // route request to try to help the originator out, since // it might be counter productive if (verbose_ssalv) trace("Ssalv %.5f _%s_ dropping --- %d %s -> %s [%d]", Scheduler::instance().clock(), net_id.dump(), cmh->uid(), p.src.dump(), p.dest.dump(), srh->salvaged()); if (mine) drop(pkt, DROP_RTR_NO_ROUTE); } }

Here is the call graph for this function:

void DSRAgent::xmitFailed (  Packet *  pkt, const char *  reason = "DROP_RTR_MAC_CALLBACK" )  [private]

Definition at line 2560 of file dsragent.cc. References hdr_cmn::access(), hdr_ip::access(), hdr_sr::access(), ID::addr, sr_addr::addr, link_down::addr_type, hdr_sr::addrs(), Packet::copy(), Address::create_ipaddr(), hdr_sr::cur_addr(), hdr_ip::daddr(), SRPacket::dest, hdr_cmn::direction(), hdr_cmn::DOWN, hdr_sr::down_links(), hdr_ip::dport(), hdr_sr::dump(), ID::dump(), hdr_sr::flow_header(), flow_table, hdr_sr::flow_timeout(), Packet::free(), link_down::from_addr, ID::getNSAddr_t(), God::hops(), ID_Type, ifq, Path::index(), Address::instance(), God::instance(), Scheduler::instance(), IP_HDR_LEN, MAC_id, MAX_ROUTE_ERRORS, net_id, Packet::next_, FlowTable::noticeDeadLink(), RouteCache::noticeDeadLink(), hdr_sr::num_addrs(), hdr_cmn::num_forwards(), hdr_sr::num_route_errors(), CMUPriQueue::prq_get_nexthop(), PT_DSR, hdr_cmn::ptype(), Path::reverseInPlace(), SRPacket::route, route_cache, hdr_sr::route_error(), hdr_sr::route_reply(), hdr_sr::route_request(), RT_PORT, hdr_ip::saddr(), sendOutPacketWithRoute(), Path::setLength(), hdr_cmn::size(), hdr_ip::sport(), SRPacket::src, link_down::tell_addr, link_down::to_addr, trace(), hdr_ip::ttl(), hdr_cmn::uid(), Agent::uidcnt_, undeliverablePkt(), and verbose. Referenced by sendOutPacketWithRoute(), and xmitFlowFailed(). { hdr_sr *srh = hdr_sr::access(pkt); hdr_ip *iph = hdr_ip::access(pkt); hdr_cmn *cmh = hdr_cmn::access(pkt); assert(cmh->size() >= 0); srh->cur_addr() -= 1; // correct for inc already done on sending if (srh->cur_addr() >= srh->num_addrs() - 1) { trace("SDFU: route error beyond end of source route????"); fprintf(stderr,"SDFU: route error beyond end of source route????\n"); Packet::free(pkt); return; } if (srh->route_request()) { trace("SDFU: route error forwarding route request????"); fprintf(stderr,"SDFU: route error forwarding route request????\n"); Packet::free(pkt); return; } ID tell_id(srh->addrs()[0].addr, (ID_Type) srh->addrs()[srh->cur_addr()].addr_type); ID from_id(srh->addrs()[srh->cur_addr()].addr, (ID_Type) srh->addrs()[srh->cur_addr()].addr_type); ID to_id(srh->addrs()[srh->cur_addr()+1].addr, (ID_Type) srh->addrs()[srh->cur_addr()].addr_type); assert(from_id == net_id || from_id == MAC_id); trace("SSendFailure %.9f _%s_ %d %d %d:%d %d:%d %s->%s %d %d %d %d %s", Scheduler::instance().clock(), net_id.dump(), cmh->uid(), cmh->ptype(), iph->saddr(), iph->sport(), iph->daddr(), iph->dport(), from_id.dump(),to_id.dump(), God::instance()->hops(from_id.getNSAddr_t(), to_id.getNSAddr_t()), God::instance()->hops(iph->saddr(),iph->daddr()), God::instance()->hops(from_id.getNSAddr_t(), iph->daddr()), srh->num_addrs(), srh->dump()); #ifdef USE_GOD_FEEDBACK if (God::instance()->hops(from_id.getNSAddr_t(), to_id.getNSAddr_t()) == 1) { /* god thinks this link is still valid */ linkerr_is_wrong++; trace("SxmitFailed %.5f _%s_ %d->%d god okays #%d", Scheduler::instance().clock(), net_id.dump(), from_id.getNSAddr_t(), to_id.getNSAddr_t(), linkerr_is_wrong); fprintf(stderr, "xmitFailed on link %d->%d god okays - ignoring & recycling #%d\n", from_id.getNSAddr_t(), to_id.getNSAddr_t(), linkerr_is_wrong); /* put packet back on end of ifq for xmission */ srh->cur_addr() += 1; // correct for decrement earlier in proc // make sure we aren't cycling packets // also change direction in pkt hdr cmh->direction() = hdr_cmn::DOWN; ll->recv(pkt, (Handler*) 0); return; } #endif if(strcmp(reason, "DROP_IFQ_QFULL") != 0) { assert(strcmp(reason, "DROP_RTR_MAC_CALLBACK") == 0); /* kill any routes we have using this link */ route_cache->noticeDeadLink(from_id, to_id, Scheduler::instance().clock()); flow_table.noticeDeadLink(from_id, to_id); /* give ourselves a chance to save the packet */ undeliverablePkt(pkt->copy(), 1); /* now kill all the other packets in the output queue that would use the same next hop. This is reasonable, since 802.11 has already retried the xmission multiple times => a persistent failure. */ /* XXX YCH 5/4/01 shouldn't each of these packets get Route Errors * if one hasn't already been sent? ie if two different routes * are using this link? */ { Packet *r, *nr, *queue1 = 0, *queue2 = 0; // pkts to be recycled while((r = ifq->prq_get_nexthop(to_id.getNSAddr_t()))) { r->next_ = queue1; queue1 = r; } // the packets are now in the reverse order of how they // appeared in the IFQ so reverse them again for(r = queue1; r; r = nr) { nr = r->next_; r->next_ = queue2; queue2 = r; } // now process them in order for(r = queue2; r; r = nr) { nr = r->next_; undeliverablePkt(r, 1); } } } /* warp pkt into a route error message */ if (tell_id == net_id || tell_id == MAC_id) { // no need to send the route error if it's for us if (verbose) trace("Sdebug _%s_ not bothering to send route error to ourselves", tell_id.dump()); Packet::free(pkt); // no drop needed pkt = 0; return; } if (srh->num_route_errors() >= MAX_ROUTE_ERRORS) { // no more room in the error packet to nest an additional error. // this pkt's been bouncing around so much, let's just drop and let // the originator retry // Another possibility is to just strip off the outer error, and // launch a Route discovey for the inner error XXX -dam 6/5/98 trace("SDFU %.5f _%s_ dumping maximally nested error %s %d -> %d", Scheduler::instance().clock(), net_id.dump(), tell_id.dump(), from_id.dump(), to_id.dump()); Packet::free(pkt); // no drop needed pkt = 0; return; } link_down *deadlink = &(srh->down_links()[srh->num_route_errors()]); deadlink->addr_type = srh->addrs()[srh->cur_addr()].addr_type; deadlink->from_addr = srh->addrs()[srh->cur_addr()].addr; deadlink->to_addr = srh->addrs()[srh->cur_addr()+1].addr; deadlink->tell_addr = srh->addrs()[0].addr; srh->num_route_errors() += 1; if (verbose) trace("Sdebug %.5f _%s_ sending into dead-link (nest %d) tell %d %d -> %d", Scheduler::instance().clock(), net_id.dump(), srh->num_route_errors(), deadlink->tell_addr, deadlink->from_addr, deadlink->to_addr); srh->route_error() = 1; srh->route_reply() = 0; srh->route_request() = 0; srh->flow_header() = 0; srh->flow_timeout() = 0; //iph->daddr() = deadlink->tell_addr; iph->daddr() = Address::instance().create_ipaddr(deadlink->tell_addr,RT_PORT); iph->dport() = RT_PORT; //iph->saddr() = net_id.addr; iph->saddr() = Address::instance().create_ipaddr(net_id.addr,RT_PORT); iph->sport() = RT_PORT; iph->ttl() = 255; cmh->ptype() = PT_DSR; // cut off data cmh->size() = IP_HDR_LEN; cmh->num_forwards() = 0; // assign this packet a new uid, since we're sending it cmh->uid() = uidcnt_++; SRPacket p(pkt, srh); p.route.setLength(p.route.index()+1); p.route.reverseInPlace(); p.dest = tell_id; p.src = net_id; /* send out the Route Error message */ sendOutPacketWithRoute(p, true); }

Here is the call graph for this function:

void DSRAgent::xmitFlowFailed (  Packet *  pkt, const char *  reason = "DROP_RTR_MAC_CALLBACK" )  [private]

Definition at line 2508 of file dsragent.cc. References hdr_cmn::access(), hdr_ip::access(), hdr_sr::access(), ID::addr, hdr_sr::addrs(), Scheduler::clock(), hdr_sr::cur_addr(), hdr_ip::daddr(), FlowTable::defaultFlow(), SRPacket::dest, FlowTable::find(), hdr_sr::flow_header(), hdr_sr::flow_id(), flow_table, Scheduler::instance(), Address::instance(), net_id, nsaddr_t, hdr_sr::num_addrs(), hdr_ip::saddr(), sendUnknownFlow(), hdr_sr::size(), hdr_cmn::size(), SRPacket::src, u_int16_t, and xmitFailed(). { hdr_sr *srh = hdr_sr::access(pkt); hdr_ip *iph = hdr_ip::access(pkt); hdr_cmn *cmh = hdr_cmn::access(pkt); int flowidx = flow_table.find(iph->saddr(), iph->daddr(), srh->flow_id()); u_int16_t default_flow; assert(!srh->num_addrs()); if (!srh->flow_header()) { if (!flow_table.defaultFlow(iph->saddr(), iph->daddr(), default_flow)) { SRPacket p(pkt, srh); //p.src = ID(iph->src(), ::IP); //p.dest = ID(iph->dst(), ::IP); p.dest = ID((Address::instance().get_nodeaddr(iph->daddr())),::IP); p.src = ID((Address::instance().get_nodeaddr(iph->saddr())),::IP); sendUnknownFlow(p, true); return; } flowidx = flow_table.find(iph->saddr(), iph->daddr(), default_flow); } if (flowidx == -1 || flow_table[flowidx].timeout < Scheduler::instance().clock()) { // blah, the flow has expired, or been forgotten. SRPacket p(pkt, srh); //p.src = ID(iph->src(), ::IP); //p.dest = ID(iph->dst(), ::IP); p.dest = ID((Address::instance().get_nodeaddr(iph->daddr())),::IP); p.src = ID((Address::instance().get_nodeaddr(iph->saddr())),::IP); return; } cmh->size() -= srh->size(); // gonna change the source route size assert(cmh->size() >= 0); flow_table[flowidx].sourceRoute.fillSR(srh); srh->cur_addr() = flow_table[flowidx].hopCount; assert(srh->addrs()[srh->cur_addr()].addr == (nsaddr_t) net_id.addr); cmh->size() += srh->size(); // xmitFailed is going to assume this was incr'ed for send srh->cur_addr()++; xmitFailed(pkt, reason); }

Here is the call graph for this function:

---

Friends And Related Function Documentation

int FilterFailure (  Packet *  p, void *  data )  [friend]

friend class SendBufferTimer [friend]

Definition at line 246 of file dsragent.h.

void XmitFailureCallback (  Packet *  pkt, void *  data )  [friend]

Definition at line 2748 of file dsragent.cc. Referenced by sendOutPacketWithRoute(). { DSRAgent *agent = (DSRAgent *)data; // cast of trust agent->xmitFailed(pkt); }

void XmitFlowFailureCallback (  Packet *  pkt, void *  data )  [friend]

Definition at line 2755 of file dsragent.cc. Referenced by handleFlowForwarding(), and sendOutPacketWithRoute(). { DSRAgent *agent = (DSRAgent *)data; agent->xmitFlowFailed(pkt); }

---

Member Data Documentation

DSRAgent_List DSRAgent::agthead = { 0 } [static]

Definition at line 98 of file dsragent.cc. Referenced by DSRAgent().

Application* Agent::app_ [protected, inherited]

Reimplemented in BayFullTcpAgent. Definition at line 134 of file agent.h. Referenced by Agent::attachApp(), Agent::idle(), RapAgent::IpgTimeout(), UdpAgent::recv(), SimpleTcpAgent::recv(), RapAgent::recv(), HttpInvalAgent::recv(), Agent::recv(), and Agent::recvBytes().

ARSTable DSRAgent::ars_table [private]

Definition at line 151 of file dsragent.h. Referenced by handleFlowForwarding(), and processFlowARS().

Tcl_Channel Agent::channel_ [protected, inherited]

Definition at line 130 of file agent.h. Referenced by Agent::addAgentTrace(), Agent::command(), Agent::flushAVar(), Agent::monitorAgentTrace(), TcpAsymSink::recv(), Agent::trace(), TcpAgent::traceAll(), TcpAsymAgent::traceAll(), TcpAgent::traceVar(), TcpSessionAgent::traceVar(), and TcpAsymAgent::traceVar().

int NsObject::debug_ [protected, inherited]

Reimplemented in FECModel, FloodAgent, and LandmarkAgent. Definition at line 66 of file object.h. Referenced by REDQueue::command(), RedPDQueue::command(), PushbackQueue::command(), NsObject::debug(), NsObject::delay_bind_dispatch(), RedPDQueue::enque(), PushbackQueue::enque(), NsObject::isdebug(), NsObject::NsObject(), TfrcAgent::recv(), PushbackQueue::reportDrop(), and REDQueue::reset().

int Agent::defttl_ [protected, inherited]

Definition at line 121 of file agent.h. Referenced by Agent::delay_bind_dispatch(), and Agent::initpkt().

NsObject* Connector::drop_ [protected, inherited]

Definition at line 57 of file connector.h. Referenced by Connector::command(), Connector::drop(), and ErrorModel::recv().

ns_addr_t Agent::dst_ [protected, inherited]

Reimplemented in AckRecons. Definition at line 115 of file agent.h. Referenced by Agent::addAgentTrace(), Agent::daddr(), Agent::delay_bind_dispatch(), Agent::deleteAgentTrace(), Agent::dport(), DSRProto::DSRProto(), Agent::flushAVar(), Agent::initpkt(), SRMAgent::recv(), SSMSRMAgent::recv(), NatAgent::recv(), SRMAgent::sendmsg(), PushbackAgent::sendMsg(), and Agent::trace().

ID DSRAgent::err_from [private]

Definition at line 154 of file dsragent.h. Referenced by processBrokenRouteError(), and sendOutRtReq().

ID DSRAgent::err_to [private]

Definition at line 154 of file dsragent.h. Referenced by processBrokenRouteError(), and sendOutRtReq().

EventTrace* Agent::et_ [protected, inherited]

Definition at line 145 of file agent.h. Referenced by TcpAgent::command(), and TcpAgent::trace_event().

int Agent::fid_ [protected, inherited]

Definition at line 118 of file agent.h. Referenced by Agent::delay_bind_dispatch(), AbsTcpAgent::flowid(), Agent::initpkt(), FullTcpAgent::recv(), CtrMcastEncap::recv(), AbsTcpAgent::send_batch(), Sack1TcpAgent::timeout(), and TcpAgent::trace_event().

int Agent::flags_ [protected, inherited]

Reimplemented in BayFullTcpAgent, RapAgent, and FullTcpAgent. Definition at line 120 of file agent.h. Referenced by Agent::delay_bind_dispatch().

FlowTable DSRAgent::flow_table [private]

Definition at line 150 of file dsragent.h. Referenced by command(), handleDefaultForwarding(), handleFlowForwarding(), processBrokenRouteError(), processFlowARS(), processUnknownFlowError(), sendOutPacketWithRoute(), xmitFailed(), and xmitFlowFailed().

GratReplyHoldDown DSRAgent::grat_hold[RTREP_HOLDOFF_SIZE] [private]

Definition at line 146 of file dsragent.h. Referenced by DSRAgent(), and sendRouteShortening().

int DSRAgent::grat_hold_victim [private]

Definition at line 147 of file dsragent.h. Referenced by DSRAgent(), and sendRouteShortening().

ns_addr_t Agent::here_ [protected, inherited]

Definition at line 114 of file agent.h. Referenced by Agent::addAgentTrace(), Agent::addr(), SinkAgent::bcast_interest(), SinkAgent::data_ready(), OmniMcastAgent::DataForSink(), FloodingAgent::DataForSink(), DiffusionAgent::DataForSink(), Agent::delay_bind_dispatch(), Agent::deleteAgentTrace(), DiffusionProb::ForwardData(), DiffusionProb::ForwardTxFailed(), DiffusionRate::FwdOriginal(), DiffusionProb::FwdPosReinf(), DiffusionRate::FwdSubsample(), OmniMcastAgent::GodForwardData(), Agent::initpkt(), OmniMcastAgent::MACprepare(), FloodingAgent::MACprepare(), DiffusionAgent::MACprepare(), Agent::monitorAgentTrace(), Agent::port(), OmniMcastAgent::prepare_message(), FloodingAgent::prepare_message(), DiffusionAgent::prepare_message(), SSMSRMAgent::recv(), PingAgent::recv(), NatAgent::recv(), DumbAgent::recv(), SinkAgent::sendpkt(), SinkAgent::set_addr(), SinkAgent::Terminate(), and Agent::trace().

CMUPriQueue* DSRAgent::ifq [private]

Definition at line 118 of file dsragent.h. Referenced by command(), DSRAgent(), handleRouteRequest(), sendOutPacketWithRoute(), and xmitFailed().

NsObject* DSRAgent::ll [private]

Definition at line 117 of file dsragent.h.

Trace* DSRAgent::logtarget [private]

Definition at line 108 of file dsragent.h. Referenced by command(), DSRAgent(), recv(), and trace().

Mac* DSRAgent::mac_ [private]

Definition at line 119 of file dsragent.h. Referenced by command(), DSRAgent(), and handleRouteRequest().

ID DSRAgent::MAC_id [private]

Definition at line 116 of file dsragent.h. Referenced by command(), handleForwarding(), handlePacketReceipt(), ignoreRouteRequestp(), processBrokenRouteError(), replyFromRouteCache(), tap(), and xmitFailed().

ID DSRAgent::net_id [private]

Definition at line 116 of file dsragent.h. Referenced by acceptRouteReply(), command(), dropSendBuff(), getRouteForPacket(), handleFlowForwarding(), handleForwarding(), handlePacketReceipt(), handlePktWithoutSR(), handleRouteRequest(), ignoreRouteRequestp(), processBrokenRouteError(), processUnknownFlowError(), recv(), replyFromRouteCache(), returnSrcRouteToRequestor(), sendBufferCheck(), sendOutPacketWithRoute(), sendOutRtReq(), sendRouteShortening(), sendUnknownFlow(), stickPacketInSendBuffer(), tap(), testinit(), undeliverablePkt(), xmitFailed(), and xmitFlowFailed().

MobileNode* DSRAgent::node_ [private]

Definition at line 122 of file dsragent.h. Referenced by acceptRouteReply(), command(), handlePktWithoutSR(), and sendOutPacketWithRoute().

int DSRAgent::num_heldoff_rt_replies [private]

Definition at line 144 of file dsragent.h. Referenced by DSRAgent().

int DSRAgent::off_ip_ [private]

Definition at line 111 of file dsragent.h.

int DSRAgent::off_ll_ [private]

Definition at line 110 of file dsragent.h.

int DSRAgent::off_mac_ [private]

Definition at line 109 of file dsragent.h.

int DSRAgent::off_sr_ [private]

Definition at line 112 of file dsragent.h.

OldValue* Agent::oldValueList_ [protected, inherited]

Definition at line 132 of file agent.h. Referenced by Agent::insertOldValue(), Agent::lookupOldValue(), and Agent::~Agent().

NsObject* DSRAgent::port_dmux_ [private]

Definition at line 126 of file dsragent.h. Referenced by command(), and recv().

int Agent::prio_ [protected, inherited]

Definition at line 119 of file agent.h. Referenced by Agent::delay_bind_dispatch(), and Agent::initpkt().

RequestTable DSRAgent::request_table [private]

Definition at line 139 of file dsragent.h. Referenced by acceptRouteReply(), getRouteForPacket(), handlePacketReceipt(), handleRouteRequest(), and ignoreRouteRequestp().

RouteCache* DSRAgent::route_cache [private]

Definition at line 140 of file dsragent.h. Referenced by acceptRouteReply(), command(), DSRAgent(), handleForwarding(), handlePktWithoutSR(), processBrokenRouteError(), replyFromRouteCache(), returnSrcRouteToRequestor(), sendRouteShortening(), tap(), testinit(), undeliverablePkt(), and xmitFailed().

Time DSRAgent::route_error_data_time [private]

Definition at line 155 of file dsragent.h. Referenced by processBrokenRouteError(), and sendOutRtReq().

bool DSRAgent::route_error_held [private]

Definition at line 153 of file dsragent.h. Referenced by DSRAgent(), processBrokenRouteError(), and sendOutRtReq().

int DSRAgent::route_request_num [private]

Definition at line 143 of file dsragent.h. Referenced by DSRAgent(), and sendOutRtReq().

RtRepHoldoff DSRAgent::rtrep_holdoff[RTREP_HOLDOFF_SIZE] [private]

Definition at line 145 of file dsragent.h. Referenced by DSRAgent().

SendBufEntry DSRAgent::send_buf[SEND_BUF_SIZE] [private]

Definition at line 141 of file dsragent.h. Referenced by acceptRouteReply(), sendBufferCheck(), stickPacketInSendBuffer(), and Terminate().

SendBufferTimer DSRAgent::send_buf_timer [private]

Definition at line 142 of file dsragent.h. Referenced by command().

int Agent::size_ [protected, inherited]

Reimplemented in SA_Agent, and AckRecons. Definition at line 116 of file agent.h. Referenced by AbsDelAckSink::AbsDelAckSink(), AbsTcpAgent::AbsTcpAgent(), AbsTcpRenoAckAgent::AbsTcpRenoAckAgent(), AbsTcpRenoDelAckAgent::AbsTcpRenoDelAckAgent(), AbsTcpSink::AbsTcpSink(), AbsTcpTahoeAckAgent::AbsTcpTahoeAckAgent(), AbsTcpTahoeDelAckAgent::AbsTcpTahoeDelAckAgent(), RTCPAgent::command(), LDPAgent::command(), SinkAgent::command(), IntTcpAgent::createTcpSession(), TfrcAgent::decrease_rate(), TcpAgent::delay_bind_dispatch(), TcpSink::delay_bind_dispatch(), FullTcpAgent::foutput(), getRouteForPacket(), TfrcAgent::increase_rate(), TcpAgent::initial_window(), Agent::initpkt(), RapAgent::IpgTimeout(), IvsReceiver::IvsReceiver(), LmsAgent::LmsAgent(), LmsReceiver::LmsReceiver(), mcastControlAgent::mcastControlAgent(), MessageAgent::MessageAgent(), MIPBSAgent::MIPBSAgent(), MIPMHAgent::MIPMHAgent(), TfrcAgent::nextpkt(), IntTcpAgent::opencwnd(), PingAgent::PingAgent(), RapAgent::RapAgent(), TfrcAgent::recv(), TcpSessionAgent::recv(), NewRenoTcpAgent::recv(), TfrcAgent::reduce_rate_on_no_feedback(), RLM_Sender::RLM_Sender(), RTCPAgent::RTCPAgent(), RTPAgent::RTPAgent(), IntTcpAgent::rxmit_last(), LmsSender::send_lms_pkt(), TcpSessionAgent::send_much(), LmsReceiver::send_nak(), IntTcpAgent::send_one(), LmsReceiver::send_refresh(), UdpAgent::sendmsg(), TfrcAgent::sendmsg(), TcpAgent::sendmsg(), SRMAgent::sendmsg(), RTPAgent::sendmsg(), RapAgent::SendPacket(), TfrcAgent::sendpkt(), rtProtoDV::sendpkt(), SinkAgent::sendpkt(), SinkAgent::SinkAgent(), Agent::size(), TfrcAgent::slowstart(), TfrcAgent::start(), TfrcAgent::TfrcAgent(), TfrcSinkAgent::TfrcSinkAgent(), RTPAgent::timeout(), RTCPAgent::timeout(), and UdpAgent::UdpAgent().

int DSRAgent::tap_uid_cache[TAP_CACHE_SIZE] [private]

Definition at line 135 of file dsragent.h. Referenced by DSRAgent(), and tap().

NsObject* Connector::target_ [protected, inherited]

Definition at line 56 of file connector.h. Referenced by SRAgent::command(), SA_Agent::command(), IvsReceiver::command(), MultiFieldFilter::command(), Filter::command(), Connector::command(), DiffusionAgent::DiffusionAgent(), DSRAgent(), PromotionTimer::expire(), FloodingAgent::FloodingAgent(), toraAgent::forward(), AODV::forward(), LandmarkAgent::ForwardPacket(), DSDV_Agent::forwardPacket(), SensorQueryAgent::generate_query(), DSDVTriggerHandler::handle(), AckRecons::handle(), handlePacketReceipt(), DSDV_Agent::helper_callback(), AODV::initialized(), DSDV_Agent::lost_link(), OmniMcastAgent::OmniMcastAgent(), LandmarkAgent::periodic_callback(), LandmarkAgent::ProcessHierUpdate(), TCPTapAgent::processpkt(), IPTapAgent::processpkt(), CMUPriQueue::prq_enqueue(), CMUPriQueue::prq_resume(), DequeTrace::recv(), Trace::recv(), TraceIpMac::recv(), TraceIp::recv(), TBF::recv(), SRMAgent::recv(), SSMSRMAgent::recv(), SatDequeTrace::recv(), SAack_Agent::recv(), Queue< T >::recv(), PingResponder::recv(), MIPEncapsulator::recv(), LmsAgent::recv(), HackLossyLink::recv(), GAFPartner::recv(), FQ::recv(), FloodAgent::recv(), ErrorModel::recv(), DynamicLink::recv(), DumbAgent::recv(), recv(), DelayModel::recv(), LinkDelay::recv(), CtrMcastDecap::recv(), CtrMcastEncap::recv(), CMUTrace::recv(), PriQueue::recvHighPriority(), Trace::recvOnly(), TapAgent::recvpkt(), Queue< T >::resume(), LinkDelay::send(), Connector::send(), Agent::send(), MIPBSAgent::send_ads(), SRMAgent::send_ctrl(), SSMSRMAgent::send_ctrl(), MFTPSndAgent::send_data(), LmsSender::send_dmcast(), LmsReceiver::send_dmcast(), LmsAgent::send_downstream(), SSMSRMAgent::send_glb_sess(), LmsSender::send_lms_pkt(), SSMSRMAgent::send_loc_sess(), MFTPRcvAgent::send_nak(), LmsReceiver::send_nak(), LmsReceiver::send_refresh(), SSMSRMAgent::send_rep_sess(), SRMAgent::send_sess(), MIPMHAgent::send_sols(), LmsSender::send_spm(), MFTPSndAgent::send_status_request(), LmsAgent::send_upstream(), LandmarkAgent::SendChangedTagListUpdate(), AODV::sendError(), AODV::sendHello(), UdpAgent::sendmsg(), SRMAgent::sendmsg(), SA_Agent::sendmsg(), RTPAgent::sendmsg(), LmsSender::sendmsg(), DSDV_Agent::sendOutBCastPkt(), SA_Agent::sendpkt(), rtProtoDV::sendpkt(), RTPAgent::sendpkt(), RTCPAgent::sendpkt(), IvsSource::sendpkt(), AODV::sendReply(), AODV::sendRequest(), LmsSender::solicit_naks(), Connector::target(), TBF::timeout(), and toraAgent::tora_output().

char* Agent::traceName_ [protected, inherited]

Definition at line 131 of file agent.h. Referenced by Agent::addAgentTrace(), Agent::command(), Agent::deleteAgentTrace(), Agent::flushAVar(), Agent::monitorAgentTrace(), and Agent::trace().

packet_t Agent::type_ [protected, inherited]

Definition at line 117 of file agent.h. Referenced by Agent::get_pkttype(), Agent::initpkt(), FullTcpAgent::listen(), BayFullTcpAgent::listen(), RapAgent::SendAck(), SRMAgent::sendmsg(), RapAgent::SendPacket(), and Agent::set_pkttype().

int Agent::uidcnt_ [static, protected, inherited]

Definition at line 68 of file agent.cc. Referenced by imepAgent::handlerControlTimer(), imepAgent::handlerReXmitTimer(), Agent::initpkt(), imepAgent::sendAck(), imepAgent::sendBeacon(), toraAgent::sendCLR(), imepAgent::sendHello(), toraAgent::sendQRY(), sendUnknownFlow(), toraAgent::sendUPD(), and xmitFailed().

---

The documentation for this class was generated from the following files:

• dsragent.h
• dsragent.cc

---