trace.cc

NS2网络仿真软件是目前最为流行的网络仿真模拟软件

			 * call dump ourselves for all but the last chunk.
			 */
			assert (sctph->NumChunks() >= 1);
			if(i < sctph->NumChunks() - 1)
				pt_->dump();
		}
	} else if (!show_tcphdr_) {
		sprintf(pt_->buffer(), "%c "TIME_FORMAT" %d %d %s %d %s %d %s.%s %s.%s %d %d",
			tt,
			pt_->round(Scheduler::instance().clock()),
			s,
			d,
			name,
			th->size(),
			flags,
			iph->flowid() /* was p->class_ */,
			// iph->src() >> (Address::instance().NodeShift_[1]), 
                        // iph->src() & (Address::instance().PortMask_), 
                        // iph->dst() >> (Address::instance().NodeShift_[1]), 
                        // iph->dst() & (Address::instance().PortMask_),
			src_nodeaddr,
			src_portaddr,
			dst_nodeaddr,
			dst_portaddr,
			seqno,
			th->uid() /* was p->uid_ */);
	} else {
		sprintf(pt_->buffer(), 
			"%c "TIME_FORMAT" %d %d %s %d %s %d %s.%s %s.%s %d %d %d 0x%x %d %d",
			tt,
			pt_->round(Scheduler::instance().clock()),
			s,
			d,
			name,
			th->size(),
			flags,
			iph->flowid(), /* was p->class_ */
		        // iph->src() >> (Address::instance().NodeShift_[1]), 
			// iph->src() & (Address::instance().PortMask_), 
  		        // iph->dst() >> (Address::instance().NodeShift_[1]), 
  		        // iph->dst() & (Address::instance().PortMask_),
			src_nodeaddr,
			src_portaddr,
			dst_nodeaddr,
			dst_portaddr,
			seqno,
			th->uid(), /* was p->uid_ */
			tcph->ackno(),
			tcph->flags(),
			tcph->hlen(),
			tcph->sa_length());
	}
	if (pt_->namchannel() != 0)
		sprintf(pt_->nbuffer(), 
			"%c -t "TIME_FORMAT" -s %d -d %d -p %s -e %d -c %d -i %d -a %d -x {%s.%s %s.%s %d %s %s}",
			tt,
			Scheduler::instance().clock(),
			s,
 			d,
			name,
			th->size(),
			iph->flowid(),
			th->uid(),
			iph->flowid(),
			src_nodeaddr,
			src_portaddr,
			dst_nodeaddr,
			dst_portaddr,
			seqno,flags,sname);
	delete [] src_nodeaddr;
  	delete [] src_portaddr;
  	delete [] dst_nodeaddr;
   	delete [] dst_portaddr;
}

void Trace::recv(Packet* p, Handler* h)
{
	format(type_, src_, dst_, p);
	pt_->dump();
	callback();
	pt_->namdump();
	/* hack: if trace object not attached to anything free packet */
	if (target_ == 0)
		Packet::free(p);
	else
		send(p, h);
}

void Trace::recvOnly(Packet *p)
{
	format(type_, src_, dst_, p);
	pt_->dump();
	callback();
	pt_->namdump();	
	target_->recvOnly(p);
}

void Trace::trace(TracedVar* var)
{
	char tmp[256] = "";
	Scheduler& s = Scheduler::instance();
	if (&s == 0)
		return;

	if (pt_->tagged()) {
		sprintf(pt_->buffer(), "%c "TIME_FORMAT" -a %s -n %s -v %s",
			type_,
			pt_->round(s.clock()),
			var->owner()->name(),
			var->name(),
			var->value(tmp, 256));
	} else {
		// format: use Mark's nam feature code without the '-' prefix
		sprintf(pt_->buffer(), "%c t"TIME_FORMAT" a%s n%s v%s",
			type_,
			pt_->round(s.clock()),
			var->owner()->name(),
			var->name(),
			var->value(tmp, 256));
	}
	pt_->dump();
	callback();
}

void Trace::callback() 
{
	if (callback_) {
		Tcl& tcl = Tcl::instance();
		tcl.evalf("%s handle { %s }", name(), pt_->buffer());
	}
}

//
// we need a DequeTraceClass here because a 'h' event need to go together
// with the '-' event. It's possible to use a postprocessing script, but 
// seems that's inconvient.
//
static class DequeTraceClass : public TclClass {
public:
	DequeTraceClass() : TclClass("Trace/Deque") { }
	TclObject* create(int args, const char*const* argv) {
		if (args >= 5)
			return (new DequeTrace(*argv[4]));
		return NULL;
	}
} dequetrace_class;


DequeTrace::~DequeTrace()
{
}

