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 u16 fc; 49 50 /* drop ACK/CTS frames and incorrect hdr len (ctrl) */ 51 if (len < 16) 52 return NULL; 53 54 fc = le16_to_cpu(hdr->frame_control); 55 56 switch (fc & IEEE80211_FCTL_FTYPE) { 57 case IEEE80211_FTYPE_DATA: 58 if (len < 24) /* drop incorrect hdr len (data) */ 59 return NULL; 60 switch (fc & (IEEE80211_FCTL_TODS | IEEE80211_FCTL_FROMDS)) { 61 case IEEE80211_FCTL_TODS: 62 return hdr->addr1; 63 case (IEEE80211_FCTL_TODS | IEEE80211_FCTL_FROMDS): 64 return NULL; 65 case IEEE80211_FCTL_FROMDS: 66 return hdr->addr2; 67 case 0: 68 return hdr->addr3; 69 } 70 break; 71 case IEEE80211_FTYPE_MGMT: 72 if (len < 24) /* drop incorrect hdr len (mgmt) */ 73 return NULL; 74 return hdr->addr3; 75 case IEEE80211_FTYPE_CTL: 76 if ((fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_PSPOLL) 77 return hdr->addr1; 78 else if ((fc & IEEE80211_FCTL_STYPE) == 79 IEEE80211_STYPE_BACK_REQ) { 80 switch (type) { 81 case IEEE80211_IF_TYPE_STA: 82 return hdr->addr2; 83 case IEEE80211_IF_TYPE_AP: 84 case IEEE80211_IF_TYPE_VLAN: 85 return hdr->addr1; 86 default: 87 return NULL; 88 } 89 } 90 else 91 return NULL; 92 } 93 94 return NULL; 95 } 96 97 int ieee80211_get_hdrlen(u16 fc) 98 { 99 int hdrlen = 24; 100 101 switch (fc & IEEE80211_FCTL_FTYPE) { 102 case IEEE80211_FTYPE_DATA: 103 if ((fc & IEEE80211_FCTL_FROMDS) && (fc & IEEE80211_FCTL_TODS)) 104 hdrlen = 30; /* Addr4 */ 105 /* 106 * The QoS Control field is two bytes and its presence is 107 * indicated by the IEEE80211_STYPE_QOS_DATA bit. Add 2 to 108 * hdrlen if that bit is set. 109 * This works by masking out the bit and shifting it to 110 * bit position 1 so the result has the value 0 or 2. 111 */ 112 hdrlen += (fc & IEEE80211_STYPE_QOS_DATA) 113 >> (ilog2(IEEE80211_STYPE_QOS_DATA)-1); 114 break; 115 case IEEE80211_FTYPE_CTL: 116 /* 117 * ACK and CTS are 10 bytes, all others 16. To see how 118 * to get this condition consider 119 * subtype mask: 0b0000000011110000 (0x00F0) 120 * ACK subtype: 0b0000000011010000 (0x00D0) 121 * CTS subtype: 0b0000000011000000 (0x00C0) 122 * bits that matter: ^^^ (0x00E0) 123 * value of those: 0b0000000011000000 (0x00C0) 124 */ 125 if ((fc & 0xE0) == 0xC0) 126 hdrlen = 10; 127 else 128 hdrlen = 16; 129 break; 130 } 131 132 return hdrlen; 133 } 134 EXPORT_SYMBOL(ieee80211_get_hdrlen); 135 136 int ieee80211_get_hdrlen_from_skb(const struct sk_buff *skb) 137 { 138 const struct ieee80211_hdr *hdr = (const struct ieee80211_hdr *) skb->data; 139 int hdrlen; 140 141 if (unlikely(skb->len < 10)) 142 return 0; 143 hdrlen = ieee80211_get_hdrlen(le16_to_cpu(hdr->frame_control)); 144 if (unlikely(hdrlen > skb->len)) 145 return 0; 146 return hdrlen; 147 } 148 EXPORT_SYMBOL(ieee80211_get_hdrlen_from_skb); 149 150 int ieee80211_get_mesh_hdrlen(struct ieee80211s_hdr *meshhdr) 151 { 152 int ae = meshhdr->flags & IEEE80211S_FLAGS_AE; 153 /* 7.1.3.5a.2 */ 154 switch (ae) { 155 case 0: 156 return 6; 157 case 1: 158 return 12; 159 case 2: 160 return 18; 161 case 3: 162 return 24; 163 default: 164 return 6; 165 } 166 } 167 168 void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx) 169 { 170 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) tx->skb->data; 171 172 hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED); 173 if (tx->extra_frag) { 174 struct ieee80211_hdr *fhdr; 175 int i; 176 for (i = 0; i < tx->num_extra_frag; i++) { 177 fhdr = (struct ieee80211_hdr *) 178 tx->extra_frag[i]->data; 179 fhdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED); 180 } 181 } 182 } 183 184 int ieee80211_frame_duration(struct ieee80211_local *local, size_t len, 185 int rate, int erp, int short_preamble) 186 { 187 int dur; 188 189 /* calculate duration (in microseconds, rounded up to next higher 190 * integer if it includes a fractional microsecond) to send frame of 191 * len bytes (does not include FCS) at the given rate. Duration will 192 * also include SIFS. 193 * 194 * rate is in 100 kbps, so divident is multiplied by 10 in the 195 * DIV_ROUND_UP() operations. 196 */ 197 198 if (local->hw.conf.channel->band == IEEE80211_BAND_5GHZ || erp) { 199 /* 200 * OFDM: 201 * 202 * N_DBPS = DATARATE x 4 203 * N_SYM = Ceiling((16+8xLENGTH+6) / N_DBPS) 204 * (16 = SIGNAL time, 6 = tail bits) 205 * TXTIME = T_PREAMBLE + T_SIGNAL + T_SYM x N_SYM + Signal Ext 206 * 207 * T_SYM = 4 usec 208 * 802.11a - 17.5.2: aSIFSTime = 16 usec 209 * 802.11g - 19.8.4: aSIFSTime = 10 usec + 210 * signal ext = 6 usec 211 */ 212 dur = 16; /* SIFS + signal ext */ 213 dur += 16; /* 17.3.2.3: T_PREAMBLE = 16 usec */ 214 dur += 4; /* 17.3.2.3: T_SIGNAL = 4 usec */ 215 dur += 4 * DIV_ROUND_UP((16 + 8 * (len + 4) + 6) * 10, 216 4 * rate); /* T_SYM x N_SYM */ 217 } else { 218 /* 219 * 802.11b or 802.11g with 802.11b compatibility: 220 * 18.3.4: TXTIME = PreambleLength + PLCPHeaderTime + 221 * Ceiling(((LENGTH+PBCC)x8)/DATARATE). PBCC=0. 222 * 223 * 802.11 (DS): 15.3.3, 802.11b: 18.3.4 224 * aSIFSTime = 10 usec 225 * aPreambleLength = 144 usec or 72 usec with short preamble 226 * aPLCPHeaderLength = 48 usec or 24 usec with short preamble 227 */ 228 dur = 10; /* aSIFSTime = 10 usec */ 229 dur += short_preamble ? (72 + 24) : (144 + 48); 230 231 dur += DIV_ROUND_UP(8 * (len + 4) * 10, rate); 232 } 233 234 return dur; 235 } 236 237 /* Exported duration function for driver use */ 238 __le16 ieee80211_generic_frame_duration(struct ieee80211_hw *hw, 239 struct ieee80211_vif *vif, 240 size_t frame_len, 241 struct ieee80211_rate *rate) 242 { 243 struct ieee80211_local *local = hw_to_local(hw); 244 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif); 245 u16 dur; 246 int erp; 247 248 erp = 0; 249 if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE) 250 erp = rate->flags & IEEE80211_RATE_ERP_G; 251 252 dur = ieee80211_frame_duration(local, frame_len, rate->bitrate, erp, 253 sdata->bss_conf.use_short_preamble); 254 255 return cpu_to_le16(dur); 256 } 257 EXPORT_SYMBOL(ieee80211_generic_frame_duration); 258 259 __le16 ieee80211_rts_duration(struct ieee80211_hw *hw, 260 struct ieee80211_vif *vif, size_t frame_len, 261 const struct ieee80211_tx_control *frame_txctl) 262 { 263 struct ieee80211_local *local = hw_to_local(hw); 264 struct ieee80211_rate *rate; 265 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif); 266 bool short_preamble; 267 int erp; 268 u16 dur; 269 270 short_preamble = sdata->bss_conf.use_short_preamble; 271 272 rate = frame_txctl->rts_cts_rate; 273 274 erp = 0; 275 if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE) 276 erp = rate->flags & IEEE80211_RATE_ERP_G; 277 278 /* CTS duration */ 279 dur = ieee80211_frame_duration(local, 10, rate->bitrate, 280 erp, short_preamble); 281 /* Data frame duration */ 282 dur += ieee80211_frame_duration(local, frame_len, rate->bitrate, 283 erp, short_preamble); 284 /* ACK duration */ 285 dur += ieee80211_frame_duration(local, 10, rate->bitrate, 286 erp, short_preamble); 287 288 return cpu_to_le16(dur); 289 } 290 EXPORT_SYMBOL(ieee80211_rts_duration); 291 292 __le16 ieee80211_ctstoself_duration(struct ieee80211_hw *hw, 293 struct ieee80211_vif *vif, 294 size_t frame_len, 295 const struct ieee80211_tx_control *frame_txctl) 296 { 297 struct ieee80211_local *local = hw_to_local(hw); 298 struct ieee80211_rate *rate; 299 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif); 300 bool short_preamble; 301 int erp; 302 u16 dur; 303 304 short_preamble = sdata->bss_conf.use_short_preamble; 305 306 rate = frame_txctl->rts_cts_rate; 307 erp = 0; 308 if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE) 309 erp = rate->flags & IEEE80211_RATE_ERP_G; 310 311 /* Data frame duration */ 312 dur = ieee80211_frame_duration(local, frame_len, rate->bitrate, 313 erp, short_preamble); 314 if (!(frame_txctl->flags & IEEE80211_TXCTL_NO_ACK)) { 315 /* ACK duration */ 316 dur += ieee80211_frame_duration(local, 10, rate->bitrate, 317 erp, short_preamble); 318 } 319 320 return cpu_to_le16(dur); 321 } 322 EXPORT_SYMBOL(ieee80211_ctstoself_duration); 323 324 void ieee80211_wake_queue(struct ieee80211_hw *hw, int queue) 325 { 326 struct ieee80211_local *local = hw_to_local(hw); 327 328 if (test_and_clear_bit(IEEE80211_LINK_STATE_XOFF, 329 &local->state[queue])) { 330 if (test_bit(IEEE80211_LINK_STATE_PENDING, 331 &local->state[queue])) 332 tasklet_schedule(&local->tx_pending_tasklet); 333 else 334 if (!ieee80211_qdisc_installed(local->mdev)) { 335 if (queue == 0) 336 netif_wake_queue(local->mdev); 337 } else 338 __netif_schedule(local->mdev); 339 } 340 } 341 EXPORT_SYMBOL(ieee80211_wake_queue); 342 343 void ieee80211_stop_queue(struct ieee80211_hw *hw, int queue) 344 { 345 struct ieee80211_local *local = hw_to_local(hw); 346 347 if (!ieee80211_qdisc_installed(local->mdev) && queue == 0) 348 netif_stop_queue(local->mdev); 349 set_bit(IEEE80211_LINK_STATE_XOFF, &local->state[queue]); 350 } 351 EXPORT_SYMBOL(ieee80211_stop_queue); 352 353 void ieee80211_start_queues(struct ieee80211_hw *hw) 354 { 355 struct ieee80211_local *local = hw_to_local(hw); 356 int i; 357 358 for (i = 0; i < local->hw.queues; i++) 359 clear_bit(IEEE80211_LINK_STATE_XOFF, &local->state[i]); 360 if (!ieee80211_qdisc_installed(local->mdev)) 361 netif_start_queue(local->mdev); 362 } 363 EXPORT_SYMBOL(ieee80211_start_queues); 364 365 void ieee80211_stop_queues(struct ieee80211_hw *hw) 366 { 367 int i; 368 369 for (i = 0; i < hw->queues; i++) 370 ieee80211_stop_queue(hw, i); 371 } 372 EXPORT_SYMBOL(ieee80211_stop_queues); 373 374 void ieee80211_wake_queues(struct ieee80211_hw *hw) 375 { 376 int i; 377 378 for (i = 0; i < hw->queues; i++) 379 ieee80211_wake_queue(hw, i); 380 } 381 EXPORT_SYMBOL(ieee80211_wake_queues); 382 383 void ieee80211_iterate_active_interfaces( 384 struct ieee80211_hw *hw, 385 void (*iterator)(void *data, u8 *mac, 386 struct ieee80211_vif *vif), 387 void *data) 388 { 389 struct ieee80211_local *local = hw_to_local(hw); 390 struct ieee80211_sub_if_data *sdata; 391 392 rtnl_lock(); 393 394 list_for_each_entry(sdata, &local->interfaces, list) { 395 switch (sdata->vif.type) { 396 case IEEE80211_IF_TYPE_INVALID: 397 case IEEE80211_IF_TYPE_MNTR: 398 case IEEE80211_IF_TYPE_VLAN: 399 continue; 400 case IEEE80211_IF_TYPE_AP: 401 case IEEE80211_IF_TYPE_STA: 402 case IEEE80211_IF_TYPE_IBSS: 403 case IEEE80211_IF_TYPE_WDS: 404 case IEEE80211_IF_TYPE_MESH_POINT: 405 break; 406 } 407 if (sdata->dev == local->mdev) 408 continue; 409 if (netif_running(sdata->dev)) 410 iterator(data, sdata->dev->dev_addr, 411 &sdata->vif); 412 } 413 414 rtnl_unlock(); 415 } 416 EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces); 417 418 void ieee80211_iterate_active_interfaces_atomic( 419 struct ieee80211_hw *hw, 420 void (*iterator)(void *data, u8 *mac, 421 struct ieee80211_vif *vif), 422 void *data) 423 { 424 struct ieee80211_local *local = hw_to_local(hw); 425 struct ieee80211_sub_if_data *sdata; 426 427 rcu_read_lock(); 428 429 list_for_each_entry_rcu(sdata, &local->interfaces, list) { 430 switch (sdata->vif.type) { 431 case IEEE80211_IF_TYPE_INVALID: 432 case IEEE80211_IF_TYPE_MNTR: 433 case IEEE80211_IF_TYPE_VLAN: 434 continue; 435 case IEEE80211_IF_TYPE_AP: 436 case IEEE80211_IF_TYPE_STA: 437 case IEEE80211_IF_TYPE_IBSS: 438 case IEEE80211_IF_TYPE_WDS: 439 case IEEE80211_IF_TYPE_MESH_POINT: 440 break; 441 } 442 if (sdata->dev == local->mdev) 443 continue; 444 if (netif_running(sdata->dev)) 445 iterator(data, sdata->dev->dev_addr, 446 &sdata->vif); 447 } 448 449 rcu_read_unlock(); 450 } 451 EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_atomic); 452