wimedia.cc

ns2.31下的UWB（Ultra WideBand）实现

	
	pnc_->ProcessPacket(p);
	
	Host2 *h = &cache_[src];
	
	if(flowid < 0 || flowid >= MAX_FLOWS) {
		discard(p, "FID");
		return;
	}

	stats_.ReceiveFragFromLower(index_, flowid, pktRx_);
	
	if(mh->fragged_) {
		if(mh->frag_seq_ == 0) {
			if(fraq_cache_[flowid] != 0) {
				// Here we have one duplicate first frag
				hdr_mac *mh_header = HDR_MAC(fraq_cache_[flowid]);
				if(mh->seq_no_ > mh_header->seq_no_) {
					Packet::free(fraq_cache_[flowid]);
				}
				else if(mh->seq_no_ == mh_header->seq_no_) {
					Packet::free(fraq_cache_[flowid]);
				}
				else {
					exit(1);
				}
			} // End of duplicate first frag
			// Here receive the first fragmentation
			fraq_cache_[flowid] = p;
		} // End of (ifmh->frag_seq_ == 0
		// if a continued fragmentation
		else {
			if(fraq_cache_[flowid] == 0) {
				Packet::free(p);
			}
			else {
				hdr_mac *mh_header = HDR_MAC(fraq_cache_[flowid]);
				if(mh->seq_no_ == mh_header->seq_no_) {
					if(mh->frag_seq_ == (mh_header->frag_seq_ + 1)) {
						// Receive a new fragmentation
						hdr_cmn *ch_header = HDR_CMN(fraq_cache_[flowid]);
						ch_header->size() += ch->size();
						++mh_header->frag_seq_;
						Packet::free(p);
						if(mh_header->frag_seq_ == (mh_header->frag_count_ - 1)) {
							if(h->seqno_[flowid] && h->seqno_[flowid] == mh_header->seq_no_) {
								exit(1);
								stats_.ReceiveDuplicateFragFromLower(index_, flowid, p);
								discard(fraq_cache_[flowid], DROP_MAC_DUPLICATE);
								return;
							}
							h->seqno_[flowid] = mh_header->seq_no_;
							stats_.ReceiveFrameFromLower(index_, flowid, fraq_cache_[flowid]);
							fraq_cache_[flowid]->incoming = 1;
							uptarget_->recv(fraq_cache_[flowid], (Handler*)0);
							fraq_cache_[flowid] = 0;
						}
					}// End of if(mh->frag_seq_ == (mh_header->frag_seq_ + 1))
					// Here Duplicate frame
					else if(mh->frag_seq_ <= mh_header->frag_seq_) {
						stats_.ReceiveDuplicateFragFromLower(index_, flowid, p);
						Packet::free(p);
					}
					// Here missing packets
					else {
						Packet::free(fraq_cache_[flowid]);
						Packet::free(p);
						fraq_cache_[flowid] = 0;
						stats_.FailedDefragmentation(index_, flowid, p);
					}
				} // End of if(mh->seq_no_ == mh_header->seq_no_)
				else if(mh->seq_no_ > mh_header->seq_no_) {
					Packet::free(p);
				}
				else {
					exit(1);
				}
			}
		}
	} // End of (if(mh->fragged_)
	// Here if not fragged
	else {
		if(fraq_cache_[flowid] != 0) {
			Packet::free(fraq_cache_[flowid]);
			fraq_cache_[flowid] = 0;
		}
		if(h->seqno_[flowid] && h->seqno_[flowid] >= mh->seq_no_) {
			stats_.ReceiveDuplicateFragFromLower(index_, flowid, p);	
			discard(p, DROP_MAC_DUPLICATE);
			return;
		}
		h->seqno_[flowid] = mh->seq_no_;
		stats_.ReceiveFrameFromLower(index_, flowid, p);
		p->incoming = 1;
		uptarget_->recv(p, (Handler*)0);
	}	
}	

