License cleanup: add SPDX GPL-2.0 license identifier to files with no license
Many source files in the tree are missing licensing information, which
makes it harder for compliance tools to determine the correct license.
By default all files without license information are under the default
license of the kernel, which is GPL version 2.
Update the files which contain no license information with the 'GPL-2.0'
SPDX license identifier. The SPDX identifier is a legally binding
shorthand, which can be used instead of the full boiler plate text.
This patch is based on work done by Thomas Gleixner and Kate Stewart and
Philippe Ombredanne.
How this work was done:
Patches were generated and checked against linux-4.14-rc6 for a subset of
the use cases:
- file had no licensing information it it.
- file was a */uapi/* one with no licensing information in it,
- file was a */uapi/* one with existing licensing information,
Further patches will be generated in subsequent months to fix up cases
where non-standard license headers were used, and references to license
had to be inferred by heuristics based on keywords.
The analysis to determine which SPDX License Identifier to be applied to
a file was done in a spreadsheet of side by side results from of the
output of two independent scanners (ScanCode & Windriver) producing SPDX
tag:value files created by Philippe Ombredanne. Philippe prepared the
base worksheet, and did an initial spot review of a few 1000 files.
The 4.13 kernel was the starting point of the analysis with 60,537 files
assessed. Kate Stewart did a file by file comparison of the scanner
results in the spreadsheet to determine which SPDX license identifier(s)
to be applied to the file. She confirmed any determination that was not
immediately clear with lawyers working with the Linux Foundation.
Criteria used to select files for SPDX license identifier tagging was:
- Files considered eligible had to be source code files.
- Make and config files were included as candidates if they contained >5
lines of source
- File already had some variant of a license header in it (even if <5
lines).
All documentation files were explicitly excluded.
The following heuristics were used to determine which SPDX license
identifiers to apply.
- when both scanners couldn't find any license traces, file was
considered to have no license information in it, and the top level
COPYING file license applied.
For non */uapi/* files that summary was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 11139
and resulted in the first patch in this series.
If that file was a */uapi/* path one, it was "GPL-2.0 WITH
Linux-syscall-note" otherwise it was "GPL-2.0". Results of that was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 WITH Linux-syscall-note 930
and resulted in the second patch in this series.
- if a file had some form of licensing information in it, and was one
of the */uapi/* ones, it was denoted with the Linux-syscall-note if
any GPL family license was found in the file or had no licensing in
it (per prior point). Results summary:
SPDX license identifier # files
---------------------------------------------------|------
GPL-2.0 WITH Linux-syscall-note 270
GPL-2.0+ WITH Linux-syscall-note 169
((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) 21
((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 17
LGPL-2.1+ WITH Linux-syscall-note 15
GPL-1.0+ WITH Linux-syscall-note 14
((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) 5
LGPL-2.0+ WITH Linux-syscall-note 4
LGPL-2.1 WITH Linux-syscall-note 3
((GPL-2.0 WITH Linux-syscall-note) OR MIT) 3
((GPL-2.0 WITH Linux-syscall-note) AND MIT) 1
and that resulted in the third patch in this series.
- when the two scanners agreed on the detected license(s), that became
the concluded license(s).
- when there was disagreement between the two scanners (one detected a
license but the other didn't, or they both detected different
licenses) a manual inspection of the file occurred.
- In most cases a manual inspection of the information in the file
resulted in a clear resolution of the license that should apply (and
which scanner probably needed to revisit its heuristics).
- When it was not immediately clear, the license identifier was
confirmed with lawyers working with the Linux Foundation.
- If there was any question as to the appropriate license identifier,
the file was flagged for further research and to be revisited later
in time.
In total, over 70 hours of logged manual review was done on the
spreadsheet to determine the SPDX license identifiers to apply to the
source files by Kate, Philippe, Thomas and, in some cases, confirmation
by lawyers working with the Linux Foundation.
Kate also obtained a third independent scan of the 4.13 code base from
FOSSology, and compared selected files where the other two scanners
disagreed against that SPDX file, to see if there was new insights. The
Windriver scanner is based on an older version of FOSSology in part, so
they are related.
Thomas did random spot checks in about 500 files from the spreadsheets
for the uapi headers and agreed with SPDX license identifier in the
files he inspected. For the non-uapi files Thomas did random spot checks
in about 15000 files.
In initial set of patches against 4.14-rc6, 3 files were found to have
copy/paste license identifier errors, and have been fixed to reflect the
correct identifier.
Additionally Philippe spent 10 hours this week doing a detailed manual
inspection and review of the 12,461 patched files from the initial patch
version early this week with:
- a full scancode scan run, collecting the matched texts, detected
license ids and scores
- reviewing anything where there was a license detected (about 500+
files) to ensure that the applied SPDX license was correct
- reviewing anything where there was no detection but the patch license
was not GPL-2.0 WITH Linux-syscall-note to ensure that the applied
SPDX license was correct
This produced a worksheet with 20 files needing minor correction. This
worksheet was then exported into 3 different .csv files for the
different types of files to be modified.
These .csv files were then reviewed by Greg. Thomas wrote a script to
parse the csv files and add the proper SPDX tag to the file, in the
format that the file expected. This script was further refined by Greg
based on the output to detect more types of files automatically and to
distinguish between header and source .c files (which need different
comment types.) Finally Greg ran the script using the .csv files to
generate the patches.
Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org>
Reviewed-by: Philippe Ombredanne <pombredanne@nexb.com>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2017-11-01 17:07:57 +03:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0 */
|
2007-04-23 23:20:05 +04:00
|
|
|
/*
|
|
|
|
|
* Wireless configuration interface internals.
|
|
|
|
|
*
|
2010-01-17 17:49:02 +03:00
|
|
|
* Copyright 2006-2010 Johannes Berg <johannes@sipsolutions.net>
|
2019-01-21 13:14:57 +03:00
|
|
|
* Copyright (C) 2018-2019 Intel Corporation
|
2007-04-23 23:20:05 +04:00
|
|
|
*/
|
|
|
|
|
#ifndef __NET_WIRELESS_CORE_H
|
|
|
|
|
#define __NET_WIRELESS_CORE_H
|
|
|
|
|
#include <linux/list.h>
|
|
|
|
|
#include <linux/netdevice.h>
|
2009-02-10 23:25:55 +03:00
|
|
|
#include <linux/rbtree.h>
|
2009-05-02 08:37:21 +04:00
|
|
|
#include <linux/debugfs.h>
|
2009-06-02 15:01:41 +04:00
|
|
|
#include <linux/rfkill.h>
|
|
|
|
|
#include <linux/workqueue.h>
|
2012-07-04 15:28:18 +04:00
|
|
|
#include <linux/rtnetlink.h>
|
2007-04-23 23:20:05 +04:00
|
|
|
#include <net/genetlink.h>
|
|
|
|
|
#include <net/cfg80211.h>
|
2008-11-13 01:22:02 +03:00
|
|
|
#include "reg.h"
|
2007-04-23 23:20:05 +04:00
|
|
|
|
2012-12-03 21:23:37 +04:00
|
|
|
|
|
|
|
|
#define WIPHY_IDX_INVALID -1
|
|
|
|
|
|
2007-04-23 23:20:05 +04:00
|
|
|
struct cfg80211_registered_device {
|
2009-05-17 02:13:46 +04:00
|
|
|
const struct cfg80211_ops *ops;
|
2007-04-23 23:20:05 +04:00
|
|
|
struct list_head list;
|
|
|
|
|
|
2009-06-02 15:01:41 +04:00
|
|
|
/* rfkill support */
|
|
|
|
|
struct rfkill_ops rfkill_ops;
|
|
|
|
|
struct rfkill *rfkill;
|
2019-08-30 14:24:44 +03:00
|
|
|
struct work_struct rfkill_block;
|
2009-06-02 15:01:41 +04:00
|
|
|
|
2008-11-13 01:22:02 +03:00
|
|
|
/* ISO / IEC 3166 alpha2 for which this device is receiving
|
|
|
|
|
* country IEs on, this can help disregard country IEs from APs
|
|
|
|
|
* on the same alpha2 quickly. The alpha2 may differ from
|
|
|
|
|
* cfg80211_regdomain's alpha2 when an intersection has occurred.
|
|
|
|
|
* If the AP is reconfigured this can also be used to tell us if
|
|
|
|
|
* the country on the country IE changed. */
|
|
|
|
|
char country_ie_alpha2[2];
|
|
|
|
|
|
2014-12-15 20:26:00 +03:00
|
|
|
/*
|
|
|
|
|
* the driver requests the regulatory core to set this regulatory
|
|
|
|
|
* domain as the wiphy's. Only used for %REGULATORY_WIPHY_SELF_MANAGED
|
|
|
|
|
* devices using the regulatory_set_wiphy_regd() API
|
|
|
|
|
*/
|
|
|
|
|
const struct ieee80211_regdomain *requested_regd;
|
|
|
|
|
|
2008-11-13 01:22:02 +03:00
|
|
|
/* If a Country IE has been received this tells us the environment
|
|
|
|
|
* which its telling us its in. This defaults to ENVIRON_ANY */
|
|
|
|
|
enum environment_cap env;
|
|
|
|
|
|
2007-04-23 23:20:05 +04:00
|
|
|
/* wiphy index, internal only */
|
2009-02-21 08:04:19 +03:00
|
|
|
int wiphy_idx;
|
2007-04-23 23:20:05 +04:00
|
|
|
|
2016-05-03 16:52:04 +03:00
|
|
|
/* protected by RTNL */
|
2012-06-15 16:33:17 +04:00
|
|
|
int devlist_generation, wdev_id;
|
2016-05-03 16:26:40 +03:00
|
|
|
int opencount;
|
2009-08-18 21:51:57 +04:00
|
|
|
wait_queue_head_t dev_wait;
|
2007-04-23 23:20:05 +04:00
|
|
|
|
2012-10-27 01:49:25 +04:00
|
|
|
struct list_head beacon_registrations;
|
|
|
|
|
spinlock_t beacon_registrations_lock;
|
2011-11-04 14:18:17 +04:00
|
|
|
|
2012-07-04 15:28:18 +04:00
|
|
|
/* protected by RTNL only */
|
2012-06-29 14:47:01 +04:00
|
|
|
int num_running_ifaces;
|
|
|
|
|
int num_running_monitor_ifaces;
|
2018-10-01 12:52:07 +03:00
|
|
|
u64 cookie_counter;
|
2012-06-29 14:47:01 +04:00
|
|
|
|
2009-02-10 23:25:55 +03:00
|
|
|
/* BSSes/scanning */
|
|
|
|
|
spinlock_t bss_lock;
|
|
|
|
|
struct list_head bss_list;
|
|
|
|
|
struct rb_root bss_tree;
|
|
|
|
|
u32 bss_generation;
|
2016-11-15 14:05:11 +03:00
|
|
|
u32 bss_entries;
|
2009-02-10 23:25:55 +03:00
|
|
|
struct cfg80211_scan_request *scan_req; /* protected by RTNL */
|
cfg80211: send scan results from work queue
Due to the previous commit, when a scan finishes, it is in theory
possible to hit the following sequence:
1. interface starts being removed
2. scan is cancelled by driver and cfg80211 is notified
3. scan done work is scheduled
4. interface is removed completely, rdev->scan_req is freed,
event sent to userspace but scan done work remains pending
5. new scan is requested on another virtual interface
6. scan done work runs, freeing the still-running scan
To fix this situation, hang on to the scan done message and block
new scans while that is the case, and only send the message from
the work function, regardless of whether the scan_req is already
freed from interface removal. This makes step 5 above impossible
and changes step 6 to be
5. scan done work runs, sending the scan done message
As this can't work for wext, so we send the message immediately,
but this shouldn't be an issue since we still return -EBUSY.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2014-01-22 13:14:19 +04:00
|
|
|
struct sk_buff *scan_msg;
|
2017-04-21 15:05:00 +03:00
|
|
|
struct list_head sched_scan_req_list;
|
2018-06-18 18:11:14 +03:00
|
|
|
time64_t suspend_at;
|
2009-07-07 05:56:11 +04:00
|
|
|
struct work_struct scan_done_wk;
|
2009-02-10 23:25:55 +03:00
|
|
|
|
2013-11-13 16:37:47 +04:00
|
|
|
struct genl_info *cur_cmd_info;
|
2009-07-01 23:26:51 +04:00
|
|
|
|
2009-07-02 11:13:27 +04:00
|
|
|
struct work_struct conn_work;
|
2009-07-07 05:56:11 +04:00
|
|
|
struct work_struct event_work;
|
2009-07-02 11:13:27 +04:00
|
|
|
|
2013-02-08 21:16:19 +04:00
|
|
|
struct delayed_work dfs_update_channels_wk;
|
|
|
|
|
|
2013-04-18 17:49:00 +04:00
|
|
|
/* netlink port which started critical protocol (0 means not started) */
|
|
|
|
|
u32 crit_proto_nlportid;
|
|
|
|
|
|
2013-06-28 22:51:26 +04:00
|
|
|
struct cfg80211_coalesce *coalesce;
|
|
|
|
|
|
2014-03-24 20:57:27 +04:00
|
|
|
struct work_struct destroy_work;
|
2014-12-15 14:25:39 +03:00
|
|
|
struct work_struct sched_scan_stop_wk;
|
2017-04-28 15:40:28 +03:00
|
|
|
struct work_struct sched_scan_res_wk;
|
2014-12-15 14:25:39 +03:00
|
|
|
|
2017-02-27 14:34:35 +03:00
|
|
|
struct cfg80211_chan_def radar_chandef;
|
|
|
|
|
struct work_struct propagate_radar_detect_wk;
|
|
|
|
|
|
|
|
|
|
struct cfg80211_chan_def cac_done_chandef;
|
|
|
|
|
struct work_struct propagate_cac_done_wk;
|
|
|
|
|
|
2007-04-23 23:20:05 +04:00
|
|
|
/* must be last because of the way we do wiphy_priv(),
|
|
|
|
|
* and it should at least be aligned to NETDEV_ALIGN */
|
2012-12-28 15:22:02 +04:00
|
|
|
struct wiphy wiphy __aligned(NETDEV_ALIGN);
|
2007-04-23 23:20:05 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static inline
|
2014-04-21 08:53:03 +04:00
|
|
|
struct cfg80211_registered_device *wiphy_to_rdev(struct wiphy *wiphy)
|
2007-04-23 23:20:05 +04:00
|
|
|
{
|
|
|
|
|
BUG_ON(!wiphy);
|
|
|
|
|
return container_of(wiphy, struct cfg80211_registered_device, wiphy);
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-04 17:37:28 +04:00
|
|
|
static inline void
|
|
|
|
|
cfg80211_rdev_free_wowlan(struct cfg80211_registered_device *rdev)
|
|
|
|
|
{
|
2013-05-15 11:30:07 +04:00
|
|
|
#ifdef CONFIG_PM
|
2011-05-04 17:37:28 +04:00
|
|
|
int i;
|
|
|
|
|
|
2013-05-15 11:30:07 +04:00
|
|
|
if (!rdev->wiphy.wowlan_config)
|
2011-05-04 17:37:28 +04:00
|
|
|
return;
|
2013-05-15 11:30:07 +04:00
|
|
|
for (i = 0; i < rdev->wiphy.wowlan_config->n_patterns; i++)
|
|
|
|
|
kfree(rdev->wiphy.wowlan_config->patterns[i].mask);
|
|
|
|
|
kfree(rdev->wiphy.wowlan_config->patterns);
|
|
|
|
|
if (rdev->wiphy.wowlan_config->tcp &&
|
|
|
|
|
rdev->wiphy.wowlan_config->tcp->sock)
|
|
|
|
|
sock_release(rdev->wiphy.wowlan_config->tcp->sock);
|
|
|
|
|
kfree(rdev->wiphy.wowlan_config->tcp);
|
2014-09-17 12:55:28 +04:00
|
|
|
kfree(rdev->wiphy.wowlan_config->nd_config);
|
2013-05-15 11:30:07 +04:00
|
|
|
kfree(rdev->wiphy.wowlan_config);
|
|
|
|
|
#endif
|
2011-05-04 17:37:28 +04:00
|
|
|
}
|
2009-11-25 17:13:00 +03:00
|
|
|
|
2018-10-01 12:52:07 +03:00
|
|
|
static inline u64 cfg80211_assign_cookie(struct cfg80211_registered_device *rdev)
|
|
|
|
|
{
|
|
|
|
|
u64 r = ++rdev->cookie_counter;
|
|
|
|
|
|
|
|
|
|
if (WARN_ON(r == 0))
|
|
|
|
|
r = ++rdev->cookie_counter;
|
|
|
|
|
|
|
|
|
|
return r;
|
|
|
|
|
}
|
|
|
|
|
|
2009-11-25 17:13:00 +03:00
|
|
|
extern struct workqueue_struct *cfg80211_wq;
|
2009-07-07 05:56:12 +04:00
|
|
|
extern struct list_head cfg80211_rdev_list;
|
2009-08-07 18:17:38 +04:00
|
|
|
extern int cfg80211_rdev_list_generation;
|
2007-04-23 23:20:05 +04:00
|
|
|
|
2009-02-10 23:25:55 +03:00
|
|
|
struct cfg80211_internal_bss {
|
|
|
|
|
struct list_head list;
|
2013-02-01 05:06:18 +04:00
|
|
|
struct list_head hidden_list;
|
2009-02-10 23:25:55 +03:00
|
|
|
struct rb_node rbn;
|
2015-10-07 12:32:53 +03:00
|
|
|
u64 ts_boottime;
|
2009-02-10 23:25:55 +03:00
|
|
|
unsigned long ts;
|
2013-02-01 05:06:18 +04:00
|
|
|
unsigned long refcount;
|
2009-07-02 19:20:43 +04:00
|
|
|
atomic_t hold;
|
2009-03-22 22:57:28 +03:00
|
|
|
|
2016-07-05 17:10:13 +03:00
|
|
|
/* time at the start of the reception of the first octet of the
|
|
|
|
|
* timestamp field of the last beacon/probe received for this BSS.
|
|
|
|
|
* The time is the TSF of the BSS specified by %parent_bssid.
|
|
|
|
|
*/
|
|
|
|
|
u64 parent_tsf;
|
|
|
|
|
|
|
|
|
|
/* the BSS according to which %parent_tsf is set. This is set to
|
|
|
|
|
* the BSS that the interface that requested the scan was connected to
|
|
|
|
|
* when the beacon/probe was received.
|
|
|
|
|
*/
|
|
|
|
|
u8 parent_bssid[ETH_ALEN] __aligned(2);
|
|
|
|
|
|
2009-02-10 23:25:55 +03:00
|
|
|
/* must be last because of priv member */
|
|
|
|
|
struct cfg80211_bss pub;
|
|
|
|
|
};
|
|
|
|
|
|
2009-07-02 19:20:43 +04:00
|
|
|
static inline struct cfg80211_internal_bss *bss_from_pub(struct cfg80211_bss *pub)
|
|
|
|
|
{
|
|
|
|
|
return container_of(pub, struct cfg80211_internal_bss, pub);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void cfg80211_hold_bss(struct cfg80211_internal_bss *bss)
|
|
|
|
|
{
|
|
|
|
|
atomic_inc(&bss->hold);
|
2019-01-21 13:25:59 +03:00
|
|
|
if (bss->pub.transmitted_bss) {
|
|
|
|
|
bss = container_of(bss->pub.transmitted_bss,
|
2019-01-21 13:22:21 +03:00
|
|
|
struct cfg80211_internal_bss, pub);
|
|
|
|
|
atomic_inc(&bss->hold);
|
|
|
|
|
}
|
2009-07-02 19:20:43 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void cfg80211_unhold_bss(struct cfg80211_internal_bss *bss)
|
|
|
|
|
{
|
|
|
|
|
int r = atomic_dec_return(&bss->hold);
|
|
|
|
|
WARN_ON(r < 0);
|
2019-01-21 13:25:59 +03:00
|
|
|
if (bss->pub.transmitted_bss) {
|
|
|
|
|
bss = container_of(bss->pub.transmitted_bss,
|
2019-01-21 13:22:21 +03:00
|
|
|
struct cfg80211_internal_bss, pub);
|
|
|
|
|
r = atomic_dec_return(&bss->hold);
|
|
|
|
|
WARN_ON(r < 0);
|
|
|
|
|
}
|
2009-07-02 19:20:43 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2009-07-07 05:56:12 +04:00
|
|
|
struct cfg80211_registered_device *cfg80211_rdev_by_wiphy_idx(int wiphy_idx);
|
2009-02-21 08:04:26 +03:00
|
|
|
int get_wiphy_idx(struct wiphy *wiphy);
|
|
|
|
|
|
|
|
|
|
struct wiphy *wiphy_idx_to_wiphy(int wiphy_idx);
|
|
|
|
|
|
2009-07-14 02:33:35 +04:00
|
|
|
int cfg80211_switch_netns(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct net *net);
|
2007-09-20 21:09:35 +04:00
|
|
|
|
2018-09-13 15:12:03 +03:00
|
|
|
void cfg80211_init_wdev(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct wireless_dev *wdev);
|
|
|
|
|
|
2009-07-07 05:56:11 +04:00
|
|
|
static inline void wdev_lock(struct wireless_dev *wdev)
|
|
|
|
|
__acquires(wdev)
|
|
|
|
|
{
|
|
|
|
|
mutex_lock(&wdev->mtx);
|
|
|
|
|
__acquire(wdev->mtx);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void wdev_unlock(struct wireless_dev *wdev)
|
|
|
|
|
__releases(wdev)
|
|
|
|
|
{
|
|
|
|
|
__release(wdev->mtx);
|
|
|
|
|
mutex_unlock(&wdev->mtx);
|
|
|
|
|
}
|
|
|
|
|
|
2010-09-15 15:28:15 +04:00
|
|
|
#define ASSERT_WDEV_LOCK(wdev) lockdep_assert_held(&(wdev)->mtx)
|
2009-07-07 05:56:11 +04:00
|
|
|
|
2012-06-29 14:47:01 +04:00
|
|
|
static inline bool cfg80211_has_monitors_only(struct cfg80211_registered_device *rdev)
|
|
|
|
|
{
|
2012-07-04 15:28:18 +04:00
|
|
|
ASSERT_RTNL();
|
2012-06-29 14:47:01 +04:00
|
|
|
|
|
|
|
|
return rdev->num_running_ifaces == rdev->num_running_monitor_ifaces &&
|
|
|
|
|
rdev->num_running_ifaces > 0;
|
|
|
|
|
}
|
|
|
|
|
|
2009-07-07 05:56:11 +04:00
|
|
|
enum cfg80211_event_type {
|
|
|
|
|
EVENT_CONNECT_RESULT,
|
|
|
|
|
EVENT_ROAMED,
|
|
|
|
|
EVENT_DISCONNECTED,
|
|
|
|
|
EVENT_IBSS_JOINED,
|
2014-04-09 17:11:01 +04:00
|
|
|
EVENT_STOPPED,
|
2017-09-29 15:21:49 +03:00
|
|
|
EVENT_PORT_AUTHORIZED,
|
2009-07-07 05:56:11 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct cfg80211_event {
|
|
|
|
|
struct list_head list;
|
|
|
|
|
enum cfg80211_event_type type;
|
|
|
|
|
|
|
|
|
|
union {
|
2017-03-31 00:22:33 +03:00
|
|
|
struct cfg80211_connect_resp_params cr;
|
2017-04-26 10:58:49 +03:00
|
|
|
struct cfg80211_roam_info rm;
|
2009-07-07 05:56:11 +04:00
|
|
|
struct {
|
|
|
|
|
const u8 *ie;
|
|
|
|
|
size_t ie_len;
|
|
|
|
|
u16 reason;
|
2015-05-22 17:22:20 +03:00
|
|
|
bool locally_generated;
|
2009-07-07 05:56:11 +04:00
|
|
|
} dc;
|
|
|
|
|
struct {
|
|
|
|
|
u8 bssid[ETH_ALEN];
|
2014-01-29 20:53:43 +04:00
|
|
|
struct ieee80211_channel *channel;
|
2009-07-07 05:56:11 +04:00
|
|
|
} ij;
|
2017-09-29 15:21:49 +03:00
|
|
|
struct {
|
|
|
|
|
u8 bssid[ETH_ALEN];
|
|
|
|
|
} pa;
|
2009-07-07 05:56:11 +04:00
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
|
cfg80211: rework key operation
This reworks the key operation in cfg80211, and now only
allows, from userspace, configuring keys (via nl80211)
after the connection has been established (in managed
mode), the IBSS been joined (in IBSS mode), at any time
(in AP[_VLAN] modes) or never for all the other modes.
In order to do shared key authentication correctly, it
is now possible to give a WEP key to the AUTH command.
To configure static WEP keys, these are given to the
CONNECT or IBSS_JOIN command directly, for a userspace
SME it is assumed it will configure it properly after
the connection has been established.
Since mac80211 used to check the default key in IBSS
mode to see whether or not the network is protected,
it needs an update in that area, as well as an update
to make use of the WEP key passed to auth() for shared
key authentication.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-07-08 16:22:54 +04:00
|
|
|
struct cfg80211_cached_keys {
|
2016-09-22 23:16:50 +03:00
|
|
|
struct key_params params[CFG80211_MAX_WEP_KEYS];
|
|
|
|
|
u8 data[CFG80211_MAX_WEP_KEYS][WLAN_KEY_LEN_WEP104];
|
2016-09-13 17:39:38 +03:00
|
|
|
int def;
|
cfg80211: rework key operation
This reworks the key operation in cfg80211, and now only
allows, from userspace, configuring keys (via nl80211)
after the connection has been established (in managed
mode), the IBSS been joined (in IBSS mode), at any time
(in AP[_VLAN] modes) or never for all the other modes.
In order to do shared key authentication correctly, it
is now possible to give a WEP key to the AUTH command.
To configure static WEP keys, these are given to the
CONNECT or IBSS_JOIN command directly, for a userspace
SME it is assumed it will configure it properly after
the connection has been established.
Since mac80211 used to check the default key in IBSS
mode to see whether or not the network is protected,
it needs an update in that area, as well as an update
to make use of the WEP key passed to auth() for shared
key authentication.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-07-08 16:22:54 +04:00
|
|
|
};
|
|
|
|
|
|
2012-06-29 14:47:00 +04:00
|
|
|
enum cfg80211_chan_mode {
|
|
|
|
|
CHAN_MODE_UNDEFINED,
|
|
|
|
|
CHAN_MODE_SHARED,
|
|
|
|
|
CHAN_MODE_EXCLUSIVE,
|
|
|
|
|
};
|
|
|
|
|
|
2012-10-27 01:49:25 +04:00
|
|
|
struct cfg80211_beacon_registration {
|
|
|
|
|
struct list_head list;
|
|
|
|
|
u32 nlportid;
|
|
|
|
|
};
|
2009-07-07 05:56:11 +04:00
|
|
|
|
2017-02-10 12:02:31 +03:00
|
|
|
struct cfg80211_cqm_config {
|
|
|
|
|
u32 rssi_hyst;
|
|
|
|
|
s32 last_rssi_event_value;
|
|
|
|
|
int n_rssi_thresholds;
|
|
|
|
|
s32 rssi_thresholds[0];
|
|
|
|
|
};
|
|
|
|
|
|
2014-03-24 20:57:27 +04:00
|
|
|
void cfg80211_destroy_ifaces(struct cfg80211_registered_device *rdev);
|
|
|
|
|
|
2007-04-23 23:20:05 +04:00
|
|
|
/* free object */
|
2013-10-19 00:48:25 +04:00
|
|
|
void cfg80211_dev_free(struct cfg80211_registered_device *rdev);
|
2007-04-23 23:20:05 +04:00
|
|
|
|
2013-10-19 00:48:25 +04:00
|
|
|
int cfg80211_dev_rename(struct cfg80211_registered_device *rdev,
|
|
|
|
|
char *newname);
|
2007-09-20 21:09:35 +04:00
|
|
|
|
2008-01-24 21:38:38 +03:00
|
|
|
void ieee80211_set_bitrate_flags(struct wiphy *wiphy);
|
|
|
|
|
|
2014-04-21 08:53:02 +04:00
|
|
|
void cfg80211_bss_expire(struct cfg80211_registered_device *rdev);
|
|
|
|
|
void cfg80211_bss_age(struct cfg80211_registered_device *rdev,
|
2009-02-12 01:14:43 +03:00
|
|
|
unsigned long age_secs);
|
cfg80211: fix duplicated scan entries after channel switch
When associated BSS completes channel switch procedure, its channel
record needs to be updated. The existing mac80211 solution was
extended to cfg80211 in commit 5dc8cdce1d72 ("mac80211/cfg80211:
update bss channel on channel switch").
However that solution still appears to be incomplete as it may lead
to duplicated scan entries for associated BSS after channel switch.
The root cause of the problem is as follows. Each BSS entry is
included into the following data structures:
- bss list rdev->bss_list
- bss search tree rdev->bss_tree
Updating BSS channel record without rebuilding bss_tree may break
tree search since cmp_bss considers all of the following: channel,
bssid, ssid. When BSS channel is updated, but its location in bss_tree
is not updated, then subsequent search operations may fail to locate
this BSS since they will be traversing bss_tree in wrong direction.
As a result, for scan performed after associated BSS channel switch,
cfg80211_bss_update may add the second entry for the same BSS to both
bss_list and bss_tree, rather then update the existing one.
To summarize, if BSS channel needs to be updated, then bss_tree should
be rebuilt in order to put updated BSS entry into a proper location.
This commit suggests the following straightforward solution:
- if new entry has been already created for BSS after channel switch,
then use its IEs to update known BSS entry and then remove new
entry completely
- use rb_erase/rb_insert_bss reinstall updated BSS in bss_tree
- for nontransmit BSS entry, the whole transmit BSS hierarchy
is updated
Signed-off-by: Sergey Matyukevich <sergey.matyukevich.os@quantenna.com>
Link: https://lore.kernel.org/r/20190726163922.27509-3-sergey.matyukevich.os@quantenna.com
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2019-07-26 19:39:34 +03:00
|
|
|
void cfg80211_update_assoc_bss_entry(struct wireless_dev *wdev,
|
|
|
|
|
struct ieee80211_channel *channel);
|
2009-02-10 23:25:55 +03:00
|
|
|
|
2009-04-19 23:24:32 +04:00
|
|
|
/* IBSS */
|
2018-03-26 20:52:45 +03:00
|
|
|
int __cfg80211_join_ibss(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct net_device *dev,
|
|
|
|
|
struct cfg80211_ibss_params *params,
|
|
|
|
|
struct cfg80211_cached_keys *connkeys);
|
2009-04-20 20:43:46 +04:00
|
|
|
void cfg80211_clear_ibss(struct net_device *dev, bool nowext);
|
2009-11-18 15:03:43 +03:00
|
|
|
int __cfg80211_leave_ibss(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct net_device *dev, bool nowext);
|
2009-04-19 23:24:32 +04:00
|
|
|
int cfg80211_leave_ibss(struct cfg80211_registered_device *rdev,
|
2009-04-20 20:43:46 +04:00
|
|
|
struct net_device *dev, bool nowext);
|
2014-01-29 20:53:43 +04:00
|
|
|
void __cfg80211_ibss_joined(struct net_device *dev, const u8 *bssid,
|
|
|
|
|
struct ieee80211_channel *channel);
|
cfg80211: rework key operation
This reworks the key operation in cfg80211, and now only
allows, from userspace, configuring keys (via nl80211)
after the connection has been established (in managed
mode), the IBSS been joined (in IBSS mode), at any time
(in AP[_VLAN] modes) or never for all the other modes.
In order to do shared key authentication correctly, it
is now possible to give a WEP key to the AUTH command.
To configure static WEP keys, these are given to the
CONNECT or IBSS_JOIN command directly, for a userspace
SME it is assumed it will configure it properly after
the connection has been established.
Since mac80211 used to check the default key in IBSS
mode to see whether or not the network is protected,
it needs an update in that area, as well as an update
to make use of the WEP key passed to auth() for shared
key authentication.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-07-08 16:22:54 +04:00
|
|
|
int cfg80211_ibss_wext_join(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct wireless_dev *wdev);
|
2009-04-19 23:24:32 +04:00
|
|
|
|
2010-12-03 11:20:44 +03:00
|
|
|
/* mesh */
|
|
|
|
|
extern const struct mesh_config default_mesh_config;
|
2010-12-17 04:37:49 +03:00
|
|
|
extern const struct mesh_setup default_mesh_setup;
|
2010-12-03 11:20:44 +03:00
|
|
|
int __cfg80211_join_mesh(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct net_device *dev,
|
2012-05-17 01:50:20 +04:00
|
|
|
struct mesh_setup *setup,
|
2010-12-03 11:20:44 +03:00
|
|
|
const struct mesh_config *conf);
|
2014-04-09 17:11:01 +04:00
|
|
|
int __cfg80211_leave_mesh(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct net_device *dev);
|
2010-12-03 11:20:44 +03:00
|
|
|
int cfg80211_leave_mesh(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct net_device *dev);
|
2012-11-09 00:25:48 +04:00
|
|
|
int cfg80211_set_mesh_channel(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct wireless_dev *wdev,
|
|
|
|
|
struct cfg80211_chan_def *chandef);
|
2010-12-03 11:20:44 +03:00
|
|
|
|
2014-11-03 12:33:18 +03:00
|
|
|
/* OCB */
|
|
|
|
|
int __cfg80211_join_ocb(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct net_device *dev,
|
|
|
|
|
struct ocb_setup *setup);
|
|
|
|
|
int cfg80211_join_ocb(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct net_device *dev,
|
|
|
|
|
struct ocb_setup *setup);
|
|
|
|
|
int __cfg80211_leave_ocb(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct net_device *dev);
|
|
|
|
|
int cfg80211_leave_ocb(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct net_device *dev);
|
|
|
|
|
|
2012-06-29 14:46:56 +04:00
|
|
|
/* AP */
|
2014-04-09 17:11:01 +04:00
|
|
|
int __cfg80211_stop_ap(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct net_device *dev, bool notify);
|
2012-06-29 14:46:56 +04:00
|
|
|
int cfg80211_stop_ap(struct cfg80211_registered_device *rdev,
|
2014-02-25 17:33:38 +04:00
|
|
|
struct net_device *dev, bool notify);
|
2012-06-29 14:46:56 +04:00
|
|
|
|
2009-07-02 19:20:43 +04:00
|
|
|
/* MLME */
|
|
|
|
|
int cfg80211_mlme_auth(struct cfg80211_registered_device *rdev,
|
2013-05-15 19:44:01 +04:00
|
|
|
struct net_device *dev,
|
|
|
|
|
struct ieee80211_channel *chan,
|
|
|
|
|
enum nl80211_auth_type auth_type,
|
|
|
|
|
const u8 *bssid,
|
2009-07-02 19:20:43 +04:00
|
|
|
const u8 *ssid, int ssid_len,
|
cfg80211: rework key operation
This reworks the key operation in cfg80211, and now only
allows, from userspace, configuring keys (via nl80211)
after the connection has been established (in managed
mode), the IBSS been joined (in IBSS mode), at any time
(in AP[_VLAN] modes) or never for all the other modes.
In order to do shared key authentication correctly, it
is now possible to give a WEP key to the AUTH command.
To configure static WEP keys, these are given to the
CONNECT or IBSS_JOIN command directly, for a userspace
SME it is assumed it will configure it properly after
the connection has been established.
Since mac80211 used to check the default key in IBSS
mode to see whether or not the network is protected,
it needs an update in that area, as well as an update
to make use of the WEP key passed to auth() for shared
key authentication.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-07-08 16:22:54 +04:00
|
|
|
const u8 *ie, int ie_len,
|
2012-09-30 20:29:39 +04:00
|
|
|
const u8 *key, int key_len, int key_idx,
|
2016-10-27 00:41:58 +03:00
|
|
|
const u8 *auth_data, int auth_data_len);
|
2009-07-02 19:20:43 +04:00
|
|
|
int cfg80211_mlme_assoc(struct cfg80211_registered_device *rdev,
|
2013-02-21 23:09:09 +04:00
|
|
|
struct net_device *dev,
|
|
|
|
|
struct ieee80211_channel *chan,
|
|
|
|
|
const u8 *bssid,
|
2009-07-07 16:37:26 +04:00
|
|
|
const u8 *ssid, int ssid_len,
|
2013-02-21 23:09:09 +04:00
|
|
|
struct cfg80211_assoc_request *req);
|
2009-07-02 19:20:43 +04:00
|
|
|
int cfg80211_mlme_deauth(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct net_device *dev, const u8 *bssid,
|
2010-04-04 10:37:19 +04:00
|
|
|
const u8 *ie, int ie_len, u16 reason,
|
|
|
|
|
bool local_state_change);
|
2009-07-02 19:20:43 +04:00
|
|
|
int cfg80211_mlme_disassoc(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct net_device *dev, const u8 *bssid,
|
2010-04-04 10:37:19 +04:00
|
|
|
const u8 *ie, int ie_len, u16 reason,
|
|
|
|
|
bool local_state_change);
|
2009-07-02 19:20:43 +04:00
|
|
|
void cfg80211_mlme_down(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct net_device *dev);
|
2010-08-12 17:38:38 +04:00
|
|
|
int cfg80211_mlme_register_mgmt(struct wireless_dev *wdev, u32 snd_pid,
|
|
|
|
|
u16 frame_type, const u8 *match_data,
|
2020-04-17 13:40:15 +03:00
|
|
|
int match_len, bool multicast_rx,
|
|
|
|
|
struct netlink_ext_ack *extack);
|
2020-04-17 13:43:01 +03:00
|
|
|
void cfg80211_mgmt_registrations_update_wk(struct work_struct *wk);
|
2010-08-12 17:38:38 +04:00
|
|
|
void cfg80211_mlme_unregister_socket(struct wireless_dev *wdev, u32 nlpid);
|
|
|
|
|
void cfg80211_mlme_purge_registrations(struct wireless_dev *wdev);
|
|
|
|
|
int cfg80211_mlme_mgmt_tx(struct cfg80211_registered_device *rdev,
|
2012-06-15 17:30:18 +04:00
|
|
|
struct wireless_dev *wdev,
|
2013-11-18 21:06:49 +04:00
|
|
|
struct cfg80211_mgmt_tx_params *params,
|
|
|
|
|
u64 *cookie);
|
2011-11-18 23:31:59 +04:00
|
|
|
void cfg80211_oper_and_ht_capa(struct ieee80211_ht_cap *ht_capa,
|
|
|
|
|
const struct ieee80211_ht_cap *ht_capa_mask);
|
2013-02-21 20:36:01 +04:00
|
|
|
void cfg80211_oper_and_vht_capa(struct ieee80211_vht_cap *vht_capa,
|
|
|
|
|
const struct ieee80211_vht_cap *vht_capa_mask);
|
2009-07-02 19:20:43 +04:00
|
|
|
|
2013-05-16 02:55:45 +04:00
|
|
|
/* SME events */
|
2009-07-01 23:26:54 +04:00
|
|
|
int cfg80211_connect(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct net_device *dev,
|
cfg80211: rework key operation
This reworks the key operation in cfg80211, and now only
allows, from userspace, configuring keys (via nl80211)
after the connection has been established (in managed
mode), the IBSS been joined (in IBSS mode), at any time
(in AP[_VLAN] modes) or never for all the other modes.
In order to do shared key authentication correctly, it
is now possible to give a WEP key to the AUTH command.
To configure static WEP keys, these are given to the
CONNECT or IBSS_JOIN command directly, for a userspace
SME it is assumed it will configure it properly after
the connection has been established.
Since mac80211 used to check the default key in IBSS
mode to see whether or not the network is protected,
it needs an update in that area, as well as an update
to make use of the WEP key passed to auth() for shared
key authentication.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-07-08 16:22:54 +04:00
|
|
|
struct cfg80211_connect_params *connect,
|
2013-05-15 19:44:01 +04:00
|
|
|
struct cfg80211_cached_keys *connkeys,
|
|
|
|
|
const u8 *prev_bssid);
|
2017-03-31 00:22:33 +03:00
|
|
|
void __cfg80211_connect_result(struct net_device *dev,
|
|
|
|
|
struct cfg80211_connect_resp_params *params,
|
|
|
|
|
bool wextev);
|
2013-05-16 02:55:45 +04:00
|
|
|
void __cfg80211_disconnected(struct net_device *dev, const u8 *ie,
|
|
|
|
|
size_t ie_len, u16 reason, bool from_ap);
|
2009-07-01 23:26:54 +04:00
|
|
|
int cfg80211_disconnect(struct cfg80211_registered_device *rdev,
|
2009-07-01 23:26:56 +04:00
|
|
|
struct net_device *dev, u16 reason,
|
|
|
|
|
bool wextev);
|
2011-05-16 20:40:15 +04:00
|
|
|
void __cfg80211_roamed(struct wireless_dev *wdev,
|
2017-04-26 10:58:49 +03:00
|
|
|
struct cfg80211_roam_info *info);
|
2017-09-29 15:21:49 +03:00
|
|
|
void __cfg80211_port_authorized(struct wireless_dev *wdev, const u8 *bssid);
|
cfg80211: rework key operation
This reworks the key operation in cfg80211, and now only
allows, from userspace, configuring keys (via nl80211)
after the connection has been established (in managed
mode), the IBSS been joined (in IBSS mode), at any time
(in AP[_VLAN] modes) or never for all the other modes.
In order to do shared key authentication correctly, it
is now possible to give a WEP key to the AUTH command.
To configure static WEP keys, these are given to the
CONNECT or IBSS_JOIN command directly, for a userspace
SME it is assumed it will configure it properly after
the connection has been established.
Since mac80211 used to check the default key in IBSS
mode to see whether or not the network is protected,
it needs an update in that area, as well as an update
to make use of the WEP key passed to auth() for shared
key authentication.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-07-08 16:22:54 +04:00
|
|
|
int cfg80211_mgd_wext_connect(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct wireless_dev *wdev);
|
2017-01-07 00:33:43 +03:00
|
|
|
void cfg80211_autodisconnect_wk(struct work_struct *work);
|
2009-07-01 23:26:54 +04:00
|
|
|
|
2013-05-16 02:55:45 +04:00
|
|
|
/* SME implementation */
|
2009-07-02 11:13:27 +04:00
|
|
|
void cfg80211_conn_work(struct work_struct *work);
|
2013-05-16 02:55:45 +04:00
|
|
|
void cfg80211_sme_scan_done(struct net_device *dev);
|
|
|
|
|
bool cfg80211_sme_rx_assoc_resp(struct wireless_dev *wdev, u16 status);
|
|
|
|
|
void cfg80211_sme_rx_auth(struct wireless_dev *wdev, const u8 *buf, size_t len);
|
|
|
|
|
void cfg80211_sme_disassoc(struct wireless_dev *wdev);
|
|
|
|
|
void cfg80211_sme_deauth(struct wireless_dev *wdev);
|
|
|
|
|
void cfg80211_sme_auth_timeout(struct wireless_dev *wdev);
|
|
|
|
|
void cfg80211_sme_assoc_timeout(struct wireless_dev *wdev);
|
2016-12-08 19:22:09 +03:00
|
|
|
void cfg80211_sme_abandon_assoc(struct wireless_dev *wdev);
|
2009-07-02 11:13:27 +04:00
|
|
|
|
2009-05-11 15:54:58 +04:00
|
|
|
/* internal helpers */
|
2011-09-21 19:14:56 +04:00
|
|
|
bool cfg80211_supported_cipher_suite(struct wiphy *wiphy, u32 cipher);
|
cfg80211: rework key operation
This reworks the key operation in cfg80211, and now only
allows, from userspace, configuring keys (via nl80211)
after the connection has been established (in managed
mode), the IBSS been joined (in IBSS mode), at any time
(in AP[_VLAN] modes) or never for all the other modes.
In order to do shared key authentication correctly, it
is now possible to give a WEP key to the AUTH command.
To configure static WEP keys, these are given to the
CONNECT or IBSS_JOIN command directly, for a userspace
SME it is assumed it will configure it properly after
the connection has been established.
Since mac80211 used to check the default key in IBSS
mode to see whether or not the network is protected,
it needs an update in that area, as well as an update
to make use of the WEP key passed to auth() for shared
key authentication.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-07-08 16:22:54 +04:00
|
|
|
int cfg80211_validate_key_settings(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct key_params *params, int key_idx,
|
2010-10-05 21:39:30 +04:00
|
|
|
bool pairwise, const u8 *mac_addr);
|
2009-07-07 05:56:11 +04:00
|
|
|
void __cfg80211_scan_done(struct work_struct *wk);
|
cfg80211: send scan results from work queue
Due to the previous commit, when a scan finishes, it is in theory
possible to hit the following sequence:
1. interface starts being removed
2. scan is cancelled by driver and cfg80211 is notified
3. scan done work is scheduled
4. interface is removed completely, rdev->scan_req is freed,
event sent to userspace but scan done work remains pending
5. new scan is requested on another virtual interface
6. scan done work runs, freeing the still-running scan
To fix this situation, hang on to the scan done message and block
new scans while that is the case, and only send the message from
the work function, regardless of whether the scan_req is already
freed from interface removal. This makes step 5 above impossible
and changes step 6 to be
5. scan done work runs, sending the scan done message
As this can't work for wext, so we send the message immediately,
but this shouldn't be an issue since we still return -EBUSY.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2014-01-22 13:14:19 +04:00
|
|
|
void ___cfg80211_scan_done(struct cfg80211_registered_device *rdev,
|
|
|
|
|
bool send_message);
|
2017-04-21 15:05:00 +03:00
|
|
|
void cfg80211_add_sched_scan_req(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct cfg80211_sched_scan_request *req);
|
|
|
|
|
int cfg80211_sched_scan_req_possible(struct cfg80211_registered_device *rdev,
|
|
|
|
|
bool want_multi);
|
2017-04-28 15:40:28 +03:00
|
|
|
void cfg80211_sched_scan_results_wk(struct work_struct *work);
|
2017-04-21 15:05:00 +03:00
|
|
|
int cfg80211_stop_sched_scan_req(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct cfg80211_sched_scan_request *req,
|
|
|
|
|
bool driver_initiated);
|
2011-05-11 18:09:35 +04:00
|
|
|
int __cfg80211_stop_sched_scan(struct cfg80211_registered_device *rdev,
|
2017-04-21 15:05:00 +03:00
|
|
|
u64 reqid, bool driver_initiated);
|
cfg80211: rework key operation
This reworks the key operation in cfg80211, and now only
allows, from userspace, configuring keys (via nl80211)
after the connection has been established (in managed
mode), the IBSS been joined (in IBSS mode), at any time
(in AP[_VLAN] modes) or never for all the other modes.
In order to do shared key authentication correctly, it
is now possible to give a WEP key to the AUTH command.
To configure static WEP keys, these are given to the
CONNECT or IBSS_JOIN command directly, for a userspace
SME it is assumed it will configure it properly after
the connection has been established.
Since mac80211 used to check the default key in IBSS
mode to see whether or not the network is protected,
it needs an update in that area, as well as an update
to make use of the WEP key passed to auth() for shared
key authentication.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-07-08 16:22:54 +04:00
|
|
|
void cfg80211_upload_connect_keys(struct wireless_dev *wdev);
|
2009-08-21 16:51:05 +04:00
|
|
|
int cfg80211_change_iface(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct net_device *dev, enum nl80211_iftype ntype,
|
2017-04-12 12:23:28 +03:00
|
|
|
struct vif_params *params);
|
2009-08-21 16:51:05 +04:00
|
|
|
void cfg80211_process_rdev_events(struct cfg80211_registered_device *rdev);
|
2012-08-02 21:41:48 +04:00
|
|
|
void cfg80211_process_wdev_events(struct wireless_dev *wdev);
|
2009-05-11 15:54:58 +04:00
|
|
|
|
2017-01-04 20:58:30 +03:00
|
|
|
bool cfg80211_does_bw_fit_range(const struct ieee80211_freq_range *freq_range,
|
|
|
|
|
u32 center_freq_khz, u32 bw_khz);
|
|
|
|
|
|
2019-02-01 13:09:54 +03:00
|
|
|
extern struct work_struct cfg80211_disconnect_work;
|
|
|
|
|
|
2013-11-05 17:48:48 +04:00
|
|
|
/**
|
|
|
|
|
* cfg80211_chandef_dfs_usable - checks if chandef is DFS usable
|
|
|
|
|
* @wiphy: the wiphy to validate against
|
|
|
|
|
* @chandef: the channel definition to check
|
|
|
|
|
*
|
|
|
|
|
* Checks if chandef is usable and we can/need start CAC on such channel.
|
|
|
|
|
*
|
|
|
|
|
* Return: Return true if all channels available and at least
|
|
|
|
|
* one channel require CAC (NL80211_DFS_USABLE)
|
|
|
|
|
*/
|
|
|
|
|
bool cfg80211_chandef_dfs_usable(struct wiphy *wiphy,
|
|
|
|
|
const struct cfg80211_chan_def *chandef);
|
|
|
|
|
|
2013-02-08 21:16:19 +04:00
|
|
|
void cfg80211_set_dfs_state(struct wiphy *wiphy,
|
|
|
|
|
const struct cfg80211_chan_def *chandef,
|
|
|
|
|
enum nl80211_dfs_state dfs_state);
|
|
|
|
|
|
|
|
|
|
void cfg80211_dfs_channels_update_work(struct work_struct *work);
|
|
|
|
|
|
2014-02-21 22:46:13 +04:00
|
|
|
unsigned int
|
|
|
|
|
cfg80211_chandef_dfs_cac_time(struct wiphy *wiphy,
|
|
|
|
|
const struct cfg80211_chan_def *chandef);
|
2013-02-08 21:16:19 +04:00
|
|
|
|
2017-02-27 14:34:33 +03:00
|
|
|
void cfg80211_sched_dfs_chan_update(struct cfg80211_registered_device *rdev);
|
|
|
|
|
|
|
|
|
|
bool cfg80211_any_wiphy_oper_chan(struct wiphy *wiphy,
|
|
|
|
|
struct ieee80211_channel *chan);
|
|
|
|
|
|
|
|
|
|
bool cfg80211_beaconing_iface_active(struct wireless_dev *wdev);
|
|
|
|
|
|
|
|
|
|
bool cfg80211_is_sub_chan(struct cfg80211_chan_def *chandef,
|
|
|
|
|
struct ieee80211_channel *chan);
|
|
|
|
|
|
2013-02-08 21:16:19 +04:00
|
|
|
static inline unsigned int elapsed_jiffies_msecs(unsigned long start)
|
|
|
|
|
{
|
|
|
|
|
unsigned long end = jiffies;
|
|
|
|
|
|
|
|
|
|
if (end >= start)
|
|
|
|
|
return jiffies_to_msecs(end - start);
|
|
|
|
|
|
2014-06-17 14:07:02 +04:00
|
|
|
return jiffies_to_msecs(end + (ULONG_MAX - start) + 1);
|
2013-02-08 21:16:19 +04:00
|
|
|
}
|
|
|
|
|
|
2012-06-29 14:47:00 +04:00
|
|
|
void
|
2012-07-10 21:39:02 +04:00
|
|
|
cfg80211_get_chan_state(struct wireless_dev *wdev,
|
2012-06-29 14:47:00 +04:00
|
|
|
struct ieee80211_channel **chan,
|
2014-01-29 17:22:27 +04:00
|
|
|
enum cfg80211_chan_mode *chanmode,
|
|
|
|
|
u8 *radar_detect);
|
2012-06-29 14:47:00 +04:00
|
|
|
|
2012-06-06 10:18:22 +04:00
|
|
|
int cfg80211_set_monitor_channel(struct cfg80211_registered_device *rdev,
|
2012-11-09 00:25:48 +04:00
|
|
|
struct cfg80211_chan_def *chandef);
|
2009-08-07 19:22:35 +04:00
|
|
|
|
2011-07-18 20:08:35 +04:00
|
|
|
int ieee80211_get_ratemask(struct ieee80211_supported_band *sband,
|
|
|
|
|
const u8 *rates, unsigned int n_rates,
|
|
|
|
|
u32 *mask);
|
|
|
|
|
|
2011-05-09 20:41:15 +04:00
|
|
|
int cfg80211_validate_beacon_int(struct cfg80211_registered_device *rdev,
|
2016-10-12 15:56:51 +03:00
|
|
|
enum nl80211_iftype iftype, u32 beacon_int);
|
2011-05-09 20:41:15 +04:00
|
|
|
|
2012-06-29 14:47:01 +04:00
|
|
|
void cfg80211_update_iface_num(struct cfg80211_registered_device *rdev,
|
|
|
|
|
enum nl80211_iftype iftype, int num);
|
|
|
|
|
|
2014-04-09 17:11:01 +04:00
|
|
|
void __cfg80211_leave(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct wireless_dev *wdev);
|
2013-02-28 13:55:25 +04:00
|
|
|
void cfg80211_leave(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct wireless_dev *wdev);
|
|
|
|
|
|
2013-03-19 18:04:07 +04:00
|
|
|
void cfg80211_stop_p2p_device(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct wireless_dev *wdev);
|
|
|
|
|
|
2016-09-20 17:31:13 +03:00
|
|
|
void cfg80211_stop_nan(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct wireless_dev *wdev);
|
|
|
|
|
|
2019-05-01 15:55:24 +03:00
|
|
|
struct cfg80211_internal_bss *
|
|
|
|
|
cfg80211_bss_update(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct cfg80211_internal_bss *tmp,
|
|
|
|
|
bool signal_valid, unsigned long ts);
|
2009-08-21 14:23:49 +04:00
|
|
|
#ifdef CONFIG_CFG80211_DEVELOPER_WARNINGS
|
|
|
|
|
#define CFG80211_DEV_WARN_ON(cond) WARN_ON(cond)
|
|
|
|
|
#else
|
|
|
|
|
/*
|
|
|
|
|
* Trick to enable using it as a condition,
|
|
|
|
|
* and also not give a warning when it's
|
|
|
|
|
* not used that way.
|
|
|
|
|
*/
|
|
|
|
|
#define CFG80211_DEV_WARN_ON(cond) ({bool __r = (cond); __r; })
|
|
|
|
|
#endif
|
|
|
|
|
|
2017-02-10 12:02:31 +03:00
|
|
|
void cfg80211_cqm_config_free(struct wireless_dev *wdev);
|
|
|
|
|
|
cfg80211: add peer measurement with FTM initiator API
Add a new "peer measurement" API, that can be used to measure
certain things related to a peer. Right now, only implement
FTM (flight time measurement) over it, but the idea is that
it'll be extensible to also support measuring the necessary
things to calculate e.g. angle-of-arrival for WiGig.
The API is structured to have a generic list of peers and
channels to measure with/on, and then for each of those a
set of measurements (again, only FTM right now) to perform.
Results are sent to the requesting socket, including a final
complete message.
Closing the controlling netlink socket will abort a running
measurement.
v3:
- add a bit to report "final" for partial results
- remove list keeping etc. and just unicast out the results
to the requester (big code reduction ...)
- also send complete message unicast, and as a result
remove the multicast group
- separate out struct cfg80211_pmsr_ftm_request_peer
from struct cfg80211_pmsr_request_peer
- document timeout == 0 if no timeout
- disallow setting timeout nl80211 attribute to 0,
must not include attribute for no timeout
- make MAC address randomization optional
- change num bursts exponent default to 0 (1 burst, rather
rather than the old default of 15==don't care)
v4:
- clarify NL80211_ATTR_TIMEOUT documentation
v5:
- remove unnecessary nl80211 multicast/family changes
- remove partial results bit/flag, final is sufficient
- add max_bursts_exponent, max_ftms_per_burst to capability
- rename "frames per burst" -> "FTMs per burst"
v6:
- rename cfg80211_pmsr_free_wdev() to cfg80211_pmsr_wdev_down()
and call it in leave, so the device can't go down with any
pending measurements
v7:
- wording fixes (Lior)
- fix ftm.max_bursts_exponent to allow having the limit of 0 (Lior)
v8:
- copyright statements
- minor coding style fixes
- fix error path leak
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2018-09-10 14:29:12 +03:00
|
|
|
void cfg80211_release_pmsr(struct wireless_dev *wdev, u32 portid);
|
|
|
|
|
void cfg80211_pmsr_wdev_down(struct wireless_dev *wdev);
|
|
|
|
|
void cfg80211_pmsr_free_wk(struct work_struct *work);
|
|
|
|
|
|
2007-04-23 23:20:05 +04:00
|
|
|
#endif /* __NET_WIRELESS_CORE_H */
|
