Encapsulator.cc:		if (strcmp(argv[1], "decap-target") == 0) {
Encapsulator.cc:		if (strcmp(argv[1], "decap-target") == 0) {
Encapsulator.cc:		Packet *copy_p= p->copy();
Encapsulator.cc:		//Packet** pp= (Packet**) encap_p->accessdata();
Encapsulator.cc: 		ch_e->size()= ch_p->size() + overhead_;
Encapsulator.cc:		ch_e->timestamp()= ch_p->timestamp();
ack-recons.cc: * the TCP source (e.g., like those implemented in tcp-asym.cc).  
ack-recons.cc:		  ip->saddr(), ip->daddr());
actp-adc.cc:	"@(#) $Header: /nfs/jade/vint/CVSROOT/ns-2/actp-adc.cc,v 1.5 1999/02/12 22:01:30 breslau Exp $";
agent.cc:                } else if (strcmp(argv[1], "dump-namtracedvars") == 0) {
agent.cc:	while ((p != NULL) && (p->var_ != v))
agent.cc:		p = p->next_;
agent.cc:	strncpy(p->val_, value, min(strlen(value)+1, TRACEVAR_MAXVALUELENGTH));
agent.cc:	p->var_ = v;
agent.cc:	p->next_ = NULL;
agent.cc:		p->next_ = oldValueList_;
agent.cc:	        p->allocdata(n);
bi-connector.cc:		if (strcmp(argv[1], "up-target") == 0) {
bi-connector.cc:		if (strcmp(argv[1], "drop-target") == 0) {
bi-connector.cc:		if (strcmp(argv[1], "up-target") == 0) {
bi-connector.cc:		if (strcmp(argv[1], "drop-target") == 0) {
cbq.cc://	top-level link-sharing:
cbq.cc://			<= the value of "top-level"
cbq.cc:	int		toplevel_;		// for top-level LS
cbq.cc:	} else if (*arg == '1' || (strcmp(arg, "top-level") == 0)) {
cbq.cc:			if (!p->satisfied(now))
cbq.cc:			p = p->level_peer_;
cbq.cc:	p->cbq_ = this;
cbq.cc:	if (p->pri_ < 0 || p->pri_ > (MAXPRIO-1)) {
cbq.cc:			p->name(), p->pri_);
cbq.cc:	if (p->q_ != NULL) {
cbq.cc:		if (active_[p->pri_] != NULL) {
cbq.cc:			p->peer_ = active_[p->pri_]->peer_;
cbq.cc:			active_[p->pri_]->peer_ = p;
cbq.cc:			p->peer_ = p;
cbq.cc:			active_[p->pri_] = p;
cbq.cc:		if (p->pri_ > maxprio_)
cbq.cc:			maxprio_ = p->pri_;
cbq.cc:	if (p->allotment_ < 0.0 || p->allotment_ > 1.0) {
cbq.cc:			p->name(), p->allotment_);
cbq.cc:	p->maxrate_ = p->allotment_ * (link_->bandwidth() / 8.0);
cbq.cc:	addallot(p->pri_, p->allotment_);
cbq.cc:	if (p->level_ <= 0 || p->level_ > MAXLEVEL) {
cbq.cc:			p->name(), p->level_);
cbq.cc:	p->level_peer_ = levels_[p->level_];
cbq.cc:	levels_[p->level_] = p;
cbq.cc:	if (p->level_ > maxlevel_)
cbq.cc:		maxlevel_ = p->level_;
cbq.cc:	++cnt_[p->pri_];
cbq.cc:	for (; p != NULL; p = p->level_peer_) {
cbq.cc:		if (p->demand() && ancestor(p))
cbq.cc:	if (!p->permit_borrowing_ || p->lender_ == NULL)
cbq.cc:	else if (p->lender_ == this)
cbq.cc:	return (ancestor(p->lender_));
channel.cc:	Node *tnode = tifp->node();
channel.cc:		  newp = p->copy();
channel.cc:		  for(; rifp; rifp = rifp->nextnode()){
channel.cc:			  if (rifp->channel() == this){
channel.cc:	    for( ; rifp; rifp = rifp->nextchnl()) {
channel.cc:		rnode = rifp->node();
channel.cc:		newp = p->copy();
chost.cc:#include "tcp-int.h"
classifier-bst.cc:		if (p->iif == ANY_IFACE.value()) // || iface == UNKN_IFACE.value())
classifier-bst.cc:			return p->slot;
classifier-bst.cc:	return p->slot;
classifier-bst.cc:	if ((node_id_ != src) && (ump->isSet) && (ump->umpID_ != node_id_)) {
classifier-bst.cc:			ump->isSet = 0;
classifier-bst.cc:		ump->isSet = 1;
classifier-bst.cc:		ump->umpID_ = node_id_;
classifier-bst.cc:// 	if (ump->isSet) {
classifier-bst.cc:// 		if (ump->umpID_ != node_id_) {
classifier-bst.cc:// 			ump->isSet = 0;
classifier-bst.cc:	if (ump->isSet) {
classifier-bst.cc:			ump->isSet = 0;
classifier-bst.cc:			ump->umpID_ = u_info->node_id;
classifier-bst.cc:			ump->oif = strdup(u_info->oiflink);
classifier-mac.cc:				mac->recv(p->copy(), 0);
classifier-mcast.cc:			hashnode* n = p->next;
classifier-mcast.cc:	for (p = ht_[h]; p != 0; p = p->next) {
classifier-mcast.cc:		if (p->src == src && p->dst == dst)
classifier-mcast.cc: 			if (p->iif == iface ||
classifier-mcast.cc: 			    //p->iif == UNKN_IFACE.value() ||
classifier-mcast.cc:	for (p = ht_star_[h]; p != 0; p = p->next) {
classifier-mcast.cc:		if (p->dst == dst && 
classifier-mcast.cc:		    (iface == ANY_IFACE.value() || p->iif == iface))
classifier-mcast.cc:		if (p->iif == ANY_IFACE.value()) // || iface == UNKN_IFACE.value())
classifier-mcast.cc:			return p->slot;
classifier-mcast.cc:	return p->slot;
classifier-mcast.cc:	p->src = src;
classifier-mcast.cc:	p->dst = dst;
classifier-mcast.cc:	p->slot = slot;
classifier-mcast.cc:	p->iif = iface;
classifier-mcast.cc:	p->next = ht[h];
classifier-mcast.cc:			if ((p == 0) || (slot_[p->slot] == 0))
classifier-mcast.cc:				tcl.resultf("%s", slot_[p->slot]->name());
classifier-mcast.cc:		if (strcmp(argv[1], "lookup-iface") == 0) {
classifier-mcast.cc:			// $classifier lookup-iface $src $group 
classifier-mcast.cc:				tcl.resultf("%d", p->iif);
classifier-mcast.cc:	if (p) p->iif = newiface;
classifier-mcast.cc:	if (p) p->iif = newiface;
classifier.cc:	return (mshift(*((int*) p->access(offset_))));
classifier.cc:        if(p->is_atm())
classifier.cc:        if ((atm) && (p->is_atm()) && (!atmswitch) && (aal->aal_type() == d))
classifier.cc:        else if ((atm) && (atmswitch) && (p->is_atm()))
classifier.cc:        else if ((atm) && (p->is_atm()) && (!atmswitch) && (aal->aal_type() == s)) {
cmu-trace.cc:			rp->rp_type,
cmu-trace.cc:                        rp->rp_hop_count,
cmu-trace.cc:                        rp->rp_dst,
cmu-trace.cc:                        rp->rp_dst_seqno,
cmu-trace.cc:                        rp->rp_lifetime,
cmu-trace.cc:                        rp->rp_type == AODVTYPE_RREP ? "REPLY" :
cmu-trace.cc:                        (rp->rp_type == AODVTYPE_UREP ? "UNSOLICITED REPLY" :
cmu-trace.cc:			rp->rp_type,
cmu-trace.cc:                        rp->rp_hop_count,
cmu-trace.cc:                        rp->rp_dst,
cmu-trace.cc:                        rp->rp_dst_seqno,
cmu-trace.cc:                        rp->rp_lifetime,
cmu-trace.cc:                        rp->rp_type == AODVTYPE_RREP ? "REPLY" :
cmu-trace.cc:                        (rp->rp_type == AODVTYPE_UREP ? "UNSOLICITED REPLY" :
connector.cc:		if (strcmp(argv[1], "drop-target") == 0) {
connector.cc:		if (strcmp(argv[1], "drop-target") == 0) {
delay.cc:	assert(p->time_ == e->time_);
drop-tail.cc:    "@(#) $Header: /nfs/jade/vint/CVSROOT/ns-2/drop-tail.cc,v 1.9 1998/06/27 01:23:44 gnguyen Exp $ (LBL)";
drop-tail.cc:#include "drop-tail.h"
drop-tail.cc: * drop-tail
drr.cc:		for (i=0,tmp=curr; i < flwcnt; i++,tmp=tmp->next) {
drr.cc:			if (maxflow->bcount < tmp->bcount)
energy-model.cc:	for (; np; np = np->next) {
energy-model.cc:		if (np->id == nodeid) {
energy-model.cc:			np->ttl = maxttl_;
energy-model.cc:		np->id = nodeid;
energy-model.cc:		np->ttl = maxttl_;
energy-model.cc:		np->next = neighbor_list.head;
energy-model.cc:		np = lp->next;
energy-model.cc:		for (; np; np = np->next) {
energy-model.cc:			np->ttl--;
energy-model.cc:			if (np->ttl <= 0){
energy-model.cc:				lp->next = np->next;
energy-model.cc:		np->ttl--;
energy-model.cc:		if (np->ttl <= 0) {
energy-model.cc:			neighbor_list.head = np->next;
errmodel.cc:	if (strcmp(argv[1], "drop-packet") == 0) {
errmodel.cc:	if (strcmp(argv[1], "drop-packet") == 0) {
errmodel.cc:		if (strcmp(argv[1], "drop-packet") == 0) {
filter.cc:			filter_target_->recv(p->copy(), h);
filter.cc:	return (*(int *)p->access(offset_) == match_) ? FILTER : PASS;
filter.cc:	p->next = field_list_;
filter.cc:		if (*(int *)p->access(tmpfield->offset) == tmpfield->match)
filter.cc:			tmp->offset = atoi(argv[2]);
filter.cc:			tmp->match = atoi(argv[3]);
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 4;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 4;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 6;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 8;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 4;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 6;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 8;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 10;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 12;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 14;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 16;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 1;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 1;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 3;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 4;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 5;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 6;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 7;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 7;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 1;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 3;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 4;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 5;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 5;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 6;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 1;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 4;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 4;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 5;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 6;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 1;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 4;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 5;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 6;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 1;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 4;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 6;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 1;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 4;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 4;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 4;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 6;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 8;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 4;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 6;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 8;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 10;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 6;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 12;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 14;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 16;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 1;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 1;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 3;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 4;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 5;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 6;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 7;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 7;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 3;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 3;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 4;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 5;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 6;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 4;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 4;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 5;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 6;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 1;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 5;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 6;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 7;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 1;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 6;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 7;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 7;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 3;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 3;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 5;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 3;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 5;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 6;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 8;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 3;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 5;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 6;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 8;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 9;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 11;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 12;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 1;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 1;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 3;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 3;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 4;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 4;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 5;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 6;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 1;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 3;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 3;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 4;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 4;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 5;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 1;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 3;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 4;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 4;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 1;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 3;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 5;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 1;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 3;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 3;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 5;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 3;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 5;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 6;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 3;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 8;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 3;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 4;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 4;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 1;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 8;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 9;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 11;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 12;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 1;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 1;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 3;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 3;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 4;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 4;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 5;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 6;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 2;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 3;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 4;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 4;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 4;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 5;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 3;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 4;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 4;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 5;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 5;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 4;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 4;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 5;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 5;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 5;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 5;
fsm.cc:		tmp->drop_[i] = NULL;
fsm.cc:		tmp->transition_[i] = -1;
fsm.cc:	tmp->batch_size_ = 6;
ivs.cc:		return (hdr_ivs*) p->access(offset_);
ivs.cc:	p->ts() = Scheduler::instance().clock();
ivs.cc:	p->S() = S_;
ivs.cc:	p->R() = R_;
ivs.cc:	p->state() = state_;
ivs.cc:	p->rshft() = rttShift_;
ivs.cc:	p->kshft() = keyShift_;
ivs.cc:	p->key() = key_;
ivs.cc:	p->maxrtt() = maxrtt_;
ivs.cc:	double ts = p->ts();
ivs.cc:	state_ = lossMeter(now - ts, p->seqno(), p->maxrtt());
ivs.cc:	if (p->R() && !ignoreR_)
ivs.cc:		upcall_rtt_solicit(ts, p->rshft());
ivs.cc:	if (now - lastTime_ < p->maxrtt() && state_ <= prevState) {
ivs.cc:	int shift = p->kshft();
ivs.cc:	if (p->key() == 0)
ivs.cc:		match = (key_ >> shift) == (p->key() >> shift);
ivs.cc:	int matchS = match ? p->S() : 0;
ivs.cc:			if (n >= p->maxmsg()) {
ivs.cc:			strcpy(p->msg(), s);
ll.cc:		if (strcmp(argv[1], "up-target") == 0) {
ll.cc:		if (strcmp(argv[1], "up-target") == 0) {
ll.cc:	if(p->incoming) {
ll.cc:                p->incoming = 0;
ll.cc:	char *mh = (char*)p->access(hdr_mac::offset_);
loss-monitor.cc:	seqno_ = p->seqno();
mac-802_11.cc:        downtarget_->recv(p->copy(), this);                             \
mac-802_11.cc:	mhDefer_(this, p->SlotTime), mhBackoff_(this, p->SlotTime)
mac-802_11.cc:	if(p->txinfo_.Pr < p->txinfo_.ant.RXThresh) {
mac-802_11.cc:	struct rts_frame *rf = (struct rts_frame*)p->access(hdr_mac::offset_);
mac-802_11.cc:	struct cts_frame *cf = (struct cts_frame*)p->access(hdr_mac::offset_);
mac-802_11.cc:	struct ack_frame *af = (struct ack_frame*)p->access(hdr_mac::offset_);
mac-802_11.cc:		if(pktRx_->txinfo_.RxPr / p->txinfo_.RxPr >= p->txinfo_.CPThresh) {
mac-802_11.cc:	struct rts_frame *rf = (struct rts_frame*)p->access(hdr_mac::offset_);
mac-802_11.cc:	p->incoming = 1;
mac-802_3.cc:	downtarget_->recv(p->copy()); 
mac-multihop.cc:	     p = (MultihopMac *)(p->macList())) {
mac-multihop.cc:		if (p->mode() != MAC_IDLE) {
mac-multihop.cc:	pkt_ = p->copy();	/* local copy for poll retries */
mac.cc:	char* mh = (char*)p->access(hdr_mac::offset_);
mftp_rcv.cc:    unsigned char* nak_bitmap = (unsigned char*) p->accessdata();
mftp_rcv.cc:        tcl.evalf("%s recv group-full %lu %lu %s",
mftp_snd.cc:            process_nak(mh->spec.nak, p->accessdata(), CurrentPass-1); // -1 because we have
mip-reg.cc:// $Header: /nfs/jade/vint/CVSROOT/ns-2/mip-reg.cc,v 1.7 2000/09/01 03:04:06 haoboy Exp $
mip-reg.cc:// #ident "@(#)mip-reg.cc  1.4     98/08/30 SMI"
mip-reg.cc:	      tcl.evalf("%s encap-route %d %d %lf", name_,
mip-reg.cc:	  tcl.evalf("%s decap-route %d %s %lf", name_, miph->haddr_,
mobilenode.cc:			phyp->insertnode(&ifhead_);
mobilenode.cc:			phyp->setnode(this);
mobilenode.cc:		gp-> new_moves(this);
node.cc:			slhp->insertlink(&linklisthead_);
node.cc:	for (; lhp; lhp = lhp->nextlinkhead()) 
node.cc:		if (label == lhp->label())
ping.cc:            hdrip->src_.addr_ >> Address::instance().NodeShift_[1], 
priqueue.cc:#include <drop-tail.h>
priqueue.cc:	for(p = q_->head(); p; p = p->next_) {
propagation.cc:	double L = ifp->getL();		// system loss
propagation.cc:	double lambda = ifp->getLambda();   // wavelength
queue.cc:	for (Packet *pp= 0, *p= head_; p; pp= p, p= p->next_) {
queue.cc:				pp->next_= p->next_;
red-pd.cc:		if (strcmp(argv[1], "mon-edrop-trace") == 0) {
red-pd.cc:		//$queue mon-edrop-trace $trace
red-pd.cc:		else if (strcmp(argv[1], "mon-edrop-trace") == 0) {
red.cc: *   or drop-tail when/if the queue overflows, and 
red.cc:	//	_RENAMED("drop-tail_", "drop_tail_");
red.cc:	//	_RENAMED("drop-front_", "drop_front_");
red.cc:	//	_RENAMED("drop-rand_", "drop_rand_");
red.cc:		if (strcmp(argv[1], "early-drop-target") == 0) {
red.cc:		if (strcmp(argv[1], "edrop-trace") == 0) {
red.cc:		if (strcmp(argv[1], "early-drop-target") == 0) {
red.cc:		if (strcmp(argv[1], "edrop-trace") == 0) {
replicator.cc:			o->recv(p->copy());
rio.cc: *   or drop-tail when/if the queue overflows, and 
rlm.cc:	srcpkt* n = p->next;
rlm.cc:	t += n->off - p->off;
rlm.cc:	IPHeader *iph = IPHeader::access(p->bits());
rlm.cc:	RLMHeader *rh = RLMHeader::access(p->bits());
rlm.cc:	sp->next = 0;
rlm.cc:	sp->off = off;
rlm.cc:	sp->size = size;
rlm.cc:	sp->level = level;
rlm.cc:		if (sp->off < (*p)->off)
route.cc:		sprintf(address,"%d.%d.%d", src[0]-1, src[1]-1, next_hop-1);
rtqueue.cc:	p->next_ = 0;
rtqueue.cc:                prev->next_ = p->next_;
rtqueue.cc:	for(p = head_; p; p = p->next_) {
rtqueue.cc:	for(p = head_; p; p = p->next_) {
sathandoff.cc:	for (lhp = np->linklisthead().lh_first; lhp; 
sathandoff.cc:	    lhp = lhp->nextlinkhead() ) {
sathandoff.cc:		if (slhp->type() == LINK_ISL_CROSSSEAM) {
sathandoff.cc:			if (!slhp->phy_tx()->channel() && 
sathandoff.cc:			    !slhp->phy_rx()->channel() ) 
sathandoff.cc:	schan_ = (SatChannel*) slhp->phy_tx()->channel();
sathandoff.cc:		printf("connected link on node %d\n", slhp->node()->address());
sathandoff.cc:		printf("Error:  node %d's tx phy ", slhp->node()->address());
sathandoff.cc:	schan_ = (SatChannel*) slhp->phy_tx()->channel();
sathandoff.cc:		// printf("Error:  node %d's tx phy ", slhp->node()->address());
sathandoff.cc:	    slhp = (SatLinkHead*) slhp->nextlinkhead() ) {
sathandoff.cc:		if (slhp->type() == LINK_GSL_GEO || 
sathandoff.cc:		    slhp->type() == LINK_GENERIC)
sathandoff.cc:		if (slhp->type() != LINK_GSL_POLAR) {
sathandoff.cc:			printf("not valid %d NOW %f\n", slhp->type(), NOW);
sathandoff.cc:			    earth_coord, mask_) && slhp->linkup_) {
sathandoff.cc:				slhp->linkup_ = FALSE;
sathandoff.cc:				slhp->phy_rx()->removechnl();
sathandoff.cc:				slhp->phy_tx()->setchnl(0);
sathandoff.cc:				slhp->phy_rx()->setchnl(0);
sathandoff.cc:		if (!slhp->linkup_) {
sathandoff.cc:				    nodep = nodep->nextnode()) {
sathandoff.cc:				slhp->linkup_ = TRUE;
sathandoff.cc:				// Point slhp->phy_tx to peer_'s inlink
sathandoff.cc:				slhp->phy_tx()->setchnl(peer_->uplink());
sathandoff.cc:				// Point slhp->phy_rx to peer_'s outlink and
sathandoff.cc:				slhp->phy_rx()->setchnl(peer_->downlink());
sathandoff.cc:				slhp->phy_rx()->insertchnl(&(peer_->downlink()->ifhead_));
sathandoff.cc:	    slhp = (SatLinkHead*) slhp->nextlinkhead() ) {
sathandoff.cc:		if (slhp->type() != LINK_ISL_CROSSSEAM)  
sathandoff.cc:		pos_ = (PolarSatPosition*)slhp->node()->position(); 
sathandoff.cc:			peer_slhp->phy_rx()->removechnl();
sathandoff.cc:			peer_slhp->phy_tx()->setchnl(0);
sathandoff.cc:			peer_slhp->phy_rx()->setchnl(0);
sathandoff.cc:			tx_channel_ = slhp->phy_tx()->channel();
sathandoff.cc:			rx_channel_ = slhp->phy_rx()->channel();
sathandoff.cc:                        peer_next_slhp->phy_tx()->setchnl(rx_channel_);
sathandoff.cc:			peer_next_slhp->phy_rx()->setchnl(tx_channel_);
sathandoff.cc:			peer_next_slhp->phy_rx()->insertchnl(&(tx_channel_->ifhead_));
sathandoff.cc:		if ((slhp->linkup_ || peer_slhp->linkup_) && link_down_flag_) {
sathandoff.cc:			slhp->linkup_ = FALSE;
sathandoff.cc:			peer_slhp->linkup_ = FALSE;
sathandoff.cc:		} else if ((!slhp->linkup_  || !peer_slhp->linkup_) && 
sathandoff.cc:			slhp->linkup_ = TRUE;
sathandoff.cc:			peer_slhp->linkup_ = TRUE;
sathandoff.cc:	    slhp = (SatLinkHead*) slhp->nextlinkhead() ) {
sathandoff.cc:		if (slhp->type() != LINK_ISL_INTERPLANE)  
sathandoff.cc:		if (slhp->linkup_ && link_down_flag_) {
sathandoff.cc:			slhp->linkup_ = FALSE;
sathandoff.cc:			peer_slhp->linkup_ = FALSE;
sathandoff.cc:		} else if (!slhp->linkup_ && !link_down_flag_) {
sathandoff.cc:			slhp->linkup_ = TRUE;
sathandoff.cc:			peer_slhp->linkup_ = TRUE;
satlink.cc:	char *mh = (char*)p->access(hdr_mac::offset_);
satlink.cc:	snd_pkt_ = p->copy();  // save a copy in case it gets retransmitted
satnode.cc:		snodep = (SatNode*) snodep->nextnode()) {
satnode.cc:		sposp = snodep->position();
satnode.cc:                printf("%d\t%.2f\t%.2f", snodep->address(), 
satnode.cc:		    RAD_TO_DEG(SatGeometry::get_latitude(sposp->coord())), 
satnode.cc:		    RAD_TO_DEG(SatGeometry::get_longitude(sposp->coord())));
satnode.cc:		if (sposp->type()==POSITION_SAT_POLAR) {
satnode.cc:			polar_sposp = (PolarSatPosition*) snodep->position();
satnode.cc:			printf ("\t%d", polar_sposp->plane());
satnode.cc:		} else if (sposp->type()==POSITION_SAT_GEO) {
satnode.cc:		} else if (sposp->type()==POSITION_SAT_TERM) {
satnode.cc:		snodep = (SatNode*) snodep->nextnode()) {
satnode.cc:		for (slhp = (SatLinkHead*) snodep->linklisthead_.lh_first; 
satnode.cc:		    slhp; slhp = (SatLinkHead*) slhp->nextlinkhead() ) {
satnode.cc:			linktype = slhp->type();
satnode.cc:			if (!slhp->linkup_)
satnode.cc:			sposp = snodep->position();
satnode.cc:			peer_sposp = peer_snodep->position();
satnode.cc:			 RAD_TO_DEG(SatGeometry::get_latitude(sposp->coord())),
satnode.cc:			 RAD_TO_DEG(SatGeometry::get_longitude(sposp->coord())),
satnode.cc:			 RAD_TO_DEG(SatGeometry::get_latitude(peer_sposp->coord())), 
satnode.cc:			 RAD_TO_DEG(SatGeometry::get_longitude(peer_sposp->coord())),
satroute.cc:        for (nodep=Node::nodehead_.lh_first; nodep; nodep = nodep->nextnode()) {
satroute.cc:	    for (slhp = (SatLinkHead*) nodep->linklisthead().lh_first; slhp; 
satroute.cc:	      slhp = (SatLinkHead*) slhp->nextlinkhead()) {
satroute.cc:		if (slhp->type() == LINK_GSL_REPEATER)
satroute.cc:		if (!slhp->linkup_)
satroute.cc:		phytxp = (Phy *) slhp->phy_tx();
satroute.cc:		channelp = phytxp->channel();
satroute.cc:		phyrxp = channelp->ifhead_.lh_first;
satroute.cc:		for (; phyrxp; phyrxp = phyrxp->nextchnl()) {
satroute.cc:		    if (phyrxp->head()->type() == LINK_GSL_REPEATER) {
satroute.cc:				    channelp)->get_pdelay(phytxp->node(), 
satroute.cc:				    phyrxp->node());
satroute.cc:			if (!((SatLinkHead*)phyrxp->head())->linkup_)
satroute.cc:			phytxp2 = ((SatLinkHead*)phyrxp->head())->phy_tx();
satroute.cc:		            src = phytxp->node()->address() + 1;
satroute.cc:		        src = phytxp->node()->address() + 1;
satroute.cc:		        dst = phyrxp->node()->address() + 1;
satroute.cc:		              channelp)->get_pdelay(phytxp->node(), 
satroute.cc:			      phyrxp->node());
satroute.cc:        for (; snodep; snodep = (SatNode*) snodep->nextnode()) {
satroute.cc:		if (snodep->ragent())
satroute.cc:			snodep->ragent()->clear_slots();
satroute.cc:		src = snodep->address();
sattrace.cc:			iph->flowid() /* was p->class_ */,
sattrace.cc:			th->uid(), /* was p->uid_ */
sattrace.cc:			iph->flowid(), /* was p->class_ */
sattrace.cc:			th->uid(), /* was p->uid_ */
scheduler.cc:	p->uid_ = -p->uid_;	// being dispatched
scheduler.cc:	p->handler_->handle(p);	// dispatch
scheduler.cc:	dispatch(p, p->time_);
scheduler.cc:		printf("t:%f uid: ", p->time_);
scheduler.cc:		printf(UID_PRINTF_FORMAT, p->uid_);
scheduler.cc:		printf(" handler: %p\n", p->handler_);
scheduler.cc:		for (Event* p = buckets_[i]; p != NULL; p = p->next_)
scheduler.cc:			if (p->uid_== uid) return p;
scheduler.cc:		while ((p = deque()) != NULL && (p->time_ <= now)) {
scheduler.cc:			int rval = rwait(p->time_);
semantic-packetqueue.cc:			p = p->next_;
semantic-packetqueue.cc:							pp->next_ = pkt;
semantic-packetqueue.cc:						new_p = p->next_;
semantic-packetqueue.cc:						if (s.lookup(p->uid_)) {
semantic-packetqueue.cc:		p = p->next_;
semantic-packetqueue.cc:	for (Packet* p = head_; p != 0; p = p->next_) {
session-rtp.cc:	for (RTPSource* sp = allsrcs_; sp != 0; sp = sp->next) {
session-rtp.cc:	        int received = sp->np() - sp->snp();
session-rtp.cc:		sp->snp(sp->np());
session-rtp.cc:	for (p = allsrcs_; p != 0; p = p->next)
session-rtp.cc:		if (p->srcid() == srcid)
sessionhelper.cc:		if (loss_dep->obj != 0) {
sessionhelper.cc:			if (loss_dep->obj->corrupt(pkt)) {
sessionhelper.cc:				get_dropped(loss_dep->loss_dep, pkt);
sessionhelper.cc:			get_dropped(loss_dep->next, pkt);
sessionhelper.cc:		rcv_depobj *tmprcv_dep = loss_dep->rcv_dep;
sessionhelper.cc:		loss_depobj *tmploss_dep = loss_dep->loss_dep;
sessionhelper.cc:			tmprcv_dep->obj->dropped = 1;
sessionhelper.cc:			tmprcv_dep = tmprcv_dep->next;
sessionhelper.cc:			tmploss_dep = tmploss_dep->next;
sessionhelper.cc:	top->loss_obj = loss_dependency_;
sessionhelper.cc:	top->next = 0;
sessionhelper.cc:		if (top->loss_obj->obj == err) {
sessionhelper.cc:			loss_depobj *tmp_loss_obj = top->loss_obj;
sessionhelper.cc:				top = top->next;
sessionhelper.cc:		loss_depobj *tmploss = top->loss_obj->loss_dep;
sessionhelper.cc:		top = top->next;
sessionhelper.cc:					    tmp->obj->name());
sessionhelper.cc:				tmp = tmp->next;
sessionhelper.cc:			tmp->bw = atof(argv[2]);
sessionhelper.cc:			tmp->delay = atof(argv[3]);
sessionhelper.cc:			tmp->prev_arrival = 0;
sessionhelper.cc:			tmp->ttl = atoi(argv[4]);
sessionhelper.cc:			tmp->addr = atoi(argv[5]);
sessionhelper.cc:			tmp->obj = (NsObject*)TclObject::lookup(argv[6]);
sessionhelper.cc:			//printf ("addr = %d, argv3 = %s, obj = %d, ttl=%d\n", tmp->addr, argv[3], tmp->obj, tmp->ttl);
sessionhelper.cc:			tmp->next = dstobj_;
shadowing.cc:	double L = ifp->getL();		// system loss
shadowing.cc:	double lambda = ifp->getLambda();   // wavelength
snoop.cc:	snoop->recv(p, h);
snoop.cc:	pkts_[i] = p->copy();
srm-ssm.cc:      printf("%s is %d and rep-status %d\n", name_, addr(), scopeFlag_);
srm-ssm.cc:      for (SRMinfo* sp = sip_; sp; sp = sp->next_) {
srm-ssm.cc:	if((sp->distanceFlag_ == REP_DISTANCE) || 
srm-ssm.cc:	   (sp->distanceFlag_ == SELF_DISTANCE)) {
srm-ssm.cc:		      sp->sender_, sp->distance_);
srm-ssm.cc:	  SRMinfo* rsp = get_state(sp->repid_);
srm-ssm.cc:		      sp->sender_, rsp->distance_);
srm-ssm.cc:      if((sp->distanceFlag_ == REP_DISTANCE) || 
srm-ssm.cc:	 (sp->distanceFlag_ == SELF_DISTANCE)) {
srm-ssm.cc:	tcl.resultf("%f", sp->distance_);
srm-ssm.cc:	SRMinfo* rsp = get_state(sp->repid_);
srm-ssm.cc:	tcl.resultf("%f", rsp->distance_);
srm-ssm.cc:      recv_data(sh->sender(), sh->seqnum(), seh->repid(), p->accessdata());
srm-ssm.cc:      recv_repr(sh->round(), sh->sender(), sh->seqnum(), p->accessdata());
srm-ssm.cc:      recv_sess(sh->seqnum(), (int*) p->accessdata(), p);
srm-ssm.cc:  sp->repid_ = repid;
srm-ssm.cc:  rsp->repid_ = repid;
srm-ssm.cc:        int* data = (int*) p->accessdata();
srm-ssm.cc:	for (SRMinfo* sp = sip_; sp; sp = sp->next_) {
srm-ssm.cc:           if ((sp->senderFlag_ || 
srm-ssm.cc:		(sp->scopeFlag_ == SRM_GLOBAL) ||
srm-ssm.cc:		(sp->sender_ == addr()))
srm-ssm.cc:	        *data++ = sp->sender_;
srm-ssm.cc:                *data++ = sp->ldata_;
srm-ssm.cc:                *data++ = sp->recvTime_;
srm-ssm.cc:                *data++ = sp->sendTime_;
srm-ssm.cc:		*data++ = sp->repid_;
srm-ssm.cc:	data = (int*) p->accessdata();
srm-ssm.cc:        int* data = (int*) p->accessdata();
srm-ssm.cc:	//int* tmp_data = (int*) p->accessdata();
srm-ssm.cc:	for (SRMinfo* sp = sip_; sp; sp = sp->next_) {
srm-ssm.cc:	  if ((sp->senderFlag_ || 
srm-ssm.cc:	       (sp->scopeFlag_ == SRM_LOCAL) ||
srm-ssm.cc:	       (sp->distanceFlag_ = SELF_DISTANCE) || 
srm-ssm.cc:	       (sp->sender_ == addr()) ||   
srm-ssm.cc:	       (repid_ == sp->sender_)) 
srm-ssm.cc:	    *data++ = sp->sender_;
srm-ssm.cc:	    *data++ = sp->ldata_;
srm-ssm.cc:	    *data++ = sp->recvTime_;
srm-ssm.cc:	    *data++ = sp->sendTime_;
srm-ssm.cc:	    *data++ = sp->repid_;
srm-ssm.cc:	data = (int*) p->accessdata();
srm-ssm.cc:        int* data = (int*) p->accessdata();
srm-ssm.cc:	for (SRMinfo* sp = sip_; sp; sp = sp->next_) {
srm-ssm.cc:	  if (sp->activeFlag_ == ACTIVE) {
srm-ssm.cc:	        *data++ = sp->sender_;
srm-ssm.cc:                *data++ = sp->ldata_;
srm-ssm.cc:		if (sp->scopeFlag_ == SRM_GLOBAL) {
srm-ssm.cc:		  *data++ = (int) (sp->distance_*1000);
srm-ssm.cc:		  *data++ = sp->recvTime_;
srm-ssm.cc:		  *data++ = sp->sendTime_;
srm-ssm.cc:		*data++ = sp->repid_;
srm-ssm.cc:	data = (int*) p->accessdata();
srm-ssm.cc:  if (sp->lglbsess_ > sessCtr)		// older session message recd.
srm-ssm.cc:  if (sp->scopeFlag_ != SRM_GLOBAL) {
srm-ssm.cc:    sp->scopeFlag_ = SRM_GLOBAL;
srm-ssm.cc:  sp->repid_ = repid;
srm-ssm.cc:  sp->lglbsess_ = sessCtr;
srm-ssm.cc:  sp->recvTime_ = now;
srm-ssm.cc:  sp->sendTime_ = stime;
srm-ssm.cc:  for (i = sp->ldata_ + 1; i <= dataCnt; i++)
srm-ssm.cc:    if (! sp->ifReceived(i))
srm-ssm.cc:      tcl.evalf("%s request %d %d", name_, sender, i, sp->repid_);
srm-ssm.cc:  if (sp->ldata_ < dataCnt)
srm-ssm.cc:    sp->ldata_ = dataCnt;
srm-ssm.cc:      sp->distance_ = (double) rtt / 2 / 1000;
srm-ssm.cc:      sp->distanceFlag_ = SELF_DISTANCE;
srm-ssm.cc:	      sentBy, sp->distance_);
srm-ssm.cc:    for (int j = sp->ldata_ + 1; j <= dataCnt; j++)
srm-ssm.cc:      if (! sp->ifReceived(j))
srm-ssm.cc:	tcl.evalf("%s request %d %d", name_, sender, j, sp->repid_);
srm-ssm.cc:    if (sp->ldata_ < dataCnt)
srm-ssm.cc:      sp->ldata_ = dataCnt;
srm-ssm.cc:  if (sp->llocsess_ > sessCtr)		// older session message recd.
srm-ssm.cc:  if (sp->scopeFlag_ != SRM_LOCAL) {
srm-ssm.cc:    sp->scopeFlag_ = SRM_LOCAL;
srm-ssm.cc:  sp->repid_ = repid;
srm-ssm.cc:  sp->llocsess_ = sessCtr;
srm-ssm.cc:  sp->recvTime_ = now;
srm-ssm.cc:  sp->sendTime_ = stime;
srm-ssm.cc:  for (i = sp->ldata_ + 1; i <= dataCnt; i++)
srm-ssm.cc:    if (! sp->ifReceived(i))
srm-ssm.cc:      tcl.evalf("%s request %d %d", name_, sender, i, sp->repid_);
srm-ssm.cc:  if (sp->ldata_ < dataCnt)
srm-ssm.cc:    sp->ldata_ = dataCnt;
srm-ssm.cc:      sp->distance_ = (double) rtt / 2 / 1000;
srm-ssm.cc:      sp->distanceFlag_ = SELF_DISTANCE;
srm-ssm.cc:	      sentBy, sp->distance_);
srm-ssm.cc:    for (int j = sp->ldata_ + 1; j <= dataCnt; j++)
srm-ssm.cc:      if (! sp->ifReceived(j))
srm-ssm.cc:	tcl.evalf("%s request %d %d", name_, sender, j, sp->repid_);
srm-ssm.cc:    if (sp->ldata_ < dataCnt)
srm-ssm.cc:      sp->ldata_ = dataCnt;
srm-ssm.cc:    fprintf(stdout,"Recvd a rep-sess with repid(%d) != address(%d)\n",
srm-ssm.cc:  if (sp->lrepsess_ > sessCtr)		// older session message recd.
srm-ssm.cc:  if (sp->scopeFlag_ != SRM_GLOBAL)      // Should I change the repid also??
srm-ssm.cc:    sp->scopeFlag_ = SRM_GLOBAL;
srm-ssm.cc:  sp->lrepsess_ = sessCtr;
srm-ssm.cc:  sp->recvTime_ = now;
srm-ssm.cc:  sp->sendTime_ = stime;
srm-ssm.cc:  for (i = sp->ldata_ + 1; i <= dataCnt; i++)
srm-ssm.cc:    if (! sp->ifReceived(i))
srm-ssm.cc:      tcl.evalf("%s request %d %d", name_, sender, i, sp->repid_);
srm-ssm.cc:  if (sp->ldata_ < dataCnt)
srm-ssm.cc:    sp->ldata_ = dataCnt;
srm-ssm.cc:      sp->distance_ = (double) rtt / 2 / 1000;
srm-ssm.cc:      sp->distanceFlag_ = SELF_DISTANCE;
srm-ssm.cc:	      sentBy, sp->distance_);
srm-ssm.cc:      if (!(is_active(sp) && (sp->distanceFlag_ == SELF_DISTANCE))) {
srm-ssm.cc:	sp->distance_ = (double) rtime/1000;   
srm-ssm.cc:	sp->distanceFlag_ = REP_DISTANCE;
srm-ssm.cc:    for (int j = sp->ldata_ + 1; j <= dataCnt; j++)
srm-ssm.cc:      if (! sp->ifReceived(j))
srm-ssm.cc:	tcl.evalf("%s request %d %d", name_, sender, j, sp->repid_);
srm-ssm.cc:    if (sp->ldata_ < dataCnt)
srm-ssm.cc:      sp->ldata_ = dataCnt;
srm-ssm.cc:  for (SRMinfo* sp = sip_->next_; sp; sp = sp->next_) {
srm-ssm.cc:    if ((now - sp->recvTime_) >= 3*sessionDelay) {
srm-ssm.cc:      sp->activeFlag_ = INACTIVE;
srm-ssm.cc:  if ((sp->sender_ != addr()) && ((now - sp->recvTime_) >= 3*sessionDelay)) {
srm-topo.cc:		for (p=ilist->head_; p; p=p->next_) {
srm-topo.cc:			nn = p->in_;
srm-topo.cc:		next = p->next_;
srm.cc:				for (SRMinfo* sp = sip_; sp; sp = sp->next_) {
srm.cc:						    sp->sender_,
srm.cc:						    sp->distance_);
srm.cc:			tcl.resultf("%lf", sp->distance_);
srm.cc:			recv_data(sh->sender(), sh->seqnum(), p->accessdata());
srm.cc:				  p->accessdata());
srm.cc:			recv_sess(p, sh->seqnum(), (int*) p->accessdata());
srm.cc:	if (msgid > sp->ldata_) {
srm.cc:		sp->setReceived(msgid);
srm.cc:		sp->ldata_ = msgid;
srm.cc:	if (msgid > sp->ldata_) {
srm.cc:		sp->ldata_ = msgid;
srm.cc:	if (msgid > sp->ldata_) {
srm.cc:		sp->setReceived(msgid);
srm.cc:		sp->ldata_ = msgid;
srm.cc:	int* data = (int*) p->accessdata();
srm.cc:	for (SRMinfo* sp = sip_; sp; sp = sp->next_) {
srm.cc:		*data++ = sp->sender_;
srm.cc:		*data++ = sp->ldata_;
srm.cc:		*data++ = sp->recvTime_;
srm.cc:		*data++ = sp->sendTime_;
srm.cc:	data = (int*) p->accessdata();
srm.cc:	if (sp->lsess_ > sessCtr)		// older session message recd.
srm.cc:	sp->lsess_ = sessCtr;
srm.cc:	sp->recvTime_ = now;
srm.cc:	sp->sendTime_ = stime;
srm.cc:	if (sp->ldata_ < dataCnt)
srm.cc:		sp->ldata_ = dataCnt;
srm.cc:			sp->distance_ = (double) rtt / 2 / 1000;
srm.cc:				sentBy, sp->distance_);
srm.cc:		if (sp->ldata_ < dataCnt)
srm.cc:			sp->ldata_ = dataCnt;
tbf.cc:		for (Packet *p=q_->head();p!=0;p=p->next_) 
tclAppInit.cc: *	message in interp->result if an error occurs.
tcp-abs.cc:/* tcp-abs.cc
tcp-abs.cc: * @(#) $Header: /nfs/jade/vint/CVSROOT/ns-2/tcp-abs.cc,v 1.2 1999/05/31 20:40:46 heideman Exp $ (LBL)";
tcp-abs.cc:#include "tcp-abs.h"
tcp-abs.cc:		if(tmp->agent_->flowid() == iph->flowid())
tcp-abs.cc:			tmp->agent_->drop(tcph->seqno());
tcp-abs.cc:		tmp = tmp->next_;
tcp-asym-fs.cc: * tcp-asym-fs: TCP mods for asymmetric networks (tcp-asym) with fast start
tcp-asym-fs.cc: * (tcp-fs).
tcp-asym-fs.cc:#include "tcp-asym.h"
tcp-asym-fs.cc:#include "tcp-fs.h"
tcp-asym-sink.cc: * tcp-asym includes modifications to several flavors of TCP to enhance
tcp-asym-sink.cc:    "@(#) $Header: /nfs/jade/vint/CVSROOT/ns-2/tcp-asym-sink.cc,v 1.16 1999/09/09 03:22:49 salehi Exp $ (UCB)";
tcp-asym-sink.cc:#include "tcp-sink.h"
tcp-asym-sink.cc:#include "tcp-asym.h"
tcp-asym.cc: * tcp-asym includes modifications to several flavors of TCP to enhance
tcp-asym.cc: * using which the sink can perform ack congestion control (tcp-asym-sink.cc). 
tcp-asym.cc: * The tcp-asym source is usually used in conjunction with a tcp-asym sink, or
tcp-asym.cc:    "@(#) $Header: /nfs/jade/vint/CVSROOT/ns-2/tcp-asym.cc,v 1.17 1999/09/09 03:22:50 salehi Exp $ (UCB)";
tcp-asym.cc:#include "tcp-asym.h"
tcp-asym.cc:/* Print out if tcp-asym-specific variables have been modified */
tcp-fack.cc:    "@(#) $Header: /nfs/jade/vint/CVSROOT/ns-2/tcp-fack.cc,v 1.25 2000/09/01 03:04:07 haoboy Exp $ (PSC)";
tcp-fack.cc:#include "tcp-fack.h"
tcp-fack.cc:	 * There are conditions under which certain versions of TCP (e.g., tcp-fs)
tcp-fs.cc: * tcp-fs: TCP with "fast start", a procedure for avoiding the penalty of
tcp-fs.cc: * etc., with suitable modifications. The same procedure as used in tcp-asym
tcp-fs.cc:#include "tcp-fs.h"
tcp-full.cc:    "@(#) $Header: /nfs/jade/vint/CVSROOT/ns-2/tcp-full.cc,v 1.83 2000/10/20 12:29:02 polly Exp $ (LBL)";
tcp-full.cc:#include "tcp-full.h"
tcp-full.cc:	 * and not doing an ack or a keep-alive probe.
tcp-full.cc: * tcp-full's version of set_initial_window()... over-rides
tcp-full.cc:         * Otherwise initialize tp->rcv_nxt, and tp->irs, iss is already
tcp-full.cc:         * Initialize tp->snd_nxt to tp->iss.
tcp-full.cc:         *      initialize tp->rcv_nxt and tp->irs
tcp-full.cc:         *      if seg contains ack then advance tp->snd_una
tcp-full.cc:			todrop--;
tcp-full.cc:         *      tp->snd_una < ti->ti_ack <= tp->snd_max
tcp-full.cc:         * then advance tp->snd_una to ti->ti_ack and drop
tcp-full.cc:		while (p->next_ &&
tcp-full.cc:		    (p->next_->startseq_ == p->endseq_)) {
tcp-full.cc:			//p->time_ = MAX(p->time_, p->next_->time_);
tcp-full.cc:			p->next_->time_ = MAX(p->time_, p->next_->time_);
tcp-full.cc:			p = p->next_;
tcp-full.cc:		//p->time_ = MAX(q->time_, p->time_);
tcp-full.cc:		p = p->next_;
tcp-full.cc:		while (p->prev_ && 
tcp-full.cc:		       (p->prev_->endseq_ == p->startseq_))
tcp-full.cc:			p = p->prev_;
tcp-full.cc:		sacks[2*num_sack_blocks + 0] = p->startseq_;
tcp-full.cc:		q = p = p->prev_;
tcp-full.cc:		while (p->prev_ && (p->prev_->endseq_ == p->startseq_))	{
tcp-full.cc:			p = p->prev_;
tcp-full.cc:			tip[0] = p->startseq_;
tcp-full.cc:		p = q = p->prev_;
tcp-full.cc:		// find the max, q->ptr to left of max, p->ptr to right
tcp-full.cc:			while (p->next_ &&
tcp-full.cc:			    (p->next_->startseq_ == p->endseq_)) {
tcp-full.cc:				p = p->next_;
tcp-full.cc:			if ((p->time_ > 0.0) && p->time_ > max) {
tcp-full.cc:			p = p->next_;
tcp-full.cc:			*sacks++ = maxp->endseq_;
tcp-full.cc:			maxp->time_ = -maxp->time_;
tcp-full.cc:		if (p->time_ < 0.0)
tcp-full.cc:			p->time_ = -p->time_;
tcp-full.cc:		p = p->next_;
tcp-full.cc:		*sacks++ = p->startseq_;
tcp-full.cc:		while (p->next_ && (p->next_->startseq_ == p->endseq_)) {
tcp-full.cc:			p = p->next_;
tcp-full.cc:		*sacks = p->endseq_;
tcp-full.cc:	ptr_ = p->next_;
tcp-full.cc:				p->startseq_, p->endseq_);
tcp-full.cc:				p->startseq_, p->endseq_);
tcp-full.cc:		p = p->next_;
tcp-full.cc:		if (p == NULL || (start > p->endseq_)) {
tcp-full.cc:				n->next_ = p->next_;
tcp-full.cc:				// point p->next_->prev_ to n
tcp-full.cc:				if(p->next_)
tcp-full.cc:                                        p->next_->prev_= n;
tcp-full.cc:				p->next_ = n;
tcp-full.cc:			p->startseq_ = MIN(p->startseq_, start);
tcp-full.cc:			p->endseq_ = MAX(p->endseq_, end);
tcp-full.cc:			p->flags_ |= tiflags;
tcp-full.cc:		rcv_nxt_ = p->endseq_;
tcp-full.cc:		tiflags |= p->flags_;
tcp-full.cc:		p = p->next_;
tcp-int.cc: * $Header: /nfs/jade/vint/CVSROOT/ns-2/tcp-int.cc,v 1.15 2000/09/01 03:04:07 haoboy Exp $
tcp-int.cc:#include "tcp-int.h"
tcp-int.cc:#include "tcp-session.h"
tcp-newreno.cc:    "@(#) $Header: /nfs/jade/vint/CVSROOT/ns-2/tcp-newreno.cc,v 1.43 2000/10/06 05:07:50 sfloyd Exp $ (LBL)";
tcp-rbp.cc: * Tcp-vegas with Rate-based pacing by John Heidemann <johnh@isi.edu>
tcp-rbp.cc:"@(#) $Header: /nfs/jade/vint/CVSROOT/ns-2/tcp-rbp.cc,v 1.19 2000/09/01 03:04:07 haoboy Exp $ (NCSU/IBM)";
tcp-reno.cc:    "@(#) $Header: /nfs/jade/vint/CVSROOT/ns-2/tcp-reno.cc,v 1.34 2000/09/01 03:04:07 haoboy Exp $ (LBL)";
tcp-rfc793edu.cc:#include "tcp-rfc793edu.h"
tcp-rfc793edu.cc:// URL "http://www.ce.chalmers.se/~fcela/tcp-tour.html"
tcp-sack-rh.cc:    "@(#) $Header: /nfs/jade/vint/CVSROOT/ns-2/tcp-sack-rh.cc,v 1.4 2000/11/10 01:45:20 sfloyd Exp $ (PSC-SACKRH)";
tcp-sack1.cc:    "@(#) $Header: /nfs/jade/vint/CVSROOT/ns-2/tcp-sack1.cc,v 1.48 2000/12/16 00:21:25 sfloyd Exp $ (PSC)";
tcp-session.cc: * $Header: /nfs/jade/vint/CVSROOT/ns-2/tcp-session.cc,v 1.18 2000/09/01 03:04:07 haoboy Exp $
tcp-session.cc:#include "tcp-int.h"
tcp-session.cc:#include "tcp-session.h"
tcp-session.cc:				tcp->wt_ = 1;
tcp-session.cc:	wtSum_ -= tcp->wt_;
tcp-session.cc:	tcp->wt_ = wt;
tcp-session.cc:	wtSum_ += tcp->wt_;
tcp-session.cc:		tcp->dynWt_ = tcp->wt_;
tcp-sink.cc:    "@(#) $Header: /nfs/jade/vint/CVSROOT/ns-2/tcp-sink.cc,v 1.43 2000/12/19 22:48:27 sfloyd Exp $ (LBL)";
tcp-sink.cc:#include "tcp-sink.h"
tcp-sink.cc:	ntcp->seqno() = acker_->Seqno();
tcp-sink.cc:	ntcp->ts() = now;
tcp-sink.cc:		ntcp->ts_echo() = acker_->ts_to_echo();
tcp-sink.cc:		ntcp->ts_echo() = otcp->ts();
tcp-sink.cc:	nip->flowid() = oip->flowid();
tcp-sink.cc:			   ntcp, otcp->seqno());
tcp-sink.cc:		// not doing recovery, i.e. not gap-filling.
tcp-sink.cc:/* "sack1-tcp-sink" is for Matt and Jamshid's implementation of sack. */
tcp-vegas.cc:"@(#) $Header: /nfs/jade/vint/CVSROOT/ns-2/tcp-vegas.cc,v 1.35 2000/12/14 05:05:21 xuanc Exp $ (NCSU/IBM)";
tfcc.cc:	hdr_tfcc* th = (hdr_tfcc*)p->access(hdr_tfcc::offset_);
tfcc.cc:	hdr_flags* fh = (hdr_flags*)p->access(hdr_flags::offset_);
tkAppInit.cc: *	message in interp->result if an error occurs.
trace.cc:	if (p->is_atm())
trace.cc:	flags[5] = hf->fs_ ? 'F' : '-';		   // Fast start: see tcp-fs and tcp-int
trace.cc:	if ((!show_tcphdr_) && (!(p->is_atm()))) {
trace.cc:			iph->flowid() /* was p->class_ */,
trace.cc:			th->uid() /* was p->uid_ */);
trace.cc:	} else if (p->is_atm()) {
trace.cc:			iph->flowid() /* was p->class_ */,
trace.cc:			iph->flowid(), /* was p->class_ */
trace.cc:			th->uid(), /* was p->uid_ */
ttl.cc:		if ((!p->is_atm()) && (ttl <= 0)) {
tworayground.cc:  double L = ifp->getL();			// system loss
tworayground.cc:  double lambda = ifp->getLambda();	// wavelength
wireless-phy.cc:	p->txinfo_.stamp(node(), ant_->copy(), Pt_, lambda_);
wireless-phy.cc:		Pr = propagation_->Pr(&p->txinfo_, &s, this);
wireless-phy.cc:			       p->txinfo_.getNode()->index(),
wireless-phy.cc:	p->txinfo_.getAntenna()->release();
wireless-phy.cc:	p->txinfo_.RxPr = Pr;
wireless-phy.cc:	p->txinfo_.CPThresh = CPThresh_;