void Mac_WiMedia::CreateAckPacket(int dst, MacACKType ack_type) {
	Packet *p = Packet::alloc();	
	
	hdr_cmn *ch = HDR_CMN(p);
	struct hdr_mac *mh = HDR_MAC(p);
	
	ch->uid() = 0;	
	ch->ptype() = PT_MAC;
	ch->size() = TotalLen_ACK();
	ch->iface() = -2;
	ch->error() = 0;
	
	mh->macDA_ = dst;
	mh->macSA_ = index_;
	mh->ftype_ = MF_ACK;
	mh->ack_type_ = ack_type;
	mh->txtime_ = TxTime(p);
	
	pktACK_ = p;
}
void Mac_WiMedia::WriteACKIDs(int flowid, bool bBeacon, int nOffset, Packet * pTempACK) {
	struct hdr_mac *mhACK = HDR_MAC(pTempACK);
	int nIdx = nOffset;
		
	int nMax = MAX_ACKED_PACKETS;
	if(bBeacon)
		nMax = MAX_ACKED_IN_BEACON;
	list <Packet*>::iterator iEnd = PacketsToBeAcked_[flowid].end();
	for(list <Packet*>::iterator i = PacketsToBeAcked_[flowid].begin(); i != iEnd; ++i) {
		struct hdr_mac *mhPkt = HDR_MAC(*i);
		struct hdr_ip *ihPkt = HDR_IP(*i);
		
		if(!bBeacon) {
			mhACK->acked_packets_[nIdx][0] = mhPkt->seq_no_;
			mhACK->acked_packets_[nIdx][1] = mhPkt->frag_seq_;
			if(mhPkt->fragged_)
				mhACK->acked_packets_[nIdx][2] = mhPkt->frag_count_;
			else
				mhACK->acked_packets_[nIdx][2] = 0;
		}
		else {
			mhACK->beacon_.ms_acked_seqno_[nIdx] = ihPkt->fid_;
			mhACK->beacon_.ms_acked_packets_[nIdx][0] = mhPkt->seq_no_;
			mhACK->beacon_.ms_acked_packets_[nIdx][1] = mhPkt->frag_seq_;
			if(mhPkt->fragged_)
				mhACK->beacon_.ms_acked_packets_[nIdx][2] = mhPkt->frag_count_;
			else
				mhACK->beacon_.ms_acked_packets_[nIdx][2] = 0;
		}
		++nIdx;
	}
	
	if(!bBeacon) {
		mhACK->acked_packets_[nIdx][0] = -1;
		mhACK->acked_packets_[nIdx][1] = -1;
		mhACK->acked_packets_[nIdx][2] = -1;
	}
	else {
		mhACK->beacon_.ms_acked_seqno_[nIdx] = -1;
		mhACK->beacon_.ms_acked_packets_[nIdx][0] = -1;
		mhACK->beacon_.ms_acked_packets_[nIdx][1] = -1;
		mhACK->beacon_.ms_acked_packets_[nIdx][2] = -1;
	}

	if(nIdx >= nMax) {
		// Too many packets to be acked
		exit(1);
	}
}

void Mac_WiMedia::CheckReceiveDataBuffer(int flowid) {
	list <Packet*>::iterator iEnd = PacketsToBeAcked_[flowid].end();
	for(list<Packet*>::iterator i = PacketsToBeAcked_[flowid].begin(); i != iEnd; ++i) {
		Packet *p = (*i);
		struct hdr_mac *mhPkt = HDR_MAC(p);
		int seq_no = mhPkt->seq_no_;
		int frag_no = mhPkt->frag_seq_;
		int frag_count = mhPkt->frag_count_;
		
		if(!mhPkt->fragged_)
			frag_count = 0;
		if(seq_no == nNextPacketToUpper_[flowid]) {
			if(frag_count == 0) {
				++nNextPacketToUpper_[flowid];
				SendDataToUp(p->copy());
			}
			else {
				if(frag_no == nNextFragToUpper_[flowid]) {
					++nNextFragToUpper_[flowid];
					if(nNextFragToUpper_[flowid] == frag_count) {
						++nNextPacketToUpper_[flowid];
						nNextFragToUpper_[flowid] = 0;
					}
					SendDataToUp(p->copy());
				}
				else if(frag_no > nNextFragToUpper_[flowid])
					break;
			}
		}
		else if(seq_no > nNextPacketToUpper_[flowid])
			break;
	}
}

