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

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

通讯编程

开发平台：

Visual C++

mac-802_11mr.cc：源码内容
  1. /* -*- Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*-
  2.  *
  3.  * Copyright (c) 1997 Regents of the University of California.
  4.  * All rights reserved.
  5.  *
  6.  * Redistribution and use in source and binary forms, with or without
  7.  * modification, are permitted provided that the following conditions
  8.  * are met:
  9.  * 1. Redistributions of source code must retain the above copyright
  10.  *    notice, this list of conditions and the following disclaimer.
  11.  * 2. Redistributions in binary form must reproduce the above copyright
  12.  *    notice, this list of conditions and the following disclaimer in the
  13.  *    documentation and/or other materials provided with the distribution.
  14.  * 3. All advertising materials mentioning features or use of this software
  15.  *    must display the following acknowledgement:
  16.  * This product includes software developed by the Computer Systems
  17.  * Engineering Group at Lawrence Berkeley Laboratory.
  18.  * 4. Neither the name of the University nor of the Laboratory may be used
  19.  *    to endorse or promote products derived from this software without
  20.  *    specific prior written permission.
  21.  *
  22.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32.  * SUCH DAMAGE.
  33.  *
  34.  *
  35.  * Ported from CMU/Monarch's code, nov'98 -Padma.
  36.  * Contributions by:
  37.  *   - Mike Holland
  38.  *   - Sushmita
  39.  *
  40.  * Ported 2006 from ns-2.29 
  41.  * by Federico Maguolo, Nicola Baldo and Simone Merlin 
  42.  * (SIGNET lab, University of Padova, Department of Information Engineering)
  43.  *
  44.  */
  46. #include <delay.h>
  47. #include <connector.h>
  48. #include <packet.h>
  49. #include <random.h>
  50. #include <mobilenode.h>
  52. // // #define DEBUG 99
  54. #include <arp.h>
  55. #include <ll.h>
  56. #include <mac.h>
  57. #include <cmu-trace.h>
  59. // Added by Sushmita to support event tracing
  60. #include <agent.h>
  61. #include <basetrace.h>
  62.  
  63. #include "mac-802_11mr.h"
  64. #include "mac-timersmr.h"
  68. PhyMode str2PhyMode(const char* str)
  69. {
  70. if (strcmp(str, "Mode1Mb") == 0) {
  71.   return Mode1Mb;
  72. } else if (strcmp(str, "Mode2Mb") == 0) {
  73.   return Mode2Mb;
  74. } else if (strcmp(str, "Mode5_5Mb") == 0) {
  75.   return Mode5_5Mb;
  76. } else if (strcmp(str, "Mode11Mb") == 0) {
  77.   return Mode11Mb;
  78. } else if (strcmp(str, "Mode6Mb") == 0) {
  79.   return Mode6Mb;
  80. } else if (strcmp(str, "Mode9Mb") == 0) {
  81.   return Mode9Mb;
  82. } else if (strcmp(str, "Mode12Mb") == 0) {
  83.   return Mode12Mb;
  84. } else if (strcmp(str, "Mode18Mb") == 0) {
  85.   return Mode18Mb;
  86. } else if (strcmp(str, "Mode24Mb") == 0) {
  87.   return Mode24Mb;
  88. } else if (strcmp(str, "Mode36Mb") == 0) {
  89.   return Mode36Mb;
  90. } else if (strcmp(str, "Mode48Mb") == 0) {
  91.   return Mode48Mb;
  92. } else if (strcmp(str, "Mode54Mb") == 0) {
  93.   return Mode54Mb;
  94. } else  return ModeUnknown;
  95. }
  98. static char* PhyModeStr[NumPhyModes]={"Mode1Mb",
  99.       "Mode2Mb",
  100.       "Mode5_5Mb",
  101.       "Mode11Mb",
  102.       "Mode6Mb",
  103.       "Mode9Mb",
  104.       "Mode12Mb",
  105.       "Mode18Mb",
  106.       "Mode24Mb",
  107.       "Mode36Mb",
  108.       "Mode48Mb",
  109.       "Mode54Mb"};
  111. const char* PhyMode2str(PhyMode pm)
  112. {
  113. if (pm == ModeUnknown)
  114. return "ModeUnknown";
  115. else
  116. return PhyModeStr[pm];
  117. }
  120. /* ======================================================================
  121.    Mac  and Phy MIB Class Functions
  122.    ====================================================================== */
  124. MR_PHY_MIB::MR_PHY_MIB(Mac802_11mr *parent) 
  125. : snr_AP(1000),
  126.   AckMode_AP(Mode1Mb)
  127. {
  128. /*
  129.  * Bind the phy mib objects.  Note that these will be bound
  130.  * to Mac/802_11 variables
  131.  */
  133. parent->bind("CWMin_", &CWMin);
  134. parent->bind("CWMax_", &CWMax);
  135. parent->bind("SlotTime_", &SlotTime);
  136. parent->bind("SIFS_", &SIFSTime);
  137. parent->bind_bool("useShortPreamble_",&useShortPreamble);
  138. parent->bind("bSyncInterval_",&bSyncInterval);
  139. parent->bind("gSyncInterval_",&gSyncInterval);
  140. }
  143. void MR_PHY_MIB::setAPSnr(double snr)
  144. {
  145. snr_AP =  snr;
  146. }
  149. double MR_PHY_MIB::getAPSnr()
  150. {
  151. return snr_AP;
  152. }
  155. MR_MAC_MIB::MR_MAC_MIB() :
  156. MPDUTxSuccessful(0),MPDUTxOneRetry(0),MPDUTxMultipleRetries(0),
  157. MPDUTxFailed(0), RTSFailed(0), ACKFailed(0), 
  158. MPDURxSuccessful(0), FrameReceives(0),  DataFrameReceives(0), CtrlFrameReceives(0), MgmtFrameReceives(0),
  159. FrameErrors(0), DataFrameErrors(0), CtrlFrameErrors(0), MgmtFrameErrors(0),
  160. FrameErrorsNoise(0), DataFrameErrorsNoise(0), CtrlFrameErrorsNoise(0), MgmtFrameErrorsNoise(0),
  161. FrameDropSyn(0), DataFrameDropSyn(0), CtrlFrameDropSyn(0), MgmtFrameDropSyn(0),
  162. FrameDropTxa(0), DataFrameDropTxa(0), CtrlFrameDropTxa(0), MgmtFrameDropTxa(0),
  163. idleSlots(0), idle2Slots(0),
  164. VerboseCounters_(0)
  165. {
  166. }
  168. /* !!!WARNING!!!  remember that MR_MAC_MIB has TWO constructors when changing base initializers */
  170. MR_MAC_MIB::MR_MAC_MIB(Mac802_11mr *parent) :
  171. MPDUTxSuccessful(0),MPDUTxOneRetry(0),MPDUTxMultipleRetries(0),
  172. MPDUTxFailed(0), RTSFailed(0), ACKFailed(0), 
  173. MPDURxSuccessful(0), FrameReceives(0),  DataFrameReceives(0), CtrlFrameReceives(0), MgmtFrameReceives(0),
  174. FrameErrors(0), DataFrameErrors(0), CtrlFrameErrors(0), MgmtFrameErrors(0),
  175. FrameErrorsNoise(0), DataFrameErrorsNoise(0), CtrlFrameErrorsNoise(0), MgmtFrameErrorsNoise(0),
  176. FrameDropSyn(0), DataFrameDropSyn(0), CtrlFrameDropSyn(0), MgmtFrameDropSyn(0),
  177. FrameDropTxa(0), DataFrameDropTxa(0), CtrlFrameDropTxa(0), MgmtFrameDropTxa(0),
  178. idleSlots(0), idle2Slots(0),
  179. VerboseCounters_(0)
  180. {
  181. /*
  182.  * Bind the phy mib objects.  Note that these will be bound
  183.  * to Mac/802_11 variables
  184.  */
  186. parent->bind("RTSThreshold_", &RTSThreshold);
  187. parent->bind("ShortRetryLimit_", &ShortRetryLimit);
  188. parent->bind("LongRetryLimit_", &LongRetryLimit);
  189. parent->bind("VerboseCounters_", &VerboseCounters_);
  190. }
  193. void MR_MAC_MIB::printCounters(int index)
  194. {
  195. fflush(stdout);
  197. char str[300];
  198. counters2string(str,300);
  200. fprintf(stdout,
  201. "nMAC counters node %d at %2.9f t%s",
  202. index, Scheduler::instance().clock(),str);
  204. fflush(stdout);
  206. }
  209. char* MR_MAC_MIB::counters2string(char* str, int size) 
  210. {
  211. // Output conforming to plotlog.m 
  212. //  snprintf(str,size,"t%d t%d t%d t%d t%d t%d t%d t%d t%d t%d t%d t%d t%d t%d t%d t%d t%d t%d",
  213. //  MPDUTxSuccessful,MPDUTxOneRetry,MPDUTxMultipleRetries,MPDUTxFailed,
  214. //  MPDURxSuccessful, 0, 0, RTSFailed, ACKFailed, 
  215. //  FrameReceives, FrameErrors, 0, 0, idleSlots, 0, 0, 0, idle2Slots);
  218. char* formatstr;
  220. if (VerboseCounters_)
  221. formatstr=" TxSucc %5d %5d %5d  TxFail %5d %5d %5d  RXSucc %5d %5d %5d %5d %5d  RXFail %5d %5d %5d %5d  RXFailNoise %5d %5d %5d %5d  SYN %5d %5d %5d %5d  TXA %5d %5d %5d %5d  IdleSlost %8d %8d";
  222. else
  223. formatstr="%5d %5d %5d   %5d %5d %5d   %5d %5d %5d %5d %5d   %5d %5d %5d %5d   %5d %5d %5d %5d   %5d %5d %5d %5d   %5d %5d %5d %5d   %8d %8d";
  224.        
  225. snprintf(str,size,formatstr,
  226.  /* TX Succ */    MPDUTxSuccessful,MPDUTxOneRetry,MPDUTxMultipleRetries,  
  227.  /* TX Fail */    MPDUTxFailed, RTSFailed, ACKFailed, 
  228.  /* RX Succ */     MPDURxSuccessful, FrameReceives, DataFrameReceives, CtrlFrameReceives, MgmtFrameReceives,
  229. /* RX Fail Tot */  FrameErrors, DataFrameErrors, CtrlFrameErrors, MgmtFrameErrors,
  230. /* RX Fail Noise*/ FrameErrorsNoise, DataFrameErrorsNoise, CtrlFrameErrorsNoise, MgmtFrameErrorsNoise,
  231. /* NRX SYN */    FrameDropSyn, DataFrameDropSyn, CtrlFrameDropSyn, MgmtFrameDropSyn,  
  232. /* NRX TXA */    FrameDropTxa, DataFrameDropTxa, CtrlFrameDropTxa, MgmtFrameDropTxa,  
  233. /* old, wrong  */  idleSlots, 
  234. /* new, correct */ idle2Slots);
  236. str[size-1]='';
  237. return str;
  238. }
  241. double MR_MAC_MIB::getPerr()
  242. {
  243. if (DataFrameErrors == 0)
  244. return 0;
  245. else
  246. return ((double)DataFrameErrorsNoise/(double)DataFrameErrors);
  247. }
  250. double MR_MAC_MIB::getPcoll()
  251. {
  252. if (DataFrameErrors == 0)
  253. return 0;
  254. else
  255. return ((double)(DataFrameErrors - DataFrameErrorsNoise)
  256. / (double) DataFrameErrors);
  257. }
  260. void
  261. Mac802_11mr::checkBackoffTimer()
  262. {
  263. if(is_idle() && mhBackoff_.paused())
  264. mhBackoff_.resume(phymib_.getDIFS());
  265. if(! is_idle() && mhBackoff_.busy() && ! mhBackoff_.paused())
  266. mhBackoff_.pause();
  267. }
  269. void
  270. Mac802_11mr::transmit(Packet *p, double timeout)
  271. {
  272. tx_active_ = 1;
  274. if (EOTtarget_) {
  275. assert (eotPacket_ == NULL);
  276. eotPacket_ = p->copy();
  277. }
  279. /*
  280.  * If I'm transmitting without doing CS, such as when
  281.  * sending an ACK, any incoming packet will be "missed"
  282.  * and hence, must be discarded.
  283.  */
  284. if(rx_state_ != MAC_IDLE) {
  285. //assert(dh->dh_fc.fc_type == MAC_Type_Control);
  286. //assert(dh->dh_fc.fc_subtype == MAC_Subtype_ACK);
  287. assert(pktRx_);
  288. struct hdr_cmn *ch = HDR_CMN(pktRx_);
  289. ch->error() = 1;        /* force packet discard */
  290. }
  292. // This is the minimum time we must wait before attempting another TX
  293. updateIdleTime(txtime(p) + phymib_.getDIFS() + phymib_.getSlotTime());
  296. /*
  297.  * If this is not a broadcast packet, we expect an ACK,
  298.  * so we cannot TX before an EIFS. We do a weak update since 
  299.  * we don't know the actual rate that the receiver will use 
  300.  * for the ACK, but eventually we want to be able to reduce 
  301.  * this waiting time if we actually receive a shorter ACK.
  302.  * See 802.11-1999, sec. 9.2.3.4
  303.  */
  304. hdr_mac802_11 *mh = HDR_MAC802_11(p);
  305. u_int32_t dst = ETHER_ADDR(mh->dh_ra);
  306. if(dst != (u_int32_t)MAC_BROADCAST) {
  307. updateIdleTime(txtime(p) + phymib_.getEIFS() + phymib_.getSlotTime(), UIT_WEAK);
  308. }
  312. /*
  313.  * pass the packet on the "interface" which will in turn
  314.  * place the packet on the channel.
  315.  *
  316.  * NOTE: a handler is passed along so that the Network
  317.  *       Interface can distinguish between incoming and
  318.  *       outgoing packets.
  319.  */
  320. downtarget_->recv(p->copy(), this);
  321. mhSend_.start(timeout); 
  322. mhIF_.start(txtime(p));
  323. }
  324. void
  325. Mac802_11mr::setRxState(DEI_MacState newState)
  326. {
  330. if (!is_idle() && newState==MAC_IDLE){
  331. macmib_.startIdleTime=Scheduler::instance().clock();
  332. // printf("start idle %f n", startIdleTime);
  333. }
  334. if (is_idle() && newState!=MAC_IDLE){
  335. //macmib_.idleSlots+=int ((Scheduler::instance().clock()-macmib_.startIdleTime)/phymib_.getSlotTime());
  336. incidleSlots(int ((Scheduler::instance().clock()-macmib_.startIdleTime)/phymib_.getSlotTime())); 
  337. // printf("end idle %f n", Scheduler::instance().clock()-startIdleTime);
  338. }
  340. rx_state_ = newState;
  341. if(debug_) printf("%f - %i --- setRxState - change RX state to %i (MAC_IDLE=%i MAC_RECV=%i MAC_COLL=%i)n",Scheduler::instance().clock(), index_, newState,MAC_IDLE,MAC_RECV,MAC_COLL);
  342. checkBackoffTimer();
  343. }
  345. void
  346. Mac802_11mr::setTxState(DEI_MacState newState)
  347. {
  350. if (!is_idle() && newState==MAC_IDLE){
  351. macmib_.startIdleTime=Scheduler::instance().clock();
  352. // printf("start idle %f n", startIdleTime);
  353. }
  354. if (is_idle() && newState!=MAC_IDLE){
  355. //macmib_.idleSlots+=int ((Scheduler::instance().clock()-macmib_.startIdleTime)/phymib_.getSlotTime());
  356. incidleSlots( int ((Scheduler::instance().clock()-macmib_.startIdleTime)/phymib_.getSlotTime()));
  357. //printf("end idle %f n", Scheduler::instance().clock()-startIdleTime);
  358. //printf("slot time %fn", phymib_.getSlotTime());
  359. //fprintf(stdout, "slots %d",idleSlots );
  360. }
  362. tx_state_ = newState;
  363. if(debug_) printf("%f - %i --- setTxState - change TX state to %i (MAC_IDLE=%i MAC_SEND=%i)n",Scheduler::instance().clock(), index_, newState,MAC_IDLE,MAC_SEND);
  364. checkBackoffTimer();
  365. }
  367. /* ======================================================================
  368.    TCL Hooks for the simulator
  369.    ====================================================================== */
  370. static class Mac802_11mrClass : public TclClass {
  371. public:
  372. Mac802_11mrClass() : TclClass("Mac/802_11/Multirate") {}
  373. TclObject* create(int, const char*const*) {
  374. return (new Mac802_11mr());
  375. }
  376. } class_mac802_11mr;
  378. // void Mac802_11mr::bindPhyMode(const char* var, PhyMode* val)
  379. // {
  380. //  create_instvar(var);
  381. //  init(new InstVarPhyMode(var, val), var);
  382. // }
  387. Mac802_11mr::Mac802_11mr() : 
  388. Mac(), phymib_(this), macmib_(this), mhIF_(this), mhNav_(this), 
  389. mhRecv_(this), mhSend_(this), 
  390. mhDefer_(this), mhBackoff_(this),
  391. profile_(0), per_(0), mehlist_(0), peerstatsdb_(0)
  392. {
  394. nav_ = 0.0;
  395. tx_state_ = rx_state_ = MAC_IDLE;
  396. macmib_.startIdleTime=Scheduler::instance().clock();
  397. tx_active_ = 0;
  398. eotPacket_ = NULL;
  399. pktRTS_ = 0;
  400. pktCTRL_ = 0;
  401. cw_ = phymib_.getCWMin();
  402. ssrc_ = slrc_ = 0;
  403. // Added by Sushmita
  404.         et_ = new EventTrace();
  406. sta_seqno_ = 1;
  407. cache_ = 0;
  408. cache_node_count_ = 0;
  410. // chk if basic/data rates are set
  411. // otherwise use bandwidth_ as default;
  412. /* bindPhyMode("basicMode_", &basicMode_);
  413. bindPhyMode("dataMode_", &dataMode_);*/
  414. //  Tcl& tcl = Tcl::instance();
  415. //  tcl.evalf("Mac/802_11/Multirate set basicRate_");
  416. //  if (strcmp(tcl.result(), "0") != 0) 
  417. //  bind_bw("basicRate_", &basicRate_);
  418. //  else
  419. //  basicRate_ = bandwidth_;
  420. // 
  421. //  tcl.evalf("Mac/802_11/Multirate set dataRate_");
  422. //  if (strcmp(tcl.result(), "0") != 0) 
  423. //  bind_bw("dataRate_", &dataRate_);
  424. //  else
  425. //  dataRate_ = bandwidth_;
  427.         EOTtarget_ = 0;
  428.         bss_id_ = IBSS_ID;
  429. //printf("bssid in constructor %dn",bss_id_);
  430. }
  433. int
  434. Mac802_11mr::command(int argc, const char*const* argv)
  435. {
  436.   Tcl& tcl = Tcl::instance();
  437. if (argc == 2) {
  438. if(strcasecmp(argv[1], "printMacCounters") == 0) {
  439. printMacCounters();
  440. return (TCL_OK);
  441.                 }else 
  442. if(strcasecmp(argv[1], "getMacCounters") == 0) {
  443. char str[300];
  444. tcl.resultf("%s",macmib_.counters2string(str,300));
  445. return (TCL_OK);
  446.                 }else 
  447. if(strcasecmp(argv[1], "printOPTCounters") == 0) {
  448. // Not supported any more!!!
  449. // nse_->print();
  450. // return (TCL_OK);
  451. return (TCL_ERROR);
  452.                 }else 
  453. if(strcasecmp(argv[1], "resetIdleSlots") == 0) {
  454. macmib_.idleSlots=0;
  455. macmib_.idle2Slots=0;
  456. return (TCL_OK);
  457.                 }else 
  458. if (strcasecmp(argv[1], "getAPSnr") == 0) {
  459. tcl.resultf("%6.3f", phymib_.getAPSnr());
  460. return TCL_OK;
  461. }
  462.  
  463. }else if (argc == 3) {
  464. if (strcasecmp(argv[1], "eot-target") == 0) {
  465. EOTtarget_ = dynamic_cast<NsObject*> (TclObject::lookup(argv[2]));
  466. if (EOTtarget_ == 0)
  467. return TCL_ERROR;
  468. return TCL_OK;
  469. } else  if (strcasecmp(argv[1], "powerProfile") == 0) {
  470. profile_ = dynamic_cast<PowerProfile*> (TclObject::lookup(argv[2]));
  471. if (profile_ == 0)
  472. return TCL_ERROR;
  473. return TCL_OK;
  474. } else  if (strcasecmp(argv[1], "per") == 0) {
  475.            per_ = dynamic_cast<PER *> (TclObject::lookup(argv[2]));
  476. if (per_ == 0)
  477. return TCL_ERROR;
  478. return TCL_OK;
  479. } else  if (strcasecmp(argv[1], "PeerStatsDB") == 0) {
  480. peerstatsdb_ = dynamic_cast<PeerStatsDB *> (TclObject::lookup(argv[2]));
  481. if (peerstatsdb_ == 0)
  482. return TCL_ERROR;
  483. return TCL_OK;
  484. } else if (strcasecmp(argv[1], "bss_id") == 0) {
  485. bss_id_ = atoi(argv[2]);
  486. return TCL_OK;
  487. } else if (strcasecmp(argv[1], "log-target") == 0) { 
  488. logtarget_ = dynamic_cast<NsObject*> (TclObject::lookup(argv[2]));
  489. if(logtarget_ == 0)
  490. return TCL_ERROR;
  491. return TCL_OK;
  492. } else if(strcasecmp(argv[1], "nodes") == 0) {
  493. if(cache_) return TCL_ERROR;
  494. cache_node_count_ = atoi(argv[2]);
  495. cache_ = new Host[cache_node_count_ + 1];
  496. assert(cache_);
  497. bzero(cache_, sizeof(Host) * (cache_node_count_+1 ));
  498. return TCL_OK;
  499. } else if(strcasecmp(argv[1], "eventtrace") == 0) {
  500. // command added to support event tracing by Sushmita
  501.                         et_ = (EventTrace *)TclObject::lookup(argv[2]);
  502.                         return (TCL_OK);
  503. } else if(strcasecmp(argv[1], "dataMode_") == 0) {
  504. dataMode_ = str2PhyMode(argv[2]);
  505. if (dataMode_ == ModeUnknown)
  506. return(TCL_ERROR);
  507. return (TCL_OK);
  508.                 } else if(strcasecmp(argv[1], "basicMode_") == 0) {
  509. basicMode_ = str2PhyMode(argv[2]);
  510. if (basicMode_ == ModeUnknown)
  511. return(TCL_ERROR);
  512. return (TCL_OK);
  513.                 } else if (strcasecmp(argv[1], "eventhandler") == 0) {
  514. addMEH(TclObject::lookup(argv[2]));
  515. return TCL_OK;
  517. } else if (strcasecmp(argv[1], "getSnr") == 0) {
  518. u_int32_t addr = atoi(argv[2]);
  519. tcl.resultf("%6.3f", getSnr(addr));
  520. return TCL_OK;
  521. }
  522. }
  523. return Mac::command(argc, argv);
  524. }
  528. void Mac802_11mr::addMEH(TclObject* tclobjptr) 
  529. {
  530. Mac80211EventHandler* mehptr;
  531. mehptr = dynamic_cast<Mac80211EventHandler*> (tclobjptr);
  532. if (mehptr == 0)  {
  533. cerr << "Mac802_11mr::addMEH() ERROR: dynamic cast failed!!!" << endl;
  534. exit(1);
  535. }       
  536. addMEH(mehptr);
  537. }
  541. void Mac802_11mr::addMEH(Mac80211EventHandler* mehptr) 
  542. {
  543. if (mehlist_ == 0) {
  544. mehlist_ = mehptr;
  545. } else {
  546. Mac80211EventHandler* curr = mehlist_;
  547. while (curr->next)
  548. curr = curr->next;
  549. curr->next = mehptr;
  550. }
  551. }
  555. // Added by Sushmita to support event tracing
  556. void Mac802_11mr::trace_event(char *eventtype, Packet *p) 
  557. {
  558.         if (et_ == NULL) return;
  559.         char *wrk = et_->buffer();
  560.         char *nwrk = et_->nbuffer();
  562.         //char *src_nodeaddr =
  563. //       Address::instance().print_nodeaddr(iph->saddr());
  564.         //char *dst_nodeaddr =
  565.         //      Address::instance().print_nodeaddr(iph->daddr());
  567.         struct hdr_mac802_11* dh = HDR_MAC802_11(p);
  569.         //struct hdr_cmn *ch = HDR_CMN(p);
  571. if(wrk != 0) {
  572. sprintf(wrk, "E -t "TIME_FORMAT" %s %2x ",
  573. et_->round(Scheduler::instance().clock()),
  574.                         eventtype,
  575.                         //ETHER_ADDR(dh->dh_sa)
  576.                         ETHER_ADDR(dh->dh_ta)
  577.                         );
  578.         }
  579.         if(nwrk != 0) {
  580.                 sprintf(nwrk, "E -t "TIME_FORMAT" %s %2x ",
  581.                         et_->round(Scheduler::instance().clock()),
  582.                         eventtype,
  583.                         //ETHER_ADDR(dh->dh_sa)
  584.                         ETHER_ADDR(dh->dh_ta)
  585.                         );
  586.         }
  587.         et_->dump();
  588. }
  590. void Mac802_11mr::printMacCounters(void) 
  591. {
  593. if (is_idle()){
  595. //macmib_.idleSlots+=int ((Scheduler::instance().clock()-macmib_.startIdleTime)/phymib_.getSlotTime());
  596. incidleSlots( int ((Scheduler::instance().clock()-macmib_.startIdleTime)/phymib_.getSlotTime()));
  597. macmib_.startIdleTime=Scheduler::instance().clock();
  598. }
  600. macmib_.printCounters(index_);
  602. printf("%d n", dataMode_);
  603. }
  607. /* ======================================================================
  608.    Debugging Routines
  609.    ====================================================================== */
  610. void
  611. Mac802_11mr::trace_pkt(Packet *p) 
  612. {
  613. struct hdr_cmn *ch = HDR_CMN(p);
  614. struct hdr_mac802_11* dh = HDR_MAC802_11(p);
  615. u_int16_t *t = (u_int16_t*) &dh->dh_fc;
  617. fprintf(stderr, "t[ %2x %2x %2x %2x ] %x %s %dn",
  618. *t, dh->dh_duration,
  619.  ETHER_ADDR(dh->dh_ra), ETHER_ADDR(dh->dh_ta),
  620. index_, packet_info.name(ch->ptype()), ch->size());
  621. }
  623. void
  624. Mac802_11mr::dump(char *fname)
  625. {
  626. fprintf(stderr,
  627. "n%s --- (INDEX: %d, time: %2.9f)n",
  628. fname, index_, Scheduler::instance().clock());
  630. fprintf(stderr,
  631. "ttx_state_: %x, rx_state_: %x, nav: %2.9f, idle: %dn",
  632. tx_state_, rx_state_, nav_, is_idle());
  634. fprintf(stderr,
  635. "tpktTx_: %lx, pktRx_: %lx, pktRTS_: %lx, pktCTRL_: %lx, callback: %lxn",
  636. (long) pktTx_, (long) pktRx_, (long) pktRTS_,
  637. (long) pktCTRL_, (long) callback_);
  639. fprintf(stderr,
  640. "tDefer: %d, Backoff: %d (%d), Recv: %d, Timer: %d Nav: %dn",
  641. mhDefer_.busy(), mhBackoff_.busy(), mhBackoff_.paused(),
  642. mhRecv_.busy(), mhSend_.busy(), mhNav_.busy());
  643. fprintf(stderr,
  644. "tBackoff Expire: %fn",
  645. mhBackoff_.expire());
  646. }
  649. /* ======================================================================
  650.    Packet Headers Routines
  651.    ====================================================================== */
  652. int
  653. Mac802_11mr::hdr_dst(char* hdr, int dst )
  654. {
  655. struct hdr_mac802_11 *dh = (struct hdr_mac802_11*) hdr;
  657. if(debug_ > 2) printf("%f - %i --- hdr_dst - mark the destination address to %in",Scheduler::instance().clock(), index_, dst);
  658.        if (dst > -2) {
  659.                if ((bss_id() == ((int)IBSS_ID)) || (addr() == bss_id()) || dst == MAC_BROADCAST) {
  660.                        /* if I'm AP (2nd condition above!), the dh_3a
  661.                         * is already set by the MAC whilst fwding; if
  662.                         * locally originated pkt, it might make sense
  663.                         * to set the dh_3a to myself here! don't know
  664.                         * how to distinguish between the two here - and
  665.                         * the info is not critical to the dst station
  666.                         * anyway!
  667.                         */
  668.                        STORE4BYTE(&dst, (dh->dh_ra));
  669.                } else {
  670.                        /* in BSS mode, the AP forwards everything;
  671.                         * therefore, the real dest goes in the 3rd
  672.                         * address, and the AP address goes in the
  673.                         * destination address
  674.                         */
  675.                        STORE4BYTE(&bss_id_, (dh->dh_ra));
  676.                        STORE4BYTE(&dst, (dh->dh_3a));
  677.                }
  678.        }
  681.        return (u_int32_t)ETHER_ADDR(dh->dh_ra);
  682. }
  684. int 
  685. Mac802_11mr::hdr_src(char* hdr, int src )
  686. {
  687. struct hdr_mac802_11 *dh = (struct hdr_mac802_11*) hdr;
  688. if(debug_ > 2) printf("%f - %i --- hdr_dst - mark the source address to %in",Scheduler::instance().clock(), index_, src);
  689.         if(src > -2)
  690.                STORE4BYTE(&src, (dh->dh_ta));
  691.         return ETHER_ADDR(dh->dh_ta);
  692. }
  694. int 
  695. Mac802_11mr::hdr_type(char* hdr, u_int16_t type)
  696. {
  697. struct hdr_mac802_11 *dh = (struct hdr_mac802_11*) hdr;
  698. if(type)
  699. STORE2BYTE(&type,(dh->dh_body));
  700. return GET2BYTE(dh->dh_body);
  701. }
  704. /* ======================================================================
  705.    Misc Routines
  706.    ====================================================================== */
  707. int
  708. Mac802_11mr::is_idle()
  709. {
  710. if(rx_state_ != MAC_IDLE)
  711. return 0;
  712. if(tx_state_ != MAC_IDLE)
  713. return 0;
  714. if(nav_ > Scheduler::instance().clock())
  715. return 0;
  717. return 1;
  718. }
  720. void
  721. Mac802_11mr::discard(Packet *p, const char* why)
  722. {
  723. hdr_mac802_11* mh = HDR_MAC802_11(p);
  724. hdr_cmn *ch = HDR_CMN(p);
  726. /* if the rcvd pkt contains errors, a real MAC layer couldn't
  727.    necessarily read any data from it, so we just toss it now */
  728. if(ch->error() != 0) {
  729. Packet::free(p);
  730. return;
  731. }
  733. switch(mh->dh_fc.fc_type) {
  734. case MAC_Type_Management:
  735. drop(p, why);
  736. return;
  737. case MAC_Type_Control:
  738. switch(mh->dh_fc.fc_subtype) {
  739. case MAC_Subtype_RTS:
  740.  if((u_int32_t)ETHER_ADDR(mh->dh_ta) ==  (u_int32_t)index_) {
  741. drop(p, why);
  742. return;
  743. }
  744. /* fall through - if necessary */
  745. case MAC_Subtype_CTS:
  746. case MAC_Subtype_ACK:
  747. if((u_int32_t)ETHER_ADDR(mh->dh_ra) == (u_int32_t)index_) {
  748. drop(p, why);
  749. return;
  750. }
  751. break;
  752. default:
  753. fprintf(stderr, "invalid MAC Control subtypen");
  754. exit(1);
  755. }
  756. break;
  757. case MAC_Type_Data:
  758. switch(mh->dh_fc.fc_subtype) {
  759. case MAC_Subtype_Data:
  760. if((u_int32_t)ETHER_ADDR(mh->dh_ra) == 
  761.                            (u_int32_t)index_ ||
  762.                           (u_int32_t)ETHER_ADDR(mh->dh_ta) == 
  763.                            (u_int32_t)index_ ||
  764.                           (u_int32_t)ETHER_ADDR(mh->dh_ra) == MAC_BROADCAST) {
  765.                                 drop(p,why);
  766.                                 return;
  767. }
  768. break;
  769. default:
  770. fprintf(stderr, "invalid MAC Data subtypen");
  771. exit(1);
  772. }
  773. break;
  774. default:
  775. fprintf(stderr, "invalid MAC type (%x)n", mh->dh_fc.fc_type);
  776. trace_pkt(p);
  777. exit(1);
  778. }
  779. Packet::free(p);
  780. }
  782. // void
  783. // Mac802_11mr::capture(Packet *p)
  784. // {
  785. //  /*
  786. //   * Update the NAV so that this does not screw
  787. //   * up carrier sense.
  788. //   */
  789. //  set_nav(phymib_.getEIFS() + txtime(p));
  790. //  Packet::free(p);
  791. // }
  793. // void
  794. // Mac802_11mr::collision(Packet *p)
  795. // {
  796. //  switch(rx_state_) {
  797. //  case MAC_RECV:
  798. //  setRxState(MAC_COLL);
  799. //  /* fall through */
  800. //  case MAC_COLL:
  801. //  assert(pktRx_);
  802. //  assert(mhRecv_.busy());
  803. //  /*
  804. //   *  Since a collision has occurred, figure out
  805. //   *  which packet that caused the collision will
  806. //   *  "last" the longest.  Make this packet,
  807. //   *  pktRx_ and reset the Recv Timer if necessary.
  808. //   */
  809. //  if(txtime(p) > mhRecv_.expire()) {
  810. //  mhRecv_.stop();
  811. //  discard(pktRx_, DROP_MAC_COLLISION);
  812. //  pktRx_ = p;
  813. //  mhRecv_.start(txtime(pktRx_));
  814. //  }
  815. //  else {
  816. //  discard(p, DROP_MAC_COLLISION);
  817. //  }
  818. //  break;
  819. //  default:
  820. //  assert(0);
  821. //  }
  822. // }
  824. void
  825. Mac802_11mr::tx_resume()
  826. {
  827. double rTime;
  828. assert(mhSend_.busy() == 0);
  829. assert(mhDefer_.busy() == 0);
  831. if(pktCTRL_) {
  832. /*
  833.  *  Need to send a CTS or ACK.
  834.  */
  835. mhDefer_.start(phymib_.getSIFS());
  836. } else if(pktRTS_) {
  837. if (mhBackoff_.busy() == 0) {
  838. /* Modifica Federico 9/12/2004 */
  839. /*rTime = (Random::random() % cw_) * phymib_.getSlotTime();
  840. mhDefer_.start( phymib_.getDIFS() + rTime);*/
  841.        
  842. mhBackoff_.start(cw_, is_idle(), phymib_.getDIFS());
  843. /*
  844. Fine modifica Federico 9/12/2004
  845. */
  846. }
  847. } else if(pktTx_) {
  848. if (mhBackoff_.busy() == 0) {
  849. hdr_cmn *ch = HDR_CMN(pktTx_);
  850. struct hdr_mac802_11 *mh = HDR_MAC802_11(pktTx_);
  852. if ((u_int32_t) ch->size() < macmib_.getRTSThreshold()
  853.     || (u_int32_t) ETHER_ADDR(mh->dh_ra) == MAC_BROADCAST) {
  854. /* Modifica Federico 9/12/2004 */
  855. /*rTime = (Random::random() % cw_)
  856. * phymib_.getSlotTime();
  857. mhDefer_.start(phymib_.getDIFS() + rTime);*/
  858.        
  859.        
  860. mhBackoff_.start(cw_, is_idle(), phymib_.getDIFS());
  861.        
  862.        //Fine modifica Federico 9/12/2004
  863.                         } else {
  864. mhDefer_.start(phymib_.getSIFS());
  865.                         }
  866. }
  867. } else if(callback_) {
  868. Handler *h = callback_;
  869. callback_ = 0;
  870. h->handle((Event*) 0);
  871. }
  872. setTxState(MAC_IDLE);
  873. }
  875. void
  876. Mac802_11mr::rx_resume()
  877. {
  878. assert(pktRx_ == 0);
  879. assert(mhRecv_.busy() == 0);
  880. setRxState(MAC_IDLE);
  881. }
  884. /* ======================================================================
  885.    Timer Handler Routines
  886.    ====================================================================== */
  887. void
  888. Mac802_11mr::backoffHandler()
  889. {
  890. if(pktCTRL_) {
  891. assert(mhSend_.busy() || mhDefer_.busy());
  892. return;
  893. }
  895. if(check_pktRTS() == 0)
  896. return;
  898. if(check_pktTx() == 0)
  899. return;
  900. }
  902. void
  903. Mac802_11mr::deferHandler()
  904. {
  905. assert(pktCTRL_ || pktRTS_ || pktTx_);
  907. if(check_pktCTRL() == 0)
  908. return;
  909. assert(mhBackoff_.busy() == 0);
  910. if(check_pktRTS() == 0)
  911. return;
  912. if(check_pktTx() == 0)
  913. return;
  914. }
  916. void
  917. Mac802_11mr::navHandler()
  918. {
  919. if(is_idle() && mhBackoff_.paused())
  920. mhBackoff_.resume(phymib_.getDIFS());
  922. if (!is_idle() && tx_state_==MAC_IDLE && rx_state_==MAC_IDLE )
  923. macmib_.startIdleTime=Scheduler::instance().clock();
  926. }
  928. void
  929. Mac802_11mr::recvHandler()
  930. {
  931. recv_timer();
  932. }
  934. void
  935. Mac802_11mr::sendHandler()
  936. {
  937. send_timer();
  938. }
  941. void
  942. Mac802_11mr::txHandler()
  943. {
  944. if (EOTtarget_) {
  945. assert(eotPacket_);
  946. EOTtarget_->recv(eotPacket_, (Handler *) 0);
  947. eotPacket_ = NULL;
  948. }
  949. if(debug_) printf("%f - %i --- txHandler - end transmission of packetn",Scheduler::instance().clock(), index_);
  950. tx_active_ = 0;
  951. }
  954. /* ======================================================================
  955.    The "real" Timer Handler Routines
  956.    ====================================================================== */
  957. void
  958. Mac802_11mr::send_timer()
  959. {
  960. switch(tx_state_) {
  961. /*
  962.  * Sent a RTS, but did not receive a CTS.
  963.  */
  964. case MAC_RTS:
  965. RetransmitRTS();
  966. break;
  967. /*
  968.  * Sent a CTS, but did not receive a DATA packet.
  969.  */
  970. case MAC_CTS:
  971. assert(pktCTRL_);
  972. Packet::free(pktCTRL_); 
  973. pktCTRL_ = 0;
  974. break;
  975. /*
  976.  * Sent DATA, but did not receive an ACK packet.
  977.  */
  978. case MAC_SEND:
  979. if(debug_) printf("%f - %i --- send_timer - retransmit datan",Scheduler::instance().clock(), index_);
  980. RetransmitDATA();
  981. break;
  982. /*
  983.  * Sent an ACK, and now ready to resume transmission.
  984.  */
  985. case MAC_ACK:
  986. assert(pktCTRL_);
  987. Packet::free(pktCTRL_); 
  988. pktCTRL_ = 0;
  989. break;
  990. case MAC_IDLE:
  991. break;
  992. default:
  993. assert(0);
  994. }
  995. if(debug_) printf("%f - %i --- send_timer - call tx_resumen",Scheduler::instance().clock(), index_);
  996. tx_resume();
  997. }
  1000. /* ======================================================================
  1001.    Outgoing Packet Routines
  1002.    ====================================================================== */
  1003. int
  1004. Mac802_11mr::check_pktCTRL()
  1005. {
  1006. struct hdr_mac802_11 *mh;
  1007. double timeout;
  1009. if(pktCTRL_ == 0)
  1010. return -1;
  1011. if(tx_state_ == MAC_CTS || tx_state_ == MAC_ACK)
  1012. return -1;
  1014. mh = HDR_MAC802_11(pktCTRL_);
  1015.   
  1016. switch(mh->dh_fc.fc_subtype) {
  1017. /*
  1018.  *  If the medium is not IDLE, don't send the CTS.
  1019.  */
  1020. case MAC_Subtype_CTS:
  1021. if(!is_idle()) {
  1022. discard(pktCTRL_, DROP_MAC_BUSY); pktCTRL_ = 0;
  1023. return 0;
  1024. }
  1025. setTxState(MAC_CTS);
  1026. /*
  1027.  * timeout:  cts + data tx time calculated by
  1028.  *           adding cts tx time to the cts duration
  1029.  *           minus ack tx time -- this timeout is
  1030.  *           a guess since it is unspecified
  1031.  *           (note: mh->dh_duration == cf->cf_duration)
  1032.  */
  1033.  timeout = txtime(phymib_.getCTSlen(), basicMode_)
  1034.                         + DSSS_MaxPropagationDelay                      // XXX
  1035.                         + sec(mh->dh_duration)
  1036.                         + DSSS_MaxPropagationDelay                      // XXX
  1037.                        - phymib_.getSIFS()
  1038.                        - txtime(phymib_.getACKlen(), basicMode_);
  1039. break;
  1040. /*
  1041.  * IEEE 802.11 specs, section 9.2.8
  1042.  * Acknowledments are sent after an SIFS, without regard to
  1043.  * the busy/idle state of the medium.
  1044.  */
  1045. case MAC_Subtype_ACK:
  1046. if(debug_) printf("%f - %i --- check_pktCTRL - transmit ackn",Scheduler::instance().clock(), index_);
  1047. setTxState(MAC_ACK);
  1048. timeout = txtime(phymib_.getACKlen(), basicMode_);
  1049. break;
  1050. default:
  1051. fprintf(stderr, "check_pktCTRL:Invalid MAC Control subtypen");
  1052. exit(1);
  1053. }
  1054. transmit(pktCTRL_, timeout);
  1055. return 0;
  1056. }
  1058. int
  1059. Mac802_11mr::check_pktRTS()
  1060. {
  1061. struct hdr_mac802_11 *mh;
  1062. double timeout;
  1064. assert(mhBackoff_.busy() == 0);
  1066. if(pktRTS_ == 0)
  1067.   return -1;
  1068. mh = HDR_MAC802_11(pktRTS_);
  1070. /*
  1071. During the backoff stage the basicMode_ could be changed by the rate adaptation algorithm
  1072. */
  1073. hdr_cmn* ch = HDR_CMN(pktRTS_);
  1074. ch->txtime() = txtime(ch->size(), basicMode_);
  1075. MultiRateHdr *mrh = HDR_MULTIRATE(pktRTS_);
  1076. mrh->mode() = basicMode_;
  1077. struct rts_frame *rf = (struct rts_frame*)pktRTS_->access(hdr_mac::offset_);
  1078. rf->rf_duration = usec(phymib_.getSIFS()
  1079.        + txtime(phymib_.getCTSlen(), basicMode_)
  1080.        + phymib_.getSIFS()
  1081.                                + txtime(pktTx_)
  1082.        + phymib_.getSIFS()
  1083.        + txtime(phymib_.getACKlen(), basicMode_));
  1085.   switch(mh->dh_fc.fc_subtype) {
  1086. case MAC_Subtype_RTS:
  1087. if(! is_idle()) {
  1088. /*
  1089. This happens when we have a simultaneous packet tx and rx and the rx event is dispatched first!!!
  1090. */
  1091. inc_cw();
  1092. mhBackoff_.start(cw_, is_idle());
  1093. if (debug_) printf("MOOOOOOLTO STRANO!!! C'e' qualcosa che non quadra!!n");
  1094. return 0;
  1095. }
  1096. setTxState(MAC_RTS);
  1097. timeout = txtime(phymib_.getRTSlen(), basicMode_)
  1098. + DSSS_MaxPropagationDelay                      // XXX
  1099. + phymib_.getSIFS()
  1100. + txtime(phymib_.getCTSlen(), basicMode_)
  1101. + DSSS_MaxPropagationDelay; /* Should we add a DIFS here??? */
  1102. break;
  1103. default:
  1104. fprintf(stderr, "check_pktRTS:Invalid MAC Control subtypen");
  1105. exit(1);
  1106. }
  1108. Mac80211EventHandler* mehptr = mehlist_;
  1109. while(mehptr) {
  1110. mehptr->chBusy(ch->txtime() + rf->rf_duration * 1e-6);
  1111. mehptr = mehptr->next;
  1112. }
  1114. transmit(pktRTS_, timeout);
  1115.   
  1117. return 0;
  1118. }
  1120. int
  1121. Mac802_11mr::check_pktTx()
  1122. {
  1123. struct hdr_mac802_11 *mh;
  1124. double timeout;
  1126. assert(mhBackoff_.busy() == 0);
  1128. if(pktTx_ == 0)
  1129. return -1;
  1131. mh = HDR_MAC802_11(pktTx_);
  1132. /*
  1133. During the backoff stage the basicMode_ could be changed by the rate adaptation algorithm
  1134. */
  1135. hdr_cmn* ch = HDR_CMN(pktTx_);
  1136. ch->txtime() = txtime(ch->size(), dataMode_);
  1137. MultiRateHdr *mrh = HDR_MULTIRATE(pktTx_);
  1138. if((u_int32_t)ETHER_ADDR(mh->dh_ra) != MAC_BROADCAST) {
  1139. /* store data tx time for unicast packets */
  1140. mrh->mode() = dataMode_;
  1141. ch->txtime() = txtime(ch->size(), dataMode_);
  1142. mh->dh_duration = usec(txtime(phymib_.getACKlen(), basicMode_)
  1143.        + phymib_.getSIFS());
  1144. } else {
  1145. /* store data tx time for broadcast packets (see 9.6) */
  1146. mrh->mode() = basicMode_;
  1147. ch->txtime() = txtime(ch->size(), basicMode_);
  1148. mh->dh_duration = 0;
  1149. }
  1151. switch(mh->dh_fc.fc_subtype) {
  1152. case MAC_Subtype_Data:
  1153. if(! is_idle()) {
  1154. /*
  1155. This happens when we have a simultaneous packet tx and rx and the rx event is dispatched first!!!
  1156. */
  1157. sendRTS(ETHER_ADDR(mh->dh_ra));
  1158. inc_cw();
  1159. mhBackoff_.start(cw_, is_idle());
  1160. if(debug_) printf("(check_pktTx) MOOOOOOLTO STRANO!!! C'e' qualcosa che non quadra!!n");
  1161. return 0;
  1162. }
  1163. setTxState(MAC_SEND);
  1164. if((u_int32_t)ETHER_ADDR(mh->dh_ra) != MAC_BROADCAST)
  1165.                         timeout = txtime(pktTx_)
  1166.                                 + DSSS_MaxPropagationDelay              // XXX
  1167.                                + phymib_.getSIFS()
  1168.                                + txtime(phymib_.getACKlen(), basicMode_)
  1169.                                + DSSS_MaxPropagationDelay;             // XXX
  1170. else
  1171. timeout = txtime(pktTx_);
  1172. if(debug_) printf("%f - %i --- check_pktTx - Begin transmission of data (timeout=%f, mh->dh_ra=%i,MAC_BROADCAST=%i, pkttime=%f ack=%f)n",Scheduler::instance().clock(), index_,timeout, (u_int32_t)ETHER_ADDR(mh->dh_ra), MAC_BROADCAST, txtime(pktTx_), txtime(phymib_.getACKlen(), basicMode_));
  1173. break;
  1174. default:
  1175. fprintf(stderr, "check_pktTx:Invalid MAC Control subtypen");
  1176. exit(1);
  1177. }
  1179. // Why do we need this test?
  1180. if((u_int32_t) ch->size() < macmib_.getRTSThreshold()) {
  1181. Mac80211EventHandler* mehptr = mehlist_;
  1182. while(mehptr) {
  1183. mehptr->chBusy(ch->txtime() + mh->dh_duration * 1e-6);
  1184. mehptr = mehptr->next;
  1185. }
  1186. }
  1188. transmit(pktTx_, timeout);
  1189. return 0;
  1190. }
  1191. /*
  1192.  * Low-level transmit functions that actually place the packet onto
  1193.  * the channel.
  1194.  */
  1195. void
  1196. Mac802_11mr::sendRTS(int dst)
  1197. {
  1198. Packet *p = Packet::alloc();
  1199. hdr_cmn* ch = HDR_CMN(p);
  1200. MultiRateHdr *mrh = HDR_MULTIRATE(p);
  1201. struct rts_frame *rf = (struct rts_frame*)p->access(hdr_mac::offset_);
  1203. assert(pktTx_);
  1204. assert(pktRTS_ == 0);
  1206. /*
  1207.  *  If the size of the packet is larger than the
  1208.  *  RTSThreshold, then perform the RTS/CTS exchange.
  1209.  */
  1210. if( (u_int32_t) HDR_CMN(pktTx_)->size() < macmib_.getRTSThreshold() ||
  1211.             (u_int32_t) dst == MAC_BROADCAST) {
  1212. Packet::free(p);
  1213. return;
  1214. }
  1216. ch->uid() = 0;
  1217. ch->ptype() = PT_MAC;
  1218. ch->size() = phymib_.getRTSlen();
  1219. ch->iface() = -2;
  1220. ch->error() = 0;
  1222. bzero(rf, MAC_HDR_LEN);
  1224. rf->rf_fc.fc_protocol_version = MAC_ProtocolVersion;
  1225.   rf->rf_fc.fc_type = MAC_Type_Control;
  1226.   rf->rf_fc.fc_subtype = MAC_Subtype_RTS;
  1227.   rf->rf_fc.fc_to_ds = 0;
  1228.   rf->rf_fc.fc_from_ds = 0;
  1229.   rf->rf_fc.fc_more_frag = 0;
  1230.   rf->rf_fc.fc_retry = 0;
  1231.   rf->rf_fc.fc_pwr_mgt = 0;
  1232.   rf->rf_fc.fc_more_data = 0;
  1233.   rf->rf_fc.fc_wep = 0;
  1234.   rf->rf_fc.fc_order = 0;
  1236. //rf->rf_duration = RTS_DURATION(pktTx_);
  1237. STORE4BYTE(&dst, (rf->rf_ra));
  1239. /* store rts tx time */
  1240. mrh->mode() = basicMode_;
  1241.   ch->txtime() = txtime(ch->size(), basicMode_);
  1243. STORE4BYTE(&index_, (rf->rf_ta));
  1245. /* calculate rts duration field */
  1246. rf->rf_duration = usec(phymib_.getSIFS()
  1247.        + txtime(phymib_.getCTSlen(), basicMode_)
  1248.        + phymib_.getSIFS()
  1249.                                + txtime(pktTx_)
  1250.        + phymib_.getSIFS()
  1251.        + txtime(phymib_.getACKlen(), basicMode_));
  1252. pktRTS_ = p;
  1253. }
  1255. void
  1256. Mac802_11mr::sendCTS(int dst, double rts_duration)
  1257. {
  1258. Packet *p = Packet::alloc();
  1259. hdr_cmn* ch = HDR_CMN(p);
  1260. MultiRateHdr *mrh = HDR_MULTIRATE(p);
  1261. struct cts_frame *cf = (struct cts_frame*)p->access(hdr_mac::offset_);
  1262. struct hdr_mac802_11 *dh = (struct hdr_mac802_11*) p->access(hdr_mac::offset_);
  1264. assert(pktCTRL_ == 0);
  1266. ch->uid() = 0;
  1267. ch->ptype() = PT_MAC;
  1268. ch->size() = phymib_.getCTSlen();
  1271. ch->iface() = -2;
  1272. ch->error() = 0;
  1273. //ch->direction() = hdr_cmn::DOWN;
  1274. bzero(cf, MAC_HDR_LEN);
  1276. cf->cf_fc.fc_protocol_version = MAC_ProtocolVersion;
  1277. cf->cf_fc.fc_type = MAC_Type_Control;
  1278. cf->cf_fc.fc_subtype = MAC_Subtype_CTS;
  1279.   cf->cf_fc.fc_to_ds = 0;
  1280.   cf->cf_fc.fc_from_ds = 0;
  1281.   cf->cf_fc.fc_more_frag = 0;
  1282.   cf->cf_fc.fc_retry = 0;
  1283.   cf->cf_fc.fc_pwr_mgt = 0;
  1284.   cf->cf_fc.fc_more_data = 0;
  1285.   cf->cf_fc.fc_wep = 0;
  1286.   cf->cf_fc.fc_order = 0;
  1288. //cf->cf_duration = CTS_DURATION(rts_duration);
  1289. STORE4BYTE(&dst, (cf->cf_ra));
  1291. // store transmitter address. 
  1292. // Not part of the standard, included for tracing and statistical purposes.
  1293. // This procedure overwrites the cf_fcs field, which is anyway unused.
  1294. STORE4BYTE(&index_, (dh->dh_ta));
  1296. /* store cts tx time */
  1297. mrh->mode() = basicMode_;
  1298. ch->txtime() = txtime(ch->size(), basicMode_);
  1300. /* calculate cts duration */
  1301. cf->cf_duration = usec(sec(rts_duration)
  1302.                               - phymib_.getSIFS()
  1303.                               - txtime(phymib_.getCTSlen(), basicMode_));
  1307. pktCTRL_ = p;
  1309. }
  1311. void
  1312. Mac802_11mr::sendACK(int dst)
  1313. {
  1314. Packet *p = Packet::alloc();
  1315. hdr_cmn* ch = HDR_CMN(p);
  1316. MultiRateHdr *mrh = HDR_MULTIRATE(p);
  1317. struct ack_frame *af = (struct ack_frame*)p->access(hdr_mac::offset_);
  1318. struct hdr_mac802_11 *dh = (struct hdr_mac802_11*) p->access(hdr_mac::offset_);
  1321. assert(pktCTRL_ == 0);
  1323. ch->uid() = 0;
  1324. ch->ptype() = PT_MAC;
  1325. // CHANGE WRT Mike's code
  1326. ch->size() = phymib_.getACKlen();
  1327. ch->iface() = -2;
  1328. ch->error() = 0;
  1330. bzero(af, MAC_HDR_LEN);
  1332. af->af_fc.fc_protocol_version = MAC_ProtocolVersion;
  1333.   af->af_fc.fc_type = MAC_Type_Control;
  1334.   af->af_fc.fc_subtype = MAC_Subtype_ACK;
  1335.   af->af_fc.fc_to_ds = 0;
  1336.   af->af_fc.fc_from_ds = 0;
  1337.   af->af_fc.fc_more_frag = 0;
  1338.   af->af_fc.fc_retry = 0;
  1339.   af->af_fc.fc_pwr_mgt = 0;
  1340.   af->af_fc.fc_more_data = 0;
  1341.   af->af_fc.fc_wep = 0;
  1342.   af->af_fc.fc_order = 0;
  1344. //af->af_duration = ACK_DURATION();
  1345. STORE4BYTE(&dst, (af->af_ra));
  1347. // store transmitter address. 
  1348. // Not part of the standard, included for tracing and statistical purposes.
  1349. // This procedure overwrites the af_fcs field, which is anyway unused.
  1350. STORE4BYTE(&index_, (dh->dh_ta));
  1352. /* store ack tx time */
  1353. mrh->mode() = basicMode_;
  1354.   ch->txtime() = txtime(ch->size(), basicMode_);
  1356. /* calculate ack duration */
  1357.   af->af_duration = 0;
  1359. pktCTRL_ = p;
  1360. }
  1362. void
  1363. Mac802_11mr::sendDATA(Packet *p)
  1364. {
  1365. hdr_cmn* ch = HDR_CMN(p);
  1366. MultiRateHdr *mrh = HDR_MULTIRATE(p);
  1367. struct hdr_mac802_11* dh = HDR_MAC802_11(p);
  1369. assert(pktTx_ == 0);
  1371. Mac80211EventHandler* mehptr = mehlist_;
  1372. while(mehptr) {
  1373. mehptr->sendDATA(p);
  1374. mehptr = mehptr->next;
  1375. }
  1377. /*
  1378.  * Update the MAC header
  1379.  */
  1380. ch->size() += phymib_.getHdrLen11();
  1382. dh->dh_fc.fc_protocol_version = MAC_ProtocolVersion;
  1383. dh->dh_fc.fc_type       = MAC_Type_Data;
  1384. dh->dh_fc.fc_subtype    = MAC_Subtype_Data;
  1386. dh->dh_fc.fc_to_ds      = 0;
  1387. dh->dh_fc.fc_from_ds    = 0;
  1388. dh->dh_fc.fc_more_frag  = 0;
  1389. dh->dh_fc.fc_retry      = 0;
  1390. dh->dh_fc.fc_pwr_mgt    = 0;
  1391. dh->dh_fc.fc_more_data  = 0;
  1392. dh->dh_fc.fc_wep        = 0;
  1393. dh->dh_fc.fc_order      = 0;
  1395. /* store data tx time */
  1396.   //ch->txtime() = txtime(ch->size(), dataMode_);
  1398. if((u_int32_t)ETHER_ADDR(dh->dh_ra) != MAC_BROADCAST) {
  1399. /* store data tx time for unicast packets */
  1400. mrh->mode() = dataMode_;
  1401. ch->txtime() = txtime(ch->size(), dataMode_);
  1403. dh->dh_duration = usec(txtime(phymib_.getACKlen(), basicMode_)
  1404.        + phymib_.getSIFS());
  1408. } else {
  1409. /* store data tx time for broadcast packets (see 9.6) */
  1410. mrh->mode() = basicMode_;
  1411. ch->txtime() = txtime(ch->size(), basicMode_);
  1413. dh->dh_duration = 0;
  1414. }
  1415. pktTx_ = p;
  1417. }
  1419. /* ======================================================================
  1420.    Retransmission Routines
  1421.    ====================================================================== */
  1422. void
  1423. Mac802_11mr::RetransmitRTS()
  1424. {
  1425. assert(pktTx_);
  1426. assert(pktRTS_);
  1427. assert(mhBackoff_.busy() == 0);
  1430. struct hdr_mac802_11 *mh = HDR_MAC802_11(pktTx_);
  1431. u_int32_t dst = (u_int32_t)ETHER_ADDR(mh->dh_ra);
  1433. incRTSFailed(dst);
  1436. ssrc_ += 1; // STA Short Retry Count
  1438. if(ssrc_ >= macmib_.getShortRetryLimit()) {
  1439. discard(pktRTS_, DROP_MAC_RETRY_COUNT_EXCEEDED); pktRTS_ = 0;
  1440. /* tell the callback the send operation failed 
  1441.    before discarding the packet */
  1442. hdr_cmn *ch = HDR_CMN(pktTx_);
  1443. if (ch->xmit_failure_) {
  1444.                         /*
  1445.                          *  Need to remove the MAC header so that 
  1446.                          *  re-cycled packets don't keep getting
  1447.                          *  bigger.
  1448.                          */
  1449. ch->size() -= phymib_.getHdrLen11();
  1450.                         ch->xmit_reason_ = XMIT_REASON_RTS;
  1451.                         ch->xmit_failure_(pktTx_->copy(),
  1452.                                           ch->xmit_failure_data_);
  1453.                 }
  1454. discard(pktTx_, DROP_MAC_RETRY_COUNT_EXCEEDED); 
  1455. pktTx_ = 0;
  1456. ssrc_ = 0;
  1457. incMPDUTxFailed(dst);
  1458. rst_cw();
  1459. } else {
  1460. struct rts_frame *rf;
  1461. rf = (struct rts_frame*)pktRTS_->access(hdr_mac::offset_);
  1462. rf->rf_fc.fc_retry = 1;
  1464. inc_cw();
  1465. //mhBackoff_.start(cw_, is_idle());
  1466. mhBackoff_.start(cw_, 0);
  1467. if(is_idle())
  1468. mhBackoff_.resume(0.0);
  1469. }
  1470. }
  1472. void
  1473. Mac802_11mr::RetransmitDATA()
  1474. {
  1475. struct hdr_cmn *ch;
  1476. struct hdr_mac802_11 *mh;
  1477. u_int32_t *rcount, thresh;
  1478. assert(mhBackoff_.busy() == 0);
  1480. assert(pktTx_);
  1481. assert(pktRTS_ == 0);
  1483. ch = HDR_CMN(pktTx_);
  1484. mh = HDR_MAC802_11(pktTx_);
  1485. u_int32_t dst = (u_int32_t)ETHER_ADDR(mh->dh_ra);
  1487. /*
  1488.  *  Broadcast packets don't get ACKed and therefore
  1489.  *  are never retransmitted.
  1490.  */
  1491. if(dst == MAC_BROADCAST) {
  1492. Packet::free(pktTx_); 
  1493. pktTx_ = 0;
  1495. /*
  1496.  * Backoff at end of TX.
  1497.  */
  1498. rst_cw();
  1499. //  mhBackoff_.start(cw_, is_idle());
  1500. mhBackoff_.start(cw_, 0);
  1501. if(is_idle())
  1502. mhBackoff_.resume(0.0);
  1504. return;
  1505. }
  1507. //macmib_.ACKFailed++;
  1508. incACKFailed(dst);
  1510. if((u_int32_t) ch->size() <= macmib_.getRTSThreshold()) {
  1511.                 rcount = &ssrc_;
  1512.                thresh = macmib_.getShortRetryLimit();
  1513.         } else {
  1514.                 rcount = &slrc_;
  1515.                thresh = macmib_.getLongRetryLimit();
  1516.         }
  1518. (*rcount)++;
  1520. if(*rcount >= thresh) {
  1521. /* IEEE Spec section 9.2.3.5 says this should be greater than
  1522.    or equal */
  1523. //macmib_.MPDUTxFailed++;
  1524. incMPDUTxFailed(dst);
  1525. /* tell the callback the send operation failed 
  1526.    before discarding the packet */
  1527. hdr_cmn *ch = HDR_CMN(pktTx_);
  1528. if (ch->xmit_failure_) {
  1529.                         ch->size() -= phymib_.getHdrLen11();
  1530. ch->xmit_reason_ = XMIT_REASON_ACK;
  1531.                         ch->xmit_failure_(pktTx_->copy(),
  1532.                                           ch->xmit_failure_data_);
  1533.                 }
  1535. discard(pktTx_, DROP_MAC_RETRY_COUNT_EXCEEDED); 
  1536. pktTx_ = 0;
  1537. *rcount = 0;
  1538. rst_cw();
  1539. }
  1540. else {
  1542. mh->dh_fc.fc_retry = 1;
  1544. sendRTS(dst);
  1545. inc_cw();
  1546. //mhBackoff_.start(cw_, is_idle());
  1547. mhBackoff_.start(cw_, 0);
  1548. if(is_idle())
  1549. mhBackoff_.resume(0.0);
  1550. }
  1551. }
  1553. /* ======================================================================
  1554.    Incoming Packet Routines
  1555.    ====================================================================== */
  1556. void
  1557. Mac802_11mr::send(Packet *p, Handler *h)
  1558. {
  1559. double rTime;
  1560. struct hdr_mac802_11* dh = HDR_MAC802_11(p);
  1562. /* EnergyModel *em = netif_->node()->energy_model();
  1563. if (em && em->sleep()) {
  1564. em->set_node_sleep(0);
  1565. em->set_node_state(EnergyModel::INROUTE);
  1566. }*/
  1568. callback_ = h;
  1569. sendDATA(p);
  1570. sendRTS(ETHER_ADDR(dh->dh_ra));
  1572. /*
  1573.  * Assign the data packet a sequence number.
  1574.  */
  1575. dh->dh_scontrol = sta_seqno_++;
  1577. /*
  1578.  *  If the medium is IDLE, we must wait for a DIFS
  1579.  *  Space before transmitting.
  1580.  */
  1581. if(mhBackoff_.busy() == 0) {
  1582. mhBackoff_.start(cw_, is_idle(), phymib_.getDIFS());
  1583. }
  1584. }
  1586. void
  1587. Mac802_11mr::recv(Packet *p, Handler *h)
  1588. {
  1589. struct hdr_cmn *hdr = HDR_CMN(p);
  1591. /*
  1592.  * Sanity Check
  1593.  */
  1594. assert(initialized());
  1596. /*
  1597.  *  Handle outgoing packets.
  1598.  */
  1599. if(hdr->direction() == hdr_cmn::DOWN) {
  1600.                 send(p, h);
  1601.                 return;
  1602.         }
  1603. /*
  1604.  *  Handle incoming packets.
  1605.  *
  1606.  *  We just received the 1st bit of a packet on the network
  1607.  *  interface.
  1608.  *
  1609.  */
  1611. // we don't know which type of packet it is 
  1612. // and if it will be received correctly,
  1613. // so we account only for its duration + DIFS
  1614. updateIdleTime(txtime(p) + phymib_.getDIFS() + phymib_.getSlotTime());
  1616. /*
  1617.  *  If the interface is currently in transmit mode, then
  1618.  *  it probably won't even see this packet.  However, the
  1619.  *  "air" around me is BUSY so I need to let the packet
  1620.  *  proceed.  Just set the error flag in the common header
  1621.  *  to that the packet gets thrown away.
  1622.  */
  1623. //  if(tx_active_ && hdr->error() == 0) {
  1624. //  hdr->error() = 1;
  1625. //  }
  1628. /**
  1629.  * If the interface is currently in transmit mode, then
  1630.  * it probably won't even see this packet, and we can discard it.
  1631.  * We have to set the NAV accordingly because the air will possibly
  1632.  * be busy even when transmission by current node ends.
  1633.  */
  1634. if(tx_active_) {
  1635. set_nav(txtime(p));
  1636. hdr_mac802_11 *mh = HDR_MAC802_11(p);
  1637. u_int32_t src = ETHER_ADDR(mh->dh_ta); 
  1638. u_int8_t  type = mh->dh_fc.fc_type;
  1639. incFrameDropTxa(src, type);
  1640. discard(p, DROP_MAC_TX_ACTIVE);
  1641. return;
  1642. }
  1645. if(debug_) printf("%f - %i --- recv - received a packet(error=%i,rx_state=%i MAC_IDLE=%i, id=%i)n",
  1646.   Scheduler::instance().clock(), index_, hdr->error(), rx_state_,MAC_IDLE,hdr->uid());
  1648. if(rx_state_ == MAC_IDLE) {
  1649. rx_time = Scheduler::instance().clock();
  1650. setRxState(MAC_RECV);
  1651. pktRx_ = p;
  1652. /*
  1653.  * Schedule the reception of this packet, in
  1654.  * txtime seconds.
  1655.  */
  1656. mhRecv_.start(txtime(p));
  1657. assert(profile_);
  1658. profile_->startNewRecording();
  1660. } else {
  1662. double si = phymib_.getSyncInterval(HDR_MULTIRATE(pktRx_)->mode_);
  1664. /* this sanity check has almost no sense, 
  1665.    since 802.11b and g packets can coexist */
  1666. //  if (si != phymib_.getSyncInterval(HDR_MULTIRATE(p->mode_))
  1667. //  printf("WARNING: two colliding packets have different SyncIntervaln" );
  1668.        
  1670. /* 
  1671.  * if the starting time of the new packet is within a SyncInterval 
  1672.  * of the first packet we synchronized onto, it is possible to 
  1673.  * re-sync on the newer packet, if it's stronger.
  1674.  */
  1676. if ((Scheduler::instance().clock() - rx_time) < si ) {
  1679. if(p->txinfo_.RxPr > pktRx_->txinfo_.RxPr ) {
  1681. /* make p the new pktRx 
  1682.  * and reschedule the recv_timer accordigly  */ 
  1684. Packet* old;
  1686. old = pktRx_;
  1687. pktRx_ = p;
  1688. p = old;
  1690. mhRecv_.stop();
  1691. mhRecv_.start(txtime(pktRx_));
  1693. if(debug_) printf("%f - %i --- recv_timer - Synchronizing on a stronger packetn",
  1694.   Scheduler::instance().clock(), index_);
  1697. }
  1699. } 
  1701.        /* The receiver stays syncronized on pktRx,
  1702. * and packet p is discarded.
  1703. */
  1705. if(debug_) printf("%f - %i --- recv_timer - dropping packet because synchronized on another packetn",
  1706.   Scheduler::instance().clock(), index_);
  1708. set_nav(txtime(p));
  1710. hdr_mac802_11 *mh = HDR_MAC802_11(p);
  1711. u_int32_t src = ETHER_ADDR(mh->dh_ta); 
  1712. u_int8_t  type = mh->dh_fc.fc_type;
  1713. incFrameDropSyn(src, type);
  1714. discard(p, DROP_MAC_SYNC_FAILED);
  1715. }
  1716. }
  1720. void
  1721. Mac802_11mr::recv_timer()
  1722. {
  1723. hdr_cmn *ch = HDR_CMN(pktRx_);
  1724. hdr_mac802_11 *mh = HDR_MAC802_11(pktRx_);
  1725. u_int32_t src = ETHER_ADDR(mh->dh_ta); 
  1726. u_int32_t dst = ETHER_ADDR(mh->dh_ra);
  1728. u_int8_t  type = mh->dh_fc.fc_type;
  1729. u_int8_t  subtype = mh->dh_fc.fc_subtype;
  1731. assert(pktRx_);
  1732. assert(rx_state_ == MAC_RECV || rx_state_ == MAC_COLL);
  1734. profile_->stopRecording();
  1736. if(debug_) printf("%f - %i --- recv_timer - tx_active=%i error=%i per_=%pn",Scheduler::instance().clock(), index_, tx_active_, ch->error(), per_);
  1740. /*
  1741.  * This block appears to be useless.
  1742.  * 1) if tx_active was true upon recv() then packet had been discarded at that time 
  1743.  *    and no recv_timer should have been scheduled.
  1744.  * 2) if tx_active was false upon recv(), it means that a transmit() had occurred afterwards
  1745.  *    (this happens when sending a packet without CS, e.g., when sending an ACK)
  1746.  *    but in that case ch->error is set by Mac802_11mr::transmit() 
  1747.          */
  1748.         if(tx_active_ && !ch->error()) {
  1749. if (debug_) {
  1750. fprintf(stderr,"%f - STRANGE!!! (node %d) tx_active==true && ch->error == 0 in mac-802_11mr::recv_timer()n",Scheduler::instance().clock(),index_);
  1751. dump("Mac802_11mr::recv_timer()");
  1752. fprintf(stderr,"pktTx_:");
  1753. trace_pkt(pktTx_);
  1754. fprintf(stderr,"pktRx_:");
  1755. trace_pkt(pktRx_);
  1756. }
  1757. Packet::free(pktRx_);
  1758. assert(0);
  1759.                 goto done;
  1760.         }
  1763. /*
  1764.          * If the interface enters TRANSMIT mode between recv() and recv_timer()
  1765.  * of this packet (this happens when sending a packet without CS, e.g., when sending an ACK)
  1766.  * ch->error is set by Mac802_11mr::transmit() since this packet cannot be received.
  1767.  * We do a silent discard without adjusting the NAV.  
  1768.  */
  1769. if( ch->error() ) {
  1770. Packet::free(pktRx_);
  1771. //set_nav(phymib_.getEIFS(BasicMode_));
  1772. updateIdleTime(phymib_.getEIFS() + phymib_.getSlotTime(), UIT_WEAK);
  1773. goto done;
  1774. }
  1777. if (per_) {
  1778. /* 
  1779. * Check for packet errors
  1780. */
  1781. double snr;
  1782. double snir;
  1783. double interf;
  1784. switch(per_->get_err(profile_, pktRx_, &snr, &snir, &interf)) 
  1785. {
  1787. case PKT_ERROR_INTERFERENCE:
  1788. if(debug_) printf("%f - %i --- recv_timer - drop for interference (COLLISION)n",Scheduler::instance().clock(), index_);
  1789. discard(pktRx_, DROP_MAC_COLLISION);
  1790. //set_nav(phymib_.getEIFS(BasicMode_));
  1791. updateIdleTime(phymib_.getEIFS() + phymib_.getSlotTime(), UIT_WEAK);
  1792. incFrameErrors(src, type, PKT_ERROR_INTERFERENCE);
  1793. goto done;
  1794. break;
  1796. case PKT_ERROR_NOISE:
  1797. if(debug_) printf("%f - %i --- recv_timer - drop for noise (ERR)n",Scheduler::instance().clock(), index_);
  1798. discard(pktRx_, DROP_MAC_PACKET_ERROR);
  1799. //set_nav(phymib_.getEIFS(BasicMode_));
  1800. updateIdleTime(phymib_.getEIFS() + phymib_.getSlotTime(), UIT_WEAK);
  1801. incFrameErrors(src, type, PKT_ERROR_NOISE);
  1802. goto done;
  1803. break;
  1805. case PKT_OK:
  1806. incFrameReceives(src, type);
  1807. break;
  1809. default:
  1810. assert(0);
  1811. break;
  1812. }
  1814. updateSnr(src, dst, snr);
  1815. updateSnir(src, dst, snir);
  1816. updateInterf(src, dst, interf);
  1818. }     
  1821. /*
  1822.  * IEEE 802.11 specs, section 9.2.5.6
  1823.  * - update the NAV (Network Allocation Vector)
  1824.  */
  1825. if(dst != (u_int32_t)index_) {
  1826. set_nav(mh->dh_duration);
  1828. // here NAV can be shrunk. See 802.11-1999, sec. 9.2.3.4
  1829. updateIdleTime(sec(mh->dh_duration) + phymib_.getDIFS() + phymib_.getSlotTime(), UIT_FORCED);
  1830. }
  1832.         /* tap out - */
  1833.         if (tap_ && type == MAC_Type_Data &&
  1834.             MAC_Subtype_Data == subtype ) 
  1835. tap_->tap(pktRx_);
  1836. /*
  1837.  * Adaptive Fidelity Algorithm Support - neighborhood infomation 
  1838.  * collection
  1839.  *
  1840.  * Hacking: Before filter the packet, log the neighbor node
  1841.  * I can hear the packet, the src is my neighbor
  1842.  */
  1844. /* Beyond sanity checking, 
  1845.  * this will enable execution in standard NS 
  1846.  * and prevent it in NS-Miracle 
  1847.  */
  1848. if (netif_ 
  1849.     && netif_->node()
  1850.     && netif_->node()->energy_model()  
  1851.     && netif_->node()->energy_model()->adaptivefidelity()) {
  1852. netif_->node()->energy_model()->add_neighbor(src);
  1853. }
  1855. /*
  1856.  * Address Filtering
  1857.  */
  1858. if(dst != (u_int32_t)index_ && dst != MAC_BROADCAST) {
  1859. /*
  1860.  *  We don't want to log this event, so we just free
  1861.  *  the packet instead of calling the drop routine.
  1862.  */
  1863. if(debug_) printf("%f - %i --- recv_timer - the packet is not for me!!n",Scheduler::instance().clock(), index_);
  1864. //discard(pktRx_, "---");
  1865. Packet::free(pktRx_);
  1866. goto done;
  1867. }
  1868. if(debug_) printf("%f - %i --- recv_timer - the packet is for me (ra=%i, pktid=%i)!!n",Scheduler::instance().clock(), index_, dst, ch->uid());
  1870. switch(type) {
  1872. case MAC_Type_Management:
  1873. discard(pktRx_, DROP_MAC_UNKNOWN_TYPE);
  1874. goto done;
  1875. case MAC_Type_Control:
  1876. switch(subtype) {
  1877. case MAC_Subtype_RTS:
  1878. recvRTS(pktRx_);
  1879. break;
  1880. case MAC_Subtype_CTS:
  1881. recvCTS(pktRx_);
  1882. break;
  1883. case MAC_Subtype_ACK:
  1884. if(debug_) printf("%f - %i --- recv_timer - received an ACK!!n",Scheduler::instance().clock(), index_);
  1885. recvACK(pktRx_);
  1886. break;
  1887. default:
  1888. fprintf(stderr,"recvTimer1:Invalid MAC Control Subtype %xn",
  1889. subtype);
  1890. exit(1);
  1891. }
  1892. break;
  1893. case MAC_Type_Data:
  1894. switch(subtype) {
  1895. case MAC_Subtype_Data:
  1896. incMPDURxSuccessful(src);
  1897. if(debug_) printf("%f - %i --- recv_timer - received a data packet!!n",Scheduler::instance().clock(), index_);
  1898. recvDATA(pktRx_);
  1899. break;
  1900. default:
  1901. fprintf(stderr, "recv_timer2:Invalid MAC Data Subtype %xn",
  1902. subtype);
  1903. exit(1);
  1904. }
  1905. break;
  1906. default:
  1907. fprintf(stderr, "recv_timer3:Invalid MAC Type %xn", subtype);
  1908. exit(1);
  1909. }
  1910.  done:
  1911. pktRx_ = 0;
  1912. if(debug_) printf("%f - %i --- recv_timer - call rx_resumen",Scheduler::instance().clock(), index_);
  1913. rx_resume();
  1914. }
  1917. void
  1918. Mac802_11mr::recvRTS(Packet *p)
  1919. {
  1920. struct rts_frame *rf = (struct rts_frame*)p->access(hdr_mac::offset_);
  1922. if(tx_state_ != MAC_IDLE) {
  1923. discard(p, DROP_MAC_BUSY);
  1924. return;
  1925. }
  1927. /*
  1928.  *  If I'm responding to someone else, discard this RTS.
  1929.  */
  1930. if(pktCTRL_) {
  1931. discard(p, DROP_MAC_BUSY);
  1932. return;
  1933. }
  1935. sendCTS(ETHER_ADDR(rf->rf_ta), rf->rf_duration);
  1937. /*
  1938.  *  Stop deferring - will be reset in tx_resume().
  1939.  */
  1940. if(mhDefer_.busy()) mhDefer_.stop();
  1942. tx_resume();
  1944. mac_log(p);
  1945. }
  1947. /*
  1948.  * txtime() - pluck the precomputed tx time from the packet header
  1949.  */
  1950. double
  1951. Mac802_11mr::txtime(Packet *p)
  1952. {
  1953. struct hdr_cmn *ch = HDR_CMN(p);
  1954. double t = ch->txtime();
  1955. if (t < 0.0) {
  1956. drop(p, "XXX");
  1957.   exit(1);
  1958. }
  1959. return t;
  1960. }
  1962.  
  1963. /*
  1964.  * txtime() - calculate tx time for packet of size "psz" bytes 
  1965.  *   at rate "drt" bps
  1966.  */
  1967. double
  1968. Mac802_11mr::txtime(int psz, PhyMode mode)
  1969. {
  1970. /* double dsz = psz - phymib_.getPLCPhdrLen();
  1971.         int plcp_hdr = phymib_.getPLCPhdrLen() << 3;
  1972. int datalen = (int)dsz << 3;
  1973. double t = (((double)plcp_hdr)/phymib_.getPLCPDataRate())
  1974.                                        + (((double)datalen)/drt);*/
  1975. switch(mode)
  1976. {
  1977. case Mode1Mb:
  1978. case Mode2Mb:
  1979. case Mode5_5Mb:
  1980. case Mode11Mb:
  1981. return(phymib_.getPHYhdrDuration(mode) + (8 *  (double)psz)/phymib_.getRate(mode));
  1982. case Mode6Mb:
  1983. case Mode9Mb:
  1984. case Mode12Mb:
  1985. case Mode18Mb:
  1986. case Mode24Mb:
  1987. case Mode36Mb:
  1988. case Mode48Mb:
  1989. case Mode54Mb:
  1990. return(phymib_.getPHYhdrDuration(mode) + ceil((OFDMServiceTail+(double)psz*8)/phymib_.getNBits(mode))*OFDMSYMBDURATION);
  1991. default:
  1992. fprintf(stderr,"Unknown PHY mode (%i)!!!n", mode);
  1993. exit(1);
  1994. }
  1995. }
  1999. void
  2000. Mac802_11mr::recvCTS(Packet *p)
  2001. {
  2002. if(tx_state_ != MAC_RTS) {
  2003. discard(p, DROP_MAC_INVALID_STATE);
  2004. return;
  2005. }
  2007. assert(pktRTS_);
  2008. Packet::free(pktRTS_); pktRTS_ = 0;
  2010. assert(pktTx_);
  2011. mhSend_.stop();
  2013. /*
  2014.  * The successful reception of this CTS packet implies
  2015.  * that our RTS was successful. 
  2016.  * According to the IEEE spec 9.2.5.3, you must 
  2017.  * reset the ssrc_, but not the congestion window.
  2018.  */
  2019. ssrc_ = 0;
  2020. tx_resume();
  2022. mac_log(p);
  2023. }
  2025. void
  2026. Mac802_11mr::recvDATA(Packet *p)
  2027. {
  2028. struct hdr_mac802_11 *dh = HDR_MAC802_11(p);
  2029. u_int32_t dst, src, size;
  2030. struct hdr_cmn *ch = HDR_CMN(p);
  2032. dst = ETHER_ADDR(dh->dh_ra);
  2033. src = ETHER_ADDR(dh->dh_ta);
  2034. size = ch->size();
  2035. /*
  2036.  * Adjust the MAC packet size - ie; strip
  2037.  * off the mac header
  2038.  */
  2039. ch->size() -= phymib_.getHdrLen11();
  2040. ch->num_forwards() += 1;
  2042. /*
  2043.  *  If we sent a CTS, clean up...
  2044.  */
  2045. if(dst != MAC_BROADCAST) {
  2046. if(size >= macmib_.getRTSThreshold()) {
  2047. if (tx_state_ == MAC_CTS) {
  2048. assert(pktCTRL_);
  2049. Packet::free(pktCTRL_); pktCTRL_ = 0;
  2050. mhSend_.stop();
  2051. /*
  2052.  * Our CTS got through.
  2053.  */
  2054. } else {
  2055. discard(p, DROP_MAC_BUSY);
  2056. return;
  2057. }
  2058. sendACK(src);
  2059. tx_resume();
  2060. } else {
  2061. /*
  2062.  *  We did not send a CTS and there's no
  2063.  *  room to buffer an ACK.
  2064.  */
  2065. if(pktCTRL_) {
  2066. discard(p, DROP_MAC_BUSY);
  2067. return;
  2068. }
  2069. sendACK(src);
  2070. if(mhSend_.busy() == 0)
  2071. tx_resume();
  2072. }
  2073. }
  2075. /* ============================================================
  2076.    Make/update an entry in our sequence number cache.
  2077.    ============================================================ */
  2079. /* Changed by Debojyoti Dutta. This upper loop of if{}else was 
  2080.    suggested by Joerg Diederich <dieder@ibr.cs.tu-bs.de>. 
  2081.    Changed on 19th Oct'2000 */
  2083.         if(dst != MAC_BROADCAST) {
  2084.                 if (src < (u_int32_t) cache_node_count_) {
  2085.                         Host *h = &cache_[src];
  2087.                         if(h->seqno && h->seqno == dh->dh_scontrol) {
  2088.                                 discard(p, DROP_MAC_DUPLICATE);
  2089.                                 return;
  2090.                         }
  2091.                         h->seqno = dh->dh_scontrol;
  2092.                 } else {
  2093. static int count = 0;
  2094. if (++count <= 10) {
  2095. printf ("MAC_802_11: accessing MAC cache_ array out of range (src %u, dst %u, size %d)!n", src, dst, cache_node_count_);
  2096. if (count == 10)
  2097. printf ("[suppressing additional MAC cache_ warnings]n");
  2098. };
  2099. };
  2100. }
  2102. /*
  2103.  *  Pass the packet up to the link-layer.
  2104.  *  XXX - we could schedule an event to account
  2105.  *  for this processing delay.
  2106.  */
  2108. /* in BSS mode, if a station receives a packet via
  2109.  * the AP, and higher layers are interested in looking
  2110.  * at the src address, we might need to put it at
  2111.  * the right place - lest the higher layers end up
  2112.  * believing the AP address to be the src addr! a quick
  2113.  * grep didn't turn up any higher layers interested in
  2114.  * the src addr though!
  2115.  * anyway, here if I'm the AP and the destination
  2116.  * address (in dh_3a) isn't me, then we have to fwd
  2117.  * the packet; we pick the real destination and set
  2118.  * set it up for the LL; we save the real src into
  2119.  * the dh_3a field for the 'interested in the info'
  2120.  * receiver; we finally push the packet towards the
  2121.  * LL to be added back to my queue - accomplish this
  2122.  * by reversing the direction!*/
  2124. if ((bss_id() == addr()) && ((u_int32_t)ETHER_ADDR(dh->dh_ra)!= MAC_BROADCAST)&& ((u_int32_t)ETHER_ADDR(dh->dh_3a) != ((u_int32_t)addr()))) {
  2125. struct hdr_cmn *ch = HDR_CMN(p);
  2126. u_int32_t dst = ETHER_ADDR(dh->dh_3a);
  2127. u_int32_t src = ETHER_ADDR(dh->dh_ta);
  2128. /* if it is a broadcast pkt then send a copy up
  2129.  * my stack also
  2130.  */
  2131. if (dst == MAC_BROADCAST) {
  2132. uptarget_->recv(p->copy(), (Handler*) 0);
  2133. }
  2135. ch->next_hop() = dst;
  2136. STORE4BYTE(&src, (dh->dh_3a));
  2137. ch->addr_type() = NS_AF_ILINK;
  2138. ch->direction() = hdr_cmn::DOWN;
  2139. }
  2141. uptarget_->recv(p, (Handler*) 0);
  2142. }
  2145. void
  2146. Mac802_11mr::recvACK(Packet *p)
  2147. {
  2148. if(tx_state_ != MAC_SEND) {
  2149. discard(p, DROP_MAC_INVALID_STATE);
  2150. return;
  2151. }
  2152. assert(pktTx_);
  2154. struct MultiRateHdr *hdm = HDR_MULTIRATE(p);
  2155. struct hdr_mac802_11 *pmh = HDR_MAC802_11(p);
  2156. PhyMode pm = hdm->mode();
  2157. u_int32_t ack_src = (u_int32_t)ETHER_ADDR(pmh->dh_ta);
  2159. struct hdr_mac802_11 *mh = HDR_MAC802_11(pktTx_);
  2160. u_int32_t dst = (u_int32_t)ETHER_ADDR(mh->dh_ra);
  2162. assert(ack_src == dst);
  2164. if (ack_src == bss_id())
  2165. phymib_.setAPAckMode(pm);
  2168. mhSend_.stop();
  2170. incMPDUTxSuccessful(dst);
  2172. /*
  2173.  * The successful reception of this ACK packet implies
  2174.  * that our DATA transmission was successful.  Hence,
  2175.  * we can reset the Short/Long Retry Count and the CW.
  2176.  *
  2177.  * need to check the size of the packet we sent that's being
  2178.  * ACK'd, not the size of the ACK packet.
  2179.  */
  2180. if((u_int32_t) HDR_CMN(pktTx_)->size() <= macmib_.getRTSThreshold()) {
  2181. if (ssrc_ > 1)  { 
  2182. incMPDUTxMultipleRetries(dst);
  2183. } else if (ssrc_ == 1){
  2184. incMPDUTxOneRetry(dst);
  2185. }
  2186. ssrc_ = 0;
  2187. } else {
  2188. if (slrc_ > 1)  { 
  2189. macmib_.MPDUTxMultipleRetries++; 
  2190. incMPDUTxMultipleRetries(dst);
  2191. } else if (slrc_ == 1){
  2192. incMPDUTxOneRetry(dst);
  2193. }
  2194. slrc_ = 0;
  2195. }
  2196. rst_cw();
  2197. Packet::free(pktTx_); 
  2198. pktTx_ = 0;
  2200. /*
  2201.  * Backoff before sending again.
  2202.  */
  2203. assert(mhBackoff_.busy() == 0);
  2204. mhBackoff_.start(cw_, 0);
  2205. if(is_idle())
  2206. mhBackoff_.resume(phymib_.getDIFS());
  2208. tx_resume();
  2210. mac_log(p);
  2211. }
  2215. void Mac802_11mr::incFrameErrors(u_int32_t src, u_int8_t  type, int reason)
  2216. {
  2217. macmib_.FrameErrors++;
  2219. if (reason == PKT_ERROR_NOISE)
  2220. macmib_.FrameErrorsNoise++;
  2222. MR_MAC_MIB* peermacmib = 0;
  2224. if (peerstatsdb_) 
  2225. peermacmib = peerstatsdb_->getPeerStats(src, (u_int32_t)index_)->macmib;
  2227. if (peermacmib) {
  2228. peermacmib->FrameErrors++;
  2229. if (reason == PKT_ERROR_NOISE)
  2230. peermacmib->FrameErrorsNoise++;
  2231. }
  2234. switch (type)  {
  2236. case MAC_Type_Management:
  2237. macmib_.MgmtFrameErrors++;
  2238. if (peermacmib)
  2239. peermacmib->MgmtFrameErrors++;
  2241. if (reason == PKT_ERROR_NOISE) {
  2242. macmib_.MgmtFrameErrorsNoise++;
  2243. if (peermacmib)
  2244. peermacmib->MgmtFrameErrorsNoise++;
  2245. }
  2246. break;
  2248. case MAC_Type_Control:
  2249. macmib_.CtrlFrameErrors++;
  2250. if (peermacmib)
  2251. peermacmib->CtrlFrameErrors++;
  2252. if (reason == PKT_ERROR_NOISE) {
  2253. macmib_.CtrlFrameErrorsNoise++;
  2254. if (peermacmib)
  2255. peermacmib->CtrlFrameErrorsNoise++;
  2256. }
  2257. break;
  2259. case MAC_Type_Data:
  2260. macmib_.DataFrameErrors++;
  2261. if (peermacmib)
  2262. peermacmib->DataFrameErrors++;
  2264. if (reason == PKT_ERROR_NOISE) {
  2265. macmib_.DataFrameErrorsNoise++;
  2266. if (peermacmib)
  2267. peermacmib->DataFrameErrorsNoise++;
  2268. }
  2269. break;
  2271. default:
  2272. fprintf(stderr,"Mac802_11mr::incFrameErrors() unknown MAC_typen");
  2273. assert(0);
  2274. break;
  2275. }
  2277. Mac80211EventHandler* mehptr = mehlist_;
  2278. while(mehptr) {
  2279. mehptr->counterHandle(ID_FrameErrors);
  2280. mehptr = mehptr->next;
  2281. }
  2282. }
  2284. void Mac802_11mr::incFrameReceives(u_int32_t src, u_int8_t  type)
  2285. {
  2286. macmib_.FrameReceives++;
  2287. MR_MAC_MIB* peermacmib = 0;
  2289. if (peerstatsdb_) 
  2290. peermacmib = peerstatsdb_->getPeerStats(src, (u_int32_t)index_)->macmib;
  2292. if (peermacmib)
  2293. peermacmib->FrameReceives++;
  2295. switch (type)  {
  2297. case MAC_Type_Management:
  2298. macmib_.MgmtFrameReceives++;
  2299. if (peermacmib)
  2300. peermacmib->MgmtFrameReceives++;
  2301. break;
  2303. case MAC_Type_Control:
  2304. macmib_.CtrlFrameReceives++;
  2305. if (peermacmib)
  2306. peermacmib->CtrlFrameReceives++;
  2307. break;
  2309. case MAC_Type_Data:
  2310. macmib_.DataFrameReceives++;
  2311. if (peermacmib)
  2312. peermacmib->DataFrameReceives++;
  2313. break;
  2315. default:
  2316. fprintf(stderr,"Mac802_11mr::incFrameReceives() unknown MAC_typen");
  2317. assert(0);
  2318. break;
  2319. }
  2321. Mac80211EventHandler* mehptr = mehlist_;
  2322. while(mehptr) {
  2323. mehptr->counterHandle(ID_FrameReceives);
  2324. mehptr = mehptr->next;
  2325. }
  2326. }
  2330. void Mac802_11mr::incFrameDropSyn(u_int32_t src, u_int8_t  type)
  2331. {
  2332. macmib_.FrameDropSyn++;
  2333. MR_MAC_MIB* peermacmib = 0;
  2335. if (peerstatsdb_) 
  2336. peermacmib = peerstatsdb_->getPeerStats(src, (u_int32_t)index_)->macmib;
  2338. if (peermacmib)
  2339. peermacmib->FrameDropSyn++;
  2341. switch (type)  {
  2343. case MAC_Type_Management:
  2344. macmib_.MgmtFrameDropSyn++;
  2345. if (peermacmib)
  2346. peermacmib->MgmtFrameDropSyn++;
  2347. break;
  2349. case MAC_Type_Control:
  2350. macmib_.CtrlFrameDropSyn++;
  2351. if (peermacmib)
  2352. peermacmib->CtrlFrameDropSyn++;
  2353. break;
  2355. case MAC_Type_Data:
  2356. macmib_.DataFrameDropSyn++;
  2357. if (peermacmib)
  2358. peermacmib->DataFrameDropSyn++;
  2359. break;
  2361. default:
  2362. fprintf(stderr,"Mac802_11mr::incFrameReceives() unknown MAC_typen");
  2363. assert(0);
  2364. break;
  2365. }
  2367. Mac80211EventHandler* mehptr = mehlist_;
  2368. while(mehptr) {
  2369. mehptr->counterHandle(ID_FrameDropSyn);
  2370. mehptr = mehptr->next;
  2371. }
  2372. }
  2375. void Mac802_11mr::incFrameDropTxa(u_int32_t src, u_int8_t  type)
  2376. {
  2377. macmib_.FrameDropTxa++;
  2378. MR_MAC_MIB* peermacmib = 0;
  2380. if (peerstatsdb_) 
  2381. peermacmib = peerstatsdb_->getPeerStats(src, (u_int32_t)index_)->macmib;
  2383. if (peermacmib)
  2384. peermacmib->FrameDropTxa++;
  2386. switch (type)  {
  2388. case MAC_Type_Management:
  2389. macmib_.MgmtFrameDropTxa++;
  2390. if (peermacmib)
  2391. peermacmib->MgmtFrameDropTxa++;
  2392. break;
  2394. case MAC_Type_Control:
  2395. macmib_.CtrlFrameDropTxa++;
  2396. if (peermacmib)
  2397. peermacmib->CtrlFrameDropTxa++;
  2398. break;
  2400. case MAC_Type_Data:
  2401. macmib_.DataFrameDropTxa++;
  2402. if (peermacmib)
  2403. peermacmib->DataFrameDropTxa++;
  2404. break;
  2406. default:
  2407. fprintf(stderr,"Mac802_11mr::incFrameReceives() unknown MAC_typen");
  2408. assert(0);
  2409. break;
  2410. }
  2412. Mac80211EventHandler* mehptr = mehlist_;
  2413. while(mehptr) {
  2414. mehptr->counterHandle(ID_FrameDropTxa);
  2415. mehptr = mehptr->next;
  2416. }
  2417. }
  2420. void Mac802_11mr::incACKFailed(u_int32_t dst)
  2421. {
  2422. macmib_.ACKFailed++;
  2424. MR_MAC_MIB* peermacmib = 0;
  2425. if (peerstatsdb_) 
  2426. peermacmib = peerstatsdb_->getPeerStats((u_int32_t)index_, dst)->macmib;
  2427. if (peermacmib)
  2428. peermacmib->ACKFailed++;       
  2430. Mac80211EventHandler* mehptr = mehlist_;
  2431. while(mehptr) {
  2432. mehptr->counterHandle(ID_ACKFailed);
  2433. mehptr = mehptr->next;
  2434. }
  2435. }
  2437. void Mac802_11mr::incRTSFailed(u_int32_t dst)
  2438. {
  2439. macmib_.RTSFailed++;
  2441. MR_MAC_MIB* peermacmib = 0;
  2442. if (peerstatsdb_) 
  2443. peermacmib = peerstatsdb_->getPeerStats((u_int32_t)index_, dst)->macmib;
  2444. if (peermacmib)
  2445. peermacmib->RTSFailed++;       
  2447. Mac80211EventHandler* mehptr = mehlist_;
  2448. while(mehptr) {
  2449. mehptr->counterHandle(ID_RTSFailed);
  2450. mehptr = mehptr->next;
  2451. }
  2452. }
  2454. void Mac802_11mr::incMPDURxSuccessful(u_int32_t src)
  2455. {
  2456. macmib_.MPDURxSuccessful++;
  2458. MR_MAC_MIB* peermacmib = 0;
  2459. if (peerstatsdb_) 
  2460. peermacmib = peerstatsdb_->getPeerStats(src, (u_int32_t)index_)->macmib;
  2461. if (peermacmib)
  2462. peermacmib->MPDURxSuccessful++;       
  2464. Mac80211EventHandler* mehptr = mehlist_;
  2465. while(mehptr) {
  2466. mehptr->counterHandle(ID_MPDURxSuccessful);
  2467. mehptr = mehptr->next;
  2468. }
  2469. }
  2471. void Mac802_11mr::incMPDUTxSuccessful(u_int32_t dst)
  2472. {
  2473. macmib_.MPDUTxSuccessful++;
  2476. MR_MAC_MIB* peermacmib = 0;
  2477. if (peerstatsdb_) 
  2478. peermacmib = peerstatsdb_->getPeerStats((u_int32_t)index_, dst)->macmib;
  2479. if (peermacmib)
  2480. peermacmib->MPDUTxSuccessful++;       
  2482. Mac80211EventHandler* mehptr = mehlist_;
  2483. while(mehptr) {
  2484. mehptr->counterHandle(ID_MPDUTxSuccessful);
  2485. mehptr = mehptr->next;
  2486. }
  2487. }
  2489. void Mac802_11mr::incMPDUTxOneRetry(u_int32_t dst)
  2490. {
  2491. macmib_.MPDUTxOneRetry++;
  2493. MR_MAC_MIB* peermacmib = 0;
  2494. if (peerstatsdb_) 
  2495. peermacmib = peerstatsdb_->getPeerStats((u_int32_t)index_, dst)->macmib;
  2496. if (peermacmib)
  2497. peermacmib->MPDUTxOneRetry++;       
  2499. Mac80211EventHandler* mehptr = mehlist_;
  2500. while(mehptr) {
  2501. mehptr->counterHandle(ID_MPDUTxOneRetry);
  2502. mehptr = mehptr->next;
  2503. }
  2504. }
  2506. void Mac802_11mr::incMPDUTxMultipleRetries(u_int32_t dst)
  2507. {
  2508. macmib_.MPDUTxMultipleRetries++;
  2510. MR_MAC_MIB* peermacmib = 0;
  2511. if (peerstatsdb_) 
  2512. peermacmib = peerstatsdb_->getPeerStats((u_int32_t)index_, dst)->macmib;
  2513. if (peermacmib)
  2514. peermacmib->MPDUTxMultipleRetries++;       
  2516. Mac80211EventHandler* mehptr = mehlist_;
  2517. while(mehptr) {
  2518. mehptr->counterHandle(ID_MPDUTxMultipleRetries);
  2519. mehptr = mehptr->next;
  2520. }
  2521. }
  2523. void Mac802_11mr::incMPDUTxFailed(u_int32_t dst)
  2524. {
  2525. macmib_.MPDUTxFailed++;
  2527. MR_MAC_MIB* peermacmib = 0;
  2528. if (peerstatsdb_) 
  2529. peermacmib = peerstatsdb_->getPeerStats((u_int32_t)index_, dst)->macmib;
  2530. if (peermacmib)
  2531. peermacmib->MPDUTxFailed++;       
  2533. Mac80211EventHandler* mehptr = mehlist_;
  2534. while(mehptr) {
  2535. mehptr->counterHandle(ID_MPDUTxFailed);
  2536. mehptr = mehptr->next;
  2537. }
  2538. }
  2541. void Mac802_11mr::incidleSlots(int step)
  2542. {
  2543. assert(step>=0);
  2544. macmib_.idleSlots += step;
  2546. Mac80211EventHandler* mehptr = mehlist_;
  2547. while(mehptr) {
  2548. mehptr->counterHandle(ID_idleSlots);
  2549. mehptr = mehptr->next;
  2550. }
  2551. }
  2553. void Mac802_11mr::incidle2Slots(int step)
  2554. {
  2555. assert(step>=0);
  2556. //  cout << NOW
  2557. //       << " node " << index_ 
  2558. //       << " idle2Slots " << macmib_.idle2Slots 
  2559. //       << " step " << step
  2560. //       << endl;
  2561. macmib_.idle2Slots += step;
  2563. Mac80211EventHandler* mehptr = mehlist_;
  2564. while(mehptr) {
  2565. mehptr->counterHandle(ID_idle2Slots);
  2566. mehptr = mehptr->next;
  2567. }
  2568. }
  2572. void Mac802_11mr::updateIdleTime(double nextIdleTime, int mode)
  2573. {
  2574. assert(nextIdleTime > 0);
  2575. double now = Scheduler::instance().clock();
  2576. nextIdleTime += now;
  2580. if (macmib_.startIdle2Time < now) {
  2581. // channel has been idle up to now
  2582. incidle2Slots(int ((now - macmib_.startIdle2Time)/phymib_.getSlotTime()));
  2583. macmib_.startIdle2Time_min = now;
  2584. }
  2586. switch (mode) {
  2588. case UIT_FORCED:
  2589. macmib_.startIdle2Time_min = std::max(nextIdleTime, macmib_.startIdle2Time_min);
  2590. macmib_.startIdle2Time = macmib_.startIdle2Time_min;
  2591. break;
  2593. case UIT_NORMAL:
  2594. if (nextIdleTime > macmib_.startIdle2Time) {
  2595. macmib_.startIdle2Time_min   = nextIdleTime;
  2596. macmib_.startIdle2Time       = nextIdleTime;
  2597. }
  2598. break;
  2600. case UIT_WEAK:
  2601. macmib_.startIdle2Time = nextIdleTime;
  2602. break;
  2604. default:
  2605. assert(0);
  2606. break;
  2607. }
  2609. }
  2614. void Mac802_11mr::updateSnr(u_int32_t src, u_int32_t dst, double snr)
  2615. {
  2616. if (dst == (u_int32_t)index_) {
  2617. if (peerstatsdb_) {
  2618. PeerStats* ps = peerstatsdb_->getPeerStats(src, (u_int32_t)index_);
  2619. assert(ps);
  2620. ps->updateSnr(snr);
  2621. }
  2622. }
  2623. if (src == bss_id()) {
  2624. phymib_.setAPSnr(snr);
  2625. }
  2626. }
  2629. void Mac802_11mr::updateSnir(u_int32_t src, u_int32_t dst, double snir)
  2630. {
  2631. if (dst == (u_int32_t)index_) {
  2632. if (peerstatsdb_) {
  2633. PeerStats* ps = peerstatsdb_->getPeerStats(src, (u_int32_t)index_);
  2634. assert(ps);
  2635. ps->updateSnir(snir);
  2636. }
  2637. }
  2638. }
  2641. void Mac802_11mr::updateInterf(u_int32_t src, u_int32_t dst, double interf)
  2642. {
  2643. if (dst == (u_int32_t)index_) {
  2644. if (peerstatsdb_) {
  2645. PeerStats* ps = peerstatsdb_->getPeerStats(src, (u_int32_t)index_);
  2646. assert(ps);
  2647. ps->updateInterf(interf);
  2648. }
  2649. }
  2650. }
  2654. double Mac802_11mr::getSnr(u_int32_t addr)
  2655. {
  2656. /* we assume it is better to exit if the requested stats
  2657.    are not available, since returning a bogus value might
  2658.    corrupt some algorithm */
  2659. assert(peerstatsdb_);
  2660. PeerStats* ps = peerstatsdb_->getPeerStats(addr, (u_int32_t)index_);
  2661. assert(ps);
  2662. return ps->getSnr();
  2663. }
  2665. double Mac802_11mr::getSnir(u_int32_t addr)
  2666. {
  2667. /* we assume it is better to exit if the requested stats
  2668.    are not available, since returning a bogus value might
  2669.    corrupt some algorithm */
  2670. assert(peerstatsdb_);
  2671. PeerStats* ps = peerstatsdb_->getPeerStats(addr, (u_int32_t)index_);
  2672. assert(ps);
  2673. return ps->getSnir();
  2674. }
  2676. double Mac802_11mr::getInterf(u_int32_t addr)
  2677. {
  2678. /* we assume it is better to exit if the requested stats
  2679.    are not available, since returning a bogus value might
  2680.    corrupt some algorithm */
  2681. assert(peerstatsdb_);
  2682. PeerStats* ps = peerstatsdb_->getPeerStats(addr, (u_int32_t)index_);
  2683. assert(ps);
  2684. return ps->getInterf();
  2685. }