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

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

通讯编程

开发平台：

Visual 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: /cvsroot/nsnam/ns-2/mac/mac-802_11.cc,v 1.56 2008/03/28 04:43:06 tom_henderson Exp $
  35.  *
  36.  * Ported from CMU/Monarch's code, nov'98 -Padma.
  37.  * Contributions by:
  38.  *   - Mike Holland
  39.  *   - Sushmita
  40.  */
  42. #include "delay.h"
  43. #include "connector.h"
  44. #include "packet.h"
  45. #include "random.h"
  46. #include "mobilenode.h"
  48. // #define DEBUG 99
  50. #include "arp.h"
  51. #include "ll.h"
  52. #include "mac.h"
  53. #include "mac-timers.h"
  54. #include "mac-802_11.h"
  55. #include "cmu-trace.h"
  57. // Added by Sushmita to support event tracing
  58. #include "agent.h"
  59. #include "basetrace.h"
  62. /* our backoff timer doesn't count down in idle times during a
  63.  * frame-exchange sequence as the mac tx state isn't idle; genreally
  64.  * these idle times are less than DIFS and won't contribute to
  65.  * counting down the backoff period, but this could be a real
  66.  * problem if the frame exchange ends up in a timeout! in that case,
  67.  * i.e. if a timeout happens we've not been counting down for the
  68.  * duration of the timeout, and in fact begin counting down only
  69.  * DIFS after the timeout!! we lose the timeout interval - which
  70.  * will is not the REAL case! also, the backoff timer could be NULL
  71.  * and we could have a pending transmission which we could have
  72.  * sent! one could argue this is an implementation artifact which
  73.  * doesn't violate the spec.. and the timeout interval is expected
  74.  * to be less than DIFS .. which means its not a lot of time we
  75.  * lose.. anyway if everyone hears everyone the only reason a ack will
  76.  * be delayed will be due to a collision => the medium won't really be
  77.  * idle for a DIFS for this to really matter!!
  78.  */
  80. inline void
  81. Mac802_11::checkBackoffTimer()
  82. {
  83. if(is_idle() && mhBackoff_.paused())
  84. mhBackoff_.resume(phymib_.getDIFS());
  85. if(! is_idle() && mhBackoff_.busy() && ! mhBackoff_.paused())
  86. mhBackoff_.pause();
  87. }
  89. inline void
  90. Mac802_11::transmit(Packet *p, double timeout)
  91. {
  92. tx_active_ = 1;
  94. if (EOTtarget_) {
  95. assert (eotPacket_ == NULL);
  96. eotPacket_ = p->copy();
  97. }
  99. /*
  100.  * If I'm transmitting without doing CS, such as when
  101.  * sending an ACK, any incoming packet will be "missed"
  102.  * and hence, must be discarded.
  103.  */
  104. if(rx_state_ != MAC_IDLE) {
  105. //assert(dh->dh_fc.fc_type == MAC_Type_Control);
  106. //assert(dh->dh_fc.fc_subtype == MAC_Subtype_ACK);
  107. assert(pktRx_);
  108. struct hdr_cmn *ch = HDR_CMN(pktRx_);
  109. ch->error() = 1;        /* force packet discard */
  110. }
  112. /*
  113.  * pass the packet on the "interface" which will in turn
  114.  * place the packet on the channel.
  115.  *
  116.  * NOTE: a handler is passed along so that the Network
  117.  *       Interface can distinguish between incoming and
  118.  *       outgoing packets.
  119.  */
  120. downtarget_->recv(p->copy(), this);
  121. mhSend_.start(timeout);
  122. mhIF_.start(txtime(p));
  123. }
  124. inline void
  125. Mac802_11::setRxState(MacState newState)
  126. {
  127. rx_state_ = newState;
  128. checkBackoffTimer();
  129. }
  131. inline void
  132. Mac802_11::setTxState(MacState newState)
  133. {
  134. tx_state_ = newState;
  135. checkBackoffTimer();
  136. }
  139. /* ======================================================================
  140.    TCL Hooks for the simulator
  141.    ====================================================================== */
  142. static class Mac802_11Class : public TclClass {
  143. public:
  144. Mac802_11Class() : TclClass("Mac/802_11") {}
  145. TclObject* create(int, const char*const*) {
  146. return (new Mac802_11());
  148. }
  149. } class_mac802_11;
  152. /* ======================================================================
  153.    Mac  and Phy MIB Class Functions
  154.    ====================================================================== */
  156. PHY_MIB::PHY_MIB(Mac802_11 *parent)
  157. {
  158. /*
  159.  * Bind the phy mib objects.  Note that these will be bound
  160.  * to Mac/802_11 variables
  161.  */
  163. parent->bind("CWMin_", &CWMin);
  164. parent->bind("CWMax_", &CWMax);
  165. parent->bind("SlotTime_", &SlotTime);
  166. parent->bind("SIFS_", &SIFSTime);
  167. parent->bind("BeaconInterval_", &BeaconInterval);
  169. parent->bind("PreambleLength_", &PreambleLength);
  170. parent->bind("PLCPHeaderLength_", &PLCPHeaderLength);
  171. parent->bind_bw("PLCPDataRate_", &PLCPDataRate);
  172. }
  174. MAC_MIB::MAC_MIB(Mac802_11 *parent)
  175. {
  176. /*
  177.  * Bind the phy mib objects.  Note that these will be bound
  178.  * to Mac/802_11 variables
  179.  */
  181. parent->bind("RTSThreshold_", &RTSThreshold);
  182. parent->bind("ShortRetryLimit_", &ShortRetryLimit);
  183. parent->bind("LongRetryLimit_", &LongRetryLimit);
  184. parent->bind("ScanType_", &ScanType);
  185. parent->bind("ProbeDelay_", &ProbeDelay);
  186. parent->bind("MaxChannelTime_", &MaxChannelTime);
  187. parent->bind("MinChannelTime_", &MinChannelTime);
  188. parent->bind("ChannelTime_", &ChannelTime);
  189. }
  193. /* ======================================================================
  194.    Mac Class Functions
  195.    ====================================================================== */
  196. Mac802_11::Mac802_11() : 
  197. Mac(), phymib_(this), macmib_(this), mhIF_(this), mhNav_(this), 
  198. mhRecv_(this), mhSend_(this), 
  199. mhDefer_(this), mhBackoff_(this), mhBeacon_(this), mhProbe_(this)
  200. {
  202. nav_ = 0.0;
  203. tx_state_ = rx_state_ = MAC_IDLE;
  204. tx_active_ = 0;
  205. eotPacket_ = NULL;
  206. pktRTS_ = 0;
  207. pktCTRL_ = 0;
  208. pktBEACON_ = 0;
  209. pktASSOCREP_ = 0;
  210. pktASSOCREQ_ = 0;
  211. pktAUTHENTICATE_ = 0;
  212. pktPROBEREQ_ = 0;
  213. pktPROBEREP_ = 0;
  214. BeaconTxtime_ = 0;
  215. infra_mode_ = 0;
  216. cw_ = phymib_.getCWMin();
  217. ssrc_ = slrc_ = 0;
  218. // Added by Sushmita
  219.         et_ = new EventTrace();
  221. sta_seqno_ = 1;
  222. cache_ = 0;
  223. cache_node_count_ = 0;
  224. client_list = NULL;
  225. ap_list = NULL;
  226. Pr = 0;
  227. ap_temp = -1;
  228. head = 0;
  229. ap_addr = -1;
  230. associated = 0;
  231. authenticated = 0;
  232. OnMinChannelTime = 0;
  233. OnMaxChannelTime = 0;
  234. Recv_Busy_ = 0;
  235. handoff= 0;
  236. // ssid_ = "0";
  237.         memset(priority_queue, 0, sizeof(priority_queue));
  239. // chk if basic/data rates are set
  240. // otherwise use bandwidth_ as default;
  242. Tcl& tcl = Tcl::instance();
  243. tcl.evalf("Mac/802_11 set basicRate_");
  244. if (strcmp(tcl.result(), "0") != 0) 
  245. bind_bw("basicRate_", &basicRate_);
  246. else
  247. basicRate_ = bandwidth_;
  249. tcl.evalf("Mac/802_11 set dataRate_");
  250. if (strcmp(tcl.result(), "0") != 0) 
  251. bind_bw("dataRate_", &dataRate_);
  252. else
  253. dataRate_ = bandwidth_;
  256. bind_bool("bugFix_timer_", &bugFix_timer_);
  258.         EOTtarget_ = 0;
  259.         bss_id_ = IBSS_ID;
  260. }
  263. int
  264. Mac802_11::command(int argc, const char*const* argv)
  265. {
  266. if (argc == 3) {
  267. if (strcmp(argv[1], "eot-target") == 0) {
  268. EOTtarget_ = (NsObject*) TclObject::lookup(argv[2]);
  269. if (EOTtarget_ == 0)
  270. return TCL_ERROR;
  271. return TCL_OK;
  272. }
  273. if (strcmp(argv[1], "ap") == 0) {
  274. ap_addr = addr();
  275. bss_id_ = addr();
  276. infra_mode_ = 1;
  277. mhBeacon_.start((Random::random() % cw_) * 
  278. phymib_.getSlotTime());
  279. return TCL_OK;
  280. } 
  281. if (strcmp(argv[1], "ScanType") == 0) {
  282. if (strcmp(argv[2], "ACTIVE") == 0) {
  283. ScanType_ = ACTIVE;
  284. infra_mode_ = 1;
  285. ap_list = NULL;
  286. mhProbe_.start(macmib_.getProbeDelay());
  287. } else if (strcmp(argv[2], "PASSIVE") == 0) {
  288. ScanType_ = PASSIVE;
  289. mhProbe_.start(macmib_.getChannelTime());
  290. infra_mode_ = 1;
  291. }
  292. return TCL_OK;
  293. } else if (strcmp(argv[1], "log-target") == 0) { 
  294. logtarget_ = (NsObject*) TclObject::lookup(argv[2]);
  295. if(logtarget_ == 0)
  296. return TCL_ERROR;
  297. return TCL_OK;
  298. } else if(strcmp(argv[1], "nodes") == 0) {
  299. if(cache_) return TCL_ERROR;
  300. cache_node_count_ = atoi(argv[2]);
  301. cache_ = new Host[cache_node_count_ + 1];
  302. assert(cache_);
  303. bzero(cache_, sizeof(Host) * (cache_node_count_+1 ));
  304. return TCL_OK;
  305. } else if(strcmp(argv[1], "eventtrace") == 0) {
  306. // command added to support event tracing by Sushmita
  307.                         et_ = (EventTrace *)TclObject::lookup(argv[2]);
  308.                         return (TCL_OK);
  309.                 }
  310. }
  311. return Mac::command(argc, argv);
  312. }
  314. // Added by Sushmita to support event tracing
  315. void Mac802_11::trace_event(char *eventtype, Packet *p) 
  316. {
  317.         if (et_ == NULL) return;
  318.         char *wrk = et_->buffer();
  319.         char *nwrk = et_->nbuffer();
  320.         //char *src_nodeaddr =
  321. //       Address::instance().print_nodeaddr(iph->saddr());
  322.         //char *dst_nodeaddr =
  323.         //      Address::instance().print_nodeaddr(iph->daddr());
  325.         struct hdr_mac802_11* dh = HDR_MAC802_11(p);
  327.         //struct hdr_cmn *ch = HDR_CMN(p);
  329. if(wrk != 0) {
  330. sprintf(wrk, "E -t "TIME_FORMAT" %s %2x ",
  331. et_->round(Scheduler::instance().clock()),
  332.                         eventtype,
  333.                         //ETHER_ADDR(dh->dh_sa)
  334.                         ETHER_ADDR(dh->dh_ta)
  335.                         );
  336.         }
  337.         if(nwrk != 0) {
  338.                 sprintf(nwrk, "E -t "TIME_FORMAT" %s %2x ",
  339.                         et_->round(Scheduler::instance().clock()),
  340.                         eventtype,
  341.                         //ETHER_ADDR(dh->dh_sa)
  342.                         ETHER_ADDR(dh->dh_ta)
  343.                         );
  344.         }
  345.         et_->dump();
  346. }
  348. /* ======================================================================
  349.    Debugging Routines
  350.    ====================================================================== */
  351. void
  352. Mac802_11::trace_pkt(Packet *p) 
  353. {
  354. struct hdr_cmn *ch = HDR_CMN(p);
  355. struct hdr_mac802_11* dh = HDR_MAC802_11(p);
  356. u_int16_t *t = (u_int16_t*) &dh->dh_fc;
  358. fprintf(stderr, "t[ %2x %2x %2x %2x ] %x %s %dn",
  359. *t, dh->dh_duration,
  360.  ETHER_ADDR(dh->dh_ra), ETHER_ADDR(dh->dh_ta),
  361. index_, packet_info.name(ch->ptype()), ch->size());
  362. }
  364. void
  365. Mac802_11::dump(char *fname)
  366. {
  367. fprintf(stderr,
  368. "n%s --- (INDEX: %d, time: %2.9f)n",
  369. fname, index_, Scheduler::instance().clock());
  371. fprintf(stderr,
  372. "ttx_state_: %x, rx_state_: %x, nav: %2.9f, idle: %dn",
  373. tx_state_, rx_state_, nav_, is_idle());
  375. fprintf(stderr,
  376. "tpktTx_: %lx, pktRx_: %lx, pktRTS_: %lx, pktCTRL_: %lx, pktBEACON_: %lx, pktASSOCREQ_: %lx, pktASSOCREP_: %lx, pktPROBEREQ_: %lx, pktPROBEREP_: %lx, pktAUTHENTICATE_: %lx, callback: %lxn", (long) pktTx_, (long) pktRx_, (long) pktRTS_,
  377. (long) pktCTRL_, (long) pktBEACON_, (long) pktASSOCREQ_, (long) pktASSOCREP_, (long) pktPROBEREQ_, (long) pktPROBEREP_, (long) pktAUTHENTICATE_, (long) callback_);
  379. fprintf(stderr,
  380. "tDefer: %d, Backoff: %d (%d), Recv: %d, Timer: %d Nav: %dn",
  381. mhDefer_.busy(), mhBackoff_.busy(), mhBackoff_.paused(),
  382. mhRecv_.busy(), mhSend_.busy(), mhNav_.busy());
  383. fprintf(stderr,
  384. "tBackoff Expire: %fn",
  385. mhBackoff_.expire());
  386. }
  389. /* ======================================================================
  390.    Packet Headers Routines
  391.    ====================================================================== */
  392. inline int
  393. Mac802_11::hdr_dst(char* hdr, int dst )
  394. {
  395. struct hdr_mac802_11 *dh = (struct hdr_mac802_11*) hdr;
  397.        if (dst > -2) {
  398.                if (bss_id() == ((int)IBSS_ID)) {
  399. STORE4BYTE(&dst, (dh->dh_ra));
  400. } else if ( addr() == bss_id_) {
  401. if ( find_client(dst) == 1 || (u_int32_t) dst == MAC_BROADCAST) {
  402. STORE4BYTE(&dst, (dh->dh_ra));
  403. } else {
  404. int dst_broadcast;
  405. dst_broadcast = MAC_BROADCAST;
  407. STORE4BYTE(&dst_broadcast, (dh->dh_ra));
  408. STORE4BYTE(&dst, (dh->dh_3a));
  409. dh->dh_fc.fc_to_ds      = 1;
  410. dh->dh_fc.fc_from_ds    = 1;
  411. }
  413. } else {
  415. STORE4BYTE(&bss_id_, (dh->dh_ra));
  416.                         STORE4BYTE(&dst, (dh->dh_3a));
  417. }
  418. }
  420.        return (u_int32_t)ETHER_ADDR(dh->dh_ra);
  421. }
  423. inline int 
  424. Mac802_11::hdr_src(char* hdr, int src )
  425. {
  426. struct hdr_mac802_11 *dh = (struct hdr_mac802_11*) hdr;
  427.         if(src > -2)
  428.                STORE4BYTE(&src, (dh->dh_ta));
  429.         return ETHER_ADDR(dh->dh_ta);
  430. }
  432. inline int 
  433. Mac802_11::hdr_type(char* hdr, u_int16_t type)
  434. {
  435. struct hdr_mac802_11 *dh = (struct hdr_mac802_11*) hdr;
  436. if(type)
  437. STORE2BYTE(&type,(dh->dh_body));
  438. return GET2BYTE(dh->dh_body);
  439. }
  442. /* ======================================================================
  443.    Misc Routines
  444.    ====================================================================== */
  445. inline int
  446. Mac802_11::is_idle()
  447. {
  448. if(rx_state_ != MAC_IDLE)
  449. return 0;
  450. if(tx_state_ != MAC_IDLE)
  451. return 0;
  452. if(nav_ > Scheduler::instance().clock())
  453. return 0;
  455. return 1;
  456. }
  458. void
  459. Mac802_11::discard(Packet *p, const char* why)
  460. {
  461. hdr_mac802_11* mh = HDR_MAC802_11(p);
  462. hdr_cmn *ch = HDR_CMN(p);
  464. /* if the rcvd pkt contains errors, a real MAC layer couldn't
  465.    necessarily read any data from it, so we just toss it now */
  466. if(ch->error() != 0) {
  467. Packet::free(p);
  468. return;
  469. }
  471. switch(mh->dh_fc.fc_type) {
  472. case MAC_Type_Management:
  473. switch(mh->dh_fc.fc_subtype) {
  474. case MAC_Subtype_Auth:
  475.  if((u_int32_t)ETHER_ADDR(mh->dh_ra) == (u_int32_t)index_) {
  476. drop(p, why);
  477. return;
  478. }
  479. break;
  480. // drop(p, why);
  481. // return;
  482. case MAC_Subtype_AssocReq:
  483. if((u_int32_t)ETHER_ADDR(mh->dh_ra) == (u_int32_t)index_) {
  484. drop(p, why);
  485. return;
  486. }
  487. break;
  488. case MAC_Subtype_AssocRep:
  489. break;
  490. case MAC_Subtype_ProbeReq:
  491.  if((u_int32_t)ETHER_ADDR(mh->dh_ra) == (u_int32_t)index_) {
  492. drop(p, why);
  493. return;
  494. }
  495. break;
  496. case MAC_Subtype_ProbeRep:
  497. break;
  498. case MAC_Subtype_80211_Beacon:
  499. break;
  500. default:
  501. fprintf(stderr, "invalid MAC Management subtypen");
  502. exit(1);
  503. }
  504. break;
  505. case MAC_Type_Control:
  506. switch(mh->dh_fc.fc_subtype) {
  507. case MAC_Subtype_RTS:
  508.  if((u_int32_t)ETHER_ADDR(mh->dh_ta) ==  (u_int32_t)index_) {
  509. drop(p, why);
  510. return;
  511. }
  512. /* fall through - if necessary */
  513. case MAC_Subtype_CTS:
  514. case MAC_Subtype_ACK:
  515. if((u_int32_t)ETHER_ADDR(mh->dh_ra) == (u_int32_t)index_) {
  516. drop(p, why);
  517. return;
  518. }
  519. break;
  520. default:
  521. fprintf(stderr, "invalid MAC Control subtypen");
  522. exit(1);
  523. }
  524. break;
  525. case MAC_Type_Data:
  526. switch(mh->dh_fc.fc_subtype) {
  527. case MAC_Subtype_Data:
  528. if((u_int32_t)ETHER_ADDR(mh->dh_ra) == 
  529.                            (u_int32_t)index_ ||
  530.                           (u_int32_t)ETHER_ADDR(mh->dh_ta) == 
  531.                            (u_int32_t)index_ ||
  532.                           ((u_int32_t)ETHER_ADDR(mh->dh_ra) == MAC_BROADCAST && mh->dh_fc.fc_to_ds == 0)) {
  533.                                 drop(p,why);
  534.                                 return;
  535. }
  536. break;
  537. default:
  538. fprintf(stderr, "invalid MAC Data subtypen");
  539. exit(1);
  540. }
  541. break;
  542. default:
  543. fprintf(stderr, "invalid MAC type (%x)n", mh->dh_fc.fc_type);
  544. trace_pkt(p);
  545. exit(1);
  546. }
  547. Packet::free(p);
  548. }
  550. void
  551. Mac802_11::capture(Packet *p)
  552. {
  553. /*
  554.  * Update the NAV so that this does not screw
  555.  * up carrier sense.
  556.  */
  557. set_nav(usec(phymib_.getEIFS() + txtime(p)));
  558. Packet::free(p);
  559. }
  561. void
  562. Mac802_11::collision(Packet *p)
  563. {
  564. switch(rx_state_) {
  565. case MAC_RECV:
  566. setRxState(MAC_COLL);
  567. /* fall through */
  568. case MAC_COLL:
  569. assert(pktRx_);
  570. assert(mhRecv_.busy());
  571. /*
  572.  *  Since a collision has occurred, figure out
  573.  *  which packet that caused the collision will
  574.  *  "last" the longest.  Make this packet,
  575.  *  pktRx_ and reset the Recv Timer if necessary.
  576.  */
  577. if(txtime(p) > mhRecv_.expire()) {
  578. mhRecv_.stop();
  579. discard(pktRx_, DROP_MAC_COLLISION);
  580. pktRx_ = p;
  581. mhRecv_.start(txtime(pktRx_));
  582. }
  583. else {
  584. discard(p, DROP_MAC_COLLISION);
  585. }
  586. break;
  587. default:
  588. assert(0);
  589. }
  590. }
  592. void
  593. Mac802_11::tx_resume()
  594. {
  595. double rTime;
  596. assert(mhSend_.busy() == 0);
  597. assert(mhDefer_.busy() == 0);
  599. if(pktCTRL_) {
  600. /*
  601.  *  Need to send a CTS or ACK.
  602.  */
  603. mhDefer_.start(phymib_.getSIFS());
  604. } else if(pktRTS_) {
  605. if (mhBackoff_.busy() == 0) {
  606. if (bugFix_timer_) {
  607. mhBackoff_.start(cw_, is_idle(), 
  608.  phymib_.getDIFS());
  609. }
  610. else {
  611. rTime = (Random::random() % cw_) * 
  612. phymib_.getSlotTime();
  613. mhDefer_.start( phymib_.getDIFS() + rTime);
  614. }
  615. }
  616. } else if(pktTx_) {
  617. if (mhBackoff_.busy() == 0) {
  618. hdr_cmn *ch = HDR_CMN(pktTx_);
  619. struct hdr_mac802_11 *mh = HDR_MAC802_11(pktTx_);
  621. if ((u_int32_t) ch->size() < macmib_.getRTSThreshold()
  622.     || (u_int32_t) ETHER_ADDR(mh->dh_ra) == MAC_BROADCAST) {
  623. if (bugFix_timer_) {
  624. mhBackoff_.start(cw_, is_idle(), 
  625.  phymib_.getDIFS());
  626. }
  627. else {
  628. rTime = (Random::random() % cw_)
  629. * phymib_.getSlotTime();
  630. mhDefer_.start(phymib_.getDIFS() + 
  631.        rTime);
  632. }
  633.                         } else {
  634. mhDefer_.start(phymib_.getSIFS());
  635.                         }
  636. }
  637. } else if(callback_) {
  638. Handler *h = callback_;
  639. callback_ = 0;
  640. h->handle((Event*) 0);
  641. }
  642. setTxState(MAC_IDLE);
  644. }
  646. void
  647. Mac802_11::rx_resume()
  648. {
  649. assert(pktRx_ == 0);
  650. assert(mhRecv_.busy() == 0);
  651. setRxState(MAC_IDLE);
  652. }
  655. /* ======================================================================
  656.    Timer Handler Routines
  657.    ====================================================================== */
  658. void
  659. Mac802_11::backoffHandler()
  660. {
  661. if(addr() != bss_id_ && infra_mode_ == 1) {
  662. if(check_pktPROBEREQ() == 0)
  663. return;
  664. if(check_pktAUTHENTICATE() == 0)
  665. return;
  666. if(check_pktASSOCREQ() == 0)
  667. return;
  668. }
  670. if(pktCTRL_) {
  671. assert(mhSend_.busy() || mhDefer_.busy());
  672. return;
  673. }
  675. if ( addr() == bss_id_ ) {
  676. if (pktPROBEREP_ && priority_queue[head] == 1) {
  677. if (check_pktPROBEREP() == 0) 
  678. return;
  679. } else if (pktBEACON_ && priority_queue[head] == 2) {
  680. if (check_pktBEACON() == 0) {
  681. return;
  682. }
  683. } else if (pktAUTHENTICATE_ && priority_queue[head] == 3) { 
  684. if (check_pktAUTHENTICATE() == 0)
  685. return;
  686. } else if(pktASSOCREP_ && priority_queue[head] == 4) {
  687. if (check_pktASSOCREP() == 0)
  688. return;
  689. }
  690. }
  692. if(check_pktRTS() == 0)
  693. return;
  694. if(check_pktTx() == 0)
  695. return;
  696. }
  698. void
  699. Mac802_11::BeaconHandler()
  700. {
  702. mhBeacon_.start(phymib_.getBeaconInterval());
  703. sendBEACON(index_);
  705. }
  708. // Probe timer is used for multiple purposes. It can be set to 4 different values
  709. // Probe Delay, MinChannelTime and MaxChannelTime -  for Active Scanning
  710. // ChannelTime - Passive Scanning
  714. void
  715. Mac802_11::ProbeHandler()
  716. {
  717. if (ScanType_ == ACTIVE) {
  718. if ( (bss_id_ == (int)IBSS_ID || handoff == 1) && OnMinChannelTime == 0 && Recv_Busy_ == 0 && OnMaxChannelTime == 0) {
  719. if (strongest_ap() < 0) {   // Probe delay over - Active Scan starts here, when the ap_table has not been built yet
  720. sendPROBEREQ(MAC_BROADCAST); 
  721. return;
  722. } else {
  723. checkAssocAuthStatus();  // MaxChannelTime Over - Handoff is taking place and ap_table is built, complete authentication and (re)association
  724. return;
  725. }
  726. }
  727. else if (OnMinChannelTime == 1 && Recv_Busy_ == 1 && OnMaxChannelTime == 0) {
  728. // MinChannelTime Over - receiver indicated busy before timer expiry, hence Probe timer should be continued for MaxChannelTime, to reeive all probe responses
  729. OnMinChannelTime = 0;
  730. OnMaxChannelTime = 1;
  731. mhProbe_.start(macmib_.getMaxChannelTime()); 
  732. return;
  733. }
  734. else if (OnMinChannelTime == 0 && Recv_Busy_ == 1 && OnMaxChannelTime == 1) {
  735. // MaxChannelTime Over - Active Scanning is over, start authentication and association
  736. OnMaxChannelTime = 0;
  737. Recv_Busy_ = 0;
  738. if (strongest_ap() > -1)
  739. active_scan();
  740. else 
  741. printf("No APs in rangen");
  742. return;
  743. }
  744. else if (OnMinChannelTime == 1 && Recv_Busy_ == 0 && OnMaxChannelTime == 0) {
  745. //printf("Out of range of any Access Point or channel without APsn");
  746. OnMinChannelTime = 0;
  747. deletelist(); //  MinChannelTime Over - Delete ap_table
  748. return;
  749. }
  750. } else {
  751. if (ScanType_ == PASSIVE && bss_id_ == (int)IBSS_ID) {
  752.  //  ChannelTime Over - Passive Scanning is over, start authentication and association
  753. passive_scan();  // 
  754. return;
  755. }
  756. }
  757. if (bss_id_ != (int)IBSS_ID && !mhProbe_.busy()) {
  758. // Start Authentication and Association
  759. checkAssocAuthStatus();
  760. }
  761. }
  763. void
  764. Mac802_11::deferHandler()
  765. {
  766. assert(pktCTRL_ || pktRTS_ || pktTx_);
  768. if(check_pktCTRL() == 0)
  769. return;
  770. assert(mhBackoff_.busy() == 0);
  771. if(check_pktRTS() == 0)
  772. return;
  773. if(check_pktTx() == 0)
  774. return;
  775. }
  777. void
  778. Mac802_11::navHandler()
  779. {
  780. if(is_idle() && mhBackoff_.paused())
  781. mhBackoff_.resume(phymib_.getDIFS());
  782. }
  784. void
  785. Mac802_11::recvHandler()
  786. {
  787. recv_timer();
  788. }
  790. void
  791. Mac802_11::sendHandler()
  792. {
  793. send_timer();
  794. }
  797. void
  798. Mac802_11::txHandler()
  799. {
  800. if (EOTtarget_) {
  801. assert(eotPacket_);
  802. EOTtarget_->recv(eotPacket_, (Handler *) 0);
  803. eotPacket_ = NULL;
  804. }
  805. tx_active_ = 0;
  806. }
  809. /* ======================================================================
  810.    The "real" Timer Handler Routines
  811.    ====================================================================== */
  812. void
  813. Mac802_11::send_timer()
  814. {
  815. switch(tx_state_) {
  817. case MAC_MGMT:
  818. if (pktAUTHENTICATE_) {
  819. assert(pktAUTHENTICATE_);
  820. Packet::free(pktAUTHENTICATE_);
  821. pktAUTHENTICATE_ = 0;
  822. if(addr() == bss_id_) {
  823. if (end() > (head + 1)) {
  824. shift_priority_queue();
  825. assert(mhBackoff_.busy() == 0);
  826. mhBackoff_.start(cw_, is_idle());
  827. } else 
  828. priority_queue[head] = 0;
  829. } else
  830. checkAssocAuthStatus();
  831. break;
  832. }
  833.   if (pktASSOCREQ_) {
  834. assert(pktASSOCREQ_);
  835. Packet::free(pktASSOCREQ_);
  836. pktASSOCREQ_ = 0;
  837. checkAssocAuthStatus();
  838. break;
  839.   }
  840. if (pktASSOCREP_) {
  841. assert(pktASSOCREP_);
  842. Packet::free(pktASSOCREP_);
  843. pktASSOCREP_ = 0;
  844. if (end() > (head + 1)) {
  845. shift_priority_queue();
  846. assert(mhBackoff_.busy() == 0);
  847. mhBackoff_.start(cw_, is_idle());
  848. } else 
  849. priority_queue[head] = 0;
  850. break;
  851. }
  852. if (pktPROBEREQ_) {
  853. assert(pktPROBEREQ_);
  854. Packet::free(pktPROBEREQ_);
  855. pktPROBEREQ_ = 0;
  856. break;
  857.   }
  858. if (pktPROBEREP_) {
  859. assert(pktPROBEREP_);
  860. Packet::free(pktPROBEREP_);
  861. pktPROBEREP_ = 0;
  862. if (end() > (head + 1)) {
  863. shift_priority_queue();
  864. assert(mhBackoff_.busy() == 0);
  865. mhBackoff_.start(cw_, is_idle());
  866. } else 
  867. priority_queue[head] = 0;
  868. break;
  869. }
  870. case MAC_BCN:
  871. assert(pktBEACON_);
  872. Packet::free(pktBEACON_);
  873. pktBEACON_ = 0;
  874. if (end() > (head + 1)) {
  875. shift_priority_queue();
  876. assert(mhBackoff_.busy() == 0);
  877. mhBackoff_.start(cw_, is_idle());
  878. } else 
  879. priority_queue[head] = 0;
  880. break;
  882. case MAC_RTS:
  883. RetransmitRTS();
  884. break;
  885. /*
  886.  * Sent a CTS, but did not receive a DATA packet.
  887.  */
  888. case MAC_CTS:
  889. assert(pktCTRL_);
  890. Packet::free(pktCTRL_); 
  891. pktCTRL_ = 0;
  892. break;
  893. /*
  894.  * Sent DATA, but did not receive an ACK packet.
  895.  */
  896. case MAC_SEND:
  897. RetransmitDATA();
  898. break;
  899. /*
  900.  * Sent an ACK, and now ready to resume transmission.
  901.  */
  902. case MAC_ACK:
  903. assert(pktCTRL_);
  904. Packet::free(pktCTRL_); 
  905. pktCTRL_ = 0;
  906. break;
  907. case MAC_IDLE:
  908. break;
  909. default:
  910. assert(0);
  911. }
  912. tx_resume();
  913. }
  916. /* ======================================================================
  917.    Outgoing Packet Routines
  918.    ====================================================================== */
  919. int
  920. Mac802_11::check_pktCTRL()
  921. {
  922. struct hdr_mac802_11 *mh;
  923. double timeout;
  925. if(pktCTRL_ == 0)
  926. return -1;
  927. if(tx_state_ == MAC_CTS || tx_state_ == MAC_ACK)
  928. return -1;
  930. mh = HDR_MAC802_11(pktCTRL_);
  931.   
  932. switch(mh->dh_fc.fc_subtype) {
  933. /*
  934.  *  If the medium is not IDLE, don't send the CTS.
  935.  */
  936. case MAC_Subtype_CTS:
  937. if(!is_idle()) {
  938. discard(pktCTRL_, DROP_MAC_BUSY); pktCTRL_ = 0;
  939. return 0;
  940. }
  941. setTxState(MAC_CTS);
  942. /*
  943.  * timeout:  cts + data tx time calculated by
  944.  *           adding cts tx time to the cts duration
  945.  *           minus ack tx time -- this timeout is
  946.  *           a guess since it is unspecified
  947.  *           (note: mh->dh_duration == cf->cf_duration)
  948.  */
  949.  timeout = txtime(phymib_.getCTSlen(), basicRate_)
  950.                         + DSSS_MaxPropagationDelay                      // XXX
  951.                         + sec(mh->dh_duration)
  952.                         + DSSS_MaxPropagationDelay                      // XXX
  953.                        - phymib_.getSIFS()
  954.                        - txtime(phymib_.getACKlen(), basicRate_);
  955. break;
  956. /*
  957.  * IEEE 802.11 specs, section 9.2.8
  958.  * Acknowledments are sent after an SIFS, without regard to
  959.  * the busy/idle state of the medium.
  960.  */
  961. case MAC_Subtype_ACK:
  962. setTxState(MAC_ACK);
  963. timeout = txtime(phymib_.getACKlen(), basicRate_);
  964. break;
  965. default:
  966. fprintf(stderr, "check_pktCTRL:Invalid MAC Control subtypen");
  967. exit(1);
  968. }
  969. transmit(pktCTRL_, timeout);
  970. return 0;
  971. }
  973. int
  974. Mac802_11::check_pktRTS()
  975. {
  976. struct hdr_mac802_11 *mh;
  977. double timeout;
  979. assert(mhBackoff_.busy() == 0);
  981. if(pktRTS_ == 0)
  982.   return -1;
  983. mh = HDR_MAC802_11(pktRTS_);
  985.   switch(mh->dh_fc.fc_subtype) {
  986. case MAC_Subtype_RTS:
  987. if(! is_idle()) {
  988. inc_cw();
  989. mhBackoff_.start(cw_, is_idle());
  990. return 0;
  991. }
  992. setTxState(MAC_RTS);
  993. timeout = txtime(phymib_.getRTSlen(), basicRate_)
  994. + DSSS_MaxPropagationDelay                      // XXX
  995. + phymib_.getSIFS()
  996. + txtime(phymib_.getCTSlen(), basicRate_)
  997. + DSSS_MaxPropagationDelay;
  998. break;
  999. default:
  1000. fprintf(stderr, "check_pktRTS:Invalid MAC Control subtypen");
  1001. exit(1);
  1002. }
  1003. transmit(pktRTS_, timeout);
  1004.   
  1006. return 0;
  1007. }
  1009. int
  1010. Mac802_11::check_pktTx()
  1011. {
  1013. struct hdr_mac802_11 *mh;
  1014. double timeout;
  1016. assert(mhBackoff_.busy() == 0);
  1018. if(pktTx_ == 0)
  1019. return -1;
  1021. mh = HDR_MAC802_11(pktTx_);
  1023. if (addr() != bss_id_ && bss_id_ != (int)IBSS_ID) {
  1024. if (handoff == 0)
  1025. STORE4BYTE(&bss_id_, (mh->dh_ra));
  1026. }
  1028. switch(mh->dh_fc.fc_subtype) {
  1029. case MAC_Subtype_Data:
  1030. if(! is_idle()) {
  1031. sendRTS(ETHER_ADDR(mh->dh_ra));
  1032. inc_cw();
  1033. mhBackoff_.start(cw_, is_idle());
  1034. return 0;
  1035. }
  1036. setTxState(MAC_SEND);
  1037. if((u_int32_t)ETHER_ADDR(mh->dh_ra) != MAC_BROADCAST)
  1038.                         timeout = txtime(pktTx_)
  1039.                                 + DSSS_MaxPropagationDelay              // XXX
  1040.                                + phymib_.getSIFS()
  1041.                                + txtime(phymib_.getACKlen(), basicRate_)
  1042.                                + DSSS_MaxPropagationDelay;             // XXX
  1043. else
  1044. timeout = txtime(pktTx_);
  1045. break;
  1046. default:
  1047. fprintf(stderr, "check_pktTx:Invalid MAC Control subtypen");
  1048. exit(1);
  1049. }
  1050. transmit(pktTx_, timeout);
  1051. return 0;
  1052. }
  1053. /*
  1054.  * Low-level transmit functions that actually place the packet onto
  1055.  * the channel.
  1056.  */
  1057. void
  1058. Mac802_11::sendRTS(int dst)
  1059. {
  1060. Packet *p = Packet::alloc();
  1061. hdr_cmn* ch = HDR_CMN(p);
  1062. struct rts_frame *rf = (struct rts_frame*)p->access(hdr_mac::offset_);
  1064. assert(pktTx_);
  1065. assert(pktRTS_ == 0);
  1067. /*
  1068.  *  If the size of the packet is larger than the
  1069.  *  RTSThreshold, then perform the RTS/CTS exchange.
  1070.  */
  1071. if( (u_int32_t) HDR_CMN(pktTx_)->size() < macmib_.getRTSThreshold() ||
  1072.             (u_int32_t) dst == MAC_BROADCAST) {
  1073. Packet::free(p);
  1074. return;
  1075. }
  1077. ch->uid() = 0;
  1078. ch->ptype() = PT_MAC;
  1079. ch->size() = phymib_.getRTSlen();
  1080. ch->iface() = -2;
  1081. ch->error() = 0;
  1083. bzero(rf, MAC_HDR_LEN);
  1085. rf->rf_fc.fc_protocol_version = MAC_ProtocolVersion;
  1086.   rf->rf_fc.fc_type = MAC_Type_Control;
  1087.   rf->rf_fc.fc_subtype = MAC_Subtype_RTS;
  1088. rf->rf_fc.fc_to_ds = 0;
  1089. rf->rf_fc.fc_from_ds = 0;
  1090.   rf->rf_fc.fc_more_frag = 0;
  1091.   rf->rf_fc.fc_retry = 0;
  1092.   rf->rf_fc.fc_pwr_mgt = 0;
  1093.   rf->rf_fc.fc_more_data = 0;
  1094.   rf->rf_fc.fc_wep = 0;
  1095.   rf->rf_fc.fc_order = 0;
  1098. //rf->rf_duration = RTS_DURATION(pktTx_);
  1099. STORE4BYTE(&dst, (rf->rf_ra));
  1101. /* store rts tx time */
  1102.   ch->txtime() = txtime(ch->size(), basicRate_);
  1104. STORE4BYTE(&index_, (rf->rf_ta));
  1106. /* calculate rts duration field */
  1107. rf->rf_duration = usec(phymib_.getSIFS()
  1108.        + txtime(phymib_.getCTSlen(), basicRate_)
  1109.        + phymib_.getSIFS()
  1110.                                + txtime(pktTx_)
  1111.        + phymib_.getSIFS()
  1112.        + txtime(phymib_.getACKlen(), basicRate_));
  1113. pktRTS_ = p;
  1114. }
  1116. void
  1117. Mac802_11::sendCTS(int dst, double rts_duration)
  1118. {
  1119. Packet *p = Packet::alloc();
  1120. hdr_cmn* ch = HDR_CMN(p);
  1121. struct cts_frame *cf = (struct cts_frame*)p->access(hdr_mac::offset_);
  1123. assert(pktCTRL_ == 0);
  1125. ch->uid() = 0;
  1126. ch->ptype() = PT_MAC;
  1127. ch->size() = phymib_.getCTSlen();
  1130. ch->iface() = -2;
  1131. ch->error() = 0;
  1132. //ch->direction() = hdr_cmn::DOWN;
  1133. bzero(cf, MAC_HDR_LEN);
  1135. cf->cf_fc.fc_protocol_version = MAC_ProtocolVersion;
  1136. cf->cf_fc.fc_type = MAC_Type_Control;
  1137. cf->cf_fc.fc_subtype = MAC_Subtype_CTS;
  1138.   cf->cf_fc.fc_to_ds = 0;
  1139. cf->cf_fc.fc_from_ds = 0;
  1140.   cf->cf_fc.fc_more_frag = 0;
  1141.   cf->cf_fc.fc_retry = 0;
  1142.   cf->cf_fc.fc_pwr_mgt = 0;
  1143.   cf->cf_fc.fc_more_data = 0;
  1144.   cf->cf_fc.fc_wep = 0;
  1145.   cf->cf_fc.fc_order = 0;
  1148. //cf->cf_duration = CTS_DURATION(rts_duration);
  1149. STORE4BYTE(&dst, (cf->cf_ra));
  1151. /* store cts tx time */
  1152. ch->txtime() = txtime(ch->size(), basicRate_);
  1154. /* calculate cts duration */
  1155. cf->cf_duration = usec(sec(rts_duration)
  1156.                               - phymib_.getSIFS()
  1157.                               - txtime(phymib_.getCTSlen(), basicRate_));
  1161. pktCTRL_ = p;
  1163. }
  1165. void
  1166. Mac802_11::sendACK(int dst)
  1167. {
  1168. Packet *p = Packet::alloc();
  1169. hdr_cmn* ch = HDR_CMN(p);
  1170. struct ack_frame *af = (struct ack_frame*)p->access(hdr_mac::offset_);
  1172. assert(pktCTRL_ == 0);
  1174. ch->uid() = 0;
  1175. ch->ptype() = PT_MAC;
  1176. // CHANGE WRT Mike's code
  1177. ch->size() = phymib_.getACKlen();
  1178. ch->iface() = -2;
  1179. ch->error() = 0;
  1181. bzero(af, MAC_HDR_LEN);
  1183. af->af_fc.fc_protocol_version = MAC_ProtocolVersion;
  1184.   af->af_fc.fc_type = MAC_Type_Control;
  1185.   af->af_fc.fc_subtype = MAC_Subtype_ACK;
  1186.   af->af_fc.fc_to_ds = 0;
  1187.   af->af_fc.fc_from_ds = 0;
  1188.   af->af_fc.fc_more_frag = 0;
  1189.   af->af_fc.fc_retry = 0;
  1190.   af->af_fc.fc_pwr_mgt = 0;
  1191.   af->af_fc.fc_more_data = 0;
  1192.   af->af_fc.fc_wep = 0;
  1193.   af->af_fc.fc_order = 0;
  1195. //af->af_duration = ACK_DURATION();
  1196. STORE4BYTE(&dst, (af->af_ra));
  1198. /* store ack tx time */
  1199.   ch->txtime() = txtime(ch->size(), basicRate_);
  1201. /* calculate ack duration */
  1202.   af->af_duration = 0;
  1204. pktCTRL_ = p;
  1205. }
  1207. void
  1208. Mac802_11::sendDATA(Packet *p)
  1209. {
  1210. hdr_cmn* ch = HDR_CMN(p);
  1211. struct hdr_mac802_11* dh = HDR_MAC802_11(p);
  1212. u_int32_t dst = ETHER_ADDR(dh->dh_ra);
  1213. assert(pktTx_ == 0);
  1215. /*
  1216.  * Update the MAC header
  1217.  */
  1218. ch->size() += phymib_.getHdrLen11();
  1220. dh->dh_fc.fc_protocol_version = MAC_ProtocolVersion;
  1221. dh->dh_fc.fc_type       = MAC_Type_Data;
  1222. dh->dh_fc.fc_subtype    = MAC_Subtype_Data;
  1223. if ( bss_id_ != (int)IBSS_ID ) {
  1224. if ( index_ == ap_addr ) {
  1225. if (dh->dh_fc.fc_to_ds == 0) {
  1226. if (find_client(dst) == 1 || dst == MAC_BROADCAST) {
  1227.   dh->dh_fc.fc_to_ds      = 0;
  1228. dh->dh_fc.fc_from_ds    = 1;
  1229. }
  1230. } 
  1231. } else {
  1232. dh->dh_fc.fc_to_ds = 1;
  1233. dh->dh_fc.fc_from_ds = 0;
  1234. }
  1235. } else {
  1236. dh->dh_fc.fc_to_ds = 0;
  1237. dh->dh_fc.fc_from_ds = 0;
  1238. }
  1240. dh->dh_fc.fc_more_frag  = 0;
  1241. dh->dh_fc.fc_retry      = 0;
  1242. dh->dh_fc.fc_pwr_mgt    = 0;
  1243. dh->dh_fc.fc_more_data  = 0;
  1244. dh->dh_fc.fc_wep        = 0;
  1245. dh->dh_fc.fc_order      = 0;
  1247. /* store data tx time */
  1248.   ch->txtime() = txtime(ch->size(), dataRate_);
  1250. if((u_int32_t)ETHER_ADDR(dh->dh_ra) != MAC_BROADCAST) {
  1251. /* store data tx time for unicast packets */
  1252. ch->txtime() = txtime(ch->size(), dataRate_);
  1254. dh->dh_duration = usec(txtime(phymib_.getACKlen(), basicRate_)
  1255.        + phymib_.getSIFS());
  1259. } else {
  1260. /* store data tx time for broadcast packets (see 9.6) */
  1261. ch->txtime() = txtime(ch->size(), basicRate_);
  1263. dh->dh_duration = 0;
  1264. }
  1265. pktTx_ = p;
  1266. }
  1268. /* ======================================================================
  1269.    Retransmission Routines
  1270.    ====================================================================== */
  1271. void
  1272. Mac802_11::RetransmitRTS()
  1273. {
  1274. assert(pktTx_);
  1275. assert(pktRTS_);
  1276. assert(mhBackoff_.busy() == 0);
  1277. macmib_.RTSFailureCount++;
  1280. ssrc_ += 1; // STA Short Retry Count
  1282. if(ssrc_ >= macmib_.getShortRetryLimit()) {
  1283. discard(pktRTS_, DROP_MAC_RETRY_COUNT_EXCEEDED); pktRTS_ = 0;
  1284. /* tell the callback the send operation failed 
  1285.    before discarding the packet */
  1286. hdr_cmn *ch = HDR_CMN(pktTx_);
  1287. if (ch->xmit_failure_) {
  1288.                         /*
  1289.                          *  Need to remove the MAC header so that 
  1290.                          *  re-cycled packets don't keep getting
  1291.                          *  bigger.
  1292.                          */
  1293. ch->size() -= phymib_.getHdrLen11();
  1294.                         ch->xmit_reason_ = XMIT_REASON_RTS;
  1295.                         ch->xmit_failure_(pktTx_->copy(),
  1296.                                           ch->xmit_failure_data_);
  1297.                 }
  1298. discard(pktTx_, DROP_MAC_RETRY_COUNT_EXCEEDED); 
  1299. pktTx_ = 0;
  1300. ssrc_ = 0;
  1301. rst_cw();
  1302. } else {
  1303. struct rts_frame *rf;
  1304. rf = (struct rts_frame*)pktRTS_->access(hdr_mac::offset_);
  1305. rf->rf_fc.fc_retry = 1;
  1307. inc_cw();
  1308. mhBackoff_.start(cw_, is_idle());
  1309. }
  1310. }
  1312. void
  1313. Mac802_11::RetransmitDATA()
  1314. {
  1315. struct hdr_cmn *ch;
  1316. struct hdr_mac802_11 *mh;
  1317. u_int32_t *rcount, thresh;
  1318. assert(mhBackoff_.busy() == 0);
  1320. assert(pktTx_);
  1321. assert(pktRTS_ == 0);
  1323. ch = HDR_CMN(pktTx_);
  1324. mh = HDR_MAC802_11(pktTx_);
  1326. /*
  1327.  *  Broadcast packets don't get ACKed and therefore
  1328.  *  are never retransmitted.
  1329.  */
  1330. if((u_int32_t)ETHER_ADDR(mh->dh_ra) == MAC_BROADCAST) {
  1331. Packet::free(pktTx_); 
  1332. pktTx_ = 0;
  1334. /*
  1335.  * Backoff at end of TX.
  1336.  */
  1337. rst_cw();
  1338. mhBackoff_.start(cw_, is_idle());
  1340. return;
  1341. }
  1343. macmib_.ACKFailureCount++;
  1345. if((u_int32_t) ch->size() <= macmib_.getRTSThreshold()) {
  1346.                 rcount = &ssrc_;
  1347.                thresh = macmib_.getShortRetryLimit();
  1348.         } else {
  1349.                 rcount = &slrc_;
  1350.                thresh = macmib_.getLongRetryLimit();
  1351.         }
  1353. (*rcount)++;
  1357. if (*rcount == 3 && handoff == 0) {
  1358. //start handoff process
  1359. printf("Client %d: Handoff Attemptedn",index_);
  1360. associated = 0;
  1361. authenticated = 0;
  1362. handoff = 1;
  1363. ScanType_ = ACTIVE;
  1364. sendPROBEREQ(MAC_BROADCAST);
  1365. return;
  1366. }
  1367. if(*rcount >= thresh) {
  1368. /* IEEE Spec section 9.2.3.5 says this should be greater than
  1369.    or equal */
  1370. macmib_.FailedCount++;
  1371. /* tell the callback the send operation failed 
  1372.    before discarding the packet */
  1373. hdr_cmn *ch = HDR_CMN(pktTx_);
  1374. if (ch->xmit_failure_) {
  1375.                         ch->size() -= phymib_.getHdrLen11();
  1376. ch->xmit_reason_ = XMIT_REASON_ACK;
  1377.                         ch->xmit_failure_(pktTx_->copy(),
  1378.                                           ch->xmit_failure_data_);
  1379.                 }
  1381. discard(pktTx_, DROP_MAC_RETRY_COUNT_EXCEEDED); 
  1382. pktTx_ = 0;
  1383. *rcount = 0;
  1384. rst_cw();
  1385. }
  1386. else {
  1387. struct hdr_mac802_11 *dh;
  1388. dh = HDR_MAC802_11(pktTx_);
  1389. dh->dh_fc.fc_retry = 1;
  1392. sendRTS(ETHER_ADDR(mh->dh_ra));
  1393. inc_cw();
  1394. mhBackoff_.start(cw_, is_idle());
  1395. }
  1396. }
  1398. void
  1399. Mac802_11::RetransmitPROBEREP()
  1400. {
  1401. double rTime;
  1403. if(mhBackoff_.busy() == 0) {
  1404. if(is_idle()) {
  1405. if (mhDefer_.busy() == 0) {
  1406. /*
  1407.  * If we are already deferring, there is no
  1408.  * need to reset the Defer timer.
  1409.  */
  1410. if (bugFix_timer_) {
  1411.   mhBackoff_.start(cw_, is_idle(), 
  1412.   phymib_.getDIFS());
  1413. priority_queue[head] = 1;
  1414. }
  1415. else {
  1416. rTime = (Random::random() % cw_)
  1417. * (phymib_.getSlotTime());
  1418. mhDefer_.start(phymib_.getDIFS() + 
  1419.        rTime);
  1420. }
  1421. }
  1422. } else {
  1423. /*
  1424.  * If the medium is NOT IDLE, then we start
  1425.  * the backoff timer.
  1426.  */
  1427. mhBackoff_.start(cw_, is_idle());
  1428. priority_queue[head] = 1;
  1430. }
  1432. } else {
  1433. priority_queue[end()] = 1;
  1434. }
  1436. }
  1438. void
  1439. Mac802_11::RetransmitAUTHENTICATE()
  1440. {
  1441. double rTime;
  1443. if(mhBackoff_.busy() == 0) {
  1444. if(is_idle()) {
  1445. if (mhDefer_.busy() == 0) {
  1446. /*
  1447.  * If we are already deferring, there is no
  1448.  * need to reset the Defer timer.
  1449.  */
  1450. if (bugFix_timer_) {
  1451.   mhBackoff_.start(cw_, is_idle(), 
  1452.   phymib_.getDIFS());
  1453. priority_queue[head] = 3;
  1454. }
  1455. else {
  1456. rTime = (Random::random() % cw_)
  1457. * (phymib_.getSlotTime());
  1458. mhDefer_.start(phymib_.getDIFS() + 
  1459.        rTime);
  1460. }
  1461. }
  1462. } else {
  1463. /*
  1464.  * If the medium is NOT IDLE, then we start
  1465.  * the backoff timer.
  1466.  */
  1467. mhBackoff_.start(cw_, is_idle());
  1468. priority_queue[head] = 3;
  1470. }
  1472. } else {
  1473. priority_queue[end()] = 3;
  1474. }
  1476. }
  1478. void
  1479. Mac802_11::RetransmitASSOCREP()
  1480. {
  1481. double rTime;
  1483. if(mhBackoff_.busy() == 0) {
  1484. if(is_idle()) {
  1485. if (mhDefer_.busy() == 0) {
  1486. /*
  1487.  * If we are already deferring, there is no
  1488.  * need to reset the Defer timer.
  1489.  */
  1490. if (bugFix_timer_) {
  1491.   mhBackoff_.start(cw_, is_idle(), 
  1492.   phymib_.getDIFS());
  1493. priority_queue[head] = 4;
  1494. }
  1495. else {
  1496. rTime = (Random::random() % cw_)
  1497. * (phymib_.getSlotTime());
  1498. mhDefer_.start(phymib_.getDIFS() + 
  1499.        rTime);
  1500. }
  1501. }
  1502. } else {
  1503. /*
  1504.  * If the medium is NOT IDLE, then we start
  1505.  * the backoff timer.
  1506.  */
  1507. mhBackoff_.start(cw_, is_idle());
  1508. priority_queue[head] = 4;
  1510. }
  1512. } else {
  1513. priority_queue[end()] = 4;
  1514. }
  1516. }
  1517. /* ======================================================================
  1518.    Incoming Packet Routines
  1519.    ====================================================================== */
  1520. void
  1521. Mac802_11::send(Packet *p, Handler *h)
  1522. {
  1523. double rTime;
  1524. struct hdr_mac802_11* dh = HDR_MAC802_11(p);
  1526. EnergyModel *em = netif_->node()->energy_model();
  1527. if (em && em->sleep()) {
  1528. em->set_node_sleep(0);
  1529. em->set_node_state(EnergyModel::INROUTE);
  1530. }
  1532. callback_ = h;
  1533. sendDATA(p);
  1534. sendRTS(ETHER_ADDR(dh->dh_ra));
  1536. /*
  1537.  * Assign the data packet a sequence number.
  1538.  */
  1539. dh->dh_scontrol = sta_seqno_++;
  1541. /*
  1542.  *  If the medium is IDLE, we must wait for a DIFS
  1543.  *  Space before transmitting.
  1544.  */
  1545.        
  1546. if(mhBackoff_.busy() == 0) {
  1547. if(is_idle()) {
  1548. if (mhDefer_.busy() == 0) {
  1549. /*
  1550.  * If we are already deferring, there is no
  1551.  * need to reset the Defer timer.
  1552.  */
  1553. if (bugFix_timer_) {
  1554.  mhBackoff_.start(cw_, is_idle(), 
  1555.   phymib_.getDIFS());
  1556. }
  1557. else {
  1558. rTime = (Random::random() % cw_)
  1559. * (phymib_.getSlotTime());
  1560. mhDefer_.start(phymib_.getDIFS() + 
  1561.        rTime);
  1562. }
  1563. } 
  1564. } else {
  1565. /*
  1566.  * If the medium is NOT IDLE, then we start
  1567.  * the backoff timer.
  1568.  */
  1569. mhBackoff_.start(cw_, is_idle());
  1570. }
  1571. }
  1573. }
  1575. void
  1576. Mac802_11::recv(Packet *p, Handler *h)
  1577. {
  1578. struct hdr_cmn *hdr = HDR_CMN(p);
  1579. /*
  1580.  * Sanity Check
  1581.  */
  1582. assert(initialized());
  1584. /*
  1585.  *  Handle outgoing packets.
  1586.  */
  1587. if(hdr->direction() == hdr_cmn::DOWN) {
  1588.                 send(p, h);
  1589.                 return;
  1590.         }
  1591. /*
  1592.  *  Handle incoming packets.
  1593.  *
  1594.  *  We just received the 1st bit of a packet on the network
  1595.  *  interface.
  1596.  *
  1597.  */
  1599. /*
  1600.  *  If the interface is currently in transmit mode, then
  1601.  *  it probably won't even see this packet.  However, the
  1602.  *  "air" around me is BUSY so I need to let the packet
  1603.  *  proceed.  Just set the error flag in the common header
  1604.  *  to that the packet gets thrown away.
  1605.  */
  1606. if(tx_active_ && hdr->error() == 0) {
  1607. hdr->error() = 1;
  1608. }
  1610. if(rx_state_ == MAC_IDLE) {
  1611. setRxState(MAC_RECV);
  1612. pktRx_ = p;
  1613. /*
  1614.  * Schedule the reception of this packet, in
  1615.  * txtime seconds.
  1616.  */
  1617. if (mhProbe_.busy() && OnMinChannelTime) {
  1618. Recv_Busy_ = 1;  // Receiver busy indication for Probe Timer 
  1619. }
  1622. mhRecv_.start(txtime(p));
  1623. } else {
  1624. /*
  1625.  *  If the power of the incoming packet is smaller than the
  1626.  *  power of the packet currently being received by at least
  1627.                  *  the capture threshold, then we ignore the new packet.
  1628.  */
  1629. if(pktRx_->txinfo_.RxPr / p->txinfo_.RxPr >= p->txinfo_.CPThresh) {
  1630. capture(p);
  1631. } else {
  1632. collision(p);
  1633. }
  1634. }
  1635. }
  1637. void
  1638. Mac802_11::recv_timer()
  1639. {
  1640. u_int32_t src; 
  1641. hdr_cmn *ch = HDR_CMN(pktRx_);
  1642. hdr_mac802_11 *mh = HDR_MAC802_11(pktRx_);
  1643. u_int32_t dst = ETHER_ADDR(mh->dh_ra);
  1644. u_int32_t ap_dst = ETHER_ADDR(mh->dh_3a);
  1645. u_int8_t  type = mh->dh_fc.fc_type;
  1646. u_int8_t  subtype = mh->dh_fc.fc_subtype;
  1648. assert(pktRx_);
  1649. assert(rx_state_ == MAC_RECV || rx_state_ == MAC_COLL);
  1652.         /*
  1653.          *  If the interface is in TRANSMIT mode when this packet
  1654.          *  "arrives", then I would never have seen it and should
  1655.          *  do a silent discard without adjusting the NAV.
  1656.          */
  1657.         if(tx_active_) {
  1658.                 Packet::free(pktRx_);
  1659.                 goto done;
  1660.         }
  1662. /*
  1663.  * Handle collisions.
  1664.  */
  1665. if(rx_state_ == MAC_COLL) {
  1666. discard(pktRx_, DROP_MAC_COLLISION);
  1667. set_nav(usec(phymib_.getEIFS()));
  1668. goto done;
  1669. }
  1671. /*
  1672.  * Check to see if this packet was received with enough
  1673.  * bit errors that the current level of FEC still could not
  1674.  * fix all of the problems - ie; after FEC, the checksum still
  1675.  * failed.
  1676.  */
  1677. if( ch->error() ) {
  1678. Packet::free(pktRx_);
  1679. set_nav(usec(phymib_.getEIFS()));
  1680. goto done;
  1681. }
  1683. /*
  1684.  * IEEE 802.11 specs, section 9.2.5.6
  1685.  * - update the NAV (Network Allocation Vector)
  1686.  */
  1687. if(dst != (u_int32_t)index_) {
  1688. set_nav(mh->dh_duration);
  1689. }
  1691.         /* tap out - */
  1692.         if (tap_ && type == MAC_Type_Data &&
  1693.             MAC_Subtype_Data == subtype ) 
  1694. tap_->tap(pktRx_);
  1695. /*
  1696.  * Adaptive Fidelity Algorithm Support - neighborhood infomation 
  1697.  * collection
  1698.  *
  1699.  * Hacking: Before filter the packet, log the neighbor node
  1700.  * I can hear the packet, the src is my neighbor
  1701.  */
  1702. if (netif_->node()->energy_model() && 
  1703.     netif_->node()->energy_model()->adaptivefidelity()) {
  1704. src = ETHER_ADDR(mh->dh_ta);
  1705. netif_->node()->energy_model()->add_neighbor(src);
  1706. }
  1707. /*
  1708.  * Address Filtering
  1709.  */
  1710. if(dst != (u_int32_t)index_ && dst != MAC_BROADCAST) {
  1711. /*
  1712.  *  We don't want to log this event, so we just free
  1713.  *  the packet instead of calling the drop routine.
  1714.  */
  1715. discard(pktRx_, "---");
  1716. goto done;
  1717. }
  1720. if ( dst == MAC_BROADCAST && mh->dh_fc.fc_to_ds == 1 && mh->dh_fc.fc_from_ds == 1) {
  1721. if (addr() != bss_id_) {
  1722.   discard(pktRx_, "---");
  1723.   goto done;
  1724. }
  1725. if (addr() == bss_id_ && find_client(ap_dst) == 0) {
  1726. discard(pktRx_, "---");
  1727.   goto done;
  1728. }
  1729.   }
  1731. if ( addr() != bss_id_ && subtype == MAC_Subtype_ProbeReq) {
  1732. discard(pktRx_, "---");
  1733.   goto done;
  1734. }
  1736. switch(type) {
  1738. case MAC_Type_Management:
  1739. //discard(pktRx_, DROP_MAC_PACKET_ERROR);
  1740. switch(subtype) {
  1741. case MAC_Subtype_80211_Beacon:
  1742. recvBEACON(pktRx_);
  1743. break;
  1744. case MAC_Subtype_Auth:
  1745. recvAUTHENTICATE(pktRx_);
  1746. break;
  1747. case MAC_Subtype_AssocReq:
  1748. recvASSOCREQ(pktRx_);
  1749. break;
  1750. case MAC_Subtype_AssocRep:
  1751. recvASSOCREP(pktRx_);
  1752. break;
  1753. case MAC_Subtype_ProbeReq:
  1754. recvPROBEREQ(pktRx_);
  1755. break;
  1756. case MAC_Subtype_ProbeRep:
  1757. recvPROBEREP(pktRx_);
  1758. break;
  1759. default:
  1760. fprintf(stderr,"recvTimer1:Invalid MAC Management Subtype %xn",
  1761. subtype);
  1762. exit(1);
  1763. }
  1764. break;
  1765. case MAC_Type_Control:
  1766. switch(subtype) {
  1767. case MAC_Subtype_RTS:
  1768. recvRTS(pktRx_);
  1769. break;
  1770. case MAC_Subtype_CTS:
  1771. recvCTS(pktRx_);
  1772. break;
  1773. case MAC_Subtype_ACK:
  1774. recvACK(pktRx_);
  1775. break;
  1776. default:
  1777. fprintf(stderr,"recvTimer2:Invalid MAC Control Subtype %xn",
  1778. subtype);
  1779. exit(1);
  1780. }
  1781. break;
  1782. case MAC_Type_Data:
  1783. switch(subtype) {
  1784. case MAC_Subtype_Data:
  1785. recvDATA(pktRx_);
  1786. break;
  1787. default:
  1788. fprintf(stderr, "recv_timer3:Invalid MAC Data Subtype %xn",
  1789. subtype);
  1790. exit(1);
  1791. }
  1792. break;
  1793. default:
  1794. fprintf(stderr, "recv_timer4:Invalid MAC Type %xn", subtype);
  1795. exit(1);
  1796. }
  1797.  done:
  1798. pktRx_ = 0;
  1799. rx_resume();
  1801. }
  1804. void
  1805. Mac802_11::recvRTS(Packet *p)
  1806. {
  1807. struct rts_frame *rf = (struct rts_frame*)p->access(hdr_mac::offset_);
  1809. if(tx_state_ != MAC_IDLE) {
  1810. discard(p, DROP_MAC_BUSY);
  1811. return;
  1812. }
  1814. /*
  1815.  *  If I'm responding to someone else, discard this RTS.
  1816.  */
  1817. if(pktCTRL_) {
  1818. discard(p, DROP_MAC_BUSY);
  1819. return;
  1820. }
  1822. sendCTS(ETHER_ADDR(rf->rf_ta), rf->rf_duration);
  1824. /*
  1825.  *  Stop deferring - will be reset in tx_resume().
  1826.  */
  1827. if(mhDefer_.busy()) mhDefer_.stop();
  1829. tx_resume();
  1831. mac_log(p);
  1832. }
  1834. /*
  1835.  * txtime() - pluck the precomputed tx time from the packet header
  1836.  */
  1837. double
  1838. Mac802_11::txtime(Packet *p)
  1839. {
  1840. struct hdr_cmn *ch = HDR_CMN(p);
  1841. double t = ch->txtime();
  1842. if (t < 0.0) {
  1843. drop(p, "XXX");
  1844.   exit(1);
  1845. }
  1846. return t;
  1847. }
  1849.  
  1850. /*
  1851.  * txtime() - calculate tx time for packet of size "psz" bytes 
  1852.  *   at rate "drt" bps
  1853.  */
  1854. double
  1855. Mac802_11::txtime(double psz, double drt)
  1856. {
  1857. double dsz = psz - phymib_.getPLCPhdrLen();
  1858.         int plcp_hdr = phymib_.getPLCPhdrLen() << 3;
  1859. int datalen = (int)dsz << 3;
  1860. double t = (((double)plcp_hdr)/phymib_.getPLCPDataRate())
  1861.                                        + (((double)datalen)/drt);
  1862. return(t);
  1863. }
  1867. void
  1868. Mac802_11::recvCTS(Packet *p)
  1869. {
  1870. if(tx_state_ != MAC_RTS) {
  1871. discard(p, DROP_MAC_INVALID_STATE);
  1872. return;
  1873. }
  1875. assert(pktRTS_);
  1876. Packet::free(pktRTS_); pktRTS_ = 0;
  1878. assert(pktTx_);
  1879. mhSend_.stop();
  1881. /*
  1882.  * The successful reception of this CTS packet implies
  1883.  * that our RTS was successful. 
  1884.  * According to the IEEE spec 9.2.5.3, you must 
  1885.  * reset the ssrc_, but not the congestion window.
  1886.  */
  1887. ssrc_ = 0;
  1888. tx_resume();
  1890. mac_log(p);
  1891. }
  1893. void
  1894. Mac802_11::recvDATA(Packet *p)
  1895. {
  1896. struct hdr_mac802_11 *dh = HDR_MAC802_11(p);
  1897. u_int32_t dst, src, size;
  1898. struct hdr_cmn *ch = HDR_CMN(p);
  1900. dst = ETHER_ADDR(dh->dh_ra);
  1901. src = ETHER_ADDR(dh->dh_ta);
  1902. size = ch->size();
  1903. /*
  1904.  * Adjust the MAC packet size - ie; strip
  1905.  * off the mac header
  1906.  */
  1907. ch->size() -= phymib_.getHdrLen11();
  1908. ch->num_forwards() += 1;
  1910. /*
  1911.  *  If we sent a CTS, clean up...
  1912.  */
  1913. if(dst != MAC_BROADCAST) {
  1914. if(size >= macmib_.getRTSThreshold()) {
  1915. if (tx_state_ == MAC_CTS) {
  1916. assert(pktCTRL_);
  1917. Packet::free(pktCTRL_); pktCTRL_ = 0;
  1918. mhSend_.stop();
  1919. /*
  1920.  * Our CTS got through.
  1921.  */
  1922. } else {
  1923. discard(p, DROP_MAC_BUSY);
  1924. return;
  1925. }
  1926. sendACK(src);
  1927. tx_resume();
  1928. } else {
  1929. /*
  1930.  *  We did not send a CTS and there's no
  1931.  *  room to buffer an ACK.
  1932.  */
  1933. if(pktCTRL_) {
  1934. discard(p, DROP_MAC_BUSY);
  1935. return;
  1936. }
  1937. sendACK(src);
  1938. if(mhSend_.busy() == 0)
  1939. tx_resume();
  1940. }
  1941. }
  1943. /* ============================================================
  1944.    Make/update an entry in our sequence number cache.
  1945.    ============================================================ */
  1947. /* Changed by Debojyoti Dutta. This upper loop of if{}else was 
  1948.    suggested by Joerg Diederich <dieder@ibr.cs.tu-bs.de>. 
  1949.    Changed on 19th Oct'2000 */
  1951.         if(dst != MAC_BROADCAST) {
  1952.                 if (src < (u_int32_t) cache_node_count_) {
  1953.                         Host *h = &cache_[src];
  1955.                         if(h->seqno && h->seqno == dh->dh_scontrol) {
  1956.                                 discard(p, DROP_MAC_DUPLICATE);
  1957.                                 return;
  1958.                         }
  1959.                         h->seqno = dh->dh_scontrol;
  1960.                 } else {
  1961. static int count = 0;
  1962. if (++count <= 10) {
  1963. printf ("MAC_802_11: accessing MAC cache_ array out of range (src %u, dst %u, size %d)!n", src, dst, cache_node_count_);
  1964. if (count == 10)
  1965. printf ("[suppressing additional MAC cache_ warnings]n");
  1966. };
  1967. };
  1968. }
  1970. /*
  1971.  *  Pass the packet up to the link-layer.
  1972.  *  XXX - we could schedule an event to account
  1973.  *  for this processing delay.
  1974.  */
  1976. /* in BSS mode, if a station receives a packet via
  1977.  * the AP, and higher layers are interested in looking
  1978.  * at the src address, we might need to put it at
  1979.  * the right place - lest the higher layers end up
  1980.  * believing the AP address to be the src addr! a quick
  1981.  * grep didn't turn up any higher layers interested in
  1982.  * the src addr though!
  1983.  * anyway, here if I'm the AP and the destination
  1984.  * address (in dh_3a) isn't me, then we have to fwd
  1985.  * the packet; we pick the real destination and set
  1986.  * set it up for the LL; we save the real src into
  1987.  * the dh_3a field for the 'interested in the info'
  1988.  * receiver; we finally push the packet towards the
  1989.  * LL to be added back to my queue - accomplish this
  1990.  * by reversing the direction!*/
  1994. 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())) && dh->dh_fc.fc_from_ds == 0) {
  1995. struct hdr_cmn *ch = HDR_CMN(p);
  1998. u_int32_t dst = ETHER_ADDR(dh->dh_3a);
  1999. u_int32_t src = ETHER_ADDR(dh->dh_ta);
  2000. /* if it is a broadcast pkt then send a copy up
  2001.  * my stack also
  2002.  */
  2004. if (dst == MAC_BROADCAST) {
  2005. uptarget_->recv(p->copy(), (Handler*) 0);
  2006. }
  2008. ch->next_hop() = dst;
  2010. if (find_client(dst) == 1 || dst == MAC_BROADCAST) {
  2011. STORE4BYTE(&src, (dh->dh_3a));
  2012. } else {
  2013. STORE4BYTE(&src, (dh->dh_4a));
  2014. }
  2016. ch->addr_type() = NS_AF_ILINK;
  2017. ch->direction() = hdr_cmn::DOWN;
  2019. }
  2021.   if ((bss_id() == addr()) && dh->dh_fc.fc_to_ds == 1 && dh->dh_fc.fc_from_ds == 1) {
  2022.   u_int32_t dst = ETHER_ADDR(dh->dh_3a);
  2023.   u_int32_t src = ETHER_ADDR(dh->dh_4a);
  2024. if (find_client(src)) { 
  2025. update_client_table(src,0,0);   // If the source is from another BSS and it is found in this AP's table, delete the node from the table
  2026. }
  2027.   ch->next_hop() = dst;
  2028.   STORE4BYTE(&src, (dh->dh_3a));
  2029.   ch->addr_type() = NS_AF_ILINK;
  2030.   ch->direction() = hdr_cmn::DOWN;
  2031.   }
  2033. uptarget_->recv(p, (Handler*) 0);
  2035. }
  2038. void
  2039. Mac802_11::recvACK(Packet *p)
  2040. {
  2041. if (tx_state_ == MAC_MGMT) {
  2042. mhSend_.stop();
  2043. if (addr() == bss_id_) {
  2044. if (pktASSOCREP_ && priority_queue[head] == 4) {
  2045. Packet::free(pktASSOCREP_);
  2046. pktASSOCREP_ = 0;
  2047. update_client_table(associating_node_,1,1);
  2048. } 
  2049. if (pktPROBEREP_ && priority_queue[head] == 1) {
  2050. Packet::free(pktPROBEREP_);
  2051. pktPROBEREP_ = 0;
  2052. }
  2053. if (pktAUTHENTICATE_ && priority_queue[head] == 3) {
  2054. Packet::free(pktAUTHENTICATE_);
  2055. pktAUTHENTICATE_ = 0;
  2056. update_client_table(authenticating_node_,1,0);
  2057. }
  2058. }
  2059. goto done;
  2060. }
  2061. if(tx_state_ != MAC_SEND) {
  2062. discard(p, DROP_MAC_INVALID_STATE);
  2063. return;
  2064. }
  2065. assert(pktTx_);
  2067. mhSend_.stop();
  2069. /*
  2070.  * The successful reception of this ACK packet implies
  2071.  * that our DATA transmission was successful.  Hence,
  2072.  * we can reset the Short/Long Retry Count and the CW.
  2073.  *
  2074.  * need to check the size of the packet we sent that's being
  2075.  * ACK'd, not the size of the ACK packet.
  2076.  */
  2077. if((u_int32_t) HDR_CMN(pktTx_)->size() <= macmib_.getRTSThreshold())
  2078. ssrc_ = 0;
  2079. else
  2080. slrc_ = 0;
  2081. rst_cw();
  2082. Packet::free(pktTx_); 
  2083. pktTx_ = 0;
  2085. /*
  2086.  * Backoff before sending again.
  2087. //   */
  2089. assert(mhBackoff_.busy() == 0);
  2090. mhBackoff_.start(cw_, is_idle());
  2091. done:
  2092. if (addr() == bss_id_) {
  2093. if (end() > (head + 1)) {
  2094. shift_priority_queue();
  2095. assert(mhBackoff_.busy() == 0);
  2096. mhBackoff_.start(cw_, is_idle());
  2097. } else 
  2098. priority_queue[head] = 0;
  2099. }
  2101. tx_resume();
  2103. mac_log(p);
  2104. }
  2107. /* AP's association table funtions
  2108. */
  2109. void Mac802_11::update_client_table(int num, int auth_status, int assoc_status) {
  2110. if (client_list == NULL) {
  2111. client_list = (struct client_table*)malloc(sizeof(struct client_table));
  2112. client_list->client_id=num;
  2113. client_list->auth_status=auth_status;
  2114. client_list->assoc_status=assoc_status;
  2115. client_list->next=NULL;
  2116. }
  2117. else {
  2118. push(num, auth_status, assoc_status);
  2119. }
  2120. //  printf("Client List for AP %dn",index_);
  2121. //  struct client_table *temp;
  2122. //  temp = client_list;
  2123. // 
  2124. //  while (temp != NULL) {
  2125. //  printf("Client %d: Authenticated = %d Associated = %dn", temp->client_id,temp->auth_status,temp->assoc_status,NOW);
  2126. //  temp=temp->next;
  2127. //  }
  2128. //  printf("n");
  2130. }
  2132. void Mac802_11::push(int num, int auth_status, int assoc_status) {
  2133. struct client_table *temp;
  2134. temp = client_list;
  2135. while (temp != NULL) {
  2136. if (temp->client_id == num) {
  2137. temp->auth_status=auth_status;
  2138. temp->assoc_status=assoc_status;
  2139. return;
  2140. }
  2141. temp=temp->next;
  2143. if (temp == NULL) {
  2144. break; 
  2145. }
  2146. }
  2148. temp = client_list;
  2149. while (temp->next != NULL) {
  2150. temp=temp->next;
  2151. }
  2152. temp->next = (struct client_table*)malloc(sizeof(struct client_table));
  2153. temp->next->client_id = num;
  2154. temp->next->auth_status=auth_status;
  2155. temp->next->assoc_status=assoc_status;
  2156. temp->next->next = NULL; 
  2157. }
  2159. int Mac802_11::find_client(int num) {
  2160. struct client_table *temp;
  2161. temp = client_list;
  2162. while (temp != NULL) {
  2163. if (temp->client_id == num && temp->auth_status == 1 && temp->assoc_status == 1) {
  2164. return 1;
  2165. break;
  2166. }
  2168. temp=temp->next;
  2170. if (temp == NULL) {
  2171. return 0; 
  2172. }
  2173. }
  2174. return 0;
  2175. }
  2177. /* Beacon send and Receive functions
  2178. */
  2179. void
  2180. Mac802_11::sendBEACON(int src)
  2181. {
  2182. Packet *p = Packet::alloc();
  2184. hdr_cmn* ch = HDR_CMN(p);
  2185. struct beacon_frame *bf = (struct beacon_frame*)p->access(hdr_mac::offset_);
  2186. double rTime;
  2187. pktBEACON_ = 0;
  2189. ch->uid() = 0;
  2192. ch->ptype() = PT_MAC;
  2193. ch->size() = phymib_.getBEACONlen();
  2194. ch->iface() = -2;
  2195. ch->error() = 0;
  2197. bzero(bf, MAC_HDR_LEN);
  2199. /* Note: I had to give a different name for MAC_Subtype_80211_Beacon as MAC_Subtype_80211_Beacon as MAC_Subtype_80211_Beacon is already defined for 802.15.4 with a different value!! (See cmu-trace.cc).
  2200. */
  2202. bf->bf_fc.fc_protocol_version = MAC_ProtocolVersion;
  2203.   bf->bf_fc.fc_type = MAC_Type_Management;
  2204.   bf->bf_fc.fc_subtype = MAC_Subtype_80211_Beacon;
  2205.   bf->bf_fc.fc_to_ds = 0;
  2206.   bf->bf_fc.fc_from_ds = 0;
  2207.   bf->bf_fc.fc_more_frag = 0;
  2208.   bf->bf_fc.fc_retry = 0;
  2209.   bf->bf_fc.fc_pwr_mgt = 0;
  2210.   bf->bf_fc.fc_more_data = 0;
  2211.   bf->bf_fc.fc_wep = 0;
  2212.   bf->bf_fc.fc_order = 0;
  2214. int  dst = MAC_BROADCAST;
  2215. STORE4BYTE(&dst, (bf->bf_ra));
  2216. STORE4BYTE(&src, (bf->bf_ta));
  2217. STORE4BYTE(&ap_addr, (bf->bf_3a));
  2219. bf->bf_timestamp = Scheduler::instance().clock();
  2220. bf->bf_bcninterval = phymib_.getBeaconInterval();
  2222. /* store beacon tx time */
  2224.   ch->txtime() = txtime(ch->size(), basicRate_);
  2226. /* calculate beacon duration??? */
  2227.   bf->bf_duration = 0;
  2229. pktBEACON_ = p;
  2231. BeaconTxtime_ = txtime(phymib_.getBEACONlen(), basicRate_);
  2233. if(mhBackoff_.busy() == 0) {
  2234. if(is_idle()) {
  2235. if (mhDefer_.busy() == 0) {
  2237. if (bugFix_timer_) {
  2238.   mhBackoff_.start(cw_, is_idle(), 
  2239.   phymib_.getDIFS());
  2240. priority_queue[head] = 2;
  2241. }
  2242. else {
  2243. rTime = (Random::random() % cw_)
  2244. * (phymib_.getSlotTime());
  2245. mhDefer_.start(phymib_.getDIFS() + 
  2246.        rTime);
  2247. }
  2248. }
  2249. } else {
  2250. /*
  2251.  * If the medium is NOT IDLE, then we start
  2252.  * the backoff timer.
  2253.  */
  2255. mhBackoff_.start(cw_, is_idle());
  2256. priority_queue[head] = 2;
  2257. }
  2258. } else {
  2259. priority_queue[end()] = 2;
  2260. }
  2262. }
  2264. int
  2265. Mac802_11::check_pktBEACON()
  2266. {
  2267. struct beacon_frame *bf = (struct beacon_frame*)pktBEACON_->access(hdr_mac::offset_);
  2268. bf->bf_timestamp = Scheduler::instance().clock();
  2270. struct hdr_mac802_11 *mh;
  2271. double timeout;
  2273. assert(mhBackoff_.busy() == 0);
  2275. if(pktBEACON_ == 0)
  2276.   return -1;
  2277. mh = HDR_MAC802_11(pktBEACON_);
  2279.   switch(mh->dh_fc.fc_subtype) {
  2280. case MAC_Subtype_80211_Beacon:
  2281. if(! is_idle()) {
  2282. inc_cw();
  2283. mhBackoff_.start(cw_, is_idle());
  2284. return 0;
  2285. }
  2286. setTxState(MAC_BCN);
  2287. timeout = txtime(phymib_.getBEACONlen(), basicRate_);
  2288. break;
  2289. default:
  2290. fprintf(stderr, "check_pktBEACON:Invalid MAC Control subtypen");
  2291. exit(1);
  2292. }
  2293. transmit(pktBEACON_, timeout);
  2295. return 0;
  2296. }
  2297.  
  2299. void
  2300. Mac802_11::recvBEACON(Packet *p)
  2301. {
  2302. struct beacon_frame *bf = (struct beacon_frame*)p->access(hdr_mac::offset_);
  2304. if(tx_state_ != MAC_IDLE) {
  2305. discard(p, DROP_MAC_BUSY);
  2306. return;
  2307. }
  2308. u_int32_t bss_id, src;
  2310. //double timestamp, beaconint;
  2311. bss_id = ETHER_ADDR(bf->bf_3a);
  2312.   src = ETHER_ADDR(bf->bf_ta);
  2313. infra_mode_ = 1;
  2314. //timestamp = bf->bf_timestamp;
  2315. Pr = p->txinfo_.RxPr;
  2316. if ( addr() != ap_addr && ScanType_ == PASSIVE) {
  2317. if (authenticated == 0 && associated == 0) {
  2318. if (find_ap(src,Pr) != 1) {
  2319. update_ap_table(src,Pr);
  2320. }
  2321.   }
  2322. }
  2324. mac_log(p);
  2325. }
  2327. void
  2328. Mac802_11::passive_scan()
  2329. {
  2330. if ( addr() != ap_addr && ScanType_ == PASSIVE) {
  2331. if (authenticated == 0 && associated == 0) {
  2332. ap_temp = strongest_ap();
  2333. if (!pktAUTHENTICATE_)
  2334. sendAUTHENTICATE(ap_temp);
  2335. }
  2337. }
  2338. }
  2339. void
  2340. Mac802_11::active_scan()
  2341. {
  2343. if ( addr() != ap_addr && ScanType_ == ACTIVE) {
  2344. if (authenticated == 0 && associated == 0) {
  2345. ap_temp = strongest_ap();
  2346. sendAUTHENTICATE(ap_temp);
  2347. }
  2349. }
  2350. }
  2353. // Association functions
  2355. void
  2356. Mac802_11::sendASSOCREQ(int dst)
  2357. {
  2358. Packet *p = Packet::alloc();
  2359. hdr_cmn* ch = HDR_CMN(p);
  2360. struct assocreq_frame *acrqf =(struct assocreq_frame*)p->access(hdr_mac::offset_);
  2362. double rTime;
  2363. pktASSOCREQ_ = 0;
  2365. ch->uid() = 0;
  2368. ch->ptype() = PT_MAC;
  2369. ch->size() = phymib_.getASSOCREQlen();
  2370. ch->iface() = -2;
  2371. ch->error() = 0;
  2373. bzero(acrqf, MAC_HDR_LEN);
  2375. acrqf->acrqf_fc.fc_protocol_version = MAC_ProtocolVersion;
  2376.   acrqf->acrqf_fc.fc_type = MAC_Type_Management;
  2377.   acrqf->acrqf_fc.fc_subtype = MAC_Subtype_AssocReq;
  2378.   acrqf->acrqf_fc.fc_to_ds = 0;
  2379.   acrqf->acrqf_fc.fc_from_ds = 0;
  2380.   acrqf->acrqf_fc.fc_more_frag= 0;
  2381.   acrqf->acrqf_fc.fc_retry = 0;
  2382.   acrqf->acrqf_fc.fc_pwr_mgt = 0;
  2383.   acrqf->acrqf_fc.fc_more_data= 0;
  2384.   acrqf->acrqf_fc.fc_wep = 0;
  2385.   acrqf->acrqf_fc.fc_order = 0;
  2387. STORE4BYTE(&dst, (acrqf->acrqf_ra));
  2388. STORE4BYTE(&index_, (acrqf->acrqf_ta));
  2389. STORE4BYTE(&dst, (acrqf->acrqf_3a));
  2392. ch->txtime() = txtime(ch->size(), basicRate_);
  2393.   acrqf->acrqf_duration = 0;
  2396. pktASSOCREQ_ = p;
  2398. if(mhBackoff_.busy() == 0) {
  2399. if(is_idle()) {
  2400. if (mhDefer_.busy() == 0) {
  2401. /*
  2402.  * If we are already deferring, there is no
  2403.  * need to reset the Defer timer.
  2404.  */
  2405. if (bugFix_timer_) {
  2406.   mhBackoff_.start(cw_, is_idle(), 
  2407.   phymib_.getDIFS());
  2408. }
  2409. else {
  2410. rTime = (Random::random() % cw_)
  2411. * (phymib_.getSlotTime());
  2412. mhDefer_.start(phymib_.getDIFS() + 
  2413.        rTime);
  2414. }
  2415. }
  2416. } else {
  2417. /*
  2418.  * If the medium is NOT IDLE, then we start
  2419.  * the backoff timer.
  2420.  */
  2421. mhBackoff_.start(cw_, is_idle());
  2422. }
  2423. }
  2424. }
  2426. int
  2427. Mac802_11::check_pktASSOCREQ()
  2428. {
  2429. struct hdr_mac802_11 *mh;
  2430. double timeout;
  2432. assert(mhBackoff_.busy() == 0);
  2434. if(pktASSOCREQ_ == 0)
  2435.   return -1;
  2436. mh = HDR_MAC802_11(pktASSOCREQ_);
  2438.   switch(mh->dh_fc.fc_subtype) {
  2439. case MAC_Subtype_AssocReq:
  2440. if(! is_idle()) {
  2441. inc_cw();
  2442. mhBackoff_.start(cw_, is_idle());
  2443. return 0;
  2444. }
  2445. setTxState(MAC_MGMT);
  2446. timeout = txtime(phymib_.getASSOCREQlen(), basicRate_)
  2447. + DSSS_MaxPropagationDelay
  2448. + macmib_.getMaxChannelTime()
  2449. + txtime(phymib_.getASSOCREPlen(), basicRate_)
  2450. + DSSS_MaxPropagationDelay;
  2451. break;
  2452. default:
  2453. fprintf(stderr, "check_pktASSOCREQ:Invalid MAC Control subtypen");
  2454. exit(1);
  2455. }
  2456. transmit(pktASSOCREQ_, timeout);
  2457.   
  2459. return 0;
  2460. }
  2462. void
  2463. Mac802_11::sendASSOCREP(int dst)
  2464. {
  2465. Packet *p = Packet::alloc();
  2466. hdr_cmn* ch = HDR_CMN(p);
  2467. struct assocrep_frame *acrpf =(struct assocrep_frame*)p->access(hdr_mac::offset_);
  2468. double rTime;
  2469. pktASSOCREP_ = 0;
  2471. ch->uid() = 0;
  2474. ch->ptype() = PT_MAC;
  2475. ch->size() = phymib_.getASSOCREPlen();
  2476. ch->iface() = -2;
  2477. ch->error() = 0;
  2479. bzero(acrpf, MAC_HDR_LEN);
  2481. acrpf->acrpf_fc.fc_protocol_version = MAC_ProtocolVersion;
  2482.   acrpf->acrpf_fc.fc_type = MAC_Type_Management;
  2483.   acrpf->acrpf_fc.fc_subtype = MAC_Subtype_AssocRep;
  2484.   acrpf->acrpf_fc.fc_to_ds = 0;
  2485.   acrpf->acrpf_fc.fc_from_ds = 0;
  2486.   acrpf->acrpf_fc.fc_more_frag= 0;
  2487.   acrpf->acrpf_fc.fc_retry = 0;
  2488.   acrpf->acrpf_fc.fc_pwr_mgt = 0;
  2489.   acrpf->acrpf_fc.fc_more_data= 0;
  2490.   acrpf->acrpf_fc.fc_wep = 0;
  2491.   acrpf->acrpf_fc.fc_order = 0;
  2493. STORE4BYTE(&dst, (acrpf->acrpf_ra));
  2494. STORE4BYTE(&index_, (acrpf->acrpf_ta));
  2495. STORE4BYTE(&index_, (acrpf->acrpf_3a));
  2497. acrpf->acrpf_statuscode = 0;
  2498. ch->txtime() = txtime(ch->size(), basicRate_);
  2499.   acrpf->acrpf_duration = 0;
  2502.   pktASSOCREP_ = p;
  2504. if(mhBackoff_.busy() == 0) {
  2505. if(is_idle()) {
  2506. if (mhDefer_.busy() == 0) {
  2507. /*
  2508.  * If we are already deferring, there is no
  2509.  * need to reset the Defer timer.
  2510.  */
  2511. if (bugFix_timer_) {
  2512.   mhBackoff_.start(cw_, is_idle(), 
  2513.   phymib_.getDIFS());
  2514. priority_queue[head] = 4;
  2515. }
  2516. else {
  2517. rTime = (Random::random() % cw_)
  2518. * (phymib_.getSlotTime());
  2519. mhDefer_.start(phymib_.getDIFS() + 
  2520.        rTime);
  2521. }
  2522. }
  2523. } else {
  2524. /*
  2525.  * If the medium is NOT IDLE, then we start
  2526.  * the backoff timer.
  2527.  */
  2528. mhBackoff_.start(cw_, is_idle());
  2529. priority_queue[head] = 4;
  2531. } 
  2534. } else {
  2535. priority_queue[end()] = 4;
  2536. }
  2538. }
  2540. int
  2541. Mac802_11::check_pktASSOCREP()
  2542. {
  2543.   struct hdr_mac802_11 *mh;
  2544.   double timeout;
  2546.   assert(mhBackoff_.busy() == 0);
  2547.   if(pktASSOCREP_ == 0)
  2548.    return -1;
  2549. mh = HDR_MAC802_11(pktASSOCREP_);
  2550.    switch(mh->dh_fc.fc_subtype) {
  2551.   case MAC_Subtype_AssocRep:
  2552.   if(!is_idle()) {
  2553.   inc_cw();
  2554. mhBackoff_.start(cw_, is_idle());
  2555. return 0;
  2556.   }
  2558.   setTxState(MAC_MGMT);
  2559.   timeout = txtime(phymib_.getASSOCREPlen(), basicRate_)
  2560. + DSSS_MaxPropagationDelay
  2561. + phymib_.getSIFS()
  2562. + txtime(phymib_.getACKlen(), basicRate_)
  2563. + DSSS_MaxPropagationDelay;
  2565.   break;
  2566. default:
  2567.   fprintf(stderr, "check_pktASSOCREP:Invalid MAC Control subtypen");
  2568.   exit(1);
  2569. }
  2570.   transmit(pktASSOCREP_, timeout);
  2572.   return 0;
  2573. }
  2575. void
  2576. Mac802_11::recvASSOCREQ(Packet *p)
  2577. {
  2578. struct assocreq_frame *acrqf = (struct assocreq_frame*)p->access(hdr_mac::offset_);
  2580. if(tx_state_ != MAC_IDLE) {
  2581. discard(p, DROP_MAC_BUSY);
  2582. return;
  2583. }
  2584. u_int32_t bss_id, src;
  2586. bss_id = ETHER_ADDR(acrqf->acrqf_3a);
  2587.   src = ETHER_ADDR(acrqf->acrqf_ta);
  2589. if (!pktASSOCREP_) {
  2590. sendASSOCREP(src);
  2591. associating_node_ = src;
  2592. } else {
  2593. discard(p, DROP_MAC_BUSY);
  2594. return;
  2595. }
  2596. tx_resume();
  2598. mac_log(p);
  2599. }
  2601. void
  2602. Mac802_11::recvASSOCREP(Packet *p)
  2603. {
  2604. struct assocrep_frame *acrpf = (struct assocrep_frame*)p->access(hdr_mac::offset_);
  2606. assert(pktASSOCREQ_);
  2607. Packet::free(pktASSOCREQ_);
  2608. pktASSOCREQ_ = 0;
  2609. mhSend_.stop();
  2611. u_int32_t src;
  2612. u_int16_t statuscode;
  2614.   src = ETHER_ADDR(acrpf->acrpf_ta);
  2615. statuscode = acrpf->acrpf_statuscode;
  2617. if (statuscode == 0) {
  2618. associated = 1;
  2619. deletelist();
  2620. if (handoff) {
  2621. handoff = 0; //handoff completed
  2622. }
  2623. sendACK(src);
  2625. }
  2626. if(mhSend_.busy() == 0)
  2627. tx_resume();
  2629. mac_log(p);
  2632. }
  2634. //Authentication functions
  2636. void
  2637. Mac802_11::sendAUTHENTICATE(int dst)
  2638. {
  2639. Packet *p = Packet::alloc();
  2640. hdr_cmn* ch = HDR_CMN(p);
  2641. struct auth_frame *authf =(struct auth_frame*)p->access(hdr_mac::offset_);
  2643. double rTime;
  2644. pktAUTHENTICATE_ = 0;
  2646. ch->uid() = 0;
  2649. ch->ptype() = PT_MAC;
  2650. ch->size() = phymib_.getAUTHENTICATElen();
  2651. ch->iface() = -2;
  2652. ch->error() = 0;
  2654. bzero(authf, MAC_HDR_LEN);
  2656. authf->authf_fc.fc_protocol_version = MAC_ProtocolVersion;
  2657.   authf->authf_fc.fc_type = MAC_Type_Management;
  2658.   authf->authf_fc.fc_subtype = MAC_Subtype_Auth;
  2659.   authf->authf_fc.fc_to_ds = 0;
  2660.   authf->authf_fc.fc_from_ds = 0;
  2661.   authf->authf_fc.fc_more_frag= 0;
  2662.   authf->authf_fc.fc_retry = 0;
  2663.   authf->authf_fc.fc_pwr_mgt = 0;
  2664.   authf->authf_fc.fc_more_data= 0;
  2665.   authf->authf_fc.fc_wep = 0;
  2666.   authf->authf_fc.fc_order = 0;
  2669. STORE4BYTE(&dst, (authf->authf_ra));
  2670. STORE4BYTE(&index_, (authf->authf_ta));
  2671. if (addr() != bss_id_)
  2672. STORE4BYTE(&dst, (authf->authf_3a));
  2673. else 
  2674. STORE4BYTE(&index_, (authf->authf_3a));
  2675. authf->authf_algono = 0; //Open system authentication
  2677. if (addr() != bss_id_) {
  2678. authf->authf_seqno = 1;  // 
  2679. } else {
  2680. authf->authf_seqno = 2;  //
  2681. authf->authf_statuscode = 0;
  2682. }
  2684. ch->txtime() = txtime(ch->size(), basicRate_);
  2685. if (addr() == bss_id_) {
  2686.   authf->authf_duration = usec(txtime(phymib_.getACKlen(), basicRate_)
  2687.        + phymib_.getSIFS());
  2688. } else { 
  2689. authf->authf_duration = 0;
  2690. }
  2693. pktAUTHENTICATE_ = p;
  2695. if(mhBackoff_.busy() == 0) {
  2696. if(is_idle()) {
  2697. if (mhDefer_.busy() == 0) {
  2698. /*
  2699.  * If we are already deferring, there is no
  2700.  * need to reset the Defer timer.
  2701.  */
  2702. if (bugFix_timer_) {
  2703.   mhBackoff_.start(cw_, is_idle(), 
  2704.   phymib_.getDIFS());
  2705. priority_queue[head] = 3;
  2706. }
  2707. else {
  2708. rTime = (Random::random() % cw_)
  2709. * (phymib_.getSlotTime());
  2710. mhDefer_.start(phymib_.getDIFS() + 
  2711.        rTime);
  2712. }
  2713. }
  2714. } else {
  2715. /*
  2716.  * If the medium is NOT IDLE, then we start
  2717.  * the backoff timer.
  2718.  */
  2719. mhBackoff_.start(cw_, is_idle());
  2720. priority_queue[head] = 3;
  2722. }
  2723. } else {
  2724. priority_queue[end()] = 3;
  2725. }
  2727. }
  2729. int
  2730. Mac802_11::check_pktAUTHENTICATE()
  2731. {
  2732. struct hdr_mac802_11 *mh;
  2733. double timeout;
  2735. assert(mhBackoff_.busy() == 0);
  2737. if(pktAUTHENTICATE_ == 0)
  2738.   return -1;
  2739. mh = HDR_MAC802_11(pktAUTHENTICATE_);
  2741.   switch(mh->dh_fc.fc_subtype) {
  2742. case MAC_Subtype_Auth:
  2743. if(! is_idle()) {
  2744. inc_cw();
  2745. mhBackoff_.start(cw_, is_idle());
  2746. return 0;
  2747. }
  2748. setTxState(MAC_MGMT);
  2749. if (addr() != bss_id_) {
  2750. timeout = txtime(phymib_.getAUTHENTICATElen(), basicRate_)
  2751. + DSSS_MaxPropagationDelay                      // XXX
  2752. + macmib_.getMaxChannelTime()
  2753. + txtime(phymib_.getAUTHENTICATElen(), basicRate_)
  2754. + DSSS_MaxPropagationDelay;
  2755. } else {
  2756. timeout = txtime(phymib_.getAUTHENTICATElen(), basicRate_)
  2757. + DSSS_MaxPropagationDelay                      // XXX
  2758. + phymib_.getSIFS()
  2759. + txtime(phymib_.getACKlen(), basicRate_)
  2760. + DSSS_MaxPropagationDelay;
  2761. }
  2762. break;
  2763. default:
  2764. fprintf(stderr, "check_pktAUTHENTICATE:Invalid MAC Control subtypen");
  2765. exit(1);
  2766. }
  2768. transmit(pktAUTHENTICATE_, timeout);
  2770. return 0;
  2771. }
  2773. void
  2774. Mac802_11::recvAUTHENTICATE(Packet *p)
  2775. {
  2776. struct auth_frame *authf = (struct auth_frame*)p->access(hdr_mac::offset_);
  2778. if (addr() != bss_id_) {
  2779. assert(pktAUTHENTICATE_);
  2780. Packet::free(pktAUTHENTICATE_);
  2781. pktAUTHENTICATE_ = 0;
  2782. mhSend_.stop();
  2783. } else {
  2784. if ( tx_state_ != MAC_IDLE) {
  2785. discard(p, DROP_MAC_BUSY);
  2786. return;
  2787. }
  2788. }
  2790. u_int32_t src;
  2792.   src = ETHER_ADDR(authf->authf_ta);
  2794. if (addr() == ap_addr) {
  2795. if (authf->authf_seqno == 1) {
  2796. if (!pktAUTHENTICATE_) {// AP is not currently involved in Authentication with any other STA 
  2797. sendAUTHENTICATE(src);
  2798. authenticating_node_ = src;
  2799. } else {
  2800. discard(p, DROP_MAC_BUSY);
  2801. return;
  2802. }
  2803. } else 
  2804. printf("Out of sequencen");
  2805. } else if (authf->authf_seqno == 2 && authf->authf_statuscode == 0) {
  2806. authenticated = 1;
  2807. if (bss_id_ != ETHER_ADDR(authf->authf_3a) && handoff == 1) {
  2808. printf("Client %d: Handoff from AP %d to AP %dn",index_, bss_id_,ETHER_ADDR(authf->authf_3a));
  2809. }
  2810. bss_id_ = ETHER_ADDR(authf->authf_3a);
  2811. sendACK(src);
  2812. mhProbe_.start(phymib_.getSIFS() + txtime(phymib_.getACKlen(), basicRate_) + macmib_.getMaxChannelTime());
  2814. }
  2816. if(mhSend_.busy() == 0)
  2817. tx_resume();
  2819. mac_log(p);
  2821. }
  2823. // Active Scanning Functions 
  2824. void
  2825. Mac802_11::sendPROBEREQ(int dst)
  2826. {
  2827. Packet *p = Packet::alloc();
  2828. hdr_cmn* ch = HDR_CMN(p);
  2829. struct probereq_frame *prrqf =(struct probereq_frame*)p->access(hdr_mac::offset_);
  2831. double rTime;
  2832. pktPROBEREQ_ = 0;
  2834. ch->uid() = 0;
  2837. ch->ptype() = PT_MAC;
  2838. ch->size() = phymib_.getPROBEREQlen();
  2839. ch->iface() = -2;
  2840. ch->error() = 0;
  2842. bzero(prrqf, MAC_HDR_LEN);
  2844. prrqf->prrqf_fc.fc_protocol_version = MAC_ProtocolVersion;
  2845.   prrqf->prrqf_fc.fc_type = MAC_Type_Management;
  2846.   prrqf->prrqf_fc.fc_subtype = MAC_Subtype_ProbeReq;
  2847.   prrqf->prrqf_fc.fc_to_ds = 0;
  2848.   prrqf->prrqf_fc.fc_from_ds = 0;
  2849.   prrqf->prrqf_fc.fc_more_frag= 0;
  2850.   prrqf->prrqf_fc.fc_retry = 0;
  2851.   prrqf->prrqf_fc.fc_pwr_mgt = 0;
  2852.   prrqf->prrqf_fc.fc_more_data= 0;
  2853.   prrqf->prrqf_fc.fc_wep = 0;
  2854.   prrqf->prrqf_fc.fc_order = 0;
  2857. STORE4BYTE(&dst, (prrqf->prrqf_ra));
  2858. STORE4BYTE(&index_, (prrqf->prrqf_ta));
  2859. STORE4BYTE(&dst, (prrqf->prrqf_3a));
  2862. ch->txtime() = txtime(ch->size(), basicRate_);
  2863.   prrqf->prrqf_duration = 0;
  2866. pktPROBEREQ_ = p;
  2868. if(mhBackoff_.busy() == 0) {
  2869. if(is_idle()) {
  2870. if (mhDefer_.busy() == 0) {
  2871. /*
  2872.  * If we are already deferring, there is no
  2873.  * need to reset the Defer timer.
  2874.  */
  2875. if (bugFix_timer_) {
  2876.   mhBackoff_.start(cw_, is_idle(), 
  2877.   phymib_.getDIFS());
  2878. }
  2879. else {
  2880. rTime = (Random::random() % cw_)
  2881. * (phymib_.getSlotTime());
  2882. mhDefer_.start(phymib_.getDIFS() + 
  2883.        rTime);
  2884. }
  2885. }
  2886. } else {
  2887. /*
  2888.  * If the medium is NOT IDLE, then we start
  2889.  * the backoff timer.
  2890.  */
  2891. mhBackoff_.start(cw_, is_idle());
  2893. }
  2894. }
  2895. }
  2898. int
  2899. Mac802_11::check_pktPROBEREQ()
  2900. {
  2901. struct hdr_mac802_11 *mh;
  2902. double timeout;
  2904. assert(mhBackoff_.busy() == 0);
  2906. if(pktPROBEREQ_ == 0)
  2907.   return -1;
  2908. mh = HDR_MAC802_11(pktPROBEREQ_);
  2910.   switch(mh->dh_fc.fc_subtype) {
  2911. case MAC_Subtype_ProbeReq:
  2912. if(! is_idle()) {
  2913. inc_cw();
  2914. mhBackoff_.start(cw_, is_idle());
  2915. return 0;
  2916. }
  2917. setTxState(MAC_MGMT);
  2918. timeout = txtime(phymib_.getPROBEREQlen(), basicRate_)
  2919. + DSSS_MaxPropagationDelay;                      // XXX
  2920. break;
  2921. default:
  2922. fprintf(stderr, "check_pktPROBEREQ:Invalid MAC Control subtypen");
  2923. exit(1);
  2924. }
  2925. transmit(pktPROBEREQ_, timeout);
  2926. mhProbe_.start(macmib_.getMinChannelTime());
  2927. OnMinChannelTime = 1;
  2928. return 0;
  2929. }
  2933. void
  2934. Mac802_11::sendPROBEREP(int dst)
  2935. {
  2936. Packet *p = Packet::alloc();
  2938. hdr_cmn* ch = HDR_CMN(p);
  2939. struct proberep_frame *prrpf = (struct proberep_frame*)p->access(hdr_mac::offset_);
  2941. pktPROBEREP_ = 0;
  2943. ch->uid() = 0;
  2945. double rTime;
  2947. ch->ptype() = PT_MAC;
  2948. ch->size() = phymib_.getPROBEREPlen();
  2949. ch->iface() = -2;
  2950. ch->error() = 0;
  2952. bzero(prrpf, MAC_HDR_LEN);
  2954. prrpf->prrpf_fc.fc_protocol_version = MAC_ProtocolVersion;
  2955.   prrpf->prrpf_fc.fc_type = MAC_Type_Management;
  2956.   prrpf->prrpf_fc.fc_subtype = MAC_Subtype_ProbeRep;
  2957.   prrpf->prrpf_fc.fc_to_ds = 0;
  2958.   prrpf->prrpf_fc.fc_from_ds = 0;
  2959.   prrpf->prrpf_fc.fc_more_frag= 0;
  2960.   prrpf->prrpf_fc.fc_retry = 0;
  2961.   prrpf->prrpf_fc.fc_pwr_mgt = 0;
  2962.   prrpf->prrpf_fc.fc_more_data= 0;
  2963.   prrpf->prrpf_fc.fc_wep = 0;
  2964.   prrpf->prrpf_fc.fc_order = 0;
  2966. STORE4BYTE(&dst, (prrpf->prrpf_ra));
  2967. STORE4BYTE(&index_, (prrpf->prrpf_ta));
  2968. STORE4BYTE(&index_, (prrpf->prrpf_3a));
  2970. // prrpf->prrpf_timestamp = Scheduler::instance().clock();
  2971. prrpf->prrpf_bcninterval = phymib_.getBeaconInterval();
  2973. ch->txtime() = txtime(ch->size(), basicRate_);
  2974.   prrpf->prrpf_duration = 0;
  2976. pktPROBEREP_ = p;
  2978. if(mhBackoff_.busy() == 0) {
  2979. if(is_idle()) {
  2980. if (mhDefer_.busy() == 0) {
  2981. /*
  2982.  * If we are already deferring, there is no
  2983.  * need to reset the Defer timer.
  2984.  */
  2985. if (bugFix_timer_) {
  2986.   mhBackoff_.start(cw_, is_idle(), 
  2987.   phymib_.getDIFS());
  2988. priority_queue[head] = 1;
  2989. }
  2990. else {
  2991. rTime = (Random::random() % cw_)
  2992. * (phymib_.getSlotTime());
  2993. mhDefer_.start(phymib_.getDIFS() + 
  2994.        rTime);
  2995. }
  2996. }
  2997. } else {
  2998. /*
  2999.  * If the medium is NOT IDLE, then we start
  3000.  * the backoff timer.
  3001.  */
  3002. mhBackoff_.start(cw_, is_idle());
  3003. priority_queue[head] = 1;
  3005. }
  3007. } else {
  3008. priority_queue[end()] = 1;
  3009. }
  3011. }
  3013. int
  3014. Mac802_11::check_pktPROBEREP()
  3015. {
  3016. struct proberep_frame *prrpf = (struct proberep_frame*)pktPROBEREP_->access(hdr_mac::offset_);
  3017. prrpf->prrpf_timestamp = Scheduler::instance().clock();
  3019. struct hdr_mac802_11 *mh;
  3020. double timeout;
  3022. assert(mhBackoff_.busy() == 0);
  3024. if(pktPROBEREP_ == 0)
  3025.   return -1;
  3026. mh = HDR_MAC802_11(pktPROBEREP_);
  3028.   switch(mh->dh_fc.fc_subtype) {
  3029. case MAC_Subtype_ProbeRep:
  3030. if(! is_idle()) {
  3031. inc_cw();
  3032. mhBackoff_.start(cw_, is_idle());
  3033. return 0;
  3034. }
  3035. setTxState(MAC_MGMT);
  3036. timeout = txtime(phymib_.getPROBEREPlen(), basicRate_)
  3037. + DSSS_MaxPropagationDelay                     // XXX
  3038. + phymib_.getSIFS()
  3039. + txtime(phymib_.getACKlen(), basicRate_)
  3040. + DSSS_MaxPropagationDelay;
  3041. break;
  3042. default:
  3043. fprintf(stderr, "check_pktPROBEREP:Invalid MAC Control subtypen");
  3044. exit(1);
  3045. }
  3046. transmit(pktPROBEREP_, timeout);
  3047.   
  3049. return 0;
  3050. }
  3053. void
  3054. Mac802_11::recvPROBEREQ(Packet *p)
  3055. {
  3056. struct probereq_frame *prrqf = (struct probereq_frame*)p->access(hdr_mac::offset_);
  3058. if(tx_state_ != MAC_IDLE) {
  3059. discard(p, DROP_MAC_BUSY);
  3060. return;
  3061. }
  3062. u_int32_t bss_id, src;
  3063. bss_id = ETHER_ADDR(prrqf->prrqf_3a);
  3064.   src = ETHER_ADDR(prrqf->prrqf_ta);
  3066. if (!pktPROBEREP_) {
  3067. sendPROBEREP(src);
  3068. } else {
  3069. discard(p, DROP_MAC_BUSY);
  3070. return;
  3071. }  
  3074. tx_resume();
  3076. mac_log(p);
  3077. }
  3079. void
  3080. Mac802_11::recvPROBEREP(Packet *p)
  3081. {
  3082. struct proberep_frame *prrpf = (struct proberep_frame*)p->access(hdr_mac::offset_);
  3084. u_int32_t bss_id, src;
  3086. Pr = p->txinfo_.RxPr;
  3087.   src = ETHER_ADDR(prrpf->prrpf_ta);
  3088. bss_id = ETHER_ADDR(prrpf->prrpf_ta);
  3090. update_ap_table(src,Pr);
  3092. sendACK(src);
  3095. if(mhSend_.busy() == 0)
  3096. tx_resume();
  3098. mac_log(p);
  3101. }
  3103. void Mac802_11::checkAssocAuthStatus() {
  3104. if ( addr() != bss_id_ ) {
  3105. if (authenticated == 0 && associated == 0) {
  3107. sendAUTHENTICATE(strongest_ap());
  3108. } 
  3109. if (authenticated == 1 && associated == 0) {
  3110. sendASSOCREQ(bss_id_);
  3111. }
  3112. }
  3113. }
  3115. /* STA's beacon power table funtions
  3116. */
  3117. void Mac802_11::update_ap_table(int num, double power) {
  3118. if (ap_list == NULL) {
  3119. ap_list = (struct ap_table*)malloc(sizeof(struct ap_table));
  3120. ap_list->ap_id=num;
  3121. ap_list->ap_power = power;
  3122. ap_list->next=NULL;
  3123. }
  3124. else {
  3125. push_ap(num, power);
  3126. }
  3127. struct ap_table *temp;
  3128. temp = ap_list;
  3129. //  while (temp != NULL) {
  3130. //  printf("Client %d: AP %d and %ft", index_, temp->ap_id,temp->ap_power);
  3131. //  temp=temp->next;
  3132. //  }
  3133. //  printf("n");
  3134. }
  3136. void Mac802_11::push_ap(int num, double power) {
  3137. struct ap_table *temp;
  3138. temp = ap_list;
  3139. while (temp->next != NULL) {
  3140. temp=temp->next;
  3141. }
  3142. temp->next = (struct ap_table*)malloc(sizeof(struct ap_table));
  3143. temp->next->ap_id = num;
  3144. temp->next->ap_power= power;
  3145. temp->next->next = NULL; 
  3146. }
  3148. void Mac802_11::deletelist() {
  3149. struct ap_table *temp;
  3150. while (ap_list != NULL) {
  3152. temp = ap_list;
  3153. ap_list = ap_list->next;
  3154. free(temp);
  3155. }
  3157. }
  3159. int Mac802_11::strongest_ap() {
  3160. struct ap_table *temp;
  3161. double max_power;
  3162. int ap;
  3163. temp = ap_list;
  3164. if (ap_list == NULL)
  3165. return -1;
  3166. max_power = 0;
  3167. while (temp != NULL) {
  3168. if (temp->ap_power > max_power) {
  3169. max_power = temp->ap_power;
  3170. ap = temp->ap_id;
  3171. }
  3172. temp = temp->next;
  3173. }
  3175. return ap;
  3176. }
  3178. int Mac802_11::find_ap(int num, double power) {
  3179. struct ap_table *temp;
  3180. temp = ap_list;
  3181. while (temp != NULL) {
  3182. if (temp->ap_id == num && temp->ap_power == power) {
  3183. return 1;
  3184. } 
  3186. temp=temp->next;
  3188. if (temp == NULL) {
  3189. return 0; 
  3190. }
  3191. }
  3192. return 0;
  3193. }
  3195. int Mac802_11::end() 
  3196. {
  3197. int end;
  3198. end = head;
  3199. while (priority_queue[end] != 0) {
  3200. end = end + 1;
  3201. }
  3202. return end;
  3203. }
  3205. void Mac802_11::shift_priority_queue()
  3206. {
  3207. int i;
  3208. i = head;
  3209. while (priority_queue[i] != 0) {
  3210. priority_queue[i] = priority_queue[i+1];
  3211. i = i + 1;
  3212. }
  3213. }