void Mac_WiMedia::recvDATA(Packet *p) {
	struct hdr_mac *mh = HDR_MAC(p);
	struct hdr_cmn *ch = HDR_CMN(p);
	int dst = mh->macDA_;
	int src = mh->macSA_;
	
	ch->num_forwards() += 1;
	hdr_ip *ih = HDR_IP(p);
	
	int flowid = ih->fid_;
	if((u_int32_t)dst != MAC_BROADCAST || (ih->dst_).addr_ == index_) {
		switch(mh->ack_type_) {
		case ACK_None:
			SendDataToUp(p);
			break;
		case ACK_Immediate:
			CreateAckPacket(src, ACK_Immediate);
			tx_resume(macmib_->sifs);
			SendDataToUp(p);
			break;
		case ACK_Beacon:
		case ACK_Delayed:
		{
			if((mh->ack_type_ == ACK_Beacon) && (!isPNC_)) {
				exit(1);
			}
			if((int)PacketsToBeAcked_[flowid].size() > flow_list_[flowid].nMaxAcks_) {
				list <Packet*>::iterator i = PacketsToBeAcked_[flowid].begin();
				list <Packet*>::iterator iEnd = PacketsToBeAcked_[flowid].end();
				while(i != iEnd) {
					struct hdr_mac *mhPkt = HDR_MAC(*i);
					if(!mhPkt->fragged_) {
						nNextPacketToUpper_[flowid] = mhPkt->seq_no_ + 1;
						nNextFragToUpper_[flowid] = 0;
					}
					else {
						if(mhPkt->frag_seq_ >= (mhPkt->frag_count_ - 1)) {
							nNextPacketToUpper_[flowid] = mhPkt->seq_no_ + 1;
	                                                nNextFragToUpper_[flowid] = 0;
						}
						else {
							nNextPacketToUpper_[flowid] = mhPkt->seq_no_;
                                                	nNextFragToUpper_[flowid] = mhPkt->frag_seq_ + 1;
						}
					}
					SendDataToUp(*i);
					i = PacketsToBeAcked_[flowid].erase(i);
					iEnd = PacketsToBeAcked_[flowid].end();
				}
			} // End of if
			if(bResetPToBeAckedOnRx_[flowid] == true) {
				list <Packet*>::iterator i = PacketsToBeAcked_[flowid].begin();
				list <Packet*>::iterator iEnd = PacketsToBeAcked_[flowid].end();
				while(i != iEnd) {
					bool bDelete = false;	
					struct hdr_mac *mhPkt = HDR_MAC(*i);
					int seq_no = mhPkt->seq_no_;
					int frag_no = mhPkt->frag_seq_;
					int frag_count = mhPkt->frag_count_;
					if(!mhPkt->fragged_)
						frag_count = 0;
					if(seq_no < nNextPacketToUpper_[flowid])
						bDelete = true;
					else if(seq_no == nNextPacketToUpper_[flowid]) {
						if(frag_count == 0)
							bDelete = false;
						else {
							if(frag_no < nNextFragToUpper_[flowid])
								bDelete = true;
							else 
								bDelete = false;
						}
					}
					else 
						bDelete = false;
					if(bDelete) {
						Packet::free(*i);
						i = PacketsToBeAcked_[flowid].erase(i);	
						iEnd = PacketsToBeAcked_[flowid].end();
					}
					else 
						++i;
				}
			}
			// Now add this new packet in a sorted way
			list <Packet*>::iterator i = PacketsToBeAcked_[flowid].begin();
			list <Packet*>::iterator iEnd = PacketsToBeAcked_[flowid].end();
			while(i != iEnd) {
				struct hdr_mac *mhTemp = HDR_MAC(*i);
				if(mh->seq_no_ < mhTemp->seq_no_) {
					PacketsToBeAcked_[flowid].insert(i, p);
					break;
				}
				else if((mh->seq_no_ == mhTemp->seq_no_) && mh->fragged_) {
					if(mh->frag_seq_ < mhTemp->frag_seq_) {
						PacketsToBeAcked_[flowid].insert(i, p);
						break;
					}
				}
				++i;
			}
			if(i == iEnd)
				PacketsToBeAcked_[flowid].push_back(p);
			if(mh->bRequestDelayedAck_) {
				bResetPToBeAckedOnRx_[flowid] = true;
				CreateAckPacket(src, ACK_Delayed);
				WriteACKIDs(flowid, false, 0, pktACK_);
				tx_resume(macmib_->sifs);
			}
			else {
				bResetPToBeAckedOnRx_[flowid] = false;
			}
			CheckReceiveDataBuffer(flowid);		
		} // End of switch
		break;
		}
	} // End of if
}

