mac-802_16-bs.cc

OPNET 中的Wimax模块, 主要用于wimax 无线网络仿真,以及普通无线网络仿真.

    Note: if it's a concat frame-  this means its a concat request.

    \param p the packet
*/
void Mac802_16BS::HandleInMgmt(Packet *p)
{
  struct hdr_cmn* ch = HDR_CMN(p);
  struct hdr_mac802_16* dh = HDR_MAC802_16(p);
  u_char concat_fr = 0;
  int cindex,findex;   /* Need to call classify for best-effort flow... */
  u_int16_t flow_id, req;
  bool aggregate = false; //$A25
  
  ParseExtHdr(p);
  
#ifdef TRACE_BS //---------------------------------------------------------
  printf("HandleInMgmt:  fc_parm = %d\n",dh->dshdr_.fc_parm);
#endif //--------------------------------------------------------------------
  switch(dh->dshdr_.fc_parm) 
    {
    //$A25
    case 4:
      aggregate = true; /*Aggretate bw request*/
    case 2: /* Request frame header */
      req = dh->dshdr_.mac_param ;
      flow_id = dh->dshdr_.len;
      find_flowindex(flow_id,&cindex,&findex);
      SSStatistics_.num_creq++;
      total_num_req_pkts_US++; 
#ifdef TRACE_BS //---------------------------------------------------------
      printf("HandleInMgmt:  req=%d, flow_id=%d\n",req,flow_id);
#endif //--------------------------------------------------------------------

      /*$A25 
      HandleReq(req, cindex, findex);*/
      HandleReq(req, cindex, findex, aggregate);
      break;
      
    case 3: /* Fragmentation frame header */
      //dump_pkt(p);
      //printf("received...\n");
      
      total_num_frag_pkts_US++; 
      HandleFrag(p);
      break;
      
    case 26: /* Concatenation frame header */
      //cindex = classify(p, UPSTREAM, &findex);

#ifdef TRACE_BS //---------------------------------------------------------
      cindex = classify(p, UPSTREAM, &findex);
      printf("Concatenation:  cindex = %d, findex = %d\n",cindex,findex);
#endif //--------------------------------------------------------------------

      concat_fr = 1;
      total_num_concat_pkts_US++; 
      HandleConcat(p, cindex, findex);
      break;	

    case 1:
      /* Rng Message */
      /* Do nothing */
      total_num_rng_pkts_US++; 
      break;       

    default:  //Error
#ifdef TRACE_BS 
      printf("Concatenation:  Error:  fc_parm: %d\n",dh->dshdr_.fc_parm);
#endif
      break;
    }
  
  double curr_time = Scheduler::instance().clock();
  
  if (curr_time - last_mmgmttime >= 1.0)
    {
      last_mmgmttime = curr_time;
      avg_mgmtpkts = (avg_mgmtpkts + num_mgmtpkts )/ 2;
      avg_mgmtbytes = (avg_mgmtbytes + num_mgmtbytes )/ 2;
      num_mgmtpkts = 0;
      num_mgmtbytes = 0;

#ifdef TRACE_BS //-------------------------------------------------------
      printf("Avg Management pkts received %d Avg Management bytes %d \n",
	     avg_mgmtpkts,avg_mgmtbytes);
#endif //------------------------------------------------------------------
    }
  
  num_mgmtpkts++;
  num_mgmtbytes += ch->size();
  
  if (!concat_fr)
    {
      //#A7
      total_num_mgt_pkts_US++;
      num_bytes += ch->size();
      total_num_rx_pkts++;
      util_total_pkts_US ++;
      total_num_rx_bytes += ch->size();
      util_total_bytes_US += ch->size(); /* Used for end of run util stat */     
      util_bytes_US += ch->size();       /* Used for dump802_16UtilStat */     
      total_num_BW_bytesUP += ch->size();
             
#ifdef TRACE_BS_UP_DATA//------------------------------------------------
      printf("BSup %lf %f %d\n",
	     Scheduler::instance().clock(),total_num_rx_bytes,ch->size());
#endif //------------------------------------------------------------------
    }  
  else 
    {
      //don't update stats else will double count the first packet in the 
      //concatonated frame
      //util_total_pkts_US ++;
      
      num_bytes += 6 + upchannel.overhead_bytes;
      total_num_rx_bytes += 6 + upchannel.overhead_bytes;
      util_total_bytes_US += 6 + upchannel.overhead_bytes; /* Used for end of run util stat */     
      util_bytes_US += 6 + upchannel.overhead_bytes;       /* Used for dump802_16UtilStat */     
      total_num_BW_bytesUP += 6 + upchannel.overhead_bytes;

#ifdef TRACE_BS_UP_DATA //----------------------------------------------
      printf("BSup %lf %f %d\n",
	     Scheduler::instance().clock(),total_num_rx_bytes,ch->size());
#endif //-----------------------------------------------------------------
    }
  	
#ifdef PACKET_TRACE //----------------------------------------------------------------------

#ifdef TRACE_BS 
  printf("BS:HandleInMgtFrame(%lf): PACKET_TRACE :  received a Mgt frame with fc_parm %d\n", 
	 Scheduler::instance().clock(),dh->dshdr_.fc_parm);
#endif

  int rc_p=0;    
  int ss=0;
  int flow=0;	
  int direction_p = 0;
  
  if(HDR_CMN(p)->direction() == hdr_cmn::DOWN)
    direction_p = 0;  
  else if(HDR_CMN(p)->direction() == hdr_cmn::UP)
    direction_p = 1;
  
  if(FLOW_ID==0 && SS_ID==0)
    rc_p=packetTrace(p,direction_p);  
  else
    {
      ss = classify(p, UPSTREAM, &flow);	
      
      if ((ss == SS_ID && FLOW_ID == 0) || 
	  (SS_ID == 0 && flow == FLOW_ID)|| 
	  (ss == SS_ID && FLOW_ID == flow))
	rc_p = packetTrace(p, direction_p);
    }	

  if(rc_p!=0)
    printf("BS:PACKET_TRACE: Packet trace monitor failed\n"); 
#endif //-----------------------------------------------------------------------------
  	
  Packet::free(p);
  p = 0;  
  return;  
}

