rlc-umts.cc

对ns2软件进行UMTS扩展

					rlch->frag() = info_[i].fraged_;
				}
				ch->size() += RLC_HDR_SZ;
				s.schedule(downtarget_, p, delay_);
			}
		}
	}
	return;
}

void RlcUmts::recvDATA(Packet* p)
{
	int i;
	hdr_cmn *ch = HDR_CMN(p);
	hdr_ip *ih = HDR_IP(p);
	hdr_rlc_umts *rh = HDR_RLC_UMTS(p);

	i = look_for(ih->flowid());

	Scheduler& s = Scheduler::instance();

	if (ch->direction() == hdr_cmn::UP){
		if (rlcverbose_==1) fprintf(stderr,"<%d> %f RLC: DATA on its way up. call sendupDATA\n", ip_ue_, NOW);
		if ((info_[i].fraged_) || (info_[i].acked_)){
			ch->size() -= RLC_HDR_SZ;
			sendUpDATA(p, i);
		} else {
			ch->size() -= RLC_HDR_SZ;
			s.schedule(uptarget_, p, delay_);
		}
	}else{
		ch->direction() = hdr_cmn::DOWN;
		if (rlcverbose_==1) fprintf(stderr,"<%d> %f RLC: DATA going down. call enqueDATA\n", ip_ue_, NOW);
		if ((info_[i].fraged_) || (info_[i].acked_)){
			enqueDATA(p, i);
		} else {
			ch->size() += RLC_HDR_SZ;
			s.schedule(downtarget_, p, delay_);
		}
	}
}


void RlcUmts::enqueDATA(Packet* p, int pos)
{
	hdr_cmn *ch = HDR_CMN(p);
	hdr_ip *ih = HDR_IP(p);
	hdr_rlc_umts *rlch = HDR_RLC_UMTS(p);

	rlch->rlctype() = RLC_DATA;

	//fragmenting to start here....
	int psize, mod;
	if(info_[pos].fraged_ == 1)
		psize = rlcfragsz_;
	else
		psize = ch->size_;

	int bopno = info_[pos].seqno_;
	int eopno = bopno + (int)((ch->size_-1)/psize);

	int i;

	for ( i = bopno; i <= eopno; i++){
		Packet * sp = p->copy();
		hdr_cmn *chsp = HDR_CMN(sp);
		hdr_rlc_umts *rlchsp = HDR_RLC_UMTS(sp);

		rlchsp->frag_ = info_[pos].fraged_;
		rlchsp->ack_ = info_[pos].acked_;
		rlchsp->seqno_ = 0;
		rlchsp->bopno_ = bopno;
		rlchsp->eopno_ = eopno;
		rlchsp->psize_ = chsp->size_; //hack for now to remeber uid
		chsp->size_ = psize;
		chsp->size() += RLC_HDR_SZ;

		if (info_[pos].acked_ == 0){
			rlchsp->seqno_ = i;
			info_[pos].seqno_++;
			Scheduler& s = Scheduler::instance();
			if (rlcverbose_==1) fprintf(stderr,"<%d> %f RLC: sending NON-acked down. pkt uid=%d seqno %d\n",
					ip_ue_, NOW,chsp->uid_, rlchsp->seqno_);
			s.schedule(downtarget_, sp, delay_);
		}else{
			rlchsp->seqno_ = i;
			info_[pos].seqno_++;
			buf_->enque(sp);
			if (rlcverbose_==1) fprintf(stderr,"<%d> %f RLC: buffering frag. rlc_seqno=%d for pkt uid=%d buf_len=%d\n"
					, ip_ue_, NOW, rlchsp->seqno_,chsp->uid_, buf_->length());
		}
	}
	if (info_[pos].acked_==1)
		sendDownDATA(pos);

	return;
}

