2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2009-09-29 15:27:28 -06:00
|
|
|
* This file implement the Wireless Extensions core API.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* Authors : Jean Tourrilhes - HPL - <jt@hpl.hp.com>
|
2007-03-22 18:31:16 -06:00
|
|
|
* Copyright (c) 1997-2007 Jean Tourrilhes, All Rights Reserved.
|
2009-09-29 15:27:28 -06:00
|
|
|
* Copyright 2009 Johannes Berg <johannes@sipsolutions.net>
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* (As all part of the Linux kernel, this file is GPL)
|
|
|
|
*/
|
2009-09-29 15:27:28 -06:00
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/rtnetlink.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2009-09-29 15:27:28 -06:00
|
|
|
#include <linux/wireless.h>
|
|
|
|
#include <linux/uaccess.h>
|
2011-07-15 09:47:34 -06:00
|
|
|
#include <linux/export.h>
|
2009-09-29 15:27:28 -06:00
|
|
|
#include <net/cfg80211.h>
|
|
|
|
#include <net/iw_handler.h>
|
2006-08-15 01:36:49 -06:00
|
|
|
#include <net/netlink.h>
|
2007-04-26 21:43:56 -06:00
|
|
|
#include <net/wext.h>
|
2009-09-29 15:27:28 -06:00
|
|
|
#include <net/net_namespace.h>
|
|
|
|
|
|
|
|
typedef int (*wext_ioctl_func)(struct net_device *, struct iwreq *,
|
|
|
|
unsigned int, struct iw_request_info *,
|
|
|
|
iw_handler);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Meta-data about all the standard Wireless Extension request we
|
|
|
|
* know about.
|
|
|
|
*/
|
|
|
|
static const struct iw_ioctl_description standard_ioctl[] = {
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCSIWCOMMIT)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_NULL,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCGIWNAME)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_CHAR,
|
|
|
|
.flags = IW_DESCR_FLAG_DUMP,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCSIWNWID)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_PARAM,
|
|
|
|
.flags = IW_DESCR_FLAG_EVENT,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCGIWNWID)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_PARAM,
|
|
|
|
.flags = IW_DESCR_FLAG_DUMP,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCSIWFREQ)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_FREQ,
|
|
|
|
.flags = IW_DESCR_FLAG_EVENT,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCGIWFREQ)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_FREQ,
|
|
|
|
.flags = IW_DESCR_FLAG_DUMP,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCSIWMODE)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_UINT,
|
|
|
|
.flags = IW_DESCR_FLAG_EVENT,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCGIWMODE)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_UINT,
|
|
|
|
.flags = IW_DESCR_FLAG_DUMP,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCSIWSENS)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_PARAM,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCGIWSENS)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_PARAM,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCSIWRANGE)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_NULL,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCGIWRANGE)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_POINT,
|
|
|
|
.token_size = 1,
|
|
|
|
.max_tokens = sizeof(struct iw_range),
|
|
|
|
.flags = IW_DESCR_FLAG_DUMP,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCSIWPRIV)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_NULL,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCGIWPRIV)] = { /* (handled directly by us) */
|
2006-02-22 16:10:56 -07:00
|
|
|
.header_type = IW_HEADER_TYPE_POINT,
|
|
|
|
.token_size = sizeof(struct iw_priv_args),
|
|
|
|
.max_tokens = 16,
|
|
|
|
.flags = IW_DESCR_FLAG_NOMAX,
|
2005-04-16 16:20:36 -06:00
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCSIWSTATS)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_NULL,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCGIWSTATS)] = { /* (handled directly by us) */
|
2006-02-22 16:10:56 -07:00
|
|
|
.header_type = IW_HEADER_TYPE_POINT,
|
|
|
|
.token_size = 1,
|
|
|
|
.max_tokens = sizeof(struct iw_statistics),
|
2005-04-16 16:20:36 -06:00
|
|
|
.flags = IW_DESCR_FLAG_DUMP,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCSIWSPY)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_POINT,
|
|
|
|
.token_size = sizeof(struct sockaddr),
|
|
|
|
.max_tokens = IW_MAX_SPY,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCGIWSPY)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_POINT,
|
|
|
|
.token_size = sizeof(struct sockaddr) +
|
|
|
|
sizeof(struct iw_quality),
|
|
|
|
.max_tokens = IW_MAX_SPY,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCSIWTHRSPY)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_POINT,
|
|
|
|
.token_size = sizeof(struct iw_thrspy),
|
|
|
|
.min_tokens = 1,
|
|
|
|
.max_tokens = 1,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCGIWTHRSPY)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_POINT,
|
|
|
|
.token_size = sizeof(struct iw_thrspy),
|
|
|
|
.min_tokens = 1,
|
|
|
|
.max_tokens = 1,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCSIWAP)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_ADDR,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCGIWAP)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_ADDR,
|
|
|
|
.flags = IW_DESCR_FLAG_DUMP,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCSIWMLME)] = {
|
2005-05-12 18:24:19 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_POINT,
|
|
|
|
.token_size = 1,
|
|
|
|
.min_tokens = sizeof(struct iw_mlme),
|
|
|
|
.max_tokens = sizeof(struct iw_mlme),
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCGIWAPLIST)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_POINT,
|
|
|
|
.token_size = sizeof(struct sockaddr) +
|
|
|
|
sizeof(struct iw_quality),
|
|
|
|
.max_tokens = IW_MAX_AP,
|
|
|
|
.flags = IW_DESCR_FLAG_NOMAX,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCSIWSCAN)] = {
|
2005-05-12 18:24:19 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_POINT,
|
|
|
|
.token_size = 1,
|
|
|
|
.min_tokens = 0,
|
|
|
|
.max_tokens = sizeof(struct iw_scan_req),
|
2005-04-16 16:20:36 -06:00
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCGIWSCAN)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_POINT,
|
|
|
|
.token_size = 1,
|
|
|
|
.max_tokens = IW_SCAN_MAX_DATA,
|
|
|
|
.flags = IW_DESCR_FLAG_NOMAX,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCSIWESSID)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_POINT,
|
|
|
|
.token_size = 1,
|
2006-09-08 14:04:05 -06:00
|
|
|
.max_tokens = IW_ESSID_MAX_SIZE,
|
2005-04-16 16:20:36 -06:00
|
|
|
.flags = IW_DESCR_FLAG_EVENT,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCGIWESSID)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_POINT,
|
|
|
|
.token_size = 1,
|
2006-09-08 14:04:05 -06:00
|
|
|
.max_tokens = IW_ESSID_MAX_SIZE,
|
2005-04-16 16:20:36 -06:00
|
|
|
.flags = IW_DESCR_FLAG_DUMP,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCSIWNICKN)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_POINT,
|
|
|
|
.token_size = 1,
|
2006-09-08 14:04:05 -06:00
|
|
|
.max_tokens = IW_ESSID_MAX_SIZE,
|
2005-04-16 16:20:36 -06:00
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCGIWNICKN)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_POINT,
|
|
|
|
.token_size = 1,
|
2006-09-08 14:04:05 -06:00
|
|
|
.max_tokens = IW_ESSID_MAX_SIZE,
|
2005-04-16 16:20:36 -06:00
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCSIWRATE)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_PARAM,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCGIWRATE)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_PARAM,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCSIWRTS)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_PARAM,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCGIWRTS)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_PARAM,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCSIWFRAG)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_PARAM,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCGIWFRAG)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_PARAM,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCSIWTXPOW)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_PARAM,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCGIWTXPOW)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_PARAM,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCSIWRETRY)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_PARAM,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCGIWRETRY)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_PARAM,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCSIWENCODE)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_POINT,
|
|
|
|
.token_size = 1,
|
|
|
|
.max_tokens = IW_ENCODING_TOKEN_MAX,
|
|
|
|
.flags = IW_DESCR_FLAG_EVENT | IW_DESCR_FLAG_RESTRICT,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCGIWENCODE)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_POINT,
|
|
|
|
.token_size = 1,
|
|
|
|
.max_tokens = IW_ENCODING_TOKEN_MAX,
|
|
|
|
.flags = IW_DESCR_FLAG_DUMP | IW_DESCR_FLAG_RESTRICT,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCSIWPOWER)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_PARAM,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCGIWPOWER)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_PARAM,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCSIWGENIE)] = {
|
2005-05-12 18:24:19 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_POINT,
|
|
|
|
.token_size = 1,
|
|
|
|
.max_tokens = IW_GENERIC_IE_MAX,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCGIWGENIE)] = {
|
2005-05-12 18:24:19 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_POINT,
|
|
|
|
.token_size = 1,
|
|
|
|
.max_tokens = IW_GENERIC_IE_MAX,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCSIWAUTH)] = {
|
2005-05-12 18:24:19 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_PARAM,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCGIWAUTH)] = {
|
2005-05-12 18:24:19 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_PARAM,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCSIWENCODEEXT)] = {
|
2005-05-12 18:24:19 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_POINT,
|
|
|
|
.token_size = 1,
|
|
|
|
.min_tokens = sizeof(struct iw_encode_ext),
|
|
|
|
.max_tokens = sizeof(struct iw_encode_ext) +
|
|
|
|
IW_ENCODING_TOKEN_MAX,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCGIWENCODEEXT)] = {
|
2005-05-12 18:24:19 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_POINT,
|
|
|
|
.token_size = 1,
|
|
|
|
.min_tokens = sizeof(struct iw_encode_ext),
|
|
|
|
.max_tokens = sizeof(struct iw_encode_ext) +
|
|
|
|
IW_ENCODING_TOKEN_MAX,
|
|
|
|
},
|
2010-03-18 19:29:35 -06:00
|
|
|
[IW_IOCTL_IDX(SIOCSIWPMKSA)] = {
|
2005-05-12 18:24:19 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_POINT,
|
|
|
|
.token_size = 1,
|
|
|
|
.min_tokens = sizeof(struct iw_pmksa),
|
|
|
|
.max_tokens = sizeof(struct iw_pmksa),
|
|
|
|
},
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
2012-04-14 23:58:06 -06:00
|
|
|
static const unsigned int standard_ioctl_num = ARRAY_SIZE(standard_ioctl);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Meta-data about all the additional standard Wireless Extension events
|
|
|
|
* we know about.
|
|
|
|
*/
|
|
|
|
static const struct iw_ioctl_description standard_event[] = {
|
2010-03-18 19:29:36 -06:00
|
|
|
[IW_EVENT_IDX(IWEVTXDROP)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_ADDR,
|
|
|
|
},
|
2010-03-18 19:29:36 -06:00
|
|
|
[IW_EVENT_IDX(IWEVQUAL)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_QUAL,
|
|
|
|
},
|
2010-03-18 19:29:36 -06:00
|
|
|
[IW_EVENT_IDX(IWEVCUSTOM)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_POINT,
|
|
|
|
.token_size = 1,
|
|
|
|
.max_tokens = IW_CUSTOM_MAX,
|
|
|
|
},
|
2010-03-18 19:29:36 -06:00
|
|
|
[IW_EVENT_IDX(IWEVREGISTERED)] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_ADDR,
|
|
|
|
},
|
2010-03-18 19:29:36 -06:00
|
|
|
[IW_EVENT_IDX(IWEVEXPIRED)] = {
|
2007-02-09 07:24:36 -07:00
|
|
|
.header_type = IW_HEADER_TYPE_ADDR,
|
2005-04-16 16:20:36 -06:00
|
|
|
},
|
2010-03-18 19:29:36 -06:00
|
|
|
[IW_EVENT_IDX(IWEVGENIE)] = {
|
2005-05-12 18:24:19 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_POINT,
|
|
|
|
.token_size = 1,
|
|
|
|
.max_tokens = IW_GENERIC_IE_MAX,
|
|
|
|
},
|
2010-03-18 19:29:36 -06:00
|
|
|
[IW_EVENT_IDX(IWEVMICHAELMICFAILURE)] = {
|
2007-02-09 07:24:36 -07:00
|
|
|
.header_type = IW_HEADER_TYPE_POINT,
|
2005-05-12 18:24:19 -06:00
|
|
|
.token_size = 1,
|
|
|
|
.max_tokens = sizeof(struct iw_michaelmicfailure),
|
|
|
|
},
|
2010-03-18 19:29:36 -06:00
|
|
|
[IW_EVENT_IDX(IWEVASSOCREQIE)] = {
|
2005-05-12 18:24:19 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_POINT,
|
|
|
|
.token_size = 1,
|
|
|
|
.max_tokens = IW_GENERIC_IE_MAX,
|
|
|
|
},
|
2010-03-18 19:29:36 -06:00
|
|
|
[IW_EVENT_IDX(IWEVASSOCRESPIE)] = {
|
2005-05-12 18:24:19 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_POINT,
|
|
|
|
.token_size = 1,
|
|
|
|
.max_tokens = IW_GENERIC_IE_MAX,
|
|
|
|
},
|
2010-03-18 19:29:36 -06:00
|
|
|
[IW_EVENT_IDX(IWEVPMKIDCAND)] = {
|
2005-05-12 18:24:19 -06:00
|
|
|
.header_type = IW_HEADER_TYPE_POINT,
|
|
|
|
.token_size = 1,
|
|
|
|
.max_tokens = sizeof(struct iw_pmkid_cand),
|
|
|
|
},
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
2012-04-14 23:58:06 -06:00
|
|
|
static const unsigned int standard_event_num = ARRAY_SIZE(standard_event);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Size (in bytes) of various events */
|
|
|
|
static const int event_type_size[] = {
|
|
|
|
IW_EV_LCP_LEN, /* IW_HEADER_TYPE_NULL */
|
|
|
|
0,
|
|
|
|
IW_EV_CHAR_LEN, /* IW_HEADER_TYPE_CHAR */
|
|
|
|
0,
|
|
|
|
IW_EV_UINT_LEN, /* IW_HEADER_TYPE_UINT */
|
|
|
|
IW_EV_FREQ_LEN, /* IW_HEADER_TYPE_FREQ */
|
|
|
|
IW_EV_ADDR_LEN, /* IW_HEADER_TYPE_ADDR */
|
|
|
|
0,
|
|
|
|
IW_EV_POINT_LEN, /* Without variable payload */
|
|
|
|
IW_EV_PARAM_LEN, /* IW_HEADER_TYPE_PARAM */
|
|
|
|
IW_EV_QUAL_LEN, /* IW_HEADER_TYPE_QUAL */
|
|
|
|
};
|
|
|
|
|
net/compat/wext: send different messages to compat tasks
Wireless extensions have the unfortunate problem that events
are multicast netlink messages, and are not independent of
pointer size. Thus, currently 32-bit tasks on 64-bit platforms
cannot properly receive events and fail with all kinds of
strange problems, for instance wpa_supplicant never notices
disassociations, due to the way the 64-bit event looks (to a
32-bit process), the fact that the address is all zeroes is
lost, it thinks instead it is 00:00:00:00:01:00.
The same problem existed with the ioctls, until David Miller
fixed those some time ago in an heroic effort.
A different problem caused by this is that we cannot send the
ASSOCREQIE/ASSOCRESPIE events because sending them causes a
32-bit wpa_supplicant on a 64-bit system to overwrite its
internal information, which is worse than it not getting the
information at all -- so we currently resort to sending a
custom string event that it then parses. This, however, has a
severe size limitation we are frequently hitting with modern
access points; this limitation would can be lifted after this
patch by sending the correct binary, not custom, event.
A similar problem apparently happens for some other netlink
users on x86_64 with 32-bit tasks due to the alignment for
64-bit quantities.
In order to fix these problems, I have implemented a way to
send compat messages to tasks. When sending an event, we send
the non-compat event data together with a compat event data in
skb_shinfo(main_skb)->frag_list. Then, when the event is read
from the socket, the netlink code makes sure to pass out only
the skb that is compatible with the task. This approach was
suggested by David Miller, my original approach required
always sending two skbs but that had various small problems.
To determine whether compat is needed or not, I have used the
MSG_CMSG_COMPAT flag, and adjusted the call path for recv and
recvfrom to include it, even if those calls do not have a cmsg
parameter.
I have not solved one small part of the problem, and I don't
think it is necessary to: if a 32-bit application uses read()
rather than any form of recvmsg() it will still get the wrong
(64-bit) event. However, neither do applications actually do
this, nor would it be a regression.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2009-07-01 05:26:02 -06:00
|
|
|
#ifdef CONFIG_COMPAT
|
|
|
|
static const int compat_event_type_size[] = {
|
|
|
|
IW_EV_COMPAT_LCP_LEN, /* IW_HEADER_TYPE_NULL */
|
|
|
|
0,
|
|
|
|
IW_EV_COMPAT_CHAR_LEN, /* IW_HEADER_TYPE_CHAR */
|
|
|
|
0,
|
|
|
|
IW_EV_COMPAT_UINT_LEN, /* IW_HEADER_TYPE_UINT */
|
|
|
|
IW_EV_COMPAT_FREQ_LEN, /* IW_HEADER_TYPE_FREQ */
|
|
|
|
IW_EV_COMPAT_ADDR_LEN, /* IW_HEADER_TYPE_ADDR */
|
|
|
|
0,
|
|
|
|
IW_EV_COMPAT_POINT_LEN, /* Without variable payload */
|
|
|
|
IW_EV_COMPAT_PARAM_LEN, /* IW_HEADER_TYPE_PARAM */
|
|
|
|
IW_EV_COMPAT_QUAL_LEN, /* IW_HEADER_TYPE_QUAL */
|
|
|
|
};
|
|
|
|
#endif
|
2007-03-22 18:31:16 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-09-29 15:27:28 -06:00
|
|
|
/* IW event code */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2016-01-27 05:29:34 -07:00
|
|
|
void wireless_nlevent_flush(void)
|
wext: fix message delay/ordering
Beniamino reported that he was getting an RTM_NEWLINK message for a
given interface, after the RTM_DELLINK for it. It turns out that the
message is a wireless extensions message, which was sent because the
interface had been connected and disconnection while it was deleted
caused a wext message.
For its netlink messages, wext uses RTM_NEWLINK, but the message is
without all the regular rtnetlink attributes, so "ip monitor link"
prints just rudimentary information:
5: wlan1: <BROADCAST,MULTICAST> mtu 1500 qdisc mq state DOWN group default
link/ether 02:00:00:00:01:00 brd ff:ff:ff:ff:ff:ff
Deleted 5: wlan1: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN group default
link/ether 02:00:00:00:01:00 brd ff:ff:ff:ff:ff:ff
5: wlan1: <BROADCAST,MULTICAST,UP>
link/ether
(from my hwsim reproduction)
This can cause userspace to get confused since it doesn't expect an
RTM_NEWLINK message after RTM_DELLINK.
The reason for this is that wext schedules a worker to send out the
messages, and the scheduling delay can cause the messages to get out
to userspace in different order.
To fix this, have wext register a netdevice notifier and flush out
any pending messages when netdevice state changes. This fixes any
ordering whenever the original message wasn't sent by a notifier
itself.
Cc: stable@vger.kernel.org
Reported-by: Beniamino Galvani <bgalvani@redhat.com>
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2016-01-27 04:37:52 -07:00
|
|
|
{
|
|
|
|
struct sk_buff *skb;
|
|
|
|
struct net *net;
|
|
|
|
|
net: Introduce net_rwsem to protect net_namespace_list
rtnl_lock() is used everywhere, and contention is very high.
When someone wants to iterate over alive net namespaces,
he/she has no a possibility to do that without exclusive lock.
But the exclusive rtnl_lock() in such places is overkill,
and it just increases the contention. Yes, there is already
for_each_net_rcu() in kernel, but it requires rcu_read_lock(),
and this can't be sleepable. Also, sometimes it may be need
really prevent net_namespace_list growth, so for_each_net_rcu()
is not fit there.
This patch introduces new rw_semaphore, which will be used
instead of rtnl_mutex to protect net_namespace_list. It is
sleepable and allows not-exclusive iterations over net
namespaces list. It allows to stop using rtnl_lock()
in several places (what is made in next patches) and makes
less the time, we keep rtnl_mutex. Here we just add new lock,
while the explanation of we can remove rtnl_lock() there are
in next patches.
Fine grained locks generally are better, then one big lock,
so let's do that with net_namespace_list, while the situation
allows that.
Signed-off-by: Kirill Tkhai <ktkhai@virtuozzo.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2018-03-29 10:20:32 -06:00
|
|
|
down_read(&net_rwsem);
|
wext: fix message delay/ordering
Beniamino reported that he was getting an RTM_NEWLINK message for a
given interface, after the RTM_DELLINK for it. It turns out that the
message is a wireless extensions message, which was sent because the
interface had been connected and disconnection while it was deleted
caused a wext message.
For its netlink messages, wext uses RTM_NEWLINK, but the message is
without all the regular rtnetlink attributes, so "ip monitor link"
prints just rudimentary information:
5: wlan1: <BROADCAST,MULTICAST> mtu 1500 qdisc mq state DOWN group default
link/ether 02:00:00:00:01:00 brd ff:ff:ff:ff:ff:ff
Deleted 5: wlan1: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN group default
link/ether 02:00:00:00:01:00 brd ff:ff:ff:ff:ff:ff
5: wlan1: <BROADCAST,MULTICAST,UP>
link/ether
(from my hwsim reproduction)
This can cause userspace to get confused since it doesn't expect an
RTM_NEWLINK message after RTM_DELLINK.
The reason for this is that wext schedules a worker to send out the
messages, and the scheduling delay can cause the messages to get out
to userspace in different order.
To fix this, have wext register a netdevice notifier and flush out
any pending messages when netdevice state changes. This fixes any
ordering whenever the original message wasn't sent by a notifier
itself.
Cc: stable@vger.kernel.org
Reported-by: Beniamino Galvani <bgalvani@redhat.com>
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2016-01-27 04:37:52 -07:00
|
|
|
for_each_net(net) {
|
|
|
|
while ((skb = skb_dequeue(&net->wext_nlevents)))
|
|
|
|
rtnl_notify(skb, net, 0, RTNLGRP_LINK, NULL,
|
|
|
|
GFP_KERNEL);
|
|
|
|
}
|
net: Introduce net_rwsem to protect net_namespace_list
rtnl_lock() is used everywhere, and contention is very high.
When someone wants to iterate over alive net namespaces,
he/she has no a possibility to do that without exclusive lock.
But the exclusive rtnl_lock() in such places is overkill,
and it just increases the contention. Yes, there is already
for_each_net_rcu() in kernel, but it requires rcu_read_lock(),
and this can't be sleepable. Also, sometimes it may be need
really prevent net_namespace_list growth, so for_each_net_rcu()
is not fit there.
This patch introduces new rw_semaphore, which will be used
instead of rtnl_mutex to protect net_namespace_list. It is
sleepable and allows not-exclusive iterations over net
namespaces list. It allows to stop using rtnl_lock()
in several places (what is made in next patches) and makes
less the time, we keep rtnl_mutex. Here we just add new lock,
while the explanation of we can remove rtnl_lock() there are
in next patches.
Fine grained locks generally are better, then one big lock,
so let's do that with net_namespace_list, while the situation
allows that.
Signed-off-by: Kirill Tkhai <ktkhai@virtuozzo.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2018-03-29 10:20:32 -06:00
|
|
|
up_read(&net_rwsem);
|
wext: fix message delay/ordering
Beniamino reported that he was getting an RTM_NEWLINK message for a
given interface, after the RTM_DELLINK for it. It turns out that the
message is a wireless extensions message, which was sent because the
interface had been connected and disconnection while it was deleted
caused a wext message.
For its netlink messages, wext uses RTM_NEWLINK, but the message is
without all the regular rtnetlink attributes, so "ip monitor link"
prints just rudimentary information:
5: wlan1: <BROADCAST,MULTICAST> mtu 1500 qdisc mq state DOWN group default
link/ether 02:00:00:00:01:00 brd ff:ff:ff:ff:ff:ff
Deleted 5: wlan1: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN group default
link/ether 02:00:00:00:01:00 brd ff:ff:ff:ff:ff:ff
5: wlan1: <BROADCAST,MULTICAST,UP>
link/ether
(from my hwsim reproduction)
This can cause userspace to get confused since it doesn't expect an
RTM_NEWLINK message after RTM_DELLINK.
The reason for this is that wext schedules a worker to send out the
messages, and the scheduling delay can cause the messages to get out
to userspace in different order.
To fix this, have wext register a netdevice notifier and flush out
any pending messages when netdevice state changes. This fixes any
ordering whenever the original message wasn't sent by a notifier
itself.
Cc: stable@vger.kernel.org
Reported-by: Beniamino Galvani <bgalvani@redhat.com>
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2016-01-27 04:37:52 -07:00
|
|
|
}
|
2016-01-27 05:29:34 -07:00
|
|
|
EXPORT_SYMBOL_GPL(wireless_nlevent_flush);
|
wext: fix message delay/ordering
Beniamino reported that he was getting an RTM_NEWLINK message for a
given interface, after the RTM_DELLINK for it. It turns out that the
message is a wireless extensions message, which was sent because the
interface had been connected and disconnection while it was deleted
caused a wext message.
For its netlink messages, wext uses RTM_NEWLINK, but the message is
without all the regular rtnetlink attributes, so "ip monitor link"
prints just rudimentary information:
5: wlan1: <BROADCAST,MULTICAST> mtu 1500 qdisc mq state DOWN group default
link/ether 02:00:00:00:01:00 brd ff:ff:ff:ff:ff:ff
Deleted 5: wlan1: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN group default
link/ether 02:00:00:00:01:00 brd ff:ff:ff:ff:ff:ff
5: wlan1: <BROADCAST,MULTICAST,UP>
link/ether
(from my hwsim reproduction)
This can cause userspace to get confused since it doesn't expect an
RTM_NEWLINK message after RTM_DELLINK.
The reason for this is that wext schedules a worker to send out the
messages, and the scheduling delay can cause the messages to get out
to userspace in different order.
To fix this, have wext register a netdevice notifier and flush out
any pending messages when netdevice state changes. This fixes any
ordering whenever the original message wasn't sent by a notifier
itself.
Cc: stable@vger.kernel.org
Reported-by: Beniamino Galvani <bgalvani@redhat.com>
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2016-01-27 04:37:52 -07:00
|
|
|
|
|
|
|
static int wext_netdev_notifier_call(struct notifier_block *nb,
|
|
|
|
unsigned long state, void *ptr)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* When a netdev changes state in any way, flush all pending messages
|
|
|
|
* to avoid them going out in a strange order, e.g. RTM_NEWLINK after
|
|
|
|
* RTM_DELLINK, or with IFF_UP after without IFF_UP during dev_close()
|
|
|
|
* or similar - all of which could otherwise happen due to delays from
|
|
|
|
* schedule_work().
|
|
|
|
*/
|
|
|
|
wireless_nlevent_flush();
|
|
|
|
|
|
|
|
return NOTIFY_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct notifier_block wext_netdev_notifier = {
|
|
|
|
.notifier_call = wext_netdev_notifier_call,
|
|
|
|
};
|
|
|
|
|
2009-09-29 15:27:28 -06:00
|
|
|
static int __net_init wext_pernet_init(struct net *net)
|
2006-02-22 16:10:56 -07:00
|
|
|
{
|
2009-09-29 15:27:28 -06:00
|
|
|
skb_queue_head_init(&net->wext_nlevents);
|
|
|
|
return 0;
|
2006-02-22 16:10:56 -07:00
|
|
|
}
|
|
|
|
|
2009-09-29 15:27:28 -06:00
|
|
|
static void __net_exit wext_pernet_exit(struct net *net)
|
2006-02-22 16:10:56 -07:00
|
|
|
{
|
2009-09-29 15:27:28 -06:00
|
|
|
skb_queue_purge(&net->wext_nlevents);
|
2006-02-22 16:10:56 -07:00
|
|
|
}
|
|
|
|
|
2009-09-29 15:27:28 -06:00
|
|
|
static struct pernet_operations wext_pernet_ops = {
|
|
|
|
.init = wext_pernet_init,
|
|
|
|
.exit = wext_pernet_exit,
|
|
|
|
};
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-09-29 15:27:28 -06:00
|
|
|
static int __init wireless_nlevent_init(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
wext: fix message delay/ordering
Beniamino reported that he was getting an RTM_NEWLINK message for a
given interface, after the RTM_DELLINK for it. It turns out that the
message is a wireless extensions message, which was sent because the
interface had been connected and disconnection while it was deleted
caused a wext message.
For its netlink messages, wext uses RTM_NEWLINK, but the message is
without all the regular rtnetlink attributes, so "ip monitor link"
prints just rudimentary information:
5: wlan1: <BROADCAST,MULTICAST> mtu 1500 qdisc mq state DOWN group default
link/ether 02:00:00:00:01:00 brd ff:ff:ff:ff:ff:ff
Deleted 5: wlan1: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN group default
link/ether 02:00:00:00:01:00 brd ff:ff:ff:ff:ff:ff
5: wlan1: <BROADCAST,MULTICAST,UP>
link/ether
(from my hwsim reproduction)
This can cause userspace to get confused since it doesn't expect an
RTM_NEWLINK message after RTM_DELLINK.
The reason for this is that wext schedules a worker to send out the
messages, and the scheduling delay can cause the messages to get out
to userspace in different order.
To fix this, have wext register a netdevice notifier and flush out
any pending messages when netdevice state changes. This fixes any
ordering whenever the original message wasn't sent by a notifier
itself.
Cc: stable@vger.kernel.org
Reported-by: Beniamino Galvani <bgalvani@redhat.com>
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2016-01-27 04:37:52 -07:00
|
|
|
int err = register_pernet_subsys(&wext_pernet_ops);
|
|
|
|
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
2016-03-16 07:29:08 -06:00
|
|
|
err = register_netdevice_notifier(&wext_netdev_notifier);
|
|
|
|
if (err)
|
|
|
|
unregister_pernet_subsys(&wext_pernet_ops);
|
|
|
|
return err;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2009-09-29 15:27:28 -06:00
|
|
|
subsys_initcall(wireless_nlevent_init);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-09-29 15:27:28 -06:00
|
|
|
/* Process events generated by the wireless layer or the driver. */
|
|
|
|
static void wireless_nlevent_process(struct work_struct *work)
|
2009-05-11 08:06:36 -06:00
|
|
|
{
|
wext: fix message delay/ordering
Beniamino reported that he was getting an RTM_NEWLINK message for a
given interface, after the RTM_DELLINK for it. It turns out that the
message is a wireless extensions message, which was sent because the
interface had been connected and disconnection while it was deleted
caused a wext message.
For its netlink messages, wext uses RTM_NEWLINK, but the message is
without all the regular rtnetlink attributes, so "ip monitor link"
prints just rudimentary information:
5: wlan1: <BROADCAST,MULTICAST> mtu 1500 qdisc mq state DOWN group default
link/ether 02:00:00:00:01:00 brd ff:ff:ff:ff:ff:ff
Deleted 5: wlan1: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN group default
link/ether 02:00:00:00:01:00 brd ff:ff:ff:ff:ff:ff
5: wlan1: <BROADCAST,MULTICAST,UP>
link/ether
(from my hwsim reproduction)
This can cause userspace to get confused since it doesn't expect an
RTM_NEWLINK message after RTM_DELLINK.
The reason for this is that wext schedules a worker to send out the
messages, and the scheduling delay can cause the messages to get out
to userspace in different order.
To fix this, have wext register a netdevice notifier and flush out
any pending messages when netdevice state changes. This fixes any
ordering whenever the original message wasn't sent by a notifier
itself.
Cc: stable@vger.kernel.org
Reported-by: Beniamino Galvani <bgalvani@redhat.com>
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2016-01-27 04:37:52 -07:00
|
|
|
wireless_nlevent_flush();
|
2009-05-11 08:06:36 -06:00
|
|
|
}
|
|
|
|
|
2009-09-29 15:27:28 -06:00
|
|
|
static DECLARE_WORK(wireless_nlevent_work, wireless_nlevent_process);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-09-29 15:27:28 -06:00
|
|
|
static struct nlmsghdr *rtnetlink_ifinfo_prep(struct net_device *dev,
|
|
|
|
struct sk_buff *skb)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2009-09-29 15:27:28 -06:00
|
|
|
struct ifinfomsg *r;
|
|
|
|
struct nlmsghdr *nlh;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-09-29 15:27:28 -06:00
|
|
|
nlh = nlmsg_put(skb, 0, 0, RTM_NEWLINK, sizeof(*r), 0);
|
|
|
|
if (!nlh)
|
|
|
|
return NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-09-29 15:27:28 -06:00
|
|
|
r = nlmsg_data(nlh);
|
|
|
|
r->ifi_family = AF_UNSPEC;
|
|
|
|
r->__ifi_pad = 0;
|
|
|
|
r->ifi_type = dev->type;
|
|
|
|
r->ifi_index = dev->ifindex;
|
|
|
|
r->ifi_flags = dev_get_flags(dev);
|
|
|
|
r->ifi_change = 0; /* Wireless changes don't affect those flags */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-03-29 02:41:26 -06:00
|
|
|
if (nla_put_string(skb, IFLA_IFNAME, dev->name))
|
|
|
|
goto nla_put_failure;
|
2007-09-17 12:56:21 -06:00
|
|
|
|
2009-09-29 15:27:28 -06:00
|
|
|
return nlh;
|
|
|
|
nla_put_failure:
|
|
|
|
nlmsg_cancel(skb, nlh);
|
|
|
|
return NULL;
|
2007-09-17 12:56:21 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-09-29 15:27:28 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2009-09-29 15:27:28 -06:00
|
|
|
* Main event dispatcher. Called from other parts and drivers.
|
|
|
|
* Send the event on the appropriate channels.
|
|
|
|
* May be called from interrupt context.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2009-09-29 15:27:28 -06:00
|
|
|
void wireless_send_event(struct net_device * dev,
|
|
|
|
unsigned int cmd,
|
|
|
|
union iwreq_data * wrqu,
|
|
|
|
const char * extra)
|
2007-12-21 04:27:17 -07:00
|
|
|
{
|
2009-09-29 15:27:28 -06:00
|
|
|
const struct iw_ioctl_description * descr = NULL;
|
|
|
|
int extra_len = 0;
|
|
|
|
struct iw_event *event; /* Mallocated whole event */
|
|
|
|
int event_len; /* Its size */
|
|
|
|
int hdr_len; /* Size of the event header */
|
|
|
|
int wrqu_off = 0; /* Offset in wrqu */
|
|
|
|
/* Don't "optimise" the following variable, it will crash */
|
2012-04-14 23:58:06 -06:00
|
|
|
unsigned int cmd_index; /* *MUST* be unsigned */
|
2009-09-29 15:27:28 -06:00
|
|
|
struct sk_buff *skb;
|
|
|
|
struct nlmsghdr *nlh;
|
|
|
|
struct nlattr *nla;
|
|
|
|
#ifdef CONFIG_COMPAT
|
|
|
|
struct __compat_iw_event *compat_event;
|
|
|
|
struct compat_iw_point compat_wrqu;
|
|
|
|
struct sk_buff *compskb;
|
|
|
|
#endif
|
2007-12-21 04:27:17 -07:00
|
|
|
|
2009-09-29 15:27:28 -06:00
|
|
|
/*
|
|
|
|
* Nothing in the kernel sends scan events with data, be safe.
|
|
|
|
* This is necessary because we cannot fix up scan event data
|
|
|
|
* for compat, due to being contained in 'extra', but normally
|
|
|
|
* applications are required to retrieve the scan data anyway
|
|
|
|
* and no data is included in the event, this codifies that
|
|
|
|
* practice.
|
2007-12-21 04:27:17 -07:00
|
|
|
*/
|
2009-09-29 15:27:28 -06:00
|
|
|
if (WARN_ON(cmd == SIOCGIWSCAN && extra))
|
|
|
|
extra = NULL;
|
2007-12-21 04:27:17 -07:00
|
|
|
|
2009-09-29 15:27:28 -06:00
|
|
|
/* Get the description of the Event */
|
|
|
|
if (cmd <= SIOCIWLAST) {
|
2010-03-18 19:29:35 -06:00
|
|
|
cmd_index = IW_IOCTL_IDX(cmd);
|
2009-09-29 15:27:28 -06:00
|
|
|
if (cmd_index < standard_ioctl_num)
|
|
|
|
descr = &(standard_ioctl[cmd_index]);
|
|
|
|
} else {
|
2010-03-18 19:29:36 -06:00
|
|
|
cmd_index = IW_EVENT_IDX(cmd);
|
2009-09-29 15:27:28 -06:00
|
|
|
if (cmd_index < standard_event_num)
|
|
|
|
descr = &(standard_event[cmd_index]);
|
|
|
|
}
|
|
|
|
/* Don't accept unknown events */
|
|
|
|
if (descr == NULL) {
|
|
|
|
/* Note : we don't return an error to the driver, because
|
|
|
|
* the driver would not know what to do about it. It can't
|
|
|
|
* return an error to the user, because the event is not
|
|
|
|
* initiated by a user request.
|
|
|
|
* The best the driver could do is to log an error message.
|
|
|
|
* We will do it ourselves instead...
|
|
|
|
*/
|
2010-11-16 20:56:49 -07:00
|
|
|
netdev_err(dev, "(WE) : Invalid/Unknown Wireless Event (0x%04X)\n",
|
|
|
|
cmd);
|
2009-09-29 15:27:28 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check extra parameters and set extra_len */
|
|
|
|
if (descr->header_type == IW_HEADER_TYPE_POINT) {
|
|
|
|
/* Check if number of token fits within bounds */
|
|
|
|
if (wrqu->data.length > descr->max_tokens) {
|
2012-08-24 06:43:31 -06:00
|
|
|
netdev_err(dev, "(WE) : Wireless Event (cmd=0x%04X) too big (%d)\n",
|
|
|
|
cmd, wrqu->data.length);
|
2009-09-29 15:27:28 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (wrqu->data.length < descr->min_tokens) {
|
2012-08-24 06:43:31 -06:00
|
|
|
netdev_err(dev, "(WE) : Wireless Event (cmd=0x%04X) too small (%d)\n",
|
|
|
|
cmd, wrqu->data.length);
|
2009-09-29 15:27:28 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* Calculate extra_len - extra is NULL for restricted events */
|
|
|
|
if (extra != NULL)
|
|
|
|
extra_len = wrqu->data.length * descr->token_size;
|
|
|
|
/* Always at an offset in wrqu */
|
|
|
|
wrqu_off = IW_EV_POINT_OFF;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Total length of the event */
|
|
|
|
hdr_len = event_type_size[descr->header_type];
|
|
|
|
event_len = hdr_len + extra_len;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The problem for 64/32 bit.
|
|
|
|
*
|
|
|
|
* On 64-bit, a regular event is laid out as follows:
|
|
|
|
* | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
|
|
|
|
* | event.len | event.cmd | p a d d i n g |
|
|
|
|
* | wrqu data ... (with the correct size) |
|
|
|
|
*
|
|
|
|
* This padding exists because we manipulate event->u,
|
|
|
|
* and 'event' is not packed.
|
|
|
|
*
|
|
|
|
* An iw_point event is laid out like this instead:
|
|
|
|
* | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
|
|
|
|
* | event.len | event.cmd | p a d d i n g |
|
|
|
|
* | iwpnt.len | iwpnt.flg | p a d d i n g |
|
|
|
|
* | extra data ...
|
|
|
|
*
|
|
|
|
* The second padding exists because struct iw_point is extended,
|
|
|
|
* but this depends on the platform...
|
|
|
|
*
|
|
|
|
* On 32-bit, all the padding shouldn't be there.
|
|
|
|
*/
|
|
|
|
|
|
|
|
skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
|
|
|
|
if (!skb)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Send via the RtNetlink event channel */
|
|
|
|
nlh = rtnetlink_ifinfo_prep(dev, skb);
|
|
|
|
if (WARN_ON(!nlh)) {
|
|
|
|
kfree_skb(skb);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Add the wireless events in the netlink packet */
|
|
|
|
nla = nla_reserve(skb, IFLA_WIRELESS, event_len);
|
|
|
|
if (!nla) {
|
|
|
|
kfree_skb(skb);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
event = nla_data(nla);
|
|
|
|
|
|
|
|
/* Fill event - first clear to avoid data leaking */
|
|
|
|
memset(event, 0, hdr_len);
|
|
|
|
event->len = event_len;
|
|
|
|
event->cmd = cmd;
|
|
|
|
memcpy(&event->u, ((char *) wrqu) + wrqu_off, hdr_len - IW_EV_LCP_LEN);
|
|
|
|
if (extra_len)
|
|
|
|
memcpy(((char *) event) + hdr_len, extra, extra_len);
|
|
|
|
|
|
|
|
nlmsg_end(skb, nlh);
|
|
|
|
#ifdef CONFIG_COMPAT
|
|
|
|
hdr_len = compat_event_type_size[descr->header_type];
|
|
|
|
event_len = hdr_len + extra_len;
|
|
|
|
|
|
|
|
compskb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
|
|
|
|
if (!compskb) {
|
|
|
|
kfree_skb(skb);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Send via the RtNetlink event channel */
|
|
|
|
nlh = rtnetlink_ifinfo_prep(dev, compskb);
|
|
|
|
if (WARN_ON(!nlh)) {
|
|
|
|
kfree_skb(skb);
|
|
|
|
kfree_skb(compskb);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Add the wireless events in the netlink packet */
|
|
|
|
nla = nla_reserve(compskb, IFLA_WIRELESS, event_len);
|
|
|
|
if (!nla) {
|
|
|
|
kfree_skb(skb);
|
|
|
|
kfree_skb(compskb);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
compat_event = nla_data(nla);
|
|
|
|
|
|
|
|
compat_event->len = event_len;
|
|
|
|
compat_event->cmd = cmd;
|
|
|
|
if (descr->header_type == IW_HEADER_TYPE_POINT) {
|
|
|
|
compat_wrqu.length = wrqu->data.length;
|
|
|
|
compat_wrqu.flags = wrqu->data.flags;
|
|
|
|
memcpy(&compat_event->pointer,
|
|
|
|
((char *) &compat_wrqu) + IW_EV_COMPAT_POINT_OFF,
|
|
|
|
hdr_len - IW_EV_COMPAT_LCP_LEN);
|
|
|
|
if (extra_len)
|
|
|
|
memcpy(((char *) compat_event) + hdr_len,
|
|
|
|
extra, extra_len);
|
|
|
|
} else {
|
|
|
|
/* extra_len must be zero, so no if (extra) needed */
|
|
|
|
memcpy(&compat_event->pointer, wrqu,
|
|
|
|
hdr_len - IW_EV_COMPAT_LCP_LEN);
|
|
|
|
}
|
|
|
|
|
|
|
|
nlmsg_end(compskb, nlh);
|
|
|
|
|
|
|
|
skb_shinfo(skb)->frag_list = compskb;
|
|
|
|
#endif
|
|
|
|
skb_queue_tail(&dev_net(dev)->wext_nlevents, skb);
|
|
|
|
schedule_work(&wireless_nlevent_work);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(wireless_send_event);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* IW handlers */
|
|
|
|
|
|
|
|
struct iw_statistics *get_wireless_stats(struct net_device *dev)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_WIRELESS_EXT
|
|
|
|
if ((dev->wireless_handlers != NULL) &&
|
|
|
|
(dev->wireless_handlers->get_wireless_stats != NULL))
|
|
|
|
return dev->wireless_handlers->get_wireless_stats(dev);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_CFG80211_WEXT
|
2010-08-28 09:41:06 -06:00
|
|
|
if (dev->ieee80211_ptr &&
|
2009-09-29 15:27:28 -06:00
|
|
|
dev->ieee80211_ptr->wiphy &&
|
|
|
|
dev->ieee80211_ptr->wiphy->wext &&
|
|
|
|
dev->ieee80211_ptr->wiphy->wext->get_wireless_stats)
|
|
|
|
return dev->ieee80211_ptr->wiphy->wext->get_wireless_stats(dev);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* not found */
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int iw_handler_get_iwstats(struct net_device * dev,
|
|
|
|
struct iw_request_info * info,
|
|
|
|
union iwreq_data * wrqu,
|
|
|
|
char * extra)
|
|
|
|
{
|
|
|
|
/* Get stats from the driver */
|
|
|
|
struct iw_statistics *stats;
|
|
|
|
|
|
|
|
stats = get_wireless_stats(dev);
|
|
|
|
if (stats) {
|
|
|
|
/* Copy statistics to extra */
|
|
|
|
memcpy(extra, stats, sizeof(struct iw_statistics));
|
|
|
|
wrqu->data.length = sizeof(struct iw_statistics);
|
|
|
|
|
|
|
|
/* Check if we need to clear the updated flag */
|
|
|
|
if (wrqu->data.flags != 0)
|
|
|
|
stats->qual.updated &= ~IW_QUAL_ALL_UPDATED;
|
|
|
|
return 0;
|
|
|
|
} else
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
|
|
|
|
|
|
|
static iw_handler get_handler(struct net_device *dev, unsigned int cmd)
|
|
|
|
{
|
|
|
|
/* Don't "optimise" the following variable, it will crash */
|
|
|
|
unsigned int index; /* *MUST* be unsigned */
|
|
|
|
const struct iw_handler_def *handlers = NULL;
|
|
|
|
|
|
|
|
#ifdef CONFIG_CFG80211_WEXT
|
|
|
|
if (dev->ieee80211_ptr && dev->ieee80211_ptr->wiphy)
|
|
|
|
handlers = dev->ieee80211_ptr->wiphy->wext;
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_WIRELESS_EXT
|
|
|
|
if (dev->wireless_handlers)
|
|
|
|
handlers = dev->wireless_handlers;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (!handlers)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
/* Try as a standard command */
|
2010-03-18 19:29:35 -06:00
|
|
|
index = IW_IOCTL_IDX(cmd);
|
2009-09-29 15:27:28 -06:00
|
|
|
if (index < handlers->num_standard)
|
|
|
|
return handlers->standard[index];
|
|
|
|
|
|
|
|
#ifdef CONFIG_WEXT_PRIV
|
|
|
|
/* Try as a private command */
|
|
|
|
index = cmd - SIOCIWFIRSTPRIV;
|
|
|
|
if (index < handlers->num_private)
|
|
|
|
return handlers->private[index];
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Not found */
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ioctl_standard_iw_point(struct iw_point *iwp, unsigned int cmd,
|
|
|
|
const struct iw_ioctl_description *descr,
|
|
|
|
iw_handler handler, struct net_device *dev,
|
|
|
|
struct iw_request_info *info)
|
|
|
|
{
|
|
|
|
int err, extra_size, user_length = 0, essid_compat = 0;
|
|
|
|
char *extra;
|
|
|
|
|
|
|
|
/* Calculate space needed by arguments. Always allocate
|
|
|
|
* for max space.
|
|
|
|
*/
|
|
|
|
extra_size = descr->max_tokens * descr->token_size;
|
|
|
|
|
|
|
|
/* Check need for ESSID compatibility for WE < 21 */
|
|
|
|
switch (cmd) {
|
2007-12-21 04:27:17 -07:00
|
|
|
case SIOCSIWESSID:
|
|
|
|
case SIOCGIWESSID:
|
|
|
|
case SIOCSIWNICKN:
|
|
|
|
case SIOCGIWNICKN:
|
|
|
|
if (iwp->length == descr->max_tokens + 1)
|
|
|
|
essid_compat = 1;
|
|
|
|
else if (IW_IS_SET(cmd) && (iwp->length != 0)) {
|
|
|
|
char essid[IW_ESSID_MAX_SIZE + 1];
|
2009-09-26 12:51:14 -06:00
|
|
|
unsigned int len;
|
|
|
|
len = iwp->length * descr->token_size;
|
2007-12-21 04:27:17 -07:00
|
|
|
|
2009-09-26 12:51:14 -06:00
|
|
|
if (len > IW_ESSID_MAX_SIZE)
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
err = copy_from_user(essid, iwp->pointer, len);
|
2007-12-21 04:27:17 -07:00
|
|
|
if (err)
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
if (essid[iwp->length - 1] == '\0')
|
|
|
|
essid_compat = 1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
iwp->length -= essid_compat;
|
|
|
|
|
|
|
|
/* Check what user space is giving us */
|
|
|
|
if (IW_IS_SET(cmd)) {
|
|
|
|
/* Check NULL pointer */
|
|
|
|
if (!iwp->pointer && iwp->length != 0)
|
|
|
|
return -EFAULT;
|
|
|
|
/* Check if number of token fits within bounds */
|
|
|
|
if (iwp->length > descr->max_tokens)
|
|
|
|
return -E2BIG;
|
|
|
|
if (iwp->length < descr->min_tokens)
|
|
|
|
return -EINVAL;
|
|
|
|
} else {
|
|
|
|
/* Check NULL pointer */
|
|
|
|
if (!iwp->pointer)
|
|
|
|
return -EFAULT;
|
|
|
|
/* Save user space buffer size for checking */
|
|
|
|
user_length = iwp->length;
|
|
|
|
|
|
|
|
/* Don't check if user_length > max to allow forward
|
|
|
|
* compatibility. The test user_length < min is
|
|
|
|
* implied by the test at the end.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Support for very large requests */
|
|
|
|
if ((descr->flags & IW_DESCR_FLAG_NOMAX) &&
|
|
|
|
(user_length > descr->max_tokens)) {
|
|
|
|
/* Allow userspace to GET more than max so
|
|
|
|
* we can support any size GET requests.
|
|
|
|
* There is still a limit : -ENOMEM.
|
|
|
|
*/
|
|
|
|
extra_size = user_length * descr->token_size;
|
|
|
|
|
|
|
|
/* Note : user_length is originally a __u16,
|
|
|
|
* and token_size is controlled by us,
|
|
|
|
* so extra_size won't get negative and
|
|
|
|
* won't overflow...
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* kzalloc() ensures NULL-termination for essid_compat. */
|
|
|
|
extra = kzalloc(extra_size, GFP_KERNEL);
|
|
|
|
if (!extra)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
/* If it is a SET, get all the extra data in here */
|
|
|
|
if (IW_IS_SET(cmd) && (iwp->length != 0)) {
|
|
|
|
if (copy_from_user(extra, iwp->pointer,
|
|
|
|
iwp->length *
|
|
|
|
descr->token_size)) {
|
|
|
|
err = -EFAULT;
|
|
|
|
goto out;
|
|
|
|
}
|
2009-05-13 04:04:30 -06:00
|
|
|
|
|
|
|
if (cmd == SIOCSIWENCODEEXT) {
|
|
|
|
struct iw_encode_ext *ee = (void *) extra;
|
|
|
|
|
2012-04-09 03:01:09 -06:00
|
|
|
if (iwp->length < sizeof(*ee) + ee->key_len) {
|
|
|
|
err = -EFAULT;
|
|
|
|
goto out;
|
|
|
|
}
|
2009-05-13 04:04:30 -06:00
|
|
|
}
|
2007-12-21 04:27:17 -07:00
|
|
|
}
|
|
|
|
|
wireless extensions: fix kernel heap content leak
Wireless extensions have an unfortunate, undocumented
requirement which requires drivers to always fill
iwp->length when returning a successful status. When
a driver doesn't do this, it leads to a kernel heap
content leak when userspace offers a larger buffer
than would have been necessary.
Arguably, this is a driver bug, as it should, if it
returns 0, fill iwp->length, even if it separately
indicated that the buffer contents was not valid.
However, we can also at least avoid the memory content
leak if the driver doesn't do this by setting the iwp
length to max_tokens, which then reflects how big the
buffer is that the driver may fill, regardless of how
big the userspace buffer is.
To illustrate the point, this patch also fixes a
corresponding cfg80211 bug (since this requirement
isn't documented nor was ever pointed out by anyone
during code review, I don't trust all drivers nor
all cfg80211 handlers to implement it correctly).
Cc: stable@kernel.org [all the way back]
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2010-08-30 04:24:54 -06:00
|
|
|
if (IW_IS_GET(cmd) && !(descr->flags & IW_DESCR_FLAG_NOMAX)) {
|
|
|
|
/*
|
|
|
|
* If this is a GET, but not NOMAX, it means that the extra
|
|
|
|
* data is not bounded by userspace, but by max_tokens. Thus
|
|
|
|
* set the length to max_tokens. This matches the extra data
|
|
|
|
* allocation.
|
|
|
|
* The driver should fill it with the number of tokens it
|
|
|
|
* provided, and it may check iwp->length rather than having
|
|
|
|
* knowledge of max_tokens. If the driver doesn't change the
|
|
|
|
* iwp->length, this ioctl just copies back max_token tokens
|
|
|
|
* filled with zeroes. Hopefully the driver isn't claiming
|
|
|
|
* them to be valid data.
|
|
|
|
*/
|
|
|
|
iwp->length = descr->max_tokens;
|
|
|
|
}
|
|
|
|
|
2007-12-21 04:27:17 -07:00
|
|
|
err = handler(dev, info, (union iwreq_data *) iwp, extra);
|
|
|
|
|
|
|
|
iwp->length += essid_compat;
|
|
|
|
|
|
|
|
/* If we have something to return to the user */
|
|
|
|
if (!err && IW_IS_GET(cmd)) {
|
|
|
|
/* Check if there is enough buffer up there */
|
|
|
|
if (user_length < iwp->length) {
|
|
|
|
err = -E2BIG;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (copy_to_user(iwp->pointer, extra,
|
|
|
|
iwp->length *
|
|
|
|
descr->token_size)) {
|
|
|
|
err = -EFAULT;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Generate an event to notify listeners of the change */
|
2009-11-24 11:47:08 -07:00
|
|
|
if ((descr->flags & IW_DESCR_FLAG_EVENT) &&
|
|
|
|
((err == 0) || (err == -EIWCOMMIT))) {
|
2007-12-21 04:27:17 -07:00
|
|
|
union iwreq_data *data = (union iwreq_data *) iwp;
|
|
|
|
|
|
|
|
if (descr->flags & IW_DESCR_FLAG_RESTRICT)
|
|
|
|
/* If the event is restricted, don't
|
|
|
|
* export the payload.
|
|
|
|
*/
|
|
|
|
wireless_send_event(dev, cmd, data, NULL);
|
|
|
|
else
|
|
|
|
wireless_send_event(dev, cmd, data, extra);
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
kfree(extra);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2009-09-29 15:27:28 -06:00
|
|
|
* Call the commit handler in the driver
|
|
|
|
* (if exist and if conditions are right)
|
|
|
|
*
|
|
|
|
* Note : our current commit strategy is currently pretty dumb,
|
|
|
|
* but we will be able to improve on that...
|
|
|
|
* The goal is to try to agreagate as many changes as possible
|
|
|
|
* before doing the commit. Drivers that will define a commit handler
|
|
|
|
* are usually those that need a reset after changing parameters, so
|
|
|
|
* we want to minimise the number of reset.
|
|
|
|
* A cool idea is to use a timer : at each "set" command, we re-set the
|
|
|
|
* timer, when the timer eventually fires, we call the driver.
|
|
|
|
* Hopefully, more on that later.
|
|
|
|
*
|
|
|
|
* Also, I'm waiting to see how many people will complain about the
|
|
|
|
* netif_running(dev) test. I'm open on that one...
|
|
|
|
* Hopefully, the driver will remember to do a commit in "open()" ;-)
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2009-09-29 15:27:28 -06:00
|
|
|
int call_commit_handler(struct net_device *dev)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2009-09-29 15:27:28 -06:00
|
|
|
#ifdef CONFIG_WIRELESS_EXT
|
|
|
|
if ((netif_running(dev)) &&
|
|
|
|
(dev->wireless_handlers->standard[0] != NULL))
|
|
|
|
/* Call the commit handler on the driver */
|
|
|
|
return dev->wireless_handlers->standard[0](dev, NULL,
|
|
|
|
NULL, NULL);
|
|
|
|
else
|
|
|
|
return 0; /* Command completed successfully */
|
|
|
|
#else
|
|
|
|
/* cfg80211 has no commit */
|
|
|
|
return 0;
|
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2007-04-26 21:43:56 -06:00
|
|
|
* Main IOCTl dispatcher.
|
2005-04-16 16:20:36 -06:00
|
|
|
* Check the type of IOCTL and call the appropriate wrapper...
|
|
|
|
*/
|
2017-06-14 01:21:58 -06:00
|
|
|
static int wireless_process_ioctl(struct net *net, struct iwreq *iwr,
|
2007-12-21 04:41:45 -07:00
|
|
|
unsigned int cmd,
|
2008-06-03 08:39:16 -06:00
|
|
|
struct iw_request_info *info,
|
2007-12-21 04:41:45 -07:00
|
|
|
wext_ioctl_func standard,
|
|
|
|
wext_ioctl_func private)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct net_device *dev;
|
|
|
|
iw_handler handler;
|
|
|
|
|
|
|
|
/* Permissions are already checked in dev_ioctl() before calling us.
|
|
|
|
* The copy_to/from_user() of ifr is also dealt with in there */
|
|
|
|
|
|
|
|
/* Make sure the device exist */
|
2017-06-14 01:21:58 -06:00
|
|
|
if ((dev = __dev_get_by_name(net, iwr->ifr_name)) == NULL)
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
/* A bunch of special cases, then the generic case...
|
|
|
|
* Note that 'cmd' is already filtered in dev_ioctl() with
|
|
|
|
* (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST) */
|
2007-04-26 21:45:47 -06:00
|
|
|
if (cmd == SIOCGIWSTATS)
|
2008-06-03 08:39:16 -06:00
|
|
|
return standard(dev, iwr, cmd, info,
|
2007-12-21 04:41:45 -07:00
|
|
|
&iw_handler_get_iwstats);
|
2007-04-10 21:10:33 -06:00
|
|
|
|
2009-09-29 15:27:28 -06:00
|
|
|
#ifdef CONFIG_WEXT_PRIV
|
2007-04-26 21:45:47 -06:00
|
|
|
if (cmd == SIOCGIWPRIV && dev->wireless_handlers)
|
2008-06-03 08:39:16 -06:00
|
|
|
return standard(dev, iwr, cmd, info,
|
2009-09-29 15:27:28 -06:00
|
|
|
iw_handler_get_private);
|
|
|
|
#endif
|
2007-04-26 21:45:47 -06:00
|
|
|
|
|
|
|
/* Basic check */
|
|
|
|
if (!netif_device_present(dev))
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
/* New driver API : try to find the handler */
|
|
|
|
handler = get_handler(dev, cmd);
|
|
|
|
if (handler) {
|
|
|
|
/* Standard and private are not the same */
|
|
|
|
if (cmd < SIOCIWFIRSTPRIV)
|
2008-06-03 08:39:16 -06:00
|
|
|
return standard(dev, iwr, cmd, info, handler);
|
2009-09-29 15:27:28 -06:00
|
|
|
else if (private)
|
2008-06-03 08:39:16 -06:00
|
|
|
return private(dev, iwr, cmd, info, handler);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-04-26 21:45:47 -06:00
|
|
|
return -EOPNOTSUPP;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-12-21 04:36:31 -07:00
|
|
|
/* If command is `set a parameter', or `get the encoding parameters',
|
|
|
|
* check if the user has the right to do it.
|
|
|
|
*/
|
|
|
|
static int wext_permission_check(unsigned int cmd)
|
|
|
|
{
|
2009-11-29 17:55:45 -07:00
|
|
|
if ((IW_IS_SET(cmd) || cmd == SIOCGIWENCODE ||
|
|
|
|
cmd == SIOCGIWENCODEEXT) &&
|
|
|
|
!capable(CAP_NET_ADMIN))
|
2007-12-21 04:36:31 -07:00
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-04-26 21:43:56 -06:00
|
|
|
/* entry point from dev ioctl */
|
2017-06-14 01:21:58 -06:00
|
|
|
static int wext_ioctl_dispatch(struct net *net, struct iwreq *iwr,
|
2008-06-03 08:39:16 -06:00
|
|
|
unsigned int cmd, struct iw_request_info *info,
|
2008-06-03 08:36:30 -06:00
|
|
|
wext_ioctl_func standard,
|
|
|
|
wext_ioctl_func private)
|
2007-04-26 21:43:56 -06:00
|
|
|
{
|
2007-12-21 04:36:31 -07:00
|
|
|
int ret = wext_permission_check(cmd);
|
2007-04-26 21:43:56 -06:00
|
|
|
|
2007-12-21 04:36:31 -07:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2007-04-26 21:45:47 -06:00
|
|
|
|
2017-06-14 01:21:58 -06:00
|
|
|
dev_load(net, iwr->ifr_name);
|
2007-04-26 21:43:56 -06:00
|
|
|
rtnl_lock();
|
2017-06-14 01:21:58 -06:00
|
|
|
ret = wireless_process_ioctl(net, iwr, cmd, info, standard, private);
|
2007-04-26 21:43:56 -06:00
|
|
|
rtnl_unlock();
|
2008-06-03 08:36:30 -06:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-09-29 15:27:28 -06:00
|
|
|
/*
|
|
|
|
* Wrapper to call a standard Wireless Extension handler.
|
|
|
|
* We do various checks and also take care of moving data between
|
|
|
|
* user space and kernel space.
|
|
|
|
*/
|
|
|
|
static int ioctl_standard_call(struct net_device * dev,
|
|
|
|
struct iwreq *iwr,
|
|
|
|
unsigned int cmd,
|
|
|
|
struct iw_request_info *info,
|
|
|
|
iw_handler handler)
|
|
|
|
{
|
|
|
|
const struct iw_ioctl_description * descr;
|
|
|
|
int ret = -EINVAL;
|
|
|
|
|
|
|
|
/* Get the description of the IOCTL */
|
2010-03-18 19:29:35 -06:00
|
|
|
if (IW_IOCTL_IDX(cmd) >= standard_ioctl_num)
|
2009-09-29 15:27:28 -06:00
|
|
|
return -EOPNOTSUPP;
|
2010-03-18 19:29:35 -06:00
|
|
|
descr = &(standard_ioctl[IW_IOCTL_IDX(cmd)]);
|
2009-09-29 15:27:28 -06:00
|
|
|
|
|
|
|
/* Check if we have a pointer to user space data or not */
|
|
|
|
if (descr->header_type != IW_HEADER_TYPE_POINT) {
|
|
|
|
|
|
|
|
/* No extra arguments. Trivial to handle */
|
|
|
|
ret = handler(dev, info, &(iwr->u), NULL);
|
|
|
|
|
|
|
|
/* Generate an event to notify listeners of the change */
|
|
|
|
if ((descr->flags & IW_DESCR_FLAG_EVENT) &&
|
|
|
|
((ret == 0) || (ret == -EIWCOMMIT)))
|
|
|
|
wireless_send_event(dev, cmd, &(iwr->u), NULL);
|
|
|
|
} else {
|
|
|
|
ret = ioctl_standard_iw_point(&iwr->u.data, cmd, descr,
|
|
|
|
handler, dev, info);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Call commit handler if needed and defined */
|
|
|
|
if (ret == -EIWCOMMIT)
|
|
|
|
ret = call_commit_handler(dev);
|
|
|
|
|
|
|
|
/* Here, we will generate the appropriate event if needed */
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-10-01 18:13:08 -06:00
|
|
|
int wext_handle_ioctl(struct net *net, unsigned int cmd, void __user *arg)
|
2008-06-03 08:36:30 -06:00
|
|
|
{
|
2008-06-03 08:39:16 -06:00
|
|
|
struct iw_request_info info = { .cmd = cmd, .flags = 0 };
|
2017-10-01 18:13:08 -06:00
|
|
|
struct iwreq iwr;
|
2008-06-03 08:39:16 -06:00
|
|
|
int ret;
|
2008-06-03 08:36:30 -06:00
|
|
|
|
2017-10-01 18:13:08 -06:00
|
|
|
if (copy_from_user(&iwr, arg, sizeof(iwr)))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
iwr.ifr_name[sizeof(iwr.ifr_name) - 1] = 0;
|
|
|
|
|
|
|
|
ret = wext_ioctl_dispatch(net, &iwr, cmd, &info,
|
2008-06-03 08:39:16 -06:00
|
|
|
ioctl_standard_call,
|
|
|
|
ioctl_private_call);
|
2008-06-03 08:36:30 -06:00
|
|
|
if (ret >= 0 &&
|
|
|
|
IW_IS_GET(cmd) &&
|
2017-10-01 18:13:08 -06:00
|
|
|
copy_to_user(arg, &iwr, sizeof(struct iwreq)))
|
2007-04-26 21:43:56 -06:00
|
|
|
return -EFAULT;
|
2008-06-03 08:36:30 -06:00
|
|
|
|
2007-04-26 21:43:56 -06:00
|
|
|
return ret;
|
|
|
|
}
|
2006-02-22 16:10:56 -07:00
|
|
|
|
2008-06-03 10:14:03 -06:00
|
|
|
#ifdef CONFIG_COMPAT
|
|
|
|
static int compat_standard_call(struct net_device *dev,
|
|
|
|
struct iwreq *iwr,
|
|
|
|
unsigned int cmd,
|
2008-06-03 08:39:16 -06:00
|
|
|
struct iw_request_info *info,
|
2008-06-03 10:14:03 -06:00
|
|
|
iw_handler handler)
|
|
|
|
{
|
|
|
|
const struct iw_ioctl_description *descr;
|
|
|
|
struct compat_iw_point *iwp_compat;
|
|
|
|
struct iw_point iwp;
|
|
|
|
int err;
|
|
|
|
|
2010-03-18 19:29:35 -06:00
|
|
|
descr = standard_ioctl + IW_IOCTL_IDX(cmd);
|
2008-06-03 10:14:03 -06:00
|
|
|
|
|
|
|
if (descr->header_type != IW_HEADER_TYPE_POINT)
|
2008-06-03 08:39:16 -06:00
|
|
|
return ioctl_standard_call(dev, iwr, cmd, info, handler);
|
2008-06-03 10:14:03 -06:00
|
|
|
|
|
|
|
iwp_compat = (struct compat_iw_point *) &iwr->u.data;
|
|
|
|
iwp.pointer = compat_ptr(iwp_compat->pointer);
|
|
|
|
iwp.length = iwp_compat->length;
|
|
|
|
iwp.flags = iwp_compat->flags;
|
|
|
|
|
2008-06-03 08:39:16 -06:00
|
|
|
err = ioctl_standard_iw_point(&iwp, cmd, descr, handler, dev, info);
|
2008-06-03 10:14:03 -06:00
|
|
|
|
|
|
|
iwp_compat->pointer = ptr_to_compat(iwp.pointer);
|
|
|
|
iwp_compat->length = iwp.length;
|
|
|
|
iwp_compat->flags = iwp.flags;
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
int compat_wext_handle_ioctl(struct net *net, unsigned int cmd,
|
|
|
|
unsigned long arg)
|
|
|
|
{
|
|
|
|
void __user *argp = (void __user *)arg;
|
2008-06-03 08:39:16 -06:00
|
|
|
struct iw_request_info info;
|
2008-06-03 10:14:03 -06:00
|
|
|
struct iwreq iwr;
|
|
|
|
char *colon;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (copy_from_user(&iwr, argp, sizeof(struct iwreq)))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
iwr.ifr_name[IFNAMSIZ-1] = 0;
|
|
|
|
colon = strchr(iwr.ifr_name, ':');
|
|
|
|
if (colon)
|
|
|
|
*colon = 0;
|
|
|
|
|
2008-06-03 08:39:16 -06:00
|
|
|
info.cmd = cmd;
|
|
|
|
info.flags = IW_REQUEST_FLAG_COMPAT;
|
|
|
|
|
2017-06-14 01:21:58 -06:00
|
|
|
ret = wext_ioctl_dispatch(net, &iwr, cmd, &info,
|
2008-06-03 10:14:03 -06:00
|
|
|
compat_standard_call,
|
|
|
|
compat_private_call);
|
|
|
|
|
|
|
|
if (ret >= 0 &&
|
|
|
|
IW_IS_GET(cmd) &&
|
|
|
|
copy_to_user(argp, &iwr, sizeof(struct iwreq)))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
#endif
|
2017-01-13 01:31:32 -07:00
|
|
|
|
|
|
|
char *iwe_stream_add_event(struct iw_request_info *info, char *stream,
|
|
|
|
char *ends, struct iw_event *iwe, int event_len)
|
|
|
|
{
|
|
|
|
int lcp_len = iwe_stream_lcp_len(info);
|
|
|
|
|
|
|
|
event_len = iwe_stream_event_len_adjust(info, event_len);
|
|
|
|
|
|
|
|
/* Check if it's possible */
|
|
|
|
if (likely((stream + event_len) < ends)) {
|
|
|
|
iwe->len = event_len;
|
|
|
|
/* Beware of alignement issues on 64 bits */
|
|
|
|
memcpy(stream, (char *) iwe, IW_EV_LCP_PK_LEN);
|
|
|
|
memcpy(stream + lcp_len, &iwe->u,
|
|
|
|
event_len - lcp_len);
|
|
|
|
stream += event_len;
|
|
|
|
}
|
|
|
|
|
|
|
|
return stream;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(iwe_stream_add_event);
|
|
|
|
|
|
|
|
char *iwe_stream_add_point(struct iw_request_info *info, char *stream,
|
|
|
|
char *ends, struct iw_event *iwe, char *extra)
|
|
|
|
{
|
|
|
|
int event_len = iwe_stream_point_len(info) + iwe->u.data.length;
|
|
|
|
int point_len = iwe_stream_point_len(info);
|
|
|
|
int lcp_len = iwe_stream_lcp_len(info);
|
|
|
|
|
|
|
|
/* Check if it's possible */
|
|
|
|
if (likely((stream + event_len) < ends)) {
|
|
|
|
iwe->len = event_len;
|
|
|
|
memcpy(stream, (char *) iwe, IW_EV_LCP_PK_LEN);
|
|
|
|
memcpy(stream + lcp_len,
|
|
|
|
((char *) &iwe->u) + IW_EV_POINT_OFF,
|
|
|
|
IW_EV_POINT_PK_LEN - IW_EV_LCP_PK_LEN);
|
|
|
|
if (iwe->u.data.length && extra)
|
|
|
|
memcpy(stream + point_len, extra, iwe->u.data.length);
|
|
|
|
stream += event_len;
|
|
|
|
}
|
|
|
|
|
|
|
|
return stream;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(iwe_stream_add_point);
|
|
|
|
|
|
|
|
char *iwe_stream_add_value(struct iw_request_info *info, char *event,
|
|
|
|
char *value, char *ends, struct iw_event *iwe,
|
|
|
|
int event_len)
|
|
|
|
{
|
|
|
|
int lcp_len = iwe_stream_lcp_len(info);
|
|
|
|
|
|
|
|
/* Don't duplicate LCP */
|
|
|
|
event_len -= IW_EV_LCP_LEN;
|
|
|
|
|
|
|
|
/* Check if it's possible */
|
|
|
|
if (likely((value + event_len) < ends)) {
|
|
|
|
/* Add new value */
|
|
|
|
memcpy(value, &iwe->u, event_len);
|
|
|
|
value += event_len;
|
|
|
|
/* Patch LCP */
|
|
|
|
iwe->len = value - event;
|
|
|
|
memcpy(event, (char *) iwe, lcp_len);
|
|
|
|
}
|
|
|
|
|
|
|
|
return value;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(iwe_stream_add_value);
|