almah.cc

为NS2仿真中的一个overlay多播协议的协议模块

void ALMAHRefreshTopologyTimer::handle(Event*) {
	if(agent->index!=0){
		if(agent->parent_in != -1)
			agent->sendParentIn(0);
		Scheduler::instance().schedule(this, &intr, agent->TREE_INT );
	}

}

void ALMAH_Agent::sendJOIN_REQ(){

    Packet* pkt = allocpkt();
    hdr_almah* hdr = hdr_almah::access(pkt);
    hdr_cmn* ch = HDR_CMN(pkt);
    ch->next_hop() = -1;
	ch->size_=8+8;
    hdr->Message_ID = 1;
    hdr->src_IP =  this->addr();
    hdr_ip* hdr_IP = hdr_ip::access(pkt);
    hdr_IP->dst_.addr_ = IP_BROADCAST;
    //hdr_IP->dst_.port_ = RT_PORT;
    hdr_IP->ttl_ = this->req_last_ttl;
    hdr_IP->dport() = 5;
    forwardBroadcast(pkt);
    return;
}


void ALMAH_Agent::sendRequestTopology(int RV_P){
    
      Packet* pktret = allocpkt();
      hdr_almah* hdrret = hdr_almah::access(pktret);
      hdr_cmn* ch = HDR_CMN(pktret);
      hdr_ip* ipret = hdr_ip::access(pktret);
      hdrret->Message_ID = 15;
      ipret->daddr() = RV_P;
      ipret->dport() = ipret->sport();
	  ch->size_=8+8;          
	  REQUEST_TOPOLOGY_STATUS = true;
	  Scheduler::instance().schedule(&topreqtimer, pktret, 0);	  	  
      return;
}

void ALMAH_Agent::sendTopology(int dst_){

      Packet* pktret = allocpkt();
      hdr_almah* hdrret = hdr_almah::access(pktret);
      hdr_cmn* ch = HDR_CMN(pktret);
      hdr_ip* ipret = hdr_ip::access(pktret);
      hdrret->Message_ID = 16;
	  if(this->topology_list!=NULL)
			hdrret->PathList = new lista(this->topology_list);
	  else
			hdrret->PathList = NULL; //new lista();
      ipret->daddr() = dst_;
      ipret->dport() = ipret->sport();
	  ch->size_=8+8;     
      send(pktret, 0);//claudio
      return;
}



void ALMAH_Agent::sendJOIN_ACK(Packet* pkt){

      hdr_ip* hdrip = hdr_ip::access(pkt);
      u_int32_t srchd = hdrip->saddr();     
      Packet* pktret = allocpkt();
      hdr_almah* hdrret = hdr_almah::access(pktret);
      hdr_cmn* ch = HDR_CMN(pktret);
      hdr_ip* ipret = hdr_ip::access(pktret);
      hdrret->Message_ID = 2;
      ipret->daddr() = srchd;
      ipret->dport() = ipret->sport();
	  ch->size_=8+8;     
      send(pktret, 0);
      return;
}



void ALMAH_Agent::sendRequestSwitch(int node){

		if(!this->SWITCHING)
			return;
      Packet* pktret = allocpkt();
      hdr_almah* hdrret = hdr_almah::access(pktret);
      hdr_cmn* ch = HDR_CMN(pktret);
      hdr_ip* ipret = hdr_ip::access(pktret);
      hdrret->Message_ID = 17;
      ipret->daddr() = node;
      ipret->dport() = ipret->sport();
	  ch->size_=8+8;     
	  Scheduler::instance().schedule(&ttimer_2, pktret, 0);	  	  
      return;
}

void ALMAH_Agent::sendAckSwitch(int node){
 
      Packet* pktret = allocpkt();
      hdr_almah* hdrret = hdr_almah::access(pktret);
      hdr_cmn* ch = HDR_CMN(pktret);
      hdr_ip* ipret = hdr_ip::access(pktret);
      hdrret->Message_ID = 18;
      ipret->daddr() = node;
      ipret->dport() = ipret->sport();
	  ch->size_=8+8;     
      send(pktret, 0);
      return;
}