void RlcUmts::sendDownDATA(int pos)
{
	Packet* sp;

	// not more pkts of this flow to tx
	if (length_ >= buf_->length()) {
		length_ = 0;
		return;
	}

	if(!(sp = buf_->deque())){
		length_ = 0;
		return;
	}

	length_++;
	hdr_ip *ihsp = HDR_IP(sp);
	if (ihsp->flowid() != info_[pos].flow_) {
		buf_->enque(sp);
		sendDownDATA(pos);
	} else {
		hdr_rlc_umts *rlcsp = HDR_RLC_UMTS(sp);
		if(info_[pos].Txbuf_->length() < info_[pos].window_){
			info_[pos].Txbuf_->enque(sp->copy());
			if (rlcverbose_==1) fprintf (stderr, "<%d> %f RLC: Txbuf not full[%d]=%d,sending a data down, rlc_seq=%d from buf\n",
					ip_ue_, NOW, pos,info_[pos].Txbuf_->length(),rlcsp->seqno_);
			Scheduler& s = Scheduler::instance();
			s.schedule(downtarget_, sp, delay_);
			length_--;
			sendDownDATA(pos);
		}else{
			length_ = 0;
			if (rlcverbose_==1) fprintf (stderr, "<%d> %f RLC: Txbuf full. couldnt send rlc_seqno=%d \n",
					ip_ue_, NOW, rlcsp->seqno_);
			buf_->enqueHead(sp);
		}
	}
	return;
}

void RlcUmts::recvACK(Packet* p)
{
	int i, Txlen, first, last, temp;

	hdr_rlc_umts *rlch = HDR_RLC_UMTS(p);
	hdr_ip *ih = HDR_IP(p);

	i = look_for(ih->flowid());

	if (rlch->ackno_==info_[i].ackno_) {
		if (rlcverbose_==1)
		fprintf(stderr,"\n<%d> %f RLC: recvd duplicate RLC_ACK num %d until %d\n",
				            ip_ue_, NOW, rlch->ackno_,rlch->eopno_);
		first = rlch->bopno_;
		last = rlch->eopno_;
		for (temp=first; temp<last; temp++){
			sendDownDATAonACK(i, temp);
		}
		Packet::free(p);
		return;
	}
	else if(info_[i].ackno_ < rlch->ackno_){
		info_[i].ackno_ = rlch->ackno_;
	} else {
		Packet::free(p);
		return;
	}

	Txlen=info_[i].Txbuf_->length();
	if (rlcverbose_==1) fprintf(stderr,"<%d> %f RLC: recvd ACK num %d waiting %d buf length %d pos %d\n",
			ip_ue_, NOW, rlch->ackno_, info_[i].ackno_, Txlen, i);

	Packet* sp=info_[i].Txbuf_->head();

	//delete pkts with seqno < ackno
	for (int j=0; j<Txlen; j++){
		hdr_rlc_umts *rlchsp= HDR_RLC_UMTS(sp);
		if((rlchsp->seqno_)<info_[i].ackno_){
			info_[i].Txbuf_->remove(sp);
			if (rlcverbose_==1) fprintf(stderr, "<%d> %f RLC: deleted pkt from tx buffer; rlc seqno=%d TxLen %d\n",
					ip_ue_, NOW, rlchsp->seqno_, info_[i].Txbuf_->length());
		}
		sp = sp->next_;
	}

	if ((info_[i].Txbuf_->length() > 0) && (info_[i].Txbuf_->length() < info_[i].window_)){
			sendDownDATA(i);
	}
}

void RlcUmts::sendDownDATAonACK(int pos, int seqno)
{
	Packet* sp=info_[pos].Txbuf_->head();
	int Txlen_=info_[pos].Txbuf_->length();

	for(int i=0; i<Txlen_; i++){

		hdr_rlc_umts *rlchsp= HDR_RLC_UMTS(sp);

		if((rlchsp->seqno_) == seqno){
			if (rlcverbose_==1)
			fprintf(stderr,"<%d> %f RLC: retx pkt from txbuf seqno=%d, eopno=%d\n",
					ip_ue_, NOW,rlchsp->seqno_,rlchsp->eopno_);
			Scheduler& s = Scheduler::instance();
			s.schedule(downtarget_, sp->copy(), delay_);
			return;
		}
		sp = sp->next_;
	}
}

