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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 3G开发 > 查看源码
mac-802_11.cc
资源名称：NS2.rar　[点击查看]
上传用户：sdhqmy
上传日期：2015-12-07
资源大小：63k
文件大小：72k
源码类别：

3G开发

开发平台：

C/C++

mac-802_11.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.  * $Header: /nfs/jade/vint/CVSROOT/ns-2/mac/mac-802_11.cc,v 1.39 2002/03/14 01:12:53 haldar Exp $
  35.  *
  36.  * Ported from CMU/Monarch's code, nov'98 -Padma.
  37.  */
  39. #include "delay.h"
  40. #include "connector.h"
  41. #include "packet.h"
  42. #include "random.h"
  43. #include "mobilenode.h"
  45. // #define DEBUG 99
  47. #include "arp.h"
  48. #include "ll.h"
  49. #include "mac.h"
  50. #include "mac-timers.h"
  51. #include "mac-802_11.h"
  53. #include "cmu-trace.h"
  56. // XXX Can't we make these macros inline methods? Otherwise why should we have
  57. // inline methods at all??
  59. #define BEACON_BACKOFF_WINDOW  32
  60. //#define ATIM_WINDOW 0.02
  61. #define DEFAULT_CHANNEL 0
  63. #define CHECK_BACKOFF_TIMER()
  64. {
  65. if(is_idle() && mhBackoff_.paused())
  66. mhBackoff_.resume(difs_);
  67. if(! is_idle() && mhBackoff_.busy() && ! mhBackoff_.paused())
  68. mhBackoff_.pause();
  69. }
  71. #define TRANSMIT(p, t)                                                  
  72. {                                                                       
  73. tx_active_ = 1;                                                  
  74.                                                                         
  75.         /*                                                              
  76.          * If I'm transmitting without doing CS, such as when           
  77.          * sending an ACK, any incoming packet will be "missed"         
  78.          * and hence, must be discarded.                                
  79.          */                                                             
  80.         if(rx_state_ != MAC_IDLE) {                                      
  81.                 struct hdr_mac802_11 *dh = HDR_MAC802_11(p);                  
  82.                                                                         
  83.                 assert(dh->dh_fc.fc_type == MAC_Type_Control);          
  84.                 assert(dh->dh_fc.fc_subtype == MAC_Subtype_ACK);        
  85.                                                                         
  86.                 assert(pktRx_);                                          
  87.                 struct hdr_cmn *ch = HDR_CMN(pktRx_);                    
  88.                                                                         
  89.                 ch->error() = 1;        /* force packet discard */      
  90.         }                                                               
  91.                                                                         
  92.         /*                                                              
  93.          * pass the packet on the "interface" which will in turn        
  94.          * place the packet on the channel.                             
  95.          *                                                              
  96.          * NOTE: a handler is passed along so that the Network          
  97.          *       Interface can distinguish between incoming and         
  98.          *       outgoing packets.                                      
  99.          */                                                             
  100. downtarget_->recv(p->copy(), this);
  101.         mhSend_.start(t);                                                
  102.                                                                         
  103. mhIF_.start(txtime(p));                                         
  104. }
  106. //It was p->copy(), 8 lines above
  108. #define SET_RX_STATE(x)
  109. {
  110. rx_state_ = (x);
  111. CHECK_BACKOFF_TIMER();
  112. }
  114. #define SET_TX_STATE(x)
  115. {
  116. tx_state_ = (x);
  117. CHECK_BACKOFF_TIMER();
  118. }
  120. #define SET_DX_STATE(x)
  121. {
  122. dx_state_ = (x);
  123. CHECK_BACKOFF_TIMER();
  124. }
  125. /* ======================================================================
  126.    Global Variables
  127.    ====================================================================== */
  129. static PHY_MIB PMIB =
  130. {
  131. DSSS_CWMin, DSSS_CWMax, DSSS_SlotTime, DSSS_CCATime,
  132. DSSS_RxTxTurnaroundTime, DSSS_SIFSTime, DSSS_PreambleLength,
  133. DSSS_PLCPHeaderLength, DSSS_PLCPDataRate
  134. };
  136. static MAC_MIB MMIB =
  137. {
  138. MAC_RTSThreshold, MAC_ShortRetryLimit,
  139. MAC_LongRetryLimit, MAC_FragmentationThreshold,
  140. MAC_MaxTransmitMSDULifetime, MAC_MaxReceiveLifetime,
  141. //JUNGMIN
  142. 100 /* BeaconPeriod */, 20 /* ATIMWindowSize */,
  143. //end of JUNGMIN
  144. 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  145. };
  147. /* ======================================================================
  148.    TCL Hooks for the simulator
  149.    ====================================================================== */
  150. static class Mac802_11Class : public TclClass {
  151. public:
  152. Mac802_11Class() : TclClass("Mac/802_11") {}
  153. TclObject* create(int, const char*const*) {
  154. return (new Mac802_11(&PMIB, &MMIB));
  155. }
  156. } class_mac802_11;
  159. /* ======================================================================
  160.    Mac Class Functions
  161.    ====================================================================== */
  162. Mac802_11::Mac802_11(PHY_MIB *p, MAC_MIB *m) : Mac(), mhIF_(this), mhNav_(this), mhRecv_(this), mhRecvDATA_(this), mhSend_(this), mhDefer_(this, p->SlotTime), mhBackoff_(this, p->SlotTime)
  163. //JUNGMIN
  164. ,mhBeacon_(this), mhBeaconBackoff_(this), mhATIMWindow_(this)
  165. ,mhWait_(this) 
  166. //end of JUNGMIN
  167. {
  168. macmib_ = m;
  169. phymib_ = p;
  171. nav_ = 0.0;
  173. //JUNGMIN
  174. mhChannelUsage_ = new ChannelUsageTimer[NUMBER_OF_CHANNELS](this);
  176. //initialize Free Channel List and Channel NAV
  177. for(int i=0; i<NUMBER_OF_CHANNELS; i++) {
  179. fcl_[i] = 0;
  181. dca_cul_[i] = 0.0;
  183. mhChannelUsage_[i].AssignChannel(i);
  184. }
  185. selected_channel_ = -1;
  186. active_channel_ = 0;
  187. ready_for_atim_ = 0;
  188. next_beacon_time_ = 0;
  189. recved_bytes_ = 0;
  191. ResetDestInfo();
  192. //end of JUNGMIN
  194. tx_state_ = rx_state_ = dx_state_ = MAC_IDLE;
  195. tx_active_ = 0;
  197. pktRTS_ = 0;
  198. pktCTRL_ = 0;
  199. pktRSH_ = 0;
  201. //JUNGMIN
  202. pktATIM_ = 0;
  203. pktATIMACK_ = 0;
  204. pktATIMRSH_ = 0;
  206. pktDx_ = 0;
  207. pktPending_ = 0;
  208. //end of JUNGMIN
  210. cw_ = phymib_->CWMin;
  211. ssrc_ = slrc_ = 0;
  212. //JUNGMIN
  213. sarc_ = 0;
  214. //end of JUNGMIN
  216. packet_count_ = 0;
  217. total_delay_ = 0.0;
  219. sifs_ = phymib_->SIFSTime;
  220. pifs_ = sifs_ + phymib_->SlotTime;
  221. difs_ = sifs_ + 2*phymib_->SlotTime;
  223. // see (802.11-1999, 9.2.10) 
  224. eifs_ = sifs_ + (8 * ETHER_ACK_LEN / phymib_->PLCPDataRate) + difs_;
  226. tx_sifs_ = sifs_ - phymib_->RxTxTurnaroundTime;
  227. tx_pifs_ = tx_sifs_ + phymib_->SlotTime;
  228. tx_difs_ = tx_sifs_ + 2 * phymib_->SlotTime;
  230. sta_seqno_ = 1;
  231. cache_ = 0;
  232. cache_node_count_ = 0;
  234. //JUNGMIN
  235. pc_ = 0;
  236. btbs_ = 0;
  237. atim_window_ = 0;
  239. dca_ = 0;
  241. //end of JUNGMIN
  243. // chk if basic/data rates are set
  244. // otherwise use bandwidth_ as default;
  246. Tcl& tcl = Tcl::instance();
  247. tcl.evalf("Mac/802_11 set basicRate_");
  248. if (strcmp(tcl.result(), "0") != 0) 
  249. bind_bw("basicRate_", &basicRate_);
  250. else
  251. basicRate_ = bandwidth_;
  253. tcl.evalf("Mac/802_11 set dataRate_");
  254. if (strcmp(tcl.result(), "0") != 0) 
  255. bind_bw("dataRate_", &dataRate_);
  256. else
  257. dataRate_ = bandwidth_;
  259. }
  262. int
  263. Mac802_11::command(int argc, const char*const* argv)
  264. {
  265. if (argc == 3) {
  266. if (strcmp(argv[1], "log-target") == 0) {
  267. logtarget_ = (NsObject*) TclObject::lookup(argv[2]);
  268. if(logtarget_ == 0)
  269. return TCL_ERROR;
  270. return TCL_OK;
  271. } else if(strcmp(argv[1], "nodes") == 0) {
  272. if(cache_) return TCL_ERROR;
  273. cache_node_count_ = atoi(argv[2]);
  274. cache_ = new Host[cache_node_count_ + 1];
  275. assert(cache_);
  276. bzero(cache_, sizeof(Host) * (cache_node_count_+1 ));
  277. return TCL_OK;
  278. }
  279. //JUNGMIN
  280. //Sets the beacon period
  281.   else if(strcmp(argv[1], "beaconperiod") == 0) {
  282. macmib_->dot11BeaconPeriod = atoi(argv[2]);
  283. return TCL_OK; 
  284. } else if(strcmp(argv[1], "atimwindowsize") == 0) {
  286. macmib_->dot11ATIMWindowSize = atoi(argv[2]);
  287. return TCL_OK;
  288. }
  289. }
  290. else if(argc == 2) {
  291. //Let this node be the Point Coordinator 
  292. if(strcmp(argv[1], "make-pc") == 0) {
  294. pc_ = 1;
  295. mhBeacon_.start(macmib_->dot11BeaconPeriod*0.001000);
  296. next_beacon_time_ = NOW + (macmib_->dot11BeaconPeriod * 0.001000);
  297. return TCL_OK;
  298. } else if(strcmp(argv[1], "recved_bytes") == 0) {
  300. printf("%dn", recved_bytes_);
  301. fflush(stdout);
  302. return TCL_OK;
  303. } else if(strcmp(argv[1], "average_delay") == 0) {
  304. if(packet_count_ != 0) {
  305. printf("%lfn", (total_delay_ / (double)packet_count_));
  306. } else {
  307. printf("");
  308. }
  309. fflush(stdout);
  310. return TCL_OK;
  311. } else if(strcmp(argv[1], "dca") == 0) {
  312. dca_ = 1;
  313. return TCL_OK;
  314. }
  316. //end of JUNGMIN
  317. }
  319. return Mac::command(argc, argv);
  320. }
  322. /* ======================================================================
  323.    Debugging Routines
  324.    ====================================================================== */
  325. void
  326. Mac802_11::trace_pkt(Packet *p) {
  327. struct hdr_cmn *ch = HDR_CMN(p);
  328. struct hdr_mac802_11* dh = HDR_MAC802_11(p);
  329. u_int16_t *t = (u_int16_t*) &dh->dh_fc;
  331. fprintf(stderr, "t[ %2x %2x %2x %2x ] %x %s %dn",
  332. *t, dh->dh_duration,
  333. ETHER_ADDR(dh->dh_da), ETHER_ADDR(dh->dh_sa),
  334. index_, packet_info.name(ch->ptype()), ch->size());
  335. }
  337. void
  338. Mac802_11::dump(char *fname)
  339. {
  340. fprintf(stderr,
  341. "n%s --- (INDEX: %d, time: %2.9f)n",
  342. fname, index_, Scheduler::instance().clock());
  344. fprintf(stderr,
  345. "ttx_state_: %x, rx_state_: %x, nav: %2.9f, idle: %dn",
  346. tx_state_, rx_state_, nav_, is_idle());
  348. fprintf(stderr,
  349. "tpktTx_: %x, pktRx_: %x, pktRTS_: %x, pktCTRL_: %x, callback: %xn",
  350. (int) pktTx_, (int) pktRx_, (int) pktRTS_,
  351. (int) pktCTRL_, (int) callback_);
  353. fprintf(stderr,
  354. "tDefer: %d, Backoff: %d (%d), Recv: %d, Timer: %d Nav: %dn",
  355. mhDefer_.busy(), mhBackoff_.busy(), mhBackoff_.paused(),
  356. mhRecv_.busy(), mhSend_.busy(), mhNav_.busy());
  357. fprintf(stderr,
  358. "tBackoff Expire: %fn",
  359. mhBackoff_.expire());
  360. }
  363. /* ======================================================================
  364.    Packet Headers Routines
  365.    ====================================================================== */
  366. inline int
  367. Mac802_11::hdr_dst(char* hdr, int dst )
  368. {
  369. struct hdr_mac802_11 *dh = (struct hdr_mac802_11*) hdr;
  370. //dst = (u_int32_t)(dst);
  372. if(dst > -2)
  373. STORE4BYTE(&dst, (dh->dh_da));
  375. return ETHER_ADDR(dh->dh_da);
  376. }
  378. inline int 
  379. Mac802_11::hdr_src(char* hdr, int src )
  380. {
  381. struct hdr_mac802_11 *dh = (struct hdr_mac802_11*) hdr;
  382. if(src > -2)
  383. STORE4BYTE(&src, (dh->dh_sa));
  384. return ETHER_ADDR(dh->dh_sa);
  385. }
  387. inline int 
  388. Mac802_11::hdr_type(char* hdr, u_int16_t type)
  389. {
  390. struct hdr_mac802_11 *dh = (struct hdr_mac802_11*) hdr;
  391. if(type)
  392. STORE2BYTE(&type,(dh->dh_body));
  393. return GET2BYTE(dh->dh_body);
  394. }
  397. /* ======================================================================
  398.    Misc Routines
  399.    ====================================================================== */
  400. inline int
  401. Mac802_11::is_idle()
  402. {
  403. if(rx_state_ != MAC_IDLE)
  404. return 0;
  405. if(tx_state_ != MAC_IDLE)
  406. return 0;
  407. if(dx_state_ != MAC_IDLE)
  408. return 0;
  409. if(nav_ > Scheduler::instance().clock())
  410. return 0;
  411. return 1;
  412. }
  414. inline int
  415. Mac802_11::is_channel_idle(int ch)
  416. {
  417. if(rx_state_ != MAC_IDLE)
  418. return 0;
  419. if(tx_state_ != MAC_IDLE)
  420. return 0;
  421. return 1;
  422. }
  424. void
  425. Mac802_11::discard(Packet *p, const char* why)
  426. {
  427. hdr_mac802_11* mh = HDR_MAC802_11(p);
  428. hdr_cmn *ch = HDR_CMN(p);
  430. #if 0
  431. /* old logic 8/8/98 -dam */
  432. /*
  433.  * If received below the RXThreshold, then just free.
  434.  */
  435. if(p->txinfo_.Pr < p->txinfo_.ant.RXThresh) {
  436. Packet::free(p);
  437. //p = 0;
  438. return;
  439. }
  440. #endif // 0
  442. /* if the rcvd pkt contains errors, a real MAC layer couldn't
  443.    necessarily read any data from it, so we just toss it now */
  444. if(ch->error() != 0) {
  445. Packet::free(p);
  446. //p = 0;
  447. return;
  448. }
  450. switch(mh->dh_fc.fc_type) {
  451. case MAC_Type_Management:
  452. //drop(p, why);
  453. break;
  454. case MAC_Type_Control:
  455. switch(mh->dh_fc.fc_subtype) {
  456. case MAC_Subtype_DRTS:
  457. case MAC_Subtype_RTS:
  458. if((u_int32_t)ETHER_ADDR(mh->dh_sa) == 
  459.    (u_int32_t)index_) {
  460. drop(p, why);
  461. return;
  462. }
  463. /* fall through - if necessary */
  464. case MAC_Subtype_DCTS:
  465. case MAC_Subtype_DRSH:
  466. case MAC_Subtype_CTS:
  467. case MAC_Subtype_ACK:
  468. if((u_int32_t)ETHER_ADDR(mh->dh_da) == 
  469.    (u_int32_t)index_) {
  470. drop(p, why);
  471. return;
  472. }
  473. break;
  474. default:
  475. fprintf(stderr, "invalid MAC Control subtypen");
  476. exit(1);
  477. }
  478. break;
  479. case MAC_Type_Data:
  480. switch(mh->dh_fc.fc_subtype) {
  481. case MAC_Subtype_Data:
  482. if((u_int32_t)ETHER_ADDR(mh->dh_da) == 
  483.    (u_int32_t)index_ ||
  484.    (u_int32_t)ETHER_ADDR(mh->dh_sa) == 
  485.    (u_int32_t)index_ ||
  486.    (u_int32_t)ETHER_ADDR(mh->dh_da) == MAC_BROADCAST) {
  487. drop(p);
  488. return;
  489. }
  490. break;
  491. default:
  492. fprintf(stderr, "invalid MAC Data subtypen");
  493. exit(1);
  494. }
  495. break;
  496. default:
  497. fprintf(stderr, "invalid MAC type (%x)n", mh->dh_fc.fc_type);
  498. trace_pkt(p);
  499. exit(1);
  500. }
  501. Packet::free(p);
  502. }
  504. void
  505. Mac802_11::capture(Packet *p)
  506. {
  507. /*
  508.  * Update the NAV so that this does not screw
  509.  * up carrier sense.
  510.  */
  511. set_nav(usec(eifs_ + txtime(p)));
  512. Packet::free(p);
  513. }
  515. void
  516. Mac802_11::collision(Packet *p)
  517. {
  518. switch(rx_state_) {
  519. case MAC_RECV:
  520. SET_RX_STATE(MAC_COLL);
  521. /* fall through */
  522. case MAC_COLL:
  523. assert(pktRx_);
  524. assert(mhRecv_.busy());
  525. /*
  526.  *  Since a collision has occurred, figure out
  527.  *  which packet that caused the collision will
  528.  *  "last" the longest.  Make this packet,
  529.  *  pktRx_ and reset the Recv Timer if necessary.
  530.  */
  531. if(txtime(p) > mhRecv_.expire()) {
  532. mhRecv_.stop();
  533. discard(pktRx_, DROP_MAC_COLLISION);
  534. pktRx_ = p;
  535. mhRecv_.start(txtime(pktRx_));
  536. }
  537. else {
  538. discard(p, DROP_MAC_COLLISION);
  539. }
  540. break;
  541. default:
  542. assert(0);
  543. }
  544. }
  546. //JUNGMIN
  547. //When a node becomes available to transmit a packet, it checks whether
  548. //there is a packet that needs to be sent.
  549. //end of JUNGMIN
  551. void
  552. Mac802_11::tx_resume()
  553. {
  554. assert(mhSend_.busy() == 0);
  555. assert(mhDefer_.busy() == 0);
  557. //JUNGMIN
  558. if(btbs_) {
  559. btbs_ = 0;
  560. send_beacon();
  561. }
  562. //end of JUNGMIN
  564. //Shouldn't we use else if?
  565. if(pktCTRL_) {
  566. //printf("[%d] tx_resume(): Control Packet Ready.n", index_); 
  567. /*
  568.  *  Need to send a CTS or ACK.
  569.  */
  570. mhDefer_.start(sifs_);
  571. } 
  572. //JUNGMIN
  573. else if(pktATIMRSH_) {
  574. mhDefer_.start(sifs_);
  575. }
  577. else if(pktATIMACK_) {
  578. mhDefer_.start(sifs_);
  579. }
  581. else if(pktPCF_) {
  582. if(mhBackoff_.busy()) {
  583. mhBackoff_.stop();
  584. }
  585. mhDefer_.start(sifs_);
  586. }
  588. else if(pktATIM_) {
  589. if(mhBackoff_.busy() == 0) 
  590. mhDefer_.start(difs_);
  591. }
  592. //end of JUNGMIN
  593. else if(pktRTS_) { 
  594. if(mhBackoff_.busy() == 0)
  595. mhDefer_.start(difs_);
  596. } else if(pktTx_) {
  597. if(mhBackoff_.busy() == 0)
  598. {
  599. hdr_cmn *ch = HDR_CMN(pktTx_);
  600. struct hdr_mac802_11 *mh = HDR_MAC802_11(pktTx_);
  602. if ((u_int32_t) ch->size() < macmib_->RTSThreshold ||
  603.     (u_int32_t) ETHER_ADDR(mh->dh_da) == MAC_BROADCAST) {
  604. mhDefer_.start(difs_);
  605. } else {
  606. //JUNGMIN
  607. //this is because there has been RTS/CTS exchange
  608. //end of JUNGMIN
  609. mhDefer_.start(sifs_);
  610. }
  611. }
  612. //JUNGMIN
  613. //because of this callback, send function can just return if it is during
  614. //backoff. Here callback is Interface Queue.
  615. //end of JUNGMIN
  616. } else if(callback_) {
  618. Handler *h = callback_;
  619. callback_ = 0;
  621. if(pktPending_ != 0 && mhWait_.busy() == 0) {
  622. Packet *p = pktPending_;
  623. pktPending_ = 0;
  624. send(p, h);
  625. } else {
  626. h->handle((Event*) 0);
  627. }
  628. }
  629. SET_TX_STATE(MAC_IDLE);
  630. }
  632. void
  633. Mac802_11::rx_resume()
  634. {
  635. assert(pktRx_ == 0);
  636. assert(mhRecv_.busy() == 0);
  637. SET_RX_STATE(MAC_IDLE);
  638. }
  640. void
  641. Mac802_11::dx_resume()
  642. {
  643. assert(pktDx_ == 0);
  644. assert(mhRecvDATA_.busy() == 0);
  645. SET_DX_STATE(MAC_IDLE);
  646. }
  648. /* ======================================================================
  649.    Timer Handler Routines
  650.    ====================================================================== */
  651. void
  652. Mac802_11::backoffHandler()
  653. {
  654. if(pktCTRL_) {
  655. assert(mhSend_.busy() || mhDefer_.busy());
  656. return;
  657. }
  659. if(check_pktPCF() == 0)
  660. return;
  662. if(pktATIMRSH_) {
  663. return;
  664. }
  666. if(pktATIMACK_) {
  667. return;
  668. }
  670. //JUNGMIN
  671. if(check_pktATIM() == 0)
  672. return;
  673. //end of JUNGMIN
  675. if(pktTx_) {
  677. if(atim_window_ == 1 || NearBeacon(pktTx_, 1)) {
  679. ll_->ifq()->ReturnPacket(pktTx_);
  681. if(pktRTS_ != 0) 
  682. Packet::free(pktRTS_); pktRTS_ = 0;
  684. pktTx_ = 0;
  685. }
  686. }
  688. if(check_pktRTS() == 0)
  689. return;
  691. if(check_pktTx() == 0)
  692. return;
  693. }
  695. void
  696. Mac802_11::deferHandler()
  697. {
  699. //JUNGMIN
  700. assert(pktCTRL_ || pktRTS_ || pktTx_ || pktPCF_ || pktATIM_ || pktATIMACK_ || pktATIMRSH_);
  701. //end of JUNGMIN
  703. if(check_pktCTRL() == 0)
  704. return;
  706. if(check_pktPCF() == 0)
  707. return;
  708. //JUNGMIN
  709. if(check_pktATIMRSH() == 0)
  710. return;
  712. if(check_pktATIMACK() == 0)
  713. return;
  715. if(check_pktATIM() == 0)
  716. return;
  717. //end of JUNGMIN
  719. assert(mhBackoff_.busy() == 0);
  720. if(check_pktRTS() == 0)
  721. return;
  723. if(check_pktTx() == 0)
  724. return;
  725. }
  727. void
  728. Mac802_11::navHandler()
  729. {
  730. if(is_idle() && mhBackoff_.paused())
  731. mhBackoff_.resume(difs_);
  732. }
  734. void
  735. Mac802_11::channelusageHandler(int ch)
  736. {
  737. if(ch < NUMBER_OF_CHANNELS) {
  738. dca_cul_[ch] = 0;
  739. } else {
  740. printf("ERROR: Trying to access non-existing channeln");
  741. }
  742. }
  744. void
  745. Mac802_11::waitHandler()
  746. {
  748. }
  750. //JUNGMIN
  751. void
  752. Mac802_11::atimHandler()
  753. {
  755. atim_window_ = 0;
  756. ready_for_atim_ = 0;
  758. if(selected_channel_ == -1) active_channel_ = 0; //Default channel
  759. else active_channel_ = selected_channel_;
  761. if(index_ < 18 && index_ >= 0) {
  762. }
  764. if(btbs_) {
  765. btbs_ = 0;
  766. }
  768. if(callback_ == 0) {
  769. ll_->ifq()->ResetATIMWindow(1);
  770. }
  771. else {
  772. ll_->ifq()->ResetATIMWindow(0);
  773. }
  774. //status parameter 0: not idle 1: idle
  775. // if idle, this function should callback the queue
  776. // explicitly to send packets. 
  777. }
  778. //end of JUNGMIN
  780. void
  781. Mac802_11::recvHandler()
  782. {
  783. recv_timer();
  784. }
  786. void
  787. Mac802_11::recvDATAHandler()
  788. {
  789. recvDATA_timer();
  790. }
  792. void
  793. Mac802_11::sendHandler()
  794. {
  795. send_timer();
  796. }
  799. void
  800. Mac802_11::txHandler()
  801. {
  802. tx_active_ = 0;
  803. }
  806. //JUNGMIN
  807. void
  808. Mac802_11::beaconHandler()
  809. {
  810. //Schedule the next beacon
  811. mhBeacon_.start(macmib_->dot11BeaconPeriod*0.001000);
  812. next_beacon_time_ = NOW + (macmib_->dot11BeaconPeriod * 0.001000);
  814. ResetAtBeacon();
  815. SetATIMWindow();
  816. if(mhATIMWindow_.busy())
  817. mhATIMWindow_.stop();
  818. mhATIMWindow_.start(macmib_->dot11ATIMWindowSize*0.001000);
  820. //Distribute Beacon
  821. //Instead of sending beacon right away, wait for a certain amount of time.
  823. prepare_beacon();
  825. }
  827. void
  828. Mac802_11::beaconBackoffHandler()
  829. {
  830. //printf("[%d] %lf: beaconBackoffHandler Called.n", index_, NOW);
  831. send_beacon();
  832. }
  833. //end of JUNGMIN
  836. /* ======================================================================
  837.    The "real" Timer Handler Routines
  838.    ====================================================================== */
  839. void
  840. Mac802_11::send_timer()
  841. {
  843. switch(tx_state_) {
  845. case MAC_ATIM:
  846. RetransmitATIM();
  847. break;
  849. case MAC_ATIMACK:
  850. assert(pktATIMACK_);
  851. Packet::free(pktATIMACK_); pktATIMACK_ = 0;
  852. break;
  854. case MAC_ATIMRSH:
  855. assert(pktATIMRSH_);
  856. Packet::free(pktATIMRSH_); pktATIMRSH_ = 0;
  857. break;
  859. /*
  860.  * Sent a RTS, but did not receive a CTS.
  861.  */
  862. case MAC_RTS:
  863. RetransmitRTS();
  864. break;
  865. /*
  866.  * Sent a CTS, but did not receive a DATA packet.
  867.  */
  868. case MAC_CTS:
  869. assert(pktCTRL_);
  870. Packet::free(pktCTRL_); pktCTRL_ = 0;
  871. break;
  872. /*
  873.  * Sent DATA, but did not receive an ACK packet.
  874.  */
  875. case MAC_SEND:
  876. if(pktRSH_) {
  877. Packet::free(pktRSH_); pktRSH_ = 0;
  878. //only for now
  879. RetransmitDATA();
  880. } else {
  881. RetransmitDATA();
  882. }
  883. break;
  884. /*
  885.  * Sent an ACK, and now ready to resume transmission.
  886.  */
  887. case MAC_ACK:
  888. assert(pktCTRL_);
  889. Packet::free(pktCTRL_); pktCTRL_ = 0;
  890. break;
  891. //JUNGMIN
  892. case MAC_BEACONING:
  893. if(pktPCF_) {
  894. Packet::free(pktPCF_); pktPCF_ = 0;
  895. }
  896. break;
  897. //end of JUNGMIN
  898. case MAC_IDLE:
  899. break;
  900. default:
  901. assert(0);
  902. }
  903. tx_resume();
  904. }
  907. /* ======================================================================
  908.    Outgoing Packet Routines
  909.    ====================================================================== */
  910. int
  911. Mac802_11::check_pktCTRL()
  912. {
  913. struct hdr_mac802_11 *mh;
  914. double timeout;
  916. if(pktCTRL_ == 0)
  917. return -1;
  918. if(tx_state_ == MAC_CTS || tx_state_ == MAC_ACK)
  919. return -1;
  921. mh = HDR_MAC802_11(pktCTRL_);
  922. struct dca_cts_frame *dcts;
  923.   
  924. switch(mh->dh_fc.fc_subtype) {
  925. /*
  926.  *  If the medium is not IDLE, don't send the CTS.
  927.  */
  928. case MAC_Subtype_CTS:
  929. if(!is_idle()) {
  930. discard(pktCTRL_, DROP_MAC_BUSY); pktCTRL_ = 0;
  931. return 0;
  932. }
  933. SET_TX_STATE(MAC_CTS);
  935. /*
  936.  * timeout:  cts + data tx time calculated by
  937.  *           adding cts tx time to the cts duration
  938.  *           minus ack tx time -- this timeout is
  939.  *           a guess since it is unspecified
  940.  *           (note: mh->dh_duration == cf->cf_duration)
  941.  */
  942. timeout = txtime(ETHER_CTS_LEN, basicRate_)
  943. + DSSS_MaxPropagationDelay // XXX
  944. + sec(mh->dh_duration)
  945. + DSSS_MaxPropagationDelay // XXX
  946. - sifs_
  947. - txtime(ETHER_ACK_LEN, basicRate_);
  949. break;
  950. /*
  951.  * IEEE 802.11 specs, section 9.2.8
  952.  * Acknowledments are sent after an SIFS, without regard to
  953.  * the busy/idle state of the medium.
  954.  */
  955. case MAC_Subtype_DCTS:
  956. if(!is_idle()) {
  957. discard(pktCTRL_, DROP_MAC_BUSY); pktCTRL_ = 0;
  958. return 0;
  959. }
  961. SET_TX_STATE(MAC_CTS);
  963. dcts = (struct dca_cts_frame*)pktCTRL_->access(hdr_mac::offset_);
  965. timeout = txtime(ETHER_DCTS_LEN, basicRate_)
  966. + DSSS_MaxPropagationDelay
  967. + dcts->dcts_usage_time
  968. + sifs_
  969. + DSSS_MaxPropagationDelay
  970. + DSSS_MaxPropagationDelay;
  972. if(dcts->dcts_selected_channel == -1) {
  973. timeout = txtime(ETHER_DCTS_LEN, basicRate_);
  974. }
  976. break;
  978. case MAC_Subtype_ACK:
  979. SET_TX_STATE(MAC_ACK);
  981. timeout = txtime(ETHER_ACK_LEN, basicRate_);
  983. break;
  984. default:
  985. fprintf(stderr, "check_pktCTRL:Invalid MAC Control subtypen");
  986. exit(1);
  987. }
  988. //JUNGMIN
  989. if(mh->dh_fc.fc_subtype == MAC_Subtype_CTS) {
  990. }
  991. else if(mh->dh_fc.fc_subtype == MAC_Subtype_DCTS) {
  992. }
  993. else if(mh->dh_fc.fc_subtype == MAC_Subtype_ACK) {
  994. }
  995. //end of JUNGMIN
  996.         TRANSMIT(pktCTRL_, timeout);
  997. return 0;
  998. }
  1000. //JUNGMIN
  1001. int
  1002. Mac802_11::check_pktATIMACK()
  1003. {
  1004. struct hdr_mac802_11 *mh;
  1005. double timeout;
  1007. if(pktATIMACK_ == 0)
  1008. return -1;
  1009. if(tx_state_ == MAC_ATIMACK)
  1010. return -1;
  1012. mh = HDR_MAC802_11(pktATIMACK_);
  1014. switch(mh->dh_fc.fc_subtype) {
  1016. case MAC_Subtype_ATIMACK:
  1018. SET_TX_STATE(MAC_ATIMACK);
  1020. timeout = txtime(ETHER_ATIMACK_LEN, basicRate_) ;
  1022. break;
  1024. default:
  1025. fprintf(stderr, "check_pktATIMACK: Invalid MAC Management subtypen");
  1026. exit(1);
  1027. }
  1029. TRANSMIT(pktATIMACK_, timeout);
  1030. return 0;
  1031. }
  1033. int
  1034. Mac802_11::check_pktATIMRSH()
  1035. {
  1036. struct hdr_mac802_11 *mh;
  1037. double timeout;
  1039. if(pktATIMRSH_ == 0)
  1040. return -1;
  1041. if(tx_state_ == MAC_ATIMRSH)
  1042. return -1;
  1044. mh = HDR_MAC802_11(pktATIMRSH_);
  1046. switch(mh->dh_fc.fc_subtype) {
  1048. case MAC_Subtype_ATIMRSH:
  1050. SET_TX_STATE(MAC_ATIMRSH);
  1052. timeout = txtime(ETHER_ATIMRSH_LEN, basicRate_) ;
  1054. break;
  1056. default:
  1057. fprintf(stderr, "check_pktATIMRSH: Invalid MAC Management subtypen");
  1058. exit(1);
  1059. }
  1061. TRANSMIT(pktATIMRSH_, timeout);
  1062. return 0;
  1063. }
  1064. //end of JUNGMIN
  1066. int
  1067. Mac802_11::check_pktRTS()
  1068. {
  1069. struct hdr_mac802_11 *mh;
  1070. double timeout;
  1072. assert(mhBackoff_.busy() == 0);
  1074. if(pktRTS_ == 0)
  1075.   return -1;
  1076. mh = HDR_MAC802_11(pktRTS_);
  1077. struct dca_rts_frame *drts;
  1079.   switch(mh->dh_fc.fc_subtype) {
  1080. case MAC_Subtype_RTS:
  1081. if(! is_idle()) {
  1082. inc_cw();
  1083. mhBackoff_.start(cw_, is_idle());
  1084. return 0;
  1085. }
  1086. SET_TX_STATE(MAC_RTS);
  1087. timeout = txtime(ETHER_RTS_LEN, basicRate_)
  1088. + DSSS_MaxPropagationDelay // XXX
  1089. + sifs_
  1090. + txtime(ETHER_CTS_LEN, basicRate_)
  1091. + DSSS_MaxPropagationDelay; // XXX
  1092. break;
  1093. case MAC_Subtype_DRTS:
  1094. if(! is_idle()) {
  1095. inc_cw();
  1096. mhBackoff_.start(cw_, is_idle());
  1097. return 0;
  1098. }
  1099. SET_TX_STATE(MAC_RTS);
  1100. timeout = txtime(ETHER_DRTS_LEN, basicRate_)
  1101. + DSSS_MaxPropagationDelay // XXX
  1102. + sifs_
  1103. + txtime(ETHER_DCTS_LEN, basicRate_)
  1104. + DSSS_MaxPropagationDelay; // XXX
  1106. drts = (struct dca_rts_frame*)pktRTS_->access(hdr_mac::offset_);
  1107. DCABuildFreeChannelList(drts->drts_channel_list);
  1109. break;
  1110. default:
  1111. fprintf(stderr, "check_pktRTS:Invalid MAC Control subtypen");
  1112. exit(1);
  1113. }
  1115.         TRANSMIT(pktRTS_, timeout);
  1116. return 0;
  1117. }
  1119. int
  1120. Mac802_11::check_pktATIM()
  1121. {
  1122. struct hdr_mac802_11 *mh;
  1123. double timeout;
  1125. assert(mhBackoff_.busy() == 0);
  1127. if(pktATIM_ == 0)
  1128. return -1;
  1130. mh = HDR_MAC802_11(pktATIM_);
  1132. struct atim_frame *atf = (struct atim_frame*)pktATIM_->access(hdr_mac::offset_);
  1134. switch(mh->dh_fc.fc_subtype) {
  1135. case MAC_Subtype_ATIM:
  1136. if(!is_idle()) {
  1137. inc_cw();
  1138. mhBackoff_.start(cw_, is_idle());
  1139. return 0;
  1140. }
  1141. SET_TX_STATE(MAC_ATIM);
  1142. timeout = txtime(ETHER_ATIM_LEN, basicRate_)
  1143. + DSSS_MaxPropagationDelay
  1144. + sifs_
  1145. + txtime(ETHER_ATIMACK_LEN, basicRate_)
  1146. + DSSS_MaxPropagationDelay;
  1147. break;
  1148. default:
  1149. fprintf(stderr, "check_pktATIM: Invalid MAC Management subtypen");
  1150. exit(1);
  1151. }
  1153. //copying my fcl_ onto the packet (SHOULD BE AS CLOSEST AS POSSIBLE TO ACTUAL SEND)
  1154. for(int j=0; j<NUMBER_OF_CHANNELS; j++) {
  1155. atf->atf_channel_list[j] = fcl_[j];
  1156. }
  1158. TRANSMIT(pktATIM_, timeout);
  1159. return 0;
  1160. }
  1162. int
  1163. Mac802_11::check_pktTx()
  1164. {
  1165. struct hdr_mac802_11 *mh;
  1166. double timeout;
  1168. assert(mhBackoff_.busy() == 0);
  1170. if(pktTx_ == 0)
  1171. return -1;
  1173. //if DCA mode, send DRSH also at the same time in different channel
  1175. mh = HDR_MAC802_11(pktTx_);
  1176.         int len = HDR_CMN(pktTx_)->size();
  1178. struct hdr_cmn *ch = HDR_CMN(pktTx_);
  1180. switch(mh->dh_fc.fc_subtype) {
  1181. case MAC_Subtype_Data:
  1182. if(! is_idle()) {
  1183. if(dca_) {
  1184. sendDRTS(ETHER_ADDR(mh->dh_da));
  1185. } else {
  1186. sendRTS(ETHER_ADDR(mh->dh_da));
  1187. }
  1188. inc_cw();
  1189. mhBackoff_.start(cw_, is_idle());
  1190. return 0;
  1191. }
  1192. SET_TX_STATE(MAC_SEND);
  1193. if((u_int32_t)ETHER_ADDR(mh->dh_da) != MAC_BROADCAST)
  1194. timeout = txtime(pktTx_)
  1195. + DSSS_MaxPropagationDelay // XXX
  1196. + sifs_
  1197. + txtime(ETHER_ACK_LEN, basicRate_)
  1198. + DSSS_MaxPropagationDelay; // XXX
  1199. else
  1200. timeout = txtime(pktTx_);
  1201. break;
  1202. default:
  1203. fprintf(stderr, "check_pktTx:Invalid MAC Control subtypen");
  1204. exit(1);
  1205. }
  1207. if(dca_) {
  1208. if((u_int32_t)ETHER_ADDR(mh->dh_da) != MAC_BROADCAST) {
  1209. if(active_channel_ == DEFAULT_CHANNEL || active_channel_ < 0) {
  1210. printf("ERROR: Cannot send data on this channel!n");
  1211. exit(1);
  1212. } else {
  1213. mh->dh_fc.fc_channel = active_channel_;
  1214. }
  1215. } else {
  1216. mh->dh_fc.fc_channel = DEFAULT_CHANNEL;
  1217. }
  1218. } else {
  1219. if(active_channel_ != -1)
  1220. mh->dh_fc.fc_channel = active_channel_;
  1221. else
  1222. mh->dh_fc.fc_channel = DEFAULT_CHANNEL;
  1223. }
  1225. if(dca_) {
  1226. if((u_int32_t)ETHER_ADDR(mh->dh_da) != MAC_BROADCAST) {
  1227. //TRANSMIT(pktRSH_, 0.0);
  1228. }
  1229. }
  1231.         TRANSMIT(pktTx_, timeout);
  1232. return 0;
  1233. }
  1235. //JUNGMIN
  1237. int
  1238. Mac802_11::check_pktPCF()
  1239. {
  1240. struct hdr_mac802_11 *mh;
  1241. double timeout;
  1243. //assert(mhBackoff_.busy() == 0);
  1245. if(pktPCF_ == 0)
  1246. return -1;
  1248. mh = HDR_MAC802_11(pktPCF_);
  1249. int len = HDR_CMN(pktPCF_)->size();
  1251. switch(mh->dh_fc.fc_type) {
  1252. case MAC_Type_Management:
  1253. switch(mh->dh_fc.fc_subtype) {
  1254. case MAC_Subtype_Beacon:
  1256. if(!is_idle())
  1257. return -1;
  1258. struct beacon_frame *beacon = (struct beacon_frame *)pktPCF_->access(hdr_mac::offset_);
  1259. timeout = txtime(pktPCF_);
  1260. SET_TX_STATE(MAC_BEACONING);
  1261. }
  1262. break;
  1263. default:
  1264. fprintf(stderr, "check_pktPCF:Invalid MAC (sub)typen");
  1266. exit(1);
  1267. }
  1269. TRANSMIT(pktPCF_, timeout);
  1271. //set a flag saying I sent a beacon
  1272. //It is also set when I receive the beacon
  1273. //This is to start sending ATIMs
  1274. if(ready_for_atim_ == 0) {
  1275. ready_for_atim_ = 1;
  1276. ll_->ifq()->StartSendingATIM();
  1277. }
  1279. return 0;
  1280. }
  1282. //end of JUNGMIN
  1284. /*
  1285.  * Low-level transmit functions that actually place the packet onto
  1286.  * the channel.
  1287.  */
  1288. void
  1289. Mac802_11::sendRTS(int dst)
  1290. {
  1291. Packet *p = Packet::alloc();
  1292. hdr_cmn* ch = HDR_CMN(p);
  1293. struct rts_frame *rf = (struct rts_frame*)p->access(hdr_mac::offset_);
  1295. //just for checking
  1296. struct hdr_mac802_11* dh = HDR_MAC802_11(p);
  1298. // sendDATA should be called before sendRTS
  1299. // this is to make sure that RTS be sent only when DATA is ready to be sent.
  1300. assert(pktTx_);
  1301. assert(pktRTS_ == 0);
  1303. /*
  1304.  *  If the size of the packet is larger than the
  1305.  *  RTSThreshold, then perform the RTS/CTS exchange.
  1306.  *
  1307.  *  XXX: also skip if destination is a broadcast
  1308.  */
  1309. if( (u_int32_t) HDR_CMN(pktTx_)->size() < macmib_->RTSThreshold ||
  1310.     (u_int32_t) dst == MAC_BROADCAST) {
  1311. Packet::free(p);
  1312. //p = 0;
  1313. return;
  1314. }
  1316. ch->uid() = 0;
  1317. ch->ptype() = PT_MAC;
  1318. ch->size() = ETHER_RTS_LEN;
  1319. ch->iface() = -2;
  1320. ch->error() = 0;
  1322. bzero(rf, MAC_HDR_LEN);
  1324. rf->rf_fc.fc_protocol_version = MAC_ProtocolVersion;
  1325.   rf->rf_fc.fc_type = MAC_Type_Control;
  1326.   rf->rf_fc.fc_subtype = MAC_Subtype_RTS;
  1327.   rf->rf_fc.fc_to_ds = 0;
  1328.   rf->rf_fc.fc_from_ds = 0;
  1329.   rf->rf_fc.fc_more_frag = 0;
  1330.   rf->rf_fc.fc_retry = 0;
  1331.   rf->rf_fc.fc_pwr_mgt = 0;
  1332.   rf->rf_fc.fc_more_data = 0;
  1333.   rf->rf_fc.fc_wep = 0;
  1334.   rf->rf_fc.fc_order = 0;
  1337. if(active_channel_ != -1) {
  1338. rf->rf_fc.fc_channel = active_channel_;
  1339. }
  1340. else
  1341. rf->rf_fc.fc_channel = DEFAULT_CHANNEL;
  1343. //rf->rf_duration = RTS_DURATION(pktTx_);
  1344. STORE4BYTE(&dst, (rf->rf_ra));
  1346. /* store rts tx time */
  1347.   ch->txtime() = txtime(ch->size(), basicRate_);
  1349. STORE4BYTE(&index_, (rf->rf_ta));
  1350. /* calculate rts duration field */
  1351. rf->rf_duration = usec(sifs_
  1352.        + txtime(ETHER_CTS_LEN, basicRate_)
  1353.        + sifs_
  1354.        + txtime(pktTx_)
  1355.        + sifs_
  1356.        + txtime(ETHER_ACK_LEN, basicRate_));
  1358. pktRTS_ = p;
  1359. }
  1361. void
  1362. Mac802_11::sendDRTS(int dst)
  1363. {
  1364. Packet *p = Packet::alloc();
  1365. hdr_cmn* ch = HDR_CMN(p);
  1366. struct dca_rts_frame *drts = (struct dca_rts_frame*)p->access(hdr_mac::offset_);
  1368. assert(pktTx_);
  1369. assert(pktRTS_);
  1371. if( (u_int32_t) HDR_CMN(pktTx_)->size() < macmib_->RTSThreshold ||
  1372.             (u_int32_t) dst == MAC_BROADCAST) {
  1373. Packet::free(p);
  1374. return;
  1375. }
  1377. ch->uid() = 0;
  1378. ch->ptype() = PT_MAC;
  1379. ch->size() = ETHER_DRTS_LEN;
  1380. ch->iface() = -2;
  1381. ch->error() = 0;
  1383. bzero(drts, MAC_HDR_LEN);
  1385. drts->drts_fc.fc_protocol_version = MAC_ProtocolVersion;
  1386. drts->drts_fc.fc_type  = MAC_Type_Control;
  1387. drts->drts_fc.fc_subtype = MAC_Subtype_DRTS;
  1388. drts->drts_fc.fc_to_ds = 0;
  1389. drts->drts_fc.fc_from_ds = 0;
  1390. drts->drts_fc.fc_more_frag = 0;
  1391. drts->drts_fc.fc_retry = 0;
  1392. drts->drts_fc.fc_pwr_mgt = 0;
  1393. drts->drts_fc.fc_more_data = 0;
  1394. drts->drts_fc.fc_wep = 0;
  1395. drts->drts_fc.fc_order = 0;
  1397. drts->drts_fc.fc_channel = DEFAULT_CHANNEL;
  1399. STORE4BYTE(&dst, (drts->drts_da));
  1401. ch->txtime() = txtime(ch->size(), basicRate_);
  1403. STORE4BYTE(&index_, (drts->drts_sa));
  1405. drts->drts_duration = usec(sifs_
  1406. + txtime(ETHER_DCTS_LEN, basicRate_)
  1407. + sifs_
  1408. + txtime(ETHER_DRSH_LEN, basicRate_));
  1410. drts->drts_data_transfer_time = txtime(pktTx_);
  1412. pktRTS_ = p;
  1413. }
  1416. //JUNGMIN
  1417. void
  1418. Mac802_11::InsertDestState(int dst)
  1419. {
  1420. if(dst < 0 || dst > MAX_NODES) return;
  1421. dest_state_[dst] = 1;
  1422. return;
  1423. }
  1425. void
  1426. Mac802_11::InsertNeighborChannelState(int dst, int channel)
  1427. {
  1428. if(dst < 0 || dst > MAX_NODES) return;
  1429. channel_state_[dst] = channel;
  1430. return;
  1431. }
  1433. int
  1434. Mac802_11::LookupDestState(int dst)
  1435. {
  1436. if(dst < 0) return 0;
  1437. return dest_state_[dst];
  1439. }
  1441. int
  1442. Mac802_11::NearBeacon(Packet* p, int afterbackoff)
  1443. {
  1444. //if it is near beacon, return 1
  1445. if(pc_ == 0) return 0;
  1447. //if afterbackoff is 1, then exclude the first difs
  1449. hdr_cmn* ch = HDR_CMN(p);
  1450. int size = ch->size() + ETHER_HDR_LEN11;
  1452. double left_time = next_beacon_time_ - NOW;
  1453. double estimated_time = txtime(ETHER_RTS_LEN, basicRate_)
  1454. + sifs_
  1455. + txtime(ETHER_CTS_LEN, basicRate_)
  1456. + sifs_
  1457. + txtime(size, basicRate_)
  1458. + sifs_
  1459. + txtime(ETHER_ACK_LEN, basicRate_);
  1460. if(afterbackoff == 0) estimated_time += difs_;
  1462. if(estimated_time > left_time) {
  1463. return 1;
  1464. }
  1465. else return 0;
  1466. }
  1468. void 
  1469. Mac802_11::sendATIM(int dst, Handler* h)
  1470. {
  1471. //see if it has previously sent an ATIM to that particular destination
  1472. int prev = LookupDestState(dst);
  1473. if(prev == 1) return;
  1475. Packet *p = Packet::alloc();
  1476. hdr_cmn* ch = HDR_CMN(p);
  1477. struct atim_frame *atf = (struct atim_frame*)p->access(hdr_mac::offset_);
  1479. assert(pktATIM_ == 0);
  1481. ch->uid() = 0;
  1482. ch->ptype() = PT_MAC;
  1483. ch->size() = ETHER_ATIM_LEN;
  1484. ch->iface() = -2;
  1485. ch->error() = 0;
  1487. bzero(atf, MAC_HDR_LEN);
  1489. atf->atf_fc.fc_protocol_version = MAC_ProtocolVersion;
  1490. atf->atf_fc.fc_type = MAC_Type_Management;
  1491. atf->atf_fc.fc_subtype = MAC_Subtype_ATIM;
  1492. atf->atf_fc.fc_to_ds = 0;
  1493. atf->atf_fc.fc_from_ds = 0;
  1494. atf->atf_fc.fc_more_frag = 0;
  1495. atf->atf_fc.fc_retry = 0;
  1496. atf->atf_fc.fc_pwr_mgt = 0;
  1497. atf->atf_fc.fc_more_data = 0;
  1498. atf->atf_fc.fc_wep = 0;
  1499. atf->atf_fc.fc_order = 0;
  1501. atf->atf_fc.fc_channel = DEFAULT_CHANNEL;
  1503. STORE4BYTE(&dst, (atf->atf_da));
  1505. ch->txtime() = txtime(ch->size(), basicRate_);
  1507. STORE4BYTE(&index_, (atf->atf_sa));
  1509. atf->atf_duration = usec(sifs_
  1510. + txtime(ETHER_ATIMACK_LEN, basicRate_)
  1511. + sifs_
  1512. + txtime(ETHER_ATIMRSH_LEN, basicRate_));
  1515. //set callback to get back to the queue
  1516. callback_ = h;
  1517. pktATIM_ = p;
  1519. EnergyModel *em = netif_->node()->energy_model();
  1520. if(em && em->sleep()) {
  1521. em->set_node_sleep(0);
  1522. em->set_node_state(EnergyModel::INROUTE);
  1523. }
  1525. if(mhBackoff_.busy() == 0) {
  1526. if(is_idle()) {
  1528. if(mhDefer_.busy() == 0)
  1529. mhDefer_.start(difs_);
  1530. }
  1532. else {
  1533. mhBackoff_.start(cw_, is_idle());
  1534. }
  1535. }
  1536. }
  1537. //end of JUNGMIN
  1539. void
  1540. Mac802_11::sendCTS(int dst, double rts_duration)
  1541. {
  1542. Packet *p = Packet::alloc();
  1543. hdr_cmn* ch = HDR_CMN(p);
  1544. struct cts_frame *cf = (struct cts_frame*)p->access(hdr_mac::offset_);
  1546. assert(pktCTRL_ == 0);
  1548. ch->uid() = 0;
  1549. ch->ptype() = PT_MAC;
  1550. ch->size() = ETHER_CTS_LEN;
  1551. ch->iface() = -2;
  1552. ch->error() = 0;
  1553. //ch->direction() = hdr_cmn::DOWN;
  1554. bzero(cf, MAC_HDR_LEN);
  1556. cf->cf_fc.fc_protocol_version = MAC_ProtocolVersion;
  1557. cf->cf_fc.fc_type = MAC_Type_Control;
  1558. cf->cf_fc.fc_subtype = MAC_Subtype_CTS;
  1559.   cf->cf_fc.fc_to_ds = 0;
  1560.   cf->cf_fc.fc_from_ds = 0;
  1561.   cf->cf_fc.fc_more_frag = 0;
  1562.   cf->cf_fc.fc_retry = 0;
  1563.   cf->cf_fc.fc_pwr_mgt = 0;
  1564.   cf->cf_fc.fc_more_data = 0;
  1565.   cf->cf_fc.fc_wep = 0;
  1566.   cf->cf_fc.fc_order = 0;
  1568. if(active_channel_ != -1)
  1569. cf->cf_fc.fc_channel = active_channel_;
  1570. else
  1571. cf->cf_fc.fc_channel = DEFAULT_CHANNEL;
  1573. //cf->cf_duration = CTS_DURATION(rts_duration);
  1574. STORE4BYTE(&dst, (cf->cf_ra));
  1576. /* store cts tx time */
  1577. ch->txtime() = txtime(ch->size(), basicRate_);
  1579. /* calculate cts duration */
  1580. cf->cf_duration = usec(sec(rts_duration)
  1581.        - sifs_
  1582.        - txtime(ETHER_CTS_LEN, basicRate_));
  1584. pktCTRL_ = p;
  1586. }
  1588. //JUNGMIN
  1589. void
  1590. Mac802_11::sendDRSH(int dst, double dcts_usage_time)
  1591. {
  1592. Packet *p = Packet::alloc();
  1593. hdr_cmn* ch = HDR_CMN(p);
  1594. struct dca_rsh_frame *drsh = (struct dca_rsh_frame*)p->access(hdr_mac::offset_);
  1596. ch->uid() = 0;
  1597. ch->ptype() = PT_MAC;
  1598. ch->size() = ETHER_DRSH_LEN;
  1599. ch->iface() = -2;
  1600. ch->error() = 0;
  1602. bzero(drsh, MAC_HDR_LEN);
  1604. drsh->drsh_fc.fc_protocol_version = MAC_ProtocolVersion;
  1605.   drsh->drsh_fc.fc_type = MAC_Type_Management;
  1606.   drsh->drsh_fc.fc_subtype = MAC_Subtype_DRSH;
  1607.   drsh->drsh_fc.fc_to_ds = 0;
  1608.   drsh->drsh_fc.fc_from_ds = 0;
  1609.   drsh->drsh_fc.fc_more_frag = 0;
  1610.   drsh->drsh_fc.fc_retry = 0;
  1611.   drsh->drsh_fc.fc_pwr_mgt = 0;
  1612.   drsh->drsh_fc.fc_more_data = 0;
  1613.   drsh->drsh_fc.fc_wep = 0;
  1614. drsh->drsh_fc.fc_order = 0;
  1616. drsh->drsh_fc.fc_channel = DEFAULT_CHANNEL;
  1618. STORE4BYTE(&dst, (drsh->drsh_ra));
  1620. ch->txtime() = txtime(ch->size(), basicRate_);
  1622. drsh->drsh_duration = 0;
  1624. drsh->drsh_confirmed_channel = active_channel_;
  1625. drsh->drsh_usage_time = dcts_usage_time
  1626. - sifs_
  1627. - txtime(ETHER_DRSH_LEN, basicRate_);
  1629. //update dca_cul_
  1630. DCAUpdateCUL(active_channel_, dcts_usage_time);
  1632. pktRSH_ = p;
  1633. }
  1635. void
  1636. Mac802_11::sendDCTS(int dst, double data_transfer_time)
  1637. {
  1638. Packet *p = Packet::alloc();
  1639. hdr_cmn* ch = HDR_CMN(p);
  1640. struct dca_cts_frame *dcts = (struct dca_cts_frame*)p->access(hdr_mac::offset_);
  1642. assert(pktCTRL_ == 0);
  1644. ch->uid() = 0;
  1645. ch->ptype() = PT_MAC;
  1646. ch->size() = ETHER_DCTS_LEN;
  1647. ch->iface() = -2;
  1648. ch->error() = 0;
  1649. //ch->direction() = hdr_cmn::DOWN;
  1650. bzero(dcts, MAC_HDR_LEN);
  1652. dcts->dcts_fc.fc_protocol_version = MAC_ProtocolVersion;
  1653. dcts->dcts_fc.fc_type = MAC_Type_Control;
  1654. dcts->dcts_fc.fc_subtype = MAC_Subtype_DCTS;
  1655.   dcts->dcts_fc.fc_to_ds = 0;
  1656.   dcts->dcts_fc.fc_from_ds = 0;
  1657.   dcts->dcts_fc.fc_more_frag = 0;
  1658.   dcts->dcts_fc.fc_retry = 0;
  1659.   dcts->dcts_fc.fc_pwr_mgt = 0;
  1660.   dcts->dcts_fc.fc_more_data = 0;
  1661.   dcts->dcts_fc.fc_wep = 0;
  1662.   dcts->dcts_fc.fc_order = 0;
  1664. dcts->dcts_fc.fc_channel = DEFAULT_CHANNEL;
  1666. //cf->cf_duration = CTS_DURATION(rts_duration);
  1667. STORE4BYTE(&dst, (dcts->dcts_ra));
  1669. /* store cts tx time */
  1670. ch->txtime() = txtime(ch->size(), basicRate_);
  1672. /* calculate cts duration */
  1673. dcts->dcts_duration = usec(sifs_ 
  1674.        + txtime(ETHER_DRSH_LEN, basicRate_));
  1676. dcts->dcts_usage_time = sifs_
  1677. + data_transfer_time
  1678. + sifs_
  1679. + txtime(ETHER_ACK_LEN, basicRate_);
  1681. active_channel_ = DCASelectChannel(dca_recved_fcl_);
  1683. dcts->dcts_selected_channel = active_channel_;
  1684. if(dcts->dcts_selected_channel != -1) {
  1685. dcts->dcts_wait_time = 0.0;
  1686. //update dca_cul_
  1687. DCAUpdateCUL(active_channel_, dcts->dcts_usage_time + txtime(ETHER_DCTS_LEN, basicRate_) + sifs_);
  1688. } else {
  1689. dcts->dcts_wait_time = FindNearestChannelFreeTime();
  1690. }
  1692. pktCTRL_ = p;
  1693. }
  1694. //end of JUNGMIN
  1696. void
  1697. Mac802_11::sendACK(int dst)
  1698. {
  1699. Packet *p = Packet::alloc();
  1700. hdr_cmn* ch = HDR_CMN(p);
  1701. struct ack_frame *af = (struct ack_frame*)p->access(hdr_mac::offset_);
  1703. assert(pktCTRL_ == 0);
  1705. ch->uid() = 0;
  1706. ch->ptype() = PT_MAC;
  1707. ch->size() = ETHER_ACK_LEN;
  1708. ch->iface() = -2;
  1709. ch->error() = 0;
  1711. bzero(af, MAC_HDR_LEN);
  1713. af->af_fc.fc_protocol_version = MAC_ProtocolVersion;
  1714.   af->af_fc.fc_type = MAC_Type_Control;
  1715.   af->af_fc.fc_subtype = MAC_Subtype_ACK;
  1716.   af->af_fc.fc_to_ds = 0;
  1717.   af->af_fc.fc_from_ds = 0;
  1718.   af->af_fc.fc_more_frag = 0;
  1719.   af->af_fc.fc_retry = 0;
  1720.   af->af_fc.fc_pwr_mgt = 0;
  1721.   af->af_fc.fc_more_data = 0;
  1722.   af->af_fc.fc_wep = 0;
  1723.   af->af_fc.fc_order = 0;
  1725. if(dca_ == 0) {
  1726. if(active_channel_ != -1)
  1727. af->af_fc.fc_channel = active_channel_;
  1728. else
  1729. af->af_fc.fc_channel = DEFAULT_CHANNEL;
  1730. } else {
  1731. if(active_channel_ == -1 || active_channel_ == DEFAULT_CHANNEL) {
  1732. printf("ERROR: cannot send packet on this channel!n");
  1733. exit(1);
  1734. }
  1735. else {
  1736. af->af_fc.fc_channel = active_channel_;
  1737. }
  1738. }
  1740. //af->af_duration = ACK_DURATION();
  1741. STORE4BYTE(&dst, (af->af_ra));
  1743. /* store ack tx time */
  1744.   ch->txtime() = txtime(ch->size(), basicRate_);
  1746. /* calculate ack duration */
  1747.   af->af_duration = 0;
  1749. pktCTRL_ = p;
  1750. }
  1752. //JUNGMIN
  1753. void
  1754. Mac802_11::sendATIMACK(int dst)
  1755. {
  1756. Packet *p = Packet::alloc();
  1757. hdr_cmn* ch = HDR_CMN(p);
  1758. struct atimack_frame *aaf = (struct atimack_frame*)p->access(hdr_mac::offset_);
  1760. assert(pktATIMACK_ == 0);
  1762. ch->uid() = 0;
  1763. ch->ptype() = PT_MAC;
  1764. ch->size() = ETHER_ATIMACK_LEN;
  1765. ch->iface() = -2;
  1766. ch->error() = 0;
  1768. bzero(aaf, MAC_HDR_LEN);
  1770. aaf->aaf_fc.fc_protocol_version = MAC_ProtocolVersion;
  1771.   aaf->aaf_fc.fc_type = MAC_Type_Management;
  1772.   aaf->aaf_fc.fc_subtype = MAC_Subtype_ATIMACK;
  1773.   aaf->aaf_fc.fc_to_ds = 0;
  1774.   aaf->aaf_fc.fc_from_ds = 0;
  1775.   aaf->aaf_fc.fc_more_frag = 0;
  1776.   aaf->aaf_fc.fc_retry = 0;
  1777.   aaf->aaf_fc.fc_pwr_mgt = 0;
  1778.   aaf->aaf_fc.fc_more_data = 0;
  1779.   aaf->aaf_fc.fc_wep = 0;
  1780. aaf->aaf_fc.fc_order = 0;
  1782. aaf->aaf_fc.fc_channel = DEFAULT_CHANNEL;
  1784. STORE4BYTE(&dst, (aaf->aaf_ra));
  1786. STORE4BYTE(&index_, (aaf->aaf_sa));
  1788. ch->txtime() = txtime(ch->size(), basicRate_);
  1790. aaf->aaf_duration = usec(sifs_
  1791. + txtime(ETHER_ATIMRSH_LEN, basicRate_));
  1793. aaf->aaf_selected_channel = selected_channel_;
  1795. pktATIMACK_ = p;
  1796. }
  1798. void
  1799. Mac802_11::sendATIMRSH(int dst)
  1800. {
  1801. Packet *p = Packet::alloc();
  1802. hdr_cmn* ch = HDR_CMN(p);
  1803. struct atimrsh_frame *ahf = (struct atimrsh_frame*)p->access(hdr_mac::offset_);
  1805. assert(pktATIMRSH_ == 0);
  1807. ch->uid() = 0;
  1808. ch->ptype() = PT_MAC;
  1809. ch->size() = ETHER_ATIMRSH_LEN;
  1810. ch->iface() = -2;
  1811. ch->error() = 0;
  1813. bzero(ahf, MAC_HDR_LEN);
  1815. ahf->ahf_fc.fc_protocol_version = MAC_ProtocolVersion;
  1816.   ahf->ahf_fc.fc_type = MAC_Type_Management;
  1817.   ahf->ahf_fc.fc_subtype = MAC_Subtype_ATIMRSH;
  1818.   ahf->ahf_fc.fc_to_ds = 0;
  1819.   ahf->ahf_fc.fc_from_ds = 0;
  1820.   ahf->ahf_fc.fc_more_frag = 0;
  1821.   ahf->ahf_fc.fc_retry = 0;
  1822.   ahf->ahf_fc.fc_pwr_mgt = 0;
  1823.   ahf->ahf_fc.fc_more_data = 0;
  1824.   ahf->ahf_fc.fc_wep = 0;
  1825. ahf->ahf_fc.fc_order = 0;
  1827. ahf->ahf_fc.fc_channel = DEFAULT_CHANNEL;
  1829. STORE4BYTE(&dst, (ahf->ahf_ra));
  1831. ch->txtime() = txtime(ch->size(), basicRate_);
  1833. ahf->ahf_duration = 0;
  1835. ahf->ahf_confirmed_channel = selected_channel_;
  1837. pktATIMRSH_ = p;
  1838. }
  1839. //end of JUNGMIN
  1841. void
  1842. Mac802_11::sendDATA(Packet *p)
  1843. {
  1844. hdr_cmn* ch = HDR_CMN(p);
  1845. struct hdr_mac802_11* dh = HDR_MAC802_11(p);
  1847. assert(pktTx_ == 0);
  1849. /*
  1850.  * Update the MAC header
  1851.  */
  1852. ch->size() += ETHER_HDR_LEN11;
  1854. dh->dh_fc.fc_protocol_version = MAC_ProtocolVersion;
  1855. dh->dh_fc.fc_type       = MAC_Type_Data;
  1856. dh->dh_fc.fc_subtype    = MAC_Subtype_Data;
  1857. //printf(".....p = %x, mac-subtype-%dn",p,dh->dh_fc.fc_subtype);
  1859. dh->dh_fc.fc_to_ds      = 0;
  1860. dh->dh_fc.fc_from_ds    = 0;
  1861. dh->dh_fc.fc_more_frag  = 0;
  1862. dh->dh_fc.fc_retry      = 0;
  1863. dh->dh_fc.fc_pwr_mgt    = 0;
  1864. dh->dh_fc.fc_more_data  = 0;
  1865. dh->dh_fc.fc_wep        = 0;
  1866. dh->dh_fc.fc_order      = 0;
  1868. if(active_channel_ != -1)
  1869. dh->dh_fc.fc_channel = active_channel_;
  1870. else
  1871. dh->dh_fc.fc_channel = DEFAULT_CHANNEL;
  1873. /* store data tx time */
  1874.   ch->txtime() = txtime(ch->size(), dataRate_);
  1876. if((u_int32_t)ETHER_ADDR(dh->dh_da) != MAC_BROADCAST) {
  1877. /* store data tx time for unicast packets */
  1878. ch->txtime() = txtime(ch->size(), dataRate_);
  1880. //dh->dh_duration = DATA_DURATION();
  1881. dh->dh_duration = usec(txtime(ETHER_ACK_LEN, basicRate_)
  1882.          + sifs_);
  1883. } else {
  1884. /* store data tx time for broadcast packets (see 9.6) */
  1885. ch->txtime() = txtime(ch->size(), basicRate_);
  1887. dh->dh_duration = 0;
  1888. }
  1889. pktTx_ = p;
  1890. }
  1892. /* ======================================================================
  1893.    Retransmission Routines
  1894.    ====================================================================== */
  1895. void
  1896. Mac802_11::RetransmitRTS()
  1897. {
  1898. //printf("[%d] %lf: Retransmitting RTSn", index_, NOW);
  1899. assert(pktTx_);
  1900. assert(pktRTS_);
  1901. assert(mhBackoff_.busy() == 0);
  1903. macmib_->RTSFailureCount++;
  1905. ssrc_ += 1; // STA Short Retry Count
  1907. if(ssrc_ >= macmib_->ShortRetryLimit) {
  1908. discard(pktRTS_, DROP_MAC_RETRY_COUNT_EXCEEDED); pktRTS_ = 0;
  1909. /* tell the callback the send operation failed 
  1910.    before discarding the packet */
  1911. hdr_cmn *ch = HDR_CMN(pktTx_);
  1912. if (ch->xmit_failure_) {
  1913.                         /*
  1914.                          *  Need to remove the MAC header so that 
  1915.                          *  re-cycled packets don't keep getting
  1916.                          *  bigger.
  1917.                          */
  1918.                         ch->size() -= ETHER_HDR_LEN11;
  1919.                         ch->xmit_reason_ = XMIT_REASON_RTS;
  1920.                         ch->xmit_failure_(pktTx_->copy(),
  1921.                                           ch->xmit_failure_data_);
  1922.                 }
  1923. //printf("(%d)....discarding RTS:%xn",index_,pktRTS_);
  1924. discard(pktTx_, DROP_MAC_RETRY_COUNT_EXCEEDED); pktTx_ = 0;
  1925. ssrc_ = 0;
  1926. rst_cw();
  1927. } else if (atim_window_ == 1) {
  1928. discard(pktRTS_, DROP_END_OF_BEACON_INTERVAL); pktRTS_ = 0;
  1930. hdr_cmn *ch = HDR_CMN(pktTx_);
  1931. if(ch->xmit_failure_) {
  1932. ch->size() -= ETHER_HDR_LEN11;
  1933. ch->xmit_reason_ = XMIT_REASON_RTS;
  1934. ch->xmit_failure_(pktTx_->copy(), 
  1935.   ch->xmit_failure_data_);
  1936. }
  1938. discard(pktTx_, DROP_END_OF_BEACON_INTERVAL); pktTx_ = 0;
  1939. ssrc_ = 0;
  1940. rst_cw();
  1941. } else {
  1942. //printf("(%d)...retxing RTS:%xn",index_,pktRTS_);
  1943. struct rts_frame *rf;
  1944. struct dca_rts_frame* drts;
  1946. if(dca_ == 0) {
  1947. rf = (struct rts_frame*)pktRTS_->access(hdr_mac::offset_);
  1948. rf->rf_fc.fc_retry = 1;
  1950. if(active_channel_ != -1)
  1951. rf->rf_fc.fc_channel = active_channel_;
  1952. else
  1953. rf->rf_fc.fc_channel = DEFAULT_CHANNEL;
  1954. } else {
  1955. drts = (struct dca_rts_frame*)pktRTS_->access(hdr_mac::offset_);
  1956. drts->drts_fc.fc_retry = 1;
  1957. drts->drts_fc.fc_channel = DEFAULT_CHANNEL;
  1958. }
  1960. inc_cw();
  1961. mhBackoff_.start(cw_, is_idle());
  1962. }
  1963. }
  1965. //JUNGMIN
  1966. void
  1967. Mac802_11::RetransmitATIM()
  1968. {
  1969. assert(pktATIM_);
  1970. assert(mhBackoff_.busy() == 0);
  1972. sarc_ += 1;
  1974. //Hardcoding Retry Limit to 3
  1975. if(sarc_ >= 3) {
  1976. discard(pktATIM_, DROP_MAC_RETRY_COUNT_EXCEEDED); pktATIM_ = 0;
  1978. sarc_ = 0;
  1979. rst_cw();
  1980. } else if(atim_window_ == 0) {
  1981. discard(pktATIM_, DROP_END_OF_ATIM_WINDOW); pktATIM_ = 0;
  1983. sarc_ = 0;
  1984. rst_cw();
  1985. } else {
  1986. struct atim_frame *atf;
  1987. atf = (struct atim_frame*)pktATIM_->access(hdr_mac::offset_);
  1988. atf->atf_fc.fc_retry = 1;
  1990. if(active_channel_ != -1)
  1991. atf->atf_fc.fc_channel = active_channel_;
  1992. else
  1993. atf->atf_fc.fc_channel = DEFAULT_CHANNEL;
  1995. inc_cw();
  1996. mhBackoff_.start(cw_, is_idle());
  1997. }
  1999. }
  2000. //end of JUNGMIN
  2002. void
  2003. Mac802_11::RetransmitDATA()
  2004. {
  2005. //printf("[%d] %lf: Retransmit DATAn", index_, NOW);
  2006. struct hdr_cmn *ch;
  2007. struct hdr_mac802_11 *mh;
  2008. u_int32_t *rcount, *thresh;
  2010. assert(mhBackoff_.busy() == 0);
  2012. assert(pktTx_);
  2013. assert(pktRTS_ == 0);
  2015. ch = HDR_CMN(pktTx_);
  2016. mh = HDR_MAC802_11(pktTx_);
  2018. /*
  2019.  *  Broadcast packets don't get ACKed and therefore
  2020.  *  are never retransmitted.
  2021.  */
  2022. if((u_int32_t)ETHER_ADDR(mh->dh_da) == MAC_BROADCAST) {
  2023. Packet::free(pktTx_); pktTx_ = 0;
  2025. /*
  2026.  * Backoff at end of TX.
  2027.  */
  2028. rst_cw();
  2029. mhBackoff_.start(cw_, is_idle());
  2031. return;
  2032. }
  2034. macmib_->ACKFailureCount++;
  2036. if((u_int32_t) ch->size() <= macmib_->RTSThreshold) {
  2037. rcount = &ssrc_;
  2038. thresh = &macmib_->ShortRetryLimit;
  2039. }
  2040. else {
  2041. rcount = &slrc_;
  2042. thresh = &macmib_->LongRetryLimit;
  2043. }
  2045. (*rcount)++;
  2047. if(*rcount > *thresh) {
  2048. macmib_->FailedCount++;
  2049. /* tell the callback the send operation failed 
  2050.    before discarding the packet */
  2051. hdr_cmn *ch = HDR_CMN(pktTx_);
  2052. if (ch->xmit_failure_) {
  2053.                         ch->size() -= ETHER_HDR_LEN11;
  2054.                         ch->xmit_reason_ = XMIT_REASON_ACK;
  2055.                         ch->xmit_failure_(pktTx_->copy(),
  2056.                                           ch->xmit_failure_data_);
  2057.                 }
  2059. discard(pktTx_, DROP_MAC_RETRY_COUNT_EXCEEDED); pktTx_ = 0;
  2060. *rcount = 0;
  2061. rst_cw();
  2062. } else if( atim_window_ == 1 ) {
  2063. macmib_->FailedCount++;
  2065. hdr_cmn *ch = HDR_CMN(pktTx_);
  2066. if(ch->xmit_failure_) {
  2067. ch->size() -= ETHER_HDR_LEN11;
  2068. ch->xmit_reason_ = XMIT_REASON_ACK;
  2069. ch->xmit_failure_(pktTx_->copy(),
  2070.   ch->xmit_failure_data_);
  2071. }
  2073. discard(pktTx_, DROP_END_OF_BEACON_INTERVAL); pktTx_ = 0;
  2074. *rcount = 0;
  2075. rst_cw();
  2076. }
  2077. else {
  2078. struct hdr_mac802_11 *dh;
  2079. dh = HDR_MAC802_11(pktTx_);
  2080. dh->dh_fc.fc_retry = 1;
  2082. if(active_channel_ != -1)
  2083. dh->dh_fc.fc_channel = active_channel_;
  2084. else
  2085. dh->dh_fc.fc_channel = DEFAULT_CHANNEL;
  2087. if(dca_) {
  2088. sendDRTS(ETHER_ADDR(mh->dh_da));
  2089. } else {
  2090. sendRTS(ETHER_ADDR(mh->dh_da));
  2091. }
  2092. //printf("(%d)retxing data:%x..sendRTS..n",index_,pktTx_);
  2093. inc_cw();
  2094. mhBackoff_.start(cw_, is_idle());
  2095. }
  2096. }
  2098. /* ======================================================================
  2099.    Incoming Packet Routines
  2100.    ====================================================================== */
  2101. void
  2102. Mac802_11::send(Packet *p, Handler *h)
  2103. {
  2104.         struct hdr_cmn *ch = HDR_CMN(p);                    
  2105. struct hdr_mac802_11* dh = HDR_MAC802_11(p);
  2107. /* 
  2108.  * drop the packet if the node is in sleep mode
  2109.  XXX sleep mode can't stop node from sending packets
  2110.  */
  2111. EnergyModel *em = netif_->node()->energy_model();
  2112. if (em && em->sleep()) {
  2113. em->set_node_sleep(0);
  2114. em->set_node_state(EnergyModel::INROUTE);
  2115. }
  2117. callback_ = h;
  2119. sendDATA(p);
  2120. if(dca_ == 0) {
  2121. sendRTS(ETHER_ADDR(dh->dh_da));
  2122. } else {
  2123. sendDRTS(ETHER_ADDR(dh->dh_da));
  2124. }
  2126. /*
  2127.  * Assign the data packet a sequence number.
  2128.  */
  2130. dh->dh_scontrol = sta_seqno_++;
  2132. /*
  2133.  *  If the medium is IDLE, we must wait for a DIFS
  2134.  *  Space before transmitting.
  2135.  */
  2136. if(mhBackoff_.busy() == 0) {
  2137. if(is_idle()) {
  2138. /*
  2139.  * If we are already deferring, there is no
  2140.  * need to reset the Defer timer.
  2141.  */
  2142. if(mhDefer_.busy() == 0)
  2143. mhDefer_.start(difs_);
  2144. }
  2145. /*
  2146.  * If the medium is NOT IDLE, then we start
  2147.  * the backoff timer.
  2148.  */
  2149. else {
  2150. mhBackoff_.start(cw_, is_idle());
  2151. }
  2152. }
  2154. }
  2156. void
  2157. Mac802_11::recv(Packet *p, Handler *h)
  2158. {
  2159. struct hdr_cmn *hdr = HDR_CMN(p);
  2160. /*
  2161.  * Sanity Check
  2162.  */
  2163. assert(initialized());
  2165. /*
  2166.  *  Handle outgoing packets.
  2167.  */
  2168. if(hdr->direction() == hdr_cmn::DOWN) {
  2170.                 send(p, h);
  2171.                 return;
  2172.         }
  2173. /*
  2174.  *  Handle incoming packets.
  2175.  *
  2176.  *  We just received the 1st bit of a packet on the network
  2177.  *  interface.
  2178.  *
  2179.  */
  2181. /*
  2182.  *  If the interface is currently in transmit mode, then
  2183.  *  it probably won't even see this packet.  However, the
  2184.  *  "air" around me is BUSY so I need to let the packet
  2185.  *  proceed.  Just set the error flag in the common header
  2186.  *  to that the packet gets thrown away.
  2187.  */
  2188. if(tx_active_ && hdr->error() == 0) {
  2189. hdr->error() = 1;
  2190. }
  2192. //JUNGMIN
  2193. //silently discard packets sent on another channel
  2194. struct hdr_mac802_11* dh = HDR_MAC802_11(p);
  2195. int ch = dh->dh_fc.fc_channel;
  2196. int dest = ETHER_ADDR(dh->dh_da);
  2198. int i=0;
  2200. if(dca_) {
  2201. if((dh->dh_fc.fc_type == MAC_Type_Data || dh->dh_fc.fc_subtype == MAC_Subtype_ACK) && (u_int32_t)ETHER_ADDR(dh->dh_da) != MAC_BROADCAST) {
  2202. if(active_channel_ == -1 && ch == 0) {
  2203. i=1;
  2205. } else if(ch == active_channel_) {
  2206. i=2;
  2208. } else {
  2209. //if the channel is different, this packet has never received that packet
  2210. Packet::free(p);
  2211. return;
  2212. }
  2213. if((u_int32_t)ETHER_ADDR(dh->dh_da) != index_) {
  2214. Packet::free(p);
  2215. return;
  2216. }
  2217. }
  2218. } else {
  2219. if(active_channel_ == -1 && ch == 0) {
  2220. i=1;
  2222. } else if(ch == active_channel_) {
  2223. i=2;
  2225. } else {
  2226. //if the channel is different, this packet has never received that packet
  2227. Packet::free(p);
  2228. return;
  2229. }
  2230. }
  2232. //end of JUNGMIN
  2234. if(dca_ == 0) {
  2235. if(rx_state_ == MAC_IDLE) {
  2236. SET_RX_STATE(MAC_RECV);
  2237. pktRx_ = p;
  2239. /*
  2240.  * Schedule the reception of this packet, in
  2241.  * txtime seconds.
  2242.  */
  2243. mhRecv_.start(txtime(p));
  2244. } else {
  2245. /*
  2246.  *  If the power of the incoming packet is smaller than the
  2247.  *  power of the packet currently being received by at least
  2248.                  *  the capture threshold, then we ignore the new packet.
  2249.  */
  2250. if(pktRx_->txinfo_.RxPr / p->txinfo_.RxPr >= p->txinfo_.CPThresh) {
  2251. capture(p);
  2252. } else {
  2253. collision(p);
  2254. }
  2255. }
  2256. } else {
  2257. if((dh->dh_fc.fc_type == MAC_Type_Data || dh->dh_fc.fc_subtype == MAC_Subtype_ACK) && (u_int32_t)ETHER_ADDR(dh->dh_da) != MAC_BROADCAST) {
  2258. if(dx_state_ == MAC_IDLE) {
  2259. SET_DX_STATE(MAC_RECV);
  2260. pktDx_ = p;
  2262. mhRecvDATA_.start(txtime(p));
  2263. } else {
  2264. Packet::free(p);
  2265. }
  2266. } else {
  2267. if(rx_state_ == MAC_IDLE) {
  2268. SET_RX_STATE(MAC_RECV);
  2269. pktRx_ = p;
  2271. mhRecv_.start(txtime(p));
  2272. } else {
  2273. if(pktRx_->txinfo_.RxPr / p->txinfo_.RxPr >= p->txinfo_.CPThresh) {
  2274. capture(p);
  2275. } else {
  2276. collision(p);
  2277. }
  2278. }
  2279. }
  2280. }
  2282. }
  2284. void
  2285. Mac802_11::recvDATA_timer()
  2286. {
  2287. u_int32_t src; 
  2288. hdr_cmn *ch = HDR_CMN(pktDx_);
  2289. hdr_mac802_11 *mh = HDR_MAC802_11(pktDx_);
  2291. u_int32_t dst = ETHER_ADDR(mh->dh_da);
  2292. // XXX debug
  2293. //struct cts_frame *cf = (struct cts_frame*)pktRx_->access(hdr_mac::offset_);
  2294. //u_int32_t src = ETHER_ADDR(mh->dh_sa);
  2296. u_int8_t  type = mh->dh_fc.fc_type;
  2297. u_int8_t  subtype = mh->dh_fc.fc_subtype;
  2299. assert(pktDx_);
  2300. assert(dx_state_ == MAC_RECV || dx_state_ == MAC_COLL);
  2302.         /*
  2303.          *  If the interface is in TRANSMIT mode when this packet
  2304.          *  "arrives", then I would never have seen it and should
  2305.          *  do a silent discard without adjusting the NAV.
  2306.          */
  2308.         if(tx_active_) {
  2309.                 Packet::free(pktDx_);
  2310.                 goto done;
  2311.         }
  2313. /*
  2314.  * Handle collisions.
  2315.  */
  2316. if(!(type == MAC_Type_Management && subtype == MAC_Subtype_Beacon)) {
  2317. if(rx_state_ == MAC_COLL) {
  2318. discard(pktDx_, DROP_MAC_COLLISION);
  2319. set_nav(usec(eifs_));
  2320. goto done;
  2321. }
  2322. }
  2324. /*
  2325.  * Check to see if this packet was received with enough
  2326.  * bit errors that the current level of FEC still could not
  2327.  * fix all of the problems - ie; after FEC, the checksum still
  2328.  * failed.
  2329.  */
  2330. if( ch->error() ) {
  2331. Packet::free(pktDx_);
  2332. set_nav(usec(eifs_));
  2333. goto done;
  2334. }
  2336. /*
  2337.  * IEEE 802.11 specs, section 9.2.5.6
  2338.  * - update the NAV (Network Allocation Vector)
  2339.  */
  2341. //Must modify this to make intelligent channel selection
  2342. if(dst != (u_int32_t)index_) {
  2343. set_nav(mh->dh_duration);
  2344. if(type == MAC_Type_Management) {
  2345. if(subtype == MAC_Subtype_ATIMRSH) {
  2346. recvOtherATIMRSH(pktDx_);
  2347. }
  2348. else if(subtype == MAC_Subtype_ATIMACK) {
  2349. recvOtherATIMACK(pktDx_);
  2350. }
  2351. } else if(type == MAC_Type_Control) {
  2352. if(subtype == MAC_Subtype_DCTS) {
  2353. recvOtherDCTS(pktDx_);
  2354. }
  2355. else if(subtype == MAC_Subtype_DRSH) {
  2356. recvOtherDRSH(pktDx_);
  2357. }
  2358. }
  2359. }
  2361.         /* tap out - */
  2362.         if (tap_ && type == MAC_Type_Data &&
  2363.             MAC_Subtype_Data == subtype ) 
  2364. tap_->tap(pktDx_);
  2365. /*
  2366.  * Adaptive Fidelity Algorithm Support - neighborhood infomation 
  2367.  * collection
  2368.  *
  2369.  * Hacking: Before filter the packet, log the neighbor node
  2370.  * I can hear the packet, the src is my neighbor
  2371.  */
  2372. if (netif_->node()->energy_model() && 
  2373.     netif_->node()->energy_model()->adaptivefidelity()) {
  2374. src = ETHER_ADDR(mh->dh_sa);
  2375. netif_->node()->energy_model()->add_neighbor(src);
  2376. }
  2377. /*
  2378.  * Address Filtering
  2379.  */
  2380. //printf("STEP 6n");
  2381. if(dst != (u_int32_t)index_ && dst != MAC_BROADCAST) {
  2382. /*
  2383.  *  We don't want to log this event, so we just free
  2384.  *  the packet instead of calling the drop routine.
  2385.  */
  2386. discard(pktDx_, "---");
  2387. goto done;
  2388. }
  2389. //printf("STEP FINALn");
  2391. switch(type) {
  2393. case MAC_Type_Control:
  2394. switch(subtype) {
  2395. case MAC_Subtype_ACK:
  2396. recvACK(pktDx_);
  2397. break;
  2398. default:
  2399. fprintf(stderr,"recvTimer1:Invalid MAC Control Subtype %xn",
  2400. subtype);
  2401. exit(1);
  2402. }
  2403. break;
  2404. case MAC_Type_Data:
  2405. //printf("DATA RECEIVEDn");
  2406. switch(subtype) {
  2407. case MAC_Subtype_Data:
  2408. recvDATA(pktDx_);
  2409. break;
  2410. default:
  2411. fprintf(stderr, "recv_timer2:Invalid MAC Data Subtype %xn",
  2412. subtype);
  2413. exit(1);
  2414. }
  2415. break;
  2416. default:
  2417. fprintf(stderr, "recv_timer3:Invalid MAC Type %xn", subtype);
  2418. exit(1);
  2419. }
  2420.  done:
  2421. pktDx_ = 0;
  2422. dx_resume();
  2423. }
  2425. void
  2426. Mac802_11::recv_timer()
  2427. {
  2428. u_int32_t src; 
  2429. hdr_cmn *ch = HDR_CMN(pktRx_);
  2430. hdr_mac802_11 *mh = HDR_MAC802_11(pktRx_);
  2431. //JUNGMIN
  2432. struct beacon_frame *beacon;
  2433. //end of JUNGMIN
  2434. u_int32_t dst = ETHER_ADDR(mh->dh_da);
  2435. // XXX debug
  2436. //struct cts_frame *cf = (struct cts_frame*)pktRx_->access(hdr_mac::offset_);
  2437. //u_int32_t src = ETHER_ADDR(mh->dh_sa);
  2439. u_int8_t  type = mh->dh_fc.fc_type;
  2440. u_int8_t  subtype = mh->dh_fc.fc_subtype;
  2442. assert(pktRx_);
  2443. assert(rx_state_ == MAC_RECV || rx_state_ == MAC_COLL);
  2445.         /*
  2446.          *  If the interface is in TRANSMIT mode when this packet
  2447.          *  "arrives", then I would never have seen it and should
  2448.          *  do a silent discard without adjusting the NAV.
  2449.          */
  2451.         if(tx_active_) {
  2452.                 Packet::free(pktRx_);
  2453.                 goto done;
  2454.         }
  2456. /*
  2457.  * Handle collisions.
  2458.  */
  2459. if(!(type == MAC_Type_Management && subtype == MAC_Subtype_Beacon)) {
  2460. if(rx_state_ == MAC_COLL) {
  2461. discard(pktRx_, DROP_MAC_COLLISION);
  2462. set_nav(usec(eifs_));
  2463. goto done;
  2464. }
  2465. }
  2467. /*
  2468.  * Check to see if this packet was received with enough
  2469.  * bit errors that the current level of FEC still could not
  2470.  * fix all of the problems - ie; after FEC, the checksum still
  2471.  * failed.
  2472.  */
  2473. if( ch->error() ) {
  2474. Packet::free(pktRx_);
  2475. set_nav(usec(eifs_));
  2476. goto done;
  2477. }
  2479. /*
  2480.  * IEEE 802.11 specs, section 9.2.5.6
  2481.  * - update the NAV (Network Allocation Vector)
  2482.  */
  2484. //Must modify this to make intelligent channel selection
  2485. if(dst != (u_int32_t)index_) {
  2486. set_nav(mh->dh_duration);
  2487. if(type == MAC_Type_Management) {
  2488. if(subtype == MAC_Subtype_ATIMRSH) {
  2489. recvOtherATIMRSH(pktRx_);
  2490. }
  2491. else if(subtype == MAC_Subtype_ATIMACK) {
  2492. recvOtherATIMACK(pktRx_);
  2493. }
  2494. } else if(type == MAC_Type_Control) {
  2495. if(subtype == MAC_Subtype_DCTS) {
  2496. recvOtherDCTS(pktRx_);
  2497. }
  2498. else if(subtype == MAC_Subtype_DRSH) {
  2499. recvOtherDRSH(pktRx_);
  2500. }
  2501. }
  2502. }
  2504.         /* tap out - */
  2505.         if (tap_ && type == MAC_Type_Data &&
  2506.             MAC_Subtype_Data == subtype ) 
  2507. tap_->tap(pktRx_);
  2508. /*
  2509.  * Adaptive Fidelity Algorithm Support - neighborhood infomation 
  2510.  * collection
  2511.  *
  2512.  * Hacking: Before filter the packet, log the neighbor node
  2513.  * I can hear the packet, the src is my neighbor
  2514.  */
  2515. if (netif_->node()->energy_model() && 
  2516.     netif_->node()->energy_model()->adaptivefidelity()) {
  2517. src = ETHER_ADDR(mh->dh_sa);
  2518. netif_->node()->energy_model()->add_neighbor(src);
  2519. }
  2520. /*
  2521.  * Address Filtering
  2522.  */
  2523. if(dst != (u_int32_t)index_ && dst != MAC_BROADCAST) {
  2524. /*
  2525.  *  We don't want to log this event, so we just free
  2526.  *  the packet instead of calling the drop routine.
  2527.  */
  2528. discard(pktRx_, "---");
  2529. goto done;
  2530. }
  2532. switch(type) {
  2534. case MAC_Type_Management:
  2536. //JUNGMIN
  2537. switch(subtype) {
  2538. case MAC_Subtype_Beacon:
  2539. beacon = (struct beacon_frame *)pktRx_->access(hdr_mac::offset_);
  2541. macmib_->dot11BeaconPeriod = beacon->bf_binterval;
  2543. //if waiting to send beacon, stop it.
  2544. beacon_received();
  2546. mac_log(pktRx_);
  2547. break;
  2549. case MAC_Subtype_ATIM:
  2550. recvATIM(pktRx_);
  2551. break;
  2553. case MAC_Subtype_ATIMACK:
  2554. recvATIMACK(pktRx_);
  2555. break;
  2557. case MAC_Subtype_ATIMRSH:
  2558. recvATIMRSH(pktRx_);
  2559. break;
  2561. default:
  2562. discard(pktRx_, DROP_MAC_PACKET_ERROR);
  2563. }
  2564. //end of JUNGMIN
  2566. goto done;
  2567. break;
  2569. case MAC_Type_Control:
  2570. switch(subtype) {
  2571. case MAC_Subtype_RTS:
  2572. recvRTS(pktRx_);
  2573. break;
  2574. case MAC_Subtype_CTS:
  2575. recvCTS(pktRx_);
  2576. break;
  2577. case MAC_Subtype_DRTS:
  2578. recvDRTS(pktRx_);
  2579. break;
  2580. case MAC_Subtype_DCTS:
  2581. recvDCTS(pktRx_);
  2582. break;
  2583. case MAC_Subtype_DRSH:
  2584. recvDRSH(pktRx_);
  2585. break;
  2586. case MAC_Subtype_ACK:
  2587. recvACK(pktRx_);
  2588. break;
  2589. default:
  2590. fprintf(stderr,"recvTimer1:Invalid MAC Control Subtype %xn",
  2591. subtype);
  2592. exit(1);
  2593. }
  2594. break;
  2595. //JUNGMIN
  2596. case MAC_Type_Data:
  2597. switch(subtype) {
  2598. case MAC_Subtype_Data:
  2599. recvDATA(pktRx_);
  2600. break;
  2601. //end of JUNGMIN
  2602. default:
  2603. fprintf(stderr, "recv_timer2:Invalid MAC Data Subtype %xn",
  2604. subtype);
  2605. exit(1);
  2606. }
  2607. break;
  2608. default:
  2609. fprintf(stderr, "recv_timer3:Invalid MAC Type %xn", subtype);
  2610. exit(1);
  2611. }
  2612.  done:
  2613. pktRx_ = 0;
  2614. rx_resume();
  2615. }
  2618. void
  2619. Mac802_11::recvRTS(Packet *p)
  2620. {
  2621. struct rts_frame *rf = (struct rts_frame*)p->access(hdr_mac::offset_);
  2623. if(tx_state_ != MAC_IDLE) {
  2624. discard(p, DROP_MAC_BUSY);
  2625. return;
  2626. }
  2628. /*
  2629.  *  If I'm responding to someone else, discard this RTS.
  2630.  */
  2631. if(pktCTRL_) {
  2632. discard(p, DROP_MAC_BUSY);
  2633. return;
  2634. }
  2636. sendCTS(ETHER_ADDR(rf->rf_ta), rf->rf_duration);
  2638. /*
  2639.  *  Stop deferring - will be reset in tx_resume().
  2640.  */
  2641. if(mhDefer_.busy()) mhDefer_.stop();
  2643. tx_resume();
  2645. mac_log(p);
  2646. }
  2648. void
  2649. Mac802_11::recvDRTS(Packet *p)
  2650. {
  2652. struct dca_rts_frame *drts = (struct dca_rts_frame*)p->access(hdr_mac::offset_);
  2654. if(tx_state_ != MAC_IDLE) {
  2655. discard(p, DROP_MAC_BUSY);
  2656. return;
  2657. }
  2659. /*
  2660.  *  If I'm responding to someone else, discard this RTS.
  2661.  */
  2662. if(pktCTRL_) {
  2663. discard(p, DROP_MAC_BUSY);
  2664. return;
  2665. }
  2667. for(int i=0; i<NUMBER_OF_CHANNELS; i++) {
  2668. dca_recved_fcl_[i] = drts->drts_channel_list[i];
  2669. }
  2671. sendDCTS(ETHER_ADDR(drts->drts_sa), drts->drts_data_transfer_time);
  2673. /*
  2674.  *  Stop deferring - will be reset in tx_resume().
  2675.  */
  2676. if(mhDefer_.busy()) mhDefer_.stop();
  2678. tx_resume();
  2680. mac_log(p);
  2681. }
  2683. //JUNGMIN
  2684. void
  2685. Mac802_11::recvATIM(Packet *p)
  2686. {
  2687. struct atim_frame *atf = (struct atim_frame*)p->access(hdr_mac::offset_);
  2689. if(tx_state_ != MAC_IDLE) {
  2690. discard(p, DROP_MAC_BUSY);
  2691. return;
  2692. }
  2694. //if I'm responding to someone else, discard this ATIM.
  2695. if(pktATIMACK_) {
  2696. discard(p, DROP_MAC_BUSY);
  2697. return;
  2698. }
  2700. SelectChannel(atf);
  2702. sendATIMACK(ETHER_ADDR(atf->atf_sa));
  2704. if(mhDefer_.busy()) mhDefer_.stop();
  2706. tx_resume();
  2708. mac_log(p);
  2709. }
  2711. void
  2712. Mac802_11::DCABuildFreeChannelList(int* fcl)
  2713. {
  2714. fcl[0] = 0;
  2715. for(int i=1; i<NUMBER_OF_CHANNELS; i++) {
  2716. if(dca_cul_[i] == 0) 
  2717. fcl[i] = 1;
  2718. else
  2719. fcl[i] = 0;
  2720. }
  2721. }
  2723. void 
  2724. Mac802_11::ConfirmChannel(struct atimack_frame* aaf)
  2725. {
  2726. if(selected_channel_ == -1) {
  2727. selected_channel_ = aaf->aaf_selected_channel;
  2728. }
  2729. }
  2731. void
  2732. Mac802_11::SelectChannel(struct atim_frame* atf)
  2733. {
  2734. //Channel Selection Algorithm
  2736. int* cl = atf->atf_channel_list;
  2737. int j, potentia, p_index, dye;
  2739. //1. Receiver Selected
  2740. if(selected_channel_ != -1)
  2741. return;
  2743. //2. Sender preferable
  2744. for(j=0; j<NUMBER_OF_CHANNELS; j++) {
  2745. if(cl[j] == -1)  {
  2746. fcl_[j] = -1;
  2747. selected_channel_ = j; //update mine
  2748. return;
  2749. }
  2750. }
  2752. p_index = 0;
  2753. potentia = fcl_[p_index];
  2755. //3. Receiver Free
  2756. for(j=0; j<NUMBER_OF_CHANNELS; j++) {
  2757. if(fcl_[j] <= potentia) {
  2758. if(fcl_[j] == potentia) {
  2759. p_index = j;
  2760. }
  2761. else {
  2762. potentia = fcl_[j];
  2763. p_index = j;
  2764. }
  2765. } 
  2766. }
  2768. //4. Sender Free
  2769. for(j=0; j<NUMBER_OF_CHANNELS; j++) {
  2770. if(cl[j] < potentia) {
  2771. potentia = cl[j];
  2772. p_index = j;
  2773. }
  2774. }
  2776. fcl_[p_index] = -1;
  2777. selected_channel_ = p_index;
  2779. return;
  2780. }
  2782. int
  2783. Mac802_11::DCASelectChannel(int* fcl)
  2784. {
  2786. for(int i=1; i<NUMBER_OF_CHANNELS; i++) {
  2788. if(dca_cul_[i] == 0) return i;
  2790. }
  2792. return -1;
  2793. }
  2795. double
  2796. Mac802_11::FindNearestChannelFreeTime()
  2797. {
  2798. double nearest = dca_cul_[1];
  2800. int i;
  2801. for(i=2; i<NUMBER_OF_CHANNELS; i++) {
  2803. if(dca_cul_[i] < nearest) {
  2804. nearest = dca_cul_[i];
  2805. }
  2806. }
  2808. return nearest;
  2809. }
  2812. void
  2813. Mac802_11::ResetChannelInfo()
  2814. {
  2815. for(int j=0; j<NUMBER_OF_CHANNELS; j++) {
  2816. fcl_[j] = 0;
  2817. }
  2818. selected_channel_ = -1;
  2819. active_channel_ = 0;
  2820. }
  2822. void
  2823. Mac802_11::ResetNeighborChannelStateInfo()
  2824. {
  2825. for(int j=0; j<MAX_NODES; j++) {
  2826. channel_state_[j] = -1;
  2827. }
  2828. }
  2830. void
  2831. Mac802_11::ResetDestInfo()
  2832. {
  2833. for(int i=0; i<MAX_NODES; i++) {
  2834. dest_state_[i] = 0;  //Did I send ATIM packet to dest i?
  2836. }
  2837. }
  2839. void
  2840. Mac802_11::ResetAtBeacon()
  2841. {
  2842. ResetChannelInfo();
  2843. ResetDestInfo();
  2844. ResetNeighborChannelStateInfo();
  2845. }
  2847. //end of JUNGMIN
  2850. /*
  2851.  * txtime() - pluck the precomputed tx time from the packet header
  2852.  */
  2853. double
  2854. Mac802_11::txtime(Packet *p)
  2855.  {
  2856.  struct hdr_cmn *ch = HDR_CMN(p);
  2857.  double t = ch->txtime();
  2858.  if (t < 0.0) {
  2859.  drop(p, "XXX");
  2860.   exit(1);
  2861.  }
  2862.  return t;
  2863.  }
  2865.  
  2866. /*
  2867.  * txtime() - calculate tx time for packet of size "psz" bytes 
  2868.  *   at rate "drt" bps
  2869.  */
  2870. double
  2871. Mac802_11::txtime(double psz, double drt)
  2872. {
  2873. double dsz = psz - PLCP_HDR_LEN;
  2874. int plcp_hdr = PLCP_HDR_LEN << 3;
  2875. int datalen = (int)dsz << 3;
  2877. double t = (((double)plcp_hdr)/phymib_->PLCPDataRate) + (((double)datalen)/drt);
  2878. return(t);
  2879. }
  2882. //JUNGMIN
  2883. void
  2884. Mac802_11::recvDCTS(Packet *p)
  2885. {
  2886. if(tx_state_ != MAC_RTS) {
  2887. discard(p, DROP_MAC_INVALID_STATE);
  2888. return;
  2889. }
  2891. assert(pktRTS_);
  2892. Packet::free(pktRTS_); pktRTS_ = 0;
  2894. assert(pktTx_);
  2896. mhSend_.stop();
  2898. ssrc_ = 0;
  2899. rst_cw();
  2901. struct dca_cts_frame *dcts = (struct dca_cts_frame*)p->access(hdr_mac::offset_);
  2903. if(dcts->dcts_selected_channel != -1) {
  2905. active_channel_ = dcts->dcts_selected_channel;
  2906. sendDRSH(ETHER_ADDR(dcts->dcts_ra), dcts->dcts_usage_time);
  2907. tx_resume();
  2909. } else {
  2911. //postpone the transmission and start waitTimer
  2912. pktTx_ = 0;
  2914. if(NOW - dcts->dcts_wait_time > 0) {
  2915. if(mhWait_.busy())
  2916. mhWait_.stop();
  2917. mhWait_.start(difs_);
  2918. } else {
  2919. if(mhWait_.busy())
  2920. mhWait_.stop();
  2921. mhWait_.start(dcts->dcts_wait_time - NOW);
  2922. }
  2923. tx_resume();
  2924. }
  2926. mac_log(p);
  2927. }
  2928. //end of JUNGMIN
  2931. void
  2932. Mac802_11::recvCTS(Packet *p)
  2933. {
  2934. if(tx_state_ != MAC_RTS) {
  2935. discard(p, DROP_MAC_INVALID_STATE);
  2936. return;
  2937. }
  2939. assert(pktRTS_);
  2940. Packet::free(pktRTS_); pktRTS_ = 0;
  2942. assert(pktTx_);
  2944. mhSend_.stop();
  2946. /*
  2947.  * The successful reception of this CTS packet implies
  2948.  * that our RTS was successful.  Hence, we can reset
  2949.  * the Short Retry Count and the CW.
  2950.  */
  2951. ssrc_ = 0;
  2952. rst_cw();
  2954. tx_resume();
  2956. mac_log(p);
  2957. }
  2959. //JUNGMIN
  2960. void
  2961. Mac802_11::recvDATA(Packet *p)
  2962. {
  2963. struct hdr_mac802_11 *dh = HDR_MAC802_11(p);
  2964. u_int32_t dst, src, size;
  2966. struct hdr_cmn *ch = HDR_CMN(p);
  2968. {
  2970. dst = ETHER_ADDR(dh->dh_da);
  2971. src = ETHER_ADDR(dh->dh_sa);
  2972. size = ch->size();
  2974. /*
  2975.  * Adjust the MAC packet size - ie; strip
  2976.  * off the mac header
  2977.  */
  2978. ch->size() -= ETHER_HDR_LEN11;
  2979. ch->num_forwards() += 1;
  2980. }
  2982. /*
  2983.  *  If we sent a CTS, clean up...
  2984.  */
  2985. if(dst != MAC_BROADCAST) {
  2986. if(size >= macmib_->RTSThreshold) {
  2987. if(dca_ == 0) {
  2988. if (tx_state_ == MAC_CTS) {
  2989. assert(pktCTRL_);
  2990. Packet::free(pktCTRL_); pktCTRL_ = 0;
  2991. mhSend_.stop();
  2992. /*
  2993.  * Our CTS got through.
  2994.  */
  2995. ssrc_ = 0;
  2996. rst_cw();
  2997. }
  2998. else {
  2999. discard(p, DROP_MAC_BUSY);
  3000. return;
  3001. }
  3002. } else {
  3003. assert(pktCTRL_);
  3004. Packet::free(pktCTRL_); pktCTRL_ = 0;
  3005. mhSend_.stop();
  3006. ssrc_ = 0;
  3007. rst_cw();
  3008. }
  3009. sendACK(src);
  3010. tx_resume();
  3011. }
  3012. /*
  3013.  *  We did not send a CTS and there's no
  3014.  *  room to buffer an ACK.
  3015.  */
  3016. else {
  3017. if(pktCTRL_) {
  3018. discard(p, DROP_MAC_BUSY);
  3019. return;
  3020. }
  3021. sendACK(src);
  3022. if(mhSend_.busy() == 0)
  3023. tx_resume();
  3024. }
  3025. }
  3027. /* ============================================================
  3028.     Make/update an entry in our sequence number cache.
  3029.    ============================================================ */
  3031. /* Changed by Debojyoti Dutta. This upper loop of if{}else was 
  3032.    suggested by Joerg Diederich <dieder@ibr.cs.tu-bs.de>. 
  3033.    Changed on 19th Oct'2000 */
  3035.         if(dst != MAC_BROADCAST) {
  3036.                 if (src < (u_int32_t) cache_node_count_) {
  3037.                         Host *h = &cache_[src];
  3039.                         if(h->seqno && h->seqno == dh->dh_scontrol) {
  3040.                                 discard(p, DROP_MAC_DUPLICATE);
  3041.                                 return;
  3042.                         }
  3043.                         h->seqno = dh->dh_scontrol;
  3044.                 } else {
  3045. static int count = 0;
  3046. if (++count <= 10) {
  3047. printf ("MAC_802_11: accessing MAC cache_ array out of range (src %u, dst %u, size %d)!n", src, dst, cache_node_count_);
  3048. if (count == 10)
  3049. printf ("[suppressing additional MAC cache_ warnings]n");
  3050. };
  3051. };
  3052. }
  3054. /*
  3056.  *  Pass the packet up to the link-layer.
  3057.  *  XXX - we could schedule an event to account
  3058.  *  for this processing delay.
  3059.  */
  3060. //p->incoming = 1;
  3061. // XXXXX NOTE: use of incoming flag has been depracated; In order to track direction of pkt flow, direction_ in hdr_cmn is used instead. see packet.h for details. 
  3063. //record recved bytes
  3064. if((ch->ptype() != PT_MESSAGE) && (ch->ptype() != PT_ARP)) {
  3066. recved_bytes_ += size - ETHER_HDR_LEN11;
  3067. }
  3069. uptarget_->recv(p, (Handler*) 0);
  3070. }
  3071. //end of JUNGMIN
  3074. void
  3075. Mac802_11::recvACK(Packet *p)
  3076. {
  3078. struct hdr_cmn *ch = HDR_CMN(p);
  3080. if(tx_state_ != MAC_SEND) {
  3081. discard(p, DROP_MAC_INVALID_STATE);
  3082. return;
  3083. }
  3084. //printf("(%d)...................recving ACK:%xn",index_,p);
  3085. assert(pktTx_);
  3086. //printf("[%d] Free DATA because it's ACKed.nn", index_);
  3087. Packet::free(pktTx_); pktTx_ = 0;
  3089. mhSend_.stop();
  3091. /*
  3092.  * The successful reception of this ACK packet implies
  3093.  * that our DATA transmission was successful.  Hence,
  3094.  * we can reset the Short/Long Retry Count and the CW.
  3095.  */
  3096. if((u_int32_t) ch->size() <= macmib_->RTSThreshold)
  3097. ssrc_ = 0;
  3098. else
  3099. slrc_ = 0;
  3101. /*
  3102.  * Backoff before sending again.
  3103.  */
  3104. rst_cw();
  3105. assert(mhBackoff_.busy() == 0);
  3106. mhBackoff_.start(cw_, is_idle());
  3108. tx_resume();
  3110. mac_log(p);
  3111. }
  3113. //JUNGMIN
  3114. void
  3115. Mac802_11::recvATIMACK(Packet *p)
  3116. {
  3117. struct atimack_frame *aaf = (struct atimack_frame*)p->access(hdr_mac::offset_);
  3118. struct hdr_cmn *ch = HDR_CMN(p);
  3120. if(tx_state_ != MAC_ATIM) {
  3121. discard(p, DROP_MAC_INVALID_STATE);
  3122. return;
  3123. }
  3124. assert(pktATIM_);
  3125. Packet::free(pktATIM_); pktATIM_ = 0;
  3127. mhSend_.stop();
  3129. ConfirmChannel(aaf);
  3130. sendATIMRSH(ETHER_ADDR(aaf->aaf_sa));
  3131. InsertDestState(ETHER_ADDR(aaf->aaf_sa));
  3133. InsertNeighborChannelState(ETHER_ADDR(aaf->aaf_sa), aaf->aaf_selected_channel);
  3135. sarc_ = 0;
  3137. rst_cw();
  3138. assert(mhBackoff_.busy() == 0);
  3139. mhBackoff_.start(cw_, is_idle());
  3141. tx_resume();
  3143. mac_log(p);
  3144. }
  3146. void
  3147. Mac802_11::recvDRSH(Packet *p)
  3148. {
  3149. mac_log(p);
  3150. }
  3152. void
  3153. Mac802_11::recvATIMRSH(Packet *p)
  3154. {
  3155. struct hdr_cmn *ch = HDR_CMN(p);
  3157. tx_resume();
  3159. mac_log(p);
  3160. }
  3162. void
  3163. Mac802_11::DCAUpdateCUL(int s_channel, double usage_time)
  3164. {
  3165. //update dca_cul_ and timer
  3166. if(dca_cul_[s_channel] < NOW + usage_time) {
  3167. //update
  3168. dca_cul_[s_channel] = NOW + usage_time;
  3169. if(mhChannelUsage_[s_channel].busy())
  3170. mhChannelUsage_[s_channel].stop();
  3171. mhChannelUsage_[s_channel].start(usage_time);
  3172. }
  3173. }
  3175. void 
  3176. Mac802_11::recvOtherDRSH(Packet *p)
  3177. {
  3178. struct dca_rsh_frame *drsh = (struct dca_rsh_frame*)p->access(hdr_mac::offset_);
  3180. int s_channel = drsh->drsh_confirmed_channel;
  3182. if(s_channel > 0) {
  3183. DCAUpdateCUL(s_channel, drsh->drsh_usage_time);
  3184. }
  3185. }
  3187. void
  3188. Mac802_11::recvOtherATIMRSH(Packet *p)
  3189. {
  3190. struct atimrsh_frame *ahf = (struct atimrsh_frame*)p->access(hdr_mac::offset_);
  3192. int s_channel = ahf->ahf_confirmed_channel;
  3194. if(fcl_[s_channel] != -1) fcl_[s_channel]++;
  3196. return;
  3197. }
  3199. void
  3200. Mac802_11::recvOtherDCTS(Packet *p)
  3201. {
  3202. struct dca_cts_frame *dcts = (struct dca_cts_frame*)p->access(hdr_mac::offset_);
  3204. int s_channel = dcts->dcts_selected_channel;
  3206. if(s_channel > 0) {
  3207. DCAUpdateCUL(s_channel, dcts->dcts_usage_time);
  3208. }
  3209. }
  3211. void
  3212. Mac802_11::recvOtherATIMACK(Packet *p)
  3213. {
  3214. struct atimack_frame *aaf = (struct atimack_frame*)p->access(hdr_mac::offset_);
  3216. int s_channel = aaf->aaf_selected_channel;
  3218. if(fcl_[s_channel] != -1) fcl_[s_channel]++;
  3220. return;
  3221. }
  3223. int
  3224. Mac802_11::CheckDest(Packet *p)
  3225. {
  3226. hdr_mac802_11* dh = HDR_MAC802_11(p);
  3227. return (u_int32_t)ETHER_ADDR(dh->dh_da);
  3228. }
  3230. void 
  3231. Mac802_11::prepare_beacon()
  3232. {
  3233. mhBeaconBackoff_.start(BEACON_BACKOFF_WINDOW);
  3234. }
  3236. void
  3237. Mac802_11::beacon_received()
  3238. {
  3239. if(mhBeaconBackoff_.busy()) 
  3240. mhBeaconBackoff_.stop();
  3242. if(btbs_ == 1) {
  3243. btbs_ = 0;
  3244. }
  3246. if(pktPCF_) {
  3247. Packet::free(pktPCF_);
  3248. pktPCF_ = 0;
  3249. }
  3251. if(ready_for_atim_ == 0) {
  3253. SetATIMWindow(); //it automatically tells queue to set ATIM window
  3254. if(mhATIMWindow_.busy())
  3255. mhATIMWindow_.stop();
  3256. mhATIMWindow_.start(macmib_->dot11ATIMWindowSize*0.001000);
  3258. ready_for_atim_ = 1;
  3259. ll_->ifq()->StartSendingATIM();
  3261. }
  3263. }
  3265. void
  3266. Mac802_11::SetATIMWindow()
  3267. {
  3268. atim_window_ = 1;
  3269. ll_->ifq()->SetATIMWindow();
  3270. }
  3272. void
  3273. Mac802_11::send_beacon()
  3274. {
  3275. if(tx_state_!=MAC_SEND&&tx_state_!=MAC_CTS && rx_state_==MAC_IDLE) {
  3276. //We can send the beacon now
  3277. pcfSend(MAC_Type_Management, MAC_Subtype_Beacon);
  3278. } else {
  3279. btbs_ = 1;
  3280. }
  3281. }
  3283. void Mac802_11::pcfSend(int type, int subtype)
  3284. {
  3285. //Packet Generation
  3286. Packet* p = Packet::alloc();
  3287. struct hdr_mac802_11 *mh = (struct hdr_mac802_11 *)p->access(hdr_mac::offset_);
  3288. hdr_cmn* ch = HDR_CMN(p);
  3289. ch->ptype() = PT_MAC;
  3290. int dst = MAC_BROADCAST;
  3291. double defertime = pifs_;
  3292. Scheduler &s = Scheduler::instance();
  3294. bzero(&mh->dh_fc, sizeof(struct frame_control));
  3296. mh->dh_fc.fc_protocol_version = MAC_ProtocolVersion;
  3297. mh->dh_fc.fc_type = type;
  3298. mh->dh_fc.fc_subtype = subtype;
  3300. if(active_channel_ != -1) {
  3301. mh->dh_fc.fc_channel = active_channel_;
  3302. }
  3303. else
  3304. mh->dh_fc.fc_channel = DEFAULT_CHANNEL;
  3306. mh->dh_scontrol = sta_seqno_++;
  3307. ch->size() += ETHER_HDR_LEN11;
  3309. switch(type) {
  3310. case MAC_Type_Management:
  3311. switch(subtype) {
  3312. case MAC_Subtype_Beacon:
  3313. struct beacon_frame *beacon = (struct beacon_frame *)p->access(hdr_mac::offset_);
  3315. beacon->bf_timestamp = (unsigned long long)((Scheduler::instance()).clock()*1000);
  3316. beacon->bf_binterval = macmib_->dot11BeaconPeriod;
  3318. beacon->bf_duration = 0;
  3320. break;
  3321. }
  3322. break;
  3323. }
  3325. pktPCF_ = p;
  3327. STORE4BYTE(&dst, (mh->dh_da));
  3328. STORE4BYTE(&index_, (mh->dh_sa));
  3331. EnergyModel *em = netif_->node()->energy_model();
  3332. if(em && em->sleep()) {
  3333. em->set_node_sleep(0);
  3334. em->set_node_state(EnergyModel::INROUTE);
  3335. }
  3337. if(mhBackoff_.busy() == 0) {
  3338. if(is_idle()) {
  3340. if(mhDefer_.busy() == 0)
  3341. mhDefer_.start(defertime);
  3342. }
  3344. else {
  3345. mhBackoff_.start(cw_, is_idle());
  3346. }
  3347. }
  3349. }
  3351. double
  3352. Mac802_11::NextBeaconTime()
  3353. {
  3354. return next_beacon_time_;
  3355. }
  3357. //end of JUNGMIN