void 
DequeTrace::recv(Packet* p, Handler* h)
{
	// write the '-' event first
	format(type_, src_, dst_, p);
	pt_->dump();
	callback();
	pt_->namdump();

	if (pt_->namchannel() != 0 ||
	    (pt_->tagged() && pt_->channel() !=0)) {
		hdr_cmn *th = hdr_cmn::access(p);
		hdr_ip *iph = hdr_ip::access(p);
		hdr_srm *sh = hdr_srm::access(p);
		const char* sname = "null";   

		packet_t t = th->ptype();
		const char* name = packet_info.name(t);
		
		if (strcmp(name,"SRM") == 0 || strcmp(name,"cbr") == 0 || strcmp(name,"udp") == 0) {
		    if ( sh->type() < 5 && sh->type() > 0  ) {
		        sname = srm_names[sh->type()];
		    }
		}   

		char *src_nodeaddr = Address::instance().print_nodeaddr(iph->saddr());
		char *src_portaddr = Address::instance().print_portaddr(iph->sport());
		char *dst_nodeaddr = Address::instance().print_nodeaddr(iph->daddr());
		char *dst_portaddr = Address::instance().print_portaddr(iph->dport());

		char flags[NUMFLAGS+1];
		for (int i = 0; i < NUMFLAGS; i++)
			flags[i] = '-';
		flags[NUMFLAGS] = 0;

		hdr_flags* hf = hdr_flags::access(p);
		flags[0] = hf->ecn_ ? 'C' : '-';          // Ecn Echo
		flags[1] = hf->pri_ ? 'P' : '-'; 
		flags[2] = '-';
		flags[3] = hf->cong_action_ ? 'A' : '-';   // Congestion Action
		flags[4] = hf->ecn_to_echo_ ? 'E' : '-';   // Congestion Experienced
		flags[5] = hf->fs_ ? 'F' : '-';
		flags[6] = hf->ecn_capable_ ? 'N' : '-';
		flags[7] = 0; // only for SCTP
	
#ifdef notdef
		flags[1] = (iph->flags() & PF_PRI) ? 'P' : '-';
		flags[2] = (iph->flags() & PF_USR1) ? '1' : '-';
		flags[3] = (iph->flags() & PF_USR2) ? '2' : '-';
		flags[5] = 0;
#endif
		
		if(!btTrace_)
		{
			if (pt_->nbuffer() != 0) {
				sprintf(pt_->nbuffer(), 
					"%c -t "TIME_FORMAT" -s %d -d %d -p %s -e %d -c %d -i %d -a %d -x {%s.%s %s.%s %d %s %s}",
					'h',
					Scheduler::instance().clock(),
					src_,
  					dst_,
					name,
					th->size(),
					iph->flowid(),
					th->uid(),
					iph->flowid(),
					src_nodeaddr,
					src_portaddr,
					dst_nodeaddr,
					dst_portaddr,
					-1, flags, sname);
				pt_->namdump();
			}
			if (pt_->tagged() && pt_->buffer() != 0) {
				sprintf(pt_->buffer(), 
					"%c "TIME_FORMAT" -s %d -d %d -p %s -e %d -c %d -i %d -a %d -x {%s.%s %s.%s %d %s %s}",
					'h',
					Scheduler::instance().clock(),
					src_,
	  				dst_,
					name,
					th->size(),
					iph->flowid(),
					th->uid(),
					iph->flowid(),
					src_nodeaddr,
					src_portaddr,
					dst_nodeaddr,
					dst_portaddr,
					-1, flags, sname);
				pt_->dump();
			}
		}
		else
		{
 			hdr_bt* bt = (struct hdr_bt*)(p)->access(hdr_bt::offset_);
 			unsigned char print = 0;
 			//string c = PacketColors[bt->type];
 			int colorindex = bt->type;
 			if (dst_ == 0 && !(bt->dir)) {
 				src_ = bt->sendId_;
 				print = 1;
 				//c = "red";
 			}
 			else if (dst_ && bt->dir) {
 				if (!(bt->am_addr) || bt->recvId_ == dst_) {
 					print = 1;
 					//c = "green";
 				}
 			}	
			//const char* color = c.c_str();
			if (print && pt_->nbuffer()) {
				sprintf(pt_->nbuffer(), 
 					"%c -t "TIME_FORMAT" -s %d -d %d -p %s -e %d -c %d -i %d -a %d -x {%s.%s %s.%s %d %s %s}",
 					'h',
 					Scheduler::instance().clock(),
 					src_,
 					dst_,
 					name,
 					th->size(),
 					iph->flowid(),
 					th->uid(),
 					/*iph->flowid(),*/
 					colorindex,
 					src_nodeaddr,
 					src_portaddr,
 					dst_nodeaddr,
 					dst_portaddr,
 					-1, flags, sname);
 				pt_->namdump();
 			}
		}
 		delete [] src_nodeaddr;
 		delete [] src_portaddr;
 		delete [] dst_nodeaddr;
 		delete [] dst_portaddr;
	}

	/* hack: if trace object not attached to anything free packet */
	if (target_ == 0)
		Packet::free(p);
	else
		send(p, h);
}

 
 static class BTNodeTraceClass : public TclClass {
 public:
 	BTNodeTraceClass() : TclClass("Trace/BTNodeColor") { }
 	TclObject* create(int , const char*const*) {
 		return (new BTNodeTrace());
 	}
 } btnodetrace_class;
 
 void
 BTNodeTrace::recv(Packet* p, Handler* h)
 {
 	target_->recv(p,h);
 }
 
 void
 BTNodeTrace::changeNodeColor (state_type curr, state_type prev)
 {
 	string s = StateName[curr];
 	string s1 = StateName[prev];
 	string c_new = ColorName[curr];
 	string c_old = ColorName[prev];
 	const char* name = s.c_str();
 	const char* name1 = s1.c_str();
 	const char* color_new = c_new.c_str();
 	const char* color_old = c_old.c_str();
	if (pt_->nbuffer() != 0) 
	{
 		sprintf(pt_->nbuffer(), 
 			"%c -t "TIME_FORMAT" -s %d -S COLOR -c %s -o %s",
 			'n',
 			Scheduler::instance().clock(),
 			src_,
 			color_new,
 			color_old);
 		pt_->namdump();
 		sprintf(pt_->nbuffer(), 
 			"%c -t "TIME_FORMAT" -s %d -S DLABEL -l %s -L %s",
 			'n',
 			Scheduler::instance().clock(),
 			src_,
 			name, name1);
 		pt_->namdump();
	}
 }
 
 BTNodeTrace::~BTNodeTrace()
 {
  }