开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 网络 > 查看源码
ssscheduler.cc
资源名称：WiMAX_Protocol_Code.rar　[点击查看]
上传用户：hzie11
上传日期：2013-10-07
资源大小：1487k
文件大小：47k
源码类别：

网络

开发平台：

C/C++

ssscheduler.cc：源码内容
  1. /* This software was developed at the National Institute of Standards and
  2.  * Technology by employees of the Federal Government in the course of
  3.  * their official duties. Pursuant to title 17 Section 105 of the United
  4.  * States Code this software is not subject to copyright protection and
  5.  * is in the public domain.
  6.  * NIST assumes no responsibility whatsoever for its use by other parties,
  7.  * and makes no guarantees, expressed or implied, about its quality,
  8.  * reliability, or any other characteristic.
  9.  * <BR>
  10.  * We would appreciate acknowledgement if the software is used.
  11.  * <BR>
  12.  * NIST ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" CONDITION AND
  13.  * DISCLAIM ANY LIABILITY OF ANY KIND FOR ANY DAMAGES WHATSOEVER RESULTING
  14.  * FROM THE USE OF THIS SOFTWARE.
  15.  * </PRE></P>
  16.  * @author  rouil
  17.  */
  19. #include "ssscheduler.h"
  20. #include "burst.h"
  22. /**
  23.  * Tcl hook for creating SS scheduler 
  24.  */
  25. static class SSschedulerClass : public TclClass {
  26. public:
  27.   SSschedulerClass() : TclClass("WimaxScheduler/SS") {}
  28.   TclObject* create(int, const char*const*) {
  29.     return (new SSscheduler());
  30.     
  31.   }
  32. } class_ssscheduler;
  34. /*
  35.  * Create a scheduler
  36.  */
  37. SSscheduler::SSscheduler (): t1timer_(0),t2timer_(0),t6timer_(0), t12timer_(0),
  38.      t21timer_(0), lostDLMAPtimer_(0), lostULMAPtimer_(0),
  39.      t44timer_(0), scan_info_(0)
  40. {
  41.   debug2 ("SSscheduler createdn");
  42. }
  44. /**
  45.  * Initializes the scheduler
  46.  */
  47. void SSscheduler::init ()
  48. {
  49.   WimaxScheduler::init();
  50.   
  51.   //At initialization, the SS is looking for synchronization
  52.   mac_->setMacState (MAC802_16_WAIT_DL_SYNCH);
  53.   mac_->getPhy()->setMode (OFDM_RECV);
  54.   //start timer for expiration
  55.   t21timer_ = new WimaxT21Timer (mac_);
  56.   t21timer_->start (mac_->macmib_.t21_timeout);
  58.   //creates other timers
  59.   t1timer_ = new WimaxT1Timer (mac_);
  60.   t12timer_ = new WimaxT12Timer (mac_);
  61.   t2timer_ = new WimaxT2Timer (mac_);
  62.   lostDLMAPtimer_ = new WimaxLostDLMAPTimer (mac_);
  63.   lostULMAPtimer_ = new WimaxLostULMAPTimer (mac_);
  65.   nb_scan_req_ = 0;
  67.   scan_info_ = (struct scanning_structure *) malloc (sizeof (struct scanning_structure));
  68.   memset (scan_info_, 0, sizeof (struct scanning_structure));
  69.   scan_info_->nbr = NULL;
  70.   scan_info_->substate = NORMAL;
  71. }
  73. /**
  74.  * Interface with the TCL script
  75.  * @param argc The number of parameter
  76.  * @param argv The list of parameters
  77.  */
  78. int SSscheduler::command(int argc, const char*const* argv)
  79. {
  80.   if (argc == 2) {
  81.     if (strcmp(argv[1], "send-scan") == 0) {
  82.       send_scan_request();
  83.       return TCL_OK;
  84.     }
  85.   }
  86.   
  87.   return TCL_ERROR;
  88. }
  90. /**
  91.  * Start a new frame
  92.  */
  93. void SSscheduler::start_dlsubframe ()
  94. {
  95.   //mac_->debug ("At %f in Mac %d SS scheduler dlsubframe expires %dn", NOW, mac_->addr(), scan_info_->substate);
  97.   mac_->frame_number_++;
  99.   switch (scan_info_->substate) {
  100.   case SCAN_PENDING: 
  101.     if (scan_info_->count == 0) {
  102.       resume_scanning();
  103.       return;
  104.     } 
  105.     scan_info_->count--;
  106.     break;
  107.   case HANDOVER_PENDING:
  108.     if (scan_info_->handoff_timeout == 0) {
  109.       assert (scan_info_->nbr);
  110. #ifdef USE_802_21
  111.       mac_->debug ("At %f in Mac %d link handoff proceedingn", NOW, mac_->addr());
  112.       mac_->send_link_handoff_proceeding (mac_->addr(), mac_->getPeerNode_head()->getPeerNode(), scan_info_->nbr->getID());
  113. #endif 
  114.       scan_info_->substate = HANDOVER;
  115.       //restore previous state 
  116.       //mac_->restore_state (scan_info_->nbr->getState()->state_info);
  117.       mac_->setChannel (scan_info_->nbr->getState()->state_info->channel);
  118.       lost_synch ();
  119.       //add target as peer
  120.       mac_->addPeerNode (new PeerNode(scan_info_->nbr->getID()));
  121.       return;
  122.     }
  123.     scan_info_->handoff_timeout--;
  124.     break;
  125.   default:
  126.     break;
  127.   }
  128.     
  129.   //change state of PHY
  130.   //mac_->getPhy()->setMode (OFDM_RECV);
  131.   
  132.   //this is the begining of new frame
  133.   map_->setStarttime (NOW);
  135.   //start handler of dlsubframe
  136.   map_->getDlSubframe()->getTimer()->sched (0);
  138.   //reschedule for next frame
  139.   dl_timer_->resched (mac_->getFrameDuration());
  140. }
  142. /**
  143.  * Start a new frame
  144.  */
  145. void SSscheduler::start_ulsubframe ()
  146. {
  147.   //mac_->debug ("At %f in Mac %d SS scheduler ulsubframe expiresn", NOW, mac_->addr());
  148.   
  149.   //change state of PHY: even though it should have been done before
  150.   //there are some cases where it does not (during scanning)
  151.   mac_->getPhy()->setMode (OFDM_SEND);
  153.   //1-Transfert the packets from the queues in Connections to burst queues
  154.   Burst *b;
  155.   OFDMPhy *phy = mac_->getPhy();
  156.   //printf ("SS has %d ul burstsn", map_->getUlSubframe()->getNbPdu ());
  158.   PeerNode *peer = mac_->getPeerNode_head(); //this is the BS
  159.   assert (peer!=NULL);
  161.   for (int index = 0 ; index < map_->getUlSubframe()->getNbPdu (); index++) {
  162.     b = map_->getUlSubframe()->getPhyPdu (index)->getBurst (0);
  164.     if (b->getIUC()==UIUC_END_OF_MAP) {
  165.       //consistency check..
  166.       assert (index == map_->getUlSubframe()->getNbPdu ()-1);
  167.       break;
  168.     }    
  169.     
  170.     if (b->getIUC()==UIUC_INITIAL_RANGING || b->getIUC()==UIUC_REQ_REGION_FULL)
  171.       continue;
  172.     int duration = 0; 
  173.     //get the packets from the connection with the same CID
  174.     //printf ("tBurst CID=%dn", b->getCid());
  175.     Connection *c=mac_->getCManager ()->get_connection (b->getCid(), true);
  176.     //assert (c);
  177.     if (!c)
  178.       continue; //I do not have this CID. Must be for another node
  179.     //transfert the packets until it reaches burst duration or no more packets
  180.     assert (c->getType()==CONN_PRIMARY);
  181.     if (peer->getBasic()!= NULL) 
  182.       duration = transfer_packets (peer->getBasic(), b, duration);
  183.     if (peer->getPrimary()!= NULL)
  184.       duration = transfer_packets (peer->getPrimary(), b, duration);
  185.     if (peer->getSecondary()!= NULL)
  186.       duration = transfer_packets (peer->getSecondary(), b, duration);
  187.     if (peer->getOutData()!=NULL)
  188.       duration = transfer_packets (peer->getOutData(), b, duration);
  189.   }
  191.   //2-compute size of data left to create bandwidth requests
  192.   if (peer->getBasic()!= NULL) 
  193.     create_request (peer->getBasic());
  194.   if (peer->getPrimary()!= NULL)
  195.     create_request (peer->getPrimary());
  196.   if (peer->getSecondary()!= NULL)
  197.     create_request (peer->getSecondary());
  198.   if (peer->getOutData()!=NULL)
  199.     create_request (peer->getOutData());
  201.   //start handler for ulsubframe
  202.   b = map_->getUlSubframe()->getPhyPdu (0)->getBurst (0);
  203.   map_->getUlSubframe()->getTimer()->sched (b->getStarttime()*phy->getSymbolTime());
  205.   //reschedule for next frame
  206.   ul_timer_->resched (mac_->getFrameDuration());      
  207. }
  209. /**
  210.  * Create a request for the given connection
  211.  * @param con The connection to check
  212.  */
  213. void SSscheduler::create_request (Connection *con)
  214. {
  215.   if (con->queueLength()==0)
  216.     return; //queue is empty
  217.   else if (map_->getUlSubframe()->getBw_req()->getRequest (con->get_cid())!=NULL) {
  218.     debug2 ("At %f in Mac %d already pending requests for cid=%dn", NOW, mac_->addr(), con->get_cid());
  219.     return; //there is already a pending request
  220.   }
  222.   Packet *p= mac_->getPacket();
  223.   hdr_cmn* ch = HDR_CMN(p);
  224.   bw_req_header_t *header = (bw_req_header_t *)&(HDR_MAC802_16(p)->header);
  225.   header->ht=1;
  226.   header->ec=1;
  227.   header->type = 0; //incremental..to check meaning
  228.   header->br = con->queueByteLength();
  229.   header->cid = con->get_cid();
  231.   double txtime = mac_->getPhy()->getTrxTime (ch->size(), map_->getUlSubframe()->getProfile (UIUC_REQ_REGION_FULL)->getEncoding());
  232.   ch->txtime() = txtime;
  233.   map_->getUlSubframe()->getBw_req()->addRequest (p, con->get_cid(), con->queueByteLength());
  234.   debug2 ("SSscheduler enqueued request for cid=%d len=%dn", con->get_cid(), con->queueByteLength());
  235.   //start timeout for request
  236. }
  238. /**
  239.  * Process a packet received by the Mac. Only scheduling related packets should be sent here (BW request, UL_MAP...)
  240.  * @param p The packet to process
  241.  */
  242. void SSscheduler::process (Packet * p)
  243. {
  244.   assert (mac_ && HDR_CMN(p)->ptype()==PT_MAC);
  245.   debug2 ("SSScheduler received packet to processn");
  246.   
  247.   hdr_mac802_16 *wimaxHdr = HDR_MAC802_16(p);
  248.   gen_mac_header_t header = wimaxHdr->header;
  250.   //we cast to this frame because all management frame start with
  251.   //a type 
  252.   mac802_16_dl_map_frame *frame = (mac802_16_dl_map_frame*) p->accessdata();
  254.   switch (frame->type) {
  255.   case MAC_DL_MAP: 
  256.     map_->setStarttime (NOW-HDR_CMN(p)->txtime());
  257.     //printf ("At %f frame start at %fn", NOW, map_->getStarttime());
  258.     process_dl_map (frame);
  259.     break;
  260.   case MAC_DCD: 
  261.     process_dcd ((mac802_16_dcd_frame*)frame);
  262.     break;
  263.   case MAC_UL_MAP: 
  264.     process_ul_map ((mac802_16_ul_map_frame*)frame);
  265.     break;
  266.   case MAC_UCD: 
  267.     process_ucd ((mac802_16_ucd_frame*)frame);
  268.     break;
  269.   case MAC_RNG_RSP:
  270.     process_ranging_rsp ((mac802_16_rng_rsp_frame*) frame);
  271.     break;
  272.   case MAC_REG_RSP:
  273.     process_reg_rsp ((mac802_16_reg_rsp_frame*) frame);
  274.     break;    
  275.   case MAC_MOB_SCN_RSP:
  276.     process_scan_rsp ((mac802_16_mob_scn_rsp_frame *) frame);
  277.     break;
  278.   case MAC_MOB_BSHO_RSP:
  279.     process_bsho_rsp ((mac802_16_mob_bsho_rsp_frame *) frame);
  280.     break;
  281.   case MAC_MOB_NBR_ADV:
  282.     process_nbr_adv ((mac802_16_mob_nbr_adv_frame *) frame);
  283.     break;
  284.   default:
  285.     mac_->debug ("unknown packet in SS %dn", mac_->addr());
  286.     //exit (0);
  287.   }
  288.   Packet::free (p);
  289. }
  291. /**
  292.  * Return the type of STA this scheduler is good for
  293.  * @return STA_SS
  294.  */
  295. station_type_t SSscheduler::getNodeType ()
  296. {
  297.   return STA_MN;
  298. }
  300. /**
  301.  * Called when lost synchronization
  302.  */
  303. void SSscheduler::lost_synch ()
  304. {
  305.   //reset timers
  306.   if (t1timer_->busy()!=0)
  307.     t1timer_->stop();
  308.   if (t12timer_->busy()!=0)
  309.     t12timer_->stop();
  310.   if (t21timer_->busy()!=0)
  311.     t21timer_->stop();
  312.   if (lostDLMAPtimer_->busy()!=0)
  313.     lostDLMAPtimer_->stop(); 
  314.   if (lostULMAPtimer_->busy()!=0)
  315.     lostULMAPtimer_->stop(); 
  316.   if (t2timer_->busy()!=0)
  317.     t2timer_->stop(); 
  318.   if (t44timer_ && t44timer_->busy()!=0)
  319.     t44timer_->stop();
  320.   //we need to go to receiving mode
  321.   //printf ("Set phy to recv %xn", mac_->getPhy());
  322.   mac_->getPhy()->setMode (OFDM_RECV);
  323.   if (mac_->getMacState()==MAC802_16_CONNECTED) {
  324.     //remove possible pending requests
  325.     map_->getUlSubframe()->getBw_req()->removeRequests(); 
  327. #ifdef USE_802_21
  328.     mac_->debug ("At %f in Mac %d, send link downn", NOW, mac_->addr());
  329.     mac_->send_link_down (mac_->addr(), RC_FAIL_NORESOURCE);
  330. #endif
  331.   }
  333.   //remove information about peer node
  334.   if (mac_->getPeerNode_head())
  335.     mac_->removePeerNode (mac_->getPeerNode_head());
  337.   //start waiting for DL synch
  338.   mac_->setMacState (MAC802_16_WAIT_DL_SYNCH);
  339.   t21timer_->start (mac_->macmib_.t21_timeout);
  340.   if (dl_timer_->status()==TIMER_PENDING)
  341.     dl_timer_->cancel();
  342.   map_->getDlSubframe()->getTimer()->reset();
  343.   if (ul_timer_->status()==TIMER_PENDING)
  344.     ul_timer_->cancel();
  345.   map_->getUlSubframe()->getTimer()->reset();
  346. }
  347.  
  348. /**
  349.  * Called when a timer expires
  350.  * @param The timer ID
  351.  */
  352. void SSscheduler::expire (timer_id id)
  353. {
  354.   switch (id) {
  355.   case WimaxT21TimerID:
  356.     mac_->debug ("At %f in Mac %d, synchronization failedn", NOW, mac_->addr());
  357.     //go to next channel
  358.     mac_->nextChannel();
  359.     t21timer_->start (mac_->macmib_.t21_timeout);
  360.     break;
  361.   case WimaxLostDLMAPTimerID:
  362.     mac_->debug ("At %f in Mac %d, lost synchronization (DL_MAP)n", NOW, mac_->addr());
  363.     lost_synch ();
  364.     break;
  365.   case WimaxT1TimerID:
  366.     mac_->debug ("At %f in Mac %d, lost synchronization (DCD)n", NOW, mac_->addr());
  367.     lost_synch ();
  368.     break;
  369.   case WimaxLostULMAPTimerID:
  370.     mac_->debug ("At %f in Mac %d, lost synchronization (UL_MAP)n", NOW, mac_->addr());
  371.     lost_synch ();
  372.     break;
  373.   case WimaxT12TimerID:
  374.     mac_->debug ("At %f in Mac %d, lost uplink param (UCD)n", NOW, mac_->addr());
  375.     lost_synch ();
  376.     break;
  377.   case WimaxT2TimerID:
  378.     mac_->debug ("At %f in Mac %d, lost synchronization (RNG)n", NOW, mac_->addr());
  379.     map_->getUlSubframe()->getRanging()->removeRequest ();
  380.     lost_synch ();
  381.     break;
  382.   case WimaxT3TimerID:
  383.     mac_->debug ("At %f in Mac %d, no response from BSn", NOW, mac_->addr());
  384.     //we reach the maximum number of retries
  385.     //mark DL channel usuable (i.e we go to next)
  386.     map_->getUlSubframe()->getRanging()->removeRequest ();
  387.     mac_->nextChannel();
  388.     lost_synch ();
  389.     break;
  390.   case WimaxT6TimerID:
  391.     mac_->debug ("At %f in Mac %d, registration timeout (nbretry=%d)n", NOW, mac_->addr(),
  392.  nb_reg_retry_);
  393.     if (nb_reg_retry_ == mac_->macmib_.reg_req_retry) {
  394.       mac_->debug ("tmax retry excedeedn");
  395.       lost_synch ();
  396.     } else {
  397.       send_registration();
  398.     }
  399.     break;
  400.   case WimaxT44TimerID:
  401.     mac_->debug ("At %f in Mac %d, did not receive MOB_SCN-RSP (nb_retry=%d)n", NOW, mac_->addr(), nb_scan_req_);
  402.     if (nb_scan_req_ <= mac_->macmib_.scan_req_retry) {
  403.       send_scan_request ();
  404.     } else { //reset for next time
  405.       nb_scan_req_ = 0;
  406.     }
  407.     break;
  408.   case WimaxScanIntervalTimerID:
  409.     pause_scanning ();
  410.     break;    
  411.   case WimaxRdvTimerID:
  412.     //we need to meet at another station. We cancel the current scanning
  413.     //lost_synch ();
  414.     mac_->debug ("At %f in Mac %d Rdv timer expiredn", NOW, mac_->addr());
  415.     break;
  416.   default:
  417.     mac_->debug ("Trigger unkownn");
  418.   }
  419. }
  421. /**** Packet processing methods ****/
  423. /**
  424.  * Process a DL_MAP message
  425.  * @param frame The dl_map information
  426.  */
  427. void SSscheduler::process_dl_map (mac802_16_dl_map_frame *frame)
  428. {
  429.   assert (frame);
  430.   
  431.   //create an entry for the BS
  432.   if (mac_->getPeerNode (frame->bsid)==NULL)
  433.     mac_->addPeerNode (new PeerNode (frame->bsid));
  435.   map_->parseDLMAPframe (frame);
  437.   if (mac_->getMacState()==MAC802_16_WAIT_DL_SYNCH) {
  438.     mac_->debug ("At %f in %d, received DL_MAP for synch from %d (substate=%d)n", 
  439.  NOW, mac_->addr(), frame->bsid,scan_info_->substate);
  440.     assert (t21timer_->busy()!=0);
  441.     //synchronization is done
  442.     t21timer_->stop();
  443.     //start lost_dl_map
  444.     lostDLMAPtimer_->start (mac_->macmib_.lost_dlmap_interval);
  445.     //start T1: DCD
  446.     t1timer_->start (mac_->macmib_.t1_timeout);
  447.     //start T12: UCD
  448.     t12timer_->start (mac_->macmib_.t12_timeout);
  450. #ifdef USE_802_21
  451.     mac_->debug ("At %f in Mac %d, send link detectedn", NOW, mac_->addr());
  452.     mac_->send_link_detected (mac_->addr(), frame->bsid, 1);
  453. #endif
  454.     
  455.     mac_->setMacState(MAC802_16_WAIT_DL_SYNCH_DCD);
  457.     //if I am doing handoff and we have dcd/ucd information 
  458.     //from scanning, use it
  459.     if (scan_info_->substate == HANDOVER || scan_info_->substate == SCANNING) {
  460.       if (scan_info_->substate == SCANNING) {
  461. if (scan_info_->nbr == NULL || scan_info_->nbr->getID()!=frame->bsid) {
  462.   //check if an entry already exist in the database
  463.   scan_info_->nbr = nbr_db_->getNeighbor (frame->bsid);
  464.   if (scan_info_->nbr == NULL) {
  465.     //create entry
  466.     debug2 ("Creating nbr info for node %dn", frame->bsid);
  467.     scan_info_->nbr = new NeighborEntry (frame->bsid);
  468.     nbr_db_->addNeighbor (scan_info_->nbr);
  469.   } else {
  470.     debug2 ("loaded nbr infon");
  471.     if (scan_info_->nbr->isDetected ()) {
  472.         //we already synchronized with this AP...skip channel
  473.         mac_->nextChannel();
  474.         lost_synch ();
  475.         return;
  476.       } 
  477.   }
  478. }
  479.       }//if HANDOVER, scan_info_->nbr is already set
  481.       bool error = false;
  482.       //we check if we can read the DL_MAP
  483.       mac802_16_dcd_frame *dcd = scan_info_->nbr->getDCD();
  484.       if (dcd!=NULL) {
  485. debug2 ("Check if we can decode stored dcdn");
  486. //check if we can decode dl_map with previously acquired dcd      
  487. bool found;
  488. for (int i = 0 ; !error && i < map_->getDlSubframe()->getPdu()->getNbBurst() ; i++) {
  489.   int diuc = map_->getDlSubframe()->getPdu()->getBurst(i)->getIUC();
  490.   if (diuc == DIUC_END_OF_MAP)
  491.     continue;
  492.   found = false;
  493.   for (u_int32_t j = 0 ; !found && j < dcd->nb_prof; j++) {
  494.     found = dcd->profiles[j].diuc==diuc;     
  495.   }
  496.   error = !found;
  497. }
  498. if (!error)
  499.   process_dcd (dcd);
  500.       } else {
  501. debug2 ("No DCD information foundn");
  502.       }
  503.     }
  504.   } else {
  505.     //maintain synchronization
  506.     assert (lostDLMAPtimer_->busy());
  507.     lostDLMAPtimer_->stop();
  508.     //printf ("update dlmap timern");
  509.     lostDLMAPtimer_->start (mac_->macmib_.lost_dlmap_interval);
  511.     if (mac_->getMacState()!= MAC802_16_WAIT_DL_SYNCH_DCD
  512. && mac_->getMacState()!=MAC802_16_UL_PARAM) {
  514.       //since the map may have changed, we need to adjust the timer 
  515.       //for the DLSubframe
  516.       double stime = map_->getStarttime();
  517.       stime += map_->getDlSubframe()->getPdu()->getBurst(1)->getStarttime()*mac_->getPhy()->getSymbolTime();
  518.       //printf ("received dl..needs to update expiration to %f, %f,%fn", stime, NOW,map_->getStarttime());
  519.       map_->getDlSubframe()->getTimer()->resched (stime-NOW);
  520.       dl_timer_->resched (map_->getStarttime()+mac_->getFrameDuration()-NOW);
  521.     }
  522.   }
  523. }
  525. /**
  526.  * Process a DCD message
  527.  * @param frame The dcd information
  528.  */
  529. void SSscheduler::process_dcd (mac802_16_dcd_frame *frame)
  530. {
  531.   if (mac_->getMacState()==MAC802_16_WAIT_DL_SYNCH) {
  532.     //we are waiting for DL_MAP, ignore this message
  533.     return;
  534.   }
  536.   map_->parseDCDframe (frame);
  537.   if (mac_->getMacState()==MAC802_16_WAIT_DL_SYNCH_DCD) {
  538.     mac_->debug ("At %f in %d, received DCD for synchn", NOW, mac_->addr());
  539.     //now I have all information such as frame duration
  540.     //adjust timing in case the frame we received the DL_MAP
  541.     //and the DCD is different
  542.     while (NOW - map_->getStarttime () > mac_->getFrameDuration()) {
  543.       map_->setStarttime (map_->getStarttime()+mac_->getFrameDuration());
  544.     }
  545.     
  546.     //store information to be used during potential handoff
  547.     if (scan_info_->substate == SCANNING) {
  548.       mac802_16_dcd_frame *tmp = (mac802_16_dcd_frame *) malloc (sizeof (mac802_16_dcd_frame));
  549.       memcpy (tmp, frame, sizeof (mac802_16_dcd_frame));
  550.       mac802_16_dcd_frame *old = scan_info_->nbr->getDCD(); 
  551.       if (frame == old)
  552. frame = tmp;
  553.       if (old)
  554. free (old); //free previous entry
  555.       scan_info_->nbr->setDCD(tmp);    //set new one
  556.     }
  558.     mac_->setMacState(MAC802_16_UL_PARAM);
  559.     //we can schedule next frame
  560.     //printf ("SS schedule next frame at %fn", map_->getStarttime()+mac_->getFrameDuration());
  561.     //dl_timer_->sched (map_->getStarttime()+mac_->getFrameDuration()-NOW);
  562.   }
  564.   if (t1timer_->busy()!=0) {
  565.     //we were waiting for this packet
  566.     t1timer_->stop();
  567.     t1timer_->start (mac_->macmib_.t1_timeout);
  568.   }
  569. }
  571. /**
  572.  * Process a UCD message
  573.  * @param frame The ucd information
  574.  */
  575. void SSscheduler::process_ucd (mac802_16_ucd_frame *frame)
  576. {
  577.   if (mac_->getMacState()==MAC802_16_WAIT_DL_SYNCH
  578.       ||mac_->getMacState()==MAC802_16_WAIT_DL_SYNCH_DCD) {
  579.     //discard the packet
  580.     return;
  581.   }
  582.   assert (t12timer_->busy()!=0); //we are waiting for this packet
  584.   if (mac_->getMacState()==MAC802_16_UL_PARAM) {
  585.     //check if uplink channel usable
  586.     mac_->debug ("At %f in %d, received UL(UCD) parametersn", NOW, mac_->addr());
  587.     //start T2: ranging
  588.     t2timer_->start (mac_->macmib_.t2_timeout);
  589.     //start Lost UL-MAP
  590.     lostULMAPtimer_->start (mac_->macmib_.lost_ulmap_interval);
  592.     //store information to be used during potential handoff
  593.     if (scan_info_->substate == SCANNING) {
  594.       mac802_16_ucd_frame *tmp = (mac802_16_ucd_frame *) malloc (sizeof (mac802_16_ucd_frame));
  595.       memcpy (tmp, frame, sizeof (mac802_16_ucd_frame));
  596.       mac802_16_ucd_frame *old = scan_info_->nbr->getUCD(); 
  597.       if (frame == old)
  598. frame = tmp;
  599.       if (old) 
  600. free (old); //free previous entry
  601.       scan_info_->nbr->setUCD(tmp);    //set new one            
  602.       
  603.     }
  605.     //change state
  606.     mac_->setMacState (MAC802_16_RANGING);
  607.   }
  609.   //reset T12
  610.   t12timer_->stop();
  611.   t12timer_->start (mac_->macmib_.t12_timeout);
  613.   map_->parseUCDframe (frame);
  614. }
  616. /**
  617.  * Process a UL_MAP message
  618.  * @param frame The ul_map information
  619.  */
  620. void SSscheduler::process_ul_map (mac802_16_ul_map_frame *frame)
  621. {
  622.   if (mac_->getMacState()==MAC802_16_WAIT_DL_SYNCH 
  623.       || mac_->getMacState()==MAC802_16_WAIT_DL_SYNCH_DCD) {
  624.     //discard the packet
  625.     return;
  626.   }
  628.   if (mac_->getMacState()==MAC802_16_UL_PARAM) {
  629.     if (scan_info_->substate == HANDOVER || scan_info_->substate==SCANNING) {
  630.       FrameMap *tmpMap = new FrameMap (mac_);
  631.       tmpMap->parseULMAPframe (frame); 
  632.       //printf ("Checking if we can read UL_MAPn");
  633.       bool error = false;
  634.       //we check if we can read the UL_MAP
  635.       mac802_16_ucd_frame *ucd = scan_info_->nbr->getUCD();
  636.       if (ucd!=NULL) {
  637. //check if we can decode ul_map with previously acquired ucd      
  638. bool found;
  639. for (int i = 0 ; !error && i < tmpMap->getUlSubframe()->getNbPdu() ; i++) {
  640.   UlBurst *b = (UlBurst*)tmpMap->getUlSubframe()->getPhyPdu(i)->getBurst(0);
  641.   int uiuc = b->getIUC();
  642.   if (uiuc == UIUC_END_OF_MAP)
  643.     continue;
  644.   if (uiuc == UIUC_EXT_UIUC && b->getExtendedUIUC ()== UIUC_FAST_RANGING)
  645.       uiuc = b->getFastRangingUIUC();   
  646.   found = false;
  647.   for (u_int32_t j = 0 ; !found && j < ucd->nb_prof; j++) {
  648.     //printf ("t prof=%d, search=%dn", ucd->profiles[j].uiuc, uiuc);
  649.     found = ucd->profiles[j].uiuc==uiuc;     
  650.   }
  651.   error = !found;
  652. }
  653. if (!error)
  654.   process_ucd (ucd);
  655.       }
  656.       delete (tmpMap);
  657.       if (error) {
  658. //we cannot read message
  659. return;
  660.       }
  661.     } else
  662.       return;
  663.   }
  665.   if (scan_info_->substate == SCANNING) {
  666.     //TBD: add checking scanning type for the given station
  667.     u_char scanning_type = 0;
  668.     for (int i = 0 ; i < scan_info_->rsp->n_recommended_bs_full ; i++) {
  669.       if (scan_info_->rsp->rec_bs_full[i].recommended_bs_id == scan_info_->nbr->getID()) {
  670. scanning_type = scan_info_->rsp->rec_bs_full[i].scanning_type;
  671. break;
  672.       }
  673.     }
  674.     if (scanning_type == 0) {
  675.       //store information about possible base station and keep scanning
  676.       scan_info_->nbr->getState()->state_info= mac_->backup_state();
  677.       mac_->debug ("At %f in Mac %d bs %d detected during scanningn", NOW, mac_->addr(), scan_info_->nbr->getID());
  678.       scan_info_->nbr->setDetected (true);
  679.       mac_->nextChannel();
  680.       lost_synch ();
  681.       return;
  682.     }
  683.   }
  685.   map_->parseULMAPframe (frame);  
  686.   if (mac_->getMacState()==MAC802_16_RANGING) {
  687.       //execute ranging
  688.      assert (t2timer_->busy()!=0); //we are waiting for this packet
  689.      init_ranging ();
  690.   }
  692.   //schedule when to take care of outgoing packets
  693.   double start = map_->getStarttime();
  694.   start += map_->getUlSubframe()->getStarttime()*mac_->getPhy()->getPS(); //offset for ul subframe
  695.   start -= NOW; //works with relative time not absolute
  696.   debug2 ("Uplink starts in %f (framestate=%f) %f %fn", 
  697.   start, 
  698.   map_->getStarttime(),
  699.   mac_->getFrameDuration()/mac_->getPhy()->getPS(), 
  700.   mac_->getFrameDuration()/mac_->getPhy()->getSymbolTime());
  701.   
  702.   ul_timer_->resched (start);
  704.   //reset Lost UL-Map
  705.   lostULMAPtimer_->stop();
  706.   lostULMAPtimer_->start (mac_->macmib_.lost_ulmap_interval);
  707. }
  709. /**
  710.  * Process a ranging response message 
  711.  * @param frame The ranging response frame
  712.  */
  713. void SSscheduler::process_ranging_rsp (mac802_16_rng_rsp_frame *frame)
  714. {
  715.   //check the destination
  716.   if (frame->ss_mac_address != mac_->addr())
  717.     return;
  718.   
  719.   Connection *basic, *primary;
  720.   PeerNode *peer;
  722.   //TBD: add processing for periodic ranging
  724.   //check status 
  725.   switch (frame->rng_status) {
  726.   case RNG_SUCCESS:
  727.     mac_->debug ("Ranging response: status = Success.Basic=%d, Primary=%dn",
  728.     frame->basic_cid, frame->primary_cid);
  730.     peer = mac_->getPeerNode_head();
  731.     assert (peer);
  732.     map_->getUlSubframe()->getRanging()->removeRequest ();
  734.     if (scan_info_->substate == SCANNING) {
  735.       //store information about possible base station and keep scanning
  736.       scan_info_->nbr->getState()->state_info= mac_->backup_state();
  737.       scan_info_->nbr->setDetected (true);
  738.       //keep the information for later
  739.       mac802_16_rng_rsp_frame *tmp = (mac802_16_rng_rsp_frame *) malloc (sizeof (mac802_16_rng_rsp_frame));
  740.       memcpy (tmp, frame, sizeof (mac802_16_rng_rsp_frame));
  741.       scan_info_->nbr->setRangingRsp (tmp);
  742.       mac_->nextChannel();
  743.       lost_synch ();
  744.       return;
  745.     }
  747.     //ranging worked, now we must register
  748.     basic = peer->getBasic();
  749.     primary = peer->getPrimary();
  750.     if (basic!=NULL && basic->get_cid ()==frame->basic_cid) {
  751.       //duplicate response
  752.       assert (primary->get_cid () == frame->primary_cid);
  753.     } else {
  754.       if (basic !=NULL) {
  755. //we have been allocated new cids..clear old ones
  756. mac_->getCManager ()->remove_connection (basic);
  757. mac_->getCManager ()->remove_connection (primary);
  758. if (peer->getSecondary()!=NULL)
  759.   mac_->getCManager ()->remove_connection (peer->getSecondary());
  760. if (peer->getOutData()!=NULL)
  761.   mac_->getCManager ()->remove_connection (peer->getOutData());
  762. if (peer->getInData()!=NULL)
  763.   mac_->getCManager ()->remove_connection (peer->getInData());
  764.       } 
  766.       basic = new Connection (CONN_BASIC, frame->basic_cid);
  767.       Connection *upbasic = new Connection (CONN_BASIC, frame->basic_cid);
  768.       primary = new Connection (CONN_PRIMARY, frame->primary_cid);
  769.       Connection *upprimary = new Connection (CONN_PRIMARY, frame->primary_cid);
  771.       //a SS should only have one peer, the BS
  772.       peer->setBasic (upbasic); //set outgoing
  773.       peer->setPrimary (upprimary); //set outgoing
  774.       basic->setPeerNode (peer);
  775.       primary->setPeerNode (peer);
  776.       mac_->getCManager()->add_connection (upbasic, true);
  777.       mac_->getCManager()->add_connection (basic, false);
  778.       mac_->getCManager()->add_connection (upprimary, true);
  779.       mac_->getCManager()->add_connection (primary, false);
  780.     }
  782.     //registration must be sent using Primary Management CID
  783.     mac_->setMacState (MAC802_16_REGISTER);
  784.     //stop timeout timer
  785.     t2timer_->stop ();
  786.     nb_reg_retry_ = 0; //first time sending
  787.     send_registration();
  789.     break;
  790.   case RNG_ABORT:
  791.   case RNG_CONTINUE:
  792.   case RNG_RERANGE:
  793.     break;
  794.   default:
  795.     fprintf (stderr, "Unknown status replyn");
  796.     exit (-1);
  797.   }
  798. }
  800. /**
  801.  * Schedule a ranging
  802.  */
  803. void SSscheduler::init_ranging ()
  804. {
  805.   //check if there is a ranging opportunity
  806.   UlSubFrame *ulsubframe = map_->getUlSubframe();
  807.   DlSubFrame *dlsubframe = map_->getDlSubframe();
  809.   /* If I am doing a Handoff, check if I already associated 
  810.      with the target AP*/
  811.   if (scan_info_->substate == HANDOVER && scan_info_->nbr->getRangingRsp()!=NULL) {
  812.     mac_->debug ("At %f in Mac %d MN already executed ranging during scanningn", NOW, mac_->addr());
  813.     process_ranging_rsp (scan_info_->nbr->getRangingRsp());
  814.     return;
  815.   }
  817.   //check if there is Fast Ranging IE
  818.   for (PhyPdu *p = map_->getUlSubframe ()->getFirstPdu(); p ; p= p ->next_entry()) {
  819.     UlBurst *b = (UlBurst*) p->getBurst(0);
  820.     if (b->getIUC() == UIUC_EXT_UIUC && 
  821. b->getExtendedUIUC ()== UIUC_FAST_RANGING &&
  822. b->getFastRangingMacAddr ()==mac_->addr()) {
  823.       debug2 ("Found fast rangingn");
  824.       //we should put the ranging request in that burst
  825.       Packet *p= mac_->getPacket();
  826.       hdr_cmn* ch = HDR_CMN(p);
  827.       HDR_MAC802_16(p)->header.cid = INITIAL_RANGING_CID;
  829.       p->allocdata (sizeof (struct mac802_16_rng_req_frame));
  830.       mac802_16_rng_req_frame *frame = (mac802_16_rng_req_frame*) p->accessdata();
  831.       frame->type = MAC_RNG_REQ;
  832.       frame->dc_id = dlsubframe->getChannelID();
  833.       frame->ss_mac_address = mac_->addr();
  834.       //other elements??      
  835.       ch->size() += RNG_REQ_SIZE;
  836.       //compute when to send message
  837.       double txtime = mac_->getPhy()->getTrxTime (ch->size(), ulsubframe->getProfile (b->getFastRangingUIUC ())->getEncoding());
  838.       ch->txtime() = txtime;
  839.       //starttime+backoff
  840.       b->enqueue(p);
  841.       mac_->setMacState(MAC802_16_WAIT_RNG_RSP);
  842.       return;
  843.     }
  844.   }
  847.   for (PhyPdu *pdu = ulsubframe->getFirstPdu(); pdu ; pdu = pdu->next_entry()) {
  848.     if (pdu->getBurst(0)->getIUC()==UIUC_INITIAL_RANGING) {
  849.       mac_->debug ("At %f SS Mac %d found ranging opportunityn", NOW, mac_->addr());
  850.       Packet *p= mac_->getPacket();
  851.       hdr_cmn* ch = HDR_CMN(p);
  852.       HDR_MAC802_16(p)->header.cid = INITIAL_RANGING_CID;
  854.       p->allocdata (sizeof (struct mac802_16_rng_req_frame));
  855.       mac802_16_rng_req_frame *frame = (mac802_16_rng_req_frame*) p->accessdata();
  856.       frame->type = MAC_RNG_REQ;
  857.       frame->dc_id = dlsubframe->getChannelID();
  858.       frame->ss_mac_address = mac_->addr();
  859.       //other elements??      
  860.       ch->size() += RNG_REQ_SIZE;
  861.       //compute when to send message
  862.       double txtime = mac_->getPhy()->getTrxTime (ch->size(), ulsubframe->getProfile (pdu->getBurst(0)->getIUC())->getEncoding());
  863.       ch->txtime() = txtime;
  864.       //starttime+backoff
  865.       map_->getUlSubframe()->getRanging()->addRequest (p);
  866.       mac_->setMacState(MAC802_16_WAIT_RNG_RSP);
  868.       return;
  869.     }
  870.   }
  871. }
  873. /**
  874.  * Prepare to send a registration message
  875.  */
  876. void SSscheduler::send_registration ()
  877. {
  878.   Packet *p;
  879.   struct hdr_cmn *ch;
  880.   hdr_mac802_16 *wimaxHdr;
  881.   mac802_16_reg_req_frame *reg_frame;
  882.   PeerNode *peer;
  884.   //create packet for request
  885.   p = mac_->getPacket ();
  886.   ch = HDR_CMN(p);
  887.   wimaxHdr = HDR_MAC802_16(p);
  888.   p->allocdata (sizeof (struct mac802_16_reg_req_frame));
  889.   reg_frame = (mac802_16_reg_req_frame*) p->accessdata();
  890.   reg_frame->type = MAC_REG_REQ;
  891.   ch->size() += REG_REQ_SIZE;
  893.   peer = mac_->getPeerNode_head();  
  894.   wimaxHdr->header.cid = peer->getPrimary()->get_cid();
  895.   peer->getPrimary()->enqueue (p);
  897.   //start reg timeout
  898.   if (t6timer_==NULL) {
  899.     t6timer_ = new WimaxT6Timer (mac_);
  900.   }
  901.   t6timer_->start (mac_->macmib_.t6_timeout);
  902.   nb_reg_retry_++;
  903. }
  905. /**
  906.  * Process a registration response message 
  907.  * @param frame The registration response frame
  908.  */
  909. void SSscheduler::process_reg_rsp (mac802_16_reg_rsp_frame *frame)
  910. {
  911.   //check the destination
  912.   PeerNode *peer = mac_->getPeerNode_head();
  914.   if (frame->response == 0) {
  915.     //status OK
  916.     mac_->debug ("At %f in Mac %d, registration sucessful (nbretry=%d)n", NOW, mac_->addr(),
  917.  nb_reg_retry_);
  918.     Connection *secondary = peer->getSecondary();
  919.     if (!secondary) {
  920.       Connection *secondary = new Connection (CONN_SECONDARY, frame->sec_mngmt_cid);
  921.       Connection *upsecondary = new Connection (CONN_SECONDARY, frame->sec_mngmt_cid);
  922.       mac_->getCManager()->add_connection (upsecondary, true);
  923.       mac_->getCManager()->add_connection (secondary, false);
  924.       peer->setSecondary (upsecondary);
  925.       secondary->setPeerNode (peer);
  926.     }
  927.     //cancel timeout
  928.     t6timer_->stop ();
  930.     //update status
  931.     mac_->setMacState(MAC802_16_CONNECTED);
  933.     //we need to setup a data connection (will be moved to service flow handler)
  934.     mac_->getServiceHandler ()->sendFlowRequest (peer->getPeerNode(), true);
  935.     mac_->getServiceHandler ()->sendFlowRequest (peer->getPeerNode(), false);
  937. #ifdef USE_802_21
  938.     if (scan_info_->substate==HANDOVER) {
  939.       mac_->debug ("At %f in Mac %d link handoff completen", NOW, mac_->addr());      
  940.       mac_->send_link_handoff_complete (mac_->addr(), scan_info_->serving_bsid, peer->getPeerNode());
  941.       scan_info_->handoff_timeout = -1;
  942.     }
  943.     mac_->debug ("At %f in Mac %d, send link upn", NOW, mac_->addr());
  944.     mac_->send_link_up (mac_->addr(), peer->getPeerNode());
  945. #endif
  946.     
  947.   } else {
  948.     //status failure
  949.     mac_->debug ("At %f in Mac %d, registration failed (nbretry=%d)n", NOW, mac_->addr(),
  950.  nb_reg_retry_);
  951.     if (nb_reg_retry_ == mac_->macmib_.reg_req_retry) {
  952. #ifdef USE_802_21
  953.       if (scan_info_ && scan_info_->handoff_timeout == -2) {
  954. mac_->debug ("At %f in Mac %d link handoff failuren", NOW, mac_->addr());      
  955. mac_->send_link_handoff_failure (mac_->addr(), scan_info_->serving_bsid, peer->getPeerNode());
  956. scan_info_->handoff_timeout = -1;
  957.       }
  958. #endif
  959.       lost_synch ();
  960.     } else {
  961.       send_registration();
  962.     }
  963.   }
  964. }
  966. /**
  967.  * Send a scanning message to the serving BS
  968.  */
  969. void SSscheduler::send_scan_request ()
  970. {
  971.   Packet *p;
  972.   struct hdr_cmn *ch;
  973.   hdr_mac802_16 *wimaxHdr;
  974.   mac802_16_mob_scn_req_frame *req_frame;
  975.   PeerNode *peer;
  977.   mac_->debug ("At %f in Mac %d enqueue scan requestn", NOW, mac_->addr());
  979.   //create packet for request
  980.   p = mac_->getPacket ();
  981.   ch = HDR_CMN(p);
  982.   wimaxHdr = HDR_MAC802_16(p);
  983.   p->allocdata (sizeof (struct mac802_16_mob_scn_req_frame));
  984.   req_frame = (mac802_16_mob_scn_req_frame*) p->accessdata();
  985.   req_frame->type = MAC_MOB_SCN_REQ;
  987.   req_frame->scan_duration = mac_->macmib_.scan_duration;
  988.   req_frame->interleaving_interval = mac_->macmib_.interleaving;
  989.   req_frame->scan_iteration = mac_->macmib_.scan_iteration;
  990.   req_frame->n_recommended_bs_index = 0;
  991.   req_frame->n_recommended_bs_full = 0;
  993.   ch->size() += Mac802_16pkt::getMOB_SCN_REQ_size(req_frame);
  994.   peer = mac_->getPeerNode_head();  
  995.   wimaxHdr->header.cid = peer->getPrimary()->get_cid();
  996.   peer->getPrimary()->enqueue (p);
  998.   //start reg timeout
  999.   if (t44timer_==NULL) {
  1000.     t44timer_ = new WimaxT44Timer (mac_);
  1001.   }
  1002.   t44timer_->start (mac_->macmib_.t44_timeout);
  1003.   nb_scan_req_++;
  1004. }
  1006. /**
  1007.  * Process a scanning response message 
  1008.  * @param frame The scanning response frame
  1009.  */
  1010. void SSscheduler::process_scan_rsp (mac802_16_mob_scn_rsp_frame *frame)
  1011. {
  1012.   //PeerNode *peer = mac_->getPeerNode_head();
  1014.   if (frame->scan_duration != 0) {
  1015.     //scanning accepted
  1016.     mac_->debug ("At %f in Mac %d, scanning accepted (dur=%d it=%d)n", NOW, mac_->addr(), frame->scan_duration,frame->scan_iteration );
  1017.     //allocate data for scanning
  1018.     //scan_info_ = (struct scanning_structure *) malloc (sizeof (struct scanning_structure));
  1019.     //store copy of frame
  1020.     
  1021.     scan_info_->rsp = (struct mac802_16_mob_scn_rsp_frame *) malloc (sizeof (struct mac802_16_mob_scn_rsp_frame));
  1022.     memcpy (scan_info_->rsp, frame, sizeof (struct mac802_16_mob_scn_rsp_frame));
  1023.     scan_info_->iteration = 0;
  1024.     scan_info_->count = frame->start_frame;
  1025.     scan_info_->substate = SCAN_PENDING;
  1026.     scan_info_->handoff_timeout = 0; 
  1027.     scan_info_->serving_bsid = mac_->getPeerNode_head()->getPeerNode();
  1028.     scan_info_->nb_rdv_timers = 0;
  1030.     //mark all neighbors as not detected
  1031.     for (int i = 0 ; i < nbr_db_->getNbNeighbor() ; i++) {
  1032.       nbr_db_->getNeighbors()[i]->setDetected(false);
  1033.     }
  1035.     //schedule timer for rdv time (for now just use full)
  1036.     //TBD: add rec_bs_index
  1037.     mac_->debug ("tstart scan in %d frames (%f)n",frame->start_frame,NOW+frame->start_frame*mac_->getFrameDuration());
  1038.     for (int i = 0 ; i < scan_info_->rsp->n_recommended_bs_full ; i++) {
  1039.       if (scan_info_->rsp->rec_bs_full[i].scanning_type ==SCAN_ASSOC_LVL1 
  1040.   || scan_info_->rsp->rec_bs_full[i].scanning_type==SCAN_ASSOC_LVL2) {
  1041. debug2 ("Creating timer for bs=%d at time %fn", 
  1042. scan_info_->rsp->rec_bs_full[i].recommended_bs_id, 
  1043. NOW+mac_->getFrameDuration()*scan_info_->rsp->rec_bs_full[i].rdv_time);
  1044. assert (nbr_db_->getNeighbor (scan_info_->rsp->rec_bs_full[i].recommended_bs_id));
  1045. //get the channel
  1046. int ch = mac_->getChannel (nbr_db_->getNeighbor (scan_info_->rsp->rec_bs_full[i].recommended_bs_id)->getDCD ()->frequency*1000);
  1047. assert (ch!=-1);
  1048. WimaxRdvTimer *timer = new WimaxRdvTimer (mac_, ch);
  1049. scan_info_->rdv_timers[scan_info_->nb_rdv_timers++] = timer;
  1050. timer->start(mac_->getFrameDuration()*scan_info_->rsp->rec_bs_full[i].rdv_time);
  1051.       }
  1052.     }
  1054.   } else {
  1055.     mac_->debug ("At %f in Mac %d, scanning deniedn", NOW, mac_->addr());
  1056.     //what do I do???
  1057.   }
  1058.   t44timer_->stop();
  1059. }
  1061. /**
  1062.  * Start/Continue scanning
  1063.  */
  1064. void SSscheduler::resume_scanning ()
  1065. {
  1066.   if (scan_info_->iteration == 0) 
  1067.     mac_->debug ("At %f in Mac %d, starts scanningn", NOW, mac_->addr());
  1068.   else 
  1069.     mac_->debug ("At %f in Mac %d, resume scanningn", NOW, mac_->addr());
  1070.   
  1071.   scan_info_->substate = SCANNING;
  1073.   //backup current state
  1074.   scan_info_->normal_state.state_info = mac_->backup_state();
  1075.   if (t1timer_->busy())
  1076.     t1timer_->pause();
  1077.   scan_info_->normal_state.t1timer = t1timer_;
  1078.   if (t2timer_->busy())
  1079.     t2timer_->pause();
  1080.   scan_info_->normal_state.t2timer = t2timer_;
  1081.   if (t6timer_->busy())
  1082.     t6timer_->pause();
  1083.   scan_info_->normal_state.t6timer = t6timer_;
  1084.   if (t12timer_->busy())
  1085.     t12timer_->pause();
  1086.   scan_info_->normal_state.t12timer = t12timer_;
  1087.   if (t21timer_->busy())
  1088.     t21timer_->pause();
  1089.   scan_info_->normal_state.t21timer = t21timer_;
  1090.   if (lostDLMAPtimer_->busy())
  1091.     lostDLMAPtimer_->pause();
  1092.   scan_info_->normal_state.lostDLMAPtimer = lostDLMAPtimer_;
  1093.   if (lostULMAPtimer_->busy())
  1094.     lostULMAPtimer_->pause();
  1095.   scan_info_->normal_state.lostULMAPtimer = lostULMAPtimer_;
  1096.   scan_info_->normal_state.map = map_;
  1098.   if (scan_info_->iteration == 0) {
  1099.     //reset state
  1100.     t1timer_ = new WimaxT1Timer (mac_);
  1101.     t2timer_ = new WimaxT2Timer (mac_);
  1102.     t6timer_ = new WimaxT6Timer (mac_);
  1103.     t12timer_ = new WimaxT12Timer (mac_);
  1104.     t21timer_ = new WimaxT21Timer (mac_);
  1105.     lostDLMAPtimer_ = new WimaxLostDLMAPTimer (mac_);
  1106.     lostULMAPtimer_ = new WimaxLostULMAPTimer (mac_);
  1107.     
  1108.     map_ = new FrameMap (mac_);
  1109.     
  1110.     mac_->nextChannel();
  1112.     scan_info_->scn_timer_ = new WimaxScanIntervalTimer (mac_);
  1114.     //start waiting for DL synch
  1115.     mac_->setMacState (MAC802_16_WAIT_DL_SYNCH);
  1116.     t21timer_->start (mac_->macmib_.t21_timeout);
  1117.     if (dl_timer_->status()==TIMER_PENDING)
  1118.       dl_timer_->cancel();
  1119.     map_->getDlSubframe()->getTimer()->reset();
  1120.     if (ul_timer_->status()==TIMER_PENDING)
  1121.       ul_timer_->cancel();
  1122.     map_->getUlSubframe()->getTimer()->reset();
  1123.     
  1125.   }else{
  1126.     //restore where we left
  1127.     //restore previous timers
  1128.     mac_->restore_state(scan_info_->scan_state.state_info);
  1129.     t1timer_ = scan_info_->scan_state.t1timer;
  1130.     if (t1timer_->paused())
  1131.       t1timer_->resume();
  1132.     t2timer_ = scan_info_->scan_state.t2timer;
  1133.     if (t2timer_->paused())
  1134.       t2timer_->resume();
  1135.     t6timer_ = scan_info_->scan_state.t6timer;
  1136.     if (t6timer_->paused())
  1137.       t6timer_->resume();
  1138.     t12timer_ = scan_info_->scan_state.t12timer;
  1139.     if (t12timer_->paused())
  1140.       t12timer_->resume();
  1141.     t21timer_ = scan_info_->scan_state.t21timer;
  1142.     if (t21timer_->paused())
  1143.       t21timer_->resume();
  1144.     lostDLMAPtimer_ = scan_info_->scan_state.lostDLMAPtimer;
  1145.     if (lostDLMAPtimer_->paused())
  1146.       lostDLMAPtimer_->resume();
  1147.     lostULMAPtimer_ = scan_info_->scan_state.lostULMAPtimer;
  1148.     if (lostULMAPtimer_->paused())
  1149.       lostULMAPtimer_->resume();
  1150.     map_ = scan_info_->scan_state.map;
  1151.     
  1152.     mac_->getPhy()->setMode (OFDM_RECV);
  1154.     if (ul_timer_->status()==TIMER_PENDING)
  1155.       ul_timer_->cancel();
  1156.   }
  1157.   mac_->setNotify_upper (false);
  1158.   //printf ("Scan duration=%d, frameduration=%fn", scan_info_->rsp->scan_duration, mac_->getFrameDuration());
  1159.   scan_info_->scn_timer_->start (scan_info_->rsp->scan_duration*mac_->getFrameDuration());
  1160.   scan_info_->iteration++;
  1161.   
  1162. }
  1164. /**
  1165.  * Pause scanning
  1166.  */
  1167. void SSscheduler::pause_scanning ()
  1168. {
  1169.   if (scan_info_->iteration < scan_info_->rsp->scan_iteration)
  1170.     mac_->debug ("At %f in Mac %d, pause scanningn", NOW, mac_->addr());
  1171.   else 
  1172.     mac_->debug ("At %f in Mac %d, stop scanningn", NOW, mac_->addr());
  1174.   //return to normal mode
  1175.   if (scan_info_->iteration < scan_info_->rsp->scan_iteration) {
  1176.     //backup current state
  1177.     scan_info_->scan_state.state_info = mac_->backup_state();
  1178.     if (t1timer_->busy())
  1179.       t1timer_->pause();
  1180.     scan_info_->scan_state.t1timer = t1timer_;
  1181.     if (t2timer_->busy())
  1182.       t2timer_->pause();
  1183.     scan_info_->scan_state.t2timer = t2timer_;
  1184.     if (t6timer_->busy())
  1185.       t6timer_->pause();
  1186.     scan_info_->scan_state.t6timer = t6timer_;
  1187.     if (t12timer_->busy())
  1188.       t12timer_->pause();
  1189.     scan_info_->scan_state.t12timer = t12timer_;
  1190.     if (t21timer_->busy())
  1191.       t21timer_->pause();
  1192.     scan_info_->scan_state.t21timer = t21timer_;
  1193.     if (lostDLMAPtimer_->busy())
  1194.       lostDLMAPtimer_->pause();
  1195.     scan_info_->scan_state.lostDLMAPtimer = lostDLMAPtimer_;
  1196.     if (lostULMAPtimer_->busy())
  1197.       lostULMAPtimer_->pause();
  1198.     scan_info_->scan_state.lostULMAPtimer = lostULMAPtimer_;
  1199.     scan_info_->scan_state.map = map_;
  1201.     scan_info_->count = scan_info_->rsp->interleaving_interval;
  1203.   } else {
  1204.     //else scanning is over, no need to save data
  1205.     //reset timers
  1206.     if (t1timer_->busy()!=0)
  1207.       t1timer_->stop();
  1208.     delete (t1timer_);
  1209.     if (t12timer_->busy()!=0)
  1210.       t12timer_->stop();
  1211.     delete (t12timer_);
  1212.     if (t21timer_->busy()!=0)
  1213.       t21timer_->stop();
  1214.     delete (t21timer_);
  1215.     if (lostDLMAPtimer_->busy()!=0)
  1216.       lostDLMAPtimer_->stop(); 
  1217.     delete (lostDLMAPtimer_);
  1218.     if (lostULMAPtimer_->busy()!=0)
  1219.       lostULMAPtimer_->stop(); 
  1220.     delete (lostULMAPtimer_);
  1221.     if (t2timer_->busy()!=0)
  1222.       t2timer_->stop(); 
  1223.     delete (t2timer_);
  1224.   }
  1225.   //restore previous timers
  1226.   mac_->restore_state(scan_info_->normal_state.state_info);
  1227.   t1timer_ = scan_info_->normal_state.t1timer;
  1228.   if (t1timer_->paused())
  1229.     t1timer_->resume();
  1230.   t2timer_ = scan_info_->normal_state.t2timer;
  1231.   if (t2timer_->paused())
  1232.     t2timer_->resume();
  1233.   t6timer_ = scan_info_->normal_state.t6timer;
  1234.   if (t6timer_->paused())
  1235.     t6timer_->resume();
  1236.   t12timer_ = scan_info_->normal_state.t12timer;
  1237.   if (t12timer_->paused())
  1238.     t12timer_->resume();
  1239.   t21timer_ = scan_info_->normal_state.t21timer;
  1240.   if (t21timer_->paused())
  1241.     t21timer_->resume();
  1242.   lostDLMAPtimer_ = scan_info_->normal_state.lostDLMAPtimer;
  1243.   if (lostDLMAPtimer_->paused())
  1244.     lostDLMAPtimer_->resume();
  1245.   lostULMAPtimer_ = scan_info_->normal_state.lostULMAPtimer;
  1246.   if (lostULMAPtimer_->paused())
  1247.     lostULMAPtimer_->resume();
  1248.   map_ = scan_info_->normal_state.map;
  1250.   mac_->setNotify_upper (true);
  1251.   dl_timer_->resched (0);
  1253.   if (scan_info_->iteration == scan_info_->rsp->scan_iteration) {
  1254.     scan_info_->substate = NORMAL;
  1256.     /** here we check if there is a better BS **/
  1257.     send_msho_req();
  1259.     scan_info_->count--; //to avoid restarting scanning
  1260.     //delete (scan_info_);
  1261.     //scan_info_ = NULL;
  1262.   } else {
  1263.     scan_info_->substate = SCAN_PENDING;
  1264.   }
  1266. }
  1268. /**
  1269.  * Send a MSHO-REQ message to the BS
  1270.  */
  1271. void SSscheduler::send_msho_req ()
  1272. {
  1273.   Packet *p;
  1274.   struct hdr_cmn *ch;
  1275.   hdr_mac802_16 *wimaxHdr;
  1276.   mac802_16_mob_msho_req_frame *req_frame;
  1277.   double rssi;
  1279.   PeerNode *peer = mac_->getPeerNode_head();
  1281.   int nbPref = 0;
  1282.   for (int i = 0 ; i < nbr_db_->getNbNeighbor() ; i++) {
  1283.     NeighborEntry *entry = nbr_db_->getNeighbors()[i];
  1284.     if (entry->isDetected()) {
  1285.       mac_->debug ("At %f in Mac %d Found new AP %d..need to send HO messagen",NOW, mac_->addr(), entry->getID());
  1286.       nbPref++;
  1287.     }  
  1288.   }
  1290.   if (nbPref==0)
  1291.     return; //no other BS found
  1293.   //create packet for request
  1294.   p = mac_->getPacket ();
  1295.   ch = HDR_CMN(p);
  1296.   wimaxHdr = HDR_MAC802_16(p);
  1297.   p->allocdata (sizeof (struct mac802_16_mob_msho_req_frame)+nbPref*sizeof (mac802_16_mob_msho_req_bs_index));
  1298.   req_frame = (mac802_16_mob_msho_req_frame*) p->accessdata();
  1299.   memset (req_frame, 0, sizeof (mac802_16_mob_msho_req_bs_index));
  1300.   req_frame->type = MAC_MOB_MSHO_REQ;
  1301.   
  1302.   req_frame->report_metric = 0x2; //include RSSI
  1303.   req_frame->n_new_bs_index = 0;
  1304.   req_frame->n_new_bs_full = nbPref;
  1305.   req_frame->n_current_bs = 1;
  1306.   rssi = mac_->getPeerNode_head()->getStatWatch()->average();
  1307.   debug2 ("RSSI=%e, %d, bs=%dn", rssi, (u_char)((rssi+103.75)/0.25), mac_->getPeerNode_head()->getPeerNode());
  1308.   req_frame->bs_current[0].temp_bsid = mac_->getPeerNode_head()->getPeerNode();
  1309.   req_frame->bs_current[0].bs_rssi_mean = (u_char)((rssi+103.75)/0.25);
  1310.   for (int i = 0, j=0; i < nbr_db_->getNbNeighbor() ; i++) {
  1311.     NeighborEntry *entry = nbr_db_->getNeighbors()[i];
  1312.     //TBD: there is an error measuring RSSI for current BS during scanning
  1313.     //anyway, we don't put it in the least, so it's ok for now
  1314.     if (entry->isDetected() && entry->getID()!= mac_->getPeerNode_head()->getPeerNode()) {
  1315.       req_frame->bs_full[j].neighbor_bs_index = entry->getID();
  1316.       rssi = entry->getState()->state_info->peer_list->lh_first->getStatWatch()->average();
  1317.       debug2 ("RSSI=%e, %d, bs=%dn", rssi, (u_char)((rssi+103.75)/0.25), entry->getID());
  1318.       req_frame->bs_full[j].bs_rssi_mean = (u_char)((rssi+103.75)/0.25);
  1319.       //the rest of req_frame->bs_full is unused for now..
  1320.       req_frame->bs_full[j].arrival_time_diff_ind = 0;
  1321.       j++;
  1322.     }
  1323.   }
  1324.   
  1325.   ch->size() += Mac802_16pkt::getMOB_MSHO_REQ_size(req_frame);
  1326.   wimaxHdr->header.cid = peer->getPrimary()->get_cid();
  1327.   peer->getPrimary()->enqueue (p);
  1328. }
  1330. /**
  1331.  * Process a BSHO-RSP message 
  1332.  * @param frame The handover response frame
  1333.  */
  1334. void SSscheduler::process_bsho_rsp (mac802_16_mob_bsho_rsp_frame *frame)
  1335. {
  1336.   mac_->debug ("At %f in Mac %d, received handover responsen", NOW, mac_->addr());
  1337.  
  1338.   //go and switch to the channel recommended by the BS
  1339.   int targetBS = frame->n_rec[0].neighbor_bsid;
  1340.   PeerNode *peer = mac_->getPeerNode_head();      
  1342.   if (peer->getPeerNode ()==targetBS) {
  1343.     mac_->debug ("tDecision to stay in current BSn");
  1344.     return;
  1345.   }
  1346.   scan_info_->nbr = nbr_db_->getNeighbor (targetBS);
  1348.   Packet *p;
  1349.   struct hdr_cmn *ch;
  1350.   hdr_mac802_16 *wimaxHdr;
  1351.   mac802_16_mob_ho_ind_frame *ind_frame;
  1352.   
  1353.   
  1354.   p = mac_->getPacket ();
  1355.   ch = HDR_CMN(p);
  1356.   wimaxHdr = HDR_MAC802_16(p);
  1357.   p->allocdata (sizeof (struct mac802_16_mob_ho_ind_frame));
  1358.   ind_frame = (mac802_16_mob_ho_ind_frame*) p->accessdata();
  1359.   ind_frame->type = MAC_MOB_HO_IND;
  1360.   
  1361.   ind_frame->mode = 0; //HO
  1362.   ind_frame->ho_ind_type = 0; //Serving BS release
  1363.   ind_frame->rng_param_valid_ind = 0;
  1364.   ind_frame->target_bsid = targetBS;
  1365.   
  1366.   ch->size() += Mac802_16pkt::getMOB_HO_IND_size(ind_frame);
  1367.   wimaxHdr->header.cid = peer->getPrimary()->get_cid();
  1368.   peer->getPrimary()->enqueue (p);
  1369.   
  1370. #ifdef USE_802_21
  1371.   mac_->send_link_handoff_imminent (mac_->addr(), peer->getPeerNode(), targetBS);
  1372.   mac_->debug ("At %f in Mac %d link handoff imminentn", NOW, mac_->addr());
  1373.   
  1374. #endif 
  1375.   
  1376.   mac_->debug ("tHandover to BS %dn", targetBS);
  1377.   scan_info_->handoff_timeout = 20;
  1378.   scan_info_->substate = HANDOVER_PENDING;
  1379.   //mac_->setChannel (scan_info_->bs_infos[i].channel);
  1380.   //lost_synch ();
  1381.   
  1382. }
  1384. /**
  1385.  * Process a NBR_ADV message 
  1386.  * @param frame The handover response frame
  1387.  */
  1388. void SSscheduler::process_nbr_adv (mac802_16_mob_nbr_adv_frame *frame)
  1389. {
  1390.   mac_->debug ("At %f in Mac %d, received neighbor advertisementn", NOW, mac_->addr());
  1392.   mac802_16_mob_nbr_adv_frame *copy;
  1394.   copy  = (mac802_16_mob_nbr_adv_frame *) malloc (sizeof (mac802_16_mob_nbr_adv_frame));
  1395.   memcpy (copy, frame, sizeof (mac802_16_mob_nbr_adv_frame));
  1396.   //all we need is to store the information. We will process that only
  1397.   //when we will look for another station
  1398.   for (int i = 0 ; i < frame->n_neighbors ; i++) {
  1399.     int nbrid = frame->nbr_info[i].nbr_bsid;
  1400.     mac802_16_nbr_adv_info *info = (mac802_16_nbr_adv_info *) malloc (sizeof(mac802_16_nbr_adv_info));
  1401.     NeighborEntry *entry = nbr_db_->getNeighbor (nbrid);
  1402.     if (entry==NULL){
  1403.       entry = new NeighborEntry (nbrid);
  1404.       nbr_db_->addNeighbor (entry);
  1405.     }
  1406.     memcpy(info, &(frame->nbr_info[i]), sizeof(mac802_16_nbr_adv_info));
  1407.     if (entry->getNbrAdvMessage ())
  1408.       free (entry->getNbrAdvMessage());
  1409.     entry->setNbrAdvMessage(info);
  1410.     if (info->dcd_included) {
  1411.       //set DCD 
  1412.       mac802_16_dcd_frame *tmp = (mac802_16_dcd_frame *)malloc (sizeof(mac802_16_dcd_frame));
  1413.       memcpy(tmp, &(info->dcd_settings), sizeof(mac802_16_dcd_frame));
  1414.       entry->setDCD(tmp);
  1415.     }
  1416.     else 
  1417.       entry->setDCD(NULL);
  1418.     if (info->ucd_included) {
  1419.       //set DCD 
  1420.       mac802_16_ucd_frame *tmp = (mac802_16_ucd_frame *)malloc (sizeof(mac802_16_ucd_frame));
  1421.       memcpy(tmp, &(info->ucd_settings), sizeof(mac802_16_ucd_frame));
  1422.       entry->setUCD(tmp);
  1423. #ifdef DEBUG_WIMAX
  1424.       debug2 ("Dump information nbr in Mac %d for nbr %d %lxn", mac_->addr(), nbrid, (long)tmp);
  1425.       int nb_prof = tmp->nb_prof;
  1426.       mac802_16_ucd_profile *profiles = tmp->profiles;
  1427.       for (int i = 0 ; i < nb_prof ; i++) {
  1428. debug2 ("t Reading ul profile %i: f=%d, rate=%d, iuc=%dn", i, 0, profiles[i].fec, profiles[i].uiuc);
  1429.       }
  1430. #endif
  1431.     }
  1432.     else
  1433.       entry->setUCD(NULL);
  1434.   }  
  1436. }