]> bbs.cooldavid.org Git - net-next-2.6.git/blame - net/mac80211/mesh_plink.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
mac80211: RCU-ify STA info structure access
[net-next-2.6.git] / net / mac80211 / mesh_plink.c
CommitLineData
c3896d2c
LCC		 1/*
2 * Copyright (c) 2008 open80211s Ltd.
3 * Author: Luis Carlos Cobo <luisca@cozybit.com>
4 *
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.
8 */
902acc78
JB		 9#include <linux/kernel.h>
10#include <linux/random.h>
c3896d2c
LCC		 11#include "ieee80211_i.h"
12#include "ieee80211_rate.h"
13#include "mesh.h"
c3896d2c
LCC		 14
15#ifdef CONFIG_MAC80211_VERBOSE_MPL_DEBUG
16#define mpl_dbg(fmt, args...) printk(KERN_DEBUG fmt, ##args)
17#else
18#define mpl_dbg(fmt, args...) do { (void)(0); } while (0)
19#endif
20
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)
25
26#define mod_plink_timer(s, t) (mod_timer(&s->plink_timer, \
27 jiffies + HZ * t / 1000))
28
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
39
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)
45
46enum plink_frame_type {
47 PLINK_OPEN = 0,
48 PLINK_CONFIRM,
49 PLINK_CLOSE
50};
51
52enum plink_event {
53 PLINK_UNDEFINED,
54 OPN_ACPT,
55 OPN_RJCT,
56 OPN_IGNR,
57 CNF_ACPT,
58 CNF_RJCT,
59 CNF_IGNR,
60 CLS_ACPT,
61 CLS_IGNR
62};
63
64static inline
65void mesh_plink_inc_estab_count(struct ieee80211_sub_if_data *sdata)
66{
67 atomic_inc(&sdata->u.sta.mshstats.estab_plinks);
d0709a65 68 mesh_accept_plinks_update(sdata);
c3896d2c
LCC		 69}
70
71static inline
72void mesh_plink_dec_estab_count(struct ieee80211_sub_if_data *sdata)
73{
74 atomic_dec(&sdata->u.sta.mshstats.estab_plinks);
d0709a65 75 mesh_accept_plinks_update(sdata);
c3896d2c
LCC		 76}
77
78/**
79 * mesh_plink_fsm_restart - restart a mesh peer link finite state machine
80 *
81 * @sta: mes peer link to restart
82 *
83 * Locking: this function must be called holding sta->plink_lock
84 */
85static inline void mesh_plink_fsm_restart(struct sta_info *sta)
86{
87 sta->plink_state = LISTEN;
88 sta->llid = sta->plid = sta->reason = sta->plink_retries = 0;
89}
90
91/**
92 * mesh_plink_add - allocate and add a new mesh peer link
93 *
94 * @hw_addr: hardware address (ETH_ALEN length)
95 * @rates: rates the mesh peer supports
96 * @dev: local mesh interface
97 *
98 * The initial state of the new plink is set to LISTEN
99 *
100 * Returns: non-NULL on success, ERR_PTR() on error.
101 */
d0709a65
JB		 102struct sta_info *mesh_plink_add(u8 *hw_addr, u64 rates,
103 struct ieee80211_sub_if_data *sdata)
c3896d2c 104{
d0709a65 105 struct ieee80211_local *local = sdata->local;
c3896d2c
LCC		 106 struct sta_info *sta;
107
d0709a65 108 if (compare_ether_addr(hw_addr, sdata->dev->dev_addr) == 0)
c3896d2c
LCC		 109 /* never add ourselves as neighbours */
110 return ERR_PTR(-EINVAL);
111
112 if (is_multicast_ether_addr(hw_addr))
113 return ERR_PTR(-EINVAL);
114
115 if (local->num_sta >= MESH_MAX_PLINKS)
116 return ERR_PTR(-ENOSPC);
117
d0709a65 118 sta = sta_info_add(sdata, hw_addr);
c3896d2c
LCC		 119 if (IS_ERR(sta))
120 return sta;
121
122 sta->plink_state = LISTEN;
123 spin_lock_init(&sta->plink_lock);
124 init_timer(&sta->plink_timer);
125 sta->flags |= WLAN_STA_AUTHORIZED;
126 sta->supp_rates[local->hw.conf.channel->band] = rates;
127 rate_control_rate_init(sta, local);
128
d0709a65 129 mesh_accept_plinks_update(sdata);
c3896d2c
LCC		 130
131 return sta;
132}
133
134/**
42096b63 135 * mesh_plink_deactivate - deactivate mesh peer link
c3896d2c
LCC		 136 *
137 * @sta: mesh peer link to deactivate
138 *
139 * All mesh paths with this peer as next hop will be flushed
140 *
141 * Locking: the caller must hold sta->plink_lock
142 */
902acc78 143static void __mesh_plink_deactivate(struct sta_info *sta)
c3896d2c 144{
d0709a65
JB		 145 struct ieee80211_sub_if_data *sdata = sta->sdata;
146
c3896d2c
LCC		 147 if (sta->plink_state == ESTAB)
148 mesh_plink_dec_estab_count(sdata);
149 sta->plink_state = BLOCKED;
150 mesh_path_flush_by_nexthop(sta);
151}
152
902acc78
JB		 153/**
154 * __mesh_plink_deactivate - deactivate mesh peer link
155 *
156 * @sta: mesh peer link to deactivate
157 *
158 * All mesh paths with this peer as next hop will be flushed
159 */
160void mesh_plink_deactivate(struct sta_info *sta)
161{
162 spin_lock_bh(&sta->plink_lock);
163 __mesh_plink_deactivate(sta);
164 spin_unlock_bh(&sta->plink_lock);
165}
166
c3896d2c
LCC		 167static int mesh_plink_frame_tx(struct net_device *dev,
168 enum plink_frame_type action, u8 *da, __le16 llid, __le16 plid,
169 __le16 reason) {
170 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
171 struct sk_buff *skb = dev_alloc_skb(local->hw.extra_tx_headroom + 400);
172 struct ieee80211_mgmt *mgmt;
173 bool include_plid = false;
174 u8 *pos;
175 int ie_len;
176
177 if (!skb)
178 return -1;
179 skb_reserve(skb, local->hw.extra_tx_headroom);
180 /* 25 is the size of the common mgmt part (24) plus the size of the
181 * common action part (1)
182 */
183 mgmt = (struct ieee80211_mgmt *)
184 skb_put(skb, 25 + sizeof(mgmt->u.action.u.plink_action));
185 memset(mgmt, 0, 25 + sizeof(mgmt->u.action.u.plink_action));
186 mgmt->frame_control = IEEE80211_FC(IEEE80211_FTYPE_MGMT,
187 IEEE80211_STYPE_ACTION);
188 memcpy(mgmt->da, da, ETH_ALEN);
189 memcpy(mgmt->sa, dev->dev_addr, ETH_ALEN);
190 /* BSSID is left zeroed, wildcard value */
191 mgmt->u.action.category = PLINK_CATEGORY;
192 mgmt->u.action.u.plink_action.action_code = action;
193
194 if (action == PLINK_CLOSE)
195 mgmt->u.action.u.plink_action.aux = reason;
196 else {
197 mgmt->u.action.u.plink_action.aux = cpu_to_le16(0x0);
198 if (action == PLINK_CONFIRM) {
199 pos = skb_put(skb, 4);
200 /* two-byte status code followed by two-byte AID */
201 memset(pos, 0, 4);
202 }
203 mesh_mgmt_ies_add(skb, dev);
204 }
205
206 /* Add Peer Link Management element */
207 switch (action) {
208 case PLINK_OPEN:
209 ie_len = 3;
210 break;
211 case PLINK_CONFIRM:
212 ie_len = 5;
213 include_plid = true;
214 break;
215 case PLINK_CLOSE:
216 default:
217 if (!plid)
218 ie_len = 5;
219 else {
220 ie_len = 7;
221 include_plid = true;
222 }
223 break;
224 }
225
226 pos = skb_put(skb, 2 + ie_len);
227 *pos++ = WLAN_EID_PEER_LINK;
228 *pos++ = ie_len;
229 *pos++ = action;
230 memcpy(pos, &llid, 2);
231 if (include_plid) {
232 pos += 2;
233 memcpy(pos, &plid, 2);
234 }
235 if (action == PLINK_CLOSE) {
236 pos += 2;
237 memcpy(pos, &reason, 2);
238 }
239
240 ieee80211_sta_tx(dev, skb, 0);
241 return 0;
242}
243
244void mesh_neighbour_update(u8 *hw_addr, u64 rates, struct net_device *dev,
245 bool peer_accepting_plinks)
246{
247 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
248 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
249 struct sta_info *sta;
250
d0709a65
JB		 251 rcu_read_lock();
252
c3896d2c
LCC		 253 sta = sta_info_get(local, hw_addr);
254 if (!sta) {
d0709a65
JB		 255 sta = mesh_plink_add(hw_addr, rates, sdata);
256 if (IS_ERR(sta)) {
257 rcu_read_unlock();
c3896d2c 258 return;
d0709a65 259 }
c3896d2c
LCC		 260 }
261
262 sta->last_rx = jiffies;
263 sta->supp_rates[local->hw.conf.channel->band] = rates;
264 if (peer_accepting_plinks && sta->plink_state == LISTEN &&
265 sdata->u.sta.accepting_plinks &&
266 sdata->u.sta.mshcfg.auto_open_plinks)
267 mesh_plink_open(sta);
268
d0709a65 269 rcu_read_unlock();
c3896d2c
LCC		 270}
271
272static void mesh_plink_timer(unsigned long data)
273{
274 struct sta_info *sta;
275 __le16 llid, plid, reason;
276 struct net_device *dev = NULL;
277 struct ieee80211_sub_if_data *sdata;
278#ifdef CONFIG_MAC80211_VERBOSE_MPL_DEBUG
279 DECLARE_MAC_BUF(mac);
280#endif
281
d0709a65
JB		 282 /*
283 * This STA is valid because sta_info_destroy() will
284 * del_timer_sync() this timer after having made sure
285 * it cannot be readded (by deleting the plink.)
286 */
c3896d2c
LCC		 287 sta = (struct sta_info *) data;
288
289 spin_lock_bh(&sta->plink_lock);
290 if (sta->ignore_plink_timer) {
291 sta->ignore_plink_timer = false;
292 spin_unlock_bh(&sta->plink_lock);
293 return;
294 }
295 mpl_dbg("Mesh plink timer for %s fired on state %d\n",
296 print_mac(mac, sta->addr), sta->plink_state);
297 reason = 0;
298 llid = sta->llid;
299 plid = sta->plid;
d0709a65
JB		 300 sdata = sta->sdata;
301 dev = sdata->dev;
c3896d2c
LCC		 302
303 switch (sta->plink_state) {
304 case OPN_RCVD:
305 case OPN_SNT:
306 /* retry timer */
307 if (sta->plink_retries < dot11MeshMaxRetries(sdata)) {
308 u32 rand;
309 mpl_dbg("Mesh plink for %s (retry, timeout): %d %d\n",
310 print_mac(mac, sta->addr),
311 sta->plink_retries, sta->plink_timeout);
312 get_random_bytes(&rand, sizeof(u32));
313 sta->plink_timeout = sta->plink_timeout +
314 rand % sta->plink_timeout;
315 ++sta->plink_retries;
d0709a65 316 mod_plink_timer(sta, sta->plink_timeout);
c3896d2c
LCC		 317 spin_unlock_bh(&sta->plink_lock);
318 mesh_plink_frame_tx(dev, PLINK_OPEN, sta->addr, llid,
319 0, 0);
320 break;
321 }
322 reason = cpu_to_le16(MESH_MAX_RETRIES);
323 /* fall through on else */
324 case CNF_RCVD:
325 /* confirm timer */
326 if (!reason)
327 reason = cpu_to_le16(MESH_CONFIRM_TIMEOUT);
328 sta->plink_state = HOLDING;
d0709a65 329 mod_plink_timer(sta, dot11MeshHoldingTimeout(sdata));
c3896d2c
LCC		 330 spin_unlock_bh(&sta->plink_lock);
331 mesh_plink_frame_tx(dev, PLINK_CLOSE, sta->addr, llid, plid,
332 reason);
333 break;
334 case HOLDING:
335 /* holding timer */
d0709a65 336 del_timer(&sta->plink_timer);
c3896d2c
LCC		 337 mesh_plink_fsm_restart(sta);
338 spin_unlock_bh(&sta->plink_lock);
339 break;
340 default:
341 spin_unlock_bh(&sta->plink_lock);
342 break;
343 }
c3896d2c
LCC		 344}
345
346static inline void mesh_plink_timer_set(struct sta_info *sta, int timeout)
347{
348 sta->plink_timer.expires = jiffies + (HZ * timeout / 1000);
349 sta->plink_timer.data = (unsigned long) sta;
350 sta->plink_timer.function = mesh_plink_timer;
351 sta->plink_timeout = timeout;
c3896d2c
LCC		 352 add_timer(&sta->plink_timer);
353}
354
355int mesh_plink_open(struct sta_info *sta)
356{
357 __le16 llid;
d0709a65 358 struct ieee80211_sub_if_data *sdata = sta->sdata;
c3896d2c
LCC		 359#ifdef CONFIG_MAC80211_VERBOSE_MPL_DEBUG
360 DECLARE_MAC_BUF(mac);
361#endif
362
363 spin_lock_bh(&sta->plink_lock);
364 get_random_bytes(&llid, 2);
365 sta->llid = llid;
366 if (sta->plink_state != LISTEN) {
367 spin_unlock_bh(&sta->plink_lock);
c3896d2c
LCC		 368 return -EBUSY;
369 }
370 sta->plink_state = OPN_SNT;
371 mesh_plink_timer_set(sta, dot11MeshRetryTimeout(sdata));
372 spin_unlock_bh(&sta->plink_lock);
373 mpl_dbg("Mesh plink: starting establishment with %s\n",
374 print_mac(mac, sta->addr));
375
d0709a65
JB		 376 return mesh_plink_frame_tx(sdata->dev, PLINK_OPEN,
377 sta->addr, llid, 0, 0);
c3896d2c
LCC		 378}
379
380void mesh_plink_block(struct sta_info *sta)
381{
382#ifdef CONFIG_MAC80211_VERBOSE_MPL_DEBUG
383 DECLARE_MAC_BUF(mac);
384#endif
385
386 spin_lock_bh(&sta->plink_lock);
902acc78 387 __mesh_plink_deactivate(sta);
c3896d2c
LCC		 388 sta->plink_state = BLOCKED;
389 spin_unlock_bh(&sta->plink_lock);
390}
391
392int mesh_plink_close(struct sta_info *sta)
393{
d0709a65 394 struct ieee80211_sub_if_data *sdata = sta->sdata;
c3896d2c
LCC		 395 int llid, plid, reason;
396#ifdef CONFIG_MAC80211_VERBOSE_MPL_DEBUG
397 DECLARE_MAC_BUF(mac);
398#endif
399
400 mpl_dbg("Mesh plink: closing link with %s\n",
401 print_mac(mac, sta->addr));
402 spin_lock_bh(&sta->plink_lock);
403 sta->reason = cpu_to_le16(MESH_LINK_CANCELLED);
404 reason = sta->reason;
405
406 if (sta->plink_state == LISTEN || sta->plink_state == BLOCKED) {
407 mesh_plink_fsm_restart(sta);
408 spin_unlock_bh(&sta->plink_lock);
c3896d2c
LCC		 409 return 0;
410 } else if (sta->plink_state == ESTAB) {
902acc78 411 __mesh_plink_deactivate(sta);
c3896d2c 412 /* The timer should not be running */
d0709a65 413 mod_plink_timer(sta, dot11MeshHoldingTimeout(sdata));
c3896d2c
LCC		 414 } else if (!mod_plink_timer(sta, dot11MeshHoldingTimeout(sdata)))
415 sta->ignore_plink_timer = true;
416
417 sta->plink_state = HOLDING;
418 llid = sta->llid;
419 plid = sta->plid;
420 spin_unlock_bh(&sta->plink_lock);
d0709a65
JB		 421 mesh_plink_frame_tx(sta->sdata->dev, PLINK_CLOSE, sta->addr, llid,
422 plid, reason);
c3896d2c
LCC		 423 return 0;
424}
425
426void mesh_rx_plink_frame(struct net_device *dev, struct ieee80211_mgmt *mgmt,
427 size_t len, struct ieee80211_rx_status *rx_status)
428{
d0709a65
JB		 429 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
430 struct ieee80211_local *local = sdata->local;
c3896d2c
LCC		 431 struct ieee802_11_elems elems;
432 struct sta_info *sta;
433 enum plink_event event;
434 enum plink_frame_type ftype;
435 size_t baselen;
436 u8 ie_len;
437 u8 *baseaddr;
438 __le16 plid, llid, reason;
439#ifdef CONFIG_MAC80211_VERBOSE_MPL_DEBUG
440 DECLARE_MAC_BUF(mac);
441#endif
c3896d2c
LCC		 442
443 if (is_multicast_ether_addr(mgmt->da)) {
444 mpl_dbg("Mesh plink: ignore frame from multicast address");
445 return;
446 }
447
448 baseaddr = mgmt->u.action.u.plink_action.variable;
449 baselen = (u8 *) mgmt->u.action.u.plink_action.variable - (u8 *) mgmt;
450 if (mgmt->u.action.u.plink_action.action_code == PLINK_CONFIRM) {
451 baseaddr += 4;
452 baselen -= 4;
453 }
454 ieee802_11_parse_elems(baseaddr, len - baselen, &elems);
455 if (!elems.peer_link) {
456 mpl_dbg("Mesh plink: missing necessary peer link ie\n");
457 return;
458 }
459
460 ftype = *((u8 *)PLINK_GET_FRAME_SUBTYPE(elems.peer_link));
461 ie_len = elems.peer_link_len;
462 if ((ftype == PLINK_OPEN && ie_len != 3) ||
463 (ftype == PLINK_CONFIRM && ie_len != 5) ||
464 (ftype == PLINK_CLOSE && ie_len != 5 && ie_len != 7)) {
465 mpl_dbg("Mesh plink: incorrect plink ie length\n");
466 return;
467 }
468
469 if (ftype != PLINK_CLOSE && (!elems.mesh_id || !elems.mesh_config)) {
470 mpl_dbg("Mesh plink: missing necessary ie\n");
471 return;
472 }
473 /* Note the lines below are correct, the llid in the frame is the plid
474 * from the point of view of this host.
475 */
476 memcpy(&plid, PLINK_GET_LLID(elems.peer_link), 2);
477 if (ftype == PLINK_CONFIRM || (ftype == PLINK_CLOSE && ie_len == 7))
478 memcpy(&llid, PLINK_GET_PLID(elems.peer_link), 2);
479
d0709a65
JB		 480 rcu_read_lock();
481
c3896d2c
LCC		 482 sta = sta_info_get(local, mgmt->sa);
483 if (!sta && ftype != PLINK_OPEN) {
484 mpl_dbg("Mesh plink: cls or cnf from unknown peer\n");
d0709a65 485 rcu_read_unlock();
c3896d2c
LCC		 486 return;
487 }
488
489 if (sta && sta->plink_state == BLOCKED) {
d0709a65 490 rcu_read_unlock();
c3896d2c
LCC		 491 return;
492 }
493
494 /* Now we will figure out the appropriate event... */
495 event = PLINK_UNDEFINED;
496 if (ftype != PLINK_CLOSE && (!mesh_matches_local(&elems, dev))) {
497 switch (ftype) {
498 case PLINK_OPEN:
499 event = OPN_RJCT;
500 break;
501 case PLINK_CONFIRM:
502 event = CNF_RJCT;
503 break;
504 case PLINK_CLOSE:
505 /* avoid warning */
506 break;
507 }
508 spin_lock_bh(&sta->plink_lock);
509 } else if (!sta) {
510 /* ftype == PLINK_OPEN */
511 u64 rates;
512 if (!mesh_plink_free_count(sdata)) {
513 mpl_dbg("Mesh plink error: no more free plinks\n");
d0709a65 514 rcu_read_unlock();
c3896d2c
LCC		 515 return;
516 }
517
518 rates = ieee80211_sta_get_rates(local, &elems, rx_status->band);
d0709a65 519 sta = mesh_plink_add(mgmt->sa, rates, sdata);
c3896d2c
LCC		 520 if (IS_ERR(sta)) {
521 mpl_dbg("Mesh plink error: plink table full\n");
d0709a65 522 rcu_read_unlock();
c3896d2c
LCC		 523 return;
524 }
525 event = OPN_ACPT;
526 spin_lock_bh(&sta->plink_lock);
527 } else {
528 spin_lock_bh(&sta->plink_lock);
529 switch (ftype) {
530 case PLINK_OPEN:
531 if (!mesh_plink_free_count(sdata) ||
d0709a65 532 (sta->plid && sta->plid != plid))
c3896d2c
LCC		 533 event = OPN_IGNR;
534 else
535 event = OPN_ACPT;
536 break;
537 case PLINK_CONFIRM:
538 if (!mesh_plink_free_count(sdata) ||
d0709a65 539 (sta->llid != llid || sta->plid != plid))
c3896d2c
LCC		 540 event = CNF_IGNR;
541 else
542 event = CNF_ACPT;
543 break;
544 case PLINK_CLOSE:
545 if (sta->plink_state == ESTAB)
546 /* Do not check for llid or plid. This does not
547 * follow the standard but since multiple plinks
548 * per sta are not supported, it is necessary in
549 * order to avoid a livelock when MP A sees an
550 * establish peer link to MP B but MP B does not
551 * see it. This can be caused by a timeout in
552 * B's peer link establishment or B beign
553 * restarted.
554 */
555 event = CLS_ACPT;
556 else if (sta->plid != plid)
557 event = CLS_IGNR;
558 else if (ie_len == 7 && sta->llid != llid)
559 event = CLS_IGNR;
560 else
561 event = CLS_ACPT;
562 break;
563 default:
564 mpl_dbg("Mesh plink: unknown frame subtype\n");
565 spin_unlock_bh(&sta->plink_lock);
d0709a65 566 rcu_read_unlock();
c3896d2c
LCC		 567 return;
568 }
569 }
570
571 mpl_dbg("Mesh plink (peer, state, llid, plid, event): %s %d %d %d %d\n",
572 print_mac(mac, mgmt->sa), sta->plink_state,
573 __le16_to_cpu(sta->llid), __le16_to_cpu(sta->plid),
574 event);
575 reason = 0;
576 switch (sta->plink_state) {
577 /* spin_unlock as soon as state is updated at each case */
578 case LISTEN:
579 switch (event) {
580 case CLS_ACPT:
581 mesh_plink_fsm_restart(sta);
582 spin_unlock_bh(&sta->plink_lock);
583 break;
584 case OPN_ACPT:
585 sta->plink_state = OPN_RCVD;
586 sta->plid = plid;
587 get_random_bytes(&llid, 2);
588 sta->llid = llid;
589 mesh_plink_timer_set(sta, dot11MeshRetryTimeout(sdata));
590 spin_unlock_bh(&sta->plink_lock);
591 mesh_plink_frame_tx(dev, PLINK_OPEN, sta->addr, llid,
592 0, 0);
593 mesh_plink_frame_tx(dev, PLINK_CONFIRM, sta->addr,
594 llid, plid, 0);
595 break;
596 default:
597 spin_unlock_bh(&sta->plink_lock);
598 break;
599 }
600 break;
601
602 case OPN_SNT:
603 switch (event) {
604 case OPN_RJCT:
605 case CNF_RJCT:
606 reason = cpu_to_le16(MESH_CAPABILITY_POLICY_VIOLATION);
607 case CLS_ACPT:
608 if (!reason)
609 reason = cpu_to_le16(MESH_CLOSE_RCVD);
610 sta->reason = reason;
611 sta->plink_state = HOLDING;
612 if (!mod_plink_timer(sta,
613 dot11MeshHoldingTimeout(sdata)))
614 sta->ignore_plink_timer = true;
615
616 llid = sta->llid;
617 spin_unlock_bh(&sta->plink_lock);
618 mesh_plink_frame_tx(dev, PLINK_CLOSE, sta->addr, llid,
619 plid, reason);
620 break;
621 case OPN_ACPT:
622 /* retry timer is left untouched */
623 sta->plink_state = OPN_RCVD;
624 sta->plid = plid;
625 llid = sta->llid;
626 spin_unlock_bh(&sta->plink_lock);
627 mesh_plink_frame_tx(dev, PLINK_CONFIRM, sta->addr, llid,
628 plid, 0);
629 break;
630 case CNF_ACPT:
631 sta->plink_state = CNF_RCVD;
632 if (!mod_plink_timer(sta,
633 dot11MeshConfirmTimeout(sdata)))
634 sta->ignore_plink_timer = true;
635
636 spin_unlock_bh(&sta->plink_lock);
637 break;
638 default:
639 spin_unlock_bh(&sta->plink_lock);
640 break;
641 }
642 break;
643
644 case OPN_RCVD:
645 switch (event) {
646 case OPN_RJCT:
647 case CNF_RJCT:
648 reason = cpu_to_le16(MESH_CAPABILITY_POLICY_VIOLATION);
649 case CLS_ACPT:
650 if (!reason)
651 reason = cpu_to_le16(MESH_CLOSE_RCVD);
652 sta->reason = reason;
653 sta->plink_state = HOLDING;
654 if (!mod_plink_timer(sta,
655 dot11MeshHoldingTimeout(sdata)))
656 sta->ignore_plink_timer = true;
657
658 llid = sta->llid;
659 spin_unlock_bh(&sta->plink_lock);
660 mesh_plink_frame_tx(dev, PLINK_CLOSE, sta->addr, llid,
661 plid, reason);
662 break;
663 case OPN_ACPT:
664 llid = sta->llid;
665 spin_unlock_bh(&sta->plink_lock);
666 mesh_plink_frame_tx(dev, PLINK_CONFIRM, sta->addr, llid,
667 plid, 0);
668 break;
669 case CNF_ACPT:
d0709a65 670 del_timer(&sta->plink_timer);
c3896d2c
LCC		 671 sta->plink_state = ESTAB;
672 mesh_plink_inc_estab_count(sdata);
673 spin_unlock_bh(&sta->plink_lock);
674 mpl_dbg("Mesh plink with %s ESTABLISHED\n",
675 print_mac(mac, sta->addr));
676 break;
677 default:
678 spin_unlock_bh(&sta->plink_lock);
679 break;
680 }
681 break;
682
683 case CNF_RCVD:
684 switch (event) {
685 case OPN_RJCT:
686 case CNF_RJCT:
687 reason = cpu_to_le16(MESH_CAPABILITY_POLICY_VIOLATION);
688 case CLS_ACPT:
689 if (!reason)
690 reason = cpu_to_le16(MESH_CLOSE_RCVD);
691 sta->reason = reason;
692 sta->plink_state = HOLDING;
693 if (!mod_plink_timer(sta,
694 dot11MeshHoldingTimeout(sdata)))
695 sta->ignore_plink_timer = true;
696
697 llid = sta->llid;
698 spin_unlock_bh(&sta->plink_lock);
699 mesh_plink_frame_tx(dev, PLINK_CLOSE, sta->addr, llid,
700 plid, reason);
ff59dc76 701 break;
c3896d2c 702 case OPN_ACPT:
d0709a65 703 del_timer(&sta->plink_timer);
c3896d2c
LCC		 704 sta->plink_state = ESTAB;
705 mesh_plink_inc_estab_count(sdata);
706 spin_unlock_bh(&sta->plink_lock);
707 mpl_dbg("Mesh plink with %s ESTABLISHED\n",
708 print_mac(mac, sta->addr));
709 mesh_plink_frame_tx(dev, PLINK_CONFIRM, sta->addr, llid,
710 plid, 0);
711 break;
712 default:
713 spin_unlock_bh(&sta->plink_lock);
714 break;
715 }
716 break;
717
718 case ESTAB:
719 switch (event) {
720 case CLS_ACPT:
721 reason = cpu_to_le16(MESH_CLOSE_RCVD);
722 sta->reason = reason;
902acc78 723 __mesh_plink_deactivate(sta);
c3896d2c
LCC		 724 sta->plink_state = HOLDING;
725 llid = sta->llid;
d0709a65 726 mod_plink_timer(sta, dot11MeshHoldingTimeout(sdata));
c3896d2c
LCC		 727 spin_unlock_bh(&sta->plink_lock);
728 mesh_plink_frame_tx(dev, PLINK_CLOSE, sta->addr, llid,
729 plid, reason);
730 break;
731 case OPN_ACPT:
732 llid = sta->llid;
733 spin_unlock_bh(&sta->plink_lock);
734 mesh_plink_frame_tx(dev, PLINK_CONFIRM, sta->addr, llid,
735 plid, 0);
736 break;
737 default:
738 spin_unlock_bh(&sta->plink_lock);
739 break;
740 }
741 break;
742 case HOLDING:
743 switch (event) {
744 case CLS_ACPT:
d0709a65 745 if (del_timer(&sta->plink_timer))
c3896d2c 746 sta->ignore_plink_timer = 1;
c3896d2c
LCC		 747 mesh_plink_fsm_restart(sta);
748 spin_unlock_bh(&sta->plink_lock);
749 break;
750 case OPN_ACPT:
751 case CNF_ACPT:
752 case OPN_RJCT:
753 case CNF_RJCT:
754 llid = sta->llid;
755 reason = sta->reason;
756 spin_unlock_bh(&sta->plink_lock);
757 mesh_plink_frame_tx(dev, PLINK_CLOSE, sta->addr, llid,
758 plid, reason);
759 break;
760 default:
761 spin_unlock_bh(&sta->plink_lock);
762 }
763 break;
764 default:
765 /* should not get here, BLOCKED is dealt with at the beggining
766 * of the function
767 */
768 spin_unlock_bh(&sta->plink_lock);
769 break;
770 }
d0709a65
JB		 771
772 rcu_read_unlock();
c3896d2c 773}
Clone of davem's net-next-2.6 tree