cmu-trace.cc

the User Agent and Service Agent functionality of the Service Location Protocol, based on RFC 2608:

                abort();
        }
}

void
CMUTrace::format_bcast(Packet *p, int offset)
{
        struct hdr_bcast *bh = HDR_BCAST(p);

        switch(bh->type) {

        case BCASTTYPE_HELLO:
        case BCASTTYPE_DATA:
        case BCASTTYPE_NACK:

                if (pt_->tagged()) {
                        // Need to determine tag names for this data
                        //sprintf(pt_->buffer() + offset,
                        //      "",
                        //      );
                } else if (newtrace_) {
                        sprintf(pt_->buffer() + offset,
                            "-P bcast -Pt 0x%x -Ph %d -Pd %d -Pds %d -Ps %d -Pss %d -Pl %f -Pc %s ",
                                bh->type,
                                bh->hop_count,
                                bh->dst,
                                bh->dst_seqno,
                                bh->src,
                                bh->src_seqno,
                                bh->lifetime,
                                bh->type == BCASTTYPE_DATA ? "DATA" :
                                  (bh->type == BCASTTYPE_HELLO ? "HELLO" : "NACK"));
                } else {

                        sprintf(pt_->buffer() + offset,
                                "[0x%x %d [%d %d] [%d %d] %f] (%s)",
                                bh->type,
                                bh->hop_count,
                                bh->dst,
                                bh->dst_seqno,
                                bh->src,
                                bh->src_seqno,
                                bh->lifetime,
                                bh->type == BCASTTYPE_DATA ? "DATA" :
                                  (bh->type == BCASTTYPE_HELLO ? "HELLO" : "NA"));
                }
                break;

        default:
#ifdef WIN32
                fprintf(stderr,
                        "CMUTrace::format_bcast: invalid BCAST packet type\n");
#else
                fprintf(stderr,
                        "%s: invalid BCAST packet type\n", __FUNCTION__);
#endif
                abort();
        }
}


void
CMUTrace::format_flood(Packet *p, int offset)
{
#ifdef WIN32
        fprintf(stderr,"CMUTrace::format_flood: invalid FLOOD packet type\n");
#else
        fprintf(stderr, "%s: invalid FLOOD packet type\n", __FUNCTION__);
#endif
        abort();
}

void
CMUTrace::format_slp(Packet *p, int offset)
{
        struct hdr_slp *sh = HDR_SLP(p);
                                                                                                 
                if (newtrace_) {
                        sprintf(pt_->buffer() + offset,
                            "-P slp -Px %d",
                                sh->xid);
                }
                else {
                        sprintf(pt_->buffer() + offset,
                                "%d ",
                                sh->xid);
                                                                                                 
                }
                                                                                                 
        offset = strlen(pt_->buffer());
                                                                                                 
        switch(sh->function_id) {
                                                                                                 
        case SLPTYPE_SRVRQST:
                sprintf(pt_->buffer() + offset, "%s ", "srvRqst");
                break;
        case SLPTYPE_SRVRPLY:
                sprintf(pt_->buffer() + offset, "%s ", "srvRply");
                break;
        case SLPTYPE_SAADVERT:
                sprintf(pt_->buffer() + offset, "%s ", "srvAdvert");
                break;
                                                                                        
        default:
                fprintf(stderr,
                        "CMUTrace::format_slp: invalid SLP packet type\n");
                abort();
        }
                                                                                                 
}

