tx.c 70 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556
  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 "driver-ops.h"
  27. #include "led.h"
  28. #include "mesh.h"
  29. #include "wep.h"
  30. #include "wpa.h"
  31. #include "wme.h"
  32. #include "rate.h"
  33. #define IEEE80211_TX_OK 0
  34. #define IEEE80211_TX_AGAIN 1
  35. #define IEEE80211_TX_PENDING 2
  36. /* misc utils */
  37. static __le16 ieee80211_duration(struct ieee80211_tx_data *tx, int group_addr,
  38. int next_frag_len)
  39. {
  40. int rate, mrate, erp, dur, i;
  41. struct ieee80211_rate *txrate;
  42. struct ieee80211_local *local = tx->local;
  43. struct ieee80211_supported_band *sband;
  44. struct ieee80211_hdr *hdr;
  45. struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
  46. /* assume HW handles this */
  47. if (info->control.rates[0].flags & IEEE80211_TX_RC_MCS)
  48. return 0;
  49. /* uh huh? */
  50. if (WARN_ON_ONCE(info->control.rates[0].idx < 0))
  51. return 0;
  52. sband = local->hw.wiphy->bands[tx->channel->band];
  53. txrate = &sband->bitrates[info->control.rates[0].idx];
  54. erp = txrate->flags & IEEE80211_RATE_ERP_G;
  55. /*
  56. * data and mgmt (except PS Poll):
  57. * - during CFP: 32768
  58. * - during contention period:
  59. * if addr1 is group address: 0
  60. * if more fragments = 0 and addr1 is individual address: time to
  61. * transmit one ACK plus SIFS
  62. * if more fragments = 1 and addr1 is individual address: time to
  63. * transmit next fragment plus 2 x ACK plus 3 x SIFS
  64. *
  65. * IEEE 802.11, 9.6:
  66. * - control response frame (CTS or ACK) shall be transmitted using the
  67. * same rate as the immediately previous frame in the frame exchange
  68. * sequence, if this rate belongs to the PHY mandatory rates, or else
  69. * at the highest possible rate belonging to the PHY rates in the
  70. * BSSBasicRateSet
  71. */
  72. hdr = (struct ieee80211_hdr *)tx->skb->data;
  73. if (ieee80211_is_ctl(hdr->frame_control)) {
  74. /* TODO: These control frames are not currently sent by
  75. * mac80211, but should they be implemented, this function
  76. * needs to be updated to support duration field calculation.
  77. *
  78. * RTS: time needed to transmit pending data/mgmt frame plus
  79. * one CTS frame plus one ACK frame plus 3 x SIFS
  80. * CTS: duration of immediately previous RTS minus time
  81. * required to transmit CTS and its SIFS
  82. * ACK: 0 if immediately previous directed data/mgmt had
  83. * more=0, with more=1 duration in ACK frame is duration
  84. * from previous frame minus time needed to transmit ACK
  85. * and its SIFS
  86. * PS Poll: BIT(15) | BIT(14) | aid
  87. */
  88. return 0;
  89. }
  90. /* data/mgmt */
  91. if (0 /* FIX: data/mgmt during CFP */)
  92. return cpu_to_le16(32768);
  93. if (group_addr) /* Group address as the destination - no ACK */
  94. return 0;
  95. /* Individual destination address:
  96. * IEEE 802.11, Ch. 9.6 (after IEEE 802.11g changes)
  97. * CTS and ACK frames shall be transmitted using the highest rate in
  98. * basic rate set that is less than or equal to the rate of the
  99. * immediately previous frame and that is using the same modulation
  100. * (CCK or OFDM). If no basic rate set matches with these requirements,
  101. * the highest mandatory rate of the PHY that is less than or equal to
  102. * the rate of the previous frame is used.
  103. * Mandatory rates for IEEE 802.11g PHY: 1, 2, 5.5, 11, 6, 12, 24 Mbps
  104. */
  105. rate = -1;
  106. /* use lowest available if everything fails */
  107. mrate = sband->bitrates[0].bitrate;
  108. for (i = 0; i < sband->n_bitrates; i++) {
  109. struct ieee80211_rate *r = &sband->bitrates[i];
  110. if (r->bitrate > txrate->bitrate)
  111. break;
  112. if (tx->sdata->vif.bss_conf.basic_rates & BIT(i))
  113. rate = r->bitrate;
  114. switch (sband->band) {
  115. case IEEE80211_BAND_2GHZ: {
  116. u32 flag;
  117. if (tx->sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
  118. flag = IEEE80211_RATE_MANDATORY_G;
  119. else
  120. flag = IEEE80211_RATE_MANDATORY_B;
  121. if (r->flags & flag)
  122. mrate = r->bitrate;
  123. break;
  124. }
  125. case IEEE80211_BAND_5GHZ:
  126. if (r->flags & IEEE80211_RATE_MANDATORY_A)
  127. mrate = r->bitrate;
  128. break;
  129. case IEEE80211_NUM_BANDS:
  130. WARN_ON(1);
  131. break;
  132. }
  133. }
  134. if (rate == -1) {
  135. /* No matching basic rate found; use highest suitable mandatory
  136. * PHY rate */
  137. rate = mrate;
  138. }
  139. /* Time needed to transmit ACK
  140. * (10 bytes + 4-byte FCS = 112 bits) plus SIFS; rounded up
  141. * to closest integer */
  142. dur = ieee80211_frame_duration(local, 10, rate, erp,
  143. tx->sdata->vif.bss_conf.use_short_preamble);
  144. if (next_frag_len) {
  145. /* Frame is fragmented: duration increases with time needed to
  146. * transmit next fragment plus ACK and 2 x SIFS. */
  147. dur *= 2; /* ACK + SIFS */
  148. /* next fragment */
  149. dur += ieee80211_frame_duration(local, next_frag_len,
  150. txrate->bitrate, erp,
  151. tx->sdata->vif.bss_conf.use_short_preamble);
  152. }
  153. return cpu_to_le16(dur);
  154. }
  155. static int inline is_ieee80211_device(struct ieee80211_local *local,
  156. struct net_device *dev)
  157. {
  158. return local == wdev_priv(dev->ieee80211_ptr);
  159. }
  160. /* tx handlers */
  161. static ieee80211_tx_result debug_noinline
  162. ieee80211_tx_h_dynamic_ps(struct ieee80211_tx_data *tx)
  163. {
  164. struct ieee80211_local *local = tx->local;
  165. struct ieee80211_if_managed *ifmgd;
  166. /* driver doesn't support power save */
  167. if (!(local->hw.flags & IEEE80211_HW_SUPPORTS_PS))
  168. return TX_CONTINUE;
  169. /* hardware does dynamic power save */
  170. if (local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS)
  171. return TX_CONTINUE;
  172. /* dynamic power save disabled */
  173. if (local->hw.conf.dynamic_ps_timeout <= 0)
  174. return TX_CONTINUE;
  175. /* we are scanning, don't enable power save */
  176. if (local->scanning)
  177. return TX_CONTINUE;
  178. if (!local->ps_sdata)
  179. return TX_CONTINUE;
  180. /* No point if we're going to suspend */
  181. if (local->quiescing)
  182. return TX_CONTINUE;
  183. /* dynamic ps is supported only in managed mode */
  184. if (tx->sdata->vif.type != NL80211_IFTYPE_STATION)
  185. return TX_CONTINUE;
  186. ifmgd = &tx->sdata->u.mgd;
  187. /*
  188. * Don't wakeup from power save if u-apsd is enabled, voip ac has
  189. * u-apsd enabled and the frame is in voip class. This effectively
  190. * means that even if all access categories have u-apsd enabled, in
  191. * practise u-apsd is only used with the voip ac. This is a
  192. * workaround for the case when received voip class packets do not
  193. * have correct qos tag for some reason, due the network or the
  194. * peer application.
  195. *
  196. * Note: local->uapsd_queues access is racy here. If the value is
  197. * changed via debugfs, user needs to reassociate manually to have
  198. * everything in sync.
  199. */
  200. if ((ifmgd->flags & IEEE80211_STA_UAPSD_ENABLED)
  201. && (local->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)
  202. && skb_get_queue_mapping(tx->skb) == 0)
  203. return TX_CONTINUE;
  204. if (local->hw.conf.flags & IEEE80211_CONF_PS) {
  205. ieee80211_stop_queues_by_reason(&local->hw,
  206. IEEE80211_QUEUE_STOP_REASON_PS);
  207. ieee80211_queue_work(&local->hw,
  208. &local->dynamic_ps_disable_work);
  209. }
  210. mod_timer(&local->dynamic_ps_timer, jiffies +
  211. msecs_to_jiffies(local->hw.conf.dynamic_ps_timeout));
  212. return TX_CONTINUE;
  213. }
  214. static ieee80211_tx_result debug_noinline
  215. ieee80211_tx_h_check_assoc(struct ieee80211_tx_data *tx)
  216. {
  217. struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
  218. struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
  219. u32 sta_flags;
  220. if (unlikely(info->flags & IEEE80211_TX_CTL_INJECTED))
  221. return TX_CONTINUE;
  222. if (unlikely(test_bit(SCAN_OFF_CHANNEL, &tx->local->scanning)) &&
  223. !ieee80211_is_probe_req(hdr->frame_control) &&
  224. !ieee80211_is_nullfunc(hdr->frame_control))
  225. /*
  226. * When software scanning only nullfunc frames (to notify
  227. * the sleep state to the AP) and probe requests (for the
  228. * active scan) are allowed, all other frames should not be
  229. * sent and we should not get here, but if we do
  230. * nonetheless, drop them to avoid sending them
  231. * off-channel. See the link below and
  232. * ieee80211_start_scan() for more.
  233. *
  234. * http://article.gmane.org/gmane.linux.kernel.wireless.general/30089
  235. */
  236. return TX_DROP;
  237. if (tx->sdata->vif.type == NL80211_IFTYPE_WDS)
  238. return TX_CONTINUE;
  239. if (tx->sdata->vif.type == NL80211_IFTYPE_MESH_POINT)
  240. return TX_CONTINUE;
  241. if (tx->flags & IEEE80211_TX_PS_BUFFERED)
  242. return TX_CONTINUE;
  243. sta_flags = tx->sta ? get_sta_flags(tx->sta) : 0;
  244. if (likely(tx->flags & IEEE80211_TX_UNICAST)) {
  245. if (unlikely(!(sta_flags & WLAN_STA_ASSOC) &&
  246. tx->sdata->vif.type != NL80211_IFTYPE_ADHOC &&
  247. ieee80211_is_data(hdr->frame_control))) {
  248. #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
  249. printk(KERN_DEBUG "%s: dropped data frame to not "
  250. "associated station %pM\n",
  251. tx->sdata->name, hdr->addr1);
  252. #endif /* CONFIG_MAC80211_VERBOSE_DEBUG */
  253. I802_DEBUG_INC(tx->local->tx_handlers_drop_not_assoc);
  254. return TX_DROP;
  255. }
  256. } else {
  257. if (unlikely(ieee80211_is_data(hdr->frame_control) &&
  258. tx->local->num_sta == 0 &&
  259. tx->sdata->vif.type != NL80211_IFTYPE_ADHOC)) {
  260. /*
  261. * No associated STAs - no need to send multicast
  262. * frames.
  263. */
  264. return TX_DROP;
  265. }
  266. return TX_CONTINUE;
  267. }
  268. return TX_CONTINUE;
  269. }
  270. /* This function is called whenever the AP is about to exceed the maximum limit
  271. * of buffered frames for power saving STAs. This situation should not really
  272. * happen often during normal operation, so dropping the oldest buffered packet
  273. * from each queue should be OK to make some room for new frames. */
  274. static void purge_old_ps_buffers(struct ieee80211_local *local)
  275. {
  276. int total = 0, purged = 0;
  277. struct sk_buff *skb;
  278. struct ieee80211_sub_if_data *sdata;
  279. struct sta_info *sta;
  280. /*
  281. * virtual interfaces are protected by RCU
  282. */
  283. rcu_read_lock();
  284. list_for_each_entry_rcu(sdata, &local->interfaces, list) {
  285. struct ieee80211_if_ap *ap;
  286. if (sdata->vif.type != NL80211_IFTYPE_AP)
  287. continue;
  288. ap = &sdata->u.ap;
  289. skb = skb_dequeue(&ap->ps_bc_buf);
  290. if (skb) {
  291. purged++;
  292. dev_kfree_skb(skb);
  293. }
  294. total += skb_queue_len(&ap->ps_bc_buf);
  295. }
  296. list_for_each_entry_rcu(sta, &local->sta_list, list) {
  297. skb = skb_dequeue(&sta->ps_tx_buf);
  298. if (skb) {
  299. purged++;
  300. dev_kfree_skb(skb);
  301. }
  302. total += skb_queue_len(&sta->ps_tx_buf);
  303. }
  304. rcu_read_unlock();
  305. local->total_ps_buffered = total;
  306. #ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
  307. wiphy_debug(local->hw.wiphy, "PS buffers full - purged %d frames\n",
  308. purged);
  309. #endif
  310. }
  311. static ieee80211_tx_result
  312. ieee80211_tx_h_multicast_ps_buf(struct ieee80211_tx_data *tx)
  313. {
  314. struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
  315. struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
  316. /*
  317. * broadcast/multicast frame
  318. *
  319. * If any of the associated stations is in power save mode,
  320. * the frame is buffered to be sent after DTIM beacon frame.
  321. * This is done either by the hardware or us.
  322. */
  323. /* powersaving STAs only in AP/VLAN mode */
  324. if (!tx->sdata->bss)
  325. return TX_CONTINUE;
  326. /* no buffering for ordered frames */
  327. if (ieee80211_has_order(hdr->frame_control))
  328. return TX_CONTINUE;
  329. /* no stations in PS mode */
  330. if (!atomic_read(&tx->sdata->bss->num_sta_ps))
  331. return TX_CONTINUE;
  332. info->flags |= IEEE80211_TX_CTL_SEND_AFTER_DTIM;
  333. /* device releases frame after DTIM beacon */
  334. if (!(tx->local->hw.flags & IEEE80211_HW_HOST_BROADCAST_PS_BUFFERING))
  335. return TX_CONTINUE;
  336. /* buffered in mac80211 */
  337. if (tx->local->total_ps_buffered >= TOTAL_MAX_TX_BUFFER)
  338. purge_old_ps_buffers(tx->local);
  339. if (skb_queue_len(&tx->sdata->bss->ps_bc_buf) >= AP_MAX_BC_BUFFER) {
  340. #ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
  341. if (net_ratelimit())
  342. printk(KERN_DEBUG "%s: BC TX buffer full - dropping the oldest frame\n",
  343. tx->sdata->name);
  344. #endif
  345. dev_kfree_skb(skb_dequeue(&tx->sdata->bss->ps_bc_buf));
  346. } else
  347. tx->local->total_ps_buffered++;
  348. skb_queue_tail(&tx->sdata->bss->ps_bc_buf, tx->skb);
  349. return TX_QUEUED;
  350. }
  351. static int ieee80211_use_mfp(__le16 fc, struct sta_info *sta,
  352. struct sk_buff *skb)
  353. {
  354. if (!ieee80211_is_mgmt(fc))
  355. return 0;
  356. if (sta == NULL || !test_sta_flags(sta, WLAN_STA_MFP))
  357. return 0;
  358. if (!ieee80211_is_robust_mgmt_frame((struct ieee80211_hdr *)
  359. skb->data))
  360. return 0;
  361. return 1;
  362. }
  363. static ieee80211_tx_result
  364. ieee80211_tx_h_unicast_ps_buf(struct ieee80211_tx_data *tx)
  365. {
  366. struct sta_info *sta = tx->sta;
  367. struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
  368. struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
  369. struct ieee80211_local *local = tx->local;
  370. u32 staflags;
  371. if (unlikely(!sta ||
  372. ieee80211_is_probe_resp(hdr->frame_control) ||
  373. ieee80211_is_auth(hdr->frame_control) ||
  374. ieee80211_is_assoc_resp(hdr->frame_control) ||
  375. ieee80211_is_reassoc_resp(hdr->frame_control)))
  376. return TX_CONTINUE;
  377. staflags = get_sta_flags(sta);
  378. if (unlikely((staflags & (WLAN_STA_PS_STA | WLAN_STA_PS_DRIVER)) &&
  379. !(info->flags & IEEE80211_TX_CTL_PSPOLL_RESPONSE))) {
  380. #ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
  381. printk(KERN_DEBUG "STA %pM aid %d: PS buffer (entries "
  382. "before %d)\n",
  383. sta->sta.addr, sta->sta.aid,
  384. skb_queue_len(&sta->ps_tx_buf));
  385. #endif /* CONFIG_MAC80211_VERBOSE_PS_DEBUG */
  386. if (tx->local->total_ps_buffered >= TOTAL_MAX_TX_BUFFER)
  387. purge_old_ps_buffers(tx->local);
  388. if (skb_queue_len(&sta->ps_tx_buf) >= STA_MAX_TX_BUFFER) {
  389. struct sk_buff *old = skb_dequeue(&sta->ps_tx_buf);
  390. #ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
  391. if (net_ratelimit()) {
  392. printk(KERN_DEBUG "%s: STA %pM TX "
  393. "buffer full - dropping oldest frame\n",
  394. tx->sdata->name, sta->sta.addr);
  395. }
  396. #endif
  397. dev_kfree_skb(old);
  398. } else
  399. tx->local->total_ps_buffered++;
  400. /*
  401. * Queue frame to be sent after STA wakes up/polls,
  402. * but don't set the TIM bit if the driver is blocking
  403. * wakeup or poll response transmissions anyway.
  404. */
  405. if (skb_queue_empty(&sta->ps_tx_buf) &&
  406. !(staflags & WLAN_STA_PS_DRIVER))
  407. sta_info_set_tim_bit(sta);
  408. info->control.jiffies = jiffies;
  409. info->control.vif = &tx->sdata->vif;
  410. info->flags |= IEEE80211_TX_INTFL_NEED_TXPROCESSING;
  411. skb_queue_tail(&sta->ps_tx_buf, tx->skb);
  412. if (!timer_pending(&local->sta_cleanup))
  413. mod_timer(&local->sta_cleanup,
  414. round_jiffies(jiffies +
  415. STA_INFO_CLEANUP_INTERVAL));
  416. return TX_QUEUED;
  417. }
  418. #ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
  419. else if (unlikely(staflags & WLAN_STA_PS_STA)) {
  420. printk(KERN_DEBUG "%s: STA %pM in PS mode, but pspoll "
  421. "set -> send frame\n", tx->sdata->name,
  422. sta->sta.addr);
  423. }
  424. #endif /* CONFIG_MAC80211_VERBOSE_PS_DEBUG */
  425. return TX_CONTINUE;
  426. }
  427. static ieee80211_tx_result debug_noinline
  428. ieee80211_tx_h_ps_buf(struct ieee80211_tx_data *tx)
  429. {
  430. if (unlikely(tx->flags & IEEE80211_TX_PS_BUFFERED))
  431. return TX_CONTINUE;
  432. if (tx->flags & IEEE80211_TX_UNICAST)
  433. return ieee80211_tx_h_unicast_ps_buf(tx);
  434. else
  435. return ieee80211_tx_h_multicast_ps_buf(tx);
  436. }
  437. static ieee80211_tx_result debug_noinline
  438. ieee80211_tx_h_check_control_port_protocol(struct ieee80211_tx_data *tx)
  439. {
  440. struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
  441. if (unlikely(tx->sdata->control_port_protocol == tx->skb->protocol &&
  442. tx->sdata->control_port_no_encrypt))
  443. info->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
  444. return TX_CONTINUE;
  445. }
  446. static ieee80211_tx_result debug_noinline
  447. ieee80211_tx_h_select_key(struct ieee80211_tx_data *tx)
  448. {
  449. struct ieee80211_key *key = NULL;
  450. struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
  451. struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
  452. if (unlikely(info->flags & IEEE80211_TX_INTFL_DONT_ENCRYPT))
  453. tx->key = NULL;
  454. else if (tx->sta && (key = rcu_dereference(tx->sta->key)))
  455. tx->key = key;
  456. else if (ieee80211_is_mgmt(hdr->frame_control) &&
  457. is_multicast_ether_addr(hdr->addr1) &&
  458. ieee80211_is_robust_mgmt_frame(hdr) &&
  459. (key = rcu_dereference(tx->sdata->default_mgmt_key)))
  460. tx->key = key;
  461. else if ((key = rcu_dereference(tx->sdata->default_key)))
  462. tx->key = key;
  463. else if (tx->sdata->drop_unencrypted &&
  464. (tx->skb->protocol != tx->sdata->control_port_protocol) &&
  465. !(info->flags & IEEE80211_TX_CTL_INJECTED) &&
  466. (!ieee80211_is_robust_mgmt_frame(hdr) ||
  467. (ieee80211_is_action(hdr->frame_control) &&
  468. tx->sta && test_sta_flags(tx->sta, WLAN_STA_MFP)))) {
  469. I802_DEBUG_INC(tx->local->tx_handlers_drop_unencrypted);
  470. return TX_DROP;
  471. } else
  472. tx->key = NULL;
  473. if (tx->key) {
  474. bool skip_hw = false;
  475. tx->key->tx_rx_count++;
  476. /* TODO: add threshold stuff again */
  477. switch (tx->key->conf.cipher) {
  478. case WLAN_CIPHER_SUITE_WEP40:
  479. case WLAN_CIPHER_SUITE_WEP104:
  480. if (ieee80211_is_auth(hdr->frame_control))
  481. break;
  482. case WLAN_CIPHER_SUITE_TKIP:
  483. if (!ieee80211_is_data_present(hdr->frame_control))
  484. tx->key = NULL;
  485. break;
  486. case WLAN_CIPHER_SUITE_CCMP:
  487. if (!ieee80211_is_data_present(hdr->frame_control) &&
  488. !ieee80211_use_mfp(hdr->frame_control, tx->sta,
  489. tx->skb))
  490. tx->key = NULL;
  491. else
  492. skip_hw = (tx->key->conf.flags &
  493. IEEE80211_KEY_FLAG_SW_MGMT) &&
  494. ieee80211_is_mgmt(hdr->frame_control);
  495. break;
  496. case WLAN_CIPHER_SUITE_AES_CMAC:
  497. if (!ieee80211_is_mgmt(hdr->frame_control))
  498. tx->key = NULL;
  499. break;
  500. }
  501. if (!skip_hw && tx->key &&
  502. tx->key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE)
  503. info->control.hw_key = &tx->key->conf;
  504. }
  505. return TX_CONTINUE;
  506. }
  507. static ieee80211_tx_result debug_noinline
  508. ieee80211_tx_h_rate_ctrl(struct ieee80211_tx_data *tx)
  509. {
  510. struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
  511. struct ieee80211_hdr *hdr = (void *)tx->skb->data;
  512. struct ieee80211_supported_band *sband;
  513. struct ieee80211_rate *rate;
  514. int i;
  515. u32 len;
  516. bool inval = false, rts = false, short_preamble = false;
  517. struct ieee80211_tx_rate_control txrc;
  518. u32 sta_flags;
  519. memset(&txrc, 0, sizeof(txrc));
  520. sband = tx->local->hw.wiphy->bands[tx->channel->band];
  521. len = min_t(u32, tx->skb->len + FCS_LEN,
  522. tx->local->hw.wiphy->frag_threshold);
  523. /* set up the tx rate control struct we give the RC algo */
  524. txrc.hw = local_to_hw(tx->local);
  525. txrc.sband = sband;
  526. txrc.bss_conf = &tx->sdata->vif.bss_conf;
  527. txrc.skb = tx->skb;
  528. txrc.reported_rate.idx = -1;
  529. txrc.rate_idx_mask = tx->sdata->rc_rateidx_mask[tx->channel->band];
  530. if (txrc.rate_idx_mask == (1 << sband->n_bitrates) - 1)
  531. txrc.max_rate_idx = -1;
  532. else
  533. txrc.max_rate_idx = fls(txrc.rate_idx_mask) - 1;
  534. txrc.ap = tx->sdata->vif.type == NL80211_IFTYPE_AP;
  535. /* set up RTS protection if desired */
  536. if (len > tx->local->hw.wiphy->rts_threshold) {
  537. txrc.rts = rts = true;
  538. }
  539. /*
  540. * Use short preamble if the BSS can handle it, but not for
  541. * management frames unless we know the receiver can handle
  542. * that -- the management frame might be to a station that
  543. * just wants a probe response.
  544. */
  545. if (tx->sdata->vif.bss_conf.use_short_preamble &&
  546. (ieee80211_is_data(hdr->frame_control) ||
  547. (tx->sta && test_sta_flags(tx->sta, WLAN_STA_SHORT_PREAMBLE))))
  548. txrc.short_preamble = short_preamble = true;
  549. sta_flags = tx->sta ? get_sta_flags(tx->sta) : 0;
  550. /*
  551. * Lets not bother rate control if we're associated and cannot
  552. * talk to the sta. This should not happen.
  553. */
  554. if (WARN(test_bit(SCAN_SW_SCANNING, &tx->local->scanning) &&
  555. (sta_flags & WLAN_STA_ASSOC) &&
  556. !rate_usable_index_exists(sband, &tx->sta->sta),
  557. "%s: Dropped data frame as no usable bitrate found while "
  558. "scanning and associated. Target station: "
  559. "%pM on %d GHz band\n",
  560. tx->sdata->name, hdr->addr1,
  561. tx->channel->band ? 5 : 2))
  562. return TX_DROP;
  563. /*
  564. * If we're associated with the sta at this point we know we can at
  565. * least send the frame at the lowest bit rate.
  566. */
  567. rate_control_get_rate(tx->sdata, tx->sta, &txrc);
  568. if (unlikely(info->control.rates[0].idx < 0))
  569. return TX_DROP;
  570. if (txrc.reported_rate.idx < 0)
  571. txrc.reported_rate = info->control.rates[0];
  572. if (tx->sta)
  573. tx->sta->last_tx_rate = txrc.reported_rate;
  574. if (unlikely(!info->control.rates[0].count))
  575. info->control.rates[0].count = 1;
  576. if (WARN_ON_ONCE((info->control.rates[0].count > 1) &&
  577. (info->flags & IEEE80211_TX_CTL_NO_ACK)))
  578. info->control.rates[0].count = 1;
  579. if (is_multicast_ether_addr(hdr->addr1)) {
  580. /*
  581. * XXX: verify the rate is in the basic rateset
  582. */
  583. return TX_CONTINUE;
  584. }
  585. /*
  586. * set up the RTS/CTS rate as the fastest basic rate
  587. * that is not faster than the data rate
  588. *
  589. * XXX: Should this check all retry rates?
  590. */
  591. if (!(info->control.rates[0].flags & IEEE80211_TX_RC_MCS)) {
  592. s8 baserate = 0;
  593. rate = &sband->bitrates[info->control.rates[0].idx];
  594. for (i = 0; i < sband->n_bitrates; i++) {
  595. /* must be a basic rate */
  596. if (!(tx->sdata->vif.bss_conf.basic_rates & BIT(i)))
  597. continue;
  598. /* must not be faster than the data rate */
  599. if (sband->bitrates[i].bitrate > rate->bitrate)
  600. continue;
  601. /* maximum */
  602. if (sband->bitrates[baserate].bitrate <
  603. sband->bitrates[i].bitrate)
  604. baserate = i;
  605. }
  606. info->control.rts_cts_rate_idx = baserate;
  607. }
  608. for (i = 0; i < IEEE80211_TX_MAX_RATES; i++) {
  609. /*
  610. * make sure there's no valid rate following
  611. * an invalid one, just in case drivers don't
  612. * take the API seriously to stop at -1.
  613. */
  614. if (inval) {
  615. info->control.rates[i].idx = -1;
  616. continue;
  617. }
  618. if (info->control.rates[i].idx < 0) {
  619. inval = true;
  620. continue;
  621. }
  622. /*
  623. * For now assume MCS is already set up correctly, this
  624. * needs to be fixed.
  625. */
  626. if (info->control.rates[i].flags & IEEE80211_TX_RC_MCS) {
  627. WARN_ON(info->control.rates[i].idx > 76);
  628. continue;
  629. }
  630. /* set up RTS protection if desired */
  631. if (rts)
  632. info->control.rates[i].flags |=
  633. IEEE80211_TX_RC_USE_RTS_CTS;
  634. /* RC is busted */
  635. if (WARN_ON_ONCE(info->control.rates[i].idx >=
  636. sband->n_bitrates)) {
  637. info->control.rates[i].idx = -1;
  638. continue;
  639. }
  640. rate = &sband->bitrates[info->control.rates[i].idx];
  641. /* set up short preamble */
  642. if (short_preamble &&
  643. rate->flags & IEEE80211_RATE_SHORT_PREAMBLE)
  644. info->control.rates[i].flags |=
  645. IEEE80211_TX_RC_USE_SHORT_PREAMBLE;
  646. /* set up G protection */
  647. if (!rts && tx->sdata->vif.bss_conf.use_cts_prot &&
  648. rate->flags & IEEE80211_RATE_ERP_G)
  649. info->control.rates[i].flags |=
  650. IEEE80211_TX_RC_USE_CTS_PROTECT;
  651. }
  652. return TX_CONTINUE;
  653. }
  654. static ieee80211_tx_result debug_noinline
  655. ieee80211_tx_h_sequence(struct ieee80211_tx_data *tx)
  656. {
  657. struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
  658. struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx->skb->data;
  659. u16 *seq;
  660. u8 *qc;
  661. int tid;
  662. /*
  663. * Packet injection may want to control the sequence
  664. * number, if we have no matching interface then we
  665. * neither assign one ourselves nor ask the driver to.
  666. */
  667. if (unlikely(info->control.vif->type == NL80211_IFTYPE_MONITOR))
  668. return TX_CONTINUE;
  669. if (unlikely(ieee80211_is_ctl(hdr->frame_control)))
  670. return TX_CONTINUE;
  671. if (ieee80211_hdrlen(hdr->frame_control) < 24)
  672. return TX_CONTINUE;
  673. /*
  674. * Anything but QoS data that has a sequence number field
  675. * (is long enough) gets a sequence number from the global
  676. * counter.
  677. */
  678. if (!ieee80211_is_data_qos(hdr->frame_control)) {
  679. /* driver should assign sequence number */
  680. info->flags |= IEEE80211_TX_CTL_ASSIGN_SEQ;
  681. /* for pure STA mode without beacons, we can do it */
  682. hdr->seq_ctrl = cpu_to_le16(tx->sdata->sequence_number);
  683. tx->sdata->sequence_number += 0x10;
  684. return TX_CONTINUE;
  685. }
  686. /*
  687. * This should be true for injected/management frames only, for
  688. * management frames we have set the IEEE80211_TX_CTL_ASSIGN_SEQ
  689. * above since they are not QoS-data frames.
  690. */
  691. if (!tx->sta)
  692. return TX_CONTINUE;
  693. /* include per-STA, per-TID sequence counter */
  694. qc = ieee80211_get_qos_ctl(hdr);
  695. tid = *qc & IEEE80211_QOS_CTL_TID_MASK;
  696. seq = &tx->sta->tid_seq[tid];
  697. hdr->seq_ctrl = cpu_to_le16(*seq);
  698. /* Increase the sequence number. */
  699. *seq = (*seq + 0x10) & IEEE80211_SCTL_SEQ;
  700. return TX_CONTINUE;
  701. }
  702. static int ieee80211_fragment(struct ieee80211_local *local,
  703. struct sk_buff *skb, int hdrlen,
  704. int frag_threshold)
  705. {
  706. struct sk_buff *tail = skb, *tmp;
  707. int per_fragm = frag_threshold - hdrlen - FCS_LEN;
  708. int pos = hdrlen + per_fragm;
  709. int rem = skb->len - hdrlen - per_fragm;
  710. if (WARN_ON(rem < 0))
  711. return -EINVAL;
  712. while (rem) {
  713. int fraglen = per_fragm;
  714. if (fraglen > rem)
  715. fraglen = rem;
  716. rem -= fraglen;
  717. tmp = dev_alloc_skb(local->tx_headroom +
  718. frag_threshold +
  719. IEEE80211_ENCRYPT_HEADROOM +
  720. IEEE80211_ENCRYPT_TAILROOM);
  721. if (!tmp)
  722. return -ENOMEM;
  723. tail->next = tmp;
  724. tail = tmp;
  725. skb_reserve(tmp, local->tx_headroom +
  726. IEEE80211_ENCRYPT_HEADROOM);
  727. /* copy control information */
  728. memcpy(tmp->cb, skb->cb, sizeof(tmp->cb));
  729. skb_copy_queue_mapping(tmp, skb);
  730. tmp->priority = skb->priority;
  731. tmp->dev = skb->dev;
  732. /* copy header and data */
  733. memcpy(skb_put(tmp, hdrlen), skb->data, hdrlen);
  734. memcpy(skb_put(tmp, fraglen), skb->data + pos, fraglen);
  735. pos += fraglen;
  736. }
  737. skb->len = hdrlen + per_fragm;
  738. return 0;
  739. }
  740. static ieee80211_tx_result debug_noinline
  741. ieee80211_tx_h_fragment(struct ieee80211_tx_data *tx)
  742. {
  743. struct sk_buff *skb = tx->skb;
  744. struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
  745. struct ieee80211_hdr *hdr = (void *)skb->data;
  746. int frag_threshold = tx->local->hw.wiphy->frag_threshold;
  747. int hdrlen;
  748. int fragnum;
  749. if (!(tx->flags & IEEE80211_TX_FRAGMENTED))
  750. return TX_CONTINUE;
  751. /*
  752. * Warn when submitting a fragmented A-MPDU frame and drop it.
  753. * This scenario is handled in ieee80211_tx_prepare but extra
  754. * caution taken here as fragmented ampdu may cause Tx stop.
  755. */
  756. if (WARN_ON(info->flags & IEEE80211_TX_CTL_AMPDU))
  757. return TX_DROP;
  758. hdrlen = ieee80211_hdrlen(hdr->frame_control);
  759. /* internal error, why is TX_FRAGMENTED set? */
  760. if (WARN_ON(skb->len + FCS_LEN <= frag_threshold))
  761. return TX_DROP;
  762. /*
  763. * Now fragment the frame. This will allocate all the fragments and
  764. * chain them (using skb as the first fragment) to skb->next.
  765. * During transmission, we will remove the successfully transmitted
  766. * fragments from this list. When the low-level driver rejects one
  767. * of the fragments then we will simply pretend to accept the skb
  768. * but store it away as pending.
  769. */
  770. if (ieee80211_fragment(tx->local, skb, hdrlen, frag_threshold))
  771. return TX_DROP;
  772. /* update duration/seq/flags of fragments */
  773. fragnum = 0;
  774. do {
  775. int next_len;
  776. const __le16 morefrags = cpu_to_le16(IEEE80211_FCTL_MOREFRAGS);
  777. hdr = (void *)skb->data;
  778. info = IEEE80211_SKB_CB(skb);
  779. if (skb->next) {
  780. hdr->frame_control |= morefrags;
  781. next_len = skb->next->len;
  782. /*
  783. * No multi-rate retries for fragmented frames, that
  784. * would completely throw off the NAV at other STAs.
  785. */
  786. info->control.rates[1].idx = -1;
  787. info->control.rates[2].idx = -1;
  788. info->control.rates[3].idx = -1;
  789. info->control.rates[4].idx = -1;
  790. BUILD_BUG_ON(IEEE80211_TX_MAX_RATES != 5);
  791. info->flags &= ~IEEE80211_TX_CTL_RATE_CTRL_PROBE;
  792. } else {
  793. hdr->frame_control &= ~morefrags;
  794. next_len = 0;
  795. }
  796. hdr->duration_id = ieee80211_duration(tx, 0, next_len);
  797. hdr->seq_ctrl |= cpu_to_le16(fragnum & IEEE80211_SCTL_FRAG);
  798. fragnum++;
  799. } while ((skb = skb->next));
  800. return TX_CONTINUE;
  801. }
  802. static ieee80211_tx_result debug_noinline
  803. ieee80211_tx_h_stats(struct ieee80211_tx_data *tx)
  804. {
  805. struct sk_buff *skb = tx->skb;
  806. if (!tx->sta)
  807. return TX_CONTINUE;
  808. tx->sta->tx_packets++;
  809. do {
  810. tx->sta->tx_fragments++;
  811. tx->sta->tx_bytes += skb->len;
  812. } while ((skb = skb->next));
  813. return TX_CONTINUE;
  814. }
  815. static ieee80211_tx_result debug_noinline
  816. ieee80211_tx_h_encrypt(struct ieee80211_tx_data *tx)
  817. {
  818. struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx->skb);
  819. if (!tx->key)
  820. return TX_CONTINUE;
  821. switch (tx->key->conf.cipher) {
  822. case WLAN_CIPHER_SUITE_WEP40:
  823. case WLAN_CIPHER_SUITE_WEP104:
  824. return ieee80211_crypto_wep_encrypt(tx);
  825. case WLAN_CIPHER_SUITE_TKIP:
  826. return ieee80211_crypto_tkip_encrypt(tx);
  827. case WLAN_CIPHER_SUITE_CCMP:
  828. return ieee80211_crypto_ccmp_encrypt(tx);
  829. case WLAN_CIPHER_SUITE_AES_CMAC:
  830. return ieee80211_crypto_aes_cmac_encrypt(tx);
  831. default:
  832. /* handle hw-only algorithm */
  833. if (info->control.hw_key) {
  834. ieee80211_tx_set_protected(tx);
  835. return TX_CONTINUE;
  836. }
  837. break;
  838. }
  839. return TX_DROP;
  840. }
  841. static ieee80211_tx_result debug_noinline
  842. ieee80211_tx_h_calculate_duration(struct ieee80211_tx_data *tx)
  843. {
  844. struct sk_buff *skb = tx->skb;
  845. struct ieee80211_hdr *hdr;
  846. int next_len;
  847. bool group_addr;
  848. do {
  849. hdr = (void *) skb->data;
  850. if (unlikely(ieee80211_is_pspoll(hdr->frame_control)))
  851. break; /* must not overwrite AID */
  852. next_len = skb->next ? skb->next->len : 0;
  853. group_addr = is_multicast_ether_addr(hdr->addr1);
  854. hdr->duration_id =
  855. ieee80211_duration(tx, group_addr, next_len);
  856. } while ((skb = skb->next));
  857. return TX_CONTINUE;
  858. }
  859. /* actual transmit path */
  860. /*
  861. * deal with packet injection down monitor interface
  862. * with Radiotap Header -- only called for monitor mode interface
  863. */
  864. static bool __ieee80211_parse_tx_radiotap(struct ieee80211_tx_data *tx,
  865. struct sk_buff *skb)
  866. {
  867. /*
  868. * this is the moment to interpret and discard the radiotap header that
  869. * must be at the start of the packet injected in Monitor mode
  870. *
  871. * Need to take some care with endian-ness since radiotap
  872. * args are little-endian
  873. */
  874. struct ieee80211_radiotap_iterator iterator;
  875. struct ieee80211_radiotap_header *rthdr =
  876. (struct ieee80211_radiotap_header *) skb->data;
  877. struct ieee80211_supported_band *sband;
  878. struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
  879. int ret = ieee80211_radiotap_iterator_init(&iterator, rthdr, skb->len,
  880. NULL);
  881. sband = tx->local->hw.wiphy->bands[tx->channel->band];
  882. info->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
  883. tx->flags &= ~IEEE80211_TX_FRAGMENTED;
  884. /*
  885. * for every radiotap entry that is present
  886. * (ieee80211_radiotap_iterator_next returns -ENOENT when no more
  887. * entries present, or -EINVAL on error)
  888. */
  889. while (!ret) {
  890. ret = ieee80211_radiotap_iterator_next(&iterator);
  891. if (ret)
  892. continue;
  893. /* see if this argument is something we can use */
  894. switch (iterator.this_arg_index) {
  895. /*
  896. * You must take care when dereferencing iterator.this_arg
  897. * for multibyte types... the pointer is not aligned. Use
  898. * get_unaligned((type *)iterator.this_arg) to dereference
  899. * iterator.this_arg for type "type" safely on all arches.
  900. */
  901. case IEEE80211_RADIOTAP_FLAGS:
  902. if (*iterator.this_arg & IEEE80211_RADIOTAP_F_FCS) {
  903. /*
  904. * this indicates that the skb we have been
  905. * handed has the 32-bit FCS CRC at the end...
  906. * we should react to that by snipping it off
  907. * because it will be recomputed and added
  908. * on transmission
  909. */
  910. if (skb->len < (iterator._max_length + FCS_LEN))
  911. return false;
  912. skb_trim(skb, skb->len - FCS_LEN);
  913. }
  914. if (*iterator.this_arg & IEEE80211_RADIOTAP_F_WEP)
  915. info->flags &= ~IEEE80211_TX_INTFL_DONT_ENCRYPT;
  916. if (*iterator.this_arg & IEEE80211_RADIOTAP_F_FRAG)
  917. tx->flags |= IEEE80211_TX_FRAGMENTED;
  918. break;
  919. /*
  920. * Please update the file
  921. * Documentation/networking/mac80211-injection.txt
  922. * when parsing new fields here.
  923. */
  924. default:
  925. break;
  926. }
  927. }
  928. if (ret != -ENOENT) /* ie, if we didn't simply run out of fields */
  929. return false;
  930. /*
  931. * remove the radiotap header
  932. * iterator->_max_length was sanity-checked against
  933. * skb->len by iterator init
  934. */
  935. skb_pull(skb, iterator._max_length);
  936. return true;
  937. }
  938. static bool ieee80211_tx_prep_agg(struct ieee80211_tx_data *tx,
  939. struct sk_buff *skb,
  940. struct ieee80211_tx_info *info,
  941. struct tid_ampdu_tx *tid_tx,
  942. int tid)
  943. {
  944. bool queued = false;
  945. if (test_bit(HT_AGG_STATE_OPERATIONAL, &tid_tx->state)) {
  946. info->flags |= IEEE80211_TX_CTL_AMPDU;
  947. } else if (test_bit(HT_AGG_STATE_WANT_START, &tid_tx->state)) {
  948. /*
  949. * nothing -- this aggregation session is being started
  950. * but that might still fail with the driver
  951. */
  952. } else {
  953. spin_lock(&tx->sta->lock);
  954. /*
  955. * Need to re-check now, because we may get here
  956. *
  957. * 1) in the window during which the setup is actually
  958. * already done, but not marked yet because not all
  959. * packets are spliced over to the driver pending
  960. * queue yet -- if this happened we acquire the lock
  961. * either before or after the splice happens, but
  962. * need to recheck which of these cases happened.
  963. *
  964. * 2) during session teardown, if the OPERATIONAL bit
  965. * was cleared due to the teardown but the pointer
  966. * hasn't been assigned NULL yet (or we loaded it
  967. * before it was assigned) -- in this case it may
  968. * now be NULL which means we should just let the
  969. * packet pass through because splicing the frames
  970. * back is already done.
  971. */
  972. tid_tx = tx->sta->ampdu_mlme.tid_tx[tid];
  973. if (!tid_tx) {
  974. /* do nothing, let packet pass through */
  975. } else if (test_bit(HT_AGG_STATE_OPERATIONAL, &tid_tx->state)) {
  976. info->flags |= IEEE80211_TX_CTL_AMPDU;
  977. } else {
  978. queued = true;
  979. info->control.vif = &tx->sdata->vif;
  980. info->flags |= IEEE80211_TX_INTFL_NEED_TXPROCESSING;
  981. __skb_queue_tail(&tid_tx->pending, skb);
  982. }
  983. spin_unlock(&tx->sta->lock);
  984. }
  985. return queued;
  986. }
  987. /*
  988. * initialises @tx
  989. */
  990. static ieee80211_tx_result
  991. ieee80211_tx_prepare(struct ieee80211_sub_if_data *sdata,
  992. struct ieee80211_tx_data *tx,
  993. struct sk_buff *skb)
  994. {
  995. struct ieee80211_local *local = sdata->local;
  996. struct ieee80211_hdr *hdr;
  997. struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
  998. int hdrlen, tid;
  999. u8 *qc;
  1000. memset(tx, 0, sizeof(*tx));
  1001. tx->skb = skb;
  1002. tx->local = local;
  1003. tx->sdata = sdata;
  1004. tx->channel = local->hw.conf.channel;
  1005. /*
  1006. * Set this flag (used below to indicate "automatic fragmentation"),
  1007. * it will be cleared/left by radiotap as desired.
  1008. */
  1009. tx->flags |= IEEE80211_TX_FRAGMENTED;
  1010. /* process and remove the injection radiotap header */
  1011. if (unlikely(info->flags & IEEE80211_TX_INTFL_HAS_RADIOTAP)) {
  1012. if (!__ieee80211_parse_tx_radiotap(tx, skb))
  1013. return TX_DROP;
  1014. /*
  1015. * __ieee80211_parse_tx_radiotap has now removed
  1016. * the radiotap header that was present and pre-filled
  1017. * 'tx' with tx control information.
  1018. */
  1019. info->flags &= ~IEEE80211_TX_INTFL_HAS_RADIOTAP;
  1020. }
  1021. /*
  1022. * If this flag is set to true anywhere, and we get here,
  1023. * we are doing the needed processing, so remove the flag
  1024. * now.
  1025. */
  1026. info->flags &= ~IEEE80211_TX_INTFL_NEED_TXPROCESSING;
  1027. hdr = (struct ieee80211_hdr *) skb->data;
  1028. if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
  1029. tx->sta = rcu_dereference(sdata->u.vlan.sta);
  1030. if (!tx->sta && sdata->dev->ieee80211_ptr->use_4addr)
  1031. return TX_DROP;
  1032. } else if (info->flags & IEEE80211_TX_CTL_INJECTED) {
  1033. tx->sta = sta_info_get_bss(sdata, hdr->addr1);
  1034. }
  1035. if (!tx->sta)
  1036. tx->sta = sta_info_get(sdata, hdr->addr1);
  1037. if (tx->sta && ieee80211_is_data_qos(hdr->frame_control) &&
  1038. (local->hw.flags & IEEE80211_HW_AMPDU_AGGREGATION)) {
  1039. struct tid_ampdu_tx *tid_tx;
  1040. qc = ieee80211_get_qos_ctl(hdr);
  1041. tid = *qc & IEEE80211_QOS_CTL_TID_MASK;
  1042. tid_tx = rcu_dereference(tx->sta->ampdu_mlme.tid_tx[tid]);
  1043. if (tid_tx) {
  1044. bool queued;
  1045. queued = ieee80211_tx_prep_agg(tx, skb, info,
  1046. tid_tx, tid);
  1047. if (unlikely(queued))
  1048. return TX_QUEUED;
  1049. }
  1050. }
  1051. if (is_multicast_ether_addr(hdr->addr1)) {
  1052. tx->flags &= ~IEEE80211_TX_UNICAST;
  1053. info->flags |= IEEE80211_TX_CTL_NO_ACK;
  1054. } else {
  1055. tx->flags |= IEEE80211_TX_UNICAST;
  1056. if (unlikely(local->wifi_wme_noack_test))
  1057. info->flags |= IEEE80211_TX_CTL_NO_ACK;
  1058. else
  1059. info->flags &= ~IEEE80211_TX_CTL_NO_ACK;
  1060. }
  1061. if (tx->flags & IEEE80211_TX_FRAGMENTED) {
  1062. if ((tx->flags & IEEE80211_TX_UNICAST) &&
  1063. skb->len + FCS_LEN > local->hw.wiphy->frag_threshold &&
  1064. !(info->flags & IEEE80211_TX_CTL_AMPDU))
  1065. tx->flags |= IEEE80211_TX_FRAGMENTED;
  1066. else
  1067. tx->flags &= ~IEEE80211_TX_FRAGMENTED;
  1068. }
  1069. if (!tx->sta)
  1070. info->flags |= IEEE80211_TX_CTL_CLEAR_PS_FILT;
  1071. else if (test_and_clear_sta_flags(tx->sta, WLAN_STA_CLEAR_PS_FILT))
  1072. info->flags |= IEEE80211_TX_CTL_CLEAR_PS_FILT;
  1073. hdrlen = ieee80211_hdrlen(hdr->frame_control);
  1074. if (skb->len > hdrlen + sizeof(rfc1042_header) + 2) {
  1075. u8 *pos = &skb->data[hdrlen + sizeof(rfc1042_header)];
  1076. tx->ethertype = (pos[0] << 8) | pos[1];
  1077. }
  1078. info->flags |= IEEE80211_TX_CTL_FIRST_FRAGMENT;
  1079. return TX_CONTINUE;
  1080. }
  1081. static int __ieee80211_tx(struct ieee80211_local *local,
  1082. struct sk_buff **skbp,
  1083. struct sta_info *sta,
  1084. bool txpending)
  1085. {
  1086. struct sk_buff *skb = *skbp, *next;
  1087. struct ieee80211_tx_info *info;
  1088. struct ieee80211_sub_if_data *sdata;
  1089. unsigned long flags;
  1090. int ret, len;
  1091. bool fragm = false;
  1092. while (skb) {
  1093. int q = skb_get_queue_mapping(skb);
  1094. spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
  1095. ret = IEEE80211_TX_OK;
  1096. if (local->queue_stop_reasons[q] ||
  1097. (!txpending && !skb_queue_empty(&local->pending[q])))
  1098. ret = IEEE80211_TX_PENDING;
  1099. spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
  1100. if (ret != IEEE80211_TX_OK)
  1101. return ret;
  1102. info = IEEE80211_SKB_CB(skb);
  1103. if (fragm)
  1104. info->flags &= ~(IEEE80211_TX_CTL_CLEAR_PS_FILT |
  1105. IEEE80211_TX_CTL_FIRST_FRAGMENT);
  1106. next = skb->next;
  1107. len = skb->len;
  1108. if (next)
  1109. info->flags |= IEEE80211_TX_CTL_MORE_FRAMES;
  1110. sdata = vif_to_sdata(info->control.vif);
  1111. switch (sdata->vif.type) {
  1112. case NL80211_IFTYPE_MONITOR:
  1113. info->control.vif = NULL;
  1114. break;
  1115. case NL80211_IFTYPE_AP_VLAN:
  1116. info->control.vif = &container_of(sdata->bss,
  1117. struct ieee80211_sub_if_data, u.ap)->vif;
  1118. break;
  1119. default:
  1120. /* keep */
  1121. break;
  1122. }
  1123. if (sta && sta->uploaded)
  1124. info->control.sta = &sta->sta;
  1125. else
  1126. info->control.sta = NULL;
  1127. ret = drv_tx(local, skb);
  1128. if (WARN_ON(ret != NETDEV_TX_OK && skb->len != len)) {
  1129. dev_kfree_skb(skb);
  1130. ret = NETDEV_TX_OK;
  1131. }
  1132. if (ret != NETDEV_TX_OK) {
  1133. info->control.vif = &sdata->vif;
  1134. return IEEE80211_TX_AGAIN;
  1135. }
  1136. *skbp = skb = next;
  1137. ieee80211_led_tx(local, 1);
  1138. fragm = true;
  1139. }
  1140. return IEEE80211_TX_OK;
  1141. }
  1142. /*
  1143. * Invoke TX handlers, return 0 on success and non-zero if the
  1144. * frame was dropped or queued.
  1145. */
  1146. static int invoke_tx_handlers(struct ieee80211_tx_data *tx)
  1147. {
  1148. struct sk_buff *skb = tx->skb;
  1149. struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
  1150. ieee80211_tx_result res = TX_DROP;
  1151. #define CALL_TXH(txh) \
  1152. do { \
  1153. res = txh(tx); \
  1154. if (res != TX_CONTINUE) \
  1155. goto txh_done; \
  1156. } while (0)
  1157. CALL_TXH(ieee80211_tx_h_dynamic_ps);
  1158. CALL_TXH(ieee80211_tx_h_check_assoc);
  1159. CALL_TXH(ieee80211_tx_h_ps_buf);
  1160. CALL_TXH(ieee80211_tx_h_check_control_port_protocol);
  1161. CALL_TXH(ieee80211_tx_h_select_key);
  1162. if (!(tx->local->hw.flags & IEEE80211_HW_HAS_RATE_CONTROL))
  1163. CALL_TXH(ieee80211_tx_h_rate_ctrl);
  1164. if (unlikely(info->flags & IEEE80211_TX_INTFL_RETRANSMISSION))
  1165. goto txh_done;
  1166. CALL_TXH(ieee80211_tx_h_michael_mic_add);
  1167. CALL_TXH(ieee80211_tx_h_sequence);
  1168. CALL_TXH(ieee80211_tx_h_fragment);
  1169. /* handlers after fragment must be aware of tx info fragmentation! */
  1170. CALL_TXH(ieee80211_tx_h_stats);
  1171. CALL_TXH(ieee80211_tx_h_encrypt);
  1172. CALL_TXH(ieee80211_tx_h_calculate_duration);
  1173. #undef CALL_TXH
  1174. txh_done:
  1175. if (unlikely(res == TX_DROP)) {
  1176. I802_DEBUG_INC(tx->local->tx_handlers_drop);
  1177. while (skb) {
  1178. struct sk_buff *next;
  1179. next = skb->next;
  1180. dev_kfree_skb(skb);
  1181. skb = next;
  1182. }
  1183. return -1;
  1184. } else if (unlikely(res == TX_QUEUED)) {
  1185. I802_DEBUG_INC(tx->local->tx_handlers_queued);
  1186. return -1;
  1187. }
  1188. return 0;
  1189. }
  1190. static void ieee80211_tx(struct ieee80211_sub_if_data *sdata,
  1191. struct sk_buff *skb, bool txpending)
  1192. {
  1193. struct ieee80211_local *local = sdata->local;
  1194. struct ieee80211_tx_data tx;
  1195. ieee80211_tx_result res_prepare;
  1196. struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
  1197. struct sk_buff *next;
  1198. unsigned long flags;
  1199. int ret, retries;
  1200. u16 queue;
  1201. queue = skb_get_queue_mapping(skb);
  1202. if (unlikely(skb->len < 10)) {
  1203. dev_kfree_skb(skb);
  1204. return;
  1205. }
  1206. rcu_read_lock();
  1207. /* initialises tx */
  1208. res_prepare = ieee80211_tx_prepare(sdata, &tx, skb);
  1209. if (unlikely(res_prepare == TX_DROP)) {
  1210. dev_kfree_skb(skb);
  1211. rcu_read_unlock();
  1212. return;
  1213. } else if (unlikely(res_prepare == TX_QUEUED)) {
  1214. rcu_read_unlock();
  1215. return;
  1216. }
  1217. tx.channel = local->hw.conf.channel;
  1218. info->band = tx.channel->band;
  1219. if (invoke_tx_handlers(&tx))
  1220. goto out;
  1221. retries = 0;
  1222. retry:
  1223. ret = __ieee80211_tx(local, &tx.skb, tx.sta, txpending);
  1224. switch (ret) {
  1225. case IEEE80211_TX_OK:
  1226. break;
  1227. case IEEE80211_TX_AGAIN:
  1228. /*
  1229. * Since there are no fragmented frames on A-MPDU
  1230. * queues, there's no reason for a driver to reject
  1231. * a frame there, warn and drop it.
  1232. */
  1233. if (WARN_ON(info->flags & IEEE80211_TX_CTL_AMPDU))
  1234. goto drop;
  1235. /* fall through */
  1236. case IEEE80211_TX_PENDING:
  1237. skb = tx.skb;
  1238. spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
  1239. if (local->queue_stop_reasons[queue] ||
  1240. !skb_queue_empty(&local->pending[queue])) {
  1241. /*
  1242. * if queue is stopped, queue up frames for later
  1243. * transmission from the tasklet
  1244. */
  1245. do {
  1246. next = skb->next;
  1247. skb->next = NULL;
  1248. if (unlikely(txpending))
  1249. __skb_queue_head(&local->pending[queue],
  1250. skb);
  1251. else
  1252. __skb_queue_tail(&local->pending[queue],
  1253. skb);
  1254. } while ((skb = next));
  1255. spin_unlock_irqrestore(&local->queue_stop_reason_lock,
  1256. flags);
  1257. } else {
  1258. /*
  1259. * otherwise retry, but this is a race condition or
  1260. * a driver bug (which we warn about if it persists)
  1261. */
  1262. spin_unlock_irqrestore(&local->queue_stop_reason_lock,
  1263. flags);
  1264. retries++;
  1265. if (WARN(retries > 10, "tx refused but queue active\n"))
  1266. goto drop;
  1267. goto retry;
  1268. }
  1269. }
  1270. out:
  1271. rcu_read_unlock();
  1272. return;
  1273. drop:
  1274. rcu_read_unlock();
  1275. skb = tx.skb;
  1276. while (skb) {
  1277. next = skb->next;
  1278. dev_kfree_skb(skb);
  1279. skb = next;
  1280. }
  1281. }
  1282. /* device xmit handlers */
  1283. static int ieee80211_skb_resize(struct ieee80211_local *local,
  1284. struct sk_buff *skb,
  1285. int head_need, bool may_encrypt)
  1286. {
  1287. int tail_need = 0;
  1288. /*
  1289. * This could be optimised, devices that do full hardware
  1290. * crypto (including TKIP MMIC) need no tailroom... But we
  1291. * have no drivers for such devices currently.
  1292. */
  1293. if (may_encrypt) {
  1294. tail_need = IEEE80211_ENCRYPT_TAILROOM;
  1295. tail_need -= skb_tailroom(skb);
  1296. tail_need = max_t(int, tail_need, 0);
  1297. }
  1298. if (head_need || tail_need) {
  1299. /* Sorry. Can't account for this any more */
  1300. skb_orphan(skb);
  1301. }
  1302. if (skb_header_cloned(skb))
  1303. I802_DEBUG_INC(local->tx_expand_skb_head_cloned);
  1304. else
  1305. I802_DEBUG_INC(local->tx_expand_skb_head);
  1306. if (pskb_expand_head(skb, head_need, tail_need, GFP_ATOMIC)) {
  1307. wiphy_debug(local->hw.wiphy,
  1308. "failed to reallocate TX buffer\n");
  1309. return -ENOMEM;
  1310. }
  1311. /* update truesize too */
  1312. skb->truesize += head_need + tail_need;
  1313. return 0;
  1314. }
  1315. static void ieee80211_xmit(struct ieee80211_sub_if_data *sdata,
  1316. struct sk_buff *skb)
  1317. {
  1318. struct ieee80211_local *local = sdata->local;
  1319. struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
  1320. struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
  1321. struct ieee80211_sub_if_data *tmp_sdata;
  1322. int headroom;
  1323. bool may_encrypt;
  1324. rcu_read_lock();
  1325. if (unlikely(sdata->vif.type == NL80211_IFTYPE_MONITOR)) {
  1326. int hdrlen;
  1327. u16 len_rthdr;
  1328. info->flags |= IEEE80211_TX_CTL_INJECTED |
  1329. IEEE80211_TX_INTFL_HAS_RADIOTAP;
  1330. len_rthdr = ieee80211_get_radiotap_len(skb->data);
  1331. hdr = (struct ieee80211_hdr *)(skb->data + len_rthdr);
  1332. hdrlen = ieee80211_hdrlen(hdr->frame_control);
  1333. /* check the header is complete in the frame */
  1334. if (likely(skb->len >= len_rthdr + hdrlen)) {
  1335. /*
  1336. * We process outgoing injected frames that have a
  1337. * local address we handle as though they are our
  1338. * own frames.
  1339. * This code here isn't entirely correct, the local
  1340. * MAC address is not necessarily enough to find
  1341. * the interface to use; for that proper VLAN/WDS
  1342. * support we will need a different mechanism.
  1343. */
  1344. list_for_each_entry_rcu(tmp_sdata, &local->interfaces,
  1345. list) {
  1346. if (!ieee80211_sdata_running(tmp_sdata))
  1347. continue;
  1348. if (tmp_sdata->vif.type != NL80211_IFTYPE_AP)
  1349. continue;
  1350. if (compare_ether_addr(tmp_sdata->vif.addr,
  1351. hdr->addr2) == 0) {
  1352. sdata = tmp_sdata;
  1353. break;
  1354. }
  1355. }
  1356. }
  1357. }
  1358. may_encrypt = !(info->flags & IEEE80211_TX_INTFL_DONT_ENCRYPT);
  1359. headroom = local->tx_headroom;
  1360. if (may_encrypt)
  1361. headroom += IEEE80211_ENCRYPT_HEADROOM;
  1362. headroom -= skb_headroom(skb);
  1363. headroom = max_t(int, 0, headroom);
  1364. if (ieee80211_skb_resize(local, skb, headroom, may_encrypt)) {
  1365. dev_kfree_skb(skb);
  1366. rcu_read_unlock();
  1367. return;
  1368. }
  1369. hdr = (struct ieee80211_hdr *) skb->data;
  1370. info->control.vif = &sdata->vif;
  1371. if (ieee80211_vif_is_mesh(&sdata->vif) &&
  1372. ieee80211_is_data(hdr->frame_control) &&
  1373. !is_multicast_ether_addr(hdr->addr1))
  1374. if (mesh_nexthop_lookup(skb, sdata)) {
  1375. /* skb queued: don't free */
  1376. rcu_read_unlock();
  1377. return;
  1378. }
  1379. ieee80211_set_qos_hdr(local, skb);
  1380. ieee80211_tx(sdata, skb, false);
  1381. rcu_read_unlock();
  1382. }
  1383. netdev_tx_t ieee80211_monitor_start_xmit(struct sk_buff *skb,
  1384. struct net_device *dev)
  1385. {
  1386. struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
  1387. struct ieee80211_channel *chan = local->hw.conf.channel;
  1388. struct ieee80211_radiotap_header *prthdr =
  1389. (struct ieee80211_radiotap_header *)skb->data;
  1390. struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
  1391. u16 len_rthdr;
  1392. /*
  1393. * Frame injection is not allowed if beaconing is not allowed
  1394. * or if we need radar detection. Beaconing is usually not allowed when
  1395. * the mode or operation (Adhoc, AP, Mesh) does not support DFS.
  1396. * Passive scan is also used in world regulatory domains where
  1397. * your country is not known and as such it should be treated as
  1398. * NO TX unless the channel is explicitly allowed in which case
  1399. * your current regulatory domain would not have the passive scan
  1400. * flag.
  1401. *
  1402. * Since AP mode uses monitor interfaces to inject/TX management
  1403. * frames we can make AP mode the exception to this rule once it
  1404. * supports radar detection as its implementation can deal with
  1405. * radar detection by itself. We can do that later by adding a
  1406. * monitor flag interfaces used for AP support.
  1407. */
  1408. if ((chan->flags & (IEEE80211_CHAN_NO_IBSS | IEEE80211_CHAN_RADAR |
  1409. IEEE80211_CHAN_PASSIVE_SCAN)))
  1410. goto fail;
  1411. /* check for not even having the fixed radiotap header part */
  1412. if (unlikely(skb->len < sizeof(struct ieee80211_radiotap_header)))
  1413. goto fail; /* too short to be possibly valid */
  1414. /* is it a header version we can trust to find length from? */
  1415. if (unlikely(prthdr->it_version))
  1416. goto fail; /* only version 0 is supported */
  1417. /* then there must be a radiotap header with a length we can use */
  1418. len_rthdr = ieee80211_get_radiotap_len(skb->data);
  1419. /* does the skb contain enough to deliver on the alleged length? */
  1420. if (unlikely(skb->len < len_rthdr))
  1421. goto fail; /* skb too short for claimed rt header extent */
  1422. /*
  1423. * fix up the pointers accounting for the radiotap
  1424. * header still being in there. We are being given
  1425. * a precooked IEEE80211 header so no need for
  1426. * normal processing
  1427. */
  1428. skb_set_mac_header(skb, len_rthdr);
  1429. /*
  1430. * these are just fixed to the end of the rt area since we
  1431. * don't have any better information and at this point, nobody cares
  1432. */
  1433. skb_set_network_header(skb, len_rthdr);
  1434. skb_set_transport_header(skb, len_rthdr);
  1435. memset(info, 0, sizeof(*info));
  1436. info->flags |= IEEE80211_TX_CTL_REQ_TX_STATUS;
  1437. /* pass the radiotap header up to xmit */
  1438. ieee80211_xmit(IEEE80211_DEV_TO_SUB_IF(dev), skb);
  1439. return NETDEV_TX_OK;
  1440. fail:
  1441. dev_kfree_skb(skb);
  1442. return NETDEV_TX_OK; /* meaning, we dealt with the skb */
  1443. }
  1444. /**
  1445. * ieee80211_subif_start_xmit - netif start_xmit function for Ethernet-type
  1446. * subinterfaces (wlan#, WDS, and VLAN interfaces)
  1447. * @skb: packet to be sent
  1448. * @dev: incoming interface
  1449. *
  1450. * Returns: 0 on success (and frees skb in this case) or 1 on failure (skb will
  1451. * not be freed, and caller is responsible for either retrying later or freeing
  1452. * skb).
  1453. *
  1454. * This function takes in an Ethernet header and encapsulates it with suitable
  1455. * IEEE 802.11 header based on which interface the packet is coming in. The
  1456. * encapsulated packet will then be passed to master interface, wlan#.11, for
  1457. * transmission (through low-level driver).
  1458. */
  1459. netdev_tx_t ieee80211_subif_start_xmit(struct sk_buff *skb,
  1460. struct net_device *dev)
  1461. {
  1462. struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
  1463. struct ieee80211_local *local = sdata->local;
  1464. struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
  1465. int ret = NETDEV_TX_BUSY, head_need;
  1466. u16 ethertype, hdrlen, meshhdrlen = 0;
  1467. __le16 fc;
  1468. struct ieee80211_hdr hdr;
  1469. struct ieee80211s_hdr mesh_hdr __maybe_unused;
  1470. const u8 *encaps_data;
  1471. int encaps_len, skip_header_bytes;
  1472. int nh_pos, h_pos;
  1473. struct sta_info *sta = NULL;
  1474. u32 sta_flags = 0;
  1475. if (unlikely(skb->len < ETH_HLEN)) {
  1476. ret = NETDEV_TX_OK;
  1477. goto fail;
  1478. }
  1479. nh_pos = skb_network_header(skb) - skb->data;
  1480. h_pos = skb_transport_header(skb) - skb->data;
  1481. /* convert Ethernet header to proper 802.11 header (based on
  1482. * operation mode) */
  1483. ethertype = (skb->data[12] << 8) | skb->data[13];
  1484. fc = cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA);
  1485. switch (sdata->vif.type) {
  1486. case NL80211_IFTYPE_AP_VLAN:
  1487. rcu_read_lock();
  1488. sta = rcu_dereference(sdata->u.vlan.sta);
  1489. if (sta) {
  1490. fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS);
  1491. /* RA TA DA SA */
  1492. memcpy(hdr.addr1, sta->sta.addr, ETH_ALEN);
  1493. memcpy(hdr.addr2, sdata->vif.addr, ETH_ALEN);
  1494. memcpy(hdr.addr3, skb->data, ETH_ALEN);
  1495. memcpy(hdr.addr4, skb->data + ETH_ALEN, ETH_ALEN);
  1496. hdrlen = 30;
  1497. sta_flags = get_sta_flags(sta);
  1498. }
  1499. rcu_read_unlock();
  1500. if (sta)
  1501. break;
  1502. /* fall through */
  1503. case NL80211_IFTYPE_AP:
  1504. fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS);
  1505. /* DA BSSID SA */
  1506. memcpy(hdr.addr1, skb->data, ETH_ALEN);
  1507. memcpy(hdr.addr2, sdata->vif.addr, ETH_ALEN);
  1508. memcpy(hdr.addr3, skb->data + ETH_ALEN, ETH_ALEN);
  1509. hdrlen = 24;
  1510. break;
  1511. case NL80211_IFTYPE_WDS:
  1512. fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS);
  1513. /* RA TA DA SA */
  1514. memcpy(hdr.addr1, sdata->u.wds.remote_addr, ETH_ALEN);
  1515. memcpy(hdr.addr2, sdata->vif.addr, ETH_ALEN);
  1516. memcpy(hdr.addr3, skb->data, ETH_ALEN);
  1517. memcpy(hdr.addr4, skb->data + ETH_ALEN, ETH_ALEN);
  1518. hdrlen = 30;
  1519. break;
  1520. #ifdef CONFIG_MAC80211_MESH
  1521. case NL80211_IFTYPE_MESH_POINT:
  1522. if (!sdata->u.mesh.mshcfg.dot11MeshTTL) {
  1523. /* Do not send frames with mesh_ttl == 0 */
  1524. sdata->u.mesh.mshstats.dropped_frames_ttl++;
  1525. ret = NETDEV_TX_OK;
  1526. goto fail;
  1527. }
  1528. if (compare_ether_addr(sdata->vif.addr,
  1529. skb->data + ETH_ALEN) == 0) {
  1530. hdrlen = ieee80211_fill_mesh_addresses(&hdr, &fc,
  1531. skb->data, skb->data + ETH_ALEN);
  1532. meshhdrlen = ieee80211_new_mesh_header(&mesh_hdr,
  1533. sdata, NULL, NULL, NULL);
  1534. } else {
  1535. /* packet from other interface */
  1536. struct mesh_path *mppath;
  1537. int is_mesh_mcast = 1;
  1538. const u8 *mesh_da;
  1539. rcu_read_lock();
  1540. if (is_multicast_ether_addr(skb->data))
  1541. /* DA TA mSA AE:SA */
  1542. mesh_da = skb->data;
  1543. else {
  1544. static const u8 bcast[ETH_ALEN] =
  1545. { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
  1546. mppath = mpp_path_lookup(skb->data, sdata);
  1547. if (mppath) {
  1548. /* RA TA mDA mSA AE:DA SA */
  1549. mesh_da = mppath->mpp;
  1550. is_mesh_mcast = 0;
  1551. } else {
  1552. /* DA TA mSA AE:SA */
  1553. mesh_da = bcast;
  1554. }
  1555. }
  1556. hdrlen = ieee80211_fill_mesh_addresses(&hdr, &fc,
  1557. mesh_da, sdata->vif.addr);
  1558. rcu_read_unlock();
  1559. if (is_mesh_mcast)
  1560. meshhdrlen =
  1561. ieee80211_new_mesh_header(&mesh_hdr,
  1562. sdata,
  1563. skb->data + ETH_ALEN,
  1564. NULL,
  1565. NULL);
  1566. else
  1567. meshhdrlen =
  1568. ieee80211_new_mesh_header(&mesh_hdr,
  1569. sdata,
  1570. NULL,
  1571. skb->data,
  1572. skb->data + ETH_ALEN);
  1573. }
  1574. break;
  1575. #endif
  1576. case NL80211_IFTYPE_STATION:
  1577. memcpy(hdr.addr1, sdata->u.mgd.bssid, ETH_ALEN);
  1578. if (sdata->u.mgd.use_4addr &&
  1579. cpu_to_be16(ethertype) != sdata->control_port_protocol) {
  1580. fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS);
  1581. /* RA TA DA SA */
  1582. memcpy(hdr.addr2, sdata->vif.addr, ETH_ALEN);
  1583. memcpy(hdr.addr3, skb->data, ETH_ALEN);
  1584. memcpy(hdr.addr4, skb->data + ETH_ALEN, ETH_ALEN);
  1585. hdrlen = 30;
  1586. } else {
  1587. fc |= cpu_to_le16(IEEE80211_FCTL_TODS);
  1588. /* BSSID SA DA */
  1589. memcpy(hdr.addr2, skb->data + ETH_ALEN, ETH_ALEN);
  1590. memcpy(hdr.addr3, skb->data, ETH_ALEN);
  1591. hdrlen = 24;
  1592. }
  1593. break;
  1594. case NL80211_IFTYPE_ADHOC:
  1595. /* DA SA BSSID */
  1596. memcpy(hdr.addr1, skb->data, ETH_ALEN);
  1597. memcpy(hdr.addr2, skb->data + ETH_ALEN, ETH_ALEN);
  1598. memcpy(hdr.addr3, sdata->u.ibss.bssid, ETH_ALEN);
  1599. hdrlen = 24;
  1600. break;
  1601. default:
  1602. ret = NETDEV_TX_OK;
  1603. goto fail;
  1604. }
  1605. /*
  1606. * There's no need to try to look up the destination
  1607. * if it is a multicast address (which can only happen
  1608. * in AP mode)
  1609. */
  1610. if (!is_multicast_ether_addr(hdr.addr1)) {
  1611. rcu_read_lock();
  1612. sta = sta_info_get(sdata, hdr.addr1);
  1613. if (sta)
  1614. sta_flags = get_sta_flags(sta);
  1615. rcu_read_unlock();
  1616. }
  1617. /* receiver and we are QoS enabled, use a QoS type frame */
  1618. if ((sta_flags & WLAN_STA_WME) && local->hw.queues >= 4) {
  1619. fc |= cpu_to_le16(IEEE80211_STYPE_QOS_DATA);
  1620. hdrlen += 2;
  1621. }
  1622. /*
  1623. * Drop unicast frames to unauthorised stations unless they are
  1624. * EAPOL frames from the local station.
  1625. */
  1626. if (!ieee80211_vif_is_mesh(&sdata->vif) &&
  1627. unlikely(!is_multicast_ether_addr(hdr.addr1) &&
  1628. !(sta_flags & WLAN_STA_AUTHORIZED) &&
  1629. !(cpu_to_be16(ethertype) == sdata->control_port_protocol &&
  1630. compare_ether_addr(sdata->vif.addr,
  1631. skb->data + ETH_ALEN) == 0))) {
  1632. #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
  1633. if (net_ratelimit())
  1634. printk(KERN_DEBUG "%s: dropped frame to %pM"
  1635. " (unauthorized port)\n", dev->name,
  1636. hdr.addr1);
  1637. #endif
  1638. I802_DEBUG_INC(local->tx_handlers_drop_unauth_port);
  1639. ret = NETDEV_TX_OK;
  1640. goto fail;
  1641. }
  1642. hdr.frame_control = fc;
  1643. hdr.duration_id = 0;
  1644. hdr.seq_ctrl = 0;
  1645. skip_header_bytes = ETH_HLEN;
  1646. if (ethertype == ETH_P_AARP || ethertype == ETH_P_IPX) {
  1647. encaps_data = bridge_tunnel_header;
  1648. encaps_len = sizeof(bridge_tunnel_header);
  1649. skip_header_bytes -= 2;
  1650. } else if (ethertype >= 0x600) {
  1651. encaps_data = rfc1042_header;
  1652. encaps_len = sizeof(rfc1042_header);
  1653. skip_header_bytes -= 2;
  1654. } else {
  1655. encaps_data = NULL;
  1656. encaps_len = 0;
  1657. }
  1658. skb_pull(skb, skip_header_bytes);
  1659. nh_pos -= skip_header_bytes;
  1660. h_pos -= skip_header_bytes;
  1661. head_need = hdrlen + encaps_len + meshhdrlen - skb_headroom(skb);
  1662. /*
  1663. * So we need to modify the skb header and hence need a copy of
  1664. * that. The head_need variable above doesn't, so far, include
  1665. * the needed header space that we don't need right away. If we
  1666. * can, then we don't reallocate right now but only after the
  1667. * frame arrives at the master device (if it does...)
  1668. *
  1669. * If we cannot, however, then we will reallocate to include all
  1670. * the ever needed space. Also, if we need to reallocate it anyway,
  1671. * make it big enough for everything we may ever need.
  1672. */
  1673. if (head_need > 0 || skb_cloned(skb)) {
  1674. head_need += IEEE80211_ENCRYPT_HEADROOM;
  1675. head_need += local->tx_headroom;
  1676. head_need = max_t(int, 0, head_need);
  1677. if (ieee80211_skb_resize(local, skb, head_need, true))
  1678. goto fail;
  1679. }
  1680. if (encaps_data) {
  1681. memcpy(skb_push(skb, encaps_len), encaps_data, encaps_len);
  1682. nh_pos += encaps_len;
  1683. h_pos += encaps_len;
  1684. }
  1685. #ifdef CONFIG_MAC80211_MESH
  1686. if (meshhdrlen > 0) {
  1687. memcpy(skb_push(skb, meshhdrlen), &mesh_hdr, meshhdrlen);
  1688. nh_pos += meshhdrlen;
  1689. h_pos += meshhdrlen;
  1690. }
  1691. #endif
  1692. if (ieee80211_is_data_qos(fc)) {
  1693. __le16 *qos_control;
  1694. qos_control = (__le16*) skb_push(skb, 2);
  1695. memcpy(skb_push(skb, hdrlen - 2), &hdr, hdrlen - 2);
  1696. /*
  1697. * Maybe we could actually set some fields here, for now just
  1698. * initialise to zero to indicate no special operation.
  1699. */
  1700. *qos_control = 0;
  1701. } else
  1702. memcpy(skb_push(skb, hdrlen), &hdr, hdrlen);
  1703. nh_pos += hdrlen;
  1704. h_pos += hdrlen;
  1705. dev->stats.tx_packets++;
  1706. dev->stats.tx_bytes += skb->len;
  1707. /* Update skb pointers to various headers since this modified frame
  1708. * is going to go through Linux networking code that may potentially
  1709. * need things like pointer to IP header. */
  1710. skb_set_mac_header(skb, 0);
  1711. skb_set_network_header(skb, nh_pos);
  1712. skb_set_transport_header(skb, h_pos);
  1713. memset(info, 0, sizeof(*info));
  1714. dev->trans_start = jiffies;
  1715. ieee80211_xmit(sdata, skb);
  1716. return NETDEV_TX_OK;
  1717. fail:
  1718. if (ret == NETDEV_TX_OK)
  1719. dev_kfree_skb(skb);
  1720. return ret;
  1721. }
  1722. /*
  1723. * ieee80211_clear_tx_pending may not be called in a context where
  1724. * it is possible that it packets could come in again.
  1725. */
  1726. void ieee80211_clear_tx_pending(struct ieee80211_local *local)
  1727. {
  1728. int i;
  1729. for (i = 0; i < local->hw.queues; i++)
  1730. skb_queue_purge(&local->pending[i]);
  1731. }
  1732. static bool ieee80211_tx_pending_skb(struct ieee80211_local *local,
  1733. struct sk_buff *skb)
  1734. {
  1735. struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
  1736. struct ieee80211_sub_if_data *sdata;
  1737. struct sta_info *sta;
  1738. struct ieee80211_hdr *hdr;
  1739. int ret;
  1740. bool result = true;
  1741. sdata = vif_to_sdata(info->control.vif);
  1742. if (info->flags & IEEE80211_TX_INTFL_NEED_TXPROCESSING) {
  1743. ieee80211_tx(sdata, skb, true);
  1744. } else {
  1745. hdr = (struct ieee80211_hdr *)skb->data;
  1746. sta = sta_info_get(sdata, hdr->addr1);
  1747. ret = __ieee80211_tx(local, &skb, sta, true);
  1748. if (ret != IEEE80211_TX_OK)
  1749. result = false;
  1750. }
  1751. return result;
  1752. }
  1753. /*
  1754. * Transmit all pending packets. Called from tasklet.
  1755. */
  1756. void ieee80211_tx_pending(unsigned long data)
  1757. {
  1758. struct ieee80211_local *local = (struct ieee80211_local *)data;
  1759. struct ieee80211_sub_if_data *sdata;
  1760. unsigned long flags;
  1761. int i;
  1762. bool txok;
  1763. rcu_read_lock();
  1764. spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
  1765. for (i = 0; i < local->hw.queues; i++) {
  1766. /*
  1767. * If queue is stopped by something other than due to pending
  1768. * frames, or we have no pending frames, proceed to next queue.
  1769. */
  1770. if (local->queue_stop_reasons[i] ||
  1771. skb_queue_empty(&local->pending[i]))
  1772. continue;
  1773. while (!skb_queue_empty(&local->pending[i])) {
  1774. struct sk_buff *skb = __skb_dequeue(&local->pending[i]);
  1775. struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
  1776. if (WARN_ON(!info->control.vif)) {
  1777. kfree_skb(skb);
  1778. continue;
  1779. }
  1780. spin_unlock_irqrestore(&local->queue_stop_reason_lock,
  1781. flags);
  1782. txok = ieee80211_tx_pending_skb(local, skb);
  1783. if (!txok)
  1784. __skb_queue_head(&local->pending[i], skb);
  1785. spin_lock_irqsave(&local->queue_stop_reason_lock,
  1786. flags);
  1787. if (!txok)
  1788. break;
  1789. }
  1790. if (skb_queue_empty(&local->pending[i]))
  1791. list_for_each_entry_rcu(sdata, &local->interfaces, list)
  1792. netif_wake_subqueue(sdata->dev, i);
  1793. }
  1794. spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
  1795. rcu_read_unlock();
  1796. }
  1797. /* functions for drivers to get certain frames */
  1798. static void ieee80211_beacon_add_tim(struct ieee80211_if_ap *bss,
  1799. struct sk_buff *skb,
  1800. struct beacon_data *beacon)
  1801. {
  1802. u8 *pos, *tim;
  1803. int aid0 = 0;
  1804. int i, have_bits = 0, n1, n2;
  1805. /* Generate bitmap for TIM only if there are any STAs in power save
  1806. * mode. */
  1807. if (atomic_read(&bss->num_sta_ps) > 0)
  1808. /* in the hope that this is faster than
  1809. * checking byte-for-byte */
  1810. have_bits = !bitmap_empty((unsigned long*)bss->tim,
  1811. IEEE80211_MAX_AID+1);
  1812. if (bss->dtim_count == 0)
  1813. bss->dtim_count = beacon->dtim_period - 1;
  1814. else
  1815. bss->dtim_count--;
  1816. tim = pos = (u8 *) skb_put(skb, 6);
  1817. *pos++ = WLAN_EID_TIM;
  1818. *pos++ = 4;
  1819. *pos++ = bss->dtim_count;
  1820. *pos++ = beacon->dtim_period;
  1821. if (bss->dtim_count == 0 && !skb_queue_empty(&bss->ps_bc_buf))
  1822. aid0 = 1;
  1823. if (have_bits) {
  1824. /* Find largest even number N1 so that bits numbered 1 through
  1825. * (N1 x 8) - 1 in the bitmap are 0 and number N2 so that bits
  1826. * (N2 + 1) x 8 through 2007 are 0. */
  1827. n1 = 0;
  1828. for (i = 0; i < IEEE80211_MAX_TIM_LEN; i++) {
  1829. if (bss->tim[i]) {
  1830. n1 = i & 0xfe;
  1831. break;
  1832. }
  1833. }
  1834. n2 = n1;
  1835. for (i = IEEE80211_MAX_TIM_LEN - 1; i >= n1; i--) {
  1836. if (bss->tim[i]) {
  1837. n2 = i;
  1838. break;
  1839. }
  1840. }
  1841. /* Bitmap control */
  1842. *pos++ = n1 | aid0;
  1843. /* Part Virt Bitmap */
  1844. memcpy(pos, bss->tim + n1, n2 - n1 + 1);
  1845. tim[1] = n2 - n1 + 4;
  1846. skb_put(skb, n2 - n1);
  1847. } else {
  1848. *pos++ = aid0; /* Bitmap control */
  1849. *pos++ = 0; /* Part Virt Bitmap */
  1850. }
  1851. }
  1852. struct sk_buff *ieee80211_beacon_get_tim(struct ieee80211_hw *hw,
  1853. struct ieee80211_vif *vif,
  1854. u16 *tim_offset, u16 *tim_length)
  1855. {
  1856. struct ieee80211_local *local = hw_to_local(hw);
  1857. struct sk_buff *skb = NULL;
  1858. struct ieee80211_tx_info *info;
  1859. struct ieee80211_sub_if_data *sdata = NULL;
  1860. struct ieee80211_if_ap *ap = NULL;
  1861. struct beacon_data *beacon;
  1862. struct ieee80211_supported_band *sband;
  1863. enum ieee80211_band band = local->hw.conf.channel->band;
  1864. struct ieee80211_tx_rate_control txrc;
  1865. sband = local->hw.wiphy->bands[band];
  1866. rcu_read_lock();
  1867. sdata = vif_to_sdata(vif);
  1868. if (tim_offset)
  1869. *tim_offset = 0;
  1870. if (tim_length)
  1871. *tim_length = 0;
  1872. if (sdata->vif.type == NL80211_IFTYPE_AP) {
  1873. ap = &sdata->u.ap;
  1874. beacon = rcu_dereference(ap->beacon);
  1875. if (ap && beacon) {
  1876. /*
  1877. * headroom, head length,
  1878. * tail length and maximum TIM length
  1879. */
  1880. skb = dev_alloc_skb(local->tx_headroom +
  1881. beacon->head_len +
  1882. beacon->tail_len + 256);
  1883. if (!skb)
  1884. goto out;
  1885. skb_reserve(skb, local->tx_headroom);
  1886. memcpy(skb_put(skb, beacon->head_len), beacon->head,
  1887. beacon->head_len);
  1888. /*
  1889. * Not very nice, but we want to allow the driver to call
  1890. * ieee80211_beacon_get() as a response to the set_tim()
  1891. * callback. That, however, is already invoked under the
  1892. * sta_lock to guarantee consistent and race-free update
  1893. * of the tim bitmap in mac80211 and the driver.
  1894. */
  1895. if (local->tim_in_locked_section) {
  1896. ieee80211_beacon_add_tim(ap, skb, beacon);
  1897. } else {
  1898. unsigned long flags;
  1899. spin_lock_irqsave(&local->sta_lock, flags);
  1900. ieee80211_beacon_add_tim(ap, skb, beacon);
  1901. spin_unlock_irqrestore(&local->sta_lock, flags);
  1902. }
  1903. if (tim_offset)
  1904. *tim_offset = beacon->head_len;
  1905. if (tim_length)
  1906. *tim_length = skb->len - beacon->head_len;
  1907. if (beacon->tail)
  1908. memcpy(skb_put(skb, beacon->tail_len),
  1909. beacon->tail, beacon->tail_len);
  1910. } else
  1911. goto out;
  1912. } else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) {
  1913. struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
  1914. struct ieee80211_hdr *hdr;
  1915. struct sk_buff *presp = rcu_dereference(ifibss->presp);
  1916. if (!presp)
  1917. goto out;
  1918. skb = skb_copy(presp, GFP_ATOMIC);
  1919. if (!skb)
  1920. goto out;
  1921. hdr = (struct ieee80211_hdr *) skb->data;
  1922. hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
  1923. IEEE80211_STYPE_BEACON);
  1924. } else if (ieee80211_vif_is_mesh(&sdata->vif)) {
  1925. struct ieee80211_mgmt *mgmt;
  1926. u8 *pos;
  1927. /* headroom, head length, tail length and maximum TIM length */
  1928. skb = dev_alloc_skb(local->tx_headroom + 400);
  1929. if (!skb)
  1930. goto out;
  1931. skb_reserve(skb, local->hw.extra_tx_headroom);
  1932. mgmt = (struct ieee80211_mgmt *)
  1933. skb_put(skb, 24 + sizeof(mgmt->u.beacon));
  1934. memset(mgmt, 0, 24 + sizeof(mgmt->u.beacon));
  1935. mgmt->frame_control =
  1936. cpu_to_le16(IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_BEACON);
  1937. memset(mgmt->da, 0xff, ETH_ALEN);
  1938. memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
  1939. memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN);
  1940. mgmt->u.beacon.beacon_int =
  1941. cpu_to_le16(sdata->vif.bss_conf.beacon_int);
  1942. mgmt->u.beacon.capab_info = 0x0; /* 0x0 for MPs */
  1943. pos = skb_put(skb, 2);
  1944. *pos++ = WLAN_EID_SSID;
  1945. *pos++ = 0x0;
  1946. mesh_mgmt_ies_add(skb, sdata);
  1947. } else {
  1948. WARN_ON(1);
  1949. goto out;
  1950. }
  1951. info = IEEE80211_SKB_CB(skb);
  1952. info->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
  1953. info->flags |= IEEE80211_TX_CTL_NO_ACK;
  1954. info->band = band;
  1955. memset(&txrc, 0, sizeof(txrc));
  1956. txrc.hw = hw;
  1957. txrc.sband = sband;
  1958. txrc.bss_conf = &sdata->vif.bss_conf;
  1959. txrc.skb = skb;
  1960. txrc.reported_rate.idx = -1;
  1961. txrc.rate_idx_mask = sdata->rc_rateidx_mask[band];
  1962. if (txrc.rate_idx_mask == (1 << sband->n_bitrates) - 1)
  1963. txrc.max_rate_idx = -1;
  1964. else
  1965. txrc.max_rate_idx = fls(txrc.rate_idx_mask) - 1;
  1966. txrc.ap = true;
  1967. rate_control_get_rate(sdata, NULL, &txrc);
  1968. info->control.vif = vif;
  1969. info->flags |= IEEE80211_TX_CTL_CLEAR_PS_FILT |
  1970. IEEE80211_TX_CTL_ASSIGN_SEQ |
  1971. IEEE80211_TX_CTL_FIRST_FRAGMENT;
  1972. out:
  1973. rcu_read_unlock();
  1974. return skb;
  1975. }
  1976. EXPORT_SYMBOL(ieee80211_beacon_get_tim);
  1977. struct sk_buff *ieee80211_pspoll_get(struct ieee80211_hw *hw,
  1978. struct ieee80211_vif *vif)
  1979. {
  1980. struct ieee80211_sub_if_data *sdata;
  1981. struct ieee80211_if_managed *ifmgd;
  1982. struct ieee80211_pspoll *pspoll;
  1983. struct ieee80211_local *local;
  1984. struct sk_buff *skb;
  1985. if (WARN_ON(vif->type != NL80211_IFTYPE_STATION))
  1986. return NULL;
  1987. sdata = vif_to_sdata(vif);
  1988. ifmgd = &sdata->u.mgd;
  1989. local = sdata->local;
  1990. skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*pspoll));
  1991. if (!skb) {
  1992. printk(KERN_DEBUG "%s: failed to allocate buffer for "
  1993. "pspoll template\n", sdata->name);
  1994. return NULL;
  1995. }
  1996. skb_reserve(skb, local->hw.extra_tx_headroom);
  1997. pspoll = (struct ieee80211_pspoll *) skb_put(skb, sizeof(*pspoll));
  1998. memset(pspoll, 0, sizeof(*pspoll));
  1999. pspoll->frame_control = cpu_to_le16(IEEE80211_FTYPE_CTL |
  2000. IEEE80211_STYPE_PSPOLL);
  2001. pspoll->aid = cpu_to_le16(ifmgd->aid);
  2002. /* aid in PS-Poll has its two MSBs each set to 1 */
  2003. pspoll->aid |= cpu_to_le16(1 << 15 | 1 << 14);
  2004. memcpy(pspoll->bssid, ifmgd->bssid, ETH_ALEN);
  2005. memcpy(pspoll->ta, vif->addr, ETH_ALEN);
  2006. return skb;
  2007. }
  2008. EXPORT_SYMBOL(ieee80211_pspoll_get);
  2009. struct sk_buff *ieee80211_nullfunc_get(struct ieee80211_hw *hw,
  2010. struct ieee80211_vif *vif)
  2011. {
  2012. struct ieee80211_hdr_3addr *nullfunc;
  2013. struct ieee80211_sub_if_data *sdata;
  2014. struct ieee80211_if_managed *ifmgd;
  2015. struct ieee80211_local *local;
  2016. struct sk_buff *skb;
  2017. if (WARN_ON(vif->type != NL80211_IFTYPE_STATION))
  2018. return NULL;
  2019. sdata = vif_to_sdata(vif);
  2020. ifmgd = &sdata->u.mgd;
  2021. local = sdata->local;
  2022. skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*nullfunc));
  2023. if (!skb) {
  2024. printk(KERN_DEBUG "%s: failed to allocate buffer for nullfunc "
  2025. "template\n", sdata->name);
  2026. return NULL;
  2027. }
  2028. skb_reserve(skb, local->hw.extra_tx_headroom);
  2029. nullfunc = (struct ieee80211_hdr_3addr *) skb_put(skb,
  2030. sizeof(*nullfunc));
  2031. memset(nullfunc, 0, sizeof(*nullfunc));
  2032. nullfunc->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
  2033. IEEE80211_STYPE_NULLFUNC |
  2034. IEEE80211_FCTL_TODS);
  2035. memcpy(nullfunc->addr1, ifmgd->bssid, ETH_ALEN);
  2036. memcpy(nullfunc->addr2, vif->addr, ETH_ALEN);
  2037. memcpy(nullfunc->addr3, ifmgd->bssid, ETH_ALEN);
  2038. return skb;
  2039. }
  2040. EXPORT_SYMBOL(ieee80211_nullfunc_get);
  2041. struct sk_buff *ieee80211_probereq_get(struct ieee80211_hw *hw,
  2042. struct ieee80211_vif *vif,
  2043. const u8 *ssid, size_t ssid_len,
  2044. const u8 *ie, size_t ie_len)
  2045. {
  2046. struct ieee80211_sub_if_data *sdata;
  2047. struct ieee80211_local *local;
  2048. struct ieee80211_hdr_3addr *hdr;
  2049. struct sk_buff *skb;
  2050. size_t ie_ssid_len;
  2051. u8 *pos;
  2052. sdata = vif_to_sdata(vif);
  2053. local = sdata->local;
  2054. ie_ssid_len = 2 + ssid_len;
  2055. skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*hdr) +
  2056. ie_ssid_len + ie_len);
  2057. if (!skb) {
  2058. printk(KERN_DEBUG "%s: failed to allocate buffer for probe "
  2059. "request template\n", sdata->name);
  2060. return NULL;
  2061. }
  2062. skb_reserve(skb, local->hw.extra_tx_headroom);
  2063. hdr = (struct ieee80211_hdr_3addr *) skb_put(skb, sizeof(*hdr));
  2064. memset(hdr, 0, sizeof(*hdr));
  2065. hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
  2066. IEEE80211_STYPE_PROBE_REQ);
  2067. memset(hdr->addr1, 0xff, ETH_ALEN);
  2068. memcpy(hdr->addr2, vif->addr, ETH_ALEN);
  2069. memset(hdr->addr3, 0xff, ETH_ALEN);
  2070. pos = skb_put(skb, ie_ssid_len);
  2071. *pos++ = WLAN_EID_SSID;
  2072. *pos++ = ssid_len;
  2073. if (ssid)
  2074. memcpy(pos, ssid, ssid_len);
  2075. pos += ssid_len;
  2076. if (ie) {
  2077. pos = skb_put(skb, ie_len);
  2078. memcpy(pos, ie, ie_len);
  2079. }
  2080. return skb;
  2081. }
  2082. EXPORT_SYMBOL(ieee80211_probereq_get);
  2083. void ieee80211_rts_get(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
  2084. const void *frame, size_t frame_len,
  2085. const struct ieee80211_tx_info *frame_txctl,
  2086. struct ieee80211_rts *rts)
  2087. {
  2088. const struct ieee80211_hdr *hdr = frame;
  2089. rts->frame_control =
  2090. cpu_to_le16(IEEE80211_FTYPE_CTL | IEEE80211_STYPE_RTS);
  2091. rts->duration = ieee80211_rts_duration(hw, vif, frame_len,
  2092. frame_txctl);
  2093. memcpy(rts->ra, hdr->addr1, sizeof(rts->ra));
  2094. memcpy(rts->ta, hdr->addr2, sizeof(rts->ta));
  2095. }
  2096. EXPORT_SYMBOL(ieee80211_rts_get);
  2097. void ieee80211_ctstoself_get(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
  2098. const void *frame, size_t frame_len,
  2099. const struct ieee80211_tx_info *frame_txctl,
  2100. struct ieee80211_cts *cts)
  2101. {
  2102. const struct ieee80211_hdr *hdr = frame;
  2103. cts->frame_control =
  2104. cpu_to_le16(IEEE80211_FTYPE_CTL | IEEE80211_STYPE_CTS);
  2105. cts->duration = ieee80211_ctstoself_duration(hw, vif,
  2106. frame_len, frame_txctl);
  2107. memcpy(cts->ra, hdr->addr1, sizeof(cts->ra));
  2108. }
  2109. EXPORT_SYMBOL(ieee80211_ctstoself_get);
  2110. struct sk_buff *
  2111. ieee80211_get_buffered_bc(struct ieee80211_hw *hw,
  2112. struct ieee80211_vif *vif)
  2113. {
  2114. struct ieee80211_local *local = hw_to_local(hw);
  2115. struct sk_buff *skb = NULL;
  2116. struct sta_info *sta;
  2117. struct ieee80211_tx_data tx;
  2118. struct ieee80211_sub_if_data *sdata;
  2119. struct ieee80211_if_ap *bss = NULL;
  2120. struct beacon_data *beacon;
  2121. struct ieee80211_tx_info *info;
  2122. sdata = vif_to_sdata(vif);
  2123. bss = &sdata->u.ap;
  2124. rcu_read_lock();
  2125. beacon = rcu_dereference(bss->beacon);
  2126. if (sdata->vif.type != NL80211_IFTYPE_AP || !beacon || !beacon->head)
  2127. goto out;
  2128. if (bss->dtim_count != 0)
  2129. goto out; /* send buffered bc/mc only after DTIM beacon */
  2130. while (1) {
  2131. skb = skb_dequeue(&bss->ps_bc_buf);
  2132. if (!skb)
  2133. goto out;
  2134. local->total_ps_buffered--;
  2135. if (!skb_queue_empty(&bss->ps_bc_buf) && skb->len >= 2) {
  2136. struct ieee80211_hdr *hdr =
  2137. (struct ieee80211_hdr *) skb->data;
  2138. /* more buffered multicast/broadcast frames ==> set
  2139. * MoreData flag in IEEE 802.11 header to inform PS
  2140. * STAs */
  2141. hdr->frame_control |=
  2142. cpu_to_le16(IEEE80211_FCTL_MOREDATA);
  2143. }
  2144. if (!ieee80211_tx_prepare(sdata, &tx, skb))
  2145. break;
  2146. dev_kfree_skb_any(skb);
  2147. }
  2148. info = IEEE80211_SKB_CB(skb);
  2149. sta = tx.sta;
  2150. tx.flags |= IEEE80211_TX_PS_BUFFERED;
  2151. tx.channel = local->hw.conf.channel;
  2152. info->band = tx.channel->band;
  2153. if (invoke_tx_handlers(&tx))
  2154. skb = NULL;
  2155. out:
  2156. rcu_read_unlock();
  2157. return skb;
  2158. }
  2159. EXPORT_SYMBOL(ieee80211_get_buffered_bc);
  2160. void ieee80211_tx_skb(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb)
  2161. {
  2162. skb_set_mac_header(skb, 0);
  2163. skb_set_network_header(skb, 0);
  2164. skb_set_transport_header(skb, 0);
  2165. /* send all internal mgmt frames on VO */
  2166. skb_set_queue_mapping(skb, 0);
  2167. /*
  2168. * The other path calling ieee80211_xmit is from the tasklet,
  2169. * and while we can handle concurrent transmissions locking
  2170. * requirements are that we do not come into tx with bhs on.
  2171. */
  2172. local_bh_disable();
  2173. ieee80211_xmit(sdata, skb);
  2174. local_bh_enable();
  2175. }