~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/wireless/mlme.c

Version: ~ [ linux-5.14-rc3 ] ~ [ linux-5.13.5 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.53 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.135 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.198 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.240 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.276 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.276 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * cfg80211 MLME SAP interface
  3  *
  4  * Copyright (c) 2009, Jouni Malinen <j@w1.fi>
  5  */
  6 
  7 #include <linux/kernel.h>
  8 #include <linux/module.h>
  9 #include <linux/etherdevice.h>
 10 #include <linux/netdevice.h>
 11 #include <linux/nl80211.h>
 12 #include <linux/slab.h>
 13 #include <linux/wireless.h>
 14 #include <net/cfg80211.h>
 15 #include <net/iw_handler.h>
 16 #include "core.h"
 17 #include "nl80211.h"
 18 #include "rdev-ops.h"
 19 
 20 
 21 void cfg80211_rx_assoc_resp(struct net_device *dev, struct cfg80211_bss *bss,
 22                             const u8 *buf, size_t len, int uapsd_queues)
 23 {
 24         struct wireless_dev *wdev = dev->ieee80211_ptr;
 25         struct wiphy *wiphy = wdev->wiphy;
 26         struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
 27         struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)buf;
 28         u8 *ie = mgmt->u.assoc_resp.variable;
 29         int ieoffs = offsetof(struct ieee80211_mgmt, u.assoc_resp.variable);
 30         u16 status_code = le16_to_cpu(mgmt->u.assoc_resp.status_code);
 31 
 32         trace_cfg80211_send_rx_assoc(dev, bss);
 33 
 34         /*
 35          * This is a bit of a hack, we don't notify userspace of
 36          * a (re-)association reply if we tried to send a reassoc
 37          * and got a reject -- we only try again with an assoc
 38          * frame instead of reassoc.
 39          */
 40         if (cfg80211_sme_rx_assoc_resp(wdev, status_code)) {
 41                 cfg80211_unhold_bss(bss_from_pub(bss));
 42                 cfg80211_put_bss(wiphy, bss);
 43                 return;
 44         }
 45 
 46         nl80211_send_rx_assoc(rdev, dev, buf, len, GFP_KERNEL, uapsd_queues);
 47         /* update current_bss etc., consumes the bss reference */
 48         __cfg80211_connect_result(dev, mgmt->bssid, NULL, 0, ie, len - ieoffs,
 49                                   status_code,
 50                                   status_code == WLAN_STATUS_SUCCESS, bss);
 51 }
 52 EXPORT_SYMBOL(cfg80211_rx_assoc_resp);
 53 
 54 static void cfg80211_process_auth(struct wireless_dev *wdev,
 55                                   const u8 *buf, size_t len)
 56 {
 57         struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
 58 
 59         nl80211_send_rx_auth(rdev, wdev->netdev, buf, len, GFP_KERNEL);
 60         cfg80211_sme_rx_auth(wdev, buf, len);
 61 }
 62 
 63 static void cfg80211_process_deauth(struct wireless_dev *wdev,
 64                                     const u8 *buf, size_t len)
 65 {
 66         struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
 67         struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)buf;
 68         const u8 *bssid = mgmt->bssid;
 69         u16 reason_code = le16_to_cpu(mgmt->u.deauth.reason_code);
 70         bool from_ap = !ether_addr_equal(mgmt->sa, wdev->netdev->dev_addr);
 71 
 72         nl80211_send_deauth(rdev, wdev->netdev, buf, len, GFP_KERNEL);
 73 
 74         if (!wdev->current_bss ||
 75             !ether_addr_equal(wdev->current_bss->pub.bssid, bssid))
 76                 return;
 77 
 78         __cfg80211_disconnected(wdev->netdev, NULL, 0, reason_code, from_ap);
 79         cfg80211_sme_deauth(wdev);
 80 }
 81 
 82 static void cfg80211_process_disassoc(struct wireless_dev *wdev,
 83                                       const u8 *buf, size_t len)
 84 {
 85         struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
 86         struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)buf;
 87         const u8 *bssid = mgmt->bssid;
 88         u16 reason_code = le16_to_cpu(mgmt->u.disassoc.reason_code);
 89         bool from_ap = !ether_addr_equal(mgmt->sa, wdev->netdev->dev_addr);
 90 
 91         nl80211_send_disassoc(rdev, wdev->netdev, buf, len, GFP_KERNEL);
 92 
 93         if (WARN_ON(!wdev->current_bss ||
 94                     !ether_addr_equal(wdev->current_bss->pub.bssid, bssid)))
 95                 return;
 96 
 97         __cfg80211_disconnected(wdev->netdev, NULL, 0, reason_code, from_ap);
 98         cfg80211_sme_disassoc(wdev);
 99 }