void Mac_WiMedia::OnRxTimer() {
// not finished
	hdr_cmn *ch = HDR_CMN(pktRx_);
	hdr_mac *mh = HDR_MAC(pktRx_);
	hdr_ip *ih = HDR_IP(pktRx_);
	u_int32_t dst = (u_int32_t)mh->macDA_;
	int src = mh->macSA_;

	MacFrameType ftype = mh->ftype_;

	if(tx_active_) {
		Packet::free(pktRx_);
		goto done;
	} // End of if
	++nTotalReceivedFrags_;
	
	// Handle collisions
	if(rx_state_ == MAC_COLL) {
		discard(pktRx_, DROP_MAC_COLLISION);
		goto done;
	} // End of if
	if(ch->error()) {
		++nCorruptedReceivedFrags_;
		stats_.ReceiveCorruptedFromLower(index_, pktRx_);
		printf("WiMedia.cc OnRxTimer()-> Errors in the packet\n");
		Packet::free(pktRx_);
		goto done;
	} // End of if

	//tap out
	if(tap_ && mh->ftype_ == MF_DATA)
		tap_->tap(pktRx_);
	if(dst != (u_int32_t)index_ && dst != MAC_BROADCAST) {
		discard(pktRx_, "---");
		goto done;
	} // End of if
	
	rx_state_ = MAC_IDLE;
	switch(ftype) {
	case MF_BEACON:
		recvBeacon(pktRx_);
		break;
	case MF_MS_BEACON:
		recvMSBeacon(pktRx_);
		break;
	case MF_ACK:
		recvACK(pktRx_);
		break;
	case MF_DATA:
		recvDATA(pktRx_);
		break;
	case MF_NULL:
		pnc_->ProcessPacket(pktRx_);
		if(mh->bRequestDelayedAck_) {
			bResetPToBeAckedOnRx_[ih->fid_] = true;
			CreateAckPacket(src, ACK_Delayed);
			WriteACKIDs(ih->fid_,false, 0, pktACK_);
			tx_resume(macmib_->sifs);
		}
		Packet::free(pktRx_);
		break;
	default:
		exit(1);
	} // End of if
done:
	pktRx_ = 0;
	rx_resume();

	if(ftype = MF_ACK)
		CheckNRTQueue(false);
}

void Mac_WiMedia::recv(Packet *p, Handler *h) {
	// Dapeng Debug
	//	printf("WiMedia.cc -> recv() start!\n");

	struct hdr_cmn *hdr = HDR_CMN(p);
	struct hdr_ip *ih = HDR_IP(p);
	struct hdr_mac *mh = HDR_MAC(p);

	/* Here we get one packet to be sent down */
	if(hdr->direction() == hdr_cmn::DOWN) {
                AddNewPacket(p,h);
		return;
        }
	
	// If not returned, after the above line is excuted 
	if((ih->dst_).addr_ == index_)
		mhBackoff_.pause();
	if(tx_active_ && hdr->error() == 0)
		hdr->error() = 1;
	if(rx_state_ == MAC_IDLE)
	{
		rx_state_ = MAC_RECV;
		pktRx_ = p;
		
		mhRecv_.start(TxTime(p));
	}
	else
		collision(p);
}

/* ======================================
   Mac Class Functions: Send a packet to 
   lower level module, called by recv()
   ====================================== */

void Mac_WiMedia::CreateDataPacket(Packet *p) {
	struct hdr_cmn* ch = HDR_CMN(p);
	struct hdr_mac* mh = HDR_MAC(p);
	struct hdr_ip* ih = HDR_IP(p);
	// Dapeng Debug
	printf("WiMedia.cc::CreateDataPacket\n");	
	ch->size() += TotalLen_Header();

	mh->macSA_ = index_;
	mh->macDA_ = (ih->dst_).addr_;
	mh->ftype_ = MF_DATA;
	mh->txtime_ = TxTime(p);
	mh->bRequestDelayedAck_ = false;
	// Dapeng Debug
	printf("WiMedia.cc:: Created Packet\n mh->macSA_:%d\n mh->macDA_:%d\n mh->ftype_:%d\n mh->txtime_:%f\n", mh->macSA_, mh->macDA_, mh->ftype_, mh->txtime_);
}