void RlcUmts::sendUpDATA(Packet* p, int pos)
{
	int flag;
	if (hdr_cmn::access(p)->error() > 0)
		drop(p);
	else{
		hdr_cmn *ch = HDR_CMN(p);
		hdr_rlc_umts *rlch = HDR_RLC_UMTS(p);
		hdr_ll *llch = HDR_LL(p);
		hdr_ip *iph = HDR_IP(p);

		if(info_[pos].acked_==0){
			if (rlch->seqno_ == info_[pos].unackseqno_){
                		info_[pos].unackseqno_++;

				if (rlch->seqno_ == rlch->eopno_ ){
					ch->size_ = rlch->psize_;
					if (rlcverbose_ == 1) fprintf(stderr ,"<%d> %f RLC: nonack. recvd all rlc frags for pktuid=%d ll_seqno=%d \n",
							ip_ue_, NOW, ch->uid_, llch->seqno_);
					Scheduler& s = Scheduler::instance();
					s.schedule(uptarget_, p, delay_);
				} else {
					if (rlcverbose_==1) fprintf(stderr ,"<%d> %f RLC: nonack. pkts not inseq. not sent up\n",ip_ue_, NOW);
					Packet::free(p);
                		}

            	} else if (rlch->seqno_ == hinfo_[pos].unackseqno_){
                		hinfo_[pos].unackseqno_++;

				if (rlch->seqno_ == rlch->eopno_ ){
					ch->size_ = rlch->psize_;
					if (rlcverbose_ == 1) fprintf(stderr ,"<%d> %f RLC: nonack. recvd all rlc frags for pktuid=%d ll_seqno=%d \n",
							ip_ue_, NOW, ch->uid_, llch->seqno_);
					Scheduler& s = Scheduler::instance();
					s.schedule(uptarget_, p, delay_);
				} else {
					if (rlcverbose_==1) fprintf(stderr ,"<%d> %f RLC: nonack. pkts not inseq. not sent up\n",ip_ue_, NOW);
					Packet::free(p);
                		}

			} else if ((rlch->seqno() == rlch->bopno()) && (rlch->bopno() == 0)){
				// in case wired--> wireless
				info_[pos].unackseqno_ = 1;

				if (rlch->seqno_ == rlch->eopno_ ){
					ch->size_ = rlch->psize_;
					if (rlcverbose_ == 1) fprintf(stderr ,"<%d> %f RLC: nonack. recvd all rlc frags for pktuid=%d ll_seqno=%d \n",
							ip_ue_, NOW, ch->uid_, llch->seqno_);
					Scheduler& s = Scheduler::instance();
					s.schedule(uptarget_, p, delay_);
				} else {
					if (rlcverbose_==1) fprintf(stderr ,"<%d> %f RLC: nonack. pkts not inseq. not sent up\n",ip_ue_, NOW);
					Packet::free(p);
                		}

			} else {
                		info_[pos].unackseqno_ = rlch->seqno_ + 1;
				Packet::free(p);
 			}
			return;

		}else{
			if(rlch->seqno_ == (info_[pos].rackno_+1)){
				info_[pos].rackno_++;
				info_[pos].numdups_ = 0;
				info_[pos].lastRx_ = p->copy();
				if ( rlch->seqno_ == rlch->eopno_ ){
					ch->size_ = rlch->psize_;
		  			if (rlcverbose_==1) fprintf(stderr , "<%d> %f RLC:ACK mode:send up to LL pktuid=%d llseqno=%d \n",
						ip_ue_, NOW,ch->uid_, llch->seqno_);
					Scheduler& s = Scheduler::instance();
					s.schedule(uptarget_, p, delay_);
				} else {
			   		if (rlcverbose_==1) fprintf(stderr ,"<%d> %f RLC:ACK mode: recvd rlc_seqno=%d for pkt uid=%d ll_seqno=%d \n"
					   ,ip_ue_, NOW, rlch->seqno_,  ch->uid_ , llch->seqno_);
				}
				flag=1;
				while(flag){
					flag=0;
					if(info_[pos].Rxbuf_->length()!=0){
						Packet* sp = info_[pos].Rxbuf_->head();
						int Rxlen_ = info_[pos].Rxbuf_->length();
						for(int i=1; i<=Rxlen_; i++){
							hdr_rlc_umts* rlcsp = HDR_RLC_UMTS(sp);
							if(rlcsp->seqno_ == (info_[pos].rackno_+1)){
								info_[pos].rackno_++;
								info_[pos].lastRx_ = sp->copy();
								flag=1;
								hdr_cmn* chsp=HDR_CMN(sp);
								if ( rlcsp->seqno_ == rlcsp->eopno_ ){
									chsp->size_ = rlcsp->psize_;
									if (rlcverbose_ == 1) fprintf(stderr,"<%d> %f RLC: pkt in rxbuf: send up uid=%d seqno=%d bopno=%d eopno=%d \n",
											ip_ue_, NOW,ch->uid_,rlch->seqno_,rlch->bopno_,rlch->eopno_);
									Scheduler& s = Scheduler::instance();
									s.schedule(uptarget_, sp->copy(), delay_);
								} else {
									if (rlcverbose_==1) fprintf(stderr , "<%d> %f RLC: pkt in rxbuf: drop uid=%d seqno=%d bopno=%d eopno=%d next_hop %d \n", ip_ue_, NOW,chsp->uid_,rlcsp->seqno_,rlcsp->bopno_,rlcsp->eopno_,chsp->next_hop());
								}
								info_[pos].Rxbuf_->remove(sp);
							}
							sp=sp->next_;
						}
					}
				}
				sendACK(p, pos);

			} else if ((handover_) && (rlch->seqno_ == (hinfo_[pos].rackno_+1))) {
				hinfo_[pos].rackno_++;
				hinfo_[pos].numdups_ = 0;
				if (rlcverbose_ == 1) fprintf(stderr , "<%d> %f RLC: hrackno=%d, src=%d \n",
					ip_ue_, NOW, hinfo_[pos].rackno_,Address::instance().get_nodeaddr(iph->saddr()));
				if ( rlch->seqno_ == rlch->eopno_ ){
					ch->size_ = rlch->psize_;
					if (rlcverbose_==1) fprintf(stderr , "<%d> %f RLC:ACK mode:send up to LL pktuid=%d llseqno=%d \n",
						ip_ue_, NOW,ch->uid_, llch->seqno_);
					Scheduler& s = Scheduler::instance();
					s.schedule(uptarget_, p, delay_);
				} else {
					if (rlcverbose_==1) fprintf(stderr ,"<%d> %f RLC:ACK mode: recvd rlc_seqno=%d for pkt uid=%d ll_seqno=%d \n"
					,ip_ue_, NOW, rlch->seqno_,  ch->uid_ , llch->seqno_);
				}
				flag=1;
				while(flag){
					flag=0;
					if(info_[pos].Rxbuf_->length()!=0){
						Packet* sp = info_[pos].Rxbuf_->head();
						int Rxlen_ = info_[pos].Rxbuf_->length();
						for(int i=1; i<=Rxlen_; i++){
							hdr_rlc_umts* rlcsp = HDR_RLC_UMTS(sp);
							if(rlcsp->seqno_ == (hinfo_[pos].rackno_+1)){
								hinfo_[pos].rackno_++;
								flag=1;
								hdr_cmn* chsp=HDR_CMN(sp);
								if ( rlcsp->seqno_ == rlcsp->eopno_ ){
									chsp->size_ = rlcsp->psize_;
									if (rlcverbose_ == 1) fprintf(stderr,"<%d> %f RLC: pkt in rxbuf: send up uid=%d seqno=%d bopno=%d eopno=%d \n",
											ip_ue_, NOW,ch->uid_,rlch->seqno_,rlch->bopno_,rlch->eopno_);
									Scheduler& s = Scheduler::instance();
									s.schedule(uptarget_, sp->copy(), delay_);
								} else {
									if (rlcverbose_==1) fprintf(stderr , "<%d> %f RLC: pkt in rxbuf: drop uid=%d seqno=%d bopno=%d eopno=%d next_hop %d \n",
										ip_ue_, NOW,chsp->uid_,rlcsp->seqno_,rlcsp->bopno_,rlcsp->eopno_,chsp->next_hop());
								}
								info_[pos].Rxbuf_->remove(sp);
							}
							sp=sp->next_;
						}
					}
				}
				sendACK(p, pos);

			}else if(rlch->seqno_ > (info_[pos].rackno_+1)){
				info_[pos].Rxbuf_->enque(p);
	     			if (info_[pos].numdups_ < 1){
					if (rlcverbose_==1) fprintf (stderr,"<%d> %f RLC: pkt out of seq, buf in rxbuf;send duplicate ackseqno=%d\n", ip_ue_, NOW,rlch->seqno_);
					sendACK(p, pos);
					info_[pos].numdups_ ++;

				}
			}
		}
	}
}