/*****************************************************************************

*****************************************************************************/
void Mac802_16BS::find_flowindex(u_int16_t flow_id, int* cindex, int* findex)
{
  int i,j;
  
  for (i = 0; i < SizeSSTable; i++)
    {
      for (j = 0; j < SSRecord[i].SizeUpFlTable; j++) /* For each flow */
	{
	  if (SSRecord[i].u_rec[j].flow_id == flow_id)
	    {
	      *cindex = i;
	      *findex = j;
	      return;
	    }
	}
    }
  printf("Mac802_16BS::find_flowindex error, flow-id not found, exiting\n");
  exit(1);
}

/*****************************************************************************
 * Routine: void Mac802_16BS::HandleFrag(Packet *p)
 *
 * inputs:  The frame containing a fragment
 *
 * output:
 *
 * Note:  the total_num_BE_pkts counter includes each fragment
 *
*****************************************************************************/
/*! 
 \param p The frame containing a fragment
  */
void Mac802_16BS::HandleFrag(Packet *p)
{
  struct hdr_cmn* ch = HDR_CMN(p);
  struct hdr_mac802_16extd* eh = HDR_MAC802_16EXTD(p);
  struct hdr_mac802_16* dh = HDR_MAC802_16(p);
  int * data = (int *)p->accessdata();
  int cindex,findex;
  u_int16_t flow_id;
  int frag_index = -1;
  
  //printf("Num_hdr = %d\n",eh->num_hdr);
  
  for (int i = 0; i < eh->num_hdr; i++)
    {
      if (eh->exthdr_[i].eh_type == 3)
	frag_index = i;
    }

  if (frag_index == -1)
    {
      printf("HandleFrag:  ERROR: Fragmentation header not present in extended header\n");
      exit(1);
    }
  /* classify the fragmented pkt on the flow.. */
  flow_id = eh->exthdr_[frag_index].eh_data[5];
  find_flowindex(flow_id,&cindex,&findex);

#ifdef TRACE_BS //---------------------------------------------------------
  printf("Fragmented packet received on %d\n",flow_id);
#endif //--------------------------------------------------------------------
  
  total_num_BE_pkts_US++;
  
  if (bit_on(SSRecord[cindex].u_rec[findex].flag, FRAG_ON_BIT))
    {
      if (!dh->dshdr_.ehdr_on)
	{
	  printf("Mac802_16BS->handle_frag: ERROR: EHDR not on in fragmented packet, Discarding the packet\n");
	  drop(p);
	  //Also, at other error points in this routine, we need to propagate an error to the caller...
	  //total_packets_dropped++;    
	  SSRecord[cindex].u_rec[findex].frag_pkt = 0;
	  set_bit(&SSRecord[cindex].u_rec[findex].flag, FRAG_ON_BIT,OFF);
	  SSRecord[cindex].u_rec[findex].frag_data = 0;
	  SSRecord[cindex].u_rec[findex].seq_num = 0;
	  return;	  
	}
      
      if (eh->exthdr_[frag_index].eh_data[2] == 1) /* First Fragment flag */
	{
	  printf("Flow_id %d Mac802_16BS->handle_frag: ERROR:  First fragment flag set in middle fragments\n",flow_id);
	  //	drop(p);
	  SSRecord[cindex].u_rec[findex].frag_pkt = 0;
	  set_bit(&SSRecord[cindex].u_rec[findex].flag, FRAG_ON_BIT,OFF);
	  SSRecord[cindex].u_rec[findex].frag_data = 0;
	  SSRecord[cindex].u_rec[findex].seq_num = 0;
	  return;	  
	}

      if (SSRecord[cindex].u_rec[findex].seq_num == eh->exthdr_[frag_index].eh_data[4])
	{
	  ch->size() -= ETHER_HDR_LEN;
	  ch->size() -= MAC802_16_HDR_LEN;
	  ch->size() -= upchannel.overhead_bytes;
	  ch->size() -= 10; /* Overhead of fragmentation header */
	  ch->num_forwards() += 1;
	  SSRecord[cindex].u_rec[findex].frag_data += ch->size();
	  SSRecord[cindex].u_rec[findex].seq_num++; 
	  
	  if (eh->exthdr_[frag_index].eh_data[1] > 0)
	    {
	      SSStatistics_.num_piggyreq++;
	      /*$A25
                HandleReq(eh->exthdr_[frag_index].eh_data[1],cindex,findex);*/
	      HandleReq(eh->exthdr_[frag_index].eh_data[1],cindex,findex,false);

	    }
	  
	  if (eh->exthdr_[frag_index].eh_data[3] == 1) /* Last fragment flag */
	    {
#ifdef TRACE_BS 
	      printf("Flow-id %d Turning-off fragmentation and passing the pkt..\n",flow_id);
#endif
	      set_bit(&SSRecord[cindex].u_rec[findex].flag, FRAG_ON_BIT,OFF);
	      SSRecord[cindex].u_rec[findex].frag_data = 0;
	      SSRecord[cindex].u_rec[findex].seq_num = 0;

	      //ParseExtHdr(p);

	      RecvFrame( SSRecord[cindex].u_rec[findex].frag_pkt,1 );
	      SSRecord[cindex].u_rec[findex].frag_pkt = 0;

	      /* Check for piggyback request */	      
	    }	  
	}      
      else
	{
	  printf("Mac802_16BS->handle_frag: ERROR: Seq num mismatch 1, Discarding the packet\n");

	  //	drop(p);

	  set_bit(&SSRecord[cindex].u_rec[findex].flag, FRAG_ON_BIT,OFF);
	  SSRecord[cindex].u_rec[findex].seq_num = 0;
	  SSRecord[cindex].u_rec[findex].frag_pkt = 0;
	  SSRecord[cindex].u_rec[findex].frag_data = 0;
	  return;
	}
    }  
  else if (eh->exthdr_[frag_index].eh_data[2] == 1) /* First Fragment flag */
    {
      
#ifdef TRACE_BS //-----------------------------------------------------
      printf("Received first fragment at bs..\n");
#endif //----------------------------------------------------------------
      
      ch->size() -= ETHER_HDR_LEN;
      ch->size() -= MAC802_16_HDR_LEN;
      ch->size() -= 10; /* Overhead of fragmentation header */
      ch->num_forwards() += 1;
      set_bit(&SSRecord[cindex].u_rec[findex].flag, FRAG_ON_BIT,ON);
      SSRecord[cindex].u_rec[findex].seq_num = eh->exthdr_[frag_index].eh_data[4] + 1;
      SSRecord[cindex].u_rec[findex].frag_data = ch->size();
      SSRecord[cindex].u_rec[findex].frag_pkt = (Packet*)(*data) ;
      
      struct hdr_cmn* fh = HDR_CMN( SSRecord[cindex].u_rec[findex].frag_pkt);

      fh->direction() = hdr_cmn::UP; /* change the direction of the pkt */
      
      if (eh->exthdr_[frag_index].eh_data[1] > 0)
	{
	  SSStatistics_.num_piggyreq++;
          /*$A25
	    HandleReq(eh->exthdr_[frag_index].eh_data[1],cindex,findex);*/
	  HandleReq(eh->exthdr_[frag_index].eh_data[1],cindex,findex,false);
	}      
    } 
  else
    {
      /* Might be a probelm on return if a drop the pkt ? */
      //drop(p);
      printf("Mac802_16BS->handle_frag: ERROR: Fragment not correct ??\n");
    }
  return ;
}

/*****************************************************************************

*****************************************************************************/
void Mac802_16BS::HandleConcat(Packet *p, int cindex, int findex)
{
  struct hdr_mac802_16* dh = HDR_MAC802_16(p);
  Packet* q;
  int * data = (int *)p->accessdata();
  int i = 0;

#ifdef TRACE_BS //-------------------------------------------------------
  printf("BS:HandleConcat(%lf): hdr mac param: %d\n", 
	 Scheduler::instance().clock(),dh->dshdr_.mac_param);
#endif //------------------------------------------------------------------
	
  for ( i = 0; i < dh->dshdr_.mac_param; i++)
    {
      q = (Packet* )*data++;
      struct hdr_cmn* ch = HDR_CMN(q);
      
      ch->direction() = hdr_cmn::UP; /* change the direction of the pkt
					else they r pushed back */