ns2 Network Simulator 2.29: SRAgent Class Reference

00076                 :Agent(PT_TCP), slot_(0), nslot_(0), maxslot_(-1) 
00077 {
00078   //  cout << " into the constructor " << endl; 
00079 }

00082 {
00083   delete [] slot_;
00084 }

00327 {
00328     char wrk[256];
00329     int n;
00330     double curTime = (&Scheduler::instance() == NULL ? 0 : 
00331               Scheduler::instance().clock());
00332     
00333     sprintf(wrk, "a -t "TIME_FORMAT" -s %d -d %d -n %s",
00334         curTime, here_.addr_, dst_.addr_, name);
00335     n = strlen(wrk);
00336     wrk[n] = '\n';
00337     wrk[n+1] = 0;
00338     if (channel_)
00339         (void)Tcl_Write(channel_, wrk, n+1);
00340     // keep agent trace name
00341     if (traceName_ != NULL)
00342         delete[] traceName_;
00343     traceName_ = new char[strlen(name)+1];
00344     strcpy(traceName_, name);
00345 }

00099 { return here_.addr_; }

00255 {
00256     NsObject** old = slot_;
00257     int n = nslot_;
00258     if (old == NULL)
00259         nslot_ = 32;
00260     while (nslot_ <= slot)
00261         nslot_ <<= 1;
00262     slot_ = new NsObject*[nslot_];
00263     memset(slot_, 0, nslot_ * sizeof(NsObject*));
00264     for (int i = 0; i < n; ++i)
00265         slot_[i] = old[i];
00266     delete [] old;
00267 }

00529 {
00530         Packet* p = allocpkt();
00531 
00532     if (n > 0)
00533             p->allocdata(n);
00534 
00535     return(p);
00536 }

00518 {
00519     Packet* p = Packet::alloc();
00520     initpkt(p);
00521     return (p);
00522 }

00373 {
00374     app_ = app;
00375 }

00090 {
00091     Tcl& tcl = Tcl::instance();     
00092 
00093     if(argc == 2)
00094       {
00095         if (strcmp(argv[1],"reset") == 0)
00096           {
00097         tcl.resultf("reset done");
00098         return(TCL_OK);
00099           }
00100       }
00101     else if(argc == 3) 
00102       {
00103         if((strcmp(argv[1], "target") == 0))
00104           {
00105         target_ = (NsObject *) TclObject::lookup(argv[2]);
00106         if (target_ == 0) {
00107           tcl.resultf("no such target %s", argv[2]);
00108           return(TCL_ERROR);
00109         }
00110         tcl.resultf(" The target is successfully set");
00111         return(TCL_OK);
00112           }
00113       }
00114     else if(argc == 4)
00115       {
00116         if((strcmp(argv[1], "install_slot") == 0))
00117           {
00118         //cout << " Installing " << argv[2] << " in " << argv[3] << endl;
00119         NsObject* obj = (NsObject*)TclObject::lookup(argv[2]);
00120         if (obj == 0) 
00121           {
00122             tcl.resultf("SRAgent: %s lookup of %s failed\n", argv[1], argv[2]);
00123             return TCL_ERROR;
00124           }
00125         else
00126           {
00127             install(atoi(argv[3]), obj);
00128             return TCL_OK;
00129           }
00130         
00131           }
00132       }
00133     else
00134       {
00135 
00136         if( (strcmp(argv[1], "install_connection") == 0))
00137           {
00138         h_node *node = (h_node *)malloc(sizeof(h_node));
00139         h_node *list;
00140         
00141         node->route_len = argc - 5;
00142         for (int tmp=0; tmp < node->route_len; tmp++)
00143           node->route[tmp] = atoi(argv[5+tmp]);
00144         node->tag = atoi(argv[2]);
00145         
00146         int hash_val = atoi(argv[2])%10;
00147         list = table[hash_val];
00148         node->next = list;
00149         table[hash_val] = node;
00150         
00151         return TCL_OK;
00152         
00153           }
00154       }
00155     return (Agent::command(argc,argv));
00156 }

