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