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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 通讯编程 > 查看源码
mac-802_11Ext.cc
资源名称：ns-allinone-2.33.tar.gz　[点击查看]
上传用户：rrhhcc
上传日期：2015-12-11
资源大小：54129k
文件大小：31k
源码类别：

通讯编程

开发平台：

Visual C++

mac-802_11Ext.cc：源码内容
  1. /*
  2.  * Copyright (C) 2007 
  3.  * Mercedes-Benz Research & Development North America, Inc. and 
  4.  * University of Karlsruhe (TH)
  5.  * All rights reserved.
  6.  *
  7.  * This program is free software; you can redistribute it and/or
  8.  * modify it under the terms of the GNU General Public License,
  9.  * version 2, as published by the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License along
  17.  * with this program; if not, write to the Free Software Foundation, Inc.,
  18.  * 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
  19.  *
  20.  *
  21.  * The copyright of this module includes the following
  22.  * linking-with-specific-other-licenses addition:
  23.  *
  24.  * In addition, as a special exception, the copyright holders of
  25.  * this module give you permission to combine (via static or
  26.  * dynamic linking) this module with free software programs or
  27.  * libraries that are released under the GNU LGPL and with code
  28.  * included in the standard release of ns-2 under the Apache 2.0
  29.  * license or under otherwise-compatible licenses with advertising
  30.  * requirements (or modified versions of such code, with unchanged
  31.  * license).  You may copy and distribute such a system following the
  32.  * terms of the GNU GPL for this module and the licenses of the
  33.  * other code concerned, provided that you include the source code of
  34.  * that other code when and as the GNU GPL requires distribution of
  35.  * source code.
  36.  *
  37.  * Note that people who make modified versions of this module
  38.  * are not obligated to grant this special exception for their
  39.  * modified versions; it is their choice whether to do so.  The GNU
  40.  * General Public License gives permission to release a modified
  41.  * version without this exception; this exception also makes it
  42.  * possible to release a modified version which carries forward this
  43.  * exception.
  44.  *
  45.  */
  46.  
  47. /*
  48.  * This code was designed and developed by:
  49.  * 
  50.  * Qi Chen                 : qi.chen@daimler.com
  51.  * Felix Schmidt-Eisenlohr : felix.schmidt-eisenlohr@kit.edu
  52.  * Daniel Jiang            : daniel.jiang@daimler.com
  53.  * 
  54.  * For further information see: 
  55.  * http://dsn.tm.uni-karlsruhe.de/english/Overhaul_NS-2.php
  56.  */
  58. #include "delay.h"
  59. #include "connector.h"
  60. #include "packet.h"
  61. #include "random.h"
  62. #include "mobilenode.h"
  63. #include "arp.h"
  64. #include "ll.h"
  65. #include "mac.h"
  66. #include "mac-802_11Ext.h"
  67. #include "cmu-trace.h"
  68. #include <iostream>
  70. #include "common/agent.h"
  72. PHY_MIBExt::PHY_MIBExt(Mac802_11Ext *parent) {
  73. parent->bind("SlotTime_", &SlotTime);
  74. parent->bind("HeaderDuration_", &HeaderDuration);
  75. parent->bind("SymbolDuration_", &SymbolDuration);
  76. parent->bind("BasicModulationScheme_", &BasicModulationScheme);
  77. parent->bind_bool("use_802_11a_flag_", &use_802_11a_flag_);
  78. }
  80. MAC_MIBExt::MAC_MIBExt(Mac802_11Ext *parent) {
  81. parent->bind("CWMin_", &CWMin);
  82. parent->bind("CWMax_", &CWMax);
  83. parent->bind("SIFS_", &SIFSTime);
  84. parent->bind("RTSThreshold_", &RTSThreshold);
  85. parent->bind("ShortRetryLimit_", &ShortRetryLimit);
  86. parent->bind("LongRetryLimit_", &LongRetryLimit);
  88. }
  90. /* ======================================================================
  91.  TCL Hooks for the simulator
  92.  ====================================================================== */
  93. static class Mac802_11ExtClass : public TclClass {
  94. public:
  95. Mac802_11ExtClass() :
  96. TclClass("Mac/802_11Ext") {
  97. }
  98. TclObject* create(int, const char*const*) {
  99. return (new Mac802_11Ext());
  100. }
  101. } class_mac802_11;
  103. /* ======================================================================
  104.  Mac Class Functions
  105.  ====================================================================== */
  106. Mac802_11Ext::Mac802_11Ext() :
  107. Mac(), bkmgr(this), csmgr(this), txc(this), rxc(this), phymib_(this),
  108. macmib_(this) {
  109. bind("MAC_DBG", &MAC_DBG);
  110. ssrc_ = slrc_ = 0;
  112. sifs_ = macmib_.getSIFS();
  113. difs_ = macmib_.getSIFS() + 2*phymib_.getSlotTime();
  114. eifs_ = macmib_.getSIFS() + difs_ + txtime(phymib_.getACKlen(),
  115. phymib_.getBasicModulationScheme());
  116. pifs_ = sifs_ + phymib_.getSlotTime();
  117. cw_ = macmib_.getCWMin();
  118. bkmgr.setSlotTime(phymib_.getSlotTime());
  119. csmgr.setIFS(eifs_);
  120. txConfirmCallback_=Callback_TXC;
  121. }
  123. int Mac802_11Ext::command(int argc, const char*const* argv) {
  124. if (argc == 3) {
  125. if (strcmp(argv[1], "log-target") == 0) {
  126. logtarget_ = (NsObject*) TclObject::lookup(argv[2]);
  127. if (logtarget_ == 0)
  128. return TCL_ERROR;
  129. return TCL_OK;
  130. }
  131. }
  132. return Mac::command(argc, argv);
  133. }
  135. /* ======================================================================
  136.  Debugging Routines
  137.  ====================================================================== */
  138. void Mac802_11Ext::trace_pkt(Packet *p) {
  139. struct hdr_cmn *ch = HDR_CMN(p);
  140. struct hdr_mac802_11* dh = HDR_MAC802_11(p);
  141. u_int16_t *t = (u_int16_t*) &dh->dh_fc;
  143. fprintf(stderr, "t[ %2x %2x %2x %2x ] %x %s %dn",
  144. *t, dh->dh_duration,
  145. ETHER_ADDR(dh->dh_ra), ETHER_ADDR(dh->dh_ta),
  146. index_, packet_info.name(ch->ptype()), ch->size());
  147. }
  149. void Mac802_11Ext::dump(char *fname) {
  151. }
  153. void Mac802_11Ext::log(char* event, char* additional) {
  154. if (MAC_DBG)
  155. cout<<"L "<<Scheduler::instance().clock()<<" "<<index_<<" "<<"MAC"<<" "<<event<<" "<<additional
  156. <<endl;
  157. }
  159. /* ======================================================================
  160.  Packet Headers Routines
  161.  ====================================================================== */
  162. inline int Mac802_11Ext::hdr_dst(char* hdr, int dst) {
  163. struct hdr_mac802_11 *dh = (struct hdr_mac802_11*) hdr;
  165. if (dst > -2)
  166. STORE4BYTE(&dst, (dh->dh_ra));
  168. return ETHER_ADDR(dh->dh_ra);
  169. }
  171. inline int Mac802_11Ext::hdr_src(char* hdr, int src) {
  172. struct hdr_mac802_11 *dh = (struct hdr_mac802_11*) hdr;
  173. if (src > -2)
  174. STORE4BYTE(&src, (dh->dh_ta));
  175. return ETHER_ADDR(dh->dh_ta);
  176. }
  178. inline int Mac802_11Ext::hdr_type(char* hdr, u_int16_t type) {
  179. struct hdr_mac802_11 *dh = (struct hdr_mac802_11*) hdr;
  180. if (type)
  181. STORE2BYTE(&type,(dh->dh_body));
  182. return GET2BYTE(dh->dh_body);
  183. }
  185. /* ======================================================================
  186.  Misc Routines
  187.  ====================================================================== */
  189. void Mac802_11Ext::discard(Packet *p, const char* why) {
  190. hdr_mac802_11* mh = HDR_MAC802_11(p);
  191. hdr_cmn *ch = HDR_CMN(p);
  193. /* if the rcvd pkt contains errors, a real MAC layer couldn't
  194.  necessarily read any data from it, so we just toss it now */
  195. if (ch->error() != 0) {
  196. Packet::free(p);
  197. //p = 0;
  198. return;
  199. }
  201. switch (mh->dh_fc.fc_type) {
  202. case MAC_Type_Management:
  203. drop(p, why);
  204. return;
  205. case MAC_Type_Control:
  206. switch (mh->dh_fc.fc_subtype) {
  207. case MAC_Subtype_RTS:
  208. if ((u_int32_t)ETHER_ADDR(mh->dh_ta) ==(u_int32_t)index_) {
  209. drop(p, why);
  210. return;
  211. }
  212. /* fall through - if necessary */
  213. case MAC_Subtype_CTS:
  214. case MAC_Subtype_ACK:
  215. if ((u_int32_t)ETHER_ADDR(mh->dh_ra) ==(u_int32_t)index_) {
  216. drop(p, why);
  217. return;
  218. }
  219. break;
  220. default:
  221. fprintf(stderr, "invalid MAC Control subtypen");
  222. exit(1);
  223. }
  224. break;
  225. case MAC_Type_Data:
  226. switch (mh->dh_fc.fc_subtype) {
  227. case MAC_Subtype_Data:
  228. if ((u_int32_t)ETHER_ADDR(mh->dh_ra) ==(u_int32_t)index_ ||(u_int32_t)ETHER_ADDR(mh->dh_ta) ==(u_int32_t)index_ ||(u_int32_t)ETHER_ADDR(mh->dh_ra) == MAC_BROADCAST) {
  229. drop(p, why); //check! drop does not work
  230. // Packet::free(p);
  231. return;
  232. }
  233. break;
  234. default:
  235. fprintf(stderr, "invalid MAC Data subtypen");
  236. exit(1);
  237. }
  238. break;
  239. default:
  240. fprintf(stderr, "invalid MAC type (%x)n", mh->dh_fc.fc_type);
  241. trace_pkt(p);
  242. exit(1);
  243. }
  244. Packet::free(p);
  246. }
  248. /*new code starts here*/
  250. /*--------------1.0 Channel State module-------------------------------*/
  251. /*----------------IFSTimer NAVTimer and ChannelStateMgr----------------*/
  252. /*---------------------------------------------------------------------*/
  254. //IFSTimer
  255. void IFSTimer::expire(Event *e) {
  256. csmgr->handleIFSTimer();
  257. }
  259. //NAVTimer
  260. void NAVTimer::expire(Event *e) {
  261. csmgr->handleNAVTimer();
  262. }
  264. //ChannelStateMgr
  265. ChannelStateMgr::ChannelStateMgr(Mac802_11Ext * m) {
  266. mac_ = m;
  267. channel_state_ = noCSnoNAV;
  268. ifs_value_ = -1.0;
  269. ifs_value_ = mac_->eifs_;
  270. ifsTimer_ = new IFSTimer(this);
  271. navTimer_ = new NAVTimer(this);
  272. }
  274. void ChannelStateMgr::setChannelState(ChannelState newState) {
  275. if (mac_->MAC_DBG) {
  276. char msg[1000];
  277. sprintf(msg, "%d -> %d", channel_state_, newState);
  278. mac_->log("ChState", msg);
  279. }
  280. channel_state_ = newState;
  281. }
  283. void ChannelStateMgr::setIFS(double tifs) {
  284. if (mac_->MAC_DBG) {
  285. char msg[1000];
  286. sprintf(msg, "%f", tifs);
  287. mac_->log("ChSetIFS", msg);
  288. }
  289. ifs_value_=tifs;
  290. //the following line of codes is used to solved the race conditon of event scheduling
  291. //IDleIndication is handled before RXEndIndication
  292. //therefore the IFSTimer is started before the new ifs_value_ is set in RXEndIndication
  293. if (ifsTimer_->status()==TIMER_PENDING) // ifsTimer has been scheduled
  294. {
  295. ifsTimer_->cancel();
  296. ifsTimer_->sched(ifs_value_);
  297. }
  298. //end of this change
  299. }
  301. void ChannelStateMgr::handlePHYBusyIndication() {
  302. switch (channel_state_) {
  303. case noCSnoNAV:
  304. mac_->bkmgr.handleCSBUSY();
  305. setChannelState(CSnoNAV);
  306. break;
  307. case noCSNAV:
  308. setChannelState(CSNAV);
  309. break;
  310. case WIFS:
  311. if (ifsTimer_->status()==TIMER_PENDING)
  312. ifsTimer_->cancel();
  313. setChannelState(CSnoNAV);
  314. break;
  315. default:
  316. //  the busy indication from phy will be ignored if the channel statemgr is already in CS_BUSY
  317. break;
  318. }
  319. }
  321. void ChannelStateMgr::handlePHYIdleIndication() {
  322. switch (channel_state_) {
  323. case CSnoNAV:
  324. ifsTimer_->sched(ifs_value_);
  325. setChannelState(WIFS);
  326. break;
  327. case CSNAV:
  328. setChannelState(noCSNAV);
  329. break;
  330. default:
  331. // the idle indication from phy will be ignored if the channel statemgr is already CS free
  332. break;
  333. }
  334. }
  336. void ChannelStateMgr::handleSetNAV(double t) {
  337. if (mac_->MAC_DBG) {
  338. char msg [1000];
  339. sprintf(msg, "%f", t);
  340. mac_->log("ChSetNAV", msg);
  341. }
  342. switch (channel_state_) {
  343. case noCSnoNAV:
  344. navTimer_->sched(t);
  345. mac_->bkmgr.handleCSBUSY();
  346. setChannelState(noCSNAV);
  347. break;
  348. case CSnoNAV:
  349. navTimer_->sched(t);
  350. setChannelState(CSNAV);
  351. break;
  352. case noCSNAV:
  353. navTimer_->cancel();
  354. navTimer_->sched(t);
  355. break;
  356. case CSNAV:
  357. navTimer_->cancel();
  358. navTimer_->sched(t);
  359. break;
  360. case WIFS:
  361. navTimer_->sched(t);
  362. if (ifsTimer_->status()==TIMER_PENDING)
  363. ifsTimer_->cancel();
  364. setChannelState(noCSNAV);
  365. //needs further attention
  366. //cout<<"logic error at ChannelStateMgr, event handleSetNAV"<<endl;
  367. //exit(-1);
  368. break;
  369. default:
  370. cout<<"logic error at ChannelStateMgr, event handleSetNAV"<<endl;
  371. exit(-1);
  372. }
  373. }
  375. void ChannelStateMgr::handleIFSTimer() {
  376. if (channel_state_ == WIFS) {
  377. //chi changed the order 
  378. setChannelState(noCSnoNAV);
  379. mac_->bkmgr.handleCSIDLE();
  381. } else {
  382. cout<<"logic error at ChannelStateMgr, event handleIFSTimer"<<endl;
  383. exit(-1);
  384. }
  385. }
  387. void ChannelStateMgr::handleNAVTimer() {
  388. switch (channel_state_) {
  389. case noCSNAV:
  390. ifsTimer_->sched(ifs_value_);
  391. setChannelState(WIFS);
  392. break;
  393. case CSNAV:
  394. setChannelState(CSnoNAV);
  395. break;
  396. default:
  397. cout<<"logic error at ChannelStateMgr, event handleNAVTimer"<<endl;
  398. exit(-1);
  399. }
  400. }
  401. /*---------------2.0 Backoff Module----------------*/
  402. /*--- BackoffTimer_t and BackoffMgr -----------*/
  403. /*---------------------------------------------*/
  404. /* BackoffTimer_t */
  406. BackoffTimer_t::BackoffTimer_t(BackoffMgr *b) {
  407. bkmgr_ =b;
  408. tSlot = -1.0; // the real initialization is in int()
  409. startTime=-1.0;
  410. remainingSlots_=-1;
  411. }
  413. void BackoffTimer_t::setSlotTime(double t) {
  414. tSlot = t;
  415. }
  417. int BackoffTimer_t::init(int CW) {
  418. remainingSlots_ = Random::integer(CW+1); //choose a number within [0,CW]
  419. startTime = -1.0;
  420. return remainingSlots_;
  421. }
  423. void BackoffTimer_t::pause() {
  424. if (startTime ==-1.0) {
  425. cout<<"logic error at BackoffTimer_t, event pause"<<endl;
  426. exit(-1);
  427. }
  428. remainingSlots_-=(int)(floor((Scheduler::instance().clock()-startTime)/tSlot));
  429. if (status()==TIMER_PENDING)
  430. cancel();
  431. startTime = -1.0;
  432. }
  434. void BackoffTimer_t::run() {
  435. //chi added for testing remainging slots
  436. if (remainingSlots_ ==0) {
  437. remainingSlots_=-1;
  438. bkmgr_->handleBackoffTimer();
  439. } else {
  440. startTime = Scheduler::instance().clock();
  441. sched(remainingSlots_*tSlot);
  442. }
  443. }
  445. void BackoffTimer_t::expire(Event *e) {
  446. remainingSlots_=-1;
  447. bkmgr_->handleBackoffTimer();
  448. return;
  449. }
  451. BackoffMgr::BackoffMgr(Mac802_11Ext *m) {
  452. mac_ = m;
  453. bk_state_ = noBackoff; //needs further attention
  454. bkTimer_ = new BackoffTimer_t(this);
  455. }
  457. void BackoffMgr::setSlotTime(double t) {
  458. bkTimer_->setSlotTime(t);
  459. }
  461. void BackoffMgr::setBackoffMgrState(BackoffMgrState newState) {
  462. if (mac_->MAC_DBG) {
  463. char msg [1000];
  464. sprintf(msg, "%d -> %d, rslots: %d", bk_state_, newState,
  465. bkTimer_->remainingSlots_);
  466. mac_->log("BkState", msg);
  467. }
  468. bk_state_ = newState;
  469. }
  471. void BackoffMgr::handleCSIDLE() {
  472. switch (bk_state_) {
  473. case BackoffPause:
  474. setBackoffMgrState(BackoffRunning);
  475. bkTimer_->run();
  476. break;
  477. case noBackoff:
  478. //ignore this signal
  479. break;
  480. default:
  481. cout<<"logic error at BackoffMgr, event handleCSIDLE"<<endl;
  482. exit(-1);
  483. }
  484. }
  486. void BackoffMgr::handleCSBUSY() {
  487. switch (bk_state_) {
  488. case noBackoff:
  489. //ignore this signal
  490. break;
  491. case BackoffPause:
  492. //ignore this signal
  493. break;
  494. case BackoffRunning:
  496. setBackoffMgrState(BackoffPause);
  497. bkTimer_->pause();
  498. break;
  499. default:
  500. cout<<"logic error at BackoffMgr, event handleCSBUSY"<<endl;
  501. exit(-1);
  502. }
  503. }
  505. void BackoffMgr::handleBKStart(int CW) {
  506. switch (bk_state_) {
  507. case noBackoff:
  508. //Chi changed
  510. if (mac_->csmgr.getChannelState()==noCSnoNAV) {
  511. if (bkTimer_->init(CW) == 0) {
  512. setBackoffMgrState(noBackoff);
  513. BKDone();
  515. } else {
  516. setBackoffMgrState(BackoffRunning);
  517. bkTimer_->run();
  519. }
  520. } else {
  522. bkTimer_->init(CW);
  523. setBackoffMgrState(BackoffPause);
  524. }
  525. break;
  526. case BackoffRunning:
  527. //ignore this signal
  528. break;
  529. case BackoffPause:
  530. //ignore this signal
  531. break;
  532. default:
  533. cout<<"logic error at BackoffMgr, event handleBKStart"<<endl;
  534. exit(-1);
  535. }
  536. }
  538. void BackoffMgr::handleBackoffTimer() {
  539. switch (bk_state_) {
  540. case BackoffRunning:
  542. setBackoffMgrState(noBackoff);
  543. BKDone();
  544. break;
  545. default:
  546. cout<<"logic error at BackoffMgr, event handleBackoffTimer"<<endl;
  547. exit(-1);
  548. }
  549. }
  551. void BackoffMgr::BKDone() {
  552. mac_->handleBKDone();
  553. }
  554. /*----------------------------------------------------*/
  555. /*-------------3.0 reception module-------------------*/
  556. /*---------------PHYBusyIndication PHYIdleIndication--*/
  557. /*---------------RXStartIndication RXEndIndication----*/
  559. void Mac802_11Ext::handlePHYBusyIndication() {
  560. if (MAC_DBG)
  561. log("PHYBusyInd", "");
  562. csmgr.handlePHYBusyIndication();
  563. }
  565. void Mac802_11Ext::handlePHYIdleIndication() {
  566. if (MAC_DBG)
  567. log("PHYIdleInd", "");
  568. csmgr.handlePHYIdleIndication();
  569. }
  571. void Mac802_11Ext::handleRXStartIndication() {
  572. if (MAC_DBG)
  573. log("RxStartInd", "");
  574. }
  576. void Mac802_11Ext::handleRXEndIndication(Packet * pktRx_) {
  577. if (!pktRx_) {
  578. if (MAC_DBG)
  579. log("RxEndInd", "FAIL");
  580. csmgr.setIFS(eifs_);
  581. return;
  582. }
  583. if (MAC_DBG)
  584. log("RxEndInd", "SUCC");
  586. hdr_mac802_11 *mh = HDR_MAC802_11(pktRx_);
  587. u_int32_t dst= ETHER_ADDR(mh->dh_ra);
  588. u_int8_t type = mh->dh_fc.fc_type;
  589. u_int8_t subtype = mh->dh_fc.fc_subtype;
  590. csmgr.setIFS(difs_);
  592. if (tap_ && type == MAC_Type_Data&& MAC_Subtype_Data == subtype)
  593. tap_->tap(pktRx_);
  594. /*
  595.  * Address Filtering
  596.  */
  597. if (dst == (u_int32_t)index_ || dst == MAC_BROADCAST) {
  598. rxc.handleMsgFromBelow(pktRx_);
  599. } else {
  600. /*
  601.  *  We don't want to log this event, so we just free
  602.  *  the packet instead of calling the drop routine.
  603.  */
  604. if (MAC_DBG)
  605. log("RxEndInd", "NAV");
  606. csmgr.handleSetNAV(sec(mh->dh_duration));
  607. discard(pktRx_, "---");
  608. return;
  609. }
  610. }
  612. //-------------------4.0 transmission module----------------//
  613. //---------------------TxTimer and MAC handlers-------------//
  615. // this function is used by transmission module
  618. void Mac802_11Ext::transmit(Packet *p, TXConfirmCallback callback) {
  619. txConfirmCallback_=callback;
  620. // check memory leak? 
  621. if (MAC_DBG)
  622. log("Tx", "Start");
  623. downtarget_->recv(p->copy(), this);
  624. }
  626. void Mac802_11Ext::handleTXEndIndication() {
  627. if (MAC_DBG)
  628. log("Tx", "Fin");
  629. switch (txConfirmCallback_) {
  630. case Callback_TXC:
  631. txc.handleTXConfirm();
  632. break;
  633. case Callback_RXC:
  634. rxc.handleTXConfirm();
  635. break;
  636. default:
  637. cout<<"logic error at handleTXTimer"<<endl;
  638. }
  639. }
  641. /*-------------------5.0 protocol coodination module----------
  642.  ---------------------5.1 tx coordination----------------------
  643.  ---------------------TxTimeout and MAC handlers-------------*/
  645. // this function is used by tx coordination to prepare the MAC frame in detail
  648. void Mac802_11Ext::handleBKDone() {
  649. txc.handleBKDone();
  650. }
  652. // this function is used to handle the packets from the upper layer
  653. void Mac802_11Ext::recv(Packet *p, Handler *h) {
  654. struct hdr_cmn *hdr = HDR_CMN(p);
  655. /*
  656.  * Sanity Check
  657.  */
  658. assert(initialized());
  660. if (hdr->direction() == hdr_cmn::DOWN) {
  661. if (MAC_DBG)
  662. log("FROM_IFQ", "");
  663. // send(p, h); replaced by txc
  664. callback_=h;
  665. txc.handleMsgFromUp(p);
  666. return;
  667. } else {
  668. //the reception of a packet is moved to handleRXStart/EndIndication
  669. cout<<"logic error at recv, event sendUP"<<endl;
  670. }
  671. }
  673. //-------------------5.2 rx coordination----------------------------------//
  674. //------------------------------------------------------------------------//
  675. void Mac802_11Ext::recvDATA(Packet *p) {
  676. struct hdr_mac802_11 *dh = HDR_MAC802_11(p);
  677. u_int32_t dst, src, size;
  679. struct hdr_cmn *ch = HDR_CMN(p);
  680. dst = ETHER_ADDR(dh->dh_ra);
  681. src = ETHER_ADDR(dh->dh_ta);
  682. size = ch->size();
  683. ch->size() -= phymib_.getHdrLen11();
  684. ch->num_forwards() += 1;
  686. if (MAC_DBG)
  687. log("SEND_UP", "");
  688. uptarget_->recv(p, (Handler*) 0);
  689. }
  691. //-------------------6.0 txtime----------------------------------//
  692. //------------------------------------------------------------------------//
  694. /*
  695.  * txtime() - pluck the precomputed tx time from the packet header
  696.  */
  697. double Mac802_11Ext::txtime(Packet *p) {
  698. struct hdr_cmn *ch = HDR_CMN(p);
  699. double t = ch->txtime();
  700. if (t < 0.0) {
  701. drop(p, "XXX");
  702. exit(1);
  703. }
  704. return t;
  705. }
  707. /*
  708.  * txtime() - calculate tx time for packet of size "psz" bytes 
  709.  *   at rate "drt" bps
  710.  */
  711. double Mac802_11Ext::txtime(double psz, double drt) {
  712. int datalen = (int) psz << 3;
  713. double t = phymib_.getHeaderDuration() + (double)datalen/drt;
  714. return (t);
  715. }
  717. /*
  718.  * txtime() - calculate tx time for packet of size "psz" bytes 
  719.  *   with modulation scheme mod_scheme
  720.  *                this is the function used in reality
  721.  */
  722. double Mac802_11Ext::txtime(double psz, int mod_scheme) {
  723. int datalen = (int) psz << 3;
  724. int DBPS = modulation_table[mod_scheme].NDBPS;
  726. // 802.11p
  727. if (phymib_.use_802_11a()) {
  728. datalen = datalen + 16 + 6; // 16 SYMBOL BITS, 6 TAIL BITS
  729. }
  730. int symbols = (int)(ceil((double)datalen/DBPS)); // PADDING BITS, FILL SYMBOl
  732. double t = phymib_.getHeaderDuration() + (double) symbols
  733. * phymib_.getSymbolDuration();
  734. return (t);
  735. }
  737. /*new code ends here*/
  739. //-------tx coordination function-------//
  740. void TXC_CTSTimer::expire(Event *e) {
  741. txc_->handleTCTStimeout();
  742. }
  744. void TXC_SIFSTimer::expire(Event *e) {
  745. txc_->handleSIFStimeout();
  746. }
  748. void TXC_ACKTimer::expire(Event *e) {
  749. txc_->handleTACKtimeout();
  750. }
  752. TXC::TXC(Mac802_11Ext *m) :
  753. txcCTSTimer(this), txcSIFSTimer(this), txcACKTimer(this) {
  754. mac_=m;
  755. pRTS=0;
  756. pDATA=0;
  757. txc_state_=TXC_Idle;
  758. shortretrycounter = 0;
  759. longretrycounter = 0;
  760. // rtsretrycounter=0;
  761. // dataretrycounter=0;
  762. }
  764. void TXC::handleMsgFromUp(Packet *p) {
  765. if (mac_->MAC_DBG)
  766. mac_->log("TXC", "msgFromUp");
  767. pDATA=p;
  768. prepareMPDU(pDATA);
  769. hdr_mac802_11* mh = HDR_MAC802_11(pDATA);
  770. struct hdr_cmn *ch = HDR_CMN(pDATA);
  772. if ((u_int32_t)ETHER_ADDR(mh->dh_ra) != MAC_BROADCAST&& (unsigned int)(ch->size())
  773. >mac_->macmib_.getRTSThreshold()) //should get the right size //check type
  774. {
  775. if (mac_->MAC_DBG)
  776. mac_->log("TXC", "msgFromUp, RTS/CTS");
  777. generateRTSFrame(pDATA);
  779. }
  780. if (mac_->bkmgr.getBackoffMgrState()==noBackoff) {
  781. if (mac_->csmgr.getChannelState()==noCSnoNAV) {
  782. if (mac_->MAC_DBG)
  783. mac_->log("TXC", "msgFromUp, noBackoff, noCSnoNAV");
  784. if (pRTS!=0) {
  785. mac_->transmit(pRTS, Callback_TXC);
  786. setTXCState(TXC_wait_RTSsent);
  787. } else {
  788. mac_->transmit(pDATA, Callback_TXC);
  789. setTXCState(TXC_wait_PDUsent);
  790. }
  791. } else {
  792. if (mac_->MAC_DBG)
  793. mac_->log("TXC", "msgFromUp, Backoff started");
  794. mac_->bkmgr.handleBKStart(mac_->cw_);
  795. if (pRTS!=0) {
  796. setTXCState(TXC_RTS_pending);
  797. } else {
  798. setTXCState(TXC_DATA_pending);
  799. }
  800. }
  801. } else {
  802. if (mac_->MAC_DBG)
  803. mac_->log("TXC", "msgFromUp, Backoff pending");
  804. if (pRTS!=0) {
  805. setTXCState(TXC_RTS_pending);
  806. } else {
  807. setTXCState(TXC_DATA_pending);
  808. }
  809. }
  810. }
  812. void TXC::prepareMPDU(Packet *p) {
  813. hdr_cmn* ch = HDR_CMN(p);
  814. struct hdr_mac802_11* dh = HDR_MAC802_11(p);
  815. ch->size() += mac_->phymib_.getHdrLen11();
  817. dh->dh_fc.fc_protocol_version = MAC_ProtocolVersion;
  818. dh->dh_fc.fc_type = MAC_Type_Data;
  819. dh->dh_fc.fc_subtype = MAC_Subtype_Data;
  820. dh->dh_fc.fc_to_ds = 0;
  821. dh->dh_fc.fc_from_ds = 0;
  822. dh->dh_fc.fc_more_frag = 0;
  823. dh->dh_fc.fc_retry = 0;
  824. dh->dh_fc.fc_pwr_mgt = 0;
  825. dh->dh_fc.fc_more_data = 0;
  826. dh->dh_fc.fc_wep = 0;
  827. dh->dh_fc.fc_order = 0;
  829. ch->txtime() = mac_->txtime(ch->size(), ch->mod_scheme_);
  831. if ((u_int32_t)ETHER_ADDR(dh->dh_ra) != MAC_BROADCAST) {
  832. dh->dh_duration = mac_->usec(mac_->txtime(mac_->phymib_.getACKlen(),
  833. mac_->phymib_.getBasicModulationScheme())
  834. + mac_->macmib_.getSIFS());
  835. } else {
  836. dh->dh_duration = 0;
  837. }
  838. }
  840. void TXC::handleBKDone() {
  841. if (mac_->MAC_DBG)
  842. mac_->log("TXC", "BK Done");
  843. switch (txc_state_) {
  844. case TXC_RTS_pending:
  845. mac_->transmit(pRTS, Callback_TXC);
  846. setTXCState(TXC_wait_RTSsent);
  847. break;
  848. case TXC_DATA_pending:
  849. mac_->transmit(pDATA, Callback_TXC);
  850. setTXCState(TXC_wait_PDUsent);
  851. break;
  852. case TXC_Idle: //check : not in the SDL
  853. case TXC_wait_CTS:
  854. case TXC_wait_ACK:
  855. break;
  856. default:
  857. cout<<txc_state_<<endl;
  858. cout<<"logic error at TXC handling BKDone"<<endl;
  859. }
  860. }
  862. void TXC::handleTXConfirm() {
  863. if (mac_->MAC_DBG)
  864. mac_->log("TXC", "TX Confirm");
  865. hdr_mac802_11* mh = HDR_MAC802_11(pDATA);
  866. switch (txc_state_) {
  867. case TXC_wait_PDUsent:
  868. if ((u_int32_t)ETHER_ADDR(mh->dh_ra) != MAC_BROADCAST) {
  869. txcACKTimer.sched(mac_->macmib_.getSIFS()+ mac_->txtime(
  870. mac_->phymib_.getACKlen(),
  871. mac_->phymib_.getBasicModulationScheme())
  872. + DSSS_MaxPropagationDelay);
  873. setTXCState(TXC_wait_ACK);
  874. } else {
  875. mac_->bkmgr.handleBKStart(mac_->cw_);
  876. checkQueue();
  877. }
  878. break;
  879. case TXC_wait_RTSsent:
  880. txcCTSTimer.sched(mac_->macmib_.getSIFS()+ mac_->txtime(
  881. mac_->phymib_.getCTSlen(),
  882. mac_->phymib_.getBasicModulationScheme())
  883. + DSSS_MaxPropagationDelay);
  884. setTXCState(TXC_wait_CTS);
  885. break;
  886. default:
  887. cout<<"logic error at TXC handling txconfirm"<<endl;
  889. }
  890. }
  892. void TXC::checkQueue() {
  893. setTXCState(TXC_Idle);
  894. if (mac_->callback_) {
  895. if (mac_->MAC_DBG)
  896. mac_->log("TXC", "checkQueue, empty");
  897. Handler *h = mac_->callback_;
  898. mac_->callback_=0;
  899. h->handle((Event*) 0);
  900. } else {
  901. if (mac_->MAC_DBG)
  902. mac_->log("TXC", "checkQueue, pending");
  903. }
  904. }
  906. void TXC::handleCTSIndication() {
  907. if (mac_->MAC_DBG)
  908. mac_->log("TXC", "CTS indication");
  909. if (txc_state_==TXC_wait_CTS) {
  910. Packet::free(pRTS);
  911. pRTS = 0;
  912. txcCTSTimer.cancel();
  913. shortretrycounter = 0;
  914. setTXCState(TXC_wait_SIFS);
  915. txcSIFSTimer.sched(mac_->macmib_.getSIFS());
  916. } else {
  917. cout<<"txc_state_"<<txc_state_<<endl;
  918. cout<<"logic error at TXC handling CTS indication"<<endl;
  919. }
  920. }
  922. void TXC::handleTCTStimeout() {
  923. if (txc_state_==TXC_wait_CTS) {
  924. shortretrycounter++;
  925. mac_->inc_cw();
  926. if (shortretrycounter >= mac_->macmib_.getShortRetryLimit()) {
  927. if (mac_->MAC_DBG)
  928. mac_->log("TXC", "CTS timeout, limit reached");
  929. mac_->discard(pRTS, DROP_MAC_RETRY_COUNT_EXCEEDED);
  930. pRTS = 0;
  931. mac_->discard(pDATA, DROP_MAC_RETRY_COUNT_EXCEEDED);
  932. pDATA = 0;
  934. shortretrycounter = 0;
  935. longretrycounter = 0;
  936. mac_->cw_=mac_->macmib_.getCWMin();
  937. mac_->bkmgr.handleBKStart(mac_->cw_);
  938. checkQueue();
  939. } else {
  940. if (mac_->MAC_DBG)
  941. mac_->log("TXC", "CTS timeout, retry");
  942. setTXCState(TXC_RTS_pending);
  943. mac_->bkmgr.handleBKStart(mac_->cw_);
  944. }
  946. } else
  947. cout<<"logic error at TXC handleTCTS timeout"<<endl;
  948. }
  950. void TXC::handleSIFStimeout() {
  951. if (mac_->MAC_DBG)
  952. mac_->log("TXC", "SIFS finished");
  953. if (txc_state_==TXC_wait_SIFS) {
  954. mac_->transmit(pDATA, Callback_TXC);
  955. setTXCState(TXC_wait_PDUsent);
  956. } else
  957. cout<<"logic error at TXC handling SIFS timeout"<<endl;
  959. }
  961. void TXC::handleTACKtimeout() {
  962. if (txc_state_==TXC_wait_ACK) {
  963. hdr_mac802_11* mh = HDR_MAC802_11(pDATA);
  964. struct hdr_cmn *ch = HDR_CMN(pDATA);
  966. unsigned int limit = 0;
  967. unsigned int * counter;
  968. if ((unsigned int)ch->size() <= mac_->macmib_.getRTSThreshold()) {
  969. limit = mac_->macmib_.getShortRetryLimit();
  970. counter = &shortretrycounter;
  971. } else {
  972. limit = mac_->macmib_.getLongRetryLimit();
  973. counter = &longretrycounter;
  974. }
  975. (*counter)++;
  977. mac_->inc_cw();
  979. if (*counter >= limit) {
  980. if (mac_->MAC_DBG)
  981. mac_->log("TXC", "ACK timeout, limit reached");
  982. mac_->discard(pDATA, DROP_MAC_RETRY_COUNT_EXCEEDED);
  983. pDATA = 0;
  985. shortretrycounter = 0;
  986. longretrycounter = 0;
  987. mac_->cw_=mac_->macmib_.getCWMin();
  988. mac_->bkmgr.handleBKStart(mac_->cw_);
  989. checkQueue();
  990. } else {
  991. if (mac_->MAC_DBG)
  992. mac_->log("TXC", "ACK timeout, retry");
  994. if ((u_int32_t)ETHER_ADDR(mh->dh_ra) != MAC_BROADCAST&&(unsigned int)(ch->size())
  995. > mac_->macmib_.getRTSThreshold()) {
  996. generateRTSFrame(pDATA);
  997. setTXCState(TXC_RTS_pending);
  998. } else {
  999. setTXCState(TXC_DATA_pending);
  1000. }
  1002. mac_->bkmgr.handleBKStart(mac_->cw_);
  1004. }
  1005. } else
  1006. cout<<"logic error at TXC handling TACK timeout"<<endl;
  1007. }
  1009. void TXC::generateRTSFrame(Packet * p) {
  1010. Packet *rts = Packet::alloc();
  1011. hdr_cmn* ch = HDR_CMN(rts);
  1012. struct rts_frame *rf = (struct rts_frame*)rts->access(hdr_mac::offset_);
  1014. ch->uid() = 0;
  1015. ch->ptype() = PT_MAC;
  1016. ch->size() = mac_->phymib_.getRTSlen();
  1017. ch->iface() = -2;
  1018. ch->error() = 0;
  1019. ch->mod_scheme_= (ModulationScheme)mac_->phymib_.getBasicModulationScheme();
  1020. bzero(rf, MAC_HDR_LEN);
  1022. rf->rf_fc.fc_protocol_version = MAC_ProtocolVersion;
  1023. rf->rf_fc.fc_type = MAC_Type_Control;
  1024. rf->rf_fc.fc_subtype = MAC_Subtype_RTS;
  1025. rf->rf_fc.fc_to_ds = 0;
  1026. rf->rf_fc.fc_from_ds = 0;
  1027. rf->rf_fc.fc_more_frag = 0;
  1028. rf->rf_fc.fc_retry = 0;
  1029. rf->rf_fc.fc_pwr_mgt = 0;
  1030. rf->rf_fc.fc_more_data = 0;
  1031. rf->rf_fc.fc_wep = 0;
  1032. rf->rf_fc.fc_order = 0;
  1034. struct hdr_mac802_11 *mh = HDR_MAC802_11(p);
  1035. u_int32_t dst= ETHER_ADDR(mh->dh_ra);
  1036. STORE4BYTE(&dst, (rf->rf_ra));
  1037. STORE4BYTE(&(mac_->index_), (rf->rf_ta));
  1039. ch->txtime() = mac_->txtime(ch->size(), ch->mod_scheme_);
  1040. rf->rf_duration = mac_->usec(mac_->macmib_.getSIFS()
  1041. + mac_->txtime(mac_->phymib_.getCTSlen(),
  1042. mac_->phymib_.getBasicModulationScheme())
  1043. + mac_->macmib_.getSIFS()+ mac_->txtime(p)+ mac_->macmib_.getSIFS()
  1044. + mac_->txtime(mac_->phymib_.getACKlen(),
  1045. mac_->phymib_.getBasicModulationScheme()));
  1046. pRTS = rts;
  1047. }
  1049. void TXC::handleACKIndication() {
  1050. if (mac_->MAC_DBG)
  1051. mac_->log("TXC", "ACK indication");
  1052. if (txc_state_==TXC_wait_ACK ) {
  1053. txcACKTimer.cancel();
  1054. shortretrycounter = 0;
  1055. longretrycounter = 0;
  1056. Packet::free(pDATA);
  1057. pDATA=0;
  1058. mac_->cw_=mac_->macmib_.getCWMin();
  1059. mac_->bkmgr.handleBKStart(mac_->cw_);
  1060. checkQueue();
  1061. } else {
  1062. cout<<"logic error at TXC handling ACKIndication"<<endl;
  1063. cout<<txc_state_<<endl;
  1064. }
  1066. }
  1068. void TXC::setTXCState(TXCState newstate) {
  1069. if (mac_->MAC_DBG) {
  1070. char msg [1000];
  1071. sprintf(msg, "%d -> %d", txc_state_, newstate);
  1072. if (mac_->MAC_DBG)
  1073. mac_->log("TXCState", msg);
  1074. }
  1075. txc_state_=newstate;
  1077. }
  1079. //-------tx coordination-------//
  1081. //-------rx coordination-------//
  1083. void RXC_SIFSTimer::expire(Event *e) {
  1084. rxc_->handleSIFStimeout();
  1085. }
  1087. RXC::RXC(Mac802_11Ext *m) :
  1088. rxcSIFSTimer_(this) {
  1089. mac_=m;
  1090. pCTRL=0;
  1091. rxc_state_=RXC_Idle;
  1092. }
  1094. void RXC::handleMsgFromBelow(Packet *p) {
  1095. hdr_mac802_11* mh = HDR_MAC802_11(p);
  1096. switch (mh->dh_fc.fc_type) {
  1098. case MAC_Type_Control:
  1099. switch (mh->dh_fc.fc_subtype) {
  1100. case MAC_Subtype_ACK:
  1101. if (mac_->MAC_DBG)
  1102. mac_->log("RXC", "msgFromBelow: ACK");
  1103. mac_->txc.handleACKIndication();
  1104. mac_->mac_log(p);
  1105. setRXCState(RXC_Idle);
  1106. break;
  1108. case MAC_Subtype_RTS:
  1109. if (mac_->MAC_DBG)
  1110. mac_->log("RXC", "msgFromBelow: RTS");
  1111. if (mac_->csmgr.getChannelState()==CSNAV
  1112. || mac_->csmgr.getChannelState()==noCSNAV) {
  1113. setRXCState(RXC_Idle);
  1114. mac_->mac_log(p);
  1115. } else {
  1116. generateCTSFrame(p);
  1117. mac_->mac_log(p);
  1118. rxcSIFSTimer_.sched(mac_->macmib_.getSIFS());
  1119. setRXCState(RXC_wait_SIFS);
  1120. }
  1121. break;
  1122. case MAC_Subtype_CTS:
  1123. if (mac_->MAC_DBG)
  1124. mac_->log("RXC", "msgFromBelow: CTS");
  1125. mac_->txc.handleCTSIndication();
  1126. mac_->mac_log(p);
  1127. setRXCState(RXC_Idle);
  1128. break;
  1129. default:
  1130. //
  1131. ;
  1132. }
  1133. break;
  1135. case MAC_Type_Data:
  1136. if (mac_->MAC_DBG)
  1137. mac_->log("RXC", "msgFromBelow: DATA");
  1138. switch (mh->dh_fc.fc_subtype) {
  1139. case MAC_Subtype_Data:
  1140. if ((u_int32_t)ETHER_ADDR(mh->dh_ra) == (u_int32_t)(mac_->index_)) {
  1141. generateACKFrame(p);
  1142. rxcSIFSTimer_.sched(mac_->macmib_.getSIFS());
  1143. mac_->recvDATA(p);
  1144. setRXCState(RXC_wait_SIFS);
  1145. } else {
  1146. mac_->recvDATA(p);
  1147. setRXCState(RXC_Idle);
  1148. }
  1149. break;
  1150. default:
  1151. cout<<"unkown mac data type"<<endl;
  1152. }
  1153. break;
  1154. default:
  1155. cout<<"logic error at handleincomingframe"<<endl;
  1156. }
  1157. }
  1159. void RXC::handleSIFStimeout() {
  1160. if (mac_->MAC_DBG)
  1161. mac_->log("RXC", "SIFS finished");
  1162. if (pCTRL != 0) {
  1163. mac_->transmit(pCTRL, Callback_RXC);
  1164. }
  1165. setRXCState(RXC_wait_sent);
  1166. }
  1168. void RXC::handleTXConfirm() {
  1169. Packet::free(pCTRL);
  1170. pCTRL = 0;
  1171. setRXCState(RXC_Idle);
  1172. }
  1174. void RXC::generateACKFrame(Packet *p) {
  1175. Packet *ack = Packet::alloc();
  1176. hdr_cmn* ch = HDR_CMN(ack);
  1177. struct ack_frame *af = (struct ack_frame*)ack->access(hdr_mac::offset_);
  1178. struct hdr_mac802_11 *dh = HDR_MAC802_11(p);
  1180. ch->uid() = 0;
  1181. ch->ptype() = PT_MAC;
  1182. ch->size() = mac_->phymib_.getACKlen();
  1183. ch->iface() = -2;
  1184. ch->error() = 0;
  1185. bzero(af, MAC_HDR_LEN);
  1187. af->af_fc.fc_protocol_version = MAC_ProtocolVersion;
  1188. af->af_fc.fc_type = MAC_Type_Control;
  1189. af->af_fc.fc_subtype = MAC_Subtype_ACK;
  1190. af->af_fc.fc_to_ds = 0;
  1191. af->af_fc.fc_from_ds = 0;
  1192. af->af_fc.fc_more_frag = 0;
  1193. af->af_fc.fc_retry = 0;
  1194. af->af_fc.fc_pwr_mgt = 0;
  1195. af->af_fc.fc_more_data = 0;
  1196. af->af_fc.fc_wep = 0;
  1197. af->af_fc.fc_order = 0;
  1199. u_int32_t dst = ETHER_ADDR(dh->dh_ta);
  1200. STORE4BYTE(&dst, (af->af_ra));
  1201. ch->txtime() = mac_->txtime(ch->size(),
  1202. mac_->phymib_.getBasicModulationScheme());
  1203. af->af_duration = 0;
  1204. pCTRL = ack;
  1205. }
  1207. void RXC::generateCTSFrame(Packet *p) {
  1208. Packet *cts = Packet::alloc();
  1209. hdr_cmn* ch = HDR_CMN(cts);
  1210. struct rts_frame *rf = (struct rts_frame*)p->access(hdr_mac::offset_);
  1211. struct cts_frame *cf = (struct cts_frame*)cts->access(hdr_mac::offset_);
  1212. ch->uid() = 0;
  1213. ch->ptype() = PT_MAC;
  1214. ch->size() = mac_->phymib_.getCTSlen();
  1215. ch->iface() = -2;
  1216. ch->error() = 0;
  1217. ch->mod_scheme_= (ModulationScheme)mac_->phymib_.getBasicModulationScheme();
  1218. bzero(cf, MAC_HDR_LEN);
  1220. cf->cf_fc.fc_protocol_version = MAC_ProtocolVersion;
  1221. cf->cf_fc.fc_type = MAC_Type_Control;
  1222. cf->cf_fc.fc_subtype = MAC_Subtype_CTS;
  1223. cf->cf_fc.fc_to_ds = 0;
  1224. cf->cf_fc.fc_from_ds = 0;
  1225. cf->cf_fc.fc_more_frag = 0;
  1226. cf->cf_fc.fc_retry = 0;
  1227. cf->cf_fc.fc_pwr_mgt = 0;
  1228. cf->cf_fc.fc_more_data = 0;
  1229. cf->cf_fc.fc_wep = 0;
  1230. cf->cf_fc.fc_order = 0;
  1232. u_int32_t dst = ETHER_ADDR(rf->rf_ta);
  1233. STORE4BYTE(&dst, (cf->cf_ra));
  1234. ch->txtime() = mac_->txtime(ch->size(),
  1235. mac_->phymib_.getBasicModulationScheme());
  1236. cf->cf_duration = mac_->usec(mac_->sec(rf->rf_duration)
  1237. - mac_->macmib_.getSIFS()- mac_->txtime(mac_->phymib_.getCTSlen(),
  1238. mac_->phymib_.getBasicModulationScheme()));
  1239. pCTRL = cts;
  1240. }
  1242. void RXC::setRXCState(RXCState newstate) {
  1243. if (mac_->MAC_DBG) {
  1244. char msg [1000];
  1245. sprintf(msg, "%d -> %d", rxc_state_, newstate);
  1246. mac_->log("RXCState", msg);
  1247. }
  1248. rxc_state_=newstate;
  1249. }
  1251. //-------rx coordination-------//