00390 {
00391 /*
00392     dst_ = dst;
00393 */
00394 }

00101 { return dst_.addr_; }

00103 {
00104     if (!debug_)
00105         return;
00106     va_list ap;
00107     va_start(ap, fmt);
00108     vprintf(fmt, ap);
00109 }

00094 {
00095     if (delay_bind(varName, localName, "agent_addr_", (int*)&(here_.addr_), tracer)) return TCL_OK;
00096     if (delay_bind(varName, localName, "agent_port_", (int*)&(here_.port_), tracer)) return TCL_OK;
00097     if (delay_bind(varName, localName, "dst_addr_", (int*)&(dst_.addr_), tracer)) return TCL_OK;
00098     if (delay_bind(varName, localName, "dst_port_", (int*)&(dst_.port_), tracer)) return TCL_OK;
00099     if (delay_bind(varName, localName, "fid_", (int*)&fid_, tracer)) return TCL_OK;
00100     if (delay_bind(varName, localName, "prio_", (int*)&prio_, tracer)) return TCL_OK;
00101     if (delay_bind(varName, localName, "flags_", (int*)&flags_, tracer)) return TCL_OK;
00102     if (delay_bind(varName, localName, "ttl_", &defttl_, tracer)) return TCL_OK;
00103     if (delay_bind(varName, localName, "class_", (int*)&fid_, tracer)) return TCL_OK;
00104     return Connector::delay_bind_dispatch(varName, localName, tracer);
00105 }

00079 {
00080     delay_bind_init_one("agent_addr_");
00081     delay_bind_init_one("agent_port_");
00082     delay_bind_init_one("dst_addr_");
00083     delay_bind_init_one("dst_port_");
00084     delay_bind_init_one("fid_");
00085     delay_bind_init_one("prio_");
00086     delay_bind_init_one("flags_");
00087     delay_bind_init_one("ttl_");
00088     delay_bind_init_one("class_");
00089     Connector::delay_bind_init_all();
00090 }

00223 {
00224     char wrk[256];
00225 
00226     // XXX we don't know InstVar outside of Tcl! Is there any
00227     // tracedvars hidden in InstVar? If so, shall we have a tclclInt.h?
00228     TracedVar* var = tracedvar_;
00229     for ( ;  var != 0;  var = var->next_) 
00230         flushAVar(var);
00231 
00232     // we need to flush all var values to trace file, 
00233     // so nam can do backtracing
00234     sprintf(wrk, "a -t "TIME_FORMAT" -s %d -d %d -n %s -x",
00235         Scheduler::instance().clock(), here_.addr_,
00236         dst_.addr_, traceName_); 
00237     if (traceName_ != NULL)
00238         delete[] traceName_;
00239     traceName_ = NULL;
00240 }

00102 { return dst_.port_; }

00115 {
00116     if (drop_ != 0)
00117         drop_->recv(p, s);
00118     else
00119         Packet::free(p);
00120 }

00107 {
00108     if (drop_ != 0)
00109         drop_->recv(p);
00110     else
00111         Packet::free(p);
00112 }

00104 { return type_; }

00092 {
00093     recv((Packet*)e);
00094 }

00364 {
00365     if (app_)
00366         app_->resume();
00367 }

