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 ifdone:	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);	}	}