1 /* 2 * Copyright 2002-2005, Instant802 Networks, Inc. 3 * Copyright 2005-2006, Devicescape Software, Inc. 4 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz> 5 * Copyright 2007 Johannes Berg <johannes@sipsolutions.net> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 as 9 * published by the Free Software Foundation. 10 * 11 * utilities for mac80211 12 */ 13 14 #include <net/mac80211.h> 15 #include <linux/netdevice.h> 16 #include <linux/types.h> 17 #include <linux/slab.h> 18 #include <linux/skbuff.h> 19 #include <linux/etherdevice.h> 20 #include <linux/if_arp.h> 21 #include <linux/wireless.h> 22 #include <linux/bitmap.h> 23 #include <net/net_namespace.h> 24 #include <net/cfg80211.h> 25 #include <net/rtnetlink.h> 26 27 #include "ieee80211_i.h" 28 #include "rate.h" 29 #include "mesh.h" 30 #include "wme.h" 31 32 /* privid for wiphys to determine whether they belong to us or not */ 33 void *mac80211_wiphy_privid = &mac80211_wiphy_privid; 34 35 /* See IEEE 802.1H for LLC/SNAP encapsulation/decapsulation */ 36 /* Ethernet-II snap header (RFC1042 for most EtherTypes) */ 37 const unsigned char rfc1042_header[] __aligned(2) = 38 { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00 }; 39 40 /* Bridge-Tunnel header (for EtherTypes ETH_P_AARP and ETH_P_IPX) */ 41 const unsigned char bridge_tunnel_header[] __aligned(2) = 42 { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0xf8 }; 43 44 45 u8 *ieee80211_get_bssid(struct ieee80211_hdr *hdr, size_t len, 46 enum ieee80211_if_types type) 47 { 48 __le16 fc = hdr->frame_control; 49 50 /* drop ACK/CTS frames and incorrect hdr len (ctrl) */ 51 if (len < 16) 52 return NULL; 53 54 if (ieee80211_is_data(fc)) { 55 if (len < 24) /* drop incorrect hdr len (data) */ 56 return NULL; 57 58 if (ieee80211_has_a4(fc)) 59 return NULL; 60 if (ieee80211_has_tods(fc)) 61 return hdr->addr1; 62 if (ieee80211_has_fromds(fc)) 63 return hdr->addr2; 64 65 return hdr->addr3; 66 } 67 68 if (ieee80211_is_mgmt(fc)) { 69 if (len < 24) /* drop incorrect hdr len (mgmt) */ 70 return NULL; 71 return hdr->addr3; 72 } 73 74 if (ieee80211_is_ctl(fc)) { 75 if(ieee80211_is_pspoll(fc)) 76 return hdr->addr1; 77 78 if (ieee80211_is_back_req(fc)) { 79 switch (type) { 80 case IEEE80211_IF_TYPE_STA: 81 return hdr->addr2; 82 case IEEE80211_IF_TYPE_AP: 83 case IEEE80211_IF_TYPE_VLAN: 84 return hdr->addr1; 85 default: 86 break; /* fall through to the return */ 87 } 88 } 89 } 90 91 return NULL; 92 } 93 94 int ieee80211_get_hdrlen(u16 fc) 95 { 96 int hdrlen = 24; 97 98 switch (fc & IEEE80211_FCTL_FTYPE) { 99 case IEEE80211_FTYPE_DATA: 100 if ((fc & IEEE80211_FCTL_FROMDS) && (fc & IEEE80211_FCTL_TODS)) 101 hdrlen = 30; /* Addr4 */ 102 /* 103 * The QoS Control field is two bytes and its presence is 104 * indicated by the IEEE80211_STYPE_QOS_DATA bit. Add 2 to 105 * hdrlen if that bit is set. 106 * This works by masking out the bit and shifting it to 107 * bit position 1 so the result has the value 0 or 2. 108 */ 109 hdrlen += (fc & IEEE80211_STYPE_QOS_DATA) 110 >> (ilog2(IEEE80211_STYPE_QOS_DATA)-1); 111 break; 112 case IEEE80211_FTYPE_CTL: 113 /* 114 * ACK and CTS are 10 bytes, all others 16. To see how 115 * to get this condition consider 116 * subtype mask: 0b0000000011110000 (0x00F0) 117 * ACK subtype: 0b0000000011010000 (0x00D0) 118 * CTS subtype: 0b0000000011000000 (0x00C0) 119 * bits that matter: ^^^ (0x00E0) 120 * value of those: 0b0000000011000000 (0x00C0) 121 */ 122 if ((fc & 0xE0) == 0xC0) 123 hdrlen = 10; 124 else 125 hdrlen = 16; 126 break; 127 } 128 129 return hdrlen; 130 } 131 EXPORT_SYMBOL(ieee80211_get_hdrlen); 132 133 unsigned int ieee80211_hdrlen(__le16 fc) 134 { 135 unsigned int hdrlen = 24; 136 137 if (ieee80211_is_data(fc)) { 138 if (ieee80211_has_a4(fc)) 139 hdrlen = 30; 140 if (ieee80211_is_data_qos(fc)) 141 hdrlen += IEEE80211_QOS_CTL_LEN; 142 goto out; 143 } 144 145 if (ieee80211_is_ctl(fc)) { 146 /* 147 * ACK and CTS are 10 bytes, all others 16. To see how 148 * to get this condition consider 149 * subtype mask: 0b0000000011110000 (0x00F0) 150 * ACK subtype: 0b0000000011010000 (0x00D0) 151 * CTS subtype: 0b0000000011000000 (0x00C0) 152 * bits that matter: ^^^ (0x00E0) 153 * value of those: 0b0000000011000000 (0x00C0) 154 */ 155 if ((fc & cpu_to_le16(0x00E0)) == cpu_to_le16(0x00C0)) 156 hdrlen = 10; 157 else 158 hdrlen = 16; 159 } 160 out: 161 return hdrlen; 162 } 163 EXPORT_SYMBOL(ieee80211_hdrlen); 164 165 unsigned int ieee80211_get_hdrlen_from_skb(const struct sk_buff *skb) 166 { 167 const struct ieee80211_hdr *hdr = (const struct ieee80211_hdr *)skb->data; 168 unsigned int hdrlen; 169 170 if (unlikely(skb->len < 10)) 171 return 0; 172 hdrlen = ieee80211_hdrlen(hdr->frame_control); 173 if (unlikely(hdrlen > skb->len)) 174 return 0; 175 return hdrlen; 176 } 177 EXPORT_SYMBOL(ieee80211_get_hdrlen_from_skb); 178 179 int ieee80211_get_mesh_hdrlen(struct ieee80211s_hdr *meshhdr) 180 { 181 int ae = meshhdr->flags & IEEE80211S_FLAGS_AE; 182 /* 7.1.3.5a.2 */ 183 switch (ae) { 184 case 0: 185 return 6; 186 case 1: 187 return 12; 188 case 2: 189 return 18; 190 case 3: 191 return 24; 192 default: 193 return 6; 194 } 195 } 196 197 void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx) 198 { 199 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) tx->skb->data; 200 201 hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED); 202 if (tx->extra_frag) { 203 struct ieee80211_hdr *fhdr; 204 int i; 205 for (i = 0; i < tx->num_extra_frag; i++) { 206 fhdr = (struct ieee80211_hdr *) 207 tx->extra_frag[i]->data; 208 fhdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED); 209 } 210 } 211 } 212 213 int ieee80211_frame_duration(struct ieee80211_local *local, size_t len, 214 int rate, int erp, int short_preamble) 215 { 216 int dur; 217 218 /* calculate duration (in microseconds, rounded up to next higher 219 * integer if it includes a fractional microsecond) to send frame of 220 * len bytes (does not include FCS) at the given rate. Duration will 221 * also include SIFS. 222 * 223 * rate is in 100 kbps, so divident is multiplied by 10 in the 224 * DIV_ROUND_UP() operations. 225 */ 226 227 if (local->hw.conf.channel->band == IEEE80211_BAND_5GHZ || erp) { 228 /* 229 * OFDM: 230 * 231 * N_DBPS = DATARATE x 4 232 * N_SYM = Ceiling((16+8xLENGTH+6) / N_DBPS) 233 * (16 = SIGNAL time, 6 = tail bits) 234 * TXTIME = T_PREAMBLE + T_SIGNAL + T_SYM x N_SYM + Signal Ext 235 * 236 * T_SYM = 4 usec 237 * 802.11a - 17.5.2: aSIFSTime = 16 usec 238 * 802.11g - 19.8.4: aSIFSTime = 10 usec + 239 * signal ext = 6 usec 240 */ 241 dur = 16; /* SIFS + signal ext */ 242 dur += 16; /* 17.3.2.3: T_PREAMBLE = 16 usec */ 243 dur += 4; /* 17.3.2.3: T_SIGNAL = 4 usec */ 244 dur += 4 * DIV_ROUND_UP((16 + 8 * (len + 4) + 6) * 10, 245 4 * rate); /* T_SYM x N_SYM */ 246 } else { 247 /* 248 * 802.11b or 802.11g with 802.11b compatibility: 249 * 18.3.4: TXTIME = PreambleLength + PLCPHeaderTime + 250 * Ceiling(((LENGTH+PBCC)x8)/DATARATE). PBCC=0. 251 * 252 * 802.11 (DS): 15.3.3, 802.11b: 18.3.4 253 * aSIFSTime = 10 usec 254 * aPreambleLength = 144 usec or 72 usec with short preamble 255 * aPLCPHeaderLength = 48 usec or 24 usec with short preamble 256 */ 257 dur = 10; /* aSIFSTime = 10 usec */ 258 dur += short_preamble ? (72 + 24) : (144 + 48); 259 260 dur += DIV_ROUND_UP(8 * (len + 4) * 10, rate); 261 } 262 263 return dur; 264 } 265 266 /* Exported duration function for driver use */ 267 __le16 ieee80211_generic_frame_duration(struct ieee80211_hw *hw, 268 struct ieee80211_vif *vif, 269 size_t frame_len, 270 struct ieee80211_rate *rate) 271 { 272 struct ieee80211_local *local = hw_to_local(hw); 273 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif); 274 u16 dur; 275 int erp; 276 277 erp = 0; 278 if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE) 279 erp = rate->flags & IEEE80211_RATE_ERP_G; 280 281 dur = ieee80211_frame_duration(local, frame_len, rate->bitrate, erp, 282 sdata->bss_conf.use_short_preamble); 283 284 return cpu_to_le16(dur); 285 } 286 EXPORT_SYMBOL(ieee80211_generic_frame_duration); 287 288 __le16 ieee80211_rts_duration(struct ieee80211_hw *hw, 289 struct ieee80211_vif *vif, size_t frame_len, 290 const struct ieee80211_tx_info *frame_txctl) 291 { 292 struct ieee80211_local *local = hw_to_local(hw); 293 struct ieee80211_rate *rate; 294 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif); 295 bool short_preamble; 296 int erp; 297 u16 dur; 298 struct ieee80211_supported_band *sband; 299 300 sband = local->hw.wiphy->bands[local->hw.conf.channel->band]; 301 302 short_preamble = sdata->bss_conf.use_short_preamble; 303 304 rate = &sband->bitrates[frame_txctl->control.rts_cts_rate_idx]; 305 306 erp = 0; 307 if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE) 308 erp = rate->flags & IEEE80211_RATE_ERP_G; 309 310 /* CTS duration */ 311 dur = ieee80211_frame_duration(local, 10, rate->bitrate, 312 erp, short_preamble); 313 /* Data frame duration */ 314 dur += ieee80211_frame_duration(local, frame_len, rate->bitrate, 315 erp, short_preamble); 316 /* ACK duration */ 317 dur += ieee80211_frame_duration(local, 10, rate->bitrate, 318 erp, short_preamble); 319 320 return cpu_to_le16(dur); 321 } 322 EXPORT_SYMBOL(ieee80211_rts_duration); 323 324 __le16 ieee80211_ctstoself_duration(struct ieee80211_hw *hw, 325 struct ieee80211_vif *vif, 326 size_t frame_len, 327 const struct ieee80211_tx_info *frame_txctl) 328 { 329 struct ieee80211_local *local = hw_to_local(hw); 330 struct ieee80211_rate *rate; 331 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif); 332 bool short_preamble; 333 int erp; 334 u16 dur; 335 struct ieee80211_supported_band *sband; 336 337 sband = local->hw.wiphy->bands[local->hw.conf.channel->band]; 338 339 short_preamble = sdata->bss_conf.use_short_preamble; 340 341 rate = &sband->bitrates[frame_txctl->control.rts_cts_rate_idx]; 342 erp = 0; 343 if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE) 344 erp = rate->flags & IEEE80211_RATE_ERP_G; 345 346 /* Data frame duration */ 347 dur = ieee80211_frame_duration(local, frame_len, rate->bitrate, 348 erp, short_preamble); 349 if (!(frame_txctl->flags & IEEE80211_TX_CTL_NO_ACK)) { 350 /* ACK duration */ 351 dur += ieee80211_frame_duration(local, 10, rate->bitrate, 352 erp, short_preamble); 353 } 354 355 return cpu_to_le16(dur); 356 } 357 EXPORT_SYMBOL(ieee80211_ctstoself_duration); 358 359 void ieee80211_wake_queue(struct ieee80211_hw *hw, int queue) 360 { 361 struct ieee80211_local *local = hw_to_local(hw); 362 363 if (test_bit(queue, local->queues_pending)) { 364 tasklet_schedule(&local->tx_pending_tasklet); 365 } else { 366 netif_wake_subqueue(local->mdev, queue); 367 } 368 } 369 EXPORT_SYMBOL(ieee80211_wake_queue); 370 371 void ieee80211_stop_queue(struct ieee80211_hw *hw, int queue) 372 { 373 struct ieee80211_local *local = hw_to_local(hw); 374 375 netif_stop_subqueue(local->mdev, queue); 376 } 377 EXPORT_SYMBOL(ieee80211_stop_queue); 378 379 void ieee80211_stop_queues(struct ieee80211_hw *hw) 380 { 381 int i; 382 383 for (i = 0; i < ieee80211_num_queues(hw); i++) 384 ieee80211_stop_queue(hw, i); 385 } 386 EXPORT_SYMBOL(ieee80211_stop_queues); 387 388 void ieee80211_wake_queues(struct ieee80211_hw *hw) 389 { 390 int i; 391 392 for (i = 0; i < hw->queues + hw->ampdu_queues; i++) 393 ieee80211_wake_queue(hw, i); 394 } 395 EXPORT_SYMBOL(ieee80211_wake_queues); 396 397 void ieee80211_iterate_active_interfaces( 398 struct ieee80211_hw *hw, 399 void (*iterator)(void *data, u8 *mac, 400 struct ieee80211_vif *vif), 401 void *data) 402 { 403 struct ieee80211_local *local = hw_to_local(hw); 404 struct ieee80211_sub_if_data *sdata; 405 406 rtnl_lock(); 407 408 list_for_each_entry(sdata, &local->interfaces, list) { 409 switch (sdata->vif.type) { 410 case IEEE80211_IF_TYPE_INVALID: 411 case IEEE80211_IF_TYPE_MNTR: 412 case IEEE80211_IF_TYPE_VLAN: 413 continue; 414 case IEEE80211_IF_TYPE_AP: 415 case IEEE80211_IF_TYPE_STA: 416 case IEEE80211_IF_TYPE_IBSS: 417 case IEEE80211_IF_TYPE_WDS: 418 case IEEE80211_IF_TYPE_MESH_POINT: 419 break; 420 } 421 if (netif_running(sdata->dev)) 422 iterator(data, sdata->dev->dev_addr, 423 &sdata->vif); 424 } 425 426 rtnl_unlock(); 427 } 428 EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces); 429 430 void ieee80211_iterate_active_interfaces_atomic( 431 struct ieee80211_hw *hw, 432 void (*iterator)(void *data, u8 *mac, 433 struct ieee80211_vif *vif), 434 void *data) 435 { 436 struct ieee80211_local *local = hw_to_local(hw); 437 struct ieee80211_sub_if_data *sdata; 438 439 rcu_read_lock(); 440 441 list_for_each_entry_rcu(sdata, &local->interfaces, list) { 442 switch (sdata->vif.type) { 443 case IEEE80211_IF_TYPE_INVALID: 444 case IEEE80211_IF_TYPE_MNTR: 445 case IEEE80211_IF_TYPE_VLAN: 446 continue; 447 case IEEE80211_IF_TYPE_AP: 448 case IEEE80211_IF_TYPE_STA: 449 case IEEE80211_IF_TYPE_IBSS: 450 case IEEE80211_IF_TYPE_WDS: 451 case IEEE80211_IF_TYPE_MESH_POINT: 452 break; 453 } 454 if (netif_running(sdata->dev)) 455 iterator(data, sdata->dev->dev_addr, 456 &sdata->vif); 457 } 458 459 rcu_read_unlock(); 460 } 461 EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_atomic); 462