00457 {
00458     hdr_cmn* ch = hdr_cmn::access(p);
00459     ch->uid() = uidcnt_++;
00460     ch->ptype() = type_;
00461     ch->size() = size_;
00462     ch->timestamp() = Scheduler::instance().clock();
00463     ch->iface() = UNKN_IFACE.value(); // from packet.h (agent is local)
00464     ch->direction() = hdr_cmn::NONE;
00465 
00466     ch->error() = 0;    /* pkt not corrupt to start with */
00467 
00468     hdr_ip* iph = hdr_ip::access(p);
00469     iph->saddr() = here_.addr_;
00470     iph->sport() = here_.port_;
00471     iph->daddr() = dst_.addr_;
00472     iph->dport() = dst_.port_;
00473     
00474     //DEBUG
00475     //if (dst_ != -1)
00476     //  printf("pl break\n");
00477     
00478     iph->flowid() = fid_;
00479     iph->prio() = prio_;
00480     iph->ttl() = defttl_;
00481 
00482     hdr_flags* hf = hdr_flags::access(p);
00483     hf->ecn_capable_ = 0;
00484     hf->ecn_ = 0;
00485     hf->eln_ = 0;
00486     hf->ecn_to_echo_ = 0;
00487     hf->fs_ = 0;
00488     hf->no_ts_ = 0;
00489     hf->pri_ = 0;
00490     hf->cong_action_ = 0;
00491     hf->qs_ = 0;
00492 #ifdef HAVE_STL
00493 
00494     hdr_nv* nv = hdr_nv::access(p);
00495     if (0)
00496         printf("Off hdr_nv %d, ip_hdr %d myaddr %d\n",
00497                hdr_nv::offset(), hdr_ip::offset(), here_.addr_);
00498     NixNode* pNixNode = NixNode::GetNodeObject(here_.addr_);
00499     if (0)
00500         printf("Node Object %p\n", pNixNode);
00501     if (pNixNode) { 
00502         // If we get non-null, indicates nixvector routing in use
00503         // Delete any left over nv in the packet
00504         // Get a nixvector to the target (may create new)
00505         NixVec* pNv = pNixNode->GetNixVector(dst_.addr_);
00506         pNv->Reset();
00507         nv->nv() = pNv; // And set the nixvec in the packet
00508         nv->h_used = 0; // And reset used portion to 0
00509     }
00510 #endif //HAVE_STL
00511 }

00251 {
00252     OldValue *p = new OldValue;
00253     assert(p != NULL);
00254     strncpy(p->val_, value, min(strlen(value)+1, TRACEVAR_MAXVALUELENGTH));
00255     p->var_ = v;
00256     p->next_ = NULL;
00257     if (oldValueList_ == NULL) 
00258         oldValueList_ = p;
00259     else {
00260         p->next_ = oldValueList_;
00261         oldValueList_ = p;
00262     }
00263 }

00159 {
00160     if (slot >= nslot_)
00161         alloc(slot);
00162     slot_[slot] = p;
00163     if (slot >= maxslot_)
00164         maxslot_ = slot;
00165 }

00061 { return debug_; }

00243 {
00244     OldValue *p = oldValueList_;
00245     while ((p != NULL) && (p->var_ != v))
00246         p = p->next_;
00247     return p;
00248 }

00311 {
00312     char wrk[256];
00313     int n;
00314     double curTime = (&Scheduler::instance() == NULL ? 0 : 
00315               Scheduler::instance().clock());
00316     
00317     sprintf(wrk, "v -t "TIME_FORMAT" -e monitor_agent %d %s",
00318         curTime, here_.addr_, traceName_);
00319     n = strlen(wrk);
00320     wrk[n] = '\n';
00321     wrk[n+1] = 0;
00322     if (channel_)
00323         (void)Tcl_Write(channel_, wrk, n+1);
00324 }

00100 { return here_.port_; }

00097 {
00098     Packet::free(p);
00099 }