100 
101 void cfg80211_rx_mlme_mgmt(struct net_device *dev, const u8 *buf, size_t len)
102 {
103         struct wireless_dev *wdev = dev->ieee80211_ptr;
104         struct ieee80211_mgmt *mgmt = (void *)buf;
105 
106         ASSERT_WDEV_LOCK(wdev);
107 
108         trace_cfg80211_rx_mlme_mgmt(dev, buf, len);
109 
110         if (WARN_ON(len < 2))
111                 return;
112 
113         if (ieee80211_is_auth(mgmt->frame_control))
114                 cfg80211_process_auth(wdev, buf, len);
115         else if (ieee80211_is_deauth(mgmt->frame_control))
116                 cfg80211_process_deauth(wdev, buf, len);
117         else if (ieee80211_is_disassoc(mgmt->frame_control))
118                 cfg80211_process_disassoc(wdev, buf, len);
119 }
120 EXPORT_SYMBOL(cfg80211_rx_mlme_mgmt);
121 
122 void cfg80211_auth_timeout(struct net_device *dev, const u8 *addr)
123 {
124         struct wireless_dev *wdev = dev->ieee80211_ptr;
125         struct wiphy *wiphy = wdev->wiphy;
126         struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
127 
128         trace_cfg80211_send_auth_timeout(dev, addr);
129 
130         nl80211_send_auth_timeout(rdev, dev, addr, GFP_KERNEL);
131         cfg80211_sme_auth_timeout(wdev);
132 }
133 EXPORT_SYMBOL(cfg80211_auth_timeout);
134 
135 void cfg80211_assoc_timeout(struct net_device *dev, struct cfg80211_bss *bss)
136 {
137         struct wireless_dev *wdev = dev->ieee80211_ptr;
138         struct wiphy *wiphy = wdev->wiphy;
139         struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
140 
141         trace_cfg80211_send_assoc_timeout(dev, bss->bssid);
142 
143         nl80211_send_assoc_timeout(rdev, dev, bss->bssid, GFP_KERNEL);
144         cfg80211_sme_assoc_timeout(wdev);
145 
146         cfg80211_unhold_bss(bss_from_pub(bss));
147         cfg80211_put_bss(wiphy, bss);
148 }
149 EXPORT_SYMBOL(cfg80211_assoc_timeout);
150 
151 void cfg80211_tx_mlme_mgmt(struct net_device *dev, const u8 *buf, size_t len)
152 {
153         struct wireless_dev *wdev = dev->ieee80211_ptr;
154         struct ieee80211_mgmt *mgmt = (void *)buf;
155 
156         ASSERT_WDEV_LOCK(wdev);
157 
158         trace_cfg80211_tx_mlme_mgmt(dev, buf, len);
159 
160         if (WARN_ON(len < 2))
161                 return;
162 
163         if (ieee80211_is_deauth(mgmt->frame_control))
164                 cfg80211_process_deauth(wdev, buf, len);
165         else
166                 cfg80211_process_disassoc(wdev, buf, len);
167 }
168 EXPORT_SYMBOL(cfg80211_tx_mlme_mgmt);
169 
170 void cfg80211_michael_mic_failure(struct net_device *dev, const u8 *addr,
171                                   enum nl80211_key_type key_type, int key_id,
172                                   const u8 *tsc, gfp_t gfp)
173 {
174         struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
175         struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
176 #ifdef CONFIG_CFG80211_WEXT
177         union iwreq_data wrqu;
178         char *buf = kmalloc(128, gfp);
179 
180         if (buf) {
181                 sprintf(buf, "MLME-MICHAELMICFAILURE.indication("
182                         "keyid=%d %scast addr=%pM)", key_id,
183                         key_type == NL80211_KEYTYPE_GROUP ? "broad" : "uni",
184                         addr);
185                 memset(&wrqu, 0, sizeof(wrqu));
186                 wrqu.data.length = strlen(buf);
187                 wireless_send_event(dev, IWEVCUSTOM, &wrqu, buf);
188                 kfree(buf);
189         }
190 #endif
191 
192         trace_cfg80211_michael_mic_failure(dev, addr, key_type, key_id, tsc);
193         nl80211_michael_mic_failure(rdev, dev, addr, key_type, key_id, tsc, gfp);
194 }
195 EXPORT_SYMBOL(cfg80211_michael_mic_failure);
196 
197 /* some MLME handling for userspace SME */
198 int cfg80211_mlme_auth(struct cfg80211_registered_device *rdev,
199                        struct net_device *dev,
200                        struct ieee80211_channel *chan,
201                        enum nl80211_auth_type auth_type,
202                        const u8 *bssid,
203                        const u8 *ssid, int ssid_len,
204                        const u8 *ie, int ie_len,
205                        const u8 *key, int key_len, int key_idx,
206                        const u8 *sae_data, int sae_data_len)
207 {
208         struct wireless_dev *wdev = dev->ieee80211_ptr;
209         struct cfg80211_auth_request req = {
210                 .ie = ie,
211                 .ie_len = ie_len,
212                 .sae_data = sae_data,
213                 .sae_data_len = sae_data_len,
214                 .auth_type = auth_type,
215                 .key = key,
216                 .key_len = key_len,
217                 .key_idx = key_idx,
218         };
219         int err;
220 
221         ASSERT_WDEV_LOCK(wdev);
222 
223         if (auth_type == NL80211_AUTHTYPE_SHARED_KEY)
224                 if (!key || !key_len || key_idx < 0 || key_idx > 4)
225                         return -EINVAL;
226 
227         if (wdev->current_bss &&
228             ether_addr_equal(bssid, wdev->current_bss->pub.bssid))
229                 return -EALREADY;
230 
231         req.bss = cfg80211_get_bss(&rdev->wiphy, chan, bssid, ssid, ssid_len,
232                                    WLAN_CAPABILITY_ESS, WLAN_CAPABILITY_ESS);
233         if (!req.bss)
234                 return -ENOENT;
235 
236         err = rdev_auth(rdev, dev, &req);
237 
238         cfg80211_put_bss(&rdev->wiphy, req.bss);
239         return err;
240 }
241 
242 /*  Do a logical ht_capa &= ht_capa_mask.  */
243 void cfg80211_oper_and_ht_capa(struct ieee80211_ht_cap *ht_capa,
244                                const struct ieee80211_ht_cap *ht_capa_mask)
245 {
246         int i;
247         u8 *p1, *p2;
248         if (!ht_capa_mask) {
249                 memset(ht_capa, 0, sizeof(*ht_capa));
250                 return;
251         }
252 
253         p1 = (u8*)(ht_capa);
254         p2 = (u8*)(ht_capa_mask);
255         for (i = 0; i<sizeof(*ht_capa); i++)
256                 p1[i] &= p2[i];
257 }
258 
259 /*  Do a logical ht_capa &= ht_capa_mask.  */
260 void cfg80211_oper_and_vht_capa(struct ieee80211_vht_cap *vht_capa,
261                                 const struct ieee80211_vht_cap *vht_capa_mask)
262 {
263         int i;
264         u8 *p1, *p2;
265         if (!vht_capa_mask) {
266                 memset(vht_capa, 0, sizeof(*vht_capa));
267                 return;
268         }
269 
270         p1 = (u8*)(vht_capa);
271         p2 = (u8*)(vht_capa_mask);
272         for (i = 0; i < sizeof(*vht_capa); i++)
273                 p1[i] &= p2[i];
274 }
275 
276 int cfg80211_mlme_assoc(struct cfg80211_registered_device *rdev,
277                         struct net_device *dev,
278                         struct ieee80211_channel *chan,
279                         const u8 *bssid,
280                         const u8 *ssid, int ssid_len,
281                         struct cfg80211_assoc_request *req)
282 {
283         struct wireless_dev *wdev = dev->ieee80211_ptr;
284         int err;
285 
286         ASSERT_WDEV_LOCK(wdev);
287 
288         if (wdev->current_bss &&
289             (!req->prev_bssid || !ether_addr_equal(wdev->current_bss->pub.bssid,
290                                                    req->prev_bssid)))
291                 return -EALREADY;
292 
293         cfg80211_oper_and_ht_capa(&req->ht_capa_mask,
294                                   rdev->wiphy.ht_capa_mod_mask);
295         cfg80211_oper_and_vht_capa(&req->vht_capa_mask,
296                                    rdev->wiphy.vht_capa_mod_mask);
297 
298         req->bss = cfg80211_get_bss(&rdev->wiphy, chan, bssid, ssid, ssid_len,
299                                     WLAN_CAPABILITY_ESS, WLAN_CAPABILITY_ESS);
300         if (!req->bss)
301                 return -ENOENT;
302 
303         err = rdev_assoc(rdev, dev, req);
304         if (!err)
305                 cfg80211_hold_bss(bss_from_pub(req->bss));
306         else
307                 cfg80211_put_bss(&rdev->wiphy, req->bss);
308 
309         return err;
310 }
311 
312 int cfg80211_mlme_deauth(struct cfg80211_registered_device *rdev,
313                          struct net_device *dev, const u8 *bssid,
314                          const u8 *ie, int ie_len, u16 reason,
315                          bool local_state_change)
316 {
317         struct wireless_dev *wdev = dev->ieee80211_ptr;
318         struct cfg80211_deauth_request req = {
319                 .bssid = bssid,
320                 .reason_code = reason,
321                 .ie = ie,
322                 .ie_len = ie_len,
323                 .local_state_change = local_state_change,
324         };
325 
326         ASSERT_WDEV_LOCK(wdev);
327 
328         if (local_state_change &&
329             (!wdev->current_bss ||
330              !ether_addr_equal(wdev->current_bss->pub.bssid, bssid)))
331                 return 0;
332 
333         return rdev_deauth(rdev, dev, &req);
334 }
335 
336 int cfg80211_mlme_disassoc(struct cfg80211_registered_device *rdev,
337                            struct net_device *dev, const u8 *bssid,
338                            const u8 *ie, int ie_len, u16 reason,
339                            bool local_state_change)
340 {
341         struct wireless_dev *wdev = dev->ieee80211_ptr;
342         struct cfg80211_disassoc_request req = {
343                 .reason_code = reason,
344                 .local_state_change = local_state_change,
345                 .ie = ie,
346                 .ie_len = ie_len,
347         };
348         int err;
349 
350         ASSERT_WDEV_LOCK(wdev);
351 
352         if (!wdev->current_bss)
353                 return -ENOTCONN;
354 
355         if (ether_addr_equal(wdev->current_bss->pub.bssid, bssid))
356                 req.bss = &wdev->current_bss->pub;
357         else
358                 return -ENOTCONN;
359 
360         err = rdev_disassoc(rdev, dev, &req);
361         if (err)
362                 return err;
363 
364         /* driver should have reported the disassoc */
365         WARN_ON(wdev->current_bss);
366         return 0;
367 }
368 
369 void cfg80211_mlme_down(struct cfg80211_registered_device *rdev,
370                         struct net_device *dev)
371 {
372         struct wireless_dev *wdev = dev->ieee80211_ptr;
373         u8 bssid[ETH_ALEN];
374 
375         ASSERT_WDEV_LOCK(wdev);
376 
377         if (!rdev->ops->deauth)
378                 return;
379 
380         if (!wdev->current_bss)
381                 return;
382 
383         memcpy(bssid, wdev->current_bss->pub.bssid, ETH_ALEN);
384         cfg80211_mlme_deauth(rdev, dev, bssid, NULL, 0,
385                              WLAN_REASON_DEAUTH_LEAVING, false);
386 }
387 
388 struct cfg80211_mgmt_registration {
389         struct list_head list;
390 
391         u32 nlportid;
392 
393         int match_len;
394 
395         __le16 frame_type;
396 
397         u8 match[];
398 };
399 
400 int cfg80211_mlme_register_mgmt(struct wireless_dev *wdev, u32 snd_portid,
401                                 u16 frame_type, const u8 *match_data,
402                                 int match_len)
403 {
404         struct wiphy *wiphy = wdev->wiphy;
405         struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
406         struct cfg80211_mgmt_registration *reg, *nreg;
407         int err = 0;
408         u16 mgmt_type;
409 
410         if (!wdev->wiphy->mgmt_stypes)
411                 return -EOPNOTSUPP;
412 
413         if ((frame_type & IEEE80211_FCTL_FTYPE) != IEEE80211_FTYPE_MGMT)
414                 return -EINVAL;
415 
416         if (frame_type & ~(IEEE80211_FCTL_FTYPE | IEEE80211_FCTL_STYPE))
417                 return -EINVAL;
418 
419         mgmt_type = (frame_type & IEEE80211_FCTL_STYPE) >> 4;
420         if (!(wdev->wiphy->mgmt_stypes[wdev->iftype].rx & BIT(mgmt_type)))
421                 return -EINVAL;
422 
423         nreg = kzalloc(sizeof(*reg) + match_len, GFP_KERNEL);
424         if (!nreg)
425                 return -ENOMEM;
426 
427         spin_lock_bh(&wdev->mgmt_registrations_lock);
428 
429         list_for_each_entry(reg, &wdev->mgmt_registrations, list) {
430                 int mlen = min(match_len, reg->match_len);
431 
432                 if (frame_type != le16_to_cpu(reg->frame_type))
433                         continue;
434 
435                 if (memcmp(reg->match, match_data, mlen) == 0) {
436                         err = -EALREADY;
437                         break;
438                 }
439         }
440 
441         if (err) {
442                 kfree(nreg);
443                 goto out;
444         }
445 
446         memcpy(nreg->match, match_data, match_len);
447         nreg->match_len = match_len;
448         nreg->nlportid = snd_portid;
449         nreg->frame_type = cpu_to_le16(frame_type);
450         list_add(&nreg->list, &wdev->mgmt_registrations);
451 
452         if (rdev->ops->mgmt_frame_register)
453                 rdev_mgmt_frame_register(rdev, wdev, frame_type, true);
454 
455  out:
456         spin_unlock_bh(&wdev->mgmt_registrations_lock);
457 
458         return err;
459 }
460 
461 void cfg80211_mlme_unregister_socket(struct wireless_dev *wdev, u32 nlportid)
462 {
463         struct wiphy *wiphy = wdev->wiphy;
464         struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
465         struct cfg80211_mgmt_registration *reg, *tmp;
466 
467         spin_lock_bh(&wdev->mgmt_registrations_lock);
468 
469         list_for_each_entry_safe(reg, tmp, &wdev->mgmt_registrations, list) {
470                 if (reg->nlportid != nlportid)
471                         continue;
472 
473                 if (rdev->ops->mgmt_frame_register) {
474                         u16 frame_type = le16_to_cpu(reg->frame_type);
475 
476                         rdev_mgmt_frame_register(rdev, wdev,
477                                                  frame_type, false);
478                 }
479 
480                 list_del(&reg->list);
481                 kfree(reg);
482         }
483 
484         spin_unlock_bh(&wdev->mgmt_registrations_lock);
485 
486         if (nlportid && rdev->crit_proto_nlportid == nlportid) {
487                 rdev->crit_proto_nlportid = 0;
488                 rdev_crit_proto_stop(rdev, wdev);
489         }
490 
491         if (nlportid == wdev->ap_unexpected_nlportid)
492                 wdev->ap_unexpected_nlportid = 0;
493 }
494 
495 void cfg80211_mlme_purge_registrations(struct wireless_dev *wdev)
496 {
497         struct cfg80211_mgmt_registration *reg, *tmp;
498 
499         spin_lock_bh(&wdev->mgmt_registrations_lock);
500 
501         list_for_each_entry_safe(reg, tmp, &wdev->mgmt_registrations, list) {
502                 list_del(&reg->list);
503                 kfree(reg);
504         }
505 
506         spin_unlock_bh(&wdev->mgmt_registrations_lock);
507 }
508 
509 int cfg80211_mlme_mgmt_tx(struct cfg80211_registered_device *rdev,
510                           struct wireless_dev *wdev,
511                           struct cfg80211_mgmt_tx_params *params, u64 *cookie)
512 {
513         const struct ieee80211_mgmt *mgmt;
514         u16 stype;
515 
516         if (!wdev->wiphy->mgmt_stypes)
517                 return -EOPNOTSUPP;
518 
519         if (!rdev->ops->mgmt_tx)
520                 return -EOPNOTSUPP;
521 
522         if (params->len < 24 + 1)
523                 return -EINVAL;
524 
525         mgmt = (const struct ieee80211_mgmt *)params->buf;
526 
527         if (!ieee80211_is_mgmt(mgmt->frame_control))
528                 return -EINVAL;
529 
530         stype = le16_to_cpu(mgmt->frame_control) & IEEE80211_FCTL_STYPE;
531         if (!(wdev->wiphy->mgmt_stypes[wdev->iftype].tx & BIT(stype >> 4)))
532                 return -EINVAL;
533 
534         if (ieee80211_is_action(mgmt->frame_control) &&
535             mgmt->u.action.category != WLAN_CATEGORY_PUBLIC) {
536                 int err = 0;
537 
538                 wdev_lock(wdev);
539 
540                 switch (wdev->iftype) {
541                 case NL80211_IFTYPE_ADHOC:
542                 case NL80211_IFTYPE_STATION:
543                 case NL80211_IFTYPE_P2P_CLIENT:
544                         if (!wdev->current_bss) {
545                                 err = -ENOTCONN;
546                                 break;
547                         }
548 
549                         if (!ether_addr_equal(wdev->current_bss->pub.bssid,
550                                               mgmt->bssid)) {
551                                 err = -ENOTCONN;
552                                 break;
553                         }
554 
555                         /*
556                          * check for IBSS DA must be done by driver as
557                          * cfg80211 doesn't track the stations
558                          */
559                         if (wdev->iftype == NL80211_IFTYPE_ADHOC)
560                                 break;
561 
562                         /* for station, check that DA is the AP */
563                         if (!ether_addr_equal(wdev->current_bss->pub.bssid,
564                                               mgmt->da)) {
565                                 err = -ENOTCONN;
566                                 break;
567                         }
568                         break;
569                 case NL80211_IFTYPE_AP:
570                 case NL80211_IFTYPE_P2P_GO:
571                 case NL80211_IFTYPE_AP_VLAN:
572                         if (!ether_addr_equal(mgmt->bssid, wdev_address(wdev)))
573                                 err = -EINVAL;
574                         break;
575                 case NL80211_IFTYPE_MESH_POINT:
576                         if (!ether_addr_equal(mgmt->sa, mgmt->bssid)) {
577                                 err = -EINVAL;
578                                 break;
579                         }
580                         /*
581                          * check for mesh DA must be done by driver as
582                          * cfg80211 doesn't track the stations
583                          */
584                         break;
585                 case NL80211_IFTYPE_P2P_DEVICE:
586                         /*
587                          * fall through, P2P device only supports
588                          * public action frames
589                          */
590                 default:
591                         err = -EOPNOTSUPP;
592                         break;
593                 }
594                 wdev_unlock(wdev);
595 
596                 if (err)
597                         return err;
598         }
599 
600         if (!ether_addr_equal(mgmt->sa, wdev_address(wdev)))
601                 return -EINVAL;
602 
603         /* Transmit the Action frame as requested by user space */
604         return rdev_mgmt_tx(rdev, wdev, params, cookie);
605 }
606 
607 bool cfg80211_rx_mgmt(struct wireless_dev *wdev, int freq, int sig_mbm,
608                       const u8 *buf, size_t len, u32 flags)
609 {
610         struct wiphy *wiphy = wdev->wiphy;
611         struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
612         struct cfg80211_mgmt_registration *reg;
613         const struct ieee80211_txrx_stypes *stypes =
614                 &wiphy->mgmt_stypes[wdev->iftype];
615         struct ieee80211_mgmt *mgmt = (void *)buf;
616         const u8 *data;
617         int data_len;
618         bool result = false;
619         __le16 ftype = mgmt->frame_control &
620                 cpu_to_le16(IEEE80211_FCTL_FTYPE | IEEE80211_FCTL_STYPE);
621         u16 stype;
622 
623         trace_cfg80211_rx_mgmt(wdev, freq, sig_mbm);
624         stype = (le16_to_cpu(mgmt->frame_control) & IEEE80211_FCTL_STYPE) >> 4;
625 
626         if (!(stypes->rx & BIT(stype))) {
627                 trace_cfg80211_return_bool(false);
628                 return false;
629         }
630 
631         data = buf + ieee80211_hdrlen(mgmt->frame_control);
632         data_len = len - ieee80211_hdrlen(mgmt->frame_control);
633 
634         spin_lock_bh(&wdev->mgmt_registrations_lock);
635 
636         list_for_each_entry(reg, &wdev->mgmt_registrations, list) {
637                 if (reg->frame_type != ftype)
638                         continue;
639 
640                 if (reg->match_len > data_len)
641                         continue;
642 
643                 if (memcmp(reg->match, data, reg->match_len))
644                         continue;
645 
646                 /* found match! */
647 
648                 /* Indicate the received Action frame to user space */
649                 if (nl80211_send_mgmt(rdev, wdev, reg->nlportid,
650                                       freq, sig_mbm,
651                                       buf, len, flags, GFP_ATOMIC))
652                         continue;
653 
654                 result = true;
655                 break;
656         }
657 
658         spin_unlock_bh(&wdev->mgmt_registrations_lock);
659 
660         trace_cfg80211_return_bool(result);
661         return result;
662 }
663 EXPORT_SYMBOL(cfg80211_rx_mgmt);
664 
665 void cfg80211_dfs_channels_update_work(struct work_struct *work)
666 {
667         struct delayed_work *delayed_work;
668         struct cfg80211_registered_device *rdev;
669         struct cfg80211_chan_def chandef;
670         struct ieee80211_supported_band *sband;
671         struct ieee80211_channel *c;
672         struct wiphy *wiphy;
673         bool check_again = false;
674         unsigned long timeout, next_time = 0;
675         int bandid, i;
676 
677         delayed_work = container_of(work, struct delayed_work, work);
678         rdev = container_of(delayed_work, struct cfg80211_registered_device,
679                             dfs_update_channels_wk);
680         wiphy = &rdev->wiphy;
681 
682         rtnl_lock();
683         for (bandid = 0; bandid < IEEE80211_NUM_BANDS; bandid++) {
684                 sband = wiphy->bands[bandid];
685                 if (!sband)
686                         continue;
687 
688                 for (i = 0; i < sband->n_channels; i++) {
689                         c = &sband->channels[i];
690 
691                         if (c->dfs_state != NL80211_DFS_UNAVAILABLE)
692                                 continue;
693 
694                         timeout = c->dfs_state_entered + msecs_to_jiffies(
695                                         IEEE80211_DFS_MIN_NOP_TIME_MS);
696 
697                         if (time_after_eq(jiffies, timeout)) {
698                                 c->dfs_state = NL80211_DFS_USABLE;
699                                 c->dfs_state_entered = jiffies;
700 
701                                 cfg80211_chandef_create(&chandef, c,
702                                                         NL80211_CHAN_NO_HT);
703 
704                                 nl80211_radar_notify(rdev, &chandef,
705                                                      NL80211_RADAR_NOP_FINISHED,
706                                                      NULL, GFP_ATOMIC);
707                                 continue;
708                         }
709 
710                         if (!check_again)
711                                 next_time = timeout - jiffies;
712                         else
713                                 next_time = min(next_time, timeout - jiffies);
714                         check_again = true;
715                 }
716         }
717         rtnl_unlock();
718 
719         /* reschedule if there are other channels waiting to be cleared again */
720         if (check_again)
721                 queue_delayed_work(cfg80211_wq, &rdev->dfs_update_channels_wk,
722                                    next_time);
723 }
724 
725 
726 void cfg80211_radar_event(struct wiphy *wiphy,
727                           struct cfg80211_chan_def *chandef,
728                           gfp_t gfp)
729 {
730         struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
731         unsigned long timeout;
732 
733         trace_cfg80211_radar_event(wiphy, chandef);
734 
735         /* only set the chandef supplied channel to unavailable, in
736          * case the radar is detected on only one of multiple channels
737          * spanned by the chandef.
738          */
739         cfg80211_set_dfs_state(wiphy, chandef, NL80211_DFS_UNAVAILABLE);
740 
741         timeout = msecs_to_jiffies(IEEE80211_DFS_MIN_NOP_TIME_MS);
742         queue_delayed_work(cfg80211_wq, &rdev->dfs_update_channels_wk,
743                            timeout);
744 
745         nl80211_radar_notify(rdev, chandef, NL80211_RADAR_DETECTED, NULL, gfp);
746 }
747 EXPORT_SYMBOL(cfg80211_radar_event);
748 
749 void cfg80211_cac_event(struct net_device *netdev,
750                         const struct cfg80211_chan_def *chandef,
751                         enum nl80211_radar_event event, gfp_t gfp)
752 {
753         struct wireless_dev *wdev = netdev->ieee80211_ptr;
754         struct wiphy *wiphy = wdev->wiphy;
755         struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
756         unsigned long timeout;
757 
758         trace_cfg80211_cac_event(netdev, event);
759 
760         if (WARN_ON(!wdev->cac_started))
761                 return;
762 
763         if (WARN_ON(!wdev->chandef.chan))
764                 return;
765 
766         switch (event) {
767         case NL80211_RADAR_CAC_FINISHED:
768                 timeout = wdev->cac_start_time +
769                           msecs_to_jiffies(wdev->cac_time_ms);
770                 WARN_ON(!time_after_eq(jiffies, timeout));
771                 cfg80211_set_dfs_state(wiphy, chandef, NL80211_DFS_AVAILABLE);
772                 break;
773         case NL80211_RADAR_CAC_ABORTED:
774                 break;
775         default:
776                 WARN_ON(1);
777                 return;
778         }
779         wdev->cac_started = false;
780 
781         nl80211_radar_notify(rdev, chandef, event, netdev, gfp);
782 }
783 EXPORT_SYMBOL(cfg80211_cac_event);
784 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp