1
2
3
4
5
6
7
8
9
10
11
12#include <linux/slab.h>
13#include <asm/unaligned.h>
14#include "ieee80211_i.h"
15#include "mesh.h"
16#include "driver-ops.h"
17
18static int mesh_allocated;
19static struct kmem_cache *rm_cache;
20
21bool mesh_action_is_path_sel(struct ieee80211_mgmt *mgmt)
22{
23 return (mgmt->u.action.u.mesh_action.action_code ==
24 WLAN_MESH_ACTION_HWMP_PATH_SELECTION);
25}
26
27void ieee80211s_init(void)
28{
29 mesh_allocated = 1;
30 rm_cache = kmem_cache_create("mesh_rmc", sizeof(struct rmc_entry),
31 0, 0, NULL);
32}
33
34void ieee80211s_stop(void)
35{
36 if (!mesh_allocated)
37 return;
38 kmem_cache_destroy(rm_cache);
39}
40
41static void ieee80211_mesh_housekeeping_timer(struct timer_list *t)
42{
43 struct ieee80211_sub_if_data *sdata =
44 from_timer(sdata, t, u.mesh.housekeeping_timer);
45 struct ieee80211_local *local = sdata->local;
46 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
47
48 set_bit(MESH_WORK_HOUSEKEEPING, &ifmsh->wrkq_flags);
49
50 ieee80211_queue_work(&local->hw, &sdata->work);
51}
52
53
54
55
56
57
58
59
60
61
62bool mesh_matches_local(struct ieee80211_sub_if_data *sdata,
63 struct ieee802_11_elems *ie)
64{
65 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
66 u32 basic_rates = 0;
67 struct cfg80211_chan_def sta_chan_def;
68 struct ieee80211_supported_band *sband;
69
70
71
72
73
74
75
76
77
78
79
80 if (!(ifmsh->mesh_id_len == ie->mesh_id_len &&
81 memcmp(ifmsh->mesh_id, ie->mesh_id, ie->mesh_id_len) == 0 &&
82 (ifmsh->mesh_pp_id == ie->mesh_config->meshconf_psel) &&
83 (ifmsh->mesh_pm_id == ie->mesh_config->meshconf_pmetric) &&
84 (ifmsh->mesh_cc_id == ie->mesh_config->meshconf_congest) &&
85 (ifmsh->mesh_sp_id == ie->mesh_config->meshconf_synch) &&
86 (ifmsh->mesh_auth_id == ie->mesh_config->meshconf_auth)))
87 return false;
88
89 sband = ieee80211_get_sband(sdata);
90 if (!sband)
91 return false;
92
93 ieee80211_sta_get_rates(sdata, ie, sband->band,
94 &basic_rates);
95
96 if (sdata->vif.bss_conf.basic_rates != basic_rates)
97 return false;
98
99 cfg80211_chandef_create(&sta_chan_def, sdata->vif.bss_conf.chandef.chan,
100 NL80211_CHAN_NO_HT);
101 ieee80211_chandef_ht_oper(ie->ht_operation, &sta_chan_def);
102 ieee80211_chandef_vht_oper(&sdata->local->hw,
103 ie->vht_operation, ie->ht_operation,
104 &sta_chan_def);
105
106 if (!cfg80211_chandef_compatible(&sdata->vif.bss_conf.chandef,
107 &sta_chan_def))
108 return false;
109
110 return true;
111}
112
113
114
115
116
117
118bool mesh_peer_accepts_plinks(struct ieee802_11_elems *ie)
119{
120 return (ie->mesh_config->meshconf_cap &
121 IEEE80211_MESHCONF_CAPAB_ACCEPT_PLINKS) != 0;
122}
123
124
125
126
127
128
129
130
131u32 mesh_accept_plinks_update(struct ieee80211_sub_if_data *sdata)
132{
133 bool free_plinks;
134 u32 changed = 0;
135
136
137
138
139
140
141
142 free_plinks = mesh_plink_availables(sdata);
143
144 if (free_plinks != sdata->u.mesh.accepting_plinks) {
145 sdata->u.mesh.accepting_plinks = free_plinks;
146 changed = BSS_CHANGED_BEACON;
147 }
148
149 return changed;
150}
151
152
153
154
155
156
157void mesh_sta_cleanup(struct sta_info *sta)
158{
159 struct ieee80211_sub_if_data *sdata = sta->sdata;
160 u32 changed = mesh_plink_deactivate(sta);
161
162 if (changed)
163 ieee80211_mbss_info_change_notify(sdata, changed);
164}
165
166int mesh_rmc_init(struct ieee80211_sub_if_data *sdata)
167{
168 int i;
169
170 sdata->u.mesh.rmc = kmalloc(sizeof(struct mesh_rmc), GFP_KERNEL);
171 if (!sdata->u.mesh.rmc)
172 return -ENOMEM;
173 sdata->u.mesh.rmc->idx_mask = RMC_BUCKETS - 1;
174 for (i = 0; i < RMC_BUCKETS; i++)
175 INIT_HLIST_HEAD(&sdata->u.mesh.rmc->bucket[i]);
176 return 0;
177}
178
179void mesh_rmc_free(struct ieee80211_sub_if_data *sdata)
180{
181 struct mesh_rmc *rmc = sdata->u.mesh.rmc;
182 struct rmc_entry *p;
183 struct hlist_node *n;
184 int i;
185
186 if (!sdata->u.mesh.rmc)
187 return;
188
189 for (i = 0; i < RMC_BUCKETS; i++) {
190 hlist_for_each_entry_safe(p, n, &rmc->bucket[i], list) {
191 hlist_del(&p->list);
192 kmem_cache_free(rm_cache, p);
193 }
194 }
195
196 kfree(rmc);
197 sdata->u.mesh.rmc = NULL;
198}
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213int mesh_rmc_check(struct ieee80211_sub_if_data *sdata,
214 const u8 *sa, struct ieee80211s_hdr *mesh_hdr)
215{
216 struct mesh_rmc *rmc = sdata->u.mesh.rmc;
217 u32 seqnum = 0;
218 int entries = 0;
219 u8 idx;
220 struct rmc_entry *p;
221 struct hlist_node *n;
222
223 if (!rmc)
224 return -1;
225
226
227 memcpy(&seqnum, &mesh_hdr->seqnum, sizeof(mesh_hdr->seqnum));
228 idx = le32_to_cpu(mesh_hdr->seqnum) & rmc->idx_mask;
229 hlist_for_each_entry_safe(p, n, &rmc->bucket[idx], list) {
230 ++entries;
231 if (time_after(jiffies, p->exp_time) ||
232 entries == RMC_QUEUE_MAX_LEN) {
233 hlist_del(&p->list);
234 kmem_cache_free(rm_cache, p);
235 --entries;
236 } else if ((seqnum == p->seqnum) && ether_addr_equal(sa, p->sa))
237 return -1;
238 }
239
240 p = kmem_cache_alloc(rm_cache, GFP_ATOMIC);
241 if (!p)
242 return 0;
243
244 p->seqnum = seqnum;
245 p->exp_time = jiffies + RMC_TIMEOUT;
246 memcpy(p->sa, sa, ETH_ALEN);
247 hlist_add_head(&p->list, &rmc->bucket[idx]);
248 return 0;
249}
250
251int mesh_add_meshconf_ie(struct ieee80211_sub_if_data *sdata,
252 struct sk_buff *skb)
253{
254 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
255 u8 *pos, neighbors;
256 u8 meshconf_len = sizeof(struct ieee80211_meshconf_ie);
257 bool is_connected_to_gate = ifmsh->num_gates > 0 ||
258 ifmsh->mshcfg.dot11MeshGateAnnouncementProtocol ||
259 ifmsh->mshcfg.dot11MeshConnectedToMeshGate;
260
261 if (skb_tailroom(skb) < 2 + meshconf_len)
262 return -ENOMEM;
263
264 pos = skb_put(skb, 2 + meshconf_len);
265 *pos++ = WLAN_EID_MESH_CONFIG;
266 *pos++ = meshconf_len;
267
268
269 ifmsh->meshconf_offset = pos - skb->data;
270
271
272 *pos++ = ifmsh->mesh_pp_id;
273
274 *pos++ = ifmsh->mesh_pm_id;
275
276 *pos++ = ifmsh->mesh_cc_id;
277
278 *pos++ = ifmsh->mesh_sp_id;
279
280 *pos++ = ifmsh->mesh_auth_id;
281
282 neighbors = atomic_read(&ifmsh->estab_plinks);
283 neighbors = min_t(int, neighbors, IEEE80211_MAX_MESH_PEERINGS);
284 *pos++ = (neighbors << 1) | is_connected_to_gate;
285
286 *pos = 0x00;
287 *pos |= ifmsh->mshcfg.dot11MeshForwarding ?
288 IEEE80211_MESHCONF_CAPAB_FORWARDING : 0x00;
289 *pos |= ifmsh->accepting_plinks ?
290 IEEE80211_MESHCONF_CAPAB_ACCEPT_PLINKS : 0x00;
291
292 *pos |= ifmsh->ps_peers_deep_sleep ?
293 IEEE80211_MESHCONF_CAPAB_POWER_SAVE_LEVEL : 0x00;
294 return 0;
295}
296
297int mesh_add_meshid_ie(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb)
298{
299 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
300 u8 *pos;
301
302 if (skb_tailroom(skb) < 2 + ifmsh->mesh_id_len)
303 return -ENOMEM;
304
305 pos = skb_put(skb, 2 + ifmsh->mesh_id_len);
306 *pos++ = WLAN_EID_MESH_ID;
307 *pos++ = ifmsh->mesh_id_len;
308 if (ifmsh->mesh_id_len)
309 memcpy(pos, ifmsh->mesh_id, ifmsh->mesh_id_len);
310
311 return 0;
312}
313
314static int mesh_add_awake_window_ie(struct ieee80211_sub_if_data *sdata,
315 struct sk_buff *skb)
316{
317 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
318 u8 *pos;
319
320
321 if (ifmsh->ps_peers_light_sleep == 0 &&
322 ifmsh->ps_peers_deep_sleep == 0 &&
323 ifmsh->nonpeer_pm == NL80211_MESH_POWER_ACTIVE)
324 return 0;
325
326 if (skb_tailroom(skb) < 4)
327 return -ENOMEM;
328
329 pos = skb_put(skb, 2 + 2);
330 *pos++ = WLAN_EID_MESH_AWAKE_WINDOW;
331 *pos++ = 2;
332 put_unaligned_le16(ifmsh->mshcfg.dot11MeshAwakeWindowDuration, pos);
333
334 return 0;
335}
336
337int mesh_add_vendor_ies(struct ieee80211_sub_if_data *sdata,
338 struct sk_buff *skb)
339{
340 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
341 u8 offset, len;
342 const u8 *data;
343
344 if (!ifmsh->ie || !ifmsh->ie_len)
345 return 0;
346
347
348 offset = ieee80211_ie_split_vendor(ifmsh->ie, ifmsh->ie_len, 0);
349
350 if (offset < ifmsh->ie_len) {
351 len = ifmsh->ie_len - offset;
352 data = ifmsh->ie + offset;
353 if (skb_tailroom(skb) < len)
354 return -ENOMEM;
355 skb_put_data(skb, data, len);
356 }
357
358 return 0;
359}
360
361int mesh_add_rsn_ie(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb)
362{
363 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
364 u8 len = 0;
365 const u8 *data;
366
367 if (!ifmsh->ie || !ifmsh->ie_len)
368 return 0;
369
370
371 data = cfg80211_find_ie(WLAN_EID_RSN, ifmsh->ie, ifmsh->ie_len);
372 if (!data)
373 return 0;
374
375 len = data[1] + 2;
376
377 if (skb_tailroom(skb) < len)
378 return -ENOMEM;
379 skb_put_data(skb, data, len);
380
381 return 0;
382}
383
384static int mesh_add_ds_params_ie(struct ieee80211_sub_if_data *sdata,
385 struct sk_buff *skb)
386{
387 struct ieee80211_chanctx_conf *chanctx_conf;
388 struct ieee80211_channel *chan;
389 u8 *pos;
390
391 if (skb_tailroom(skb) < 3)
392 return -ENOMEM;
393
394 rcu_read_lock();
395 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
396 if (WARN_ON(!chanctx_conf)) {
397 rcu_read_unlock();
398 return -EINVAL;
399 }
400 chan = chanctx_conf->def.chan;
401 rcu_read_unlock();
402
403 pos = skb_put(skb, 2 + 1);
404 *pos++ = WLAN_EID_DS_PARAMS;
405 *pos++ = 1;
406 *pos++ = ieee80211_frequency_to_channel(chan->center_freq);
407
408 return 0;
409}
410
411int mesh_add_ht_cap_ie(struct ieee80211_sub_if_data *sdata,
412 struct sk_buff *skb)
413{
414 struct ieee80211_supported_band *sband;
415 u8 *pos;
416
417 sband = ieee80211_get_sband(sdata);
418 if (!sband)
419 return -EINVAL;
420
421 if (!sband->ht_cap.ht_supported ||
422 sdata->vif.bss_conf.chandef.width == NL80211_CHAN_WIDTH_20_NOHT ||
423 sdata->vif.bss_conf.chandef.width == NL80211_CHAN_WIDTH_5 ||
424 sdata->vif.bss_conf.chandef.width == NL80211_CHAN_WIDTH_10)
425 return 0;
426
427 if (skb_tailroom(skb) < 2 + sizeof(struct ieee80211_ht_cap))
428 return -ENOMEM;
429
430 pos = skb_put(skb, 2 + sizeof(struct ieee80211_ht_cap));
431 ieee80211_ie_build_ht_cap(pos, &sband->ht_cap, sband->ht_cap.cap);
432
433 return 0;
434}
435
436int mesh_add_ht_oper_ie(struct ieee80211_sub_if_data *sdata,
437 struct sk_buff *skb)
438{
439 struct ieee80211_local *local = sdata->local;
440 struct ieee80211_chanctx_conf *chanctx_conf;
441 struct ieee80211_channel *channel;
442 struct ieee80211_supported_band *sband;
443 struct ieee80211_sta_ht_cap *ht_cap;
444 u8 *pos;
445
446 rcu_read_lock();
447 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
448 if (WARN_ON(!chanctx_conf)) {
449 rcu_read_unlock();
450 return -EINVAL;
451 }
452 channel = chanctx_conf->def.chan;
453 rcu_read_unlock();
454
455 sband = local->hw.wiphy->bands[channel->band];
456 ht_cap = &sband->ht_cap;
457
458 if (!ht_cap->ht_supported ||
459 sdata->vif.bss_conf.chandef.width == NL80211_CHAN_WIDTH_20_NOHT ||
460 sdata->vif.bss_conf.chandef.width == NL80211_CHAN_WIDTH_5 ||
461 sdata->vif.bss_conf.chandef.width == NL80211_CHAN_WIDTH_10)
462 return 0;
463
464 if (skb_tailroom(skb) < 2 + sizeof(struct ieee80211_ht_operation))
465 return -ENOMEM;
466
467 pos = skb_put(skb, 2 + sizeof(struct ieee80211_ht_operation));
468 ieee80211_ie_build_ht_oper(pos, ht_cap, &sdata->vif.bss_conf.chandef,
469 sdata->vif.bss_conf.ht_operation_mode,
470 false);
471
472 return 0;
473}
474
475int mesh_add_vht_cap_ie(struct ieee80211_sub_if_data *sdata,
476 struct sk_buff *skb)
477{
478 struct ieee80211_supported_band *sband;
479 u8 *pos;
480
481 sband = ieee80211_get_sband(sdata);
482 if (!sband)
483 return -EINVAL;
484
485 if (!sband->vht_cap.vht_supported ||
486 sdata->vif.bss_conf.chandef.width == NL80211_CHAN_WIDTH_20_NOHT ||
487 sdata->vif.bss_conf.chandef.width == NL80211_CHAN_WIDTH_5 ||
488 sdata->vif.bss_conf.chandef.width == NL80211_CHAN_WIDTH_10)
489 return 0;
490
491 if (skb_tailroom(skb) < 2 + sizeof(struct ieee80211_vht_cap))
492 return -ENOMEM;
493
494 pos = skb_put(skb, 2 + sizeof(struct ieee80211_vht_cap));
495 ieee80211_ie_build_vht_cap(pos, &sband->vht_cap, sband->vht_cap.cap);
496
497 return 0;
498}
499
500int mesh_add_vht_oper_ie(struct ieee80211_sub_if_data *sdata,
501 struct sk_buff *skb)
502{
503 struct ieee80211_local *local = sdata->local;
504 struct ieee80211_chanctx_conf *chanctx_conf;
505 struct ieee80211_channel *channel;
506 struct ieee80211_supported_band *sband;
507 struct ieee80211_sta_vht_cap *vht_cap;
508 u8 *pos;
509
510 rcu_read_lock();
511 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
512 if (WARN_ON(!chanctx_conf)) {
513 rcu_read_unlock();
514 return -EINVAL;
515 }
516 channel = chanctx_conf->def.chan;
517 rcu_read_unlock();
518
519 sband = local->hw.wiphy->bands[channel->band];
520 vht_cap = &sband->vht_cap;
521
522 if (!vht_cap->vht_supported ||
523 sdata->vif.bss_conf.chandef.width == NL80211_CHAN_WIDTH_20_NOHT ||
524 sdata->vif.bss_conf.chandef.width == NL80211_CHAN_WIDTH_5 ||
525 sdata->vif.bss_conf.chandef.width == NL80211_CHAN_WIDTH_10)
526 return 0;
527
528 if (skb_tailroom(skb) < 2 + sizeof(struct ieee80211_vht_operation))
529 return -ENOMEM;
530
531 pos = skb_put(skb, 2 + sizeof(struct ieee80211_vht_operation));
532 ieee80211_ie_build_vht_oper(pos, vht_cap,
533 &sdata->vif.bss_conf.chandef);
534
535 return 0;
536}
537
538static void ieee80211_mesh_path_timer(struct timer_list *t)
539{
540 struct ieee80211_sub_if_data *sdata =
541 from_timer(sdata, t, u.mesh.mesh_path_timer);
542
543 ieee80211_queue_work(&sdata->local->hw, &sdata->work);
544}
545
546static void ieee80211_mesh_path_root_timer(struct timer_list *t)
547{
548 struct ieee80211_sub_if_data *sdata =
549 from_timer(sdata, t, u.mesh.mesh_path_root_timer);
550 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
551
552 set_bit(MESH_WORK_ROOT, &ifmsh->wrkq_flags);
553
554 ieee80211_queue_work(&sdata->local->hw, &sdata->work);
555}
556
557void ieee80211_mesh_root_setup(struct ieee80211_if_mesh *ifmsh)
558{
559 if (ifmsh->mshcfg.dot11MeshHWMPRootMode > IEEE80211_ROOTMODE_ROOT)
560 set_bit(MESH_WORK_ROOT, &ifmsh->wrkq_flags);
561 else {
562 clear_bit(MESH_WORK_ROOT, &ifmsh->wrkq_flags);
563
564 del_timer_sync(&ifmsh->mesh_path_root_timer);
565 }
566}
567
568
569
570
571
572
573
574
575
576
577
578int ieee80211_fill_mesh_addresses(struct ieee80211_hdr *hdr, __le16 *fc,
579 const u8 *meshda, const u8 *meshsa)
580{
581 if (is_multicast_ether_addr(meshda)) {
582 *fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS);
583
584 memcpy(hdr->addr1, meshda, ETH_ALEN);
585 memcpy(hdr->addr2, meshsa, ETH_ALEN);
586 memcpy(hdr->addr3, meshsa, ETH_ALEN);
587 return 24;
588 } else {
589 *fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS);
590
591 eth_zero_addr(hdr->addr1);
592 memcpy(hdr->addr2, meshsa, ETH_ALEN);
593 memcpy(hdr->addr3, meshda, ETH_ALEN);
594 memcpy(hdr->addr4, meshsa, ETH_ALEN);
595 return 30;
596 }
597}
598
599
600
601
602
603
604
605
606
607
608
609
610
611unsigned int ieee80211_new_mesh_header(struct ieee80211_sub_if_data *sdata,
612 struct ieee80211s_hdr *meshhdr,
613 const char *addr4or5, const char *addr6)
614{
615 if (WARN_ON(!addr4or5 && addr6))
616 return 0;
617
618 memset(meshhdr, 0, sizeof(*meshhdr));
619
620 meshhdr->ttl = sdata->u.mesh.mshcfg.dot11MeshTTL;
621
622
623 put_unaligned(cpu_to_le32(sdata->u.mesh.mesh_seqnum), &meshhdr->seqnum);
624 sdata->u.mesh.mesh_seqnum++;
625
626 if (addr4or5 && !addr6) {
627 meshhdr->flags |= MESH_FLAGS_AE_A4;
628 memcpy(meshhdr->eaddr1, addr4or5, ETH_ALEN);
629 return 2 * ETH_ALEN;
630 } else if (addr4or5 && addr6) {
631 meshhdr->flags |= MESH_FLAGS_AE_A5_A6;
632 memcpy(meshhdr->eaddr1, addr4or5, ETH_ALEN);
633 memcpy(meshhdr->eaddr2, addr6, ETH_ALEN);
634 return 3 * ETH_ALEN;
635 }
636
637 return ETH_ALEN;
638}
639
640static void ieee80211_mesh_housekeeping(struct ieee80211_sub_if_data *sdata)
641{
642 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
643 u32 changed;
644
645 if (ifmsh->mshcfg.plink_timeout > 0)
646 ieee80211_sta_expire(sdata, ifmsh->mshcfg.plink_timeout * HZ);
647 mesh_path_expire(sdata);
648
649 changed = mesh_accept_plinks_update(sdata);
650 ieee80211_mbss_info_change_notify(sdata, changed);
651
652 mod_timer(&ifmsh->housekeeping_timer,
653 round_jiffies(jiffies +
654 IEEE80211_MESH_HOUSEKEEPING_INTERVAL));
655}
656
657static void ieee80211_mesh_rootpath(struct ieee80211_sub_if_data *sdata)
658{
659 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
660 u32 interval;
661
662 mesh_path_tx_root_frame(sdata);
663
664 if (ifmsh->mshcfg.dot11MeshHWMPRootMode == IEEE80211_PROACTIVE_RANN)
665 interval = ifmsh->mshcfg.dot11MeshHWMPRannInterval;
666 else
667 interval = ifmsh->mshcfg.dot11MeshHWMProotInterval;
668
669 mod_timer(&ifmsh->mesh_path_root_timer,
670 round_jiffies(TU_TO_EXP_TIME(interval)));
671}
672
673static int
674ieee80211_mesh_build_beacon(struct ieee80211_if_mesh *ifmsh)
675{
676 struct beacon_data *bcn;
677 int head_len, tail_len;
678 struct sk_buff *skb;
679 struct ieee80211_mgmt *mgmt;
680 struct ieee80211_chanctx_conf *chanctx_conf;
681 struct mesh_csa_settings *csa;
682 enum nl80211_band band;
683 u8 *pos;
684 struct ieee80211_sub_if_data *sdata;
685 int hdr_len = offsetofend(struct ieee80211_mgmt, u.beacon);
686
687 sdata = container_of(ifmsh, struct ieee80211_sub_if_data, u.mesh);
688 rcu_read_lock();
689 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
690 band = chanctx_conf->def.chan->band;
691 rcu_read_unlock();
692
693 head_len = hdr_len +
694 2 +
695
696 2 + sizeof(struct ieee80211_channel_sw_ie) +
697
698 2 + sizeof(struct ieee80211_mesh_chansw_params_ie) +
699
700 2 + 2 + sizeof(struct ieee80211_wide_bw_chansw_ie) +
701 2 + sizeof(struct ieee80211_sec_chan_offs_ie) +
702 2 + 8 +
703 2 + 3;
704 tail_len = 2 + (IEEE80211_MAX_SUPP_RATES - 8) +
705 2 + sizeof(struct ieee80211_ht_cap) +
706 2 + sizeof(struct ieee80211_ht_operation) +
707 2 + ifmsh->mesh_id_len +
708 2 + sizeof(struct ieee80211_meshconf_ie) +
709 2 + sizeof(__le16) +
710 2 + sizeof(struct ieee80211_vht_cap) +
711 2 + sizeof(struct ieee80211_vht_operation) +
712 ifmsh->ie_len;
713
714 bcn = kzalloc(sizeof(*bcn) + head_len + tail_len, GFP_KERNEL);
715
716 skb = dev_alloc_skb(max(head_len, tail_len));
717
718 if (!bcn || !skb)
719 goto out_free;
720
721
722
723
724
725 bcn->head = ((u8 *) bcn) + sizeof(*bcn);
726
727
728 mgmt = skb_put_zero(skb, hdr_len);
729 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
730 IEEE80211_STYPE_BEACON);
731 eth_broadcast_addr(mgmt->da);
732 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
733 memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN);
734 ieee80211_mps_set_frame_flags(sdata, NULL, (void *) mgmt);
735 mgmt->u.beacon.beacon_int =
736 cpu_to_le16(sdata->vif.bss_conf.beacon_int);
737 mgmt->u.beacon.capab_info |= cpu_to_le16(
738 sdata->u.mesh.security ? WLAN_CAPABILITY_PRIVACY : 0);
739
740 pos = skb_put(skb, 2);
741 *pos++ = WLAN_EID_SSID;
742 *pos++ = 0x0;
743
744 rcu_read_lock();
745 csa = rcu_dereference(ifmsh->csa);
746 if (csa) {
747 enum nl80211_channel_type ct;
748 struct cfg80211_chan_def *chandef;
749 int ie_len = 2 + sizeof(struct ieee80211_channel_sw_ie) +
750 2 + sizeof(struct ieee80211_mesh_chansw_params_ie);
751
752 pos = skb_put_zero(skb, ie_len);
753 *pos++ = WLAN_EID_CHANNEL_SWITCH;
754 *pos++ = 3;
755 *pos++ = 0x0;
756 *pos++ = ieee80211_frequency_to_channel(
757 csa->settings.chandef.chan->center_freq);
758 bcn->csa_current_counter = csa->settings.count;
759 bcn->csa_counter_offsets[0] = hdr_len + 6;
760 *pos++ = csa->settings.count;
761 *pos++ = WLAN_EID_CHAN_SWITCH_PARAM;
762 *pos++ = 6;
763 if (ifmsh->csa_role == IEEE80211_MESH_CSA_ROLE_INIT) {
764 *pos++ = ifmsh->mshcfg.dot11MeshTTL;
765 *pos |= WLAN_EID_CHAN_SWITCH_PARAM_INITIATOR;
766 } else {
767 *pos++ = ifmsh->chsw_ttl;
768 }
769 *pos++ |= csa->settings.block_tx ?
770 WLAN_EID_CHAN_SWITCH_PARAM_TX_RESTRICT : 0x00;
771 put_unaligned_le16(WLAN_REASON_MESH_CHAN, pos);
772 pos += 2;
773 put_unaligned_le16(ifmsh->pre_value, pos);
774 pos += 2;
775
776 switch (csa->settings.chandef.width) {
777 case NL80211_CHAN_WIDTH_40:
778 ie_len = 2 + sizeof(struct ieee80211_sec_chan_offs_ie);
779 pos = skb_put_zero(skb, ie_len);
780
781 *pos++ = WLAN_EID_SECONDARY_CHANNEL_OFFSET;
782 *pos++ = 1;
783 ct = cfg80211_get_chandef_type(&csa->settings.chandef);
784 if (ct == NL80211_CHAN_HT40PLUS)
785 *pos++ = IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
786 else
787 *pos++ = IEEE80211_HT_PARAM_CHA_SEC_BELOW;
788 break;
789 case NL80211_CHAN_WIDTH_80:
790 case NL80211_CHAN_WIDTH_80P80:
791 case NL80211_CHAN_WIDTH_160:
792
793 ie_len = 2 + 2 +
794 sizeof(struct ieee80211_wide_bw_chansw_ie);
795 pos = skb_put_zero(skb, ie_len);
796
797 *pos++ = WLAN_EID_CHANNEL_SWITCH_WRAPPER;
798 *pos++ = 5;
799
800 chandef = &csa->settings.chandef;
801 ieee80211_ie_build_wide_bw_cs(pos, chandef);
802 break;
803 default:
804 break;
805 }
806 }
807 rcu_read_unlock();
808
809 if (ieee80211_add_srates_ie(sdata, skb, true, band) ||
810 mesh_add_ds_params_ie(sdata, skb))
811 goto out_free;
812
813 bcn->head_len = skb->len;
814 memcpy(bcn->head, skb->data, bcn->head_len);
815
816
817 skb_trim(skb, 0);
818 bcn->tail = bcn->head + bcn->head_len;
819
820 if (ieee80211_add_ext_srates_ie(sdata, skb, true, band) ||
821 mesh_add_rsn_ie(sdata, skb) ||
822 mesh_add_ht_cap_ie(sdata, skb) ||
823 mesh_add_ht_oper_ie(sdata, skb) ||
824 mesh_add_meshid_ie(sdata, skb) ||
825 mesh_add_meshconf_ie(sdata, skb) ||
826 mesh_add_awake_window_ie(sdata, skb) ||
827 mesh_add_vht_cap_ie(sdata, skb) ||
828 mesh_add_vht_oper_ie(sdata, skb) ||
829 mesh_add_vendor_ies(sdata, skb))
830 goto out_free;
831
832 bcn->tail_len = skb->len;
833 memcpy(bcn->tail, skb->data, bcn->tail_len);
834 bcn->meshconf = (struct ieee80211_meshconf_ie *)
835 (bcn->tail + ifmsh->meshconf_offset);
836
837 dev_kfree_skb(skb);
838 rcu_assign_pointer(ifmsh->beacon, bcn);
839 return 0;
840out_free:
841 kfree(bcn);
842 dev_kfree_skb(skb);
843 return -ENOMEM;
844}
845
846static int
847ieee80211_mesh_rebuild_beacon(struct ieee80211_sub_if_data *sdata)
848{
849 struct beacon_data *old_bcn;
850 int ret;
851
852 old_bcn = rcu_dereference_protected(sdata->u.mesh.beacon,
853 lockdep_is_held(&sdata->wdev.mtx));
854 ret = ieee80211_mesh_build_beacon(&sdata->u.mesh);
855 if (ret)
856
857 return ret;
858
859 if (old_bcn)
860 kfree_rcu(old_bcn, rcu_head);
861 return 0;
862}
863
864void ieee80211_mbss_info_change_notify(struct ieee80211_sub_if_data *sdata,
865 u32 changed)
866{
867 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
868 unsigned long bits = changed;
869 u32 bit;
870
871 if (!bits)
872 return;
873
874
875 for_each_set_bit(bit, &bits, sizeof(changed) * BITS_PER_BYTE)
876 set_bit(bit, &ifmsh->mbss_changed);
877 set_bit(MESH_WORK_MBSS_CHANGED, &ifmsh->wrkq_flags);
878 ieee80211_queue_work(&sdata->local->hw, &sdata->work);
879}
880
881int ieee80211_start_mesh(struct ieee80211_sub_if_data *sdata)
882{
883 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
884 struct ieee80211_local *local = sdata->local;
885 u32 changed = BSS_CHANGED_BEACON |
886 BSS_CHANGED_BEACON_ENABLED |
887 BSS_CHANGED_HT |
888 BSS_CHANGED_BASIC_RATES |
889 BSS_CHANGED_BEACON_INT |
890 BSS_CHANGED_MCAST_RATE;
891
892 local->fif_other_bss++;
893
894 atomic_inc(&local->iff_allmultis);
895 ieee80211_configure_filter(local);
896
897 ifmsh->mesh_cc_id = 0;
898
899 ifmsh->sync_ops = ieee80211_mesh_sync_ops_get(ifmsh->mesh_sp_id);
900 ifmsh->sync_offset_clockdrift_max = 0;
901 set_bit(MESH_WORK_HOUSEKEEPING, &ifmsh->wrkq_flags);
902 ieee80211_mesh_root_setup(ifmsh);
903 ieee80211_queue_work(&local->hw, &sdata->work);
904 sdata->vif.bss_conf.ht_operation_mode =
905 ifmsh->mshcfg.ht_opmode;
906 sdata->vif.bss_conf.enable_beacon = true;
907
908 changed |= ieee80211_mps_local_status_update(sdata);
909
910 if (ieee80211_mesh_build_beacon(ifmsh)) {
911 ieee80211_stop_mesh(sdata);
912 return -ENOMEM;
913 }
914
915 ieee80211_recalc_dtim(local, sdata);
916 ieee80211_bss_info_change_notify(sdata, changed);
917
918 netif_carrier_on(sdata->dev);
919 return 0;
920}
921
922void ieee80211_stop_mesh(struct ieee80211_sub_if_data *sdata)
923{
924 struct ieee80211_local *local = sdata->local;
925 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
926 struct beacon_data *bcn;
927
928 netif_carrier_off(sdata->dev);
929
930
931 sta_info_flush(sdata);
932 mesh_path_flush_by_iface(sdata);
933
934
935 ifmsh->mesh_id_len = 0;
936 sdata->vif.bss_conf.enable_beacon = false;
937 clear_bit(SDATA_STATE_OFFCHANNEL_BEACON_STOPPED, &sdata->state);
938 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON_ENABLED);
939
940
941 bcn = rcu_dereference_protected(ifmsh->beacon,
942 lockdep_is_held(&sdata->wdev.mtx));
943 RCU_INIT_POINTER(ifmsh->beacon, NULL);
944 kfree_rcu(bcn, rcu_head);
945
946
947 local->total_ps_buffered -= skb_queue_len(&ifmsh->ps.bc_buf);
948 skb_queue_purge(&ifmsh->ps.bc_buf);
949
950 del_timer_sync(&sdata->u.mesh.housekeeping_timer);
951 del_timer_sync(&sdata->u.mesh.mesh_path_root_timer);
952 del_timer_sync(&sdata->u.mesh.mesh_path_timer);
953
954
955 ifmsh->wrkq_flags = 0;
956 ifmsh->mbss_changed = 0;
957
958 local->fif_other_bss--;
959 atomic_dec(&local->iff_allmultis);
960 ieee80211_configure_filter(local);
961}
962
963static void ieee80211_mesh_csa_mark_radar(struct ieee80211_sub_if_data *sdata)
964{
965 int err;
966
967
968
969
970 err = cfg80211_chandef_dfs_required(sdata->local->hw.wiphy,
971 &sdata->vif.bss_conf.chandef,
972 NL80211_IFTYPE_MESH_POINT);
973 if (err > 0)
974 cfg80211_radar_event(sdata->local->hw.wiphy,
975 &sdata->vif.bss_conf.chandef, GFP_ATOMIC);
976}
977
978static bool
979ieee80211_mesh_process_chnswitch(struct ieee80211_sub_if_data *sdata,
980 struct ieee802_11_elems *elems, bool beacon)
981{
982 struct cfg80211_csa_settings params;
983 struct ieee80211_csa_ie csa_ie;
984 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
985 struct ieee80211_supported_band *sband;
986 int err;
987 u32 sta_flags;
988
989 sdata_assert_lock(sdata);
990
991 sband = ieee80211_get_sband(sdata);
992 if (!sband)
993 return false;
994
995 sta_flags = 0;
996 switch (sdata->vif.bss_conf.chandef.width) {
997 case NL80211_CHAN_WIDTH_20_NOHT:
998 sta_flags |= IEEE80211_STA_DISABLE_HT;
999
1000 case NL80211_CHAN_WIDTH_20:
1001 sta_flags |= IEEE80211_STA_DISABLE_40MHZ;
1002
1003 case NL80211_CHAN_WIDTH_40:
1004 sta_flags |= IEEE80211_STA_DISABLE_VHT;
1005 break;
1006 default:
1007 break;
1008 }
1009
1010 memset(¶ms, 0, sizeof(params));
1011 err = ieee80211_parse_ch_switch_ie(sdata, elems, sband->band,
1012 sta_flags, sdata->vif.addr,
1013 &csa_ie);
1014 if (err < 0)
1015 return false;
1016 if (err)
1017 return false;
1018
1019
1020
1021
1022 if (csa_ie.reason_code == WLAN_REASON_MESH_CHAN_REGULATORY)
1023 ieee80211_mesh_csa_mark_radar(sdata);
1024
1025 params.chandef = csa_ie.chandef;
1026 params.count = csa_ie.count;
1027
1028 if (!cfg80211_chandef_usable(sdata->local->hw.wiphy, ¶ms.chandef,
1029 IEEE80211_CHAN_DISABLED) ||
1030 !cfg80211_reg_can_beacon(sdata->local->hw.wiphy, ¶ms.chandef,
1031 NL80211_IFTYPE_MESH_POINT)) {
1032 sdata_info(sdata,
1033 "mesh STA %pM switches to unsupported channel (%d MHz, width:%d, CF1/2: %d/%d MHz), aborting\n",
1034 sdata->vif.addr,
1035 params.chandef.chan->center_freq,
1036 params.chandef.width,
1037 params.chandef.center_freq1,
1038 params.chandef.center_freq2);
1039 return false;
1040 }
1041
1042 err = cfg80211_chandef_dfs_required(sdata->local->hw.wiphy,
1043 ¶ms.chandef,
1044 NL80211_IFTYPE_MESH_POINT);
1045 if (err < 0)
1046 return false;
1047 if (err > 0 && !ifmsh->userspace_handles_dfs) {
1048 sdata_info(sdata,
1049 "mesh STA %pM switches to channel requiring DFS (%d MHz, width:%d, CF1/2: %d/%d MHz), aborting\n",
1050 sdata->vif.addr,
1051 params.chandef.chan->center_freq,
1052 params.chandef.width,
1053 params.chandef.center_freq1,
1054 params.chandef.center_freq2);
1055 return false;
1056 }
1057
1058 params.radar_required = err;
1059
1060 if (cfg80211_chandef_identical(¶ms.chandef,
1061 &sdata->vif.bss_conf.chandef)) {
1062 mcsa_dbg(sdata,
1063 "received csa with an identical chandef, ignoring\n");
1064 return true;
1065 }
1066
1067 mcsa_dbg(sdata,
1068 "received channel switch announcement to go to channel %d MHz\n",
1069 params.chandef.chan->center_freq);
1070
1071 params.block_tx = csa_ie.mode & WLAN_EID_CHAN_SWITCH_PARAM_TX_RESTRICT;
1072 if (beacon) {
1073 ifmsh->chsw_ttl = csa_ie.ttl - 1;
1074 if (ifmsh->pre_value >= csa_ie.pre_value)
1075 return false;
1076 ifmsh->pre_value = csa_ie.pre_value;
1077 }
1078
1079 if (ifmsh->chsw_ttl >= ifmsh->mshcfg.dot11MeshTTL)
1080 return false;
1081
1082 ifmsh->csa_role = IEEE80211_MESH_CSA_ROLE_REPEATER;
1083
1084 if (ieee80211_channel_switch(sdata->local->hw.wiphy, sdata->dev,
1085 ¶ms) < 0)
1086 return false;
1087
1088 return true;
1089}
1090
1091static void
1092ieee80211_mesh_rx_probe_req(struct ieee80211_sub_if_data *sdata,
1093 struct ieee80211_mgmt *mgmt, size_t len)
1094{
1095 struct ieee80211_local *local = sdata->local;
1096 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
1097 struct sk_buff *presp;
1098 struct beacon_data *bcn;
1099 struct ieee80211_mgmt *hdr;
1100 struct ieee802_11_elems elems;
1101 size_t baselen;
1102 u8 *pos;
1103
1104 pos = mgmt->u.probe_req.variable;
1105 baselen = (u8 *) pos - (u8 *) mgmt;
1106 if (baselen > len)
1107 return;
1108
1109 ieee802_11_parse_elems(pos, len - baselen, false, &elems);
1110
1111 if (!elems.mesh_id)
1112 return;
1113
1114
1115 if ((!ether_addr_equal(mgmt->da, sdata->vif.addr) &&
1116 !is_broadcast_ether_addr(mgmt->da)) ||
1117 elems.ssid_len != 0)
1118 return;
1119
1120 if (elems.mesh_id_len != 0 &&
1121 (elems.mesh_id_len != ifmsh->mesh_id_len ||
1122 memcmp(elems.mesh_id, ifmsh->mesh_id, ifmsh->mesh_id_len)))
1123 return;
1124
1125 rcu_read_lock();
1126 bcn = rcu_dereference(ifmsh->beacon);
1127
1128 if (!bcn)
1129 goto out;
1130
1131 presp = dev_alloc_skb(local->tx_headroom +
1132 bcn->head_len + bcn->tail_len);
1133 if (!presp)
1134 goto out;
1135
1136 skb_reserve(presp, local->tx_headroom);
1137 skb_put_data(presp, bcn->head, bcn->head_len);
1138 skb_put_data(presp, bcn->tail, bcn->tail_len);
1139 hdr = (struct ieee80211_mgmt *) presp->data;
1140 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
1141 IEEE80211_STYPE_PROBE_RESP);
1142 memcpy(hdr->da, mgmt->sa, ETH_ALEN);
1143 IEEE80211_SKB_CB(presp)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
1144 ieee80211_tx_skb(sdata, presp);
1145out:
1146 rcu_read_unlock();
1147}
1148
1149static void ieee80211_mesh_rx_bcn_presp(struct ieee80211_sub_if_data *sdata,
1150 u16 stype,
1151 struct ieee80211_mgmt *mgmt,
1152 size_t len,
1153 struct ieee80211_rx_status *rx_status)
1154{
1155 struct ieee80211_local *local = sdata->local;
1156 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
1157 struct ieee802_11_elems elems;
1158 struct ieee80211_channel *channel;
1159 size_t baselen;
1160 int freq;
1161 enum nl80211_band band = rx_status->band;
1162
1163
1164 if (stype == IEEE80211_STYPE_PROBE_RESP &&
1165 !ether_addr_equal(mgmt->da, sdata->vif.addr))
1166 return;
1167
1168 baselen = (u8 *) mgmt->u.probe_resp.variable - (u8 *) mgmt;
1169 if (baselen > len)
1170 return;
1171
1172 ieee802_11_parse_elems(mgmt->u.probe_resp.variable, len - baselen,
1173 false, &elems);
1174
1175
1176 if ((!elems.mesh_id || !elems.mesh_config) ||
1177 (elems.rsn && sdata->u.mesh.security == IEEE80211_MESH_SEC_NONE) ||
1178 (!elems.rsn && sdata->u.mesh.security != IEEE80211_MESH_SEC_NONE))
1179 return;
1180
1181 if (elems.ds_params)
1182 freq = ieee80211_channel_to_frequency(elems.ds_params[0], band);
1183 else
1184 freq = rx_status->freq;
1185
1186 channel = ieee80211_get_channel(local->hw.wiphy, freq);
1187
1188 if (!channel || channel->flags & IEEE80211_CHAN_DISABLED)
1189 return;
1190
1191 if (mesh_matches_local(sdata, &elems)) {
1192 mpl_dbg(sdata, "rssi_threshold=%d,rx_status->signal=%d\n",
1193 sdata->u.mesh.mshcfg.rssi_threshold, rx_status->signal);
1194 if (!sdata->u.mesh.user_mpm ||
1195 sdata->u.mesh.mshcfg.rssi_threshold == 0 ||
1196 sdata->u.mesh.mshcfg.rssi_threshold < rx_status->signal)
1197 mesh_neighbour_update(sdata, mgmt->sa, &elems,
1198 rx_status);
1199 }
1200
1201 if (ifmsh->sync_ops)
1202 ifmsh->sync_ops->rx_bcn_presp(sdata,
1203 stype, mgmt, &elems, rx_status);
1204
1205 if (ifmsh->csa_role != IEEE80211_MESH_CSA_ROLE_INIT &&
1206 !sdata->vif.csa_active)
1207 ieee80211_mesh_process_chnswitch(sdata, &elems, true);
1208}
1209
1210int ieee80211_mesh_finish_csa(struct ieee80211_sub_if_data *sdata)
1211{
1212 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
1213 struct mesh_csa_settings *tmp_csa_settings;
1214 int ret = 0;
1215 int changed = 0;
1216
1217
1218 ifmsh->csa_role = IEEE80211_MESH_CSA_ROLE_NONE;
1219 ifmsh->chsw_ttl = 0;
1220
1221
1222 tmp_csa_settings = rcu_dereference(ifmsh->csa);
1223 RCU_INIT_POINTER(ifmsh->csa, NULL);
1224 if (tmp_csa_settings)
1225 kfree_rcu(tmp_csa_settings, rcu_head);
1226 ret = ieee80211_mesh_rebuild_beacon(sdata);
1227 if (ret)
1228 return -EINVAL;
1229
1230 changed |= BSS_CHANGED_BEACON;
1231
1232 mcsa_dbg(sdata, "complete switching to center freq %d MHz",
1233 sdata->vif.bss_conf.chandef.chan->center_freq);
1234 return changed;
1235}
1236
1237int ieee80211_mesh_csa_beacon(struct ieee80211_sub_if_data *sdata,
1238 struct cfg80211_csa_settings *csa_settings)
1239{
1240 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
1241 struct mesh_csa_settings *tmp_csa_settings;
1242 int ret = 0;
1243
1244 tmp_csa_settings = kmalloc(sizeof(*tmp_csa_settings),
1245 GFP_ATOMIC);
1246 if (!tmp_csa_settings)
1247 return -ENOMEM;
1248
1249 memcpy(&tmp_csa_settings->settings, csa_settings,
1250 sizeof(struct cfg80211_csa_settings));
1251
1252 rcu_assign_pointer(ifmsh->csa, tmp_csa_settings);
1253
1254 ret = ieee80211_mesh_rebuild_beacon(sdata);
1255 if (ret) {
1256 tmp_csa_settings = rcu_dereference(ifmsh->csa);
1257 RCU_INIT_POINTER(ifmsh->csa, NULL);
1258 kfree_rcu(tmp_csa_settings, rcu_head);
1259 return ret;
1260 }
1261
1262 return BSS_CHANGED_BEACON;
1263}
1264
1265static int mesh_fwd_csa_frame(struct ieee80211_sub_if_data *sdata,
1266 struct ieee80211_mgmt *mgmt, size_t len,
1267 struct ieee802_11_elems *elems)
1268{
1269 struct ieee80211_mgmt *mgmt_fwd;
1270 struct sk_buff *skb;
1271 struct ieee80211_local *local = sdata->local;
1272
1273 skb = dev_alloc_skb(local->tx_headroom + len);
1274 if (!skb)
1275 return -ENOMEM;
1276 skb_reserve(skb, local->tx_headroom);
1277 mgmt_fwd = skb_put(skb, len);
1278
1279 elems->mesh_chansw_params_ie->mesh_ttl--;
1280 elems->mesh_chansw_params_ie->mesh_flags &=
1281 ~WLAN_EID_CHAN_SWITCH_PARAM_INITIATOR;
1282
1283 memcpy(mgmt_fwd, mgmt, len);
1284 eth_broadcast_addr(mgmt_fwd->da);
1285 memcpy(mgmt_fwd->sa, sdata->vif.addr, ETH_ALEN);
1286 memcpy(mgmt_fwd->bssid, sdata->vif.addr, ETH_ALEN);
1287
1288 ieee80211_tx_skb(sdata, skb);
1289 return 0;
1290}
1291
1292static void mesh_rx_csa_frame(struct ieee80211_sub_if_data *sdata,
1293 struct ieee80211_mgmt *mgmt, size_t len)
1294{
1295 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
1296 struct ieee802_11_elems elems;
1297 u16 pre_value;
1298 bool fwd_csa = true;
1299 size_t baselen;
1300 u8 *pos;
1301
1302 if (mgmt->u.action.u.measurement.action_code !=
1303 WLAN_ACTION_SPCT_CHL_SWITCH)
1304 return;
1305
1306 pos = mgmt->u.action.u.chan_switch.variable;
1307 baselen = offsetof(struct ieee80211_mgmt,
1308 u.action.u.chan_switch.variable);
1309 ieee802_11_parse_elems(pos, len - baselen, true, &elems);
1310
1311 ifmsh->chsw_ttl = elems.mesh_chansw_params_ie->mesh_ttl;
1312 if (!--ifmsh->chsw_ttl)
1313 fwd_csa = false;
1314
1315 pre_value = le16_to_cpu(elems.mesh_chansw_params_ie->mesh_pre_value);
1316 if (ifmsh->pre_value >= pre_value)
1317 return;
1318
1319 ifmsh->pre_value = pre_value;
1320
1321 if (!sdata->vif.csa_active &&
1322 !ieee80211_mesh_process_chnswitch(sdata, &elems, false)) {
1323 mcsa_dbg(sdata, "Failed to process CSA action frame");
1324 return;
1325 }
1326
1327
1328 if (fwd_csa) {
1329 if (mesh_fwd_csa_frame(sdata, mgmt, len, &elems) < 0)
1330 mcsa_dbg(sdata, "Failed to forward the CSA frame");
1331 }
1332}
1333
1334static void ieee80211_mesh_rx_mgmt_action(struct ieee80211_sub_if_data *sdata,
1335 struct ieee80211_mgmt *mgmt,
1336 size_t len,
1337 struct ieee80211_rx_status *rx_status)
1338{
1339 switch (mgmt->u.action.category) {
1340 case WLAN_CATEGORY_SELF_PROTECTED:
1341 switch (mgmt->u.action.u.self_prot.action_code) {
1342 case WLAN_SP_MESH_PEERING_OPEN:
1343 case WLAN_SP_MESH_PEERING_CLOSE:
1344 case WLAN_SP_MESH_PEERING_CONFIRM:
1345 mesh_rx_plink_frame(sdata, mgmt, len, rx_status);
1346 break;
1347 }
1348 break;
1349 case WLAN_CATEGORY_MESH_ACTION:
1350 if (mesh_action_is_path_sel(mgmt))
1351 mesh_rx_path_sel_frame(sdata, mgmt, len);
1352 break;
1353 case WLAN_CATEGORY_SPECTRUM_MGMT:
1354 mesh_rx_csa_frame(sdata, mgmt, len);
1355 break;
1356 }
1357}
1358
1359void ieee80211_mesh_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata,
1360 struct sk_buff *skb)
1361{
1362 struct ieee80211_rx_status *rx_status;
1363 struct ieee80211_mgmt *mgmt;
1364 u16 stype;
1365
1366 sdata_lock(sdata);
1367
1368
1369 if (!sdata->u.mesh.mesh_id_len)
1370 goto out;
1371
1372 rx_status = IEEE80211_SKB_RXCB(skb);
1373 mgmt = (struct ieee80211_mgmt *) skb->data;
1374 stype = le16_to_cpu(mgmt->frame_control) & IEEE80211_FCTL_STYPE;
1375
1376 switch (stype) {
1377 case IEEE80211_STYPE_PROBE_RESP:
1378 case IEEE80211_STYPE_BEACON:
1379 ieee80211_mesh_rx_bcn_presp(sdata, stype, mgmt, skb->len,
1380 rx_status);
1381 break;
1382 case IEEE80211_STYPE_PROBE_REQ:
1383 ieee80211_mesh_rx_probe_req(sdata, mgmt, skb->len);
1384 break;
1385 case IEEE80211_STYPE_ACTION:
1386 ieee80211_mesh_rx_mgmt_action(sdata, mgmt, skb->len, rx_status);
1387 break;
1388 }
1389out:
1390 sdata_unlock(sdata);
1391}
1392
1393static void mesh_bss_info_changed(struct ieee80211_sub_if_data *sdata)
1394{
1395 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
1396 u32 bit, changed = 0;
1397
1398 for_each_set_bit(bit, &ifmsh->mbss_changed,
1399 sizeof(changed) * BITS_PER_BYTE) {
1400 clear_bit(bit, &ifmsh->mbss_changed);
1401 changed |= BIT(bit);
1402 }
1403
1404 if (sdata->vif.bss_conf.enable_beacon &&
1405 (changed & (BSS_CHANGED_BEACON |
1406 BSS_CHANGED_HT |
1407 BSS_CHANGED_BASIC_RATES |
1408 BSS_CHANGED_BEACON_INT)))
1409 if (ieee80211_mesh_rebuild_beacon(sdata))
1410 return;
1411
1412 ieee80211_bss_info_change_notify(sdata, changed);
1413}
1414
1415void ieee80211_mesh_work(struct ieee80211_sub_if_data *sdata)
1416{
1417 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
1418
1419 sdata_lock(sdata);
1420
1421
1422 if (!sdata->u.mesh.mesh_id_len)
1423 goto out;
1424
1425 if (ifmsh->preq_queue_len &&
1426 time_after(jiffies,
1427 ifmsh->last_preq + msecs_to_jiffies(ifmsh->mshcfg.dot11MeshHWMPpreqMinInterval)))
1428 mesh_path_start_discovery(sdata);
1429
1430 if (test_and_clear_bit(MESH_WORK_HOUSEKEEPING, &ifmsh->wrkq_flags))
1431 ieee80211_mesh_housekeeping(sdata);
1432
1433 if (test_and_clear_bit(MESH_WORK_ROOT, &ifmsh->wrkq_flags))
1434 ieee80211_mesh_rootpath(sdata);
1435
1436 if (test_and_clear_bit(MESH_WORK_DRIFT_ADJUST, &ifmsh->wrkq_flags))
1437 mesh_sync_adjust_tsf(sdata);
1438
1439 if (test_and_clear_bit(MESH_WORK_MBSS_CHANGED, &ifmsh->wrkq_flags))
1440 mesh_bss_info_changed(sdata);
1441out:
1442 sdata_unlock(sdata);
1443}
1444
1445
1446void ieee80211_mesh_init_sdata(struct ieee80211_sub_if_data *sdata)
1447{
1448 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
1449 static u8 zero_addr[ETH_ALEN] = {};
1450
1451 timer_setup(&ifmsh->housekeeping_timer,
1452 ieee80211_mesh_housekeeping_timer, 0);
1453
1454 ifmsh->accepting_plinks = true;
1455 atomic_set(&ifmsh->mpaths, 0);
1456 mesh_rmc_init(sdata);
1457 ifmsh->last_preq = jiffies;
1458 ifmsh->next_perr = jiffies;
1459 ifmsh->csa_role = IEEE80211_MESH_CSA_ROLE_NONE;
1460
1461 if (!mesh_allocated)
1462 ieee80211s_init();
1463
1464 mesh_pathtbl_init(sdata);
1465
1466 timer_setup(&ifmsh->mesh_path_timer, ieee80211_mesh_path_timer, 0);
1467 timer_setup(&ifmsh->mesh_path_root_timer,
1468 ieee80211_mesh_path_root_timer, 0);
1469 INIT_LIST_HEAD(&ifmsh->preq_queue.list);
1470 skb_queue_head_init(&ifmsh->ps.bc_buf);
1471 spin_lock_init(&ifmsh->mesh_preq_queue_lock);
1472 spin_lock_init(&ifmsh->sync_offset_lock);
1473 RCU_INIT_POINTER(ifmsh->beacon, NULL);
1474
1475 sdata->vif.bss_conf.bssid = zero_addr;
1476}
1477
1478void ieee80211_mesh_teardown_sdata(struct ieee80211_sub_if_data *sdata)
1479{
1480 mesh_rmc_free(sdata);
1481 mesh_pathtbl_unregister(sdata);
1482}
1483