2 * Copyright (c) 2008 open80211s Ltd.
3 * Author: Luis Carlos Cobo <luisca@cozybit.com>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
9 #include <linux/kernel.h>
10 #include <linux/random.h>
11 #include "ieee80211_i.h"
12 #include "ieee80211_rate.h"
15 #ifdef CONFIG_MAC80211_VERBOSE_MPL_DEBUG
16 #define mpl_dbg(fmt, args...) printk(KERN_DEBUG fmt, ##args)
18 #define mpl_dbg(fmt, args...) do { (void)(0); } while (0)
21 #define IEEE80211_FC(type, stype) cpu_to_le16(type | stype)
22 #define PLINK_GET_FRAME_SUBTYPE(p) (p)
23 #define PLINK_GET_LLID(p) (p + 1)
24 #define PLINK_GET_PLID(p) (p + 3)
26 #define mod_plink_timer(s, t) (mod_timer(&s->plink_timer, \
27 jiffies + HZ * t / 1000))
29 /* Peer link cancel reasons, all subject to ANA approval */
30 #define MESH_LINK_CANCELLED 2
31 #define MESH_MAX_NEIGHBORS 3
32 #define MESH_CAPABILITY_POLICY_VIOLATION 4
33 #define MESH_CLOSE_RCVD 5
34 #define MESH_MAX_RETRIES 6
35 #define MESH_CONFIRM_TIMEOUT 7
36 #define MESH_SECURITY_ROLE_NEGOTIATION_DIFFERS 8
37 #define MESH_SECURITY_AUTHENTICATION_IMPOSSIBLE 9
38 #define MESH_SECURITY_FAILED_VERIFICATION 10
40 #define dot11MeshMaxRetries(s) (s->u.sta.mshcfg.dot11MeshMaxRetries)
41 #define dot11MeshRetryTimeout(s) (s->u.sta.mshcfg.dot11MeshRetryTimeout)
42 #define dot11MeshConfirmTimeout(s) (s->u.sta.mshcfg.dot11MeshConfirmTimeout)
43 #define dot11MeshHoldingTimeout(s) (s->u.sta.mshcfg.dot11MeshHoldingTimeout)
44 #define dot11MeshMaxPeerLinks(s) (s->u.sta.mshcfg.dot11MeshMaxPeerLinks)
46 enum plink_frame_type {
65 void mesh_plink_inc_estab_count(struct ieee80211_sub_if_data *sdata)
67 atomic_inc(&sdata->u.sta.mshstats.estab_plinks);
68 mesh_accept_plinks_update(sdata);
72 void mesh_plink_dec_estab_count(struct ieee80211_sub_if_data *sdata)
74 atomic_dec(&sdata->u.sta.mshstats.estab_plinks);
75 mesh_accept_plinks_update(sdata);
79 * mesh_plink_fsm_restart - restart a mesh peer link finite state machine
81 * @sta: mes peer link to restart
83 * Locking: this function must be called holding sta->plink_lock
85 static inline void mesh_plink_fsm_restart(struct sta_info *sta)
87 sta->plink_state = PLINK_LISTEN;
88 sta->llid = sta->plid = sta->reason = 0;
89 sta->plink_retries = 0;
93 * NOTE: This is just an alias for sta_info_alloc(), see notes
94 * on it in the lifecycle management section!
96 static struct sta_info *mesh_plink_alloc(struct ieee80211_sub_if_data *sdata,
97 u8 *hw_addr, u64 rates)
99 struct ieee80211_local *local = sdata->local;
100 struct sta_info *sta;
102 if (local->num_sta >= MESH_MAX_PLINKS)
105 sta = sta_info_alloc(sdata, hw_addr, GFP_ATOMIC);
109 sta->flags |= WLAN_STA_AUTHORIZED;
110 sta->supp_rates[local->hw.conf.channel->band] = rates;
116 * mesh_plink_deactivate - deactivate mesh peer link
118 * @sta: mesh peer link to deactivate
120 * All mesh paths with this peer as next hop will be flushed
122 * Locking: the caller must hold sta->plink_lock
124 static void __mesh_plink_deactivate(struct sta_info *sta)
126 struct ieee80211_sub_if_data *sdata = sta->sdata;
128 if (sta->plink_state == PLINK_ESTAB)
129 mesh_plink_dec_estab_count(sdata);
130 sta->plink_state = PLINK_BLOCKED;
131 mesh_path_flush_by_nexthop(sta);
135 * __mesh_plink_deactivate - deactivate mesh peer link
137 * @sta: mesh peer link to deactivate
139 * All mesh paths with this peer as next hop will be flushed
141 void mesh_plink_deactivate(struct sta_info *sta)
143 spin_lock_bh(&sta->plink_lock);
144 __mesh_plink_deactivate(sta);
145 spin_unlock_bh(&sta->plink_lock);
148 static int mesh_plink_frame_tx(struct net_device *dev,
149 enum plink_frame_type action, u8 *da, __le16 llid, __le16 plid,
151 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
152 struct sk_buff *skb = dev_alloc_skb(local->hw.extra_tx_headroom + 400);
153 struct ieee80211_mgmt *mgmt;
154 bool include_plid = false;
160 skb_reserve(skb, local->hw.extra_tx_headroom);
161 /* 25 is the size of the common mgmt part (24) plus the size of the
162 * common action part (1)
164 mgmt = (struct ieee80211_mgmt *)
165 skb_put(skb, 25 + sizeof(mgmt->u.action.u.plink_action));
166 memset(mgmt, 0, 25 + sizeof(mgmt->u.action.u.plink_action));
167 mgmt->frame_control = IEEE80211_FC(IEEE80211_FTYPE_MGMT,
168 IEEE80211_STYPE_ACTION);
169 memcpy(mgmt->da, da, ETH_ALEN);
170 memcpy(mgmt->sa, dev->dev_addr, ETH_ALEN);
171 /* BSSID is left zeroed, wildcard value */
172 mgmt->u.action.category = PLINK_CATEGORY;
173 mgmt->u.action.u.plink_action.action_code = action;
175 if (action == PLINK_CLOSE)
176 mgmt->u.action.u.plink_action.aux = reason;
178 mgmt->u.action.u.plink_action.aux = cpu_to_le16(0x0);
179 if (action == PLINK_CONFIRM) {
180 pos = skb_put(skb, 4);
181 /* two-byte status code followed by two-byte AID */
184 mesh_mgmt_ies_add(skb, dev);
187 /* Add Peer Link Management element */
207 pos = skb_put(skb, 2 + ie_len);
208 *pos++ = WLAN_EID_PEER_LINK;
211 memcpy(pos, &llid, 2);
214 memcpy(pos, &plid, 2);
216 if (action == PLINK_CLOSE) {
218 memcpy(pos, &reason, 2);
221 ieee80211_sta_tx(dev, skb, 0);
225 void mesh_neighbour_update(u8 *hw_addr, u64 rates, struct net_device *dev,
226 bool peer_accepting_plinks)
228 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
229 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
230 struct sta_info *sta;
234 sta = sta_info_get(local, hw_addr);
236 sta = mesh_plink_alloc(sdata, hw_addr, rates);
241 if (sta_info_insert(sta)) {
247 sta->last_rx = jiffies;
248 sta->supp_rates[local->hw.conf.channel->band] = rates;
249 if (peer_accepting_plinks && sta->plink_state == PLINK_LISTEN &&
250 sdata->u.sta.accepting_plinks &&
251 sdata->u.sta.mshcfg.auto_open_plinks)
252 mesh_plink_open(sta);
257 static void mesh_plink_timer(unsigned long data)
259 struct sta_info *sta;
260 __le16 llid, plid, reason;
261 struct net_device *dev = NULL;
262 struct ieee80211_sub_if_data *sdata;
263 #ifdef CONFIG_MAC80211_VERBOSE_MPL_DEBUG
264 DECLARE_MAC_BUF(mac);
268 * This STA is valid because sta_info_destroy() will
269 * del_timer_sync() this timer after having made sure
270 * it cannot be readded (by deleting the plink.)
272 sta = (struct sta_info *) data;
274 spin_lock_bh(&sta->plink_lock);
275 if (sta->ignore_plink_timer) {
276 sta->ignore_plink_timer = false;
277 spin_unlock_bh(&sta->plink_lock);
280 mpl_dbg("Mesh plink timer for %s fired on state %d\n",
281 print_mac(mac, sta->addr), sta->plink_state);
288 switch (sta->plink_state) {
292 if (sta->plink_retries < dot11MeshMaxRetries(sdata)) {
294 mpl_dbg("Mesh plink for %s (retry, timeout): %d %d\n",
295 print_mac(mac, sta->addr),
296 sta->plink_retries, sta->plink_timeout);
297 get_random_bytes(&rand, sizeof(u32));
298 sta->plink_timeout = sta->plink_timeout +
299 rand % sta->plink_timeout;
300 ++sta->plink_retries;
301 mod_plink_timer(sta, sta->plink_timeout);
302 spin_unlock_bh(&sta->plink_lock);
303 mesh_plink_frame_tx(dev, PLINK_OPEN, sta->addr, llid,
307 reason = cpu_to_le16(MESH_MAX_RETRIES);
308 /* fall through on else */
312 reason = cpu_to_le16(MESH_CONFIRM_TIMEOUT);
313 sta->plink_state = PLINK_HOLDING;
314 mod_plink_timer(sta, dot11MeshHoldingTimeout(sdata));
315 spin_unlock_bh(&sta->plink_lock);
316 mesh_plink_frame_tx(dev, PLINK_CLOSE, sta->addr, llid, plid,
321 del_timer(&sta->plink_timer);
322 mesh_plink_fsm_restart(sta);
323 spin_unlock_bh(&sta->plink_lock);
326 spin_unlock_bh(&sta->plink_lock);
331 static inline void mesh_plink_timer_set(struct sta_info *sta, int timeout)
333 sta->plink_timer.expires = jiffies + (HZ * timeout / 1000);
334 sta->plink_timer.data = (unsigned long) sta;
335 sta->plink_timer.function = mesh_plink_timer;
336 sta->plink_timeout = timeout;
337 add_timer(&sta->plink_timer);
340 int mesh_plink_open(struct sta_info *sta)
343 struct ieee80211_sub_if_data *sdata = sta->sdata;
344 #ifdef CONFIG_MAC80211_VERBOSE_MPL_DEBUG
345 DECLARE_MAC_BUF(mac);
348 spin_lock_bh(&sta->plink_lock);
349 get_random_bytes(&llid, 2);
351 if (sta->plink_state != PLINK_LISTEN) {
352 spin_unlock_bh(&sta->plink_lock);
355 sta->plink_state = PLINK_OPN_SNT;
356 mesh_plink_timer_set(sta, dot11MeshRetryTimeout(sdata));
357 spin_unlock_bh(&sta->plink_lock);
358 mpl_dbg("Mesh plink: starting establishment with %s\n",
359 print_mac(mac, sta->addr));
361 return mesh_plink_frame_tx(sdata->dev, PLINK_OPEN,
362 sta->addr, llid, 0, 0);
365 void mesh_plink_block(struct sta_info *sta)
367 #ifdef CONFIG_MAC80211_VERBOSE_MPL_DEBUG
368 DECLARE_MAC_BUF(mac);
371 spin_lock_bh(&sta->plink_lock);
372 __mesh_plink_deactivate(sta);
373 sta->plink_state = PLINK_BLOCKED;
374 spin_unlock_bh(&sta->plink_lock);
377 int mesh_plink_close(struct sta_info *sta)
379 struct ieee80211_sub_if_data *sdata = sta->sdata;
380 __le16 llid, plid, reason;
381 #ifdef CONFIG_MAC80211_VERBOSE_MPL_DEBUG
382 DECLARE_MAC_BUF(mac);
385 mpl_dbg("Mesh plink: closing link with %s\n",
386 print_mac(mac, sta->addr));
387 spin_lock_bh(&sta->plink_lock);
388 sta->reason = cpu_to_le16(MESH_LINK_CANCELLED);
389 reason = sta->reason;
391 if (sta->plink_state == PLINK_LISTEN ||
392 sta->plink_state == PLINK_BLOCKED) {
393 mesh_plink_fsm_restart(sta);
394 spin_unlock_bh(&sta->plink_lock);
396 } else if (sta->plink_state == PLINK_ESTAB) {
397 __mesh_plink_deactivate(sta);
398 /* The timer should not be running */
399 mod_plink_timer(sta, dot11MeshHoldingTimeout(sdata));
400 } else if (!mod_plink_timer(sta, dot11MeshHoldingTimeout(sdata)))
401 sta->ignore_plink_timer = true;
403 sta->plink_state = PLINK_HOLDING;
406 spin_unlock_bh(&sta->plink_lock);
407 mesh_plink_frame_tx(sta->sdata->dev, PLINK_CLOSE, sta->addr, llid,
412 void mesh_rx_plink_frame(struct net_device *dev, struct ieee80211_mgmt *mgmt,
413 size_t len, struct ieee80211_rx_status *rx_status)
415 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
416 struct ieee80211_local *local = sdata->local;
417 struct ieee802_11_elems elems;
418 struct sta_info *sta;
419 enum plink_event event;
420 enum plink_frame_type ftype;
424 __le16 plid, llid, reason;
425 #ifdef CONFIG_MAC80211_VERBOSE_MPL_DEBUG
426 DECLARE_MAC_BUF(mac);
429 if (is_multicast_ether_addr(mgmt->da)) {
430 mpl_dbg("Mesh plink: ignore frame from multicast address");
434 baseaddr = mgmt->u.action.u.plink_action.variable;
435 baselen = (u8 *) mgmt->u.action.u.plink_action.variable - (u8 *) mgmt;
436 if (mgmt->u.action.u.plink_action.action_code == PLINK_CONFIRM) {
440 ieee802_11_parse_elems(baseaddr, len - baselen, &elems);
441 if (!elems.peer_link) {
442 mpl_dbg("Mesh plink: missing necessary peer link ie\n");
446 ftype = *((u8 *)PLINK_GET_FRAME_SUBTYPE(elems.peer_link));
447 ie_len = elems.peer_link_len;
448 if ((ftype == PLINK_OPEN && ie_len != 3) ||
449 (ftype == PLINK_CONFIRM && ie_len != 5) ||
450 (ftype == PLINK_CLOSE && ie_len != 5 && ie_len != 7)) {
451 mpl_dbg("Mesh plink: incorrect plink ie length\n");
455 if (ftype != PLINK_CLOSE && (!elems.mesh_id || !elems.mesh_config)) {
456 mpl_dbg("Mesh plink: missing necessary ie\n");
459 /* Note the lines below are correct, the llid in the frame is the plid
460 * from the point of view of this host.
462 memcpy(&plid, PLINK_GET_LLID(elems.peer_link), 2);
463 if (ftype == PLINK_CONFIRM || (ftype == PLINK_CLOSE && ie_len == 7))
464 memcpy(&llid, PLINK_GET_PLID(elems.peer_link), 2);
468 sta = sta_info_get(local, mgmt->sa);
469 if (!sta && ftype != PLINK_OPEN) {
470 mpl_dbg("Mesh plink: cls or cnf from unknown peer\n");
475 if (sta && sta->plink_state == PLINK_BLOCKED) {
480 /* Now we will figure out the appropriate event... */
481 event = PLINK_UNDEFINED;
482 if (ftype != PLINK_CLOSE && (!mesh_matches_local(&elems, dev))) {
494 spin_lock_bh(&sta->plink_lock);
496 /* ftype == PLINK_OPEN */
498 if (!mesh_plink_free_count(sdata)) {
499 mpl_dbg("Mesh plink error: no more free plinks\n");
504 rates = ieee80211_sta_get_rates(local, &elems, rx_status->band);
505 sta = mesh_plink_alloc(sdata, mgmt->sa, rates);
507 mpl_dbg("Mesh plink error: plink table full\n");
511 if (sta_info_insert(sta)) {
516 spin_lock_bh(&sta->plink_lock);
518 spin_lock_bh(&sta->plink_lock);
521 if (!mesh_plink_free_count(sdata) ||
522 (sta->plid && sta->plid != plid))
528 if (!mesh_plink_free_count(sdata) ||
529 (sta->llid != llid || sta->plid != plid))
535 if (sta->plink_state == PLINK_ESTAB)
536 /* Do not check for llid or plid. This does not
537 * follow the standard but since multiple plinks
538 * per sta are not supported, it is necessary in
539 * order to avoid a livelock when MP A sees an
540 * establish peer link to MP B but MP B does not
541 * see it. This can be caused by a timeout in
542 * B's peer link establishment or B beign
546 else if (sta->plid != plid)
548 else if (ie_len == 7 && sta->llid != llid)
554 mpl_dbg("Mesh plink: unknown frame subtype\n");
555 spin_unlock_bh(&sta->plink_lock);
561 mpl_dbg("Mesh plink (peer, state, llid, plid, event): %s %d %d %d %d\n",
562 print_mac(mac, mgmt->sa), sta->plink_state,
563 le16_to_cpu(sta->llid), le16_to_cpu(sta->plid),
566 switch (sta->plink_state) {
567 /* spin_unlock as soon as state is updated at each case */
571 mesh_plink_fsm_restart(sta);
572 spin_unlock_bh(&sta->plink_lock);
575 sta->plink_state = PLINK_OPN_RCVD;
577 get_random_bytes(&llid, 2);
579 mesh_plink_timer_set(sta, dot11MeshRetryTimeout(sdata));
580 spin_unlock_bh(&sta->plink_lock);
581 mesh_plink_frame_tx(dev, PLINK_OPEN, sta->addr, llid,
583 mesh_plink_frame_tx(dev, PLINK_CONFIRM, sta->addr,
587 spin_unlock_bh(&sta->plink_lock);
596 reason = cpu_to_le16(MESH_CAPABILITY_POLICY_VIOLATION);
599 reason = cpu_to_le16(MESH_CLOSE_RCVD);
600 sta->reason = reason;
601 sta->plink_state = PLINK_HOLDING;
602 if (!mod_plink_timer(sta,
603 dot11MeshHoldingTimeout(sdata)))
604 sta->ignore_plink_timer = true;
607 spin_unlock_bh(&sta->plink_lock);
608 mesh_plink_frame_tx(dev, PLINK_CLOSE, sta->addr, llid,
612 /* retry timer is left untouched */
613 sta->plink_state = PLINK_OPN_RCVD;
616 spin_unlock_bh(&sta->plink_lock);
617 mesh_plink_frame_tx(dev, PLINK_CONFIRM, sta->addr, llid,
621 sta->plink_state = PLINK_CNF_RCVD;
622 if (!mod_plink_timer(sta,
623 dot11MeshConfirmTimeout(sdata)))
624 sta->ignore_plink_timer = true;
626 spin_unlock_bh(&sta->plink_lock);
629 spin_unlock_bh(&sta->plink_lock);
638 reason = cpu_to_le16(MESH_CAPABILITY_POLICY_VIOLATION);
641 reason = cpu_to_le16(MESH_CLOSE_RCVD);
642 sta->reason = reason;
643 sta->plink_state = PLINK_HOLDING;
644 if (!mod_plink_timer(sta,
645 dot11MeshHoldingTimeout(sdata)))
646 sta->ignore_plink_timer = true;
649 spin_unlock_bh(&sta->plink_lock);
650 mesh_plink_frame_tx(dev, PLINK_CLOSE, sta->addr, llid,
655 spin_unlock_bh(&sta->plink_lock);
656 mesh_plink_frame_tx(dev, PLINK_CONFIRM, sta->addr, llid,
660 del_timer(&sta->plink_timer);
661 sta->plink_state = PLINK_ESTAB;
662 mesh_plink_inc_estab_count(sdata);
663 spin_unlock_bh(&sta->plink_lock);
664 mpl_dbg("Mesh plink with %s ESTABLISHED\n",
665 print_mac(mac, sta->addr));
668 spin_unlock_bh(&sta->plink_lock);
677 reason = cpu_to_le16(MESH_CAPABILITY_POLICY_VIOLATION);
680 reason = cpu_to_le16(MESH_CLOSE_RCVD);
681 sta->reason = reason;
682 sta->plink_state = PLINK_HOLDING;
683 if (!mod_plink_timer(sta,
684 dot11MeshHoldingTimeout(sdata)))
685 sta->ignore_plink_timer = true;
688 spin_unlock_bh(&sta->plink_lock);
689 mesh_plink_frame_tx(dev, PLINK_CLOSE, sta->addr, llid,
693 del_timer(&sta->plink_timer);
694 sta->plink_state = PLINK_ESTAB;
695 mesh_plink_inc_estab_count(sdata);
696 spin_unlock_bh(&sta->plink_lock);
697 mpl_dbg("Mesh plink with %s ESTABLISHED\n",
698 print_mac(mac, sta->addr));
699 mesh_plink_frame_tx(dev, PLINK_CONFIRM, sta->addr, llid,
703 spin_unlock_bh(&sta->plink_lock);
711 reason = cpu_to_le16(MESH_CLOSE_RCVD);
712 sta->reason = reason;
713 __mesh_plink_deactivate(sta);
714 sta->plink_state = PLINK_HOLDING;
716 mod_plink_timer(sta, dot11MeshHoldingTimeout(sdata));
717 spin_unlock_bh(&sta->plink_lock);
718 mesh_plink_frame_tx(dev, PLINK_CLOSE, sta->addr, llid,
723 spin_unlock_bh(&sta->plink_lock);
724 mesh_plink_frame_tx(dev, PLINK_CONFIRM, sta->addr, llid,
728 spin_unlock_bh(&sta->plink_lock);
735 if (del_timer(&sta->plink_timer))
736 sta->ignore_plink_timer = 1;
737 mesh_plink_fsm_restart(sta);
738 spin_unlock_bh(&sta->plink_lock);
745 reason = sta->reason;
746 spin_unlock_bh(&sta->plink_lock);
747 mesh_plink_frame_tx(dev, PLINK_CLOSE, sta->addr, llid,
751 spin_unlock_bh(&sta->plink_lock);
755 /* should not get here, PLINK_BLOCKED is dealt with at the
756 * beggining of the function
758 spin_unlock_bh(&sta->plink_lock);