void RlcUmts::sendACK(Packet* p, int pos)
{

		hdr_cmn *ch = HDR_CMN(p);
		hdr_phy *ph = HDR_PHY_UMTS(p);
		hdr_ip *iph = HDR_IP(p);

		Packet* sp = Packet::alloc();
		hdr_cmn *chsp = HDR_CMN(sp);
		hdr_rlc_umts *rlchsp = HDR_RLC_UMTS(sp);
		hdr_phy *phsp = HDR_PHY_UMTS(sp);
		hdr_ip *iphsp = HDR_IP(sp);

		chsp->next_hop_= Address::instance().get_nodeaddr(ch->prev_hop_);
		chsp->prev_hop_=Address::instance().get_nodeaddr(iph->daddr());
		chsp->channel_t() = CCCH;
		chsp->addr_type_ = ch->addr_type_;
		chsp->direction_ = hdr_cmn::DOWN;
		chsp->ptype_=PT_ACK;
		chsp->size_=6;
		chsp->iface()= -2;
		chsp->error()= 0;
		chsp->uid()= info_[pos].rackno_+1;

		iphsp->saddr() = iph->daddr();
		iphsp->daddr() = iph->saddr();
		iphsp->flowid() = iph->flowid();

		rlchsp->rlctype() = RLC_ACK;
		rlchsp->ackno_ = info_[pos].rackno_+1;
		rlchsp->bopno_ = info_[pos].rackno_+1;

		int len, vt;
		len=info_[pos].Rxbuf_->length();
		Packet* ptemp=info_[pos].Rxbuf_->head();
		if (ptemp != NULL) {
			struct hdr_rlc_umts *pth = HDR_RLC_UMTS(ptemp);
			vt = pth->seqno_;
			ptemp = ptemp->next_;
			for (int j=1; j<len; j++) {
				pth = HDR_RLC_UMTS(ptemp);
				if (pth->seqno_ < vt){
					vt = pth->seqno_;
				}
				ptemp = ptemp->next_;
			}
			rlchsp->eopno_ = vt;
		} else {
			rlchsp->eopno_ = rlchsp->bopno_+1;
		}

		phsp->da() = ph->sa();

		Scheduler& s = Scheduler::instance();
		s.schedule(downtarget_, sp, delay_);
		rtx_->start(info_[pos].flow_, 0.05);
		if (rlcverbose_==1)
		fprintf(stderr,"<%d> %f RLC: send RLCACK num %d in pos %d with first %d last %d\n",
				ip_ue_, NOW, rlchsp->ackno_, pos,rlchsp->bopno_,rlchsp->eopno_);
}

void RlcUmts::rTxHandler(int flow)
{
	if (rlcverbose_)
		printf("UE %d at %f RLC: Timer of flow %d expired. Retransmit ack\n", ip_ue_, NOW, flow);
	int pos = look_for(flow);
	sendACK(info_[pos].lastRx_, pos);
	return;
}