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