void
CMUTrace::nam_format(Packet *p, int offset)
{
	Node* srcnode = 0 ;
	Node* dstnode = 0 ;
	Node* nextnode = 0 ;
        struct hdr_cmn *ch = HDR_CMN(p);
	struct hdr_ip *ih = HDR_IP(p);
	char op = (char) type_;
	char colors[32];
	int next_hop = -1 ;

// change wrt Mike's code
	assert(type_ != EOT);



        int dst = Address::instance().get_nodeaddr(ih->daddr());

	nextnode = Node::get_node_by_address(ch->next_hop_);
        if (nextnode) next_hop = nextnode->nodeid(); 

	srcnode = Node::get_node_by_address(src_);
	dstnode = Node::get_node_by_address(ch->next_hop_);

	double distance = 0;

        if ((srcnode) && (dstnode)) {
	   MobileNode* tmnode = (MobileNode*)srcnode;
	   MobileNode* rmnode = (MobileNode*)dstnode;

	   distance = tmnode->propdelay(rmnode) * 300000000 ;
	}

	double energy = -1;
	double initenergy = -1;

	//default value for changing node color with respect to energy depletion
	double l1 = 0.5; 
	double l2 = 0.2;
	
	if (srcnode) {
	    if (srcnode->energy_model()) {
		    energy = srcnode->energy_model()->energy();
		    initenergy = srcnode->energy_model()->initialenergy();
		    l1 = srcnode->energy_model()->level1();
		    l2 = srcnode->energy_model()->level2();
	    }
	}

        int energyLevel = 0 ;
        double energyLeft = (double)(energy/initenergy) ;

        if ((energyLeft <= 1 ) && (energyLeft >= l1 )) energyLevel = 3;	
        if ((energyLeft >= l2 ) && (energyLeft < l1 )) energyLevel = 2;	
        if ((energyLeft > 0 ) && (energyLeft < l2 )) energyLevel = 1;	

	if (energyLevel == 0) 
		strcpy(colors,"-c black -o red");
        else if (energyLevel == 1) 
		strcpy(colors,"-c red -o yellow");
        else if (energyLevel == 2) 
		strcpy(colors,"-c yellow -o green");
        else if (energyLevel == 3) 
		strcpy(colors,"-c green -o black");

	// A simple hack for scadds demo (fernandez's visit) -- Chalermek
	int pkt_color = 0;
	if (ch->ptype()==PT_DIFF) {
		hdr_cdiff *dfh= HDR_CDIFF(p);
		if (dfh->mess_type != DATA) {
			pkt_color = 1;
		}
	}
	// convert to nam format 
	if (op == 's') op = 'h' ;
	if (op == 'D') op = 'd' ;
	if (op == 'h') {
	   sprintf(pt_->nbuffer(),
		"+ -t %.9f -s %d -d %d -p %s -e %d -c 2 -a %d -i %d -k %3s ",
		Scheduler::instance().clock(),
		src_,                           // this node
		next_hop,
		packet_info.name(ch->ptype()),
		ch->size(),
		pkt_color,   
		ch->uid(),
		tracename);

	   offset = strlen(pt_->nbuffer());
	   pt_->namdump();
	   sprintf(pt_->nbuffer() ,
		"- -t %.9f -s %d -d %d -p %s -e %d -c 2 -a %d -i %d -k %3s",
		Scheduler::instance().clock(),
		src_,                           // this node
		next_hop,
		packet_info.name(ch->ptype()),
		ch->size(),
		pkt_color,
		ch->uid(),
		tracename);

	   offset = strlen(pt_->nbuffer());
           pt_->namdump();
	}

        // if nodes are too far from each other
	// nam won't dump SEND event 'cuz it's
	// gonna be dropped later anyway
	// this value 250 is pre-calculated by using 
	// two-ray ground refelction model with fixed
	// transmission power 3.652e-10
//	if ((type_ == SEND)  && (distance > 250 )) return ;

	if(tracetype == TR_ROUTER && type_ == RECV && dst != -1 ) return ;
	if(type_ == RECV && dst == -1 )dst = src_ ; //broadcasting event

        if (energy != -1) { //energy model being turned on
	   if (src_ >= MAX_NODE) {
	       fprintf (stderr, "%: node id must be < %d\n",
		       __PRETTY_FUNCTION__, MAX_NODE);
	       exit(0);
	   }
	   if (nodeColor[src_] != energyLevel ) { //only dump it when node  
	       sprintf(pt_->nbuffer() ,                    //color change
	          "n -t %.9f -s %d -S COLOR %s",
	           Scheduler::instance().clock(),
	           src_,                           // this node
	           colors);
               offset = strlen(pt_->nbuffer());
               pt_->namdump();
	       nodeColor[src_] = energyLevel ;
	    }   
        }

	sprintf(pt_->nbuffer() ,
		"%c -t %.9f -s %d -d %d -p %s -e %d -c 2 -a %d -i %d -k %3s",
		op,
		Scheduler::instance().clock(),
		src_,                           // this node
		next_hop,
		packet_info.name(ch->ptype()),
		ch->size(),
		pkt_color,
		ch->uid(),
		tracename);

	offset = strlen(pt_->nbuffer());
	pt_->namdump();
}

