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);