void Mac_WiMedia::QAddPacket(Packet *p) {
	struct hdr_cmn* ch = HDR_CMN(p);
	struct hdr_ip* ih = HDR_IP(p);
	// struct hdr_mac* mh = HDR_MAC(p);

	int flowid = ih->fid_;
	if(flowid >= MAX_FLOWS || flowid < 0)
		exit(1);
	
	if(bDoFragmentation_ && (ch->size() > (max_frag_size_ + TotalLen_Header()))) {
		int nFragments = (int)ceil(((double)ch->size() - TotalLen_Header()) / ((double)max_frag_size_));
		for(int i = 0; i <(nFragments - 1); i++) {
			Packet *pTemp = p->copy();
			struct hdr_cmn* ch_temp = HDR_CMN(pTemp);
			ch_temp->size() = max_frag_size_ + TotalLen_Header();
			struct hdr_mac* mh_temp = HDR_MAC(pTemp);
			mh_temp->fragged_ = true;
			mh_temp->frag_count_ = nFragments;
			mh_temp->frag_seq_ = i;
			packet_queue_[flowid].push_back(pTemp);
		}
		// Add the tail packet
		Packet *pTemp = p->copy();
		struct hdr_cmn* ch_temp = HDR_CMN(pTemp);
		ch_temp->size() = ch->size() - ((nFragments - 1) * max_frag_size_);
		if(ch_temp->size() > TotalLen_Header()) {
			struct hdr_mac* mh_temp = HDR_MAC(pTemp);
			mh_temp->fragged_ = true;
			mh_temp->frag_count_ = nFragments;
			mh_temp->frag_seq_ = nFragments - 1;
			
			packet_queue_[flowid].push_back(pTemp);
		}
		else if (ch_temp->size() < TotalLen_Header()) {
			exit(1);
		}
		else 
			exit(1);

		flow_list_[flowid].qs_ = packet_queue_[flowid].size();
		Packet::free(p);
	}
	else {
		packet_queue_[flowid].push_back(p);
		flow_list_[flowid].qs_ = packet_queue_[flowid].size();
	}
}
	 
void Mac_WiMedia::AddNewPacket(Packet *p, Handler *h) {
	struct hdr_mac* mh = HDR_MAC(p);
	struct hdr_ip* ih = HDR_IP(p);
	// Dapeng Debug
	printf("Mac_WiMedia::AddNewpacket\n");	
	CreateDataPacket(p);

	int flowid = ih->fid_;
	if(flowid < 0 || flowid >= MAX_FLOWS) {
		exit(1);
		Packet::free(p);
		Handler *h = callback_;
		callback_ = 0;
		h->handle((Event*)0);
		return;
	}
	
	stats_.ReceiveFrameFromUpper(index_, flowid, p);
	// struct hdr_cmn* ch = HDR_CMN(p);
	mh->seq_no_ = sta_seqno_[flowid]++;
	mh->timestamp_ = Scheduler::instance().clock();
	
	QAddPacket(p);
	
	h->handle((Event*)0);

	if(isPNC_) {
		struct hdr_cmn* chTemp = HDR_CMN(pktNULL_);
		struct hdr_mac* mhTemp = HDR_MAC(pktNULL_);
		struct hdr_ip* ihTemp = HDR_IP(pktNULL_);
		chTemp->size() = TotalLen_Header();
		chTemp->uid() = 0;
		chTemp->ptype() = PT_MAC;
		chTemp->error() = 0;
		mhTemp->ftype_ = MF_NULL;
		mhTemp->macDA_ = 0;
		mhTemp->macSA_ = index_;
		ihTemp->fid_ = flowid;
		mhTemp->qs_ = QPacketCount(flowid) + QUnAckedPacketCount(flowid);
		mhTemp->stream_index_ = (u_char)ih->fid_;
		pnc_->ProcessPacket(pktNULL_);
	}
	if(is_idle() && (current_traffic_type_ != Traffic_NRT)) {
		if((Scheduler::instance().clock() - last_ack_received_) >= macmib_->sifs)
			CheckQueues(0, MAC_IDLE);
		else {
			double defer_duration = macmib_->sifs - (Scheduler::instance().clock() - last_ack_received_);
			if(defer_duration > macmib_->sifs || defer_duration < 0)
				exit(1);
			CheckQueues(defer_duration, MAC_IDLE);
		}
	}
	else if(current_traffic_type_ == Traffic_NRT) {
		if(is_idle())
			CheckNRTQueue(true);
	}	
}