void ALMAH_Agent::recvAckSwitch(Packet* pkt, Handler*){

    hdr_ip* hdrip = hdr_ip::access(pkt);
	if(this->SWITCHING && parent_in!=-1){
			SWITCHING = false;
			NACKING = true;
			send_NACK(parent_in);
			parent_in_switch = parent_in;
			parent_in = hdrip->saddr();
			nb_insert(parent_in);
			parent_in_distance = 0;			
			sendParentIn(0);
			sendHello(hdrip->saddr());
			delete path_list;
			path_list = NULL;
			switch_time_on = true;
			Scheduler::instance().schedule(&ptimer,(new Event),1);

	}
    Packet::free(pkt);
    return;
}

void ALMAH_Agent::recvRequestSwitch(Packet* pkt, Handler*){

    hdr_ip* hdrip = hdr_ip::access(pkt);   
    int src = hdrip->saddr();
    OBAMP_Overlay_Neighbor *nb;
    nb = nb_lookup(hdrip->saddr());
    if(nb == 0 && this->parent_in_switch != hdrip->saddr() && this->parent_in != hdrip->saddr() && !switch_time_on) {
        if(nb_lookup(src)==NULL)
			nb_insert(src);
		this->sendAckSwitch(src);
    }else if(nb != 0 && this->parent_in_switch != hdrip->saddr() && this->parent_in != hdrip->saddr() && !switch_time_on){
		if(nb_lookup(src)==NULL)
			nb_insert(src);
		this->sendAckSwitch(src);
    }
    Packet::free(pkt);
    return;
}

void ALMAH_Agent::recvRequestTopology(Packet* pkt, Handler*){

    hdr_ip* hdrip = hdr_ip::access(pkt);
    int src = hdrip->saddr();  
	this->sendTopology(src);
    Packet::free(pkt);    
    return;
}

void ALMAH_Agent::recvTopology(Packet* pkt, Handler*){

    double now = CURRENT_TIME;
    hdr_almah* hdr = hdr_almah::access(pkt);  
	if(REQUEST_TOPOLOGY_STATUS == false){
		 Packet::free(pkt);
		return;
	}
	else REQUEST_TOPOLOGY_STATUS = false;
	if(this->topology_list!= NULL)
		delete this->topology_list;
	if(hdr->PathList!=NULL)
		this->topology_list = new lista(hdr->PathList);
	
	if(TH_DISTANCE_SETTED == 1)
		this->NeighborDist1(this->parent_in);	// set in the mb table all not descendand neighbours at one hop from parent_in
	else 
		this->NeighborDistN(this->parent_in, TH_DISTANCE_SETTED); // set in the mb table all not descendand neighbours at TH_DISTANCE_SETTED hops from parent_in

	OBAMP_Overlay_Neighbor *mb;
    OBAMP_Overlay_Neighbor *mbn;
    mb = mbhead.lh_first;     
    if(mb!=0){
            for(; mb; mb = mbn) {
                mbn = mb->nb_link.le_next;
				mb->nb_expire = now;
                this->sendPING(mb->nb_addr,0);
           }
	Scheduler::instance().schedule(&dttimer,(new Event),1);
	}	
    Packet::free(pkt);
    return;
}

void ALMAH_Agent::recvJOIN_ACK(Packet* pkt, Handler*){

    hdr_ip* hdrip = hdr_ip::access(pkt);
    if(parent_in == -1) {		
        parent_in = hdrip->saddr();
        nb_insert(hdrip->saddr());
		ON_PingTimer = 1;
        this->found_neighbour=true;
		JOIN_ACKING = true;
		Event* h = (Event*)pkt;
		Scheduler::instance().schedule(&htimer_2, h , 0);
		return;	
    } 
    Packet::free(pkt);
    return;
}

void ALMAH_Agent::recvJOIN_REQ(Packet* pkt, Handler*){

  hdr_ip* hdrip = hdr_ip::access(pkt);
  assert((u_int32_t)hdrip->daddr() == IP_BROADCAST);
  if(index ==0){
		this->sendJOIN_ACK(pkt);
  }else{
	  if(this->parent_in!=-1){
		  if(this->path_list==NULL || this->path_list->trova(hdrip->saddr())==NULL){
				this->sendJOIN_ACK(pkt);
		  }
	  }
  }
  if(here_.addr_ != hdrip->saddr()){
    forwardBroadcast(pkt);
  }
  else{
     drop(pkt, "CLAUDIO");
  }  
  return;
}

