Mercurial Mercurial > ns-3.24 / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
src/wifi/model/wifi-mac-header.cc
changeset 7141 072fb225b714
parent 6852 8f1a53d3f6ca
child 7385 10beb0e53130
equal deleted inserted replaced
7140:d203296efb63 7141:072fb225b714 
    25 
    25 
    26 namespace ns3 {
 
    26 namespace ns3 {
 
    27 
    27 
    28 NS_OBJECT_ENSURE_REGISTERED (WifiMacHeader);
 
    28 NS_OBJECT_ENSURE_REGISTERED (WifiMacHeader);
 
    29 
    29 
    30 enum {
 
    30 enum
 
       
    31 {
 
    31   TYPE_MGT = 0,
 
    32   TYPE_MGT = 0,
 
    32   TYPE_CTL  = 1,
 
    33   TYPE_CTL  = 1,
 
    33   TYPE_DATA = 2
 
    34   TYPE_DATA = 2
 
    34 };
 
    35 };
 
    35 
    36 
    36 enum {
 
    37 enum
 
       
    38 {
 
    37   SUBTYPE_CTL_BACKREQ = 8,
 
    39   SUBTYPE_CTL_BACKREQ = 8,
 
    38   SUBTYPE_CTL_BACKRESP = 9,
 
    40   SUBTYPE_CTL_BACKRESP = 9,
 
    39   SUBTYPE_CTL_RTS = 11,
 
    41   SUBTYPE_CTL_RTS = 11,
 
    40   SUBTYPE_CTL_CTS = 12,
 
    42   SUBTYPE_CTL_CTS = 12,
 
    41   SUBTYPE_CTL_ACK = 13
 
    43   SUBTYPE_CTL_ACK = 13
 
    45   : m_ctrlPwrMgt (0),
 
    47   : m_ctrlPwrMgt (0),
 
    46     m_ctrlMoreData (0),
 
    48     m_ctrlMoreData (0),
 
    47     m_ctrlWep (0),
 
    49     m_ctrlWep (0),
 
    48     m_ctrlOrder (1),
 
    50     m_ctrlOrder (1),
 
    49     m_amsduPresent (0)
 
    51     m_amsduPresent (0)
 
    50 {}
 
    52 {
 
       
    53 }
 
    51 WifiMacHeader::~WifiMacHeader ()
 
    54 WifiMacHeader::~WifiMacHeader ()
 
    52 {}
 
    55 {
 
    53 
    56 }
 
    54 void 
    57 
       
    58 void
 
    55 WifiMacHeader::SetDsFrom (void)
 
    59 WifiMacHeader::SetDsFrom (void)
 
    56 {
 
    60 {
 
    57   m_ctrlFromDs = 1;
 
    61   m_ctrlFromDs = 1;
 
    58 }
 
    62 }
 
    59 void 
    63 void
 
    60 WifiMacHeader::SetDsNotFrom (void)
 
    64 WifiMacHeader::SetDsNotFrom (void)
 
    61 {
 
    65 {
 
    62   m_ctrlFromDs = 0;
 
    66   m_ctrlFromDs = 0;
 
    63 }
 
    67 }
 
    64 void 
    68 void
 
    65 WifiMacHeader::SetDsTo (void)
 
    69 WifiMacHeader::SetDsTo (void)
 
    66 {
 
    70 {
 
    67   m_ctrlToDs = 1;
 
    71   m_ctrlToDs = 1;
 
    68 }
 
    72 }
 
    69 void 
    73 void
 
    70 WifiMacHeader::SetDsNotTo (void)
 
    74 WifiMacHeader::SetDsNotTo (void)
 
    71 {
 
    75 {
 
    72   m_ctrlToDs = 0;
 
    76   m_ctrlToDs = 0;
 
    73 }
 
    77 }
 
    74 
    78 
    75 void 
    79 void
 
    76 WifiMacHeader::SetAddr1 (Mac48Address address)
 
    80 WifiMacHeader::SetAddr1 (Mac48Address address)
 
    77 {
 
    81 {
 
    78   m_addr1 = address;
 
    82   m_addr1 = address;
 
    79 }
 
    83 }
 
    80 void 
    84 void
 
    81 WifiMacHeader::SetAddr2 (Mac48Address address)
 
    85 WifiMacHeader::SetAddr2 (Mac48Address address)
 
    82 {
 
    86 {
 
    83   m_addr2 = address;
 
    87   m_addr2 = address;
 
    84 }
 
    88 }
 
    85 void 
    89 void
 
    86 WifiMacHeader::SetAddr3 (Mac48Address address)
 
    90 WifiMacHeader::SetAddr3 (Mac48Address address)
 
    87 {
 
    91 {
 
    88   m_addr3 = address;
 
    92   m_addr3 = address;
 
    89 }
 
    93 }
 
    90 void 
    94 void
 
    91 WifiMacHeader::SetAddr4 (Mac48Address address)
 
    95 WifiMacHeader::SetAddr4 (Mac48Address address)
 
    92 {
 
    96 {
 
    93   m_addr4 = address;
 
    97   m_addr4 = address;
 
    94 }
 
    98 }
 
    95 void 
    99 void
 
    96 WifiMacHeader::SetAssocReq (void)
 
   100 WifiMacHeader::SetAssocReq (void)
 
    97 {
 
   101 {
 
    98   m_ctrlType = TYPE_MGT;
 
   102   m_ctrlType = TYPE_MGT;
 
    99   m_ctrlSubtype = 0;
 
   103   m_ctrlSubtype = 0;
 
   100 }
 
   104 }
 
   101 void 
   105 void
 
   102 WifiMacHeader::SetAssocResp (void)
 
   106 WifiMacHeader::SetAssocResp (void)
 
   103 {
 
   107 {
 
   104   m_ctrlType = TYPE_MGT;
 
   108   m_ctrlType = TYPE_MGT;
 
   105   m_ctrlSubtype = 1;
 
   109   m_ctrlSubtype = 1;
 
   106 }
 
   110 }
 
   107 void 
   111 void
 
   108 WifiMacHeader::SetProbeReq (void)
 
   112 WifiMacHeader::SetProbeReq (void)
 
   109 {
 
   113 {
 
   110   m_ctrlType = TYPE_MGT;
 
   114   m_ctrlType = TYPE_MGT;
 
   111   m_ctrlSubtype = 4;
 
   115   m_ctrlSubtype = 4;
 
   112 }
 
   116 }
 
   113 void 
   117 void
 
   114 WifiMacHeader::SetProbeResp (void)
 
   118 WifiMacHeader::SetProbeResp (void)
 
   115 {
 
   119 {
 
   116   m_ctrlType = TYPE_MGT;
 
   120   m_ctrlType = TYPE_MGT;
 
   117   m_ctrlSubtype = 5;
 
   121   m_ctrlSubtype = 5;
 
   118 }
 
   122 }
 
   119 void 
   123 void
 
   120 WifiMacHeader::SetBeacon (void)
 
   124 WifiMacHeader::SetBeacon (void)
 
   121 {
 
   125 {
 
   122   m_ctrlType = TYPE_MGT;
 
   126   m_ctrlType = TYPE_MGT;
 
   123   m_ctrlSubtype = 8;
 
   127   m_ctrlSubtype = 8;
 
   124 }
 
   128 }
 
   133 {
 
   137 {
 
   134   m_ctrlType = TYPE_CTL;
 
   138   m_ctrlType = TYPE_CTL;
 
   135   m_ctrlSubtype = 9;
 
   139   m_ctrlSubtype = 9;
 
   136 }
 
   140 }
 
   137 
   141 
   138 void 
   142 void
 
   139 WifiMacHeader::SetTypeData (void)
 
   143 WifiMacHeader::SetTypeData (void)
 
   140 {
 
   144 {
 
   141   m_ctrlType = TYPE_DATA;
 
   145   m_ctrlType = TYPE_DATA;
 
   142   m_ctrlSubtype = 0;
 
   146   m_ctrlSubtype = 0;
 
   143 }
 
   147 }
 
   144 void
 
   148 void
 
   145 WifiMacHeader::SetAction (void)
 
   149 WifiMacHeader::SetAction (void)
 
   146 {
 
   150 {
 
   147  m_ctrlType = TYPE_MGT;
 
   151   m_ctrlType = TYPE_MGT;
 
   148  m_ctrlSubtype = 0x0D;
 
   152   m_ctrlSubtype = 0x0D;
 
   149 }
 
   153 }
 
   150 void
 
   154 void
 
   151 WifiMacHeader::SetMultihopAction (void)
 
   155 WifiMacHeader::SetMultihopAction (void)
 
   152 {
 
   156 {
 
   153  m_ctrlType = TYPE_MGT;
 
   157   m_ctrlType = TYPE_MGT;
 
   154  m_ctrlSubtype = 0x0F;
 
   158   m_ctrlSubtype = 0x0F;
 
   155 }
 
   159 }
 
   156 void 
   160 void
 
   157 WifiMacHeader::SetType (enum WifiMacType type)
 
   161 WifiMacHeader::SetType (enum WifiMacType type)
 
   158 {
 
   162 {
 
   159   switch (type) {
 
   163   switch (type)
 
   160   case WIFI_MAC_CTL_BACKREQ:
 
   164     {
 
   161     m_ctrlType = TYPE_CTL;
 
   165     case WIFI_MAC_CTL_BACKREQ:
 
   162     m_ctrlSubtype = SUBTYPE_CTL_BACKREQ;
 
   166       m_ctrlType = TYPE_CTL;
 
   163     break;
 
   167       m_ctrlSubtype = SUBTYPE_CTL_BACKREQ;
 
   164   case WIFI_MAC_CTL_BACKRESP:
 
   168       break;
 
   165     m_ctrlType = TYPE_CTL;
 
   169     case WIFI_MAC_CTL_BACKRESP:
 
   166     m_ctrlSubtype = SUBTYPE_CTL_BACKRESP;
 
   170       m_ctrlType = TYPE_CTL;
 
   167     break;
 
   171       m_ctrlSubtype = SUBTYPE_CTL_BACKRESP;
 
   168   case WIFI_MAC_CTL_RTS:
 
   172       break;
 
   169     m_ctrlType = TYPE_CTL;
 
   173     case WIFI_MAC_CTL_RTS:
 
   170     m_ctrlSubtype = SUBTYPE_CTL_RTS;
 
   174       m_ctrlType = TYPE_CTL;
 
   171     break;
 
   175       m_ctrlSubtype = SUBTYPE_CTL_RTS;
 
   172   case WIFI_MAC_CTL_CTS:
 
   176       break;
 
   173     m_ctrlType = TYPE_CTL;
 
   177     case WIFI_MAC_CTL_CTS:
 
   174     m_ctrlSubtype = SUBTYPE_CTL_CTS;
 
   178       m_ctrlType = TYPE_CTL;
 
   175     break;
 
   179       m_ctrlSubtype = SUBTYPE_CTL_CTS;
 
   176   case WIFI_MAC_CTL_ACK:
 
   180       break;
 
   177     m_ctrlType = TYPE_CTL;
 
   181     case WIFI_MAC_CTL_ACK:
 
   178     m_ctrlSubtype = SUBTYPE_CTL_ACK;
 
   182       m_ctrlType = TYPE_CTL;
 
   179     break;
 
   183       m_ctrlSubtype = SUBTYPE_CTL_ACK;
 
   180   case WIFI_MAC_MGT_ASSOCIATION_REQUEST:
 
   184       break;
 
   181     m_ctrlType = TYPE_MGT;
 
   185     case WIFI_MAC_MGT_ASSOCIATION_REQUEST:
 
   182     m_ctrlSubtype = 0;
 
   186       m_ctrlType = TYPE_MGT;
 
   183     break;
 
   187       m_ctrlSubtype = 0;
 
   184   case WIFI_MAC_MGT_ASSOCIATION_RESPONSE:
 
   188       break;
 
   185     m_ctrlType = TYPE_MGT;
 
   189     case WIFI_MAC_MGT_ASSOCIATION_RESPONSE:
 
   186     m_ctrlSubtype = 1;
 
   190       m_ctrlType = TYPE_MGT;
 
   187     break;
 
   191       m_ctrlSubtype = 1;
 
   188   case WIFI_MAC_MGT_REASSOCIATION_REQUEST:
 
   192       break;
 
   189     m_ctrlType = TYPE_MGT;
 
   193     case WIFI_MAC_MGT_REASSOCIATION_REQUEST:
 
   190     m_ctrlSubtype = 2;
 
   194       m_ctrlType = TYPE_MGT;
 
   191     break;
 
   195       m_ctrlSubtype = 2;
 
   192   case WIFI_MAC_MGT_REASSOCIATION_RESPONSE:
 
   196       break;
 
   193     m_ctrlType = TYPE_MGT;
 
   197     case WIFI_MAC_MGT_REASSOCIATION_RESPONSE:
 
   194     m_ctrlSubtype = 3;
 
   198       m_ctrlType = TYPE_MGT;
 
   195     break;
 
   199       m_ctrlSubtype = 3;
 
   196   case WIFI_MAC_MGT_PROBE_REQUEST:
 
   200       break;
 
   197     m_ctrlType = TYPE_MGT;
 
   201     case WIFI_MAC_MGT_PROBE_REQUEST:
 
   198     m_ctrlSubtype = 4;
 
   202       m_ctrlType = TYPE_MGT;
 
   199     break;
 
   203       m_ctrlSubtype = 4;
 
   200   case WIFI_MAC_MGT_PROBE_RESPONSE:
 
   204       break;
 
   201     m_ctrlType = TYPE_MGT;
 
   205     case WIFI_MAC_MGT_PROBE_RESPONSE:
 
   202     m_ctrlSubtype = 5;
 
   206       m_ctrlType = TYPE_MGT;
 
   203     break;
 
   207       m_ctrlSubtype = 5;
 
   204   case WIFI_MAC_MGT_BEACON:
 
   208       break;
 
   205     m_ctrlType = TYPE_MGT;
 
   209     case WIFI_MAC_MGT_BEACON:
 
   206     m_ctrlSubtype = 8;
 
   210       m_ctrlType = TYPE_MGT;
 
   207     break;
 
   211       m_ctrlSubtype = 8;
 
   208   case WIFI_MAC_MGT_DISASSOCIATION:
 
   212       break;
 
   209     m_ctrlType = TYPE_MGT;
 
   213     case WIFI_MAC_MGT_DISASSOCIATION:
 
   210     m_ctrlSubtype = 10;
 
   214       m_ctrlType = TYPE_MGT;
 
   211     break;
 
   215       m_ctrlSubtype = 10;
 
   212   case WIFI_MAC_MGT_AUTHENTICATION:
 
   216       break;
 
   213     m_ctrlType = TYPE_MGT;
 
   217     case WIFI_MAC_MGT_AUTHENTICATION:
 
   214     m_ctrlSubtype = 11;
 
   218       m_ctrlType = TYPE_MGT;
 
   215     break;
 
   219       m_ctrlSubtype = 11;
 
   216   case WIFI_MAC_MGT_DEAUTHENTICATION:
 
   220       break;
 
   217     m_ctrlType = TYPE_MGT;
 
   221     case WIFI_MAC_MGT_DEAUTHENTICATION:
 
   218     m_ctrlSubtype = 12;
 
   222       m_ctrlType = TYPE_MGT;
 
   219   case WIFI_MAC_MGT_ACTION:
 
   223       m_ctrlSubtype = 12;
 
   220     m_ctrlType = TYPE_MGT;
 
   224     case WIFI_MAC_MGT_ACTION:
 
   221     m_ctrlSubtype = 13;
 
   225       m_ctrlType = TYPE_MGT;
 
   222   case WIFI_MAC_MGT_ACTION_NO_ACK:
 
   226       m_ctrlSubtype = 13;
 
   223     m_ctrlType = TYPE_MGT;
 
   227     case WIFI_MAC_MGT_ACTION_NO_ACK:
 
   224     m_ctrlSubtype = 14;
 
   228       m_ctrlType = TYPE_MGT;
 
   225   case WIFI_MAC_MGT_MULTIHOP_ACTION:
 
   229       m_ctrlSubtype = 14;
 
   226     m_ctrlType = TYPE_MGT;
 
   230     case WIFI_MAC_MGT_MULTIHOP_ACTION:
 
   227     m_ctrlSubtype = 15;
 
   231       m_ctrlType = TYPE_MGT;
 
   228     break;
 
   232       m_ctrlSubtype = 15;
 
   229 
   233       break;
 
   230   case WIFI_MAC_DATA:
 
   234 
   231     m_ctrlType = TYPE_DATA;
 
   235     case WIFI_MAC_DATA:
 
   232     m_ctrlSubtype = 0;
 
   236       m_ctrlType = TYPE_DATA;
 
   233     break;
 
   237       m_ctrlSubtype = 0;
 
   234   case WIFI_MAC_DATA_CFACK:
 
   238       break;
 
   235     m_ctrlType = TYPE_DATA;
 
   239     case WIFI_MAC_DATA_CFACK:
 
   236     m_ctrlSubtype = 1;
 
   240       m_ctrlType = TYPE_DATA;
 
   237     break;
 
   241       m_ctrlSubtype = 1;
 
   238   case WIFI_MAC_DATA_CFPOLL:
 
   242       break;
 
   239     m_ctrlType = TYPE_DATA;
 
   243     case WIFI_MAC_DATA_CFPOLL:
 
   240     m_ctrlSubtype = 2;
 
   244       m_ctrlType = TYPE_DATA;
 
   241     break;
 
   245       m_ctrlSubtype = 2;
 
   242   case WIFI_MAC_DATA_CFACK_CFPOLL:
 
   246       break;
 
   243     m_ctrlType = TYPE_DATA;
 
   247     case WIFI_MAC_DATA_CFACK_CFPOLL:
 
   244     m_ctrlSubtype = 3;
 
   248       m_ctrlType = TYPE_DATA;
 
   245     break;
 
   249       m_ctrlSubtype = 3;
 
   246   case WIFI_MAC_DATA_NULL:
 
   250       break;
 
   247     m_ctrlType = TYPE_DATA;
 
   251     case WIFI_MAC_DATA_NULL:
 
   248     m_ctrlSubtype = 4;
 
   252       m_ctrlType = TYPE_DATA;
 
   249     break;
 
   253       m_ctrlSubtype = 4;
 
   250   case WIFI_MAC_DATA_NULL_CFACK:
 
   254       break;
 
   251     m_ctrlType = TYPE_DATA;
 
   255     case WIFI_MAC_DATA_NULL_CFACK:
 
   252     m_ctrlSubtype = 5;
 
   256       m_ctrlType = TYPE_DATA;
 
   253     break;
 
   257       m_ctrlSubtype = 5;
 
   254   case WIFI_MAC_DATA_NULL_CFPOLL:
 
   258       break;
 
   255     m_ctrlType = TYPE_DATA;
 
   259     case WIFI_MAC_DATA_NULL_CFPOLL:
 
   256     m_ctrlSubtype = 6;
 
   260       m_ctrlType = TYPE_DATA;
 
   257     break;
 
   261       m_ctrlSubtype = 6;
 
   258   case WIFI_MAC_DATA_NULL_CFACK_CFPOLL:
 
   262       break;
 
   259     m_ctrlType = TYPE_DATA;
 
   263     case WIFI_MAC_DATA_NULL_CFACK_CFPOLL:
 
   260     m_ctrlSubtype = 7;
 
   264       m_ctrlType = TYPE_DATA;
 
   261     break;
 
   265       m_ctrlSubtype = 7;
 
   262   case WIFI_MAC_QOSDATA:
 
   266       break;
 
   263     m_ctrlType = TYPE_DATA;
 
   267     case WIFI_MAC_QOSDATA:
 
   264     m_ctrlSubtype = 8;
 
   268       m_ctrlType = TYPE_DATA;
 
   265     break;
 
   269       m_ctrlSubtype = 8;
 
   266   case WIFI_MAC_QOSDATA_CFACK:
 
   270       break;
 
   267     m_ctrlType = TYPE_DATA;
 
   271     case WIFI_MAC_QOSDATA_CFACK:
 
   268     m_ctrlSubtype = 9;
 
   272       m_ctrlType = TYPE_DATA;
 
   269     break;
 
   273       m_ctrlSubtype = 9;
 
   270   case WIFI_MAC_QOSDATA_CFPOLL:
 
   274       break;
 
   271     m_ctrlType = TYPE_DATA;
 
   275     case WIFI_MAC_QOSDATA_CFPOLL:
 
   272     m_ctrlSubtype = 10;
 
   276       m_ctrlType = TYPE_DATA;
 
   273     break;
 
   277       m_ctrlSubtype = 10;
 
   274   case WIFI_MAC_QOSDATA_CFACK_CFPOLL:
 
   278       break;
 
   275     m_ctrlType = TYPE_DATA;
 
   279     case WIFI_MAC_QOSDATA_CFACK_CFPOLL:
 
   276     m_ctrlSubtype = 11;
 
   280       m_ctrlType = TYPE_DATA;
 
   277     break;
 
   281       m_ctrlSubtype = 11;
 
   278   case WIFI_MAC_QOSDATA_NULL:
 
   282       break;
 
   279     m_ctrlType = TYPE_DATA;
 
   283     case WIFI_MAC_QOSDATA_NULL:
 
   280     m_ctrlSubtype = 12;
 
   284       m_ctrlType = TYPE_DATA;
 
   281     break;
 
   285       m_ctrlSubtype = 12;
 
   282   case WIFI_MAC_QOSDATA_NULL_CFPOLL:
 
   286       break;
 
   283     m_ctrlType = TYPE_DATA;
 
   287     case WIFI_MAC_QOSDATA_NULL_CFPOLL:
 
   284     m_ctrlSubtype = 14;
 
   288       m_ctrlType = TYPE_DATA;
 
   285     break;
 
   289       m_ctrlSubtype = 14;
 
   286   case WIFI_MAC_QOSDATA_NULL_CFACK_CFPOLL:
 
   290       break;
 
   287     m_ctrlType = TYPE_DATA;
 
   291     case WIFI_MAC_QOSDATA_NULL_CFACK_CFPOLL:
 
   288     m_ctrlSubtype = 15;
 
   292       m_ctrlType = TYPE_DATA;
 
   289     break;
 
   293       m_ctrlSubtype = 15;
 
   290   }
 
   294       break;
 
       
   295     }
 
   291   m_ctrlToDs = 0;
 
   296   m_ctrlToDs = 0;
 
   292   m_ctrlFromDs = 0;
 
   297   m_ctrlFromDs = 0;
 
   293 }
 
   298 }
 
   294 void 
   299 void
 
   295 WifiMacHeader::SetRawDuration (uint16_t duration)
 
   300 WifiMacHeader::SetRawDuration (uint16_t duration)
 
   296 {
 
   301 {
 
   297   m_duration = duration;
 
   302   m_duration = duration;
 
   298 }
 
   303 }
 
   299 void 
   304 void
 
   300 WifiMacHeader::SetDuration (Time duration)
 
   305 WifiMacHeader::SetDuration (Time duration)
 
   301 {
 
   306 {
 
   302   int64_t duration_us = duration.GetMicroSeconds ();
 
   307   int64_t duration_us = duration.GetMicroSeconds ();
 
   303   NS_ASSERT (duration_us >= 0 && duration_us <= 0x7fff);
 
   308   NS_ASSERT (duration_us >= 0 && duration_us <= 0x7fff);
 
   304   m_duration = static_cast<uint16_t> (duration_us);
 
   309   m_duration = static_cast<uint16_t> (duration_us);
 
   344 {
 
   349 {
 
   345   m_qosEosp = 0;
 
   350   m_qosEosp = 0;
 
   346 }
 
   351 }
 
   347 void WifiMacHeader::SetQosAckPolicy (enum QosAckPolicy policy)
 
   352 void WifiMacHeader::SetQosAckPolicy (enum QosAckPolicy policy)
 
   348 {
 
   353 {
 
   349   switch (policy) {
 
   354   switch (policy)
 
   350   case NORMAL_ACK :
 
   355     {
 
   351     m_qosAckPolicy = 0;
 
   356     case NORMAL_ACK:
 
   352     break;
 
   357       m_qosAckPolicy = 0;
 
   353   case NO_ACK :
 
   358       break;
 
   354     m_qosAckPolicy = 1;
 
   359     case NO_ACK:
 
   355     break;
 
   360       m_qosAckPolicy = 1;
 
   356   case NO_EXPLICIT_ACK :
 
   361       break;
 
   357     m_qosAckPolicy = 2;
 
   362     case NO_EXPLICIT_ACK:
 
   358     break;
 
   363       m_qosAckPolicy = 2;
 
   359   case BLOCK_ACK :
 
   364       break;
 
   360     m_qosAckPolicy = 3;
 
   365     case BLOCK_ACK:
 
   361     break;
 
   366       m_qosAckPolicy = 3;
 
   362   }
 
   367       break;
 
       
   368     }
 
   363 }
 
   369 }
 
   364 void
 
   370 void
 
   365 WifiMacHeader::SetQosNormalAck ()
 
   371 WifiMacHeader::SetQosNormalAck ()
 
   366 {
 
   372 {
 
   367   m_qosAckPolicy = 0;
 
   373   m_qosAckPolicy = 0;
 
   387 void WifiMacHeader::SetQosTxopLimit (uint8_t txop)
 
   393 void WifiMacHeader::SetQosTxopLimit (uint8_t txop)
 
   388 {
 
   394 {
 
   389   m_qosStuff = txop;
 
   395   m_qosStuff = txop;
 
   390 }
 
   396 }
 
   391 
   397 
   392 Mac48Address 
   398 Mac48Address
 
   393 WifiMacHeader::GetAddr1 (void) const
 
   399 WifiMacHeader::GetAddr1 (void) const
 
   394 {
 
   400 {
 
   395   return m_addr1;
 
   401   return m_addr1;
 
   396 }
 
   402 }
 
   397 Mac48Address 
   403 Mac48Address
 
   398 WifiMacHeader::GetAddr2 (void) const
 
   404 WifiMacHeader::GetAddr2 (void) const
 
   399 {
 
   405 {
 
   400   return m_addr2;
 
   406   return m_addr2;
 
   401 }
 
   407 }
 
   402 Mac48Address 
   408 Mac48Address
 
   403 WifiMacHeader::GetAddr3 (void) const
 
   409 WifiMacHeader::GetAddr3 (void) const
 
   404 {
 
   410 {
 
   405   return m_addr3;
 
   411   return m_addr3;
 
   406 }
 
   412 }
 
   407 Mac48Address 
   413 Mac48Address
 
   408 WifiMacHeader::GetAddr4 (void) const
 
   414 WifiMacHeader::GetAddr4 (void) const
 
   409 {
 
   415 {
 
   410   return m_addr4;
 
   416   return m_addr4;
 
   411 }
 
   417 }
 
   412 
   418 
   413 enum WifiMacType 
   419 enum WifiMacType
 
   414 WifiMacHeader::GetType (void) const
 
   420 WifiMacHeader::GetType (void) const
 
   415 {
 
   421 {
 
   416   switch (m_ctrlType) {
 
   422   switch (m_ctrlType)
 
   417   case TYPE_MGT:
 
   423     {
 
   418     switch (m_ctrlSubtype) {
 
   424     case TYPE_MGT:
 
   419     case 0:
 
   425       switch (m_ctrlSubtype)
 
   420       return WIFI_MAC_MGT_ASSOCIATION_REQUEST;
 
   426         {
 
   421       break;
 
   427         case 0:
 
   422     case 1:
 
   428           return WIFI_MAC_MGT_ASSOCIATION_REQUEST;
 
   423       return WIFI_MAC_MGT_ASSOCIATION_RESPONSE;
 
   429           break;
 
   424       break;
 
   430         case 1:
 
   425     case 2:
 
   431           return WIFI_MAC_MGT_ASSOCIATION_RESPONSE;
 
   426       return WIFI_MAC_MGT_REASSOCIATION_REQUEST;
 
   432           break;
 
   427       break;
 
   433         case 2:
 
   428     case 3:
 
   434           return WIFI_MAC_MGT_REASSOCIATION_REQUEST;
 
   429       return WIFI_MAC_MGT_REASSOCIATION_RESPONSE;
 
   435           break;
 
   430       break;
 
   436         case 3:
 
   431     case 4:
 
   437           return WIFI_MAC_MGT_REASSOCIATION_RESPONSE;
 
   432       return WIFI_MAC_MGT_PROBE_REQUEST;
 
   438           break;
 
   433       break;
 
   439         case 4:
 
   434     case 5:
 
   440           return WIFI_MAC_MGT_PROBE_REQUEST;
 
   435       return WIFI_MAC_MGT_PROBE_RESPONSE;
 
   441           break;
 
   436       break;
 
   442         case 5:
 
   437     case 8:
 
   443           return WIFI_MAC_MGT_PROBE_RESPONSE;
 
   438       return WIFI_MAC_MGT_BEACON;
 
   444           break;
 
   439       break;
 
   445         case 8:
 
   440     case 10:
 
   446           return WIFI_MAC_MGT_BEACON;
 
   441       return WIFI_MAC_MGT_DISASSOCIATION;
 
   447           break;
 
   442       break;
 
   448         case 10:
 
   443     case 11:
 
   449           return WIFI_MAC_MGT_DISASSOCIATION;
 
   444       return WIFI_MAC_MGT_AUTHENTICATION;
 
   450           break;
 
   445       break;
 
   451         case 11:
 
   446     case 12:
 
   452           return WIFI_MAC_MGT_AUTHENTICATION;
 
   447       return WIFI_MAC_MGT_DEAUTHENTICATION;
 
   453           break;
 
   448       break;
 
   454         case 12:
 
   449     case 13:
 
   455           return WIFI_MAC_MGT_DEAUTHENTICATION;
 
   450       return WIFI_MAC_MGT_ACTION;
 
   456           break;
 
   451       break;
 
   457         case 13:
 
   452     case 14:
 
   458           return WIFI_MAC_MGT_ACTION;
 
   453       return WIFI_MAC_MGT_ACTION_NO_ACK;
 
   459           break;
 
   454       break;
 
   460         case 14:
 
   455     case 15:
 
   461           return WIFI_MAC_MGT_ACTION_NO_ACK;
 
   456       return WIFI_MAC_MGT_MULTIHOP_ACTION;
 
   462           break;
 
   457       break;
 
   463         case 15:
 
   458 
   464           return WIFI_MAC_MGT_MULTIHOP_ACTION;
 
       
   465           break;
 
       
   466 
       
   467         }
 
       
   468       break;
 
       
   469     case TYPE_CTL:
 
       
   470       switch (m_ctrlSubtype)
 
       
   471         {
 
       
   472         case SUBTYPE_CTL_BACKREQ:
 
       
   473           return WIFI_MAC_CTL_BACKREQ;
 
       
   474           break;
 
       
   475         case SUBTYPE_CTL_BACKRESP:
 
       
   476           return WIFI_MAC_CTL_BACKRESP;
 
       
   477           break;
 
       
   478         case SUBTYPE_CTL_RTS:
 
       
   479           return WIFI_MAC_CTL_RTS;
 
       
   480           break;
 
       
   481         case SUBTYPE_CTL_CTS:
 
       
   482           return WIFI_MAC_CTL_CTS;
 
       
   483           break;
 
       
   484         case SUBTYPE_CTL_ACK:
 
       
   485           return WIFI_MAC_CTL_ACK;
 
       
   486           break;
 
       
   487         }
 
       
   488       break;
 
       
   489     case TYPE_DATA:
 
       
   490       switch (m_ctrlSubtype)
 
       
   491         {
 
       
   492         case 0:
 
       
   493           return WIFI_MAC_DATA;
 
       
   494           break;
 
       
   495         case 1:
 
       
   496           return WIFI_MAC_DATA_CFACK;
 
       
   497           break;
 
       
   498         case 2:
 
       
   499           return WIFI_MAC_DATA_CFPOLL;
 
       
   500           break;
 
       
   501         case 3:
 
       
   502           return WIFI_MAC_DATA_CFACK_CFPOLL;
 
       
   503           break;
 
       
   504         case 4:
 
       
   505           return WIFI_MAC_DATA_NULL;
 
       
   506           break;
 
       
   507         case 5:
 
       
   508           return WIFI_MAC_DATA_NULL_CFACK;
 
       
   509           break;
 
       
   510         case 6:
 
       
   511           return WIFI_MAC_DATA_NULL_CFPOLL;
 
       
   512           break;
 
       
   513         case 7:
 
       
   514           return WIFI_MAC_DATA_NULL_CFACK_CFPOLL;
 
       
   515           break;
 
       
   516         case 8:
 
       
   517           return WIFI_MAC_QOSDATA;
 
       
   518           break;
 
       
   519         case 9:
 
       
   520           return WIFI_MAC_QOSDATA_CFACK;
 
       
   521           break;
 
       
   522         case 10:
 
       
   523           return WIFI_MAC_QOSDATA_CFPOLL;
 
       
   524           break;
 
       
   525         case 11:
 
       
   526           return WIFI_MAC_QOSDATA_CFACK_CFPOLL;
 
       
   527           break;
 
       
   528         case 12:
 
       
   529           return WIFI_MAC_QOSDATA_NULL;
 
       
   530           break;
 
       
   531         case 14:
 
       
   532           return WIFI_MAC_QOSDATA_NULL_CFPOLL;
 
       
   533           break;
 
       
   534         case 15:
 
       
   535           return WIFI_MAC_QOSDATA_NULL_CFACK_CFPOLL;
 
       
   536           break;
 
       
   537 
       
   538         }
 
       
   539       break;
 
   459     }
 
   540     }
 
   460     break;
 
       
   461   case TYPE_CTL:
 
       
   462     switch (m_ctrlSubtype) {
 
       
   463     case SUBTYPE_CTL_BACKREQ:
 
       
   464       return WIFI_MAC_CTL_BACKREQ;
 
       
   465       break;
 
       
   466     case SUBTYPE_CTL_BACKRESP:
 
       
   467       return WIFI_MAC_CTL_BACKRESP;
 
       
   468       break;
 
       
   469     case SUBTYPE_CTL_RTS:
 
       
   470       return WIFI_MAC_CTL_RTS;
 
       
   471       break;
 
       
   472     case SUBTYPE_CTL_CTS:
 
       
   473       return WIFI_MAC_CTL_CTS;
 
       
   474       break;
 
       
   475     case SUBTYPE_CTL_ACK:
 
       
   476       return WIFI_MAC_CTL_ACK;
 
       
   477       break;
 
       
   478     }
 
       
   479     break;
 
       
   480   case TYPE_DATA:
 
       
   481     switch (m_ctrlSubtype) {
 
       
   482     case 0:
 
       
   483       return WIFI_MAC_DATA;
 
       
   484       break;
 
       
   485     case 1:
 
       
   486       return WIFI_MAC_DATA_CFACK;
 
       
   487       break;
 
       
   488     case 2:
 
       
   489       return WIFI_MAC_DATA_CFPOLL;
 
       
   490       break;
 
       
   491     case 3:
 
       
   492       return WIFI_MAC_DATA_CFACK_CFPOLL;
 
       
   493       break;
 
       
   494     case 4:
 
       
   495       return WIFI_MAC_DATA_NULL;
 
       
   496       break;
 
       
   497     case 5:
 
       
   498       return WIFI_MAC_DATA_NULL_CFACK;
 
       
   499       break;
 
       
   500     case 6:
 
       
   501       return WIFI_MAC_DATA_NULL_CFPOLL;
 
       
   502       break;
 
       
   503     case 7:
 
       
   504       return WIFI_MAC_DATA_NULL_CFACK_CFPOLL;
 
       
   505       break;
 
       
   506     case 8:
 
       
   507       return WIFI_MAC_QOSDATA;
 
       
   508       break;
 
       
   509     case 9:
 
       
   510       return WIFI_MAC_QOSDATA_CFACK;
 
       
   511       break;
 
       
   512     case 10:
 
       
   513       return WIFI_MAC_QOSDATA_CFPOLL;
 
       
   514       break;
 
       
   515     case 11:
 
       
   516       return WIFI_MAC_QOSDATA_CFACK_CFPOLL;
 
       
   517       break;
 
       
   518     case 12:
 
       
   519       return WIFI_MAC_QOSDATA_NULL;
 
       
   520       break;
 
       
   521     case 14:
 
       
   522       return WIFI_MAC_QOSDATA_NULL_CFPOLL;
 
       
   523       break;
 
       
   524     case 15:
 
       
   525       return WIFI_MAC_QOSDATA_NULL_CFACK_CFPOLL;
 
       
   526       break;
 
       
   527 
       
   528     }
 
       
   529     break;
 
       
   530   }
 
       
   531   // NOTREACHED
 
   541   // NOTREACHED
 
   532   NS_ASSERT (false);
 
   542   NS_ASSERT (false);
 
   533   return (enum WifiMacType)-1;
 
   543   return (enum WifiMacType)-1;
 
   534 }
 
   544 }
 
   535 bool 
   545 bool
 
   536 WifiMacHeader::IsFromDs (void) const
 
   546 WifiMacHeader::IsFromDs (void) const
 
   537 {
 
   547 {
 
   538   return m_ctrlFromDs == 1;
 
   548   return m_ctrlFromDs == 1;
 
   539 }
 
   549 }
 
   540 bool 
   550 bool
 
   541 WifiMacHeader::IsToDs (void) const
 
   551 WifiMacHeader::IsToDs (void) const
 
   542 {
 
   552 {
 
   543   return m_ctrlToDs == 1;
 
   553   return m_ctrlToDs == 1;
 
   544 }
 
   554 }
 
   545 
   555 
   546 bool 
   556 bool
 
   547 WifiMacHeader::IsData (void) const
 
   557 WifiMacHeader::IsData (void) const
 
   548 {
 
   558 {
 
   549   return (m_ctrlType == TYPE_DATA);
 
   559   return (m_ctrlType == TYPE_DATA);
 
   550     
   560 
   551 }
 
   561 }
 
   552 bool 
   562 bool
 
   553 WifiMacHeader::IsQosData (void) const
 
   563 WifiMacHeader::IsQosData (void) const
 
   554 {
 
   564 {
 
   555   return (m_ctrlType == TYPE_DATA && (m_ctrlSubtype & 0x08));
 
   565   return (m_ctrlType == TYPE_DATA && (m_ctrlSubtype & 0x08));
 
   556 }
 
   566 }
 
   557 bool 
   567 bool
 
   558 WifiMacHeader::IsCtl (void) const
 
   568 WifiMacHeader::IsCtl (void) const
 
   559 {
 
   569 {
 
   560   return (m_ctrlType == TYPE_CTL);
 
   570   return (m_ctrlType == TYPE_CTL);
 
   561 }
 
   571 }
 
   562 bool 
   572 bool
 
   563 WifiMacHeader::IsMgt (void) const
 
   573 WifiMacHeader::IsMgt (void) const
 
   564 {
 
   574 {
 
   565   return (m_ctrlType == TYPE_MGT);
 
   575   return (m_ctrlType == TYPE_MGT);
 
   566 }
 
   576 }
 
   567 bool 
   577 bool
 
   568 WifiMacHeader::IsCfpoll (void) const
 
   578 WifiMacHeader::IsCfpoll (void) const
 
   569 {
 
   579 {
 
   570   switch (GetType ()) {
 
   580   switch (GetType ())
 
   571   case WIFI_MAC_DATA_CFPOLL:
 
   581     {
 
   572   case WIFI_MAC_DATA_CFACK_CFPOLL:
 
   582     case WIFI_MAC_DATA_CFPOLL:
 
   573   case WIFI_MAC_DATA_NULL_CFPOLL:
 
   583     case WIFI_MAC_DATA_CFACK_CFPOLL:
 
   574   case WIFI_MAC_DATA_NULL_CFACK_CFPOLL:
 
   584     case WIFI_MAC_DATA_NULL_CFPOLL:
 
   575   case WIFI_MAC_QOSDATA_CFPOLL:
 
   585     case WIFI_MAC_DATA_NULL_CFACK_CFPOLL:
 
   576   case WIFI_MAC_QOSDATA_CFACK_CFPOLL:
 
   586     case WIFI_MAC_QOSDATA_CFPOLL:
 
   577   case WIFI_MAC_QOSDATA_NULL_CFPOLL:
 
   587     case WIFI_MAC_QOSDATA_CFACK_CFPOLL:
 
   578   case WIFI_MAC_QOSDATA_NULL_CFACK_CFPOLL:
 
   588     case WIFI_MAC_QOSDATA_NULL_CFPOLL:
 
   579     return true;
 
   589     case WIFI_MAC_QOSDATA_NULL_CFACK_CFPOLL:
 
   580     break;
 
   590       return true;
 
   581   default:
 
   591       break;
 
   582     return false;
 
   592     default:
 
   583     break;
 
   593       return false;
 
   584   }
 
   594       break;
 
   585 }
 
   595     }
 
   586 bool 
   596 }
 
       
   597 bool
 
   587 WifiMacHeader::IsRts (void) const
 
   598 WifiMacHeader::IsRts (void) const
 
   588 {
 
   599 {
 
   589   return (GetType () == WIFI_MAC_CTL_RTS);
 
   600   return (GetType () == WIFI_MAC_CTL_RTS);
 
   590 }
 
   601 }
 
   591 bool 
   602 bool
 
   592 WifiMacHeader::IsCts (void) const
 
   603 WifiMacHeader::IsCts (void) const
 
   593 {
 
   604 {
 
   594   return (GetType () == WIFI_MAC_CTL_CTS);
 
   605   return (GetType () == WIFI_MAC_CTL_CTS);
 
   595 }
 
   606 }
 
   596 bool 
   607 bool
 
   597 WifiMacHeader::IsAck (void) const
 
   608 WifiMacHeader::IsAck (void) const
 
   598 {
 
   609 {
 
   599   return (GetType () == WIFI_MAC_CTL_ACK);
 
   610   return (GetType () == WIFI_MAC_CTL_ACK);
 
   600 }
 
   611 }
 
   601 bool 
   612 bool
 
   602 WifiMacHeader::IsAssocReq (void) const
 
   613 WifiMacHeader::IsAssocReq (void) const
 
   603 {
 
   614 {
 
   604   return (GetType () == WIFI_MAC_MGT_ASSOCIATION_REQUEST);
 
   615   return (GetType () == WIFI_MAC_MGT_ASSOCIATION_REQUEST);
 
   605 }
 
   616 }
 
   606 bool 
   617 bool
 
   607 WifiMacHeader::IsAssocResp (void) const
 
   618 WifiMacHeader::IsAssocResp (void) const
 
   608 {
 
   619 {
 
   609   return (GetType () == WIFI_MAC_MGT_ASSOCIATION_RESPONSE);
 
   620   return (GetType () == WIFI_MAC_MGT_ASSOCIATION_RESPONSE);
 
   610 }
 
   621 }
 
   611 bool 
   622 bool
 
   612 WifiMacHeader::IsReassocReq (void) const
 
   623 WifiMacHeader::IsReassocReq (void) const
 
   613 {
 
   624 {
 
   614   return (GetType () == WIFI_MAC_MGT_REASSOCIATION_REQUEST);
 
   625   return (GetType () == WIFI_MAC_MGT_REASSOCIATION_REQUEST);
 
   615 }
 
   626 }
 
   616 bool 
   627 bool
 
   617 WifiMacHeader::IsReassocResp (void) const
 
   628 WifiMacHeader::IsReassocResp (void) const
 
   618 {
 
   629 {
 
   619   return (GetType () == WIFI_MAC_MGT_REASSOCIATION_RESPONSE);
 
   630   return (GetType () == WIFI_MAC_MGT_REASSOCIATION_RESPONSE);
 
   620 }
 
   631 }
 
   621 bool 
   632 bool
 
   622 WifiMacHeader::IsProbeReq (void) const
 
   633 WifiMacHeader::IsProbeReq (void) const
 
   623 {
 
   634 {
 
   624   return (GetType () == WIFI_MAC_MGT_PROBE_REQUEST);
 
   635   return (GetType () == WIFI_MAC_MGT_PROBE_REQUEST);
 
   625 }
 
   636 }
 
   626 bool 
   637 bool
 
   627 WifiMacHeader::IsProbeResp (void) const
 
   638 WifiMacHeader::IsProbeResp (void) const
 
   628 {
 
   639 {
 
   629   return (GetType () == WIFI_MAC_MGT_PROBE_RESPONSE);
 
   640   return (GetType () == WIFI_MAC_MGT_PROBE_RESPONSE);
 
   630 }
 
   641 }
 
   631 bool 
   642 bool
 
   632 WifiMacHeader::IsBeacon (void) const
 
   643 WifiMacHeader::IsBeacon (void) const
 
   633 {
 
   644 {
 
   634   return (GetType () == WIFI_MAC_MGT_BEACON);
 
   645   return (GetType () == WIFI_MAC_MGT_BEACON);
 
   635 }
 
   646 }
 
   636 bool 
   647 bool
 
   637 WifiMacHeader::IsDisassociation (void) const
 
   648 WifiMacHeader::IsDisassociation (void) const
 
   638 {
 
   649 {
 
   639   return (GetType () == WIFI_MAC_MGT_DISASSOCIATION);
 
   650   return (GetType () == WIFI_MAC_MGT_DISASSOCIATION);
 
   640 }
 
   651 }
 
   641 bool 
   652 bool
 
   642 WifiMacHeader::IsAuthentication (void) const
 
   653 WifiMacHeader::IsAuthentication (void) const
 
   643 {
 
   654 {
 
   644   return (GetType () == WIFI_MAC_MGT_AUTHENTICATION);
 
   655   return (GetType () == WIFI_MAC_MGT_AUTHENTICATION);
 
   645 }
 
   656 }
 
   646 bool 
   657 bool
 
   647 WifiMacHeader::IsDeauthentication (void) const
 
   658 WifiMacHeader::IsDeauthentication (void) const
 
   648 {
 
   659 {
 
   649   return (GetType () == WIFI_MAC_MGT_DEAUTHENTICATION);
 
   660   return (GetType () == WIFI_MAC_MGT_DEAUTHENTICATION);
 
   650 }
 
   661 }
 
   651 bool
 
   662 bool
 
   659   return (GetType () == WIFI_MAC_MGT_MULTIHOP_ACTION);
 
   670   return (GetType () == WIFI_MAC_MGT_MULTIHOP_ACTION);
 
   660 }
 
   671 }
 
   661 bool
 
   672 bool
 
   662 WifiMacHeader::IsBlockAckReq (void) const
 
   673 WifiMacHeader::IsBlockAckReq (void) const
 
   663 {
 
   674 {
 
   664   return (GetType () == WIFI_MAC_CTL_BACKREQ)?true:false;
 
   675   return (GetType () == WIFI_MAC_CTL_BACKREQ) ? true : false;
 
   665 }
 
   676 }
 
   666 bool
 
   677 bool
 
   667 WifiMacHeader::IsBlockAck (void) const
 
   678 WifiMacHeader::IsBlockAck (void) const
 
   668 {
 
   679 {
 
   669   return (GetType () == WIFI_MAC_CTL_BACKRESP)?true:false;
 
   680   return (GetType () == WIFI_MAC_CTL_BACKRESP) ? true : false;
 
   670 }
 
   681 }
 
   671 
   682 
   672 
   683 
   673 uint16_t 
   684 uint16_t
 
   674 WifiMacHeader::GetRawDuration (void) const
 
   685 WifiMacHeader::GetRawDuration (void) const
 
   675 {
 
   686 {
 
   676   return m_duration;
 
   687   return m_duration;
 
   677 }
 
   688 }
 
   678 Time
 
   689 Time
 
   679 WifiMacHeader::GetDuration (void) const
 
   690 WifiMacHeader::GetDuration (void) const
 
   680 {
 
   691 {
 
   681   return MicroSeconds (m_duration);
 
   692   return MicroSeconds (m_duration);
 
   682 }
 
   693 }
 
   683 uint16_t 
   694 uint16_t
 
   684 WifiMacHeader::GetSequenceControl (void) const
 
   695 WifiMacHeader::GetSequenceControl (void) const
 
   685 {
 
   696 {
 
   686   return (m_seqSeq << 4) | m_seqFrag;
 
   697   return (m_seqSeq << 4) | m_seqFrag;
 
   687 }
 
   698 }
 
   688 uint16_t
 
   699 uint16_t
 
   693 uint16_t
 
   704 uint16_t
 
   694 WifiMacHeader::GetFragmentNumber (void) const
 
   705 WifiMacHeader::GetFragmentNumber (void) const
 
   695 {
 
   706 {
 
   696   return m_seqFrag;
 
   707   return m_seqFrag;
 
   697 }
 
   708 }
 
   698 bool 
   709 bool
 
   699 WifiMacHeader::IsRetry (void) const
 
   710 WifiMacHeader::IsRetry (void) const
 
   700 {
 
   711 {
 
   701   return (m_ctrlRetry == 1);
 
   712   return (m_ctrlRetry == 1);
 
   702 }
 
   713 }
 
   703 bool 
   714 bool
 
   704 WifiMacHeader::IsMoreFragments (void) const
 
   715 WifiMacHeader::IsMoreFragments (void) const
 
   705 {
 
   716 {
 
   706   return (m_ctrlMoreFrag == 1);
 
   717   return (m_ctrlMoreFrag == 1);
 
   707 }
 
   718 }
 
   708 bool 
   719 bool
 
   709 WifiMacHeader::IsQosBlockAck (void) const
 
   720 WifiMacHeader::IsQosBlockAck (void) const
 
   710 {
 
   721 {
 
   711   NS_ASSERT (IsQosData ());
 
   722   NS_ASSERT (IsQosData ());
 
   712   return (m_qosAckPolicy == 3);
 
   723   return (m_qosAckPolicy == 3);
 
   713 }
 
   724 }
 
   714 bool 
   725 bool
 
   715 WifiMacHeader::IsQosNoAck (void) const
 
   726 WifiMacHeader::IsQosNoAck (void) const
 
   716 {
 
   727 {
 
   717   NS_ASSERT (IsQosData ());
 
   728   NS_ASSERT (IsQosData ());
 
   718   return (m_qosAckPolicy == 1);
 
   729   return (m_qosAckPolicy == 1);
 
   719 }
 
   730 }
 
   720 bool 
   731 bool
 
   721 WifiMacHeader::IsQosAck (void) const
 
   732 WifiMacHeader::IsQosAck (void) const
 
   722 {
 
   733 {
 
   723   NS_ASSERT (IsQosData ());
 
   734   NS_ASSERT (IsQosData ());
 
   724   return (m_qosAckPolicy == 0);
 
   735   return (m_qosAckPolicy == 0);
 
   725 }
 
   736 }
 
   742   return m_qosTid;
 
   753   return m_qosTid;
 
   743 }
 
   754 }
 
   744 enum WifiMacHeader::QosAckPolicy
 
   755 enum WifiMacHeader::QosAckPolicy
 
   745 WifiMacHeader::GetQosAckPolicy (void) const
 
   756 WifiMacHeader::GetQosAckPolicy (void) const
 
   746 {
 
   757 {
 
   747   switch (m_qosAckPolicy) {
 
   758   switch (m_qosAckPolicy)
 
   748   case 0 :
 
   759     {
 
   749     return NORMAL_ACK;
 
   760     case 0:
 
   750     break;
 
   761       return NORMAL_ACK;
 
   751   case 1 :
 
   762       break;
 
   752     return NO_ACK;
 
   763     case 1:
 
   753     break;
 
   764       return NO_ACK;
 
   754   case 2 :
 
   765       break;
 
   755     return NO_EXPLICIT_ACK;
 
   766     case 2:
 
   756     break;
 
   767       return NO_EXPLICIT_ACK;
 
   757   case 3 :
 
   768       break;
 
   758     return BLOCK_ACK;
 
   769     case 3:
 
   759     break;
 
   770       return BLOCK_ACK;
 
   760   }
 
   771       break;
 
       
   772     }
 
   761   // NOTREACHED
 
   773   // NOTREACHED
 
   762   NS_ASSERT (false);
 
   774   NS_ASSERT (false);
 
   763   return (enum QosAckPolicy)-1;
 
   775   return (enum QosAckPolicy)-1;
 
   764 }
 
   776 }
 
   765 
   777 
   766 uint8_t 
   778 uint8_t
 
   767 WifiMacHeader::GetQosTxopLimit (void) const
 
   779 WifiMacHeader::GetQosTxopLimit (void) const
 
   768 {
 
   780 {
 
   769   NS_ASSERT (IsQosData ());
 
   781   NS_ASSERT (IsQosData ());
 
   770   return m_qosStuff;
 
   782   return m_qosStuff;
 
   771 }
 
   783 }
 
   772 
   784 
   773 uint16_t
 
   785 uint16_t
 
   774 WifiMacHeader::GetFrameControl (void) const
 
   786 WifiMacHeader::GetFrameControl (void) const
 
   775 {
 
   787 {
 
   776   uint16_t val = 0;
 
   788   uint16_t val = 0;
 
   777   val |= (m_ctrlType << 2) & (0x3<<2);
 
   789   val |= (m_ctrlType << 2) & (0x3 << 2);
 
   778   val |= (m_ctrlSubtype << 4) & (0xf<<4);
 
   790   val |= (m_ctrlSubtype << 4) & (0xf << 4);
 
   779   val |= (m_ctrlToDs << 8) & (0x1<<8);
 
   791   val |= (m_ctrlToDs << 8) & (0x1 << 8);
 
   780   val |= (m_ctrlFromDs << 9) & (0x1<<9);
 
   792   val |= (m_ctrlFromDs << 9) & (0x1 << 9);
 
   781   val |= (m_ctrlMoreFrag << 10) & (0x1<<10);
 
   793   val |= (m_ctrlMoreFrag << 10) & (0x1 << 10);
 
   782   val |= (m_ctrlRetry << 11) & (0x1<<11);
 
   794   val |= (m_ctrlRetry << 11) & (0x1 << 11);
 
   783   val |= (m_ctrlMoreData << 13) & (0x1<<13);
 
   795   val |= (m_ctrlMoreData << 13) & (0x1 << 13);
 
   784   val |= (m_ctrlWep << 14) & (0x1<<14);
 
   796   val |= (m_ctrlWep << 14) & (0x1 << 14);
 
   785   val |= (m_ctrlOrder << 15) & (0x1<<15);
 
   797   val |= (m_ctrlOrder << 15) & (0x1 << 15);
 
   786   return val;
 
   798   return val;
 
   787 }
 
   799 }
 
   788 
   800 
   789 uint16_t
 
   801 uint16_t
 
   790 WifiMacHeader::GetQosControl (void) const
 
   802 WifiMacHeader::GetQosControl (void) const
 
   809   m_ctrlRetry = (ctrl >> 11) & 0x01;
 
   821   m_ctrlRetry = (ctrl >> 11) & 0x01;
 
   810   m_ctrlMoreData = (ctrl >> 13) & 0x01;
 
   822   m_ctrlMoreData = (ctrl >> 13) & 0x01;
 
   811   m_ctrlWep = (ctrl >> 14) & 0x01;
 
   823   m_ctrlWep = (ctrl >> 14) & 0x01;
 
   812   m_ctrlOrder = (ctrl >> 15) & 0x01;
 
   824   m_ctrlOrder = (ctrl >> 15) & 0x01;
 
   813 }
 
   825 }
 
   814 void 
   826 void
 
   815 WifiMacHeader::SetSequenceControl (uint16_t seq)
 
   827 WifiMacHeader::SetSequenceControl (uint16_t seq)
 
   816 {
 
   828 {
 
   817   m_seqFrag = seq & 0x0f;
 
   829   m_seqFrag = seq & 0x0f;
 
   818   m_seqSeq = (seq >> 4) & 0x0fff;
 
   830   m_seqSeq = (seq >> 4) & 0x0fff;
 
   819 }
 
   831 }
 
   825   m_qosAckPolicy = (qos >> 5) & 0x0003;
 
   837   m_qosAckPolicy = (qos >> 5) & 0x0003;
 
   826   m_amsduPresent = (qos >> 7) & 0x0001;
 
   838   m_amsduPresent = (qos >> 7) & 0x0001;
 
   827   m_qosStuff = (qos >> 8) & 0x00ff;
 
   839   m_qosStuff = (qos >> 8) & 0x00ff;
 
   828 }
 
   840 }
 
   829 
   841 
   830 uint32_t 
   842 uint32_t
 
   831 WifiMacHeader::GetSize (void) const
 
   843 WifiMacHeader::GetSize (void) const
 
   832 {
 
   844 {
 
   833   uint32_t size = 0;
 
   845   uint32_t size = 0;
 
   834   switch (m_ctrlType) {
 
   846   switch (m_ctrlType)
 
   835   case TYPE_MGT:
 
   847     {
 
   836     size = 2+2+6+6+6+2;
 
   848     case TYPE_MGT:
 
   837     break;
 
   849       size = 2 + 2 + 6 + 6 + 6 + 2;
 
   838   case TYPE_CTL:
 
   850       break;
 
   839     switch (m_ctrlSubtype) {
 
   851     case TYPE_CTL:
 
   840     case SUBTYPE_CTL_RTS:
 
   852       switch (m_ctrlSubtype)
 
   841       size = 2+2+6+6;
 
   853         {
 
   842       break;
 
   854         case SUBTYPE_CTL_RTS:
 
   843     case SUBTYPE_CTL_CTS:
 
   855           size = 2 + 2 + 6 + 6;
 
   844     case SUBTYPE_CTL_ACK:
 
   856           break;
 
   845       size = 2+2+6;
 
   857         case SUBTYPE_CTL_CTS:
 
   846       break;
 
   858         case SUBTYPE_CTL_ACK:
 
   847     case SUBTYPE_CTL_BACKREQ:
 
   859           size = 2 + 2 + 6;
 
   848     case SUBTYPE_CTL_BACKRESP:
 
   860           break;
 
   849       size = 2+2+6+6;
 
   861         case SUBTYPE_CTL_BACKREQ:
 
       
   862         case SUBTYPE_CTL_BACKRESP:
 
       
   863           size = 2 + 2 + 6 + 6;
 
       
   864           break;
 
       
   865         }
 
       
   866       break;
 
       
   867     case TYPE_DATA:
 
       
   868       size = 2 + 2 + 6 + 6 + 6 + 2;
 
       
   869       if (m_ctrlToDs && m_ctrlFromDs)
 
       
   870         {
 
       
   871           size += 6;
 
       
   872         }
 
       
   873       if (m_ctrlSubtype & 0x08)
 
       
   874         {
 
       
   875           size += 2;
 
       
   876         }
 
   850       break;
 
   877       break;
 
   851     }
 
   878     }
 
   852     break;
 
       
   853   case TYPE_DATA:
 
       
   854     size = 2+2+6+6+6+2;
 
       
   855     if (m_ctrlToDs && m_ctrlFromDs) {
 
       
   856       size += 6;
 
       
   857     }
 
       
   858     if (m_ctrlSubtype & 0x08) {
 
       
   859       size += 2;
 
       
   860     }
 
       
   861     break;
 
       
   862   }
 
       
   863   return size;
 
   879   return size;
 
   864 }
 
   880 }
 
   865 const char *
 
   881 const char *
 
   866 WifiMacHeader::GetTypeString (void) const
 
   882 WifiMacHeader::GetTypeString (void) const
 
   867 {
 
   883 {
 
   868 #define FOO(x) \
 
   884 #define FOO(x) \
 
   869 case WIFI_MAC_ ## x: \
 
   885 case WIFI_MAC_ ## x: \
 
   870   return #x; \
 
   886   return # x; \
 
   871   break;
 
   887   break;
 
   872 
   888 
   873   switch (GetType ()) {
 
   889   switch (GetType ())
 
   874     FOO (CTL_RTS);
 
   890     {
 
   875     FOO (CTL_CTS);
 
   891       FOO (CTL_RTS);
 
   876     FOO (CTL_ACK);
 
   892       FOO (CTL_CTS);
 
   877     FOO (CTL_BACKREQ);
 
   893       FOO (CTL_ACK);
 
   878     FOO (CTL_BACKRESP);
 
   894       FOO (CTL_BACKREQ);
 
   879 
   895       FOO (CTL_BACKRESP);
 
   880     FOO (MGT_BEACON);
 
   896 
   881     FOO (MGT_ASSOCIATION_REQUEST);
 
   897       FOO (MGT_BEACON);
 
   882     FOO (MGT_ASSOCIATION_RESPONSE);
 
   898       FOO (MGT_ASSOCIATION_REQUEST);
 
   883     FOO (MGT_DISASSOCIATION);
 
   899       FOO (MGT_ASSOCIATION_RESPONSE);
 
   884     FOO (MGT_REASSOCIATION_REQUEST);
 
   900       FOO (MGT_DISASSOCIATION);
 
   885     FOO (MGT_REASSOCIATION_RESPONSE);
 
   901       FOO (MGT_REASSOCIATION_REQUEST);
 
   886     FOO (MGT_PROBE_REQUEST);
 
   902       FOO (MGT_REASSOCIATION_RESPONSE);
 
   887     FOO (MGT_PROBE_RESPONSE);
 
   903       FOO (MGT_PROBE_REQUEST);
 
   888     FOO (MGT_AUTHENTICATION);
 
   904       FOO (MGT_PROBE_RESPONSE);
 
   889     FOO (MGT_DEAUTHENTICATION);
 
   905       FOO (MGT_AUTHENTICATION);
 
   890     FOO (MGT_ACTION);
 
   906       FOO (MGT_DEAUTHENTICATION);
 
   891     FOO (MGT_ACTION_NO_ACK);
 
   907       FOO (MGT_ACTION);
 
   892     FOO (MGT_MULTIHOP_ACTION);
 
   908       FOO (MGT_ACTION_NO_ACK);
 
   893     
   909       FOO (MGT_MULTIHOP_ACTION);
 
   894     FOO (DATA);
 
   910 
   895     FOO (DATA_CFACK);
 
   911       FOO (DATA);
 
   896     FOO (DATA_CFPOLL);
 
   912       FOO (DATA_CFACK);
 
   897     FOO (DATA_CFACK_CFPOLL);
 
   913       FOO (DATA_CFPOLL);
 
   898     FOO (DATA_NULL);
 
   914       FOO (DATA_CFACK_CFPOLL);
 
   899     FOO (DATA_NULL_CFACK);
 
   915       FOO (DATA_NULL);
 
   900     FOO (DATA_NULL_CFPOLL);
 
   916       FOO (DATA_NULL_CFACK);
 
   901     FOO (DATA_NULL_CFACK_CFPOLL);
 
   917       FOO (DATA_NULL_CFPOLL);
 
   902     FOO (QOSDATA);
 
   918       FOO (DATA_NULL_CFACK_CFPOLL);
 
   903     FOO (QOSDATA_CFACK);
 
   919       FOO (QOSDATA);
 
   904     FOO (QOSDATA_CFPOLL);
 
   920       FOO (QOSDATA_CFACK);
 
   905     FOO (QOSDATA_CFACK_CFPOLL);
 
   921       FOO (QOSDATA_CFPOLL);
 
   906     FOO (QOSDATA_NULL);
 
   922       FOO (QOSDATA_CFACK_CFPOLL);
 
   907     FOO (QOSDATA_NULL_CFPOLL);
 
   923       FOO (QOSDATA_NULL);
 
   908     FOO (QOSDATA_NULL_CFACK_CFPOLL);
 
   924       FOO (QOSDATA_NULL_CFPOLL);
 
   909   default:
 
   925       FOO (QOSDATA_NULL_CFACK_CFPOLL);
 
   910     return "ERROR";
 
   926     default:
 
   911   }
 
   927       return "ERROR";
 
       
   928     }
 
   912 #undef FOO
 
   929 #undef FOO
 
   913   // needed to make gcc 4.0.1 ppc darwin happy.
 
   930   // needed to make gcc 4.0.1 ppc darwin happy.
 
   914   return "BIG_ERROR";
 
   931   return "BIG_ERROR";
 
   915 }
 
   932 }
 
   916 
   933 
   917 TypeId 
   934 TypeId
 
   918 WifiMacHeader::GetTypeId (void)
 
   935 WifiMacHeader::GetTypeId (void)
 
   919 {
 
   936 {
 
   920   static TypeId tid = TypeId ("ns3::WifiMacHeader")
 
   937   static TypeId tid = TypeId ("ns3::WifiMacHeader")
 
   921     .SetParent<Header> ()
 
   938     .SetParent<Header> ()
 
   922     .AddConstructor<WifiMacHeader> ()
 
   939     .AddConstructor<WifiMacHeader> ()
 
   923     ;
 
   940   ;
 
   924   return tid;
 
   941   return tid;
 
   925 }
 
   942 }
 
   926 
   943 
   927 TypeId 
   944 TypeId
 
   928 WifiMacHeader::GetInstanceTypeId (void) const
 
   945 WifiMacHeader::GetInstanceTypeId (void) const
 
   929 {
 
   946 {
 
   930   return GetTypeId ();
 
   947   return GetTypeId ();
 
   931 }
 
   948 }
 
   932 
   949 
   933 void 
   950 void
 
   934 WifiMacHeader::PrintFrameControl (std::ostream &os) const
 
   951 WifiMacHeader::PrintFrameControl (std::ostream &os) const
 
   935 {
 
   952 {
 
   936   os << "ToDS=" << std::hex << (int) m_ctrlToDs << ", FromDS=" << std::hex << (int) m_ctrlFromDs 
   953   os << "ToDS=" << std::hex << (int) m_ctrlToDs << ", FromDS=" << std::hex << (int) m_ctrlFromDs
 
   937      << ", MoreFrag=" <<  std::hex << (int) m_ctrlMoreFrag << ", Retry=" << std::hex << (int) m_ctrlRetry 
   954      << ", MoreFrag=" <<  std::hex << (int) m_ctrlMoreFrag << ", Retry=" << std::hex << (int) m_ctrlRetry
 
   938      << ", MoreData=" <<  std::hex << (int) m_ctrlMoreData << std::dec 
   955      << ", MoreData=" <<  std::hex << (int) m_ctrlMoreData << std::dec
 
   939     ;
 
   956   ;
 
   940 }
 
   957 }
 
   941 
   958 
   942 void 
   959 void
 
   943 WifiMacHeader::Print (std::ostream &os) const
 
   960 WifiMacHeader::Print (std::ostream &os) const
 
   944 {
 
   961 {
 
   945   os << GetTypeString () << " ";
 
   962   os << GetTypeString () << " ";
 
   946   switch (GetType ())
 
   963   switch (GetType ())
 
   947     {
 
   964     {
 
  1026     case WIFI_MAC_QOSDATA_NULL_CFPOLL:
 
  1043     case WIFI_MAC_QOSDATA_NULL_CFPOLL:
 
  1027     case WIFI_MAC_QOSDATA_NULL_CFACK_CFPOLL:
 
  1044     case WIFI_MAC_QOSDATA_NULL_CFACK_CFPOLL:
 
  1028       break;
 
  1045       break;
 
  1029     }
 
  1046     }
 
  1030 }
 
  1047 }
 
  1031 uint32_t 
  1048 uint32_t
 
  1032 WifiMacHeader::GetSerializedSize (void) const
 
  1049 WifiMacHeader::GetSerializedSize (void) const
 
  1033 {
 
  1050 {
 
  1034   return GetSize ();
 
  1051   return GetSize ();
 
  1035 }
 
  1052 }
 
  1036 void 
  1053 void
 
  1037 WifiMacHeader::Serialize (Buffer::Iterator i) const
 
  1054 WifiMacHeader::Serialize (Buffer::Iterator i) const
 
  1038 {
 
  1055 {
 
  1039   i.WriteHtolsbU16 (GetFrameControl ());
 
  1056   i.WriteHtolsbU16 (GetFrameControl ());
 
  1040   i.WriteHtolsbU16 (m_duration);
 
  1057   i.WriteHtolsbU16 (m_duration);
 
  1041   WriteTo (i, m_addr1);
 
  1058   WriteTo (i, m_addr1);
 
  1042   switch (m_ctrlType) {
 
  1059   switch (m_ctrlType)
 
  1043   case TYPE_MGT:
 
  1060     {
 
  1044     WriteTo (i, m_addr2);
 
  1061     case TYPE_MGT:
 
  1045     WriteTo (i, m_addr3);
 
       
  1046     i.WriteHtolsbU16 (GetSequenceControl ());
 
       
  1047     break;
 
       
  1048   case TYPE_CTL:
 
       
  1049     switch (m_ctrlSubtype) {
 
       
  1050     case SUBTYPE_CTL_RTS:
 
       
  1051       WriteTo (i, m_addr2);
 
  1062       WriteTo (i, m_addr2);
 
  1052       break;
 
  1063       WriteTo (i, m_addr3);
 
  1053     case SUBTYPE_CTL_CTS:
 
  1064       i.WriteHtolsbU16 (GetSequenceControl ());
 
  1054     case SUBTYPE_CTL_ACK:
 
  1065       break;
 
  1055       break;
 
  1066     case TYPE_CTL:
 
  1056     case SUBTYPE_CTL_BACKREQ:
 
  1067       switch (m_ctrlSubtype)
 
  1057     case SUBTYPE_CTL_BACKRESP:
 
  1068         {
 
  1058       WriteTo (i, m_addr2);
 
  1069         case SUBTYPE_CTL_RTS:
 
  1059       break;
 
  1070           WriteTo (i, m_addr2);
 
       
  1071           break;
 
       
  1072         case SUBTYPE_CTL_CTS:
 
       
  1073         case SUBTYPE_CTL_ACK:
 
       
  1074           break;
 
       
  1075         case SUBTYPE_CTL_BACKREQ:
 
       
  1076         case SUBTYPE_CTL_BACKRESP:
 
       
  1077           WriteTo (i, m_addr2);
 
       
  1078           break;
 
       
  1079         default:
 
       
  1080           //NOTREACHED
 
       
  1081           NS_ASSERT (false);
 
       
  1082           break;
 
       
  1083         }
 
       
  1084       break;
 
       
  1085     case TYPE_DATA:
 
       
  1086       {
 
       
  1087         WriteTo (i, m_addr2);
 
       
  1088         WriteTo (i, m_addr3);
 
       
  1089         i.WriteHtolsbU16 (GetSequenceControl ());
 
       
  1090         if (m_ctrlToDs && m_ctrlFromDs)
 
       
  1091           {
 
       
  1092             WriteTo (i, m_addr4);
 
       
  1093           }
 
       
  1094         if (m_ctrlSubtype & 0x08)
 
       
  1095           {
 
       
  1096             i.WriteHtolsbU16 (GetQosControl ());
 
       
  1097           }
 
       
  1098       } break;
 
  1060     default:
 
  1099     default:
 
  1061       //NOTREACHED
 
  1100       //NOTREACHED
 
  1062       NS_ASSERT (false);
 
  1101       NS_ASSERT (false);
 
  1063       break;
 
  1102       break;
 
  1064     }
 
  1103     }
 
  1065     break;
 
       
  1066   case TYPE_DATA: {
 
       
  1067     WriteTo (i, m_addr2);
 
       
  1068     WriteTo (i, m_addr3);
 
       
  1069     i.WriteHtolsbU16 (GetSequenceControl ());
 
       
  1070     if (m_ctrlToDs && m_ctrlFromDs) {
 
       
  1071       WriteTo (i, m_addr4);
 
       
  1072     }
 
       
  1073     if (m_ctrlSubtype & 0x08) {
 
       
  1074       i.WriteHtolsbU16 (GetQosControl ());
 
       
  1075     }
 
       
  1076     } break;
 
       
  1077   default:
 
       
  1078     //NOTREACHED
 
       
  1079     NS_ASSERT (false);
 
       
  1080     break;
 
       
  1081   }
 
       
  1082 }
 
  1104 }
 
  1083 uint32_t
 
  1105 uint32_t
 
  1084 WifiMacHeader::Deserialize (Buffer::Iterator start)
 
  1106 WifiMacHeader::Deserialize (Buffer::Iterator start)
 
  1085 {
 
  1107 {
 
  1086   Buffer::Iterator i = start;
 
  1108   Buffer::Iterator i = start;
 
  1087   uint16_t frame_control = i.ReadLsbtohU16 ();
 
  1109   uint16_t frame_control = i.ReadLsbtohU16 ();
 
  1088   SetFrameControl (frame_control);
 
  1110   SetFrameControl (frame_control);
 
  1089   m_duration = i.ReadLsbtohU16 ();
 
  1111   m_duration = i.ReadLsbtohU16 ();
 
  1090   ReadFrom (i, m_addr1);
 
  1112   ReadFrom (i, m_addr1);
 
  1091   switch (m_ctrlType) {
 
  1113   switch (m_ctrlType)
 
  1092   case TYPE_MGT:
 
  1114     {
 
  1093     ReadFrom (i, m_addr2);
 
  1115     case TYPE_MGT:
 
  1094     ReadFrom (i, m_addr3);
 
       
  1095     SetSequenceControl (i.ReadLsbtohU16 ());
 
       
  1096     break;
 
       
  1097   case TYPE_CTL:
 
       
  1098     switch (m_ctrlSubtype) {
 
       
  1099     case SUBTYPE_CTL_RTS:
 
       
  1100       ReadFrom (i, m_addr2);
 
  1116       ReadFrom (i, m_addr2);
 
  1101       break;
 
  1117       ReadFrom (i, m_addr3);
 
  1102     case SUBTYPE_CTL_CTS:
 
  1118       SetSequenceControl (i.ReadLsbtohU16 ());
 
  1103     case SUBTYPE_CTL_ACK:
 
  1119       break;
 
  1104       break;
 
  1120     case TYPE_CTL:
 
  1105     case SUBTYPE_CTL_BACKREQ:
 
  1121       switch (m_ctrlSubtype)
 
  1106     case SUBTYPE_CTL_BACKRESP:
 
  1122         {
 
       
  1123         case SUBTYPE_CTL_RTS:
 
       
  1124           ReadFrom (i, m_addr2);
 
       
  1125           break;
 
       
  1126         case SUBTYPE_CTL_CTS:
 
       
  1127         case SUBTYPE_CTL_ACK:
 
       
  1128           break;
 
       
  1129         case SUBTYPE_CTL_BACKREQ:
 
       
  1130         case SUBTYPE_CTL_BACKRESP:
 
       
  1131           ReadFrom (i, m_addr2);
 
       
  1132           break;
 
       
  1133         }
 
       
  1134       break;
 
       
  1135     case TYPE_DATA:
 
  1107       ReadFrom (i, m_addr2);
 
  1136       ReadFrom (i, m_addr2);
 
       
  1137       ReadFrom (i, m_addr3);
 
       
  1138       SetSequenceControl (i.ReadLsbtohU16 ());
 
       
  1139       if (m_ctrlToDs && m_ctrlFromDs)
 
       
  1140         {
 
       
  1141           ReadFrom (i, m_addr4);
 
       
  1142         }
 
       
  1143       if (m_ctrlSubtype & 0x08)
 
       
  1144         {
 
       
  1145           SetQosControl (i.ReadLsbtohU16 ());
 
       
  1146         }
 
  1108       break;
 
  1147       break;
 
  1109     }
 
  1148     }
 
  1110     break;
 
       
  1111   case TYPE_DATA:
 
       
  1112     ReadFrom (i, m_addr2);
 
       
  1113     ReadFrom (i, m_addr3);
 
       
  1114     SetSequenceControl (i.ReadLsbtohU16 ());
 
       
  1115     if (m_ctrlToDs && m_ctrlFromDs) {
 
       
  1116       ReadFrom (i, m_addr4);
 
       
  1117     }
 
       
  1118     if (m_ctrlSubtype & 0x08) {
 
       
  1119       SetQosControl (i.ReadLsbtohU16 ());
 
       
  1120     }
 
       
  1121     break;
 
       
  1122   }
 
       
  1123   return i.GetDistanceFrom (start);
 
  1149   return i.GetDistanceFrom (start);
 
  1124 }
 
  1150 }
 
  1125 
  1151 
  1126 } // namespace ns3
 
  1152 } // namespace ns3
ns-3.24