2 * Copyright (c) 2008, 2009 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.
10 #include <linux/kernel.h>
11 #include <linux/random.h>
12 #include "ieee80211_i.h"
16 #ifdef CONFIG_MAC80211_VERBOSE_MPL_DEBUG
17 #define mpl_dbg(fmt, args...) printk(KERN_DEBUG fmt, ##args)
19 #define mpl_dbg(fmt, args...) do { (void)(0); } while (0)
22 #define PLINK_GET_LLID(p) (p + 4)
23 #define PLINK_GET_PLID(p) (p + 6)
25 #define mod_plink_timer(s, t) (mod_timer(&s->plink_timer, \
26 jiffies + HZ * t / 1000))
28 /* Peer link cancel reasons, all subject to ANA approval */
29 #define MESH_LINK_CANCELLED 2
30 #define MESH_MAX_NEIGHBORS 3
31 #define MESH_CAPABILITY_POLICY_VIOLATION 4
32 #define MESH_CLOSE_RCVD 5
33 #define MESH_MAX_RETRIES 6
34 #define MESH_CONFIRM_TIMEOUT 7
35 #define MESH_SECURITY_ROLE_NEGOTIATION_DIFFERS 8
36 #define MESH_SECURITY_AUTHENTICATION_IMPOSSIBLE 9
37 #define MESH_SECURITY_FAILED_VERIFICATION 10
39 #define dot11MeshMaxRetries(s) (s->u.mesh.mshcfg.dot11MeshMaxRetries)
40 #define dot11MeshRetryTimeout(s) (s->u.mesh.mshcfg.dot11MeshRetryTimeout)
41 #define dot11MeshConfirmTimeout(s) (s->u.mesh.mshcfg.dot11MeshConfirmTimeout)
42 #define dot11MeshHoldingTimeout(s) (s->u.mesh.mshcfg.dot11MeshHoldingTimeout)
43 #define dot11MeshMaxPeerLinks(s) (s->u.mesh.mshcfg.dot11MeshMaxPeerLinks)
45 enum plink_frame_type {
64 void mesh_plink_inc_estab_count(struct ieee80211_sub_if_data *sdata)
66 atomic_inc(&sdata->u.mesh.mshstats.estab_plinks);
67 mesh_accept_plinks_update(sdata);
71 void mesh_plink_dec_estab_count(struct ieee80211_sub_if_data *sdata)
73 atomic_dec(&sdata->u.mesh.mshstats.estab_plinks);
74 mesh_accept_plinks_update(sdata);
78 * mesh_plink_fsm_restart - restart a mesh peer link finite state machine
80 * @sta: mesh peer link to restart
82 * Locking: this function must be called holding sta->lock
84 static inline void mesh_plink_fsm_restart(struct sta_info *sta)
86 sta->plink_state = NL80211_PLINK_LISTEN;
87 sta->llid = sta->plid = sta->reason = 0;
88 sta->plink_retries = 0;
92 * NOTE: This is just an alias for sta_info_alloc(), see notes
93 * on it in the lifecycle management section!
95 static struct sta_info *mesh_plink_alloc(struct ieee80211_sub_if_data *sdata,
96 u8 *hw_addr, u32 rates)
98 struct ieee80211_local *local = sdata->local;
101 if (local->num_sta >= MESH_MAX_PLINKS)
104 sta = sta_info_alloc(sdata, hw_addr, GFP_KERNEL);
108 sta->flags = WLAN_STA_AUTHORIZED | WLAN_STA_AUTH;
109 sta->sta.supp_rates[local->hw.conf.channel->band] = rates;
110 rate_control_rate_init(sta);
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->lock
124 static bool __mesh_plink_deactivate(struct sta_info *sta)
126 struct ieee80211_sub_if_data *sdata = sta->sdata;
127 bool deactivated = false;
129 if (sta->plink_state == NL80211_PLINK_ESTAB) {
130 mesh_plink_dec_estab_count(sdata);
133 sta->plink_state = NL80211_PLINK_BLOCKED;
134 mesh_path_flush_by_nexthop(sta);
140 * mesh_plink_deactivate - deactivate mesh peer link
142 * @sta: mesh peer link to deactivate
144 * All mesh paths with this peer as next hop will be flushed
146 void mesh_plink_deactivate(struct sta_info *sta)
148 struct ieee80211_sub_if_data *sdata = sta->sdata;
151 spin_lock_bh(&sta->lock);
152 deactivated = __mesh_plink_deactivate(sta);
153 spin_unlock_bh(&sta->lock);
156 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON);
159 static int mesh_plink_frame_tx(struct ieee80211_sub_if_data *sdata,
160 enum plink_frame_type action, u8 *da, __le16 llid, __le16 plid,
162 struct ieee80211_local *local = sdata->local;
163 struct sk_buff *skb = dev_alloc_skb(local->hw.extra_tx_headroom + 400 +
164 sdata->u.mesh.ie_len);
165 struct ieee80211_mgmt *mgmt;
166 bool include_plid = false;
167 static const u8 meshpeeringproto[] = { 0x00, 0x0F, 0xAC, 0x2A };
173 skb_reserve(skb, local->hw.extra_tx_headroom);
174 /* 25 is the size of the common mgmt part (24) plus the size of the
175 * common action part (1)
177 mgmt = (struct ieee80211_mgmt *)
178 skb_put(skb, 25 + sizeof(mgmt->u.action.u.plink_action));
179 memset(mgmt, 0, 25 + sizeof(mgmt->u.action.u.plink_action));
180 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
181 IEEE80211_STYPE_ACTION);
182 memcpy(mgmt->da, da, ETH_ALEN);
183 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
184 memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN);
185 mgmt->u.action.category = WLAN_CATEGORY_MESH_ACTION;
186 mgmt->u.action.u.plink_action.action_code = action;
188 if (action == PLINK_CLOSE)
189 mgmt->u.action.u.plink_action.aux = reason;
191 mgmt->u.action.u.plink_action.aux = cpu_to_le16(0x0);
192 if (action == PLINK_CONFIRM) {
193 pos = skb_put(skb, 4);
194 /* two-byte status code followed by two-byte AID */
196 memcpy(pos + 2, &plid, 2);
198 mesh_mgmt_ies_add(skb, sdata);
201 /* Add Peer Link Management element */
221 pos = skb_put(skb, 2 + ie_len);
222 *pos++ = WLAN_EID_PEER_LINK;
224 memcpy(pos, meshpeeringproto, sizeof(meshpeeringproto));
226 memcpy(pos, &llid, 2);
229 memcpy(pos, &plid, 2);
231 if (action == PLINK_CLOSE) {
233 memcpy(pos, &reason, 2);
236 ieee80211_tx_skb(sdata, skb);
240 void mesh_neighbour_update(u8 *hw_addr, u32 rates,
241 struct ieee80211_sub_if_data *sdata,
242 struct ieee802_11_elems *elems)
244 struct ieee80211_local *local = sdata->local;
245 struct sta_info *sta;
249 sta = sta_info_get(sdata, hw_addr);
252 /* Userspace handles peer allocation when security is enabled
254 if (sdata->u.mesh.security & IEEE80211_MESH_SEC_AUTHED)
255 cfg80211_notify_new_peer_candidate(sdata->dev, hw_addr,
256 elems->ie_start, elems->total_len,
259 sta = mesh_plink_alloc(sdata, hw_addr, rates);
262 if (sta_info_insert_rcu(sta)) {
268 sta->last_rx = jiffies;
269 sta->sta.supp_rates[local->hw.conf.channel->band] = rates;
270 if (mesh_peer_accepts_plinks(elems) &&
271 sta->plink_state == NL80211_PLINK_LISTEN &&
272 sdata->u.mesh.accepting_plinks &&
273 sdata->u.mesh.mshcfg.auto_open_plinks)
274 mesh_plink_open(sta);
279 static void mesh_plink_timer(unsigned long data)
281 struct sta_info *sta;
282 __le16 llid, plid, reason;
283 struct ieee80211_sub_if_data *sdata;
286 * This STA is valid because sta_info_destroy() will
287 * del_timer_sync() this timer after having made sure
288 * it cannot be readded (by deleting the plink.)
290 sta = (struct sta_info *) data;
292 if (sta->sdata->local->quiescing) {
293 sta->plink_timer_was_running = true;
297 spin_lock_bh(&sta->lock);
298 if (sta->ignore_plink_timer) {
299 sta->ignore_plink_timer = false;
300 spin_unlock_bh(&sta->lock);
303 mpl_dbg("Mesh plink timer for %pM fired on state %d\n",
304 sta->sta.addr, sta->plink_state);
310 switch (sta->plink_state) {
311 case NL80211_PLINK_OPN_RCVD:
312 case NL80211_PLINK_OPN_SNT:
314 if (sta->plink_retries < dot11MeshMaxRetries(sdata)) {
316 mpl_dbg("Mesh plink for %pM (retry, timeout): %d %d\n",
317 sta->sta.addr, sta->plink_retries,
319 get_random_bytes(&rand, sizeof(u32));
320 sta->plink_timeout = sta->plink_timeout +
321 rand % sta->plink_timeout;
322 ++sta->plink_retries;
323 mod_plink_timer(sta, sta->plink_timeout);
324 spin_unlock_bh(&sta->lock);
325 mesh_plink_frame_tx(sdata, PLINK_OPEN, sta->sta.addr, llid,
329 reason = cpu_to_le16(MESH_MAX_RETRIES);
330 /* fall through on else */
331 case NL80211_PLINK_CNF_RCVD:
334 reason = cpu_to_le16(MESH_CONFIRM_TIMEOUT);
335 sta->plink_state = NL80211_PLINK_HOLDING;
336 mod_plink_timer(sta, dot11MeshHoldingTimeout(sdata));
337 spin_unlock_bh(&sta->lock);
338 mesh_plink_frame_tx(sdata, PLINK_CLOSE, sta->sta.addr, llid, plid,
341 case NL80211_PLINK_HOLDING:
343 del_timer(&sta->plink_timer);
344 mesh_plink_fsm_restart(sta);
345 spin_unlock_bh(&sta->lock);
348 spin_unlock_bh(&sta->lock);
354 void mesh_plink_quiesce(struct sta_info *sta)
356 if (del_timer_sync(&sta->plink_timer))
357 sta->plink_timer_was_running = true;
360 void mesh_plink_restart(struct sta_info *sta)
362 if (sta->plink_timer_was_running) {
363 add_timer(&sta->plink_timer);
364 sta->plink_timer_was_running = false;
369 static inline void mesh_plink_timer_set(struct sta_info *sta, int timeout)
371 sta->plink_timer.expires = jiffies + (HZ * timeout / 1000);
372 sta->plink_timer.data = (unsigned long) sta;
373 sta->plink_timer.function = mesh_plink_timer;
374 sta->plink_timeout = timeout;
375 add_timer(&sta->plink_timer);
378 int mesh_plink_open(struct sta_info *sta)
381 struct ieee80211_sub_if_data *sdata = sta->sdata;
383 if (!test_sta_flags(sta, WLAN_STA_AUTH))
386 spin_lock_bh(&sta->lock);
387 get_random_bytes(&llid, 2);
389 if (sta->plink_state != NL80211_PLINK_LISTEN) {
390 spin_unlock_bh(&sta->lock);
393 sta->plink_state = NL80211_PLINK_OPN_SNT;
394 mesh_plink_timer_set(sta, dot11MeshRetryTimeout(sdata));
395 spin_unlock_bh(&sta->lock);
396 mpl_dbg("Mesh plink: starting establishment with %pM\n",
399 return mesh_plink_frame_tx(sdata, PLINK_OPEN,
400 sta->sta.addr, llid, 0, 0);
403 void mesh_plink_block(struct sta_info *sta)
405 struct ieee80211_sub_if_data *sdata = sta->sdata;
408 spin_lock_bh(&sta->lock);
409 deactivated = __mesh_plink_deactivate(sta);
410 sta->plink_state = NL80211_PLINK_BLOCKED;
411 spin_unlock_bh(&sta->lock);
414 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON);
418 void mesh_rx_plink_frame(struct ieee80211_sub_if_data *sdata, struct ieee80211_mgmt *mgmt,
419 size_t len, struct ieee80211_rx_status *rx_status)
421 struct ieee80211_local *local = sdata->local;
422 struct ieee802_11_elems elems;
423 struct sta_info *sta;
424 enum plink_event event;
425 enum plink_frame_type ftype;
427 bool deactivated, matches_local = true;
430 __le16 plid, llid, reason;
431 #ifdef CONFIG_MAC80211_VERBOSE_MPL_DEBUG
432 static const char *mplstates[] = {
433 [NL80211_PLINK_LISTEN] = "LISTEN",
434 [NL80211_PLINK_OPN_SNT] = "OPN-SNT",
435 [NL80211_PLINK_OPN_RCVD] = "OPN-RCVD",
436 [NL80211_PLINK_CNF_RCVD] = "CNF_RCVD",
437 [NL80211_PLINK_ESTAB] = "ESTAB",
438 [NL80211_PLINK_HOLDING] = "HOLDING",
439 [NL80211_PLINK_BLOCKED] = "BLOCKED"
443 /* need action_code, aux */
444 if (len < IEEE80211_MIN_ACTION_SIZE + 3)
447 if (is_multicast_ether_addr(mgmt->da)) {
448 mpl_dbg("Mesh plink: ignore frame from multicast address");
452 baseaddr = mgmt->u.action.u.plink_action.variable;
453 baselen = (u8 *) mgmt->u.action.u.plink_action.variable - (u8 *) mgmt;
454 if (mgmt->u.action.u.plink_action.action_code == PLINK_CONFIRM) {
458 ieee802_11_parse_elems(baseaddr, len - baselen, &elems);
459 if (!elems.peer_link) {
460 mpl_dbg("Mesh plink: missing necessary peer link ie\n");
464 sdata->u.mesh.security == IEEE80211_MESH_SEC_NONE) {
465 mpl_dbg("Mesh plink: can't establish link with secure peer\n");
469 ftype = mgmt->u.action.u.plink_action.action_code;
470 ie_len = elems.peer_link_len;
471 if ((ftype == PLINK_OPEN && ie_len != 6) ||
472 (ftype == PLINK_CONFIRM && ie_len != 8) ||
473 (ftype == PLINK_CLOSE && ie_len != 8 && ie_len != 10)) {
474 mpl_dbg("Mesh plink: incorrect plink ie length %d %d\n",
479 if (ftype != PLINK_CLOSE && (!elems.mesh_id || !elems.mesh_config)) {
480 mpl_dbg("Mesh plink: missing necessary ie\n");
483 /* Note the lines below are correct, the llid in the frame is the plid
484 * from the point of view of this host.
486 memcpy(&plid, PLINK_GET_LLID(elems.peer_link), 2);
487 if (ftype == PLINK_CONFIRM || (ftype == PLINK_CLOSE && ie_len == 10))
488 memcpy(&llid, PLINK_GET_PLID(elems.peer_link), 2);
492 sta = sta_info_get(sdata, mgmt->sa);
493 if (!sta && ftype != PLINK_OPEN) {
494 mpl_dbg("Mesh plink: cls or cnf from unknown peer\n");
499 if (sta && !test_sta_flags(sta, WLAN_STA_AUTH)) {
500 mpl_dbg("Mesh plink: Action frame from non-authed peer\n");
505 if (sta && sta->plink_state == NL80211_PLINK_BLOCKED) {
510 /* Now we will figure out the appropriate event... */
511 event = PLINK_UNDEFINED;
512 if (ftype != PLINK_CLOSE && (!mesh_matches_local(&elems, sdata))) {
513 matches_local = false;
527 if (!sta && !matches_local) {
529 reason = cpu_to_le16(MESH_CAPABILITY_POLICY_VIOLATION);
531 mesh_plink_frame_tx(sdata, PLINK_CLOSE, mgmt->sa, llid,
535 /* ftype == PLINK_OPEN */
540 if (!mesh_plink_free_count(sdata)) {
541 mpl_dbg("Mesh plink error: no more free plinks\n");
545 rates = ieee80211_sta_get_rates(local, &elems, rx_status->band);
546 sta = mesh_plink_alloc(sdata, mgmt->sa, rates);
548 mpl_dbg("Mesh plink error: plink table full\n");
551 if (sta_info_insert_rcu(sta)) {
556 spin_lock_bh(&sta->lock);
557 } else if (matches_local) {
558 spin_lock_bh(&sta->lock);
561 if (!mesh_plink_free_count(sdata) ||
562 (sta->plid && sta->plid != plid))
568 if (!mesh_plink_free_count(sdata) ||
569 (sta->llid != llid || sta->plid != plid))
575 if (sta->plink_state == NL80211_PLINK_ESTAB)
576 /* Do not check for llid or plid. This does not
577 * follow the standard but since multiple plinks
578 * per sta are not supported, it is necessary in
579 * order to avoid a livelock when MP A sees an
580 * establish peer link to MP B but MP B does not
581 * see it. This can be caused by a timeout in
582 * B's peer link establishment or B beign
586 else if (sta->plid != plid)
588 else if (ie_len == 7 && sta->llid != llid)
594 mpl_dbg("Mesh plink: unknown frame subtype\n");
595 spin_unlock_bh(&sta->lock);
600 spin_lock_bh(&sta->lock);
603 mpl_dbg("Mesh plink (peer, state, llid, plid, event): %pM %s %d %d %d\n",
604 mgmt->sa, mplstates[sta->plink_state],
605 le16_to_cpu(sta->llid), le16_to_cpu(sta->plid),
608 switch (sta->plink_state) {
609 /* spin_unlock as soon as state is updated at each case */
610 case NL80211_PLINK_LISTEN:
613 mesh_plink_fsm_restart(sta);
614 spin_unlock_bh(&sta->lock);
617 sta->plink_state = NL80211_PLINK_OPN_RCVD;
619 get_random_bytes(&llid, 2);
621 mesh_plink_timer_set(sta, dot11MeshRetryTimeout(sdata));
622 spin_unlock_bh(&sta->lock);
623 mesh_plink_frame_tx(sdata, PLINK_OPEN, sta->sta.addr, llid,
625 mesh_plink_frame_tx(sdata, PLINK_CONFIRM, sta->sta.addr,
629 spin_unlock_bh(&sta->lock);
634 case NL80211_PLINK_OPN_SNT:
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 = NL80211_PLINK_HOLDING;
644 if (!mod_plink_timer(sta,
645 dot11MeshHoldingTimeout(sdata)))
646 sta->ignore_plink_timer = true;
649 spin_unlock_bh(&sta->lock);
650 mesh_plink_frame_tx(sdata, PLINK_CLOSE, sta->sta.addr, llid,
654 /* retry timer is left untouched */
655 sta->plink_state = NL80211_PLINK_OPN_RCVD;
658 spin_unlock_bh(&sta->lock);
659 mesh_plink_frame_tx(sdata, PLINK_CONFIRM, sta->sta.addr, llid,
663 sta->plink_state = NL80211_PLINK_CNF_RCVD;
664 if (!mod_plink_timer(sta,
665 dot11MeshConfirmTimeout(sdata)))
666 sta->ignore_plink_timer = true;
668 spin_unlock_bh(&sta->lock);
671 spin_unlock_bh(&sta->lock);
676 case NL80211_PLINK_OPN_RCVD:
680 reason = cpu_to_le16(MESH_CAPABILITY_POLICY_VIOLATION);
683 reason = cpu_to_le16(MESH_CLOSE_RCVD);
684 sta->reason = reason;
685 sta->plink_state = NL80211_PLINK_HOLDING;
686 if (!mod_plink_timer(sta,
687 dot11MeshHoldingTimeout(sdata)))
688 sta->ignore_plink_timer = true;
691 spin_unlock_bh(&sta->lock);
692 mesh_plink_frame_tx(sdata, PLINK_CLOSE, sta->sta.addr, llid,
697 spin_unlock_bh(&sta->lock);
698 mesh_plink_frame_tx(sdata, PLINK_CONFIRM, sta->sta.addr, llid,
702 del_timer(&sta->plink_timer);
703 sta->plink_state = NL80211_PLINK_ESTAB;
704 spin_unlock_bh(&sta->lock);
705 mesh_plink_inc_estab_count(sdata);
706 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON);
707 mpl_dbg("Mesh plink with %pM ESTABLISHED\n",
711 spin_unlock_bh(&sta->lock);
716 case NL80211_PLINK_CNF_RCVD:
720 reason = cpu_to_le16(MESH_CAPABILITY_POLICY_VIOLATION);
723 reason = cpu_to_le16(MESH_CLOSE_RCVD);
724 sta->reason = reason;
725 sta->plink_state = NL80211_PLINK_HOLDING;
726 if (!mod_plink_timer(sta,
727 dot11MeshHoldingTimeout(sdata)))
728 sta->ignore_plink_timer = true;
731 spin_unlock_bh(&sta->lock);
732 mesh_plink_frame_tx(sdata, PLINK_CLOSE, sta->sta.addr, llid,
736 del_timer(&sta->plink_timer);
737 sta->plink_state = NL80211_PLINK_ESTAB;
738 spin_unlock_bh(&sta->lock);
739 mesh_plink_inc_estab_count(sdata);
740 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON);
741 mpl_dbg("Mesh plink with %pM ESTABLISHED\n",
743 mesh_plink_frame_tx(sdata, PLINK_CONFIRM, sta->sta.addr, llid,
747 spin_unlock_bh(&sta->lock);
752 case NL80211_PLINK_ESTAB:
755 reason = cpu_to_le16(MESH_CLOSE_RCVD);
756 sta->reason = reason;
757 deactivated = __mesh_plink_deactivate(sta);
758 sta->plink_state = NL80211_PLINK_HOLDING;
760 mod_plink_timer(sta, dot11MeshHoldingTimeout(sdata));
761 spin_unlock_bh(&sta->lock);
763 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON);
764 mesh_plink_frame_tx(sdata, PLINK_CLOSE, sta->sta.addr, llid,
769 spin_unlock_bh(&sta->lock);
770 mesh_plink_frame_tx(sdata, PLINK_CONFIRM, sta->sta.addr, llid,
774 spin_unlock_bh(&sta->lock);
778 case NL80211_PLINK_HOLDING:
781 if (del_timer(&sta->plink_timer))
782 sta->ignore_plink_timer = 1;
783 mesh_plink_fsm_restart(sta);
784 spin_unlock_bh(&sta->lock);
791 reason = sta->reason;
792 spin_unlock_bh(&sta->lock);
793 mesh_plink_frame_tx(sdata, PLINK_CLOSE, sta->sta.addr,
797 spin_unlock_bh(&sta->lock);
801 /* should not get here, PLINK_BLOCKED is dealt with at the
802 * beginning of the function
804 spin_unlock_bh(&sta->lock);