void ALMAH_Agent::recvParentIn(Packet* pkt, Handler*){

    hdr_almah* hdr = hdr_almah::access(pkt);  
	tree_analyzer_list_elem* el_new = hdr->PathList->get_ultimo();	
    hdr_ip* hdrip = hdr_ip::access(pkt);
    int src = hdrip->saddr();
	if(this->topology_list!=NULL){
		tree_analyzer_list_elem* el_old = this->topology_list->trova_ordine(src, 1);
		if(el_old == NULL){
			topology_list->inserisci(src, el_new->D);
		}else{
			el_old->D = el_new->D;
		}
	}else{
			topology_list = new lista();
			topology_list->inserisci(src, el_new->D);
	}
    Packet::free(pkt);
    return;
}

void ALMAH_Agent::sendParentIn(int RV_P){

      Packet* pktret = allocpkt();
      hdr_almah* hdrret = hdr_almah::access(pktret);
      hdr_cmn* ch = HDR_CMN(pktret);
      hdr_ip* ipret = hdr_ip::access(pktret);
      hdrret->Message_ID = 14;
	  hdrret->PathList = new lista();
	  hdrret->PathList->inserisci(index, parent_in);
      ipret->daddr() = RV_P;
      ipret->dport() = ipret->sport();
	  ch->size_=8+8;     
      send(pktret, 0);
      return;
}

bool ALMAH_Agent::NeighborDist1(int node){

	OBAMP_Overlay_Neighbor* mb = NULL;
	tree_analyzer_list_elem* el = NULL;
	mb_purge_all();
	mb = mbhead.lh_first;
	if(this->topology_list==NULL || this->topology_list->numero_elementi == 0)
		return false;
	el = topology_list->get_elemento(node,false);
	if(el==NULL)
		return false;
	if(el->S != index && el->D != index){
		if(el->S != node)
			mb_insert(el->S);
		else
			mb_insert(el->D);
	}
	while(topology_list->pt != NULL){
			el = topology_list->get_elemento(node,true);
			if(el==NULL)
				return true;
			if(el->S != index && el->D != index){
				if(el->S != node)
					mb_insert(el->S);
				else
					mb_insert(el->D);
			}
	}	
	return true;
}

bool ALMAH_Agent::NeighborDist(){

	OBAMP_Overlay_Neighbor* mb = NULL;
	OBAMP_Overlay_Neighbor *mbn = NULL;	
	tree_analyzer_list_elem* el = NULL;
	mb = mbhead.lh_first;
	if(mb!=0){
            for(; mb; mb = mbn) {
				el = this->topology_list->trova_ordine(mb->nb_addr,2,false);
				if(el!=NULL){
					if(mb_lookup(el->S)==NULL && el->S != index && el->S != parent_in)
						mb_insert(el->S);
					el = this->topology_list->trova_ordine(mb->nb_addr,2,true);
					while(el!=NULL){
						if(mb_lookup(el->S)==NULL && el->S != index && el->S != parent_in)
							mb_insert(el->S);
						el = this->topology_list->trova_ordine(mb->nb_addr,2,true);
					}
				}
				el = this->topology_list->trova_ordine(mb->nb_addr,1,false);
				if(el!=NULL){
					if(mb_lookup(el->D)==NULL && el->D != index && el->D != parent_in)
						mb_insert(el->D);
					el = this->topology_list->trova_ordine(mb->nb_addr,1,true);
					while(el!=NULL){
						if(mb_lookup(el->S)==NULL && el->D != index && el->D != parent_in)
							mb_insert(el->D);
						el = this->topology_list->trova_ordine(mb->nb_addr,1,true);
					}
				}
				mbn = mb->nb_link.le_next;
            }
	}
	return true;
}
	

bool ALMAH_Agent::NeighborDistN(int node, int order){
	
	int k = order;
	this->NeighborDist1(node);
	k--;
	while(k>0){
		this->NeighborDist();
		k--;
	}
	return true;

}

