tx.c 56 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083
  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. *
  12. * Transmit and frame generation functions.
  13. */
  14. #include <linux/kernel.h>
  15. #include <linux/slab.h>
  16. #include <linux/skbuff.h>
  17. #include <linux/etherdevice.h>
  18. #include <linux/bitmap.h>
  19. #include <linux/rcupdate.h>
  20. #include <net/net_namespace.h>
  21. #include <net/ieee80211_radiotap.h>
  22. #include <net/cfg80211.h>
  23. #include <net/mac80211.h>
  24. #include <asm/unaligned.h>
  25. #include "ieee80211_i.h"
  26. #include "led.h"
  27. #include "mesh.h"
  28. #include "wep.h"
  29. #include "wpa.h"
  30. #include "wme.h"
  31. #include "rate.h"
  32. #define IEEE80211_TX_OK 0
  33. #define IEEE80211_TX_AGAIN 1
  34. #define IEEE80211_TX_FRAG_AGAIN 2
  35. /* misc utils */
  36. static __le16 ieee80211_duration(struct ieee80211_tx_data *tx, int group_addr,
  37. int next_frag_len)
  38. {
  39. int rate, mrate, erp, dur, i;
  40. struct ieee80211_rate *txrate;
  41. struct ieee80211_local *local = tx->local;
  42. struct ieee80211_supported_band *sband;
  43. struct ieee80211_hdr *hdr;
  44. struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
  45. /* assume HW handles this */
  46. if (info->control.rates[0].flags & IEEE80211_TX_RC_MCS)
  47. return 0;
  48. /* uh huh? */
  49. if (WARN_ON_ONCE(info->control.rates[0].idx < 0))
  50. return 0;
  51. sband = local->hw.wiphy->bands[tx->channel->band];
  52. txrate = &sband->bitrates[info->control.rates[0].idx];
  53. erp = txrate->flags & IEEE80211_RATE_ERP_G;
  54. /*
  55. * data and mgmt (except PS Poll):
  56. * - during CFP: 32768
  57. * - during contention period:
  58. * if addr1 is group address: 0
  59. * if more fragments = 0 and addr1 is individual address: time to
  60. * transmit one ACK plus SIFS
  61. * if more fragments = 1 and addr1 is individual address: time to
  62. * transmit next fragment plus 2 x ACK plus 3 x SIFS
  63. *
  64. * IEEE 802.11, 9.6:
  65. * - control response frame (CTS or ACK) shall be transmitted using the
  66. * same rate as the immediately previous frame in the frame exchange
  67. * sequence, if this rate belongs to the PHY mandatory rates, or else
  68. * at the highest possible rate belonging to the PHY rates in the
  69. * BSSBasicRateSet
  70. */
  71. hdr = (struct ieee80211_hdr *)tx->skb->data;
  72. if (ieee80211_is_ctl(hdr->frame_control)) {
  73. /* TODO: These control frames are not currently sent by
  74. * mac80211, but should they be implemented, this function
  75. * needs to be updated to support duration field calculation.
  76. *
  77. * RTS: time needed to transmit pending data/mgmt frame plus
  78. * one CTS frame plus one ACK frame plus 3 x SIFS
  79. * CTS: duration of immediately previous RTS minus time
  80. * required to transmit CTS and its SIFS
  81. * ACK: 0 if immediately previous directed data/mgmt had
  82. * more=0, with more=1 duration in ACK frame is duration
  83. * from previous frame minus time needed to transmit ACK
  84. * and its SIFS
  85. * PS Poll: BIT(15) | BIT(14) | aid
  86. */
  87. return 0;
  88. }
  89. /* data/mgmt */
  90. if (0 /* FIX: data/mgmt during CFP */)
  91. return cpu_to_le16(32768);
  92. if (group_addr) /* Group address as the destination - no ACK */
  93. return 0;
  94. /* Individual destination address:
  95. * IEEE 802.11, Ch. 9.6 (after IEEE 802.11g changes)
  96. * CTS and ACK frames shall be transmitted using the highest rate in
  97. * basic rate set that is less than or equal to the rate of the
  98. * immediately previous frame and that is using the same modulation
  99. * (CCK or OFDM). If no basic rate set matches with these requirements,
  100. * the highest mandatory rate of the PHY that is less than or equal to
  101. * the rate of the previous frame is used.
  102. * Mandatory rates for IEEE 802.11g PHY: 1, 2, 5.5, 11, 6, 12, 24 Mbps
  103. */
  104. rate = -1;
  105. /* use lowest available if everything fails */
  106. mrate = sband->bitrates[0].bitrate;
  107. for (i = 0; i < sband->n_bitrates; i++) {
  108. struct ieee80211_rate *r = &sband->bitrates[i];
  109. if (r->bitrate > txrate->bitrate)
  110. break;
  111. if (tx->sdata->vif.bss_conf.basic_rates & BIT(i))
  112. rate = r->bitrate;
  113. switch (sband->band) {
  114. case IEEE80211_BAND_2GHZ: {
  115. u32 flag;
  116. if (tx->sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
  117. flag = IEEE80211_RATE_MANDATORY_G;
  118. else
  119. flag = IEEE80211_RATE_MANDATORY_B;
  120. if (r->flags & flag)
  121. mrate = r->bitrate;
  122. break;
  123. }
  124. case IEEE80211_BAND_5GHZ:
  125. if (r->flags & IEEE80211_RATE_MANDATORY_A)
  126. mrate = r->bitrate;
  127. break;
  128. case IEEE80211_NUM_BANDS:
  129. WARN_ON(1);
  130. break;
  131. }
  132. }
  133. if (rate == -1) {
  134. /* No matching basic rate found; use highest suitable mandatory
  135. * PHY rate */
  136. rate = mrate;
  137. }
  138. /* Time needed to transmit ACK
  139. * (10 bytes + 4-byte FCS = 112 bits) plus SIFS; rounded up
  140. * to closest integer */
  141. dur = ieee80211_frame_duration(local, 10, rate, erp,
  142. tx->sdata->vif.bss_conf.use_short_preamble);
  143. if (next_frag_len) {
  144. /* Frame is fragmented: duration increases with time needed to
  145. * transmit next fragment plus ACK and 2 x SIFS. */
  146. dur *= 2; /* ACK + SIFS */
  147. /* next fragment */
  148. dur += ieee80211_frame_duration(local, next_frag_len,
  149. txrate->bitrate, erp,
  150. tx->sdata->vif.bss_conf.use_short_preamble);
  151. }
  152. return cpu_to_le16(dur);
  153. }
  154. static int inline is_ieee80211_device(struct ieee80211_local *local,
  155. struct net_device *dev)
  156. {
  157. return local == wdev_priv(dev->ieee80211_ptr);
  158. }
  159. /* tx handlers */
  160. static ieee80211_tx_result debug_noinline
  161. ieee80211_tx_h_check_assoc(struct ieee80211_tx_data *tx)
  162. {
  163. struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
  164. struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
  165. u32 sta_flags;
  166. if (unlikely(info->flags & IEEE80211_TX_CTL_INJECTED))
  167. return TX_CONTINUE;
  168. if (unlikely(tx->local->sw_scanning) &&
  169. !ieee80211_is_probe_req(hdr->frame_control))
  170. return TX_DROP;
  171. if (tx->sdata->vif.type == NL80211_IFTYPE_MESH_POINT)
  172. return TX_CONTINUE;
  173. if (tx->flags & IEEE80211_TX_PS_BUFFERED)
  174. return TX_CONTINUE;
  175. sta_flags = tx->sta ? get_sta_flags(tx->sta) : 0;
  176. if (likely(tx->flags & IEEE80211_TX_UNICAST)) {
  177. if (unlikely(!(sta_flags & WLAN_STA_ASSOC) &&
  178. tx->sdata->vif.type != NL80211_IFTYPE_ADHOC &&
  179. ieee80211_is_data(hdr->frame_control))) {
  180. #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
  181. printk(KERN_DEBUG "%s: dropped data frame to not "
  182. "associated station %pM\n",
  183. tx->dev->name, hdr->addr1);
  184. #endif /* CONFIG_MAC80211_VERBOSE_DEBUG */
  185. I802_DEBUG_INC(tx->local->tx_handlers_drop_not_assoc);
  186. return TX_DROP;
  187. }
  188. } else {
  189. if (unlikely(ieee80211_is_data(hdr->frame_control) &&
  190. tx->local->num_sta == 0 &&
  191. tx->sdata->vif.type != NL80211_IFTYPE_ADHOC)) {
  192. /*
  193. * No associated STAs - no need to send multicast
  194. * frames.
  195. */
  196. return TX_DROP;
  197. }
  198. return TX_CONTINUE;
  199. }
  200. return TX_CONTINUE;
  201. }
  202. /* This function is called whenever the AP is about to exceed the maximum limit
  203. * of buffered frames for power saving STAs. This situation should not really
  204. * happen often during normal operation, so dropping the oldest buffered packet
  205. * from each queue should be OK to make some room for new frames. */
  206. static void purge_old_ps_buffers(struct ieee80211_local *local)
  207. {
  208. int total = 0, purged = 0;
  209. struct sk_buff *skb;
  210. struct ieee80211_sub_if_data *sdata;
  211. struct sta_info *sta;
  212. /*
  213. * virtual interfaces are protected by RCU
  214. */
  215. rcu_read_lock();
  216. list_for_each_entry_rcu(sdata, &local->interfaces, list) {
  217. struct ieee80211_if_ap *ap;
  218. if (sdata->vif.type != NL80211_IFTYPE_AP)
  219. continue;
  220. ap = &sdata->u.ap;
  221. skb = skb_dequeue(&ap->ps_bc_buf);
  222. if (skb) {
  223. purged++;
  224. dev_kfree_skb(skb);
  225. }
  226. total += skb_queue_len(&ap->ps_bc_buf);
  227. }
  228. list_for_each_entry_rcu(sta, &local->sta_list, list) {
  229. skb = skb_dequeue(&sta->ps_tx_buf);
  230. if (skb) {
  231. purged++;
  232. dev_kfree_skb(skb);
  233. }
  234. total += skb_queue_len(&sta->ps_tx_buf);
  235. }
  236. rcu_read_unlock();
  237. local->total_ps_buffered = total;
  238. #ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
  239. printk(KERN_DEBUG "%s: PS buffers full - purged %d frames\n",
  240. wiphy_name(local->hw.wiphy), purged);
  241. #endif
  242. }
  243. static ieee80211_tx_result
  244. ieee80211_tx_h_multicast_ps_buf(struct ieee80211_tx_data *tx)
  245. {
  246. struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
  247. struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
  248. /*
  249. * broadcast/multicast frame
  250. *
  251. * If any of the associated stations is in power save mode,
  252. * the frame is buffered to be sent after DTIM beacon frame.
  253. * This is done either by the hardware or us.
  254. */
  255. /* powersaving STAs only in AP/VLAN mode */
  256. if (!tx->sdata->bss)
  257. return TX_CONTINUE;
  258. /* no buffering for ordered frames */
  259. if (ieee80211_has_order(hdr->frame_control))
  260. return TX_CONTINUE;
  261. /* no stations in PS mode */
  262. if (!atomic_read(&tx->sdata->bss->num_sta_ps))
  263. return TX_CONTINUE;
  264. /* buffered in mac80211 */
  265. if (tx->local->hw.flags & IEEE80211_HW_HOST_BROADCAST_PS_BUFFERING) {
  266. if (tx->local->total_ps_buffered >= TOTAL_MAX_TX_BUFFER)
  267. purge_old_ps_buffers(tx->local);
  268. if (skb_queue_len(&tx->sdata->bss->ps_bc_buf) >=
  269. AP_MAX_BC_BUFFER) {
  270. #ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
  271. if (net_ratelimit()) {
  272. printk(KERN_DEBUG "%s: BC TX buffer full - "
  273. "dropping the oldest frame\n",
  274. tx->dev->name);
  275. }
  276. #endif
  277. dev_kfree_skb(skb_dequeue(&tx->sdata->bss->ps_bc_buf));
  278. } else
  279. tx->local->total_ps_buffered++;
  280. skb_queue_tail(&tx->sdata->bss->ps_bc_buf, tx->skb);
  281. return TX_QUEUED;
  282. }
  283. /* buffered in hardware */
  284. info->flags |= IEEE80211_TX_CTL_SEND_AFTER_DTIM;
  285. return TX_CONTINUE;
  286. }
  287. static ieee80211_tx_result
  288. ieee80211_tx_h_unicast_ps_buf(struct ieee80211_tx_data *tx)
  289. {
  290. struct sta_info *sta = tx->sta;
  291. struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
  292. struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
  293. u32 staflags;
  294. if (unlikely(!sta || ieee80211_is_probe_resp(hdr->frame_control)))
  295. return TX_CONTINUE;
  296. staflags = get_sta_flags(sta);
  297. if (unlikely((staflags & WLAN_STA_PS) &&
  298. !(staflags & WLAN_STA_PSPOLL))) {
  299. #ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
  300. printk(KERN_DEBUG "STA %pM aid %d: PS buffer (entries "
  301. "before %d)\n",
  302. sta->sta.addr, sta->sta.aid,
  303. skb_queue_len(&sta->ps_tx_buf));
  304. #endif /* CONFIG_MAC80211_VERBOSE_PS_DEBUG */
  305. if (tx->local->total_ps_buffered >= TOTAL_MAX_TX_BUFFER)
  306. purge_old_ps_buffers(tx->local);
  307. if (skb_queue_len(&sta->ps_tx_buf) >= STA_MAX_TX_BUFFER) {
  308. struct sk_buff *old = skb_dequeue(&sta->ps_tx_buf);
  309. #ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
  310. if (net_ratelimit()) {
  311. printk(KERN_DEBUG "%s: STA %pM TX "
  312. "buffer full - dropping oldest frame\n",
  313. tx->dev->name, sta->sta.addr);
  314. }
  315. #endif
  316. dev_kfree_skb(old);
  317. } else
  318. tx->local->total_ps_buffered++;
  319. /* Queue frame to be sent after STA sends an PS Poll frame */
  320. if (skb_queue_empty(&sta->ps_tx_buf))
  321. sta_info_set_tim_bit(sta);
  322. info->control.jiffies = jiffies;
  323. skb_queue_tail(&sta->ps_tx_buf, tx->skb);
  324. return TX_QUEUED;
  325. }
  326. #ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
  327. else if (unlikely(test_sta_flags(sta, WLAN_STA_PS))) {
  328. printk(KERN_DEBUG "%s: STA %pM in PS mode, but pspoll "
  329. "set -> send frame\n", tx->dev->name,
  330. sta->sta.addr);
  331. }
  332. #endif /* CONFIG_MAC80211_VERBOSE_PS_DEBUG */
  333. clear_sta_flags(sta, WLAN_STA_PSPOLL);
  334. return TX_CONTINUE;
  335. }
  336. static ieee80211_tx_result debug_noinline
  337. ieee80211_tx_h_ps_buf(struct ieee80211_tx_data *tx)
  338. {
  339. if (unlikely(tx->flags & IEEE80211_TX_PS_BUFFERED))
  340. return TX_CONTINUE;
  341. if (tx->flags & IEEE80211_TX_UNICAST)
  342. return ieee80211_tx_h_unicast_ps_buf(tx);
  343. else
  344. return ieee80211_tx_h_multicast_ps_buf(tx);
  345. }
  346. static ieee80211_tx_result debug_noinline
  347. ieee80211_tx_h_select_key(struct ieee80211_tx_data *tx)
  348. {
  349. struct ieee80211_key *key;
  350. struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
  351. struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
  352. if (unlikely(tx->skb->do_not_encrypt))
  353. tx->key = NULL;
  354. else if (tx->sta && (key = rcu_dereference(tx->sta->key)))
  355. tx->key = key;
  356. else if ((key = rcu_dereference(tx->sdata->default_key)))
  357. tx->key = key;
  358. else if (tx->sdata->drop_unencrypted &&
  359. (tx->skb->protocol != cpu_to_be16(ETH_P_PAE)) &&
  360. !(info->flags & IEEE80211_TX_CTL_INJECTED)) {
  361. I802_DEBUG_INC(tx->local->tx_handlers_drop_unencrypted);
  362. return TX_DROP;
  363. } else
  364. tx->key = NULL;
  365. if (tx->key) {
  366. tx->key->tx_rx_count++;
  367. /* TODO: add threshold stuff again */
  368. switch (tx->key->conf.alg) {
  369. case ALG_WEP:
  370. if (ieee80211_is_auth(hdr->frame_control))
  371. break;
  372. case ALG_TKIP:
  373. case ALG_CCMP:
  374. if (!ieee80211_is_data_present(hdr->frame_control))
  375. tx->key = NULL;
  376. break;
  377. }
  378. }
  379. if (!tx->key || !(tx->key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE))
  380. tx->skb->do_not_encrypt = 1;
  381. return TX_CONTINUE;
  382. }
  383. static ieee80211_tx_result debug_noinline
  384. ieee80211_tx_h_rate_ctrl(struct ieee80211_tx_data *tx)
  385. {
  386. struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
  387. struct ieee80211_hdr *hdr = (void *)tx->skb->data;
  388. struct ieee80211_supported_band *sband;
  389. struct ieee80211_rate *rate;
  390. int i, len;
  391. bool inval = false, rts = false, short_preamble = false;
  392. struct ieee80211_tx_rate_control txrc;
  393. memset(&txrc, 0, sizeof(txrc));
  394. sband = tx->local->hw.wiphy->bands[tx->channel->band];
  395. len = min_t(int, tx->skb->len + FCS_LEN,
  396. tx->local->fragmentation_threshold);
  397. /* set up the tx rate control struct we give the RC algo */
  398. txrc.hw = local_to_hw(tx->local);
  399. txrc.sband = sband;
  400. txrc.bss_conf = &tx->sdata->vif.bss_conf;
  401. txrc.skb = tx->skb;
  402. txrc.reported_rate.idx = -1;
  403. txrc.max_rate_idx = tx->sdata->max_ratectrl_rateidx;
  404. /* set up RTS protection if desired */
  405. if (tx->local->rts_threshold < IEEE80211_MAX_RTS_THRESHOLD &&
  406. len > tx->local->rts_threshold) {
  407. txrc.rts = rts = true;
  408. }
  409. /*
  410. * Use short preamble if the BSS can handle it, but not for
  411. * management frames unless we know the receiver can handle
  412. * that -- the management frame might be to a station that
  413. * just wants a probe response.
  414. */
  415. if (tx->sdata->vif.bss_conf.use_short_preamble &&
  416. (ieee80211_is_data(hdr->frame_control) ||
  417. (tx->sta && test_sta_flags(tx->sta, WLAN_STA_SHORT_PREAMBLE))))
  418. txrc.short_preamble = short_preamble = true;
  419. rate_control_get_rate(tx->sdata, tx->sta, &txrc);
  420. if (unlikely(info->control.rates[0].idx < 0))
  421. return TX_DROP;
  422. if (txrc.reported_rate.idx < 0)
  423. txrc.reported_rate = info->control.rates[0];
  424. if (tx->sta)
  425. tx->sta->last_tx_rate = txrc.reported_rate;
  426. if (unlikely(!info->control.rates[0].count))
  427. info->control.rates[0].count = 1;
  428. if (is_multicast_ether_addr(hdr->addr1)) {
  429. /*
  430. * XXX: verify the rate is in the basic rateset
  431. */
  432. return TX_CONTINUE;
  433. }
  434. /*
  435. * set up the RTS/CTS rate as the fastest basic rate
  436. * that is not faster than the data rate
  437. *
  438. * XXX: Should this check all retry rates?
  439. */
  440. if (!(info->control.rates[0].flags & IEEE80211_TX_RC_MCS)) {
  441. s8 baserate = 0;
  442. rate = &sband->bitrates[info->control.rates[0].idx];
  443. for (i = 0; i < sband->n_bitrates; i++) {
  444. /* must be a basic rate */
  445. if (!(tx->sdata->vif.bss_conf.basic_rates & BIT(i)))
  446. continue;
  447. /* must not be faster than the data rate */
  448. if (sband->bitrates[i].bitrate > rate->bitrate)
  449. continue;
  450. /* maximum */
  451. if (sband->bitrates[baserate].bitrate <
  452. sband->bitrates[i].bitrate)
  453. baserate = i;
  454. }
  455. info->control.rts_cts_rate_idx = baserate;
  456. }
  457. for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
  458. /*
  459. * make sure there's no valid rate following
  460. * an invalid one, just in case drivers don't
  461. * take the API seriously to stop at -1.
  462. */
  463. if (inval) {
  464. info->control.rates[i].idx = -1;
  465. continue;
  466. }
  467. if (info->control.rates[i].idx < 0) {
  468. inval = true;
  469. continue;
  470. }
  471. /*
  472. * For now assume MCS is already set up correctly, this
  473. * needs to be fixed.
  474. */
  475. if (info->control.rates[i].flags & IEEE80211_TX_RC_MCS) {
  476. WARN_ON(info->control.rates[i].idx > 76);
  477. continue;
  478. }
  479. /* set up RTS protection if desired */
  480. if (rts)
  481. info->control.rates[i].flags |=
  482. IEEE80211_TX_RC_USE_RTS_CTS;
  483. /* RC is busted */
  484. if (WARN_ON_ONCE(info->control.rates[i].idx >=
  485. sband->n_bitrates)) {
  486. info->control.rates[i].idx = -1;
  487. continue;
  488. }
  489. rate = &sband->bitrates[info->control.rates[i].idx];
  490. /* set up short preamble */
  491. if (short_preamble &&
  492. rate->flags & IEEE80211_RATE_SHORT_PREAMBLE)
  493. info->control.rates[i].flags |=
  494. IEEE80211_TX_RC_USE_SHORT_PREAMBLE;
  495. /* set up G protection */
  496. if (!rts && tx->sdata->vif.bss_conf.use_cts_prot &&
  497. rate->flags & IEEE80211_RATE_ERP_G)
  498. info->control.rates[i].flags |=
  499. IEEE80211_TX_RC_USE_CTS_PROTECT;
  500. }
  501. return TX_CONTINUE;
  502. }
  503. static ieee80211_tx_result debug_noinline
  504. ieee80211_tx_h_misc(struct ieee80211_tx_data *tx)
  505. {
  506. struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
  507. if (tx->sta)
  508. info->control.sta = &tx->sta->sta;
  509. return TX_CONTINUE;
  510. }
  511. static ieee80211_tx_result debug_noinline
  512. ieee80211_tx_h_sequence(struct ieee80211_tx_data *tx)
  513. {
  514. struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
  515. struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
  516. u16 *seq;
  517. u8 *qc;
  518. int tid;
  519. /*
  520. * Packet injection may want to control the sequence
  521. * number, if we have no matching interface then we
  522. * neither assign one ourselves nor ask the driver to.
  523. */
  524. if (unlikely(!info->control.vif))
  525. return TX_CONTINUE;
  526. if (unlikely(ieee80211_is_ctl(hdr->frame_control)))
  527. return TX_CONTINUE;
  528. if (ieee80211_hdrlen(hdr->frame_control) < 24)
  529. return TX_CONTINUE;
  530. /*
  531. * Anything but QoS data that has a sequence number field
  532. * (is long enough) gets a sequence number from the global
  533. * counter.
  534. */
  535. if (!ieee80211_is_data_qos(hdr->frame_control)) {
  536. /* driver should assign sequence number */
  537. info->flags |= IEEE80211_TX_CTL_ASSIGN_SEQ;
  538. /* for pure STA mode without beacons, we can do it */
  539. hdr->seq_ctrl = cpu_to_le16(tx->sdata->sequence_number);
  540. tx->sdata->sequence_number += 0x10;
  541. tx->sdata->sequence_number &= IEEE80211_SCTL_SEQ;
  542. return TX_CONTINUE;
  543. }
  544. /*
  545. * This should be true for injected/management frames only, for
  546. * management frames we have set the IEEE80211_TX_CTL_ASSIGN_SEQ
  547. * above since they are not QoS-data frames.
  548. */
  549. if (!tx->sta)
  550. return TX_CONTINUE;
  551. /* include per-STA, per-TID sequence counter */
  552. qc = ieee80211_get_qos_ctl(hdr);
  553. tid = *qc & IEEE80211_QOS_CTL_TID_MASK;
  554. seq = &tx->sta->tid_seq[tid];
  555. hdr->seq_ctrl = cpu_to_le16(*seq);
  556. /* Increase the sequence number. */
  557. *seq = (*seq + 0x10) & IEEE80211_SCTL_SEQ;
  558. return TX_CONTINUE;
  559. }
  560. static ieee80211_tx_result debug_noinline
  561. ieee80211_tx_h_fragment(struct ieee80211_tx_data *tx)
  562. {
  563. struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
  564. struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
  565. size_t hdrlen, per_fragm, num_fragm, payload_len, left;
  566. struct sk_buff **frags, *first, *frag;
  567. int i;
  568. u16 seq;
  569. u8 *pos;
  570. int frag_threshold = tx->local->fragmentation_threshold;
  571. if (!(tx->flags & IEEE80211_TX_FRAGMENTED))
  572. return TX_CONTINUE;
  573. /*
  574. * Warn when submitting a fragmented A-MPDU frame and drop it.
  575. * This scenario is handled in __ieee80211_tx_prepare but extra
  576. * caution taken here as fragmented ampdu may cause Tx stop.
  577. */
  578. if (WARN_ON(info->flags & IEEE80211_TX_CTL_AMPDU))
  579. return TX_DROP;
  580. first = tx->skb;
  581. hdrlen = ieee80211_hdrlen(hdr->frame_control);
  582. payload_len = first->len - hdrlen;
  583. per_fragm = frag_threshold - hdrlen - FCS_LEN;
  584. num_fragm = DIV_ROUND_UP(payload_len, per_fragm);
  585. frags = kzalloc(num_fragm * sizeof(struct sk_buff *), GFP_ATOMIC);
  586. if (!frags)
  587. goto fail;
  588. hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_MOREFRAGS);
  589. seq = le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_SEQ;
  590. pos = first->data + hdrlen + per_fragm;
  591. left = payload_len - per_fragm;
  592. for (i = 0; i < num_fragm - 1; i++) {
  593. struct ieee80211_hdr *fhdr;
  594. size_t copylen;
  595. if (left <= 0)
  596. goto fail;
  597. /* reserve enough extra head and tail room for possible
  598. * encryption */
  599. frag = frags[i] =
  600. dev_alloc_skb(tx->local->tx_headroom +
  601. frag_threshold +
  602. IEEE80211_ENCRYPT_HEADROOM +
  603. IEEE80211_ENCRYPT_TAILROOM);
  604. if (!frag)
  605. goto fail;
  606. /* Make sure that all fragments use the same priority so
  607. * that they end up using the same TX queue */
  608. frag->priority = first->priority;
  609. skb_reserve(frag, tx->local->tx_headroom +
  610. IEEE80211_ENCRYPT_HEADROOM);
  611. /* copy TX information */
  612. info = IEEE80211_SKB_CB(frag);
  613. memcpy(info, first->cb, sizeof(frag->cb));
  614. /* copy/fill in 802.11 header */
  615. fhdr = (struct ieee80211_hdr *) skb_put(frag, hdrlen);
  616. memcpy(fhdr, first->data, hdrlen);
  617. fhdr->seq_ctrl = cpu_to_le16(seq | ((i + 1) & IEEE80211_SCTL_FRAG));
  618. if (i == num_fragm - 2) {
  619. /* clear MOREFRAGS bit for the last fragment */
  620. fhdr->frame_control &= cpu_to_le16(~IEEE80211_FCTL_MOREFRAGS);
  621. } else {
  622. /*
  623. * No multi-rate retries for fragmented frames, that
  624. * would completely throw off the NAV at other STAs.
  625. */
  626. info->control.rates[1].idx = -1;
  627. info->control.rates[2].idx = -1;
  628. info->control.rates[3].idx = -1;
  629. info->control.rates[4].idx = -1;
  630. BUILD_BUG_ON(IEEE80211_TX_MAX_RATES != 5);
  631. info->flags &= ~IEEE80211_TX_CTL_RATE_CTRL_PROBE;
  632. }
  633. /* copy data */
  634. copylen = left > per_fragm ? per_fragm : left;
  635. memcpy(skb_put(frag, copylen), pos, copylen);
  636. skb_copy_queue_mapping(frag, first);
  637. frag->do_not_encrypt = first->do_not_encrypt;
  638. pos += copylen;
  639. left -= copylen;
  640. }
  641. skb_trim(first, hdrlen + per_fragm);
  642. tx->num_extra_frag = num_fragm - 1;
  643. tx->extra_frag = frags;
  644. return TX_CONTINUE;
  645. fail:
  646. if (frags) {
  647. for (i = 0; i < num_fragm - 1; i++)
  648. if (frags[i])
  649. dev_kfree_skb(frags[i]);
  650. kfree(frags);
  651. }
  652. I802_DEBUG_INC(tx->local->tx_handlers_drop_fragment);
  653. return TX_DROP;
  654. }
  655. static ieee80211_tx_result debug_noinline
  656. ieee80211_tx_h_encrypt(struct ieee80211_tx_data *tx)
  657. {
  658. if (!tx->key)
  659. return TX_CONTINUE;
  660. switch (tx->key->conf.alg) {
  661. case ALG_WEP:
  662. return ieee80211_crypto_wep_encrypt(tx);
  663. case ALG_TKIP:
  664. return ieee80211_crypto_tkip_encrypt(tx);
  665. case ALG_CCMP:
  666. return ieee80211_crypto_ccmp_encrypt(tx);
  667. }
  668. /* not reached */
  669. WARN_ON(1);
  670. return TX_DROP;
  671. }
  672. static ieee80211_tx_result debug_noinline
  673. ieee80211_tx_h_calculate_duration(struct ieee80211_tx_data *tx)
  674. {
  675. struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
  676. int next_len, i;
  677. int group_addr = is_multicast_ether_addr(hdr->addr1);
  678. if (!(tx->flags & IEEE80211_TX_FRAGMENTED)) {
  679. hdr->duration_id = ieee80211_duration(tx, group_addr, 0);
  680. return TX_CONTINUE;
  681. }
  682. hdr->duration_id = ieee80211_duration(tx, group_addr,
  683. tx->extra_frag[0]->len);
  684. for (i = 0; i < tx->num_extra_frag; i++) {
  685. if (i + 1 < tx->num_extra_frag)
  686. next_len = tx->extra_frag[i + 1]->len;
  687. else
  688. next_len = 0;
  689. hdr = (struct ieee80211_hdr *)tx->extra_frag[i]->data;
  690. hdr->duration_id = ieee80211_duration(tx, 0, next_len);
  691. }
  692. return TX_CONTINUE;
  693. }
  694. static ieee80211_tx_result debug_noinline
  695. ieee80211_tx_h_stats(struct ieee80211_tx_data *tx)
  696. {
  697. int i;
  698. if (!tx->sta)
  699. return TX_CONTINUE;
  700. tx->sta->tx_packets++;
  701. tx->sta->tx_fragments++;
  702. tx->sta->tx_bytes += tx->skb->len;
  703. if (tx->extra_frag) {
  704. tx->sta->tx_fragments += tx->num_extra_frag;
  705. for (i = 0; i < tx->num_extra_frag; i++)
  706. tx->sta->tx_bytes += tx->extra_frag[i]->len;
  707. }
  708. return TX_CONTINUE;
  709. }
  710. /* actual transmit path */
  711. /*
  712. * deal with packet injection down monitor interface
  713. * with Radiotap Header -- only called for monitor mode interface
  714. */
  715. static ieee80211_tx_result
  716. __ieee80211_parse_tx_radiotap(struct ieee80211_tx_data *tx,
  717. struct sk_buff *skb)
  718. {
  719. /*
  720. * this is the moment to interpret and discard the radiotap header that
  721. * must be at the start of the packet injected in Monitor mode
  722. *
  723. * Need to take some care with endian-ness since radiotap
  724. * args are little-endian
  725. */
  726. struct ieee80211_radiotap_iterator iterator;
  727. struct ieee80211_radiotap_header *rthdr =
  728. (struct ieee80211_radiotap_header *) skb->data;
  729. struct ieee80211_supported_band *sband;
  730. int ret = ieee80211_radiotap_iterator_init(&iterator, rthdr, skb->len);
  731. sband = tx->local->hw.wiphy->bands[tx->channel->band];
  732. skb->do_not_encrypt = 1;
  733. tx->flags &= ~IEEE80211_TX_FRAGMENTED;
  734. /*
  735. * for every radiotap entry that is present
  736. * (ieee80211_radiotap_iterator_next returns -ENOENT when no more
  737. * entries present, or -EINVAL on error)
  738. */
  739. while (!ret) {
  740. ret = ieee80211_radiotap_iterator_next(&iterator);
  741. if (ret)
  742. continue;
  743. /* see if this argument is something we can use */
  744. switch (iterator.this_arg_index) {
  745. /*
  746. * You must take care when dereferencing iterator.this_arg
  747. * for multibyte types... the pointer is not aligned. Use
  748. * get_unaligned((type *)iterator.this_arg) to dereference
  749. * iterator.this_arg for type "type" safely on all arches.
  750. */
  751. case IEEE80211_RADIOTAP_FLAGS:
  752. if (*iterator.this_arg & IEEE80211_RADIOTAP_F_FCS) {
  753. /*
  754. * this indicates that the skb we have been
  755. * handed has the 32-bit FCS CRC at the end...
  756. * we should react to that by snipping it off
  757. * because it will be recomputed and added
  758. * on transmission
  759. */
  760. if (skb->len < (iterator.max_length + FCS_LEN))
  761. return TX_DROP;
  762. skb_trim(skb, skb->len - FCS_LEN);
  763. }
  764. if (*iterator.this_arg & IEEE80211_RADIOTAP_F_WEP)
  765. tx->skb->do_not_encrypt = 0;
  766. if (*iterator.this_arg & IEEE80211_RADIOTAP_F_FRAG)
  767. tx->flags |= IEEE80211_TX_FRAGMENTED;
  768. break;
  769. /*
  770. * Please update the file
  771. * Documentation/networking/mac80211-injection.txt
  772. * when parsing new fields here.
  773. */
  774. default:
  775. break;
  776. }
  777. }
  778. if (ret != -ENOENT) /* ie, if we didn't simply run out of fields */
  779. return TX_DROP;
  780. /*
  781. * remove the radiotap header
  782. * iterator->max_length was sanity-checked against
  783. * skb->len by iterator init
  784. */
  785. skb_pull(skb, iterator.max_length);
  786. return TX_CONTINUE;
  787. }
  788. /*
  789. * initialises @tx
  790. */
  791. static ieee80211_tx_result
  792. __ieee80211_tx_prepare(struct ieee80211_tx_data *tx,
  793. struct sk_buff *skb,
  794. struct net_device *dev)
  795. {
  796. struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
  797. struct ieee80211_hdr *hdr;
  798. struct ieee80211_sub_if_data *sdata;
  799. struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
  800. int hdrlen, tid;
  801. u8 *qc, *state;
  802. memset(tx, 0, sizeof(*tx));
  803. tx->skb = skb;
  804. tx->dev = dev; /* use original interface */
  805. tx->local = local;
  806. tx->sdata = IEEE80211_DEV_TO_SUB_IF(dev);
  807. tx->channel = local->hw.conf.channel;
  808. /*
  809. * Set this flag (used below to indicate "automatic fragmentation"),
  810. * it will be cleared/left by radiotap as desired.
  811. */
  812. tx->flags |= IEEE80211_TX_FRAGMENTED;
  813. /* process and remove the injection radiotap header */
  814. sdata = IEEE80211_DEV_TO_SUB_IF(dev);
  815. if (unlikely(info->flags & IEEE80211_TX_CTL_INJECTED)) {
  816. if (__ieee80211_parse_tx_radiotap(tx, skb) == TX_DROP)
  817. return TX_DROP;
  818. /*
  819. * __ieee80211_parse_tx_radiotap has now removed
  820. * the radiotap header that was present and pre-filled
  821. * 'tx' with tx control information.
  822. */
  823. }
  824. hdr = (struct ieee80211_hdr *) skb->data;
  825. tx->sta = sta_info_get(local, hdr->addr1);
  826. if (tx->sta && ieee80211_is_data_qos(hdr->frame_control)) {
  827. qc = ieee80211_get_qos_ctl(hdr);
  828. tid = *qc & IEEE80211_QOS_CTL_TID_MASK;
  829. state = &tx->sta->ampdu_mlme.tid_state_tx[tid];
  830. if (*state == HT_AGG_STATE_OPERATIONAL)
  831. info->flags |= IEEE80211_TX_CTL_AMPDU;
  832. }
  833. if (is_multicast_ether_addr(hdr->addr1)) {
  834. tx->flags &= ~IEEE80211_TX_UNICAST;
  835. info->flags |= IEEE80211_TX_CTL_NO_ACK;
  836. } else {
  837. tx->flags |= IEEE80211_TX_UNICAST;
  838. info->flags &= ~IEEE80211_TX_CTL_NO_ACK;
  839. }
  840. if (tx->flags & IEEE80211_TX_FRAGMENTED) {
  841. if ((tx->flags & IEEE80211_TX_UNICAST) &&
  842. skb->len + FCS_LEN > local->fragmentation_threshold &&
  843. !(info->flags & IEEE80211_TX_CTL_AMPDU))
  844. tx->flags |= IEEE80211_TX_FRAGMENTED;
  845. else
  846. tx->flags &= ~IEEE80211_TX_FRAGMENTED;
  847. }
  848. if (!tx->sta)
  849. info->flags |= IEEE80211_TX_CTL_CLEAR_PS_FILT;
  850. else if (test_and_clear_sta_flags(tx->sta, WLAN_STA_CLEAR_PS_FILT))
  851. info->flags |= IEEE80211_TX_CTL_CLEAR_PS_FILT;
  852. hdrlen = ieee80211_hdrlen(hdr->frame_control);
  853. if (skb->len > hdrlen + sizeof(rfc1042_header) + 2) {
  854. u8 *pos = &skb->data[hdrlen + sizeof(rfc1042_header)];
  855. tx->ethertype = (pos[0] << 8) | pos[1];
  856. }
  857. info->flags |= IEEE80211_TX_CTL_FIRST_FRAGMENT;
  858. return TX_CONTINUE;
  859. }
  860. /*
  861. * NB: @tx is uninitialised when passed in here
  862. */
  863. static int ieee80211_tx_prepare(struct ieee80211_local *local,
  864. struct ieee80211_tx_data *tx,
  865. struct sk_buff *skb)
  866. {
  867. struct net_device *dev;
  868. dev = dev_get_by_index(&init_net, skb->iif);
  869. if (unlikely(dev && !is_ieee80211_device(local, dev))) {
  870. dev_put(dev);
  871. dev = NULL;
  872. }
  873. if (unlikely(!dev))
  874. return -ENODEV;
  875. /* initialises tx with control */
  876. __ieee80211_tx_prepare(tx, skb, dev);
  877. dev_put(dev);
  878. return 0;
  879. }
  880. static int __ieee80211_tx(struct ieee80211_local *local, struct sk_buff *skb,
  881. struct ieee80211_tx_data *tx)
  882. {
  883. struct ieee80211_tx_info *info;
  884. int ret, i;
  885. if (skb) {
  886. if (netif_subqueue_stopped(local->mdev, skb))
  887. return IEEE80211_TX_AGAIN;
  888. info = IEEE80211_SKB_CB(skb);
  889. ret = local->ops->tx(local_to_hw(local), skb);
  890. if (ret)
  891. return IEEE80211_TX_AGAIN;
  892. local->mdev->trans_start = jiffies;
  893. ieee80211_led_tx(local, 1);
  894. }
  895. if (tx->extra_frag) {
  896. for (i = 0; i < tx->num_extra_frag; i++) {
  897. if (!tx->extra_frag[i])
  898. continue;
  899. info = IEEE80211_SKB_CB(tx->extra_frag[i]);
  900. info->flags &= ~(IEEE80211_TX_CTL_CLEAR_PS_FILT |
  901. IEEE80211_TX_CTL_FIRST_FRAGMENT);
  902. if (netif_subqueue_stopped(local->mdev,
  903. tx->extra_frag[i]))
  904. return IEEE80211_TX_FRAG_AGAIN;
  905. ret = local->ops->tx(local_to_hw(local),
  906. tx->extra_frag[i]);
  907. if (ret)
  908. return IEEE80211_TX_FRAG_AGAIN;
  909. local->mdev->trans_start = jiffies;
  910. ieee80211_led_tx(local, 1);
  911. tx->extra_frag[i] = NULL;
  912. }
  913. kfree(tx->extra_frag);
  914. tx->extra_frag = NULL;
  915. }
  916. return IEEE80211_TX_OK;
  917. }
  918. /*
  919. * Invoke TX handlers, return 0 on success and non-zero if the
  920. * frame was dropped or queued.
  921. */
  922. static int invoke_tx_handlers(struct ieee80211_tx_data *tx)
  923. {
  924. struct sk_buff *skb = tx->skb;
  925. ieee80211_tx_result res = TX_DROP;
  926. int i;
  927. #define CALL_TXH(txh) \
  928. res = txh(tx); \
  929. if (res != TX_CONTINUE) \
  930. goto txh_done;
  931. CALL_TXH(ieee80211_tx_h_check_assoc)
  932. CALL_TXH(ieee80211_tx_h_ps_buf)
  933. CALL_TXH(ieee80211_tx_h_select_key)
  934. CALL_TXH(ieee80211_tx_h_michael_mic_add)
  935. CALL_TXH(ieee80211_tx_h_rate_ctrl)
  936. CALL_TXH(ieee80211_tx_h_misc)
  937. CALL_TXH(ieee80211_tx_h_sequence)
  938. CALL_TXH(ieee80211_tx_h_fragment)
  939. /* handlers after fragment must be aware of tx info fragmentation! */
  940. CALL_TXH(ieee80211_tx_h_encrypt)
  941. CALL_TXH(ieee80211_tx_h_calculate_duration)
  942. CALL_TXH(ieee80211_tx_h_stats)
  943. #undef CALL_TXH
  944. txh_done:
  945. if (unlikely(res == TX_DROP)) {
  946. I802_DEBUG_INC(tx->local->tx_handlers_drop);
  947. dev_kfree_skb(skb);
  948. for (i = 0; i < tx->num_extra_frag; i++)
  949. if (tx->extra_frag[i])
  950. dev_kfree_skb(tx->extra_frag[i]);
  951. kfree(tx->extra_frag);
  952. return -1;
  953. } else if (unlikely(res == TX_QUEUED)) {
  954. I802_DEBUG_INC(tx->local->tx_handlers_queued);
  955. return -1;
  956. }
  957. return 0;
  958. }
  959. static int ieee80211_tx(struct net_device *dev, struct sk_buff *skb)
  960. {
  961. struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
  962. struct sta_info *sta;
  963. struct ieee80211_tx_data tx;
  964. ieee80211_tx_result res_prepare;
  965. struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
  966. int ret, i;
  967. u16 queue;
  968. queue = skb_get_queue_mapping(skb);
  969. WARN_ON(test_bit(queue, local->queues_pending));
  970. if (unlikely(skb->len < 10)) {
  971. dev_kfree_skb(skb);
  972. return 0;
  973. }
  974. rcu_read_lock();
  975. /* initialises tx */
  976. res_prepare = __ieee80211_tx_prepare(&tx, skb, dev);
  977. if (res_prepare == TX_DROP) {
  978. dev_kfree_skb(skb);
  979. rcu_read_unlock();
  980. return 0;
  981. }
  982. sta = tx.sta;
  983. tx.channel = local->hw.conf.channel;
  984. info->band = tx.channel->band;
  985. if (invoke_tx_handlers(&tx))
  986. goto out;
  987. retry:
  988. ret = __ieee80211_tx(local, skb, &tx);
  989. if (ret) {
  990. struct ieee80211_tx_stored_packet *store;
  991. /*
  992. * Since there are no fragmented frames on A-MPDU
  993. * queues, there's no reason for a driver to reject
  994. * a frame there, warn and drop it.
  995. */
  996. if (WARN_ON(info->flags & IEEE80211_TX_CTL_AMPDU))
  997. goto drop;
  998. store = &local->pending_packet[queue];
  999. if (ret == IEEE80211_TX_FRAG_AGAIN)
  1000. skb = NULL;
  1001. set_bit(queue, local->queues_pending);
  1002. smp_mb();
  1003. /*
  1004. * When the driver gets out of buffers during sending of
  1005. * fragments and calls ieee80211_stop_queue, the netif
  1006. * subqueue is stopped. There is, however, a small window
  1007. * in which the PENDING bit is not yet set. If a buffer
  1008. * gets available in that window (i.e. driver calls
  1009. * ieee80211_wake_queue), we would end up with ieee80211_tx
  1010. * called with the PENDING bit still set. Prevent this by
  1011. * continuing transmitting here when that situation is
  1012. * possible to have happened.
  1013. */
  1014. if (!__netif_subqueue_stopped(local->mdev, queue)) {
  1015. clear_bit(queue, local->queues_pending);
  1016. goto retry;
  1017. }
  1018. store->skb = skb;
  1019. store->extra_frag = tx.extra_frag;
  1020. store->num_extra_frag = tx.num_extra_frag;
  1021. }
  1022. out:
  1023. rcu_read_unlock();
  1024. return 0;
  1025. drop:
  1026. if (skb)
  1027. dev_kfree_skb(skb);
  1028. for (i = 0; i < tx.num_extra_frag; i++)
  1029. if (tx.extra_frag[i])
  1030. dev_kfree_skb(tx.extra_frag[i]);
  1031. kfree(tx.extra_frag);
  1032. rcu_read_unlock();
  1033. return 0;
  1034. }
  1035. /* device xmit handlers */
  1036. static int ieee80211_skb_resize(struct ieee80211_local *local,
  1037. struct sk_buff *skb,
  1038. int head_need, bool may_encrypt)
  1039. {
  1040. int tail_need = 0;
  1041. /*
  1042. * This could be optimised, devices that do full hardware
  1043. * crypto (including TKIP MMIC) need no tailroom... But we
  1044. * have no drivers for such devices currently.
  1045. */
  1046. if (may_encrypt) {
  1047. tail_need = IEEE80211_ENCRYPT_TAILROOM;
  1048. tail_need -= skb_tailroom(skb);
  1049. tail_need = max_t(int, tail_need, 0);
  1050. }
  1051. if (head_need || tail_need) {
  1052. /* Sorry. Can't account for this any more */
  1053. skb_orphan(skb);
  1054. }
  1055. if (skb_header_cloned(skb))
  1056. I802_DEBUG_INC(local->tx_expand_skb_head_cloned);
  1057. else
  1058. I802_DEBUG_INC(local->tx_expand_skb_head);
  1059. if (pskb_expand_head(skb, head_need, tail_need, GFP_ATOMIC)) {
  1060. printk(KERN_DEBUG "%s: failed to reallocate TX buffer\n",
  1061. wiphy_name(local->hw.wiphy));
  1062. return -ENOMEM;
  1063. }
  1064. /* update truesize too */
  1065. skb->truesize += head_need + tail_need;
  1066. return 0;
  1067. }
  1068. int ieee80211_master_start_xmit(struct sk_buff *skb, struct net_device *dev)
  1069. {
  1070. struct ieee80211_master_priv *mpriv = netdev_priv(dev);
  1071. struct ieee80211_local *local = mpriv->local;
  1072. struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
  1073. struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
  1074. struct net_device *odev = NULL;
  1075. struct ieee80211_sub_if_data *osdata;
  1076. int headroom;
  1077. bool may_encrypt;
  1078. enum {
  1079. NOT_MONITOR,
  1080. FOUND_SDATA,
  1081. UNKNOWN_ADDRESS,
  1082. } monitor_iface = NOT_MONITOR;
  1083. int ret;
  1084. if (skb->iif)
  1085. odev = dev_get_by_index(&init_net, skb->iif);
  1086. if (unlikely(odev && !is_ieee80211_device(local, odev))) {
  1087. dev_put(odev);
  1088. odev = NULL;
  1089. }
  1090. if (unlikely(!odev)) {
  1091. #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
  1092. printk(KERN_DEBUG "%s: Discarded packet with nonexistent "
  1093. "originating device\n", dev->name);
  1094. #endif
  1095. dev_kfree_skb(skb);
  1096. return 0;
  1097. }
  1098. memset(info, 0, sizeof(*info));
  1099. info->flags |= IEEE80211_TX_CTL_REQ_TX_STATUS;
  1100. osdata = IEEE80211_DEV_TO_SUB_IF(odev);
  1101. if (ieee80211_vif_is_mesh(&osdata->vif) &&
  1102. ieee80211_is_data(hdr->frame_control)) {
  1103. if (is_multicast_ether_addr(hdr->addr3))
  1104. memcpy(hdr->addr1, hdr->addr3, ETH_ALEN);
  1105. else
  1106. if (mesh_nexthop_lookup(skb, osdata))
  1107. return 0;
  1108. if (memcmp(odev->dev_addr, hdr->addr4, ETH_ALEN) != 0)
  1109. IEEE80211_IFSTA_MESH_CTR_INC(&osdata->u.mesh,
  1110. fwded_frames);
  1111. } else if (unlikely(osdata->vif.type == NL80211_IFTYPE_MONITOR)) {
  1112. struct ieee80211_sub_if_data *sdata;
  1113. int hdrlen;
  1114. u16 len_rthdr;
  1115. info->flags |= IEEE80211_TX_CTL_INJECTED;
  1116. monitor_iface = UNKNOWN_ADDRESS;
  1117. len_rthdr = ieee80211_get_radiotap_len(skb->data);
  1118. hdr = (struct ieee80211_hdr *)skb->data + len_rthdr;
  1119. hdrlen = ieee80211_hdrlen(hdr->frame_control);
  1120. /* check the header is complete in the frame */
  1121. if (likely(skb->len >= len_rthdr + hdrlen)) {
  1122. /*
  1123. * We process outgoing injected frames that have a
  1124. * local address we handle as though they are our
  1125. * own frames.
  1126. * This code here isn't entirely correct, the local
  1127. * MAC address is not necessarily enough to find
  1128. * the interface to use; for that proper VLAN/WDS
  1129. * support we will need a different mechanism.
  1130. */
  1131. rcu_read_lock();
  1132. list_for_each_entry_rcu(sdata, &local->interfaces,
  1133. list) {
  1134. if (!netif_running(sdata->dev))
  1135. continue;
  1136. if (compare_ether_addr(sdata->dev->dev_addr,
  1137. hdr->addr2)) {
  1138. dev_hold(sdata->dev);
  1139. dev_put(odev);
  1140. osdata = sdata;
  1141. odev = osdata->dev;
  1142. skb->iif = sdata->dev->ifindex;
  1143. monitor_iface = FOUND_SDATA;
  1144. break;
  1145. }
  1146. }
  1147. rcu_read_unlock();
  1148. }
  1149. }
  1150. may_encrypt = !skb->do_not_encrypt;
  1151. headroom = osdata->local->tx_headroom;
  1152. if (may_encrypt)
  1153. headroom += IEEE80211_ENCRYPT_HEADROOM;
  1154. headroom -= skb_headroom(skb);
  1155. headroom = max_t(int, 0, headroom);
  1156. if (ieee80211_skb_resize(osdata->local, skb, headroom, may_encrypt)) {
  1157. dev_kfree_skb(skb);
  1158. dev_put(odev);
  1159. return 0;
  1160. }
  1161. if (osdata->vif.type == NL80211_IFTYPE_AP_VLAN)
  1162. osdata = container_of(osdata->bss,
  1163. struct ieee80211_sub_if_data,
  1164. u.ap);
  1165. if (likely(monitor_iface != UNKNOWN_ADDRESS))
  1166. info->control.vif = &osdata->vif;
  1167. ret = ieee80211_tx(odev, skb);
  1168. dev_put(odev);
  1169. return ret;
  1170. }
  1171. int ieee80211_monitor_start_xmit(struct sk_buff *skb,
  1172. struct net_device *dev)
  1173. {
  1174. struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
  1175. struct ieee80211_radiotap_header *prthdr =
  1176. (struct ieee80211_radiotap_header *)skb->data;
  1177. u16 len_rthdr;
  1178. /* check for not even having the fixed radiotap header part */
  1179. if (unlikely(skb->len < sizeof(struct ieee80211_radiotap_header)))
  1180. goto fail; /* too short to be possibly valid */
  1181. /* is it a header version we can trust to find length from? */
  1182. if (unlikely(prthdr->it_version))
  1183. goto fail; /* only version 0 is supported */
  1184. /* then there must be a radiotap header with a length we can use */
  1185. len_rthdr = ieee80211_get_radiotap_len(skb->data);
  1186. /* does the skb contain enough to deliver on the alleged length? */
  1187. if (unlikely(skb->len < len_rthdr))
  1188. goto fail; /* skb too short for claimed rt header extent */
  1189. skb->dev = local->mdev;
  1190. /* needed because we set skb device to master */
  1191. skb->iif = dev->ifindex;
  1192. /* sometimes we do encrypt injected frames, will be fixed
  1193. * up in radiotap parser if not wanted */
  1194. skb->do_not_encrypt = 0;
  1195. /*
  1196. * fix up the pointers accounting for the radiotap
  1197. * header still being in there. We are being given
  1198. * a precooked IEEE80211 header so no need for
  1199. * normal processing
  1200. */
  1201. skb_set_mac_header(skb, len_rthdr);
  1202. /*
  1203. * these are just fixed to the end of the rt area since we
  1204. * don't have any better information and at this point, nobody cares
  1205. */
  1206. skb_set_network_header(skb, len_rthdr);
  1207. skb_set_transport_header(skb, len_rthdr);
  1208. /* pass the radiotap header up to the next stage intact */
  1209. dev_queue_xmit(skb);
  1210. return NETDEV_TX_OK;
  1211. fail:
  1212. dev_kfree_skb(skb);
  1213. return NETDEV_TX_OK; /* meaning, we dealt with the skb */
  1214. }
  1215. /**
  1216. * ieee80211_subif_start_xmit - netif start_xmit function for Ethernet-type
  1217. * subinterfaces (wlan#, WDS, and VLAN interfaces)
  1218. * @skb: packet to be sent
  1219. * @dev: incoming interface
  1220. *
  1221. * Returns: 0 on success (and frees skb in this case) or 1 on failure (skb will
  1222. * not be freed, and caller is responsible for either retrying later or freeing
  1223. * skb).
  1224. *
  1225. * This function takes in an Ethernet header and encapsulates it with suitable
  1226. * IEEE 802.11 header based on which interface the packet is coming in. The
  1227. * encapsulated packet will then be passed to master interface, wlan#.11, for
  1228. * transmission (through low-level driver).
  1229. */
  1230. int ieee80211_subif_start_xmit(struct sk_buff *skb,
  1231. struct net_device *dev)
  1232. {
  1233. struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
  1234. struct ieee80211_local *local = sdata->local;
  1235. int ret = 1, head_need;
  1236. u16 ethertype, hdrlen, meshhdrlen = 0;
  1237. __le16 fc;
  1238. struct ieee80211_hdr hdr;
  1239. struct ieee80211s_hdr mesh_hdr;
  1240. const u8 *encaps_data;
  1241. int encaps_len, skip_header_bytes;
  1242. int nh_pos, h_pos;
  1243. struct sta_info *sta;
  1244. u32 sta_flags = 0;
  1245. if (unlikely(skb->len < ETH_HLEN)) {
  1246. ret = 0;
  1247. goto fail;
  1248. }
  1249. if (!(local->hw.flags & IEEE80211_HW_NO_STACK_DYNAMIC_PS) &&
  1250. local->dynamic_ps_timeout > 0) {
  1251. if (local->hw.conf.flags & IEEE80211_CONF_PS) {
  1252. ieee80211_stop_queues_by_reason(&local->hw,
  1253. IEEE80211_QUEUE_STOP_REASON_PS);
  1254. queue_work(local->hw.workqueue,
  1255. &local->dynamic_ps_disable_work);
  1256. }
  1257. mod_timer(&local->dynamic_ps_timer, jiffies +
  1258. msecs_to_jiffies(local->dynamic_ps_timeout));
  1259. }
  1260. nh_pos = skb_network_header(skb) - skb->data;
  1261. h_pos = skb_transport_header(skb) - skb->data;
  1262. /* convert Ethernet header to proper 802.11 header (based on
  1263. * operation mode) */
  1264. ethertype = (skb->data[12] << 8) | skb->data[13];
  1265. fc = cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA);
  1266. switch (sdata->vif.type) {
  1267. case NL80211_IFTYPE_AP:
  1268. case NL80211_IFTYPE_AP_VLAN:
  1269. fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS);
  1270. /* DA BSSID SA */
  1271. memcpy(hdr.addr1, skb->data, ETH_ALEN);
  1272. memcpy(hdr.addr2, dev->dev_addr, ETH_ALEN);
  1273. memcpy(hdr.addr3, skb->data + ETH_ALEN, ETH_ALEN);
  1274. hdrlen = 24;
  1275. break;
  1276. case NL80211_IFTYPE_WDS:
  1277. fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS);
  1278. /* RA TA DA SA */
  1279. memcpy(hdr.addr1, sdata->u.wds.remote_addr, ETH_ALEN);
  1280. memcpy(hdr.addr2, dev->dev_addr, ETH_ALEN);
  1281. memcpy(hdr.addr3, skb->data, ETH_ALEN);
  1282. memcpy(hdr.addr4, skb->data + ETH_ALEN, ETH_ALEN);
  1283. hdrlen = 30;
  1284. break;
  1285. #ifdef CONFIG_MAC80211_MESH
  1286. case NL80211_IFTYPE_MESH_POINT:
  1287. fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS);
  1288. if (!sdata->u.mesh.mshcfg.dot11MeshTTL) {
  1289. /* Do not send frames with mesh_ttl == 0 */
  1290. sdata->u.mesh.mshstats.dropped_frames_ttl++;
  1291. ret = 0;
  1292. goto fail;
  1293. }
  1294. memset(&mesh_hdr, 0, sizeof(mesh_hdr));
  1295. if (compare_ether_addr(dev->dev_addr,
  1296. skb->data + ETH_ALEN) == 0) {
  1297. /* RA TA DA SA */
  1298. memset(hdr.addr1, 0, ETH_ALEN);
  1299. memcpy(hdr.addr2, dev->dev_addr, ETH_ALEN);
  1300. memcpy(hdr.addr3, skb->data, ETH_ALEN);
  1301. memcpy(hdr.addr4, skb->data + ETH_ALEN, ETH_ALEN);
  1302. meshhdrlen = ieee80211_new_mesh_header(&mesh_hdr, sdata);
  1303. } else {
  1304. /* packet from other interface */
  1305. struct mesh_path *mppath;
  1306. memset(hdr.addr1, 0, ETH_ALEN);
  1307. memcpy(hdr.addr2, dev->dev_addr, ETH_ALEN);
  1308. memcpy(hdr.addr4, dev->dev_addr, ETH_ALEN);
  1309. if (is_multicast_ether_addr(skb->data))
  1310. memcpy(hdr.addr3, skb->data, ETH_ALEN);
  1311. else {
  1312. rcu_read_lock();
  1313. mppath = mpp_path_lookup(skb->data, sdata);
  1314. if (mppath)
  1315. memcpy(hdr.addr3, mppath->mpp, ETH_ALEN);
  1316. else
  1317. memset(hdr.addr3, 0xff, ETH_ALEN);
  1318. rcu_read_unlock();
  1319. }
  1320. mesh_hdr.flags |= MESH_FLAGS_AE_A5_A6;
  1321. mesh_hdr.ttl = sdata->u.mesh.mshcfg.dot11MeshTTL;
  1322. put_unaligned(cpu_to_le32(sdata->u.mesh.mesh_seqnum), &mesh_hdr.seqnum);
  1323. memcpy(mesh_hdr.eaddr1, skb->data, ETH_ALEN);
  1324. memcpy(mesh_hdr.eaddr2, skb->data + ETH_ALEN, ETH_ALEN);
  1325. sdata->u.mesh.mesh_seqnum++;
  1326. meshhdrlen = 18;
  1327. }
  1328. hdrlen = 30;
  1329. break;
  1330. #endif
  1331. case NL80211_IFTYPE_STATION:
  1332. fc |= cpu_to_le16(IEEE80211_FCTL_TODS);
  1333. /* BSSID SA DA */
  1334. memcpy(hdr.addr1, sdata->u.sta.bssid, ETH_ALEN);
  1335. memcpy(hdr.addr2, skb->data + ETH_ALEN, ETH_ALEN);
  1336. memcpy(hdr.addr3, skb->data, ETH_ALEN);
  1337. hdrlen = 24;
  1338. break;
  1339. case NL80211_IFTYPE_ADHOC:
  1340. /* DA SA BSSID */
  1341. memcpy(hdr.addr1, skb->data, ETH_ALEN);
  1342. memcpy(hdr.addr2, skb->data + ETH_ALEN, ETH_ALEN);
  1343. memcpy(hdr.addr3, sdata->u.sta.bssid, ETH_ALEN);
  1344. hdrlen = 24;
  1345. break;
  1346. default:
  1347. ret = 0;
  1348. goto fail;
  1349. }
  1350. /*
  1351. * There's no need to try to look up the destination
  1352. * if it is a multicast address (which can only happen
  1353. * in AP mode)
  1354. */
  1355. if (!is_multicast_ether_addr(hdr.addr1)) {
  1356. rcu_read_lock();
  1357. sta = sta_info_get(local, hdr.addr1);
  1358. if (sta)
  1359. sta_flags = get_sta_flags(sta);
  1360. rcu_read_unlock();
  1361. }
  1362. /* receiver and we are QoS enabled, use a QoS type frame */
  1363. if (sta_flags & WLAN_STA_WME &&
  1364. ieee80211_num_regular_queues(&local->hw) >= 4) {
  1365. fc |= cpu_to_le16(IEEE80211_STYPE_QOS_DATA);
  1366. hdrlen += 2;
  1367. }
  1368. /*
  1369. * Drop unicast frames to unauthorised stations unless they are
  1370. * EAPOL frames from the local station.
  1371. */
  1372. if (!ieee80211_vif_is_mesh(&sdata->vif) &&
  1373. unlikely(!is_multicast_ether_addr(hdr.addr1) &&
  1374. !(sta_flags & WLAN_STA_AUTHORIZED) &&
  1375. !(ethertype == ETH_P_PAE &&
  1376. compare_ether_addr(dev->dev_addr,
  1377. skb->data + ETH_ALEN) == 0))) {
  1378. #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
  1379. if (net_ratelimit())
  1380. printk(KERN_DEBUG "%s: dropped frame to %pM"
  1381. " (unauthorized port)\n", dev->name,
  1382. hdr.addr1);
  1383. #endif
  1384. I802_DEBUG_INC(local->tx_handlers_drop_unauth_port);
  1385. ret = 0;
  1386. goto fail;
  1387. }
  1388. hdr.frame_control = fc;
  1389. hdr.duration_id = 0;
  1390. hdr.seq_ctrl = 0;
  1391. skip_header_bytes = ETH_HLEN;
  1392. if (ethertype == ETH_P_AARP || ethertype == ETH_P_IPX) {
  1393. encaps_data = bridge_tunnel_header;
  1394. encaps_len = sizeof(bridge_tunnel_header);
  1395. skip_header_bytes -= 2;
  1396. } else if (ethertype >= 0x600) {
  1397. encaps_data = rfc1042_header;
  1398. encaps_len = sizeof(rfc1042_header);
  1399. skip_header_bytes -= 2;
  1400. } else {
  1401. encaps_data = NULL;
  1402. encaps_len = 0;
  1403. }
  1404. skb_pull(skb, skip_header_bytes);
  1405. nh_pos -= skip_header_bytes;
  1406. h_pos -= skip_header_bytes;
  1407. head_need = hdrlen + encaps_len + meshhdrlen - skb_headroom(skb);
  1408. /*
  1409. * So we need to modify the skb header and hence need a copy of
  1410. * that. The head_need variable above doesn't, so far, include
  1411. * the needed header space that we don't need right away. If we
  1412. * can, then we don't reallocate right now but only after the
  1413. * frame arrives at the master device (if it does...)
  1414. *
  1415. * If we cannot, however, then we will reallocate to include all
  1416. * the ever needed space. Also, if we need to reallocate it anyway,
  1417. * make it big enough for everything we may ever need.
  1418. */
  1419. if (head_need > 0 || skb_cloned(skb)) {
  1420. head_need += IEEE80211_ENCRYPT_HEADROOM;
  1421. head_need += local->tx_headroom;
  1422. head_need = max_t(int, 0, head_need);
  1423. if (ieee80211_skb_resize(local, skb, head_need, true))
  1424. goto fail;
  1425. }
  1426. if (encaps_data) {
  1427. memcpy(skb_push(skb, encaps_len), encaps_data, encaps_len);
  1428. nh_pos += encaps_len;
  1429. h_pos += encaps_len;
  1430. }
  1431. if (meshhdrlen > 0) {
  1432. memcpy(skb_push(skb, meshhdrlen), &mesh_hdr, meshhdrlen);
  1433. nh_pos += meshhdrlen;
  1434. h_pos += meshhdrlen;
  1435. }
  1436. if (ieee80211_is_data_qos(fc)) {
  1437. __le16 *qos_control;
  1438. qos_control = (__le16*) skb_push(skb, 2);
  1439. memcpy(skb_push(skb, hdrlen - 2), &hdr, hdrlen - 2);
  1440. /*
  1441. * Maybe we could actually set some fields here, for now just
  1442. * initialise to zero to indicate no special operation.
  1443. */
  1444. *qos_control = 0;
  1445. } else
  1446. memcpy(skb_push(skb, hdrlen), &hdr, hdrlen);
  1447. nh_pos += hdrlen;
  1448. h_pos += hdrlen;
  1449. skb->iif = dev->ifindex;
  1450. skb->dev = local->mdev;
  1451. dev->stats.tx_packets++;
  1452. dev->stats.tx_bytes += skb->len;
  1453. /* Update skb pointers to various headers since this modified frame
  1454. * is going to go through Linux networking code that may potentially
  1455. * need things like pointer to IP header. */
  1456. skb_set_mac_header(skb, 0);
  1457. skb_set_network_header(skb, nh_pos);
  1458. skb_set_transport_header(skb, h_pos);
  1459. dev->trans_start = jiffies;
  1460. dev_queue_xmit(skb);
  1461. return 0;
  1462. fail:
  1463. if (!ret)
  1464. dev_kfree_skb(skb);
  1465. return ret;
  1466. }
  1467. /*
  1468. * ieee80211_clear_tx_pending may not be called in a context where
  1469. * it is possible that it packets could come in again.
  1470. */
  1471. void ieee80211_clear_tx_pending(struct ieee80211_local *local)
  1472. {
  1473. int i, j;
  1474. struct ieee80211_tx_stored_packet *store;
  1475. for (i = 0; i < ieee80211_num_regular_queues(&local->hw); i++) {
  1476. if (!test_bit(i, local->queues_pending))
  1477. continue;
  1478. store = &local->pending_packet[i];
  1479. kfree_skb(store->skb);
  1480. for (j = 0; j < store->num_extra_frag; j++)
  1481. kfree_skb(store->extra_frag[j]);
  1482. kfree(store->extra_frag);
  1483. clear_bit(i, local->queues_pending);
  1484. }
  1485. }
  1486. /*
  1487. * Transmit all pending packets. Called from tasklet, locks master device
  1488. * TX lock so that no new packets can come in.
  1489. */
  1490. void ieee80211_tx_pending(unsigned long data)
  1491. {
  1492. struct ieee80211_local *local = (struct ieee80211_local *)data;
  1493. struct net_device *dev = local->mdev;
  1494. struct ieee80211_tx_stored_packet *store;
  1495. struct ieee80211_tx_data tx;
  1496. int i, ret;
  1497. netif_tx_lock_bh(dev);
  1498. for (i = 0; i < ieee80211_num_regular_queues(&local->hw); i++) {
  1499. /* Check that this queue is ok */
  1500. if (__netif_subqueue_stopped(local->mdev, i) &&
  1501. !test_bit(i, local->queues_pending_run))
  1502. continue;
  1503. if (!test_bit(i, local->queues_pending)) {
  1504. clear_bit(i, local->queues_pending_run);
  1505. ieee80211_wake_queue(&local->hw, i);
  1506. continue;
  1507. }
  1508. clear_bit(i, local->queues_pending_run);
  1509. netif_start_subqueue(local->mdev, i);
  1510. store = &local->pending_packet[i];
  1511. tx.extra_frag = store->extra_frag;
  1512. tx.num_extra_frag = store->num_extra_frag;
  1513. tx.flags = 0;
  1514. ret = __ieee80211_tx(local, store->skb, &tx);
  1515. if (ret) {
  1516. if (ret == IEEE80211_TX_FRAG_AGAIN)
  1517. store->skb = NULL;
  1518. } else {
  1519. clear_bit(i, local->queues_pending);
  1520. ieee80211_wake_queue(&local->hw, i);
  1521. }
  1522. }
  1523. netif_tx_unlock_bh(dev);
  1524. }
  1525. /* functions for drivers to get certain frames */
  1526. static void ieee80211_beacon_add_tim(struct ieee80211_if_ap *bss,
  1527. struct sk_buff *skb,
  1528. struct beacon_data *beacon)
  1529. {
  1530. u8 *pos, *tim;
  1531. int aid0 = 0;
  1532. int i, have_bits = 0, n1, n2;
  1533. /* Generate bitmap for TIM only if there are any STAs in power save
  1534. * mode. */
  1535. if (atomic_read(&bss->num_sta_ps) > 0)
  1536. /* in the hope that this is faster than
  1537. * checking byte-for-byte */
  1538. have_bits = !bitmap_empty((unsigned long*)bss->tim,
  1539. IEEE80211_MAX_AID+1);
  1540. if (bss->dtim_count == 0)
  1541. bss->dtim_count = beacon->dtim_period - 1;
  1542. else
  1543. bss->dtim_count--;
  1544. tim = pos = (u8 *) skb_put(skb, 6);
  1545. *pos++ = WLAN_EID_TIM;
  1546. *pos++ = 4;
  1547. *pos++ = bss->dtim_count;
  1548. *pos++ = beacon->dtim_period;
  1549. if (bss->dtim_count == 0 && !skb_queue_empty(&bss->ps_bc_buf))
  1550. aid0 = 1;
  1551. if (have_bits) {
  1552. /* Find largest even number N1 so that bits numbered 1 through
  1553. * (N1 x 8) - 1 in the bitmap are 0 and number N2 so that bits
  1554. * (N2 + 1) x 8 through 2007 are 0. */
  1555. n1 = 0;
  1556. for (i = 0; i < IEEE80211_MAX_TIM_LEN; i++) {
  1557. if (bss->tim[i]) {
  1558. n1 = i & 0xfe;
  1559. break;
  1560. }
  1561. }
  1562. n2 = n1;
  1563. for (i = IEEE80211_MAX_TIM_LEN - 1; i >= n1; i--) {
  1564. if (bss->tim[i]) {
  1565. n2 = i;
  1566. break;
  1567. }
  1568. }
  1569. /* Bitmap control */
  1570. *pos++ = n1 | aid0;
  1571. /* Part Virt Bitmap */
  1572. memcpy(pos, bss->tim + n1, n2 - n1 + 1);
  1573. tim[1] = n2 - n1 + 4;
  1574. skb_put(skb, n2 - n1);
  1575. } else {
  1576. *pos++ = aid0; /* Bitmap control */
  1577. *pos++ = 0; /* Part Virt Bitmap */
  1578. }
  1579. }
  1580. struct sk_buff *ieee80211_beacon_get(struct ieee80211_hw *hw,
  1581. struct ieee80211_vif *vif)
  1582. {
  1583. struct ieee80211_local *local = hw_to_local(hw);
  1584. struct sk_buff *skb = NULL;
  1585. struct ieee80211_tx_info *info;
  1586. struct ieee80211_sub_if_data *sdata = NULL;
  1587. struct ieee80211_if_ap *ap = NULL;
  1588. struct ieee80211_if_sta *ifsta = NULL;
  1589. struct beacon_data *beacon;
  1590. struct ieee80211_supported_band *sband;
  1591. enum ieee80211_band band = local->hw.conf.channel->band;
  1592. sband = local->hw.wiphy->bands[band];
  1593. rcu_read_lock();
  1594. sdata = vif_to_sdata(vif);
  1595. if (sdata->vif.type == NL80211_IFTYPE_AP) {
  1596. ap = &sdata->u.ap;
  1597. beacon = rcu_dereference(ap->beacon);
  1598. if (ap && beacon) {
  1599. /*
  1600. * headroom, head length,
  1601. * tail length and maximum TIM length
  1602. */
  1603. skb = dev_alloc_skb(local->tx_headroom +
  1604. beacon->head_len +
  1605. beacon->tail_len + 256);
  1606. if (!skb)
  1607. goto out;
  1608. skb_reserve(skb, local->tx_headroom);
  1609. memcpy(skb_put(skb, beacon->head_len), beacon->head,
  1610. beacon->head_len);
  1611. /*
  1612. * Not very nice, but we want to allow the driver to call
  1613. * ieee80211_beacon_get() as a response to the set_tim()
  1614. * callback. That, however, is already invoked under the
  1615. * sta_lock to guarantee consistent and race-free update
  1616. * of the tim bitmap in mac80211 and the driver.
  1617. */
  1618. if (local->tim_in_locked_section) {
  1619. ieee80211_beacon_add_tim(ap, skb, beacon);
  1620. } else {
  1621. unsigned long flags;
  1622. spin_lock_irqsave(&local->sta_lock, flags);
  1623. ieee80211_beacon_add_tim(ap, skb, beacon);
  1624. spin_unlock_irqrestore(&local->sta_lock, flags);
  1625. }
  1626. if (beacon->tail)
  1627. memcpy(skb_put(skb, beacon->tail_len),
  1628. beacon->tail, beacon->tail_len);
  1629. } else
  1630. goto out;
  1631. } else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
  1632. struct ieee80211_hdr *hdr;
  1633. ifsta = &sdata->u.sta;
  1634. if (!ifsta->probe_resp)
  1635. goto out;
  1636. skb = skb_copy(ifsta->probe_resp, GFP_ATOMIC);
  1637. if (!skb)
  1638. goto out;
  1639. hdr = (struct ieee80211_hdr *) skb->data;
  1640. hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
  1641. IEEE80211_STYPE_BEACON);
  1642. } else if (ieee80211_vif_is_mesh(&sdata->vif)) {
  1643. struct ieee80211_mgmt *mgmt;
  1644. u8 *pos;
  1645. /* headroom, head length, tail length and maximum TIM length */
  1646. skb = dev_alloc_skb(local->tx_headroom + 400);
  1647. if (!skb)
  1648. goto out;
  1649. skb_reserve(skb, local->hw.extra_tx_headroom);
  1650. mgmt = (struct ieee80211_mgmt *)
  1651. skb_put(skb, 24 + sizeof(mgmt->u.beacon));
  1652. memset(mgmt, 0, 24 + sizeof(mgmt->u.beacon));
  1653. mgmt->frame_control =
  1654. cpu_to_le16(IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_BEACON);
  1655. memset(mgmt->da, 0xff, ETH_ALEN);
  1656. memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
  1657. /* BSSID is left zeroed, wildcard value */
  1658. mgmt->u.beacon.beacon_int =
  1659. cpu_to_le16(local->hw.conf.beacon_int);
  1660. mgmt->u.beacon.capab_info = 0x0; /* 0x0 for MPs */
  1661. pos = skb_put(skb, 2);
  1662. *pos++ = WLAN_EID_SSID;
  1663. *pos++ = 0x0;
  1664. mesh_mgmt_ies_add(skb, sdata);
  1665. } else {
  1666. WARN_ON(1);
  1667. goto out;
  1668. }
  1669. info = IEEE80211_SKB_CB(skb);
  1670. skb->do_not_encrypt = 1;
  1671. info->band = band;
  1672. /*
  1673. * XXX: For now, always use the lowest rate
  1674. */
  1675. info->control.rates[0].idx = 0;
  1676. info->control.rates[0].count = 1;
  1677. info->control.rates[1].idx = -1;
  1678. info->control.rates[2].idx = -1;
  1679. info->control.rates[3].idx = -1;
  1680. info->control.rates[4].idx = -1;
  1681. BUILD_BUG_ON(IEEE80211_TX_MAX_RATES != 5);
  1682. info->control.vif = vif;
  1683. info->flags |= IEEE80211_TX_CTL_NO_ACK;
  1684. info->flags |= IEEE80211_TX_CTL_CLEAR_PS_FILT;
  1685. info->flags |= IEEE80211_TX_CTL_ASSIGN_SEQ;
  1686. out:
  1687. rcu_read_unlock();
  1688. return skb;
  1689. }
  1690. EXPORT_SYMBOL(ieee80211_beacon_get);
  1691. void ieee80211_rts_get(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
  1692. const void *frame, size_t frame_len,
  1693. const struct ieee80211_tx_info *frame_txctl,
  1694. struct ieee80211_rts *rts)
  1695. {
  1696. const struct ieee80211_hdr *hdr = frame;
  1697. rts->frame_control =
  1698. cpu_to_le16(IEEE80211_FTYPE_CTL | IEEE80211_STYPE_RTS);
  1699. rts->duration = ieee80211_rts_duration(hw, vif, frame_len,
  1700. frame_txctl);
  1701. memcpy(rts->ra, hdr->addr1, sizeof(rts->ra));
  1702. memcpy(rts->ta, hdr->addr2, sizeof(rts->ta));
  1703. }
  1704. EXPORT_SYMBOL(ieee80211_rts_get);
  1705. void ieee80211_ctstoself_get(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
  1706. const void *frame, size_t frame_len,
  1707. const struct ieee80211_tx_info *frame_txctl,
  1708. struct ieee80211_cts *cts)
  1709. {
  1710. const struct ieee80211_hdr *hdr = frame;
  1711. cts->frame_control =
  1712. cpu_to_le16(IEEE80211_FTYPE_CTL | IEEE80211_STYPE_CTS);
  1713. cts->duration = ieee80211_ctstoself_duration(hw, vif,
  1714. frame_len, frame_txctl);
  1715. memcpy(cts->ra, hdr->addr1, sizeof(cts->ra));
  1716. }
  1717. EXPORT_SYMBOL(ieee80211_ctstoself_get);
  1718. struct sk_buff *
  1719. ieee80211_get_buffered_bc(struct ieee80211_hw *hw,
  1720. struct ieee80211_vif *vif)
  1721. {
  1722. struct ieee80211_local *local = hw_to_local(hw);
  1723. struct sk_buff *skb = NULL;
  1724. struct sta_info *sta;
  1725. struct ieee80211_tx_data tx;
  1726. struct ieee80211_sub_if_data *sdata;
  1727. struct ieee80211_if_ap *bss = NULL;
  1728. struct beacon_data *beacon;
  1729. struct ieee80211_tx_info *info;
  1730. sdata = vif_to_sdata(vif);
  1731. bss = &sdata->u.ap;
  1732. if (!bss)
  1733. return NULL;
  1734. rcu_read_lock();
  1735. beacon = rcu_dereference(bss->beacon);
  1736. if (sdata->vif.type != NL80211_IFTYPE_AP || !beacon || !beacon->head)
  1737. goto out;
  1738. if (bss->dtim_count != 0)
  1739. goto out; /* send buffered bc/mc only after DTIM beacon */
  1740. while (1) {
  1741. skb = skb_dequeue(&bss->ps_bc_buf);
  1742. if (!skb)
  1743. goto out;
  1744. local->total_ps_buffered--;
  1745. if (!skb_queue_empty(&bss->ps_bc_buf) && skb->len >= 2) {
  1746. struct ieee80211_hdr *hdr =
  1747. (struct ieee80211_hdr *) skb->data;
  1748. /* more buffered multicast/broadcast frames ==> set
  1749. * MoreData flag in IEEE 802.11 header to inform PS
  1750. * STAs */
  1751. hdr->frame_control |=
  1752. cpu_to_le16(IEEE80211_FCTL_MOREDATA);
  1753. }
  1754. if (!ieee80211_tx_prepare(local, &tx, skb))
  1755. break;
  1756. dev_kfree_skb_any(skb);
  1757. }
  1758. info = IEEE80211_SKB_CB(skb);
  1759. sta = tx.sta;
  1760. tx.flags |= IEEE80211_TX_PS_BUFFERED;
  1761. tx.channel = local->hw.conf.channel;
  1762. info->band = tx.channel->band;
  1763. if (invoke_tx_handlers(&tx))
  1764. skb = NULL;
  1765. out:
  1766. rcu_read_unlock();
  1767. return skb;
  1768. }
  1769. EXPORT_SYMBOL(ieee80211_get_buffered_bc);