00171 {
00172     //  int i = 0;
00173     //int n;
00174   hdr_cmn *cmh =  hdr_cmn::access(packet);
00175   hdr_src *srh =  hdr_src::access(packet);
00176   hdr_ip *iph = hdr_ip::access(packet);
00177 
00178   assert(cmh->size() >= 0);
00179   /* insert the route in the header here , also after this the target
00180    * should have been set.*/
00181   if (cmh->src_rt_valid)
00182     {
00183       //cout << "src rt packet" << endl;
00184       
00185       if (srh->cur_addr_ == srh->num_addrs_)
00186         {
00187       // supposedly dest reached
00188       // I can change the packet type and send it to the entry point once again..... this would set things right. This part of the code is managing things at the receiver also..... finally the packet goes to the right agent and not our src rt agent.
00189       //cout << " setting the packet tye as tcp" << endl; 
00190           cmh->src_rt_valid = '\0';
00191           send(packet,0);
00192       return;
00193         }
00194       
00195       int slot_no = srh->addrs[srh->cur_addr_++];
00196       NsObject *node =  slot_[slot_no];
00197       //cout << "passing to the next hop: " << slot_no << endl;
00198       
00199       if (node == NULL)
00200     {
00201       //cout << "src_rt : null node " << slot_no << " accessed" << endl;
00202       //cout << "flow id is " << iph->flowid() << endl;
00203       exit(0);
00204     }
00205       else
00206     {
00207       //cout << "packet of type" << cmh->ptype() << endl;
00208       cmh->src_rt_valid = '1';
00209       
00210       node->recv(packet, (Handler *)0);
00211       
00212     }
00213       return;
00214     }
00215   else
00216     {
00217       // packet from the TCP most probably
00218       h_node *temp_list;
00219       //cout << " Packet of type: "<< cmh->ptype();
00220 
00221       srh->cur_addr_ = 1;
00222       int connect_id = iph->flowid();
00223       //cout << " The flowid is" << connect_id << endl;
00224       temp_list = table[connect_id%10];
00225 
00226       while (temp_list && temp_list->tag != connect_id)
00227     temp_list = temp_list->next;
00228       if (temp_list == NULL)
00229     {
00230       printf(" The connection id is not in routing tabel\n");
00231       exit(0);
00232     }
00233       
00234       srh->num_addrs_ = temp_list->route_len;
00235       // cout << " total number of hops:" << srh->num_addrs_ << endl;
00236       
00237       for (int j = 0; j< srh->num_addrs_; j++ )
00238     {
00239       srh->addrs[j] = temp_list->route[j];
00240       // cout << " setting the next hop "<< srh->addrs[j];
00241     }
00242       //cout << endl;
00243       //set the target before starting anything in the tcl code
00244       
00245       cmh->src_rt_valid = '1';
00246       //      cout << "setting the type to be src_rt" << endl; 
00247       
00248       send(packet,0);
00249       return;
00250     }
00251   
00252 }

00355 {
00356     if (app_)
00357         app_->recv(nbytes); 
00358 }

00091 { sendmsg(nbytes); }

00084 { sendmsg(sz, data, 0); }

00080 { target_->recv(p, h); }

00401 {
00402     fprintf(stderr, 
00403     "Agent::sendmsg(int, AppData*, const char*) not implemented\n");
00404     abort();
00405 }

00413 {
00414     fprintf(stderr, 
00415     "Agent::sendmsg(int, AppData*, const char*) not implemented\n");
00416     abort();
00417 }

00103 { type_ = pkttype; }

00051 {drop_ = dt; }

00098 { return size_; }

00049 { target_ = target; }

00048 { return target_; }