void ALMAH_Agent::RefreshParent(){
		
		if (hop_based_mode==0) {
			if((parent_in_rtt > threshold_level1) && (parent_in_rtt < threshold_level2)){
					sendRequestTopology(0);
					TH_DISTANCE_SETTED = 1;
			}else if(this->parent_in_rtt >= threshold_level2 && (parent_in_rtt < threshold_level3)){
					sendRequestTopology(0);
					TH_DISTANCE_SETTED = 2;
			} else if(this->parent_in_rtt >= threshold_level3 && (parent_in_rtt < threshold_level4)){
					sendRequestTopology(0);
					TH_DISTANCE_SETTED = 3;
			} else if (parent_in_rtt >= threshold_level4) {
					sendRequestTopology(0);
					TH_DISTANCE_SETTED = 4;
			}
		} else {
			if((parent_in_distance > threshold_level1) && (parent_in_distance <= threshold_level2)){
					sendRequestTopology(0);
					TH_DISTANCE_SETTED = 1;
			}else if(parent_in_distance > threshold_level2 && parent_in_distance <= threshold_level3){
					sendRequestTopology(0);
					TH_DISTANCE_SETTED = 2;
			}else if(parent_in_distance > threshold_level3 && parent_in_distance <= threshold_level4){
					sendRequestTopology(0);
					TH_DISTANCE_SETTED = 3;
			} else if(parent_in_distance > threshold_level4){
					sendRequestTopology(0);
					TH_DISTANCE_SETTED = 4;
			}
		}
		return;
}

void ALMAH_Agent::switch_parent(){
		
		double now = CURRENT_TIME;
		if(SWITCHING || NACKING)
			return;
		int distance = 100;
		double rtt = 100000;
		OBAMP_Overlay_Neighbor *mb;
		OBAMP_Overlay_Neighbor *mbn;
		OBAMP_Overlay_Neighbor *mb_switch = NULL;
		mb = mbhead.lh_first;
		if(mb!=0){
            for(; mb; mb = mbn) {
                if (hop_based_mode==0) {
                	    if(mb->nb_expire > now && mb->last_receiving_time < rtt){
						rtt = mb->last_receiving_time;
						mb_switch = mb;									
					}     
                } 
                else {
	                if(mb->nb_expire > now && mb->distance < distance){
						distance = mb->distance;
						mb_switch = mb;									
					}
                }
				mbn = mb->nb_link.le_next;
            }
					
			if((distance < this->parent_in_distance && hop_based_mode!=0) || (rtt < this->parent_in_rtt && hop_based_mode==0) ){
				this->SWITCHING = true;
				this->sendRequestSwitch(mb_switch->nb_addr);
			}
		}
		return;
}

void
ALMAHJoinACKNotifyTimer::handle(Event* h) {
  				  Packet* pkt = (Packet*)h;
				  int node;
				  hdr_ip* ipret = hdr_ip::access(pkt);
				  node = ipret->daddr();
				  if(agent->JOIN_ACKING){
					  Packet* pkt = (Packet*)h;
					  Packet* new_pkt = pkt->copy();
					  agent->sendJOINACKNotify(pkt);
					  Scheduler::instance().schedule(this, new_pkt, 1);

				  }else{ 
					  	Packet* pkt = (Packet*)h;
						Packet::free(pkt);						
				  }
}

void ALMAH_Agent::recvJOINACKNotify(Packet* pkt, Handler*){

    hdr_ip* hdrip = hdr_ip::access(pkt); 
    OBAMP_Overlay_Neighbor *nb = nb_lookup(hdrip->saddr());
    if(nb == 0) {
        nb_insert(hdrip->saddr());
    }    
	sendJOINACKConf(pkt);
    return;
}
void ALMAH_Agent::sendJOINACKNotify(Packet* pkt){

      hdr_ip* hdrip = hdr_ip::access(pkt);
	  u_int32_t srchd = hdrip->saddr();
      Packet* pktret = allocpkt();
      hdr_almah* hdrret = hdr_almah::access(pktret);
      hdr_cmn* ch = HDR_CMN(pktret);
      hdr_ip* ipret = hdr_ip::access(pktret);
      hdrret->Message_ID = 10;
	  ch->size_=8+8;
	  ipret->daddr() = srchd;
      ipret->dport() = ipret->sport();
	  send(pktret, 0);
      return;
}

void ALMAH_Agent::sendJOINACKConf(Packet* pkt){

		hdr_almah* hdrret = hdr_almah::access(pkt);
        hdr_cmn* ch = HDR_CMN(pkt);
        hdr_ip* ipret = hdr_ip::access(pkt);        
		hdrret->Message_ID = 23;
        hdrret->src_IP = here_.addr_;
	    ch->size_=8+8;
		ch->num_forwards()=0;
		ch->direction()=hdr_cmn::DOWN;
		ipret->daddr() = ipret->saddr();
        ipret->saddr() = index;
        send(pkt, 0);       
		return;
}

void ALMAH_Agent::recvJOINACKConf(Packet* pkt){

		JOIN_ACKING = false;
		Packet::free(pkt);		
		return;
}