void CMUTrace::format(Packet* p, const char *why)
{
	hdr_cmn *ch = HDR_CMN(p);
	int offset = 0;

	/*
	 * Log the MAC Header
	 */
	format_mac_common(p, why, offset);

	if (pt_->namchannel()) 
		nam_format(p, offset);
	offset = strlen(pt_->buffer());
	switch(ch->ptype()) {
	case PT_MAC:
	case PT_SMAC:
		break;
	case PT_ARP:
		format_arp(p, offset);
		break;
	default:
		format_ip(p, offset);
		offset = strlen(pt_->buffer());
		switch(ch->ptype()) {
                case PT_SLP:
                        format_slp(p, offset);
                        break;
		case PT_AODV:
			format_aodv(p, offset);
			break;
                case PT_BCAST:
                        format_bcast(p, offset);
                        break;
                case PT_FLOOD:
                        format_flood(p, offset);
                        break;
		case PT_TORA:
                        format_tora(p, offset);
                        break;
                case PT_IMEP:
                        format_imep(p, offset);
                        break;
		case PT_DSR:
			format_dsr(p, offset);
			break;
		case PT_MESSAGE:
		case PT_UDP:
			format_msg(p, offset);
			break;
		case PT_TCP:
		case PT_ACK:
			format_tcp(p, offset);
			break;
		case PT_SCTP:
			/* Armando L. Caro Jr. <acaro@@cis,udel,edu> 6/5/2002
			 */
			format_sctp(p, offset);
			break;
		case PT_CBR:
			format_rtp(p, offset);
			break;
	        case PT_DIFF:
			break;
		case PT_GAF:
		case PT_PING:
			break;
		default:
			fprintf(stderr, "%s - invalid packet type (%s).\n",
				__PRETTY_FUNCTION__, packet_info.name(ch->ptype()));
			exit(1);
		}
	}
}

int
CMUTrace::command(int argc, const char*const* argv)
{
	
        if(argc == 3) {
                if(strcmp(argv[1], "node") == 0) {
                        node_ = (MobileNode*) TclObject::lookup(argv[2]);
                        if(node_ == 0)
                                return TCL_ERROR;
                        return TCL_OK;
                }
		if (strcmp(argv[1], "newtrace") == 0) {
			newtrace_ = atoi(argv[2]);
		        return TCL_OK;
		}
        }
	return Trace::command(argc, argv);
}

/*ARGSUSED*/
void
CMUTrace::recv(Packet *p, Handler *h)
{
	if (!node_energy()) {
		Packet::free(p);
		return;
	}
        assert(initialized());
        /*
         * Agent Trace "stamp" the packet with the optimal route on
         * sending.
         */
        if (tracetype == TR_AGENT && type_ == SEND) {
                God::instance()->stampPacket(p);
        }
#if 0
        /*
         * When the originator of a packet drops the packet, it may or may
         * not have been stamped by GOD.  Stamp it before logging the
         * information.
         */
        if(src_ == src && type_ == DROP) {
                God::instance()->stampPacket(p);
        }
#endif
	format(p, "---");
	pt_->dump();
	//namdump();
	if(target_ == 0)
		Packet::free(p);
	else
		send(p, h);
}

void
CMUTrace::recv(Packet *p, const char* why)
{
        assert(initialized() && type_ == DROP);
	if (!node_energy()) {
		Packet::free(p);
		return;
	}
#if 0
        /*
         * When the originator of a packet drops the packet, it may or may
         * not have been stamped by GOD.  Stamp it before logging the
         * information.
         */
        if(src_ == ih->saddr()) {
                God::instance()->stampPacket(p);
        }
#endif
	format(p, why);
	pt_->dump();
	//namdump();
	Packet::free(p);
}

int CMUTrace::node_energy()
{
	Node* thisnode = Node::get_node_by_address(src_);
	double energy = 1;
	if (thisnode) {
		if (thisnode->energy_model()) {
			energy = thisnode->energy_model()->energy();
		}
	} 
	if (energy > 0) return 1;
	return 0;
}