00267 {
00268     if (channel_ == 0)
00269         return;
00270     char wrk[256], value[128];
00271     int n;
00272 
00273     // XXX we need to keep track of old values. What's the best way?
00274     v->value(value, 128);
00275 
00276     // XXX hack: how do I know ns has not started yet?
00277     // if there's nothing in value, return
00278     static int started = 0;
00279     if (!started) {
00280         Tcl::instance().evalc("[Simulator instance] is-started");
00281         if (Tcl::instance().result()[0] == '0')
00282             // Simulator not started, do nothing
00283             return;
00284         // remember for next time (so we don't always have to call to tcl)
00285         started = 1;
00286     };
00287 
00288     OldValue *ov = lookupOldValue(v);
00289     if (ov != NULL) {
00290         sprintf(wrk, 
00291             "f -t "TIME_FORMAT" -s %d -d %d -n %s -a %s -v %s -o %s -T v",
00292             Scheduler::instance().clock(), here_.addr_,
00293             dst_.addr_, v->name(), traceName_, value, ov->val_);
00294         strncpy(ov->val_, 
00295             value,
00296             min(strlen(value)+1, TRACEVAR_MAXVALUELENGTH));
00297     } else {
00298         // if there is value, insert it into old value list
00299         sprintf(wrk, "f -t "TIME_FORMAT" -s %d -d %d -n %s -a %s -v %s -T v",
00300             Scheduler::instance().clock(), here_.addr_,
00301             dst_.addr_, v->name(), traceName_, value);
00302         insertOldValue(v, value);
00303     }
00304     n = strlen(wrk);
00305     wrk[n] = '\n';
00306     wrk[n+1] = 0;
00307     (void)Tcl_Write(channel_, wrk, n+1);
00308 }


Public Member Functions
nsaddr_t &	addr ()
void	alloc (int)
virtual void	attachApp (Application *app)
virtual void	close ()
virtual int	command (int argc, const char const argv)
virtual void	connect (nsaddr_t dst)
nsaddr_t &	daddr ()
virtual void	debug (const char *fmt,...)
nsaddr_t &	dport ()
virtual void	drop (Packet *p)
packet_t	get_pkttype ()
void	install (int slot, NsObject *)
int	isdebug () const
virtual void	listen ()
nsaddr_t &	port ()
virtual void	recv (Packet p, const char s)
virtual void	recv (Packet , Handler callback=0)
void	recvOnly (Packet *)
virtual void	send (int nbytes)
virtual void	send (int sz, AppData *data)
void	send (Packet p, Handler h)
virtual void	sendmsg (int nbytes, const char *flags=0)
virtual void	sendmsg (int sz, AppData , const char flags=0)
virtual void	sendto (int nbytes, const char *flags, ns_addr_t dst)
virtual void	sendto (int nbytes, const char *flags, nsaddr_t dst)
virtual void	sendto (int sz, AppData , const char flags, ns_addr_t dst)
virtual void	sendto (int sz, AppData , const char flags, nsaddr_t dst)
void	set_pkttype (packet_t pkttype)
void	setDropTarget (NsObject *dt)
virtual int &	size ()
	SRAgent ()
void	target (NsObject *target)
NsObject *	target ()
virtual void	timeout (int tno)
	~SRAgent ()
Data Fields
int	maxslot_
int	nslot_
int	num_connection
NsObject **	slot_
h_node *	table [10]
Protected Member Functions
void	addAgentTrace (const char *name)
Packet *	allocpkt (int) const
Packet *	allocpkt () const
virtual int	delay_bind_dispatch (const char varName, const char localName, TclObject *tracer)
virtual void	delay_bind_init_all ()
void	deleteAgentTrace ()
virtual void	drop (Packet p, const char s)
void	dumpTracedVars ()
void	handle (Event *)
virtual void	idle ()
void	initpkt (Packet *) const
void	insertOldValue (TracedVar v, const char value)
OldValue *	lookupOldValue (TracedVar *v)
void	monitorAgentTrace ()
virtual void	recvBytes (int bytes)
virtual void	reset ()
virtual void	trace (TracedVar *v)
virtual void	trace_event (char *eventtype)
Protected Attributes
Application *	app_
Tcl_Channel	channel_
int	debug_
int	defttl_
NsObject *	drop_
ns_addr_t	dst_
EventTrace *	et_
int	fid_
int	flags_
ns_addr_t	here_
OldValue *	oldValueList_
int	prio_
int	size_
NsObject *	target_
char *	traceName_
packet_t	type_
Static Protected Attributes
static int	uidcnt_
Private Attributes
Agent *	agent_
int	off_src_

SRAgent Class Reference

Detailed Description

Public Member Functions

Data Fields

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Attributes

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation