NS2.26SourcesOriginal: IPTapAgent class Reference

00052 {
00053   int i = 0;
00054   index = 0;
00055   for (; i < MAX_PACKETS ; i++) {
00056     ident[i] = -1;
00057     offset[i] = -1;
00058   }
00059 
00060 }

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_; }

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 }

00105 {
00106         Tcl& tcl = Tcl::instance();
00107 
00108         if (argc == 2) {
00109                 if (strcmp(argv[1], "network") == 0) {
00110                         tcl.result(name());
00111                         return(TCL_OK);
00112                 } 
00113         }
00114         if (argc == 3) {
00115                 if (strcmp(argv[1], "network") == 0) {
00116                         net_ = (Network *)TclObject::lookup(argv[2]);
00117                         if (net_ != 0) {
00118                                 return(linknet());
00119                         } else {
00120                                 fprintf(stderr,
00121                                 "TapAgent(%s): unknown network %s\n",
00122                                     name(), argv[2]);
00123                                 return (TCL_ERROR);
00124                         }
00125                         return(TCL_OK);
00126                 }       
00127         }
00128         return (Agent::command(argc, argv));
00129 }

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 }

00201 {
00202         /*
00203          * Just process one packet.  We could put a loop here
00204          * but instead we allow the dispatcher to call us back
00205          * if there is a queue in the socket buffer; this allows
00206          * other events to get a chance to slip in...
00207          */
00208 #ifdef notdef
00209 Scheduler::instance().sync();   // sim clock gets set to now
00210 #endif
00211         recvpkt();
00212 }

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 }

00093 {
00094   register int sum = 0;
00095   u_short answer = 0;
00096   register u_short *w = addr;
00097   register int nleft = len;
00098   
00099   /*
00100    * Our algorithm is simple, using a 32 bit accumulator (sum), we add
00101    * sequential 16 bit words to it, and at the end, fold back all the
00102    * carry bits from the top 16 bits into the lower 16 bits.
00103    */
00104   while (nleft > 1)  {
00105     sum += *w++;
00106     nleft -= 2;
00107   }
00108   
00109   /* mop up an odd byte, if necessary */
00110   if (nleft == 1) {
00111     *(u_char *)(&answer) = *(u_char *)w ;
00112     sum += answer;
00113   }
00114   
00115   /* add back carry outs from top 16 bits to low 16 bits */
00116   sum = (sum >> 16) + (sum & 0xffff);     /* add hi 16 to low 16 */
00117   sum += (sum >> 16);                     /* add carry */
00118   answer = ~sum;                          /* truncate to 16 bits */
00119   return(answer);
00120   
00121 }

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 }

00061 { return debug_; }

00073 {
00074   int i = 0;
00075   for( ; i < MAX_PACKETS; i++){
00076     if ((ident[i] == id) && (offset[i] == off)) {
00077       return 1;
00078     }
00079   }
00080   ident[index % MAX_PACKETS] = id;
00081   offset[index % MAX_PACKETS] = off;
00082   index++;
00083   return 0;
00084 }

00059 {
00060         int mode = net_->mode();
00061         int rchan = net_->rchannel();
00062         int wchan = net_->schannel();
00063 
00064         unlink();
00065         if (mode == O_RDONLY || mode == O_RDWR) {
00066                 // reading enabled?
00067                 if (rchan < 0) {
00068                         fprintf(stderr,
00069                 "TapAgent(%s): network %s not open for reading (mode:%d)\n",
00070                             name(), net_->name(), mode);
00071                         return (TCL_ERROR);
00072                 }
00073                 link(rchan, TCL_READABLE);
00074                 TDEBUG3("TapAgent(%s): linked sock %d as READABLE\n",
00075                         name(), rchan);
00076         } else if (mode != O_WRONLY) {
00077                 if (mode == -1) {
00078                         fprintf(stderr,
00079                            "TapAgent(%s): Network(%s) not opened properly.\n",
00080                                 name(), net_->name());
00081                         fprintf(stderr,
00082                            "(choose: readonly, readwrite, or writeonly)\n");
00083                 } else {
00084                         fprintf(stderr,
00085                             "TapAgent(%s): unknown mode %d in Network(%s)\n",
00086                                 name(), mode, net_->name());
00087                 }
00088                 return (TCL_ERROR);
00089         }
00090 
00091         if (mode == O_WRONLY || mode == O_RDWR) {
00092                 // writing enabled?
00093                 if (wchan < 0) {
00094                         fprintf(stderr,
00095                         "TapAgent(%s): network %s not open for writing\n",
00096                             name(), net_->name());
00097                         return (TCL_ERROR);
00098                 }
00099         }
00100         return (TCL_OK);
00101 }

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 }

00076 { return Scheduler::instance().clock(); }

00125 {
00126   IPTapAgent *inst = (IPTapAgent *)clientdata;
00127   inst->processpkt(p, ts);
00128 }

00097 { return here_.port_; }

00132 {
00133   struct ip *ipheader;
00134   struct tcphdr *tcpheader;
00135   unsigned char *buf;
00136   
00137   /* Ip header information from the grabbed packet. */
00138   int iphlen;  
00139   unsigned short datagramlen;
00140   unsigned char ttl;
00141   
00142   /* TCP header info from the grabbed packet. */
00143   unsigned char tcphlen;
00144   
00145   /* 
00146      At this point, all I have to do is to grab the ttl value 
00147      from the received packet and put it in p's ttl field after
00148      decrementing it. It's ok, if we don't recalculate the checksum
00149      of the actual packet, because we'll do it at the end anyways.
00150   */
00151 
00152   ipheader = (struct ip *) p->accessdata();
00153   buf = p->accessdata();
00154   iphlen = ipheader->ip_hl * 4;
00155   ttl = ipheader->ip_ttl;
00156   if (!(--ttl)) {
00157     fprintf(stderr,
00158             "IPTapAgent(%s) : received ttl zero.\n",
00159             name());
00160     Packet::free(p);
00161     return;
00162   }
00163 
00164    /* Removed test for isDuplicate on 08/19/02 
00165     * Recommend adding ether dst or adding not ether src instead 
00166     * since at high packet rates the test cannot keep up and results 
00167     * in losing packets */
00168   /* Discard if duplicate. */
00169   /* if (isDuplicate(ntohs(ipheader->ip_id), ntohs(ipheader->ip_off))) {
00170     Packet::free(p);
00171     return;
00172     } */ 
00173   
00174   datagramlen = ntohs(ipheader->ip_len);
00175 
00176   /* Put all the info in the ns headers. */
00177   hdr_cmn *ch = HDR_CMN(p);
00178   ch->size() = datagramlen;
00179 
00180   hdr_ip *ih = HDR_IP(p);
00181   ih->ttl() = ttl;
00182 
00183   // inject into simulator
00184   target_->recv(p);
00185   return;
00186 }

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

00224 {
00225         (void) sendpkt(p);
00226         Packet::free(p);
00227         return;
00228 }

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

00199 {
00200   if (net_->mode() != O_RDWR && net_->mode() != O_RDONLY) {
00201     fprintf(stderr,
00202             "IPTapAgent(%s): recvpkt called while in write-only mode!\n",
00203             name());
00204     return;
00205   }
00206   
00207   int cc = net_->recv(pkt_handler, this);
00208   if (cc <= 0) {
00209     if (cc < 0) {
00210       perror("recv");
00211     }
00212     return;
00213   }
00214   TDEBUG4("%f: IPTapAgent(%s): recvpkt, cc:%d\n", now(), name(), cc);
00215 
00216   // nothing to do coz pkt_handler would have called processpkt()
00217   // that would have injected packets into the simulator
00218 
00219 }

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 }

00232 {
00233   int byteswritten;
00234   unsigned char *packet;
00235   unsigned char received_ttl;
00236   unsigned short dglen;
00237   struct ip *ipheader;
00238 
00239   if (net_->mode() != O_RDWR && net_->mode() != O_WRONLY) {
00240     fprintf(stderr,
00241             "IPTapAgent(%s): sendpkt called while in read-only mode!\n",
00242             name());
00243     return (-1);
00244   }
00245   
00246   // send packet into the live network
00247   hdr_cmn* hc = HDR_CMN(p);
00248   if (net_ == NULL) {
00249     fprintf(stderr,
00250             "IPTapAgent(%s): sendpkt attempted with NULL net\n",
00251             name());
00252     drop(p);
00253     return (-1);
00254   }
00255   
00256   /*
00257     At this point, we should grab the ttl field from the ns
00258     packet, put it in the IP header of the actual packet,
00259     recalculate the checksum and send the packet on it's
00260     way (hoping that anything else in the packet hasn't got
00261     corrupted.
00262   */
00263 
00264   /* Grab the info from the ns packet. */
00265   hdr_ip  *ih = HDR_IP(p);
00266   received_ttl = ih->ttl_;
00267   if (!received_ttl) {
00268     /* Should drop the packet if ttl is zero. */
00269     fprintf(stderr,
00270             "IPTapAgent(%s): received packet ttl zero.\n",
00271             name());
00272     drop(p);
00273     return(-1);
00274   }
00275 
00276 
00277   /* Modify the original packet with the new info. */
00278   packet = p->accessdata();
00279   ipheader = (struct ip *) packet;
00280   ipheader->ip_ttl = received_ttl;
00281   ipheader->ip_sum = 0;
00282   ipheader->ip_sum = (unsigned short) in_cksum((unsigned short *) ipheader,
00283                                                 sizeof(struct ip));
00284 
00285   if (net_->send(p->accessdata(), hc->size()) < 0) {
00286     fprintf(stderr,
00287             "IPTapAgent(%s): sendpkt (%p, %d): %s\n",
00288             name(), p->accessdata(), hc->size(), strerror(errno));
00289     Packet::free(p);
00290     return (-1);
00291     
00292   }
00293   Packet::free(p);
00294   TDEBUG3("IPTapAgent(%s): sent packet (sz: %d)\n",
00295           name(), hc->size());
00296   return 0;
00297 }

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
	IPTapAgent ()
int	command (int, const char const )
void	recv (Packet p, Handler )
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,...)
Protected Member Functions
void	dispatch (int)
int	linknet ()
double	now ()
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
int	maxpkt_
Network *	net_
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
unsigned short	in_cksum (unsigned short *, int)
void	recvpkt ()
int	sendpkt (Packet *)
int	isDuplicate (unsigned short, unsigned short)
void	processpkt (Packet *, const struct timeval &)
Static Private Member Functions
void	pkt_handler (void , Packet , const struct timeval &)
Private Attributes
int	ident [MAX_PACKETS]
int	offset [MAX_PACKETS]
int	index

IPTapAgent Class Reference

Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation