NS2.26SourcesOriginal: 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 }

00096 { 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 }

00518 {
00519         Packet* p = allocpkt();
00520 
00521         if (n > 0)
00522                 p->allocdata(n);
00523 
00524         return(p);
00525 }

00507 {
00508         Packet* p = Packet::alloc();
00509         initpkt(p);
00510         return (p);
00511 }

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 }

00098 { 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 }

00099 { 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 }

00101 { return type_; }

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

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

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

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 }

00097 { 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 }

00089 { 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 }

00409 {
00410         fprintf(stderr, 
00411         "Agent::sendmsg(int, AppData*, const char*) not implemented\n");
00412         abort();
00413 }

00100 { type_ = pkttype; }

00095 { return size_; }

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
void	install (int slot, NsObject *)
void	alloc (int)
virtual int	command (int argc, const char const argv)
virtual void	recv (Packet , Handler callback=0)
	SRAgent ()
	~SRAgent ()
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,...)
Public Attributes
h_node *	table [10]
int	num_connection
NsObject **	slot_
int	nslot_
int	maxslot_
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 Attributes
int	off_src_
Agent *	agent_

SRAgent Class Reference

Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Attributes

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation