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"
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 PLINK_GET_FRAME_SUBTYPE(p) (p)
22 #define PLINK_GET_LLID(p) (p + 1)
23 #define PLINK_GET_PLID(p) (p + 3)
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.sta.mshcfg.dot11MeshMaxRetries)
40 #define dot11MeshRetryTimeout(s) (s->u.sta.mshcfg.dot11MeshRetryTimeout)
41 #define dot11MeshConfirmTimeout(s) (s->u.sta.mshcfg.dot11MeshConfirmTimeout)
42 #define dot11MeshHoldingTimeout(s) (s->u.sta.mshcfg.dot11MeshHoldingTimeout)
43 #define dot11MeshMaxPeerLinks(s) (s->u.sta.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
.sta
.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
.sta
.mshstats
.estab_plinks
);
74 mesh_accept_plinks_update(sdata
);
78 * mesh_plink_fsm_restart - restart a mesh peer link finite state machine
80 * @sta: mes 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
= 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
, u64 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_ATOMIC
);
108 sta
->flags
= WLAN_STA_AUTHORIZED
;
109 sta
->supp_rates
[local
->hw
.conf
.channel
->band
] = rates
;
115 * mesh_plink_deactivate - deactivate mesh peer link
117 * @sta: mesh peer link to deactivate
119 * All mesh paths with this peer as next hop will be flushed
121 * Locking: the caller must hold sta->lock
123 static void __mesh_plink_deactivate(struct sta_info
*sta
)
125 struct ieee80211_sub_if_data
*sdata
= sta
->sdata
;
127 if (sta
->plink_state
== PLINK_ESTAB
)
128 mesh_plink_dec_estab_count(sdata
);
129 sta
->plink_state
= PLINK_BLOCKED
;
130 mesh_path_flush_by_nexthop(sta
);
134 * __mesh_plink_deactivate - deactivate mesh peer link
136 * @sta: mesh peer link to deactivate
138 * All mesh paths with this peer as next hop will be flushed
140 void mesh_plink_deactivate(struct sta_info
*sta
)
142 spin_lock_bh(&sta
->lock
);
143 __mesh_plink_deactivate(sta
);
144 spin_unlock_bh(&sta
->lock
);
147 static int mesh_plink_frame_tx(struct ieee80211_sub_if_data
*sdata
,
148 enum plink_frame_type action
, u8
*da
, __le16 llid
, __le16 plid
,
150 struct ieee80211_local
*local
= sdata
->local
;
151 struct sk_buff
*skb
= dev_alloc_skb(local
->hw
.extra_tx_headroom
+ 400);
152 struct ieee80211_mgmt
*mgmt
;
153 bool include_plid
= false;
159 skb_reserve(skb
, local
->hw
.extra_tx_headroom
);
160 /* 25 is the size of the common mgmt part (24) plus the size of the
161 * common action part (1)
163 mgmt
= (struct ieee80211_mgmt
*)
164 skb_put(skb
, 25 + sizeof(mgmt
->u
.action
.u
.plink_action
));
165 memset(mgmt
, 0, 25 + sizeof(mgmt
->u
.action
.u
.plink_action
));
166 mgmt
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_MGMT
|
167 IEEE80211_STYPE_ACTION
);
168 memcpy(mgmt
->da
, da
, ETH_ALEN
);
169 memcpy(mgmt
->sa
, sdata
->dev
->dev_addr
, ETH_ALEN
);
170 /* BSSID is left zeroed, wildcard value */
171 mgmt
->u
.action
.category
= PLINK_CATEGORY
;
172 mgmt
->u
.action
.u
.plink_action
.action_code
= action
;
174 if (action
== PLINK_CLOSE
)
175 mgmt
->u
.action
.u
.plink_action
.aux
= reason
;
177 mgmt
->u
.action
.u
.plink_action
.aux
= cpu_to_le16(0x0);
178 if (action
== PLINK_CONFIRM
) {
179 pos
= skb_put(skb
, 4);
180 /* two-byte status code followed by two-byte AID */
183 mesh_mgmt_ies_add(skb
, sdata
);
186 /* Add Peer Link Management element */
206 pos
= skb_put(skb
, 2 + ie_len
);
207 *pos
++ = WLAN_EID_PEER_LINK
;
210 memcpy(pos
, &llid
, 2);
213 memcpy(pos
, &plid
, 2);
215 if (action
== PLINK_CLOSE
) {
217 memcpy(pos
, &reason
, 2);
220 ieee80211_sta_tx(sdata
, skb
, 0);
224 void mesh_neighbour_update(u8
*hw_addr
, u64 rates
, struct ieee80211_sub_if_data
*sdata
,
225 bool peer_accepting_plinks
)
227 struct ieee80211_local
*local
= sdata
->local
;
228 struct sta_info
*sta
;
232 sta
= sta_info_get(local
, hw_addr
);
234 sta
= mesh_plink_alloc(sdata
, hw_addr
, rates
);
239 if (sta_info_insert(sta
)) {
245 sta
->last_rx
= jiffies
;
246 sta
->supp_rates
[local
->hw
.conf
.channel
->band
] = rates
;
247 if (peer_accepting_plinks
&& sta
->plink_state
== PLINK_LISTEN
&&
248 sdata
->u
.sta
.accepting_plinks
&&
249 sdata
->u
.sta
.mshcfg
.auto_open_plinks
)
250 mesh_plink_open(sta
);
255 static void mesh_plink_timer(unsigned long data
)
257 struct sta_info
*sta
;
258 __le16 llid
, plid
, reason
;
259 struct ieee80211_sub_if_data
*sdata
;
260 #ifdef CONFIG_MAC80211_VERBOSE_MPL_DEBUG
261 DECLARE_MAC_BUF(mac
);
265 * This STA is valid because sta_info_destroy() will
266 * del_timer_sync() this timer after having made sure
267 * it cannot be readded (by deleting the plink.)
269 sta
= (struct sta_info
*) data
;
271 spin_lock_bh(&sta
->lock
);
272 if (sta
->ignore_plink_timer
) {
273 sta
->ignore_plink_timer
= false;
274 spin_unlock_bh(&sta
->lock
);
277 mpl_dbg("Mesh plink timer for %s fired on state %d\n",
278 print_mac(mac
, sta
->addr
), sta
->plink_state
);
284 switch (sta
->plink_state
) {
288 if (sta
->plink_retries
< dot11MeshMaxRetries(sdata
)) {
290 mpl_dbg("Mesh plink for %s (retry, timeout): %d %d\n",
291 print_mac(mac
, sta
->addr
),
292 sta
->plink_retries
, sta
->plink_timeout
);
293 get_random_bytes(&rand
, sizeof(u32
));
294 sta
->plink_timeout
= sta
->plink_timeout
+
295 rand
% sta
->plink_timeout
;
296 ++sta
->plink_retries
;
297 mod_plink_timer(sta
, sta
->plink_timeout
);
298 spin_unlock_bh(&sta
->lock
);
299 mesh_plink_frame_tx(sdata
, PLINK_OPEN
, sta
->addr
, llid
,
303 reason
= cpu_to_le16(MESH_MAX_RETRIES
);
304 /* fall through on else */
308 reason
= cpu_to_le16(MESH_CONFIRM_TIMEOUT
);
309 sta
->plink_state
= PLINK_HOLDING
;
310 mod_plink_timer(sta
, dot11MeshHoldingTimeout(sdata
));
311 spin_unlock_bh(&sta
->lock
);
312 mesh_plink_frame_tx(sdata
, PLINK_CLOSE
, sta
->addr
, llid
, plid
,
317 del_timer(&sta
->plink_timer
);
318 mesh_plink_fsm_restart(sta
);
319 spin_unlock_bh(&sta
->lock
);
322 spin_unlock_bh(&sta
->lock
);
327 static inline void mesh_plink_timer_set(struct sta_info
*sta
, int timeout
)
329 sta
->plink_timer
.expires
= jiffies
+ (HZ
* timeout
/ 1000);
330 sta
->plink_timer
.data
= (unsigned long) sta
;
331 sta
->plink_timer
.function
= mesh_plink_timer
;
332 sta
->plink_timeout
= timeout
;
333 add_timer(&sta
->plink_timer
);
336 int mesh_plink_open(struct sta_info
*sta
)
339 struct ieee80211_sub_if_data
*sdata
= sta
->sdata
;
340 #ifdef CONFIG_MAC80211_VERBOSE_MPL_DEBUG
341 DECLARE_MAC_BUF(mac
);
344 spin_lock_bh(&sta
->lock
);
345 get_random_bytes(&llid
, 2);
347 if (sta
->plink_state
!= PLINK_LISTEN
) {
348 spin_unlock_bh(&sta
->lock
);
351 sta
->plink_state
= PLINK_OPN_SNT
;
352 mesh_plink_timer_set(sta
, dot11MeshRetryTimeout(sdata
));
353 spin_unlock_bh(&sta
->lock
);
354 mpl_dbg("Mesh plink: starting establishment with %s\n",
355 print_mac(mac
, sta
->addr
));
357 return mesh_plink_frame_tx(sdata
, PLINK_OPEN
,
358 sta
->addr
, llid
, 0, 0);
361 void mesh_plink_block(struct sta_info
*sta
)
363 #ifdef CONFIG_MAC80211_VERBOSE_MPL_DEBUG
364 DECLARE_MAC_BUF(mac
);
367 spin_lock_bh(&sta
->lock
);
368 __mesh_plink_deactivate(sta
);
369 sta
->plink_state
= PLINK_BLOCKED
;
370 spin_unlock_bh(&sta
->lock
);
373 int mesh_plink_close(struct sta_info
*sta
)
375 struct ieee80211_sub_if_data
*sdata
= sta
->sdata
;
376 __le16 llid
, plid
, reason
;
377 #ifdef CONFIG_MAC80211_VERBOSE_MPL_DEBUG
378 DECLARE_MAC_BUF(mac
);
381 mpl_dbg("Mesh plink: closing link with %s\n",
382 print_mac(mac
, sta
->addr
));
383 spin_lock_bh(&sta
->lock
);
384 sta
->reason
= cpu_to_le16(MESH_LINK_CANCELLED
);
385 reason
= sta
->reason
;
387 if (sta
->plink_state
== PLINK_LISTEN
||
388 sta
->plink_state
== PLINK_BLOCKED
) {
389 mesh_plink_fsm_restart(sta
);
390 spin_unlock_bh(&sta
->lock
);
392 } else if (sta
->plink_state
== PLINK_ESTAB
) {
393 __mesh_plink_deactivate(sta
);
394 /* The timer should not be running */
395 mod_plink_timer(sta
, dot11MeshHoldingTimeout(sdata
));
396 } else if (!mod_plink_timer(sta
, dot11MeshHoldingTimeout(sdata
)))
397 sta
->ignore_plink_timer
= true;
399 sta
->plink_state
= PLINK_HOLDING
;
402 spin_unlock_bh(&sta
->lock
);
403 mesh_plink_frame_tx(sta
->sdata
, PLINK_CLOSE
, sta
->addr
, llid
,
408 void mesh_rx_plink_frame(struct ieee80211_sub_if_data
*sdata
, struct ieee80211_mgmt
*mgmt
,
409 size_t len
, struct ieee80211_rx_status
*rx_status
)
411 struct ieee80211_local
*local
= sdata
->local
;
412 struct ieee802_11_elems elems
;
413 struct sta_info
*sta
;
414 enum plink_event event
;
415 enum plink_frame_type ftype
;
419 __le16 plid
, llid
, reason
;
420 #ifdef CONFIG_MAC80211_VERBOSE_MPL_DEBUG
421 DECLARE_MAC_BUF(mac
);
424 if (is_multicast_ether_addr(mgmt
->da
)) {
425 mpl_dbg("Mesh plink: ignore frame from multicast address");
429 baseaddr
= mgmt
->u
.action
.u
.plink_action
.variable
;
430 baselen
= (u8
*) mgmt
->u
.action
.u
.plink_action
.variable
- (u8
*) mgmt
;
431 if (mgmt
->u
.action
.u
.plink_action
.action_code
== PLINK_CONFIRM
) {
435 ieee802_11_parse_elems(baseaddr
, len
- baselen
, &elems
);
436 if (!elems
.peer_link
) {
437 mpl_dbg("Mesh plink: missing necessary peer link ie\n");
441 ftype
= *((u8
*)PLINK_GET_FRAME_SUBTYPE(elems
.peer_link
));
442 ie_len
= elems
.peer_link_len
;
443 if ((ftype
== PLINK_OPEN
&& ie_len
!= 3) ||
444 (ftype
== PLINK_CONFIRM
&& ie_len
!= 5) ||
445 (ftype
== PLINK_CLOSE
&& ie_len
!= 5 && ie_len
!= 7)) {
446 mpl_dbg("Mesh plink: incorrect plink ie length\n");
450 if (ftype
!= PLINK_CLOSE
&& (!elems
.mesh_id
|| !elems
.mesh_config
)) {
451 mpl_dbg("Mesh plink: missing necessary ie\n");
454 /* Note the lines below are correct, the llid in the frame is the plid
455 * from the point of view of this host.
457 memcpy(&plid
, PLINK_GET_LLID(elems
.peer_link
), 2);
458 if (ftype
== PLINK_CONFIRM
|| (ftype
== PLINK_CLOSE
&& ie_len
== 7))
459 memcpy(&llid
, PLINK_GET_PLID(elems
.peer_link
), 2);
463 sta
= sta_info_get(local
, mgmt
->sa
);
464 if (!sta
&& ftype
!= PLINK_OPEN
) {
465 mpl_dbg("Mesh plink: cls or cnf from unknown peer\n");
470 if (sta
&& sta
->plink_state
== PLINK_BLOCKED
) {
475 /* Now we will figure out the appropriate event... */
476 event
= PLINK_UNDEFINED
;
477 if (ftype
!= PLINK_CLOSE
&& (!mesh_matches_local(&elems
, sdata
))) {
489 spin_lock_bh(&sta
->lock
);
491 /* ftype == PLINK_OPEN */
493 if (!mesh_plink_free_count(sdata
)) {
494 mpl_dbg("Mesh plink error: no more free plinks\n");
499 rates
= ieee80211_sta_get_rates(local
, &elems
, rx_status
->band
);
500 sta
= mesh_plink_alloc(sdata
, mgmt
->sa
, rates
);
502 mpl_dbg("Mesh plink error: plink table full\n");
506 if (sta_info_insert(sta
)) {
511 spin_lock_bh(&sta
->lock
);
513 spin_lock_bh(&sta
->lock
);
516 if (!mesh_plink_free_count(sdata
) ||
517 (sta
->plid
&& sta
->plid
!= plid
))
523 if (!mesh_plink_free_count(sdata
) ||
524 (sta
->llid
!= llid
|| sta
->plid
!= plid
))
530 if (sta
->plink_state
== PLINK_ESTAB
)
531 /* Do not check for llid or plid. This does not
532 * follow the standard but since multiple plinks
533 * per sta are not supported, it is necessary in
534 * order to avoid a livelock when MP A sees an
535 * establish peer link to MP B but MP B does not
536 * see it. This can be caused by a timeout in
537 * B's peer link establishment or B beign
541 else if (sta
->plid
!= plid
)
543 else if (ie_len
== 7 && sta
->llid
!= llid
)
549 mpl_dbg("Mesh plink: unknown frame subtype\n");
550 spin_unlock_bh(&sta
->lock
);
556 mpl_dbg("Mesh plink (peer, state, llid, plid, event): %s %d %d %d %d\n",
557 print_mac(mac
, mgmt
->sa
), sta
->plink_state
,
558 le16_to_cpu(sta
->llid
), le16_to_cpu(sta
->plid
),
561 switch (sta
->plink_state
) {
562 /* spin_unlock as soon as state is updated at each case */
566 mesh_plink_fsm_restart(sta
);
567 spin_unlock_bh(&sta
->lock
);
570 sta
->plink_state
= PLINK_OPN_RCVD
;
572 get_random_bytes(&llid
, 2);
574 mesh_plink_timer_set(sta
, dot11MeshRetryTimeout(sdata
));
575 spin_unlock_bh(&sta
->lock
);
576 mesh_plink_frame_tx(sdata
, PLINK_OPEN
, sta
->addr
, llid
,
578 mesh_plink_frame_tx(sdata
, PLINK_CONFIRM
, sta
->addr
,
582 spin_unlock_bh(&sta
->lock
);
591 reason
= cpu_to_le16(MESH_CAPABILITY_POLICY_VIOLATION
);
594 reason
= cpu_to_le16(MESH_CLOSE_RCVD
);
595 sta
->reason
= reason
;
596 sta
->plink_state
= PLINK_HOLDING
;
597 if (!mod_plink_timer(sta
,
598 dot11MeshHoldingTimeout(sdata
)))
599 sta
->ignore_plink_timer
= true;
602 spin_unlock_bh(&sta
->lock
);
603 mesh_plink_frame_tx(sdata
, PLINK_CLOSE
, sta
->addr
, llid
,
607 /* retry timer is left untouched */
608 sta
->plink_state
= PLINK_OPN_RCVD
;
611 spin_unlock_bh(&sta
->lock
);
612 mesh_plink_frame_tx(sdata
, PLINK_CONFIRM
, sta
->addr
, llid
,
616 sta
->plink_state
= PLINK_CNF_RCVD
;
617 if (!mod_plink_timer(sta
,
618 dot11MeshConfirmTimeout(sdata
)))
619 sta
->ignore_plink_timer
= true;
621 spin_unlock_bh(&sta
->lock
);
624 spin_unlock_bh(&sta
->lock
);
633 reason
= cpu_to_le16(MESH_CAPABILITY_POLICY_VIOLATION
);
636 reason
= cpu_to_le16(MESH_CLOSE_RCVD
);
637 sta
->reason
= reason
;
638 sta
->plink_state
= PLINK_HOLDING
;
639 if (!mod_plink_timer(sta
,
640 dot11MeshHoldingTimeout(sdata
)))
641 sta
->ignore_plink_timer
= true;
644 spin_unlock_bh(&sta
->lock
);
645 mesh_plink_frame_tx(sdata
, PLINK_CLOSE
, sta
->addr
, llid
,
650 spin_unlock_bh(&sta
->lock
);
651 mesh_plink_frame_tx(sdata
, PLINK_CONFIRM
, sta
->addr
, llid
,
655 del_timer(&sta
->plink_timer
);
656 sta
->plink_state
= PLINK_ESTAB
;
657 mesh_plink_inc_estab_count(sdata
);
658 spin_unlock_bh(&sta
->lock
);
659 mpl_dbg("Mesh plink with %s ESTABLISHED\n",
660 print_mac(mac
, sta
->addr
));
663 spin_unlock_bh(&sta
->lock
);
672 reason
= cpu_to_le16(MESH_CAPABILITY_POLICY_VIOLATION
);
675 reason
= cpu_to_le16(MESH_CLOSE_RCVD
);
676 sta
->reason
= reason
;
677 sta
->plink_state
= PLINK_HOLDING
;
678 if (!mod_plink_timer(sta
,
679 dot11MeshHoldingTimeout(sdata
)))
680 sta
->ignore_plink_timer
= true;
683 spin_unlock_bh(&sta
->lock
);
684 mesh_plink_frame_tx(sdata
, PLINK_CLOSE
, sta
->addr
, llid
,
688 del_timer(&sta
->plink_timer
);
689 sta
->plink_state
= PLINK_ESTAB
;
690 mesh_plink_inc_estab_count(sdata
);
691 spin_unlock_bh(&sta
->lock
);
692 mpl_dbg("Mesh plink with %s ESTABLISHED\n",
693 print_mac(mac
, sta
->addr
));
694 mesh_plink_frame_tx(sdata
, PLINK_CONFIRM
, sta
->addr
, llid
,
698 spin_unlock_bh(&sta
->lock
);
706 reason
= cpu_to_le16(MESH_CLOSE_RCVD
);
707 sta
->reason
= reason
;
708 __mesh_plink_deactivate(sta
);
709 sta
->plink_state
= PLINK_HOLDING
;
711 mod_plink_timer(sta
, dot11MeshHoldingTimeout(sdata
));
712 spin_unlock_bh(&sta
->lock
);
713 mesh_plink_frame_tx(sdata
, PLINK_CLOSE
, sta
->addr
, llid
,
718 spin_unlock_bh(&sta
->lock
);
719 mesh_plink_frame_tx(sdata
, PLINK_CONFIRM
, sta
->addr
, llid
,
723 spin_unlock_bh(&sta
->lock
);
730 if (del_timer(&sta
->plink_timer
))
731 sta
->ignore_plink_timer
= 1;
732 mesh_plink_fsm_restart(sta
);
733 spin_unlock_bh(&sta
->lock
);
740 reason
= sta
->reason
;
741 spin_unlock_bh(&sta
->lock
);
742 mesh_plink_frame_tx(sdata
, PLINK_CLOSE
, sta
->addr
, llid
,
746 spin_unlock_bh(&sta
->lock
);
750 /* should not get here, PLINK_BLOCKED is dealt with at the
751 * beggining of the function
753 spin_unlock_bh(&sta
->lock
);