2007-04-23 19:20:05 +00:00
|
|
|
/*
|
|
|
|
|
* Wireless configuration interface internals.
|
|
|
|
|
*
|
2010-01-17 14:49:02 +00:00
|
|
|
* Copyright 2006-2010 Johannes Berg <johannes@sipsolutions.net>
|
2007-04-23 19:20:05 +00:00
|
|
|
*/
|
|
|
|
|
#ifndef __NET_WIRELESS_CORE_H
|
|
|
|
|
#define __NET_WIRELESS_CORE_H
|
|
|
|
|
#include <linux/mutex.h>
|
|
|
|
|
#include <linux/list.h>
|
|
|
|
|
#include <linux/netdevice.h>
|
2009-02-10 20:25:55 +00:00
|
|
|
#include <linux/kref.h>
|
|
|
|
|
#include <linux/rbtree.h>
|
2009-05-02 04:37:21 +00:00
|
|
|
#include <linux/debugfs.h>
|
2009-06-02 11:01:41 +00:00
|
|
|
#include <linux/rfkill.h>
|
|
|
|
|
#include <linux/workqueue.h>
|
2007-04-23 19:20:05 +00:00
|
|
|
#include <net/genetlink.h>
|
|
|
|
|
#include <net/cfg80211.h>
|
2008-11-12 22:22:02 +00:00
|
|
|
#include "reg.h"
|
2007-04-23 19:20:05 +00:00
|
|
|
|
|
|
|
|
struct cfg80211_registered_device {
|
2009-05-16 22:13:46 +00:00
|
|
|
const struct cfg80211_ops *ops;
|
2007-04-23 19:20:05 +00:00
|
|
|
struct list_head list;
|
|
|
|
|
/* we hold this mutex during any call so that
|
|
|
|
|
* we cannot do multiple calls at once, and also
|
|
|
|
|
* to avoid the deregister call to proceed while
|
|
|
|
|
* any call is in progress */
|
|
|
|
|
struct mutex mtx;
|
|
|
|
|
|
2009-06-02 11:01:41 +00:00
|
|
|
/* rfkill support */
|
|
|
|
|
struct rfkill_ops rfkill_ops;
|
|
|
|
|
struct rfkill *rfkill;
|
|
|
|
|
struct work_struct rfkill_sync;
|
|
|
|
|
|
2008-11-12 22:22:02 +00: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];
|
|
|
|
|
|
|
|
|
|
/* 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 19:20:05 +00:00
|
|
|
/* wiphy index, internal only */
|
2009-02-21 05:04:19 +00:00
|
|
|
int wiphy_idx;
|
2007-04-23 19:20:05 +00:00
|
|
|
|
|
|
|
|
/* associate netdev list */
|
|
|
|
|
struct mutex devlist_mtx;
|
2010-01-17 14:49:02 +00:00
|
|
|
/* protected by devlist_mtx or RCU */
|
2007-04-23 19:20:05 +00:00
|
|
|
struct list_head netdev_list;
|
2009-08-07 14:17:38 +00:00
|
|
|
int devlist_generation;
|
2009-08-18 17:51:57 +00:00
|
|
|
int opencount; /* also protected by devlist_mtx */
|
|
|
|
|
wait_queue_head_t dev_wait;
|
2007-04-23 19:20:05 +00:00
|
|
|
|
2009-02-10 20:25:55 +00:00
|
|
|
/* BSSes/scanning */
|
|
|
|
|
spinlock_t bss_lock;
|
|
|
|
|
struct list_head bss_list;
|
|
|
|
|
struct rb_root bss_tree;
|
|
|
|
|
u32 bss_generation;
|
|
|
|
|
struct cfg80211_scan_request *scan_req; /* protected by RTNL */
|
2011-05-11 14:09:35 +00:00
|
|
|
struct cfg80211_sched_scan_request *sched_scan_req;
|
2009-02-11 22:14:43 +00:00
|
|
|
unsigned long suspend_at;
|
2009-07-07 01:56:11 +00:00
|
|
|
struct work_struct scan_done_wk;
|
2011-05-11 14:09:35 +00:00
|
|
|
struct work_struct sched_scan_results_wk;
|
|
|
|
|
struct work_struct sched_scan_stopped_wk;
|
2009-02-10 20:25:55 +00:00
|
|
|
|
2009-07-01 19:26:51 +00:00
|
|
|
#ifdef CONFIG_NL80211_TESTMODE
|
|
|
|
|
struct genl_info *testmode_info;
|
|
|
|
|
#endif
|
|
|
|
|
|
2009-07-02 07:13:27 +00:00
|
|
|
struct work_struct conn_work;
|
2009-07-07 01:56:11 +00:00
|
|
|
struct work_struct event_work;
|
2009-07-02 07:13:27 +00:00
|
|
|
|
2011-05-04 13:37:28 +00:00
|
|
|
struct cfg80211_wowlan *wowlan;
|
|
|
|
|
|
2007-04-23 19:20:05 +00:00
|
|
|
/* must be last because of the way we do wiphy_priv(),
|
|
|
|
|
* and it should at least be aligned to NETDEV_ALIGN */
|
|
|
|
|
struct wiphy wiphy __attribute__((__aligned__(NETDEV_ALIGN)));
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static inline
|
|
|
|
|
struct cfg80211_registered_device *wiphy_to_dev(struct wiphy *wiphy)
|
|
|
|
|
{
|
|
|
|
|
BUG_ON(!wiphy);
|
|
|
|
|
return container_of(wiphy, struct cfg80211_registered_device, wiphy);
|
|
|
|
|
}
|
|
|
|
|
|
2009-02-21 05:04:20 +00:00
|
|
|
/* Note 0 is valid, hence phy0 */
|
|
|
|
|
static inline
|
|
|
|
|
bool wiphy_idx_valid(int wiphy_idx)
|
|
|
|
|
{
|
2010-09-22 20:43:57 +00:00
|
|
|
return wiphy_idx >= 0;
|
2009-02-21 05:04:20 +00:00
|
|
|
}
|
|
|
|
|
|
2011-05-04 13:37:28 +00:00
|
|
|
static inline void
|
|
|
|
|
cfg80211_rdev_free_wowlan(struct cfg80211_registered_device *rdev)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
if (!rdev->wowlan)
|
|
|
|
|
return;
|
|
|
|
|
for (i = 0; i < rdev->wowlan->n_patterns; i++)
|
|
|
|
|
kfree(rdev->wowlan->patterns[i].mask);
|
|
|
|
|
kfree(rdev->wowlan->patterns);
|
|
|
|
|
kfree(rdev->wowlan);
|
|
|
|
|
}
|
2009-11-25 14:13:00 +00:00
|
|
|
|
|
|
|
|
extern struct workqueue_struct *cfg80211_wq;
|
2009-02-21 05:04:21 +00:00
|
|
|
extern struct mutex cfg80211_mutex;
|
2009-07-07 01:56:12 +00:00
|
|
|
extern struct list_head cfg80211_rdev_list;
|
2009-08-07 14:17:38 +00:00
|
|
|
extern int cfg80211_rdev_list_generation;
|
2007-04-23 19:20:05 +00:00
|
|
|
|
2010-09-15 11:28:15 +00:00
|
|
|
static inline void assert_cfg80211_lock(void)
|
|
|
|
|
{
|
|
|
|
|
lockdep_assert_held(&cfg80211_mutex);
|
|
|
|
|
}
|
2009-02-21 05:04:25 +00:00
|
|
|
|
2009-02-21 05:04:26 +00:00
|
|
|
/*
|
|
|
|
|
* You can use this to mark a wiphy_idx as not having an associated wiphy.
|
2009-07-07 01:56:12 +00:00
|
|
|
* It guarantees cfg80211_rdev_by_wiphy_idx(wiphy_idx) will return NULL
|
2009-02-21 05:04:26 +00:00
|
|
|
*/
|
|
|
|
|
#define WIPHY_IDX_STALE -1
|
|
|
|
|
|
2009-02-10 20:25:55 +00:00
|
|
|
struct cfg80211_internal_bss {
|
|
|
|
|
struct list_head list;
|
|
|
|
|
struct rb_node rbn;
|
|
|
|
|
unsigned long ts;
|
|
|
|
|
struct kref ref;
|
2009-07-02 15:20:43 +00:00
|
|
|
atomic_t hold;
|
2010-01-06 14:19:24 +00:00
|
|
|
bool beacon_ies_allocated;
|
|
|
|
|
bool proberesp_ies_allocated;
|
2009-03-22 19:57:28 +00:00
|
|
|
|
2009-02-10 20:25:55 +00:00
|
|
|
/* must be last because of priv member */
|
|
|
|
|
struct cfg80211_bss pub;
|
|
|
|
|
};
|
|
|
|
|
|
2009-07-02 15:20:43 +00:00
|
|
|
static inline struct cfg80211_internal_bss *bss_from_pub(struct cfg80211_bss *pub)
|
|
|
|
|
{
|
|
|
|
|
return container_of(pub, struct cfg80211_internal_bss, pub);
|
|
|
|
|
}
|
|
|
|
|
|
2009-07-29 09:23:49 +00:00
|
|
|
static inline void cfg80211_ref_bss(struct cfg80211_internal_bss *bss)
|
|
|
|
|
{
|
|
|
|
|
kref_get(&bss->ref);
|
|
|
|
|
}
|
|
|
|
|
|
2009-07-02 15:20:43 +00:00
|
|
|
static inline void cfg80211_hold_bss(struct cfg80211_internal_bss *bss)
|
|
|
|
|
{
|
|
|
|
|
atomic_inc(&bss->hold);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void cfg80211_unhold_bss(struct cfg80211_internal_bss *bss)
|
|
|
|
|
{
|
|
|
|
|
int r = atomic_dec_return(&bss->hold);
|
|
|
|
|
WARN_ON(r < 0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2009-07-07 01:56:12 +00:00
|
|
|
struct cfg80211_registered_device *cfg80211_rdev_by_wiphy_idx(int wiphy_idx);
|
2009-02-21 05:04:26 +00:00
|
|
|
int get_wiphy_idx(struct wiphy *wiphy);
|
|
|
|
|
|
2009-03-24 08:35:46 +00:00
|
|
|
struct cfg80211_registered_device *
|
2009-07-07 01:56:12 +00:00
|
|
|
__cfg80211_rdev_from_info(struct genl_info *info);
|
2009-03-24 08:35:46 +00:00
|
|
|
|
2007-09-20 17:09:35 +00:00
|
|
|
/*
|
|
|
|
|
* This function returns a pointer to the driver
|
|
|
|
|
* that the genl_info item that is passed refers to.
|
|
|
|
|
* If successful, it returns non-NULL and also locks
|
|
|
|
|
* the driver's mutex!
|
|
|
|
|
*
|
2009-07-07 01:56:09 +00:00
|
|
|
* This means that you need to call cfg80211_unlock_rdev()
|
2009-02-21 05:04:21 +00:00
|
|
|
* before being allowed to acquire &cfg80211_mutex!
|
2007-09-20 17:09:35 +00:00
|
|
|
*
|
|
|
|
|
* This is necessary because we need to lock the global
|
|
|
|
|
* mutex to get an item off the list safely, and then
|
2009-07-07 01:56:12 +00:00
|
|
|
* we lock the rdev mutex so it doesn't go away under us.
|
2007-09-20 17:09:35 +00:00
|
|
|
*
|
2009-02-21 05:04:21 +00:00
|
|
|
* We don't want to keep cfg80211_mutex locked
|
2007-09-20 17:09:35 +00:00
|
|
|
* for all the time in order to allow requests on
|
|
|
|
|
* other interfaces to go through at the same time.
|
|
|
|
|
*
|
|
|
|
|
* The result of this can be a PTR_ERR and hence must
|
|
|
|
|
* be checked with IS_ERR() for errors.
|
|
|
|
|
*/
|
|
|
|
|
extern struct cfg80211_registered_device *
|
|
|
|
|
cfg80211_get_dev_from_info(struct genl_info *info);
|
|
|
|
|
|
2009-07-07 01:56:12 +00:00
|
|
|
/* requires cfg80211_rdev_mutex to be held! */
|
2009-02-21 05:04:26 +00:00
|
|
|
struct wiphy *wiphy_idx_to_wiphy(int wiphy_idx);
|
|
|
|
|
|
2007-09-20 17:09:35 +00:00
|
|
|
/* identical to cfg80211_get_dev_from_info but only operate on ifindex */
|
|
|
|
|
extern struct cfg80211_registered_device *
|
2009-07-13 22:33:35 +00:00
|
|
|
cfg80211_get_dev_from_ifindex(struct net *net, int ifindex);
|
|
|
|
|
|
|
|
|
|
int cfg80211_switch_netns(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct net *net);
|
2007-09-20 17:09:35 +00:00
|
|
|
|
2009-07-07 01:56:12 +00:00
|
|
|
static inline void cfg80211_lock_rdev(struct cfg80211_registered_device *rdev)
|
2009-07-07 01:56:11 +00:00
|
|
|
{
|
2009-07-07 01:56:12 +00:00
|
|
|
mutex_lock(&rdev->mtx);
|
2009-07-07 01:56:11 +00:00
|
|
|
}
|
|
|
|
|
|
2009-07-07 01:56:12 +00:00
|
|
|
static inline void cfg80211_unlock_rdev(struct cfg80211_registered_device *rdev)
|
2009-07-07 01:56:09 +00:00
|
|
|
{
|
2009-07-07 01:56:12 +00:00
|
|
|
BUG_ON(IS_ERR(rdev) || !rdev);
|
|
|
|
|
mutex_unlock(&rdev->mtx);
|
2009-07-07 01:56:09 +00:00
|
|
|
}
|
2007-09-20 17:09:35 +00:00
|
|
|
|
2009-07-07 01:56:11 +00: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 11:28:15 +00:00
|
|
|
#define ASSERT_RDEV_LOCK(rdev) lockdep_assert_held(&(rdev)->mtx)
|
|
|
|
|
#define ASSERT_WDEV_LOCK(wdev) lockdep_assert_held(&(wdev)->mtx)
|
2009-07-07 01:56:11 +00:00
|
|
|
|
|
|
|
|
enum cfg80211_event_type {
|
|
|
|
|
EVENT_CONNECT_RESULT,
|
|
|
|
|
EVENT_ROAMED,
|
|
|
|
|
EVENT_DISCONNECTED,
|
|
|
|
|
EVENT_IBSS_JOINED,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct cfg80211_event {
|
|
|
|
|
struct list_head list;
|
|
|
|
|
enum cfg80211_event_type type;
|
|
|
|
|
|
|
|
|
|
union {
|
|
|
|
|
struct {
|
|
|
|
|
u8 bssid[ETH_ALEN];
|
|
|
|
|
const u8 *req_ie;
|
|
|
|
|
const u8 *resp_ie;
|
|
|
|
|
size_t req_ie_len;
|
|
|
|
|
size_t resp_ie_len;
|
|
|
|
|
u16 status;
|
|
|
|
|
} cr;
|
|
|
|
|
struct {
|
|
|
|
|
u8 bssid[ETH_ALEN];
|
|
|
|
|
const u8 *req_ie;
|
|
|
|
|
const u8 *resp_ie;
|
|
|
|
|
size_t req_ie_len;
|
|
|
|
|
size_t resp_ie_len;
|
|
|
|
|
} rm;
|
|
|
|
|
struct {
|
|
|
|
|
const u8 *ie;
|
|
|
|
|
size_t ie_len;
|
|
|
|
|
u16 reason;
|
|
|
|
|
} dc;
|
|
|
|
|
struct {
|
|
|
|
|
u8 bssid[ETH_ALEN];
|
|
|
|
|
} ij;
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
|
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 12:22:54 +00:00
|
|
|
struct cfg80211_cached_keys {
|
|
|
|
|
struct key_params params[6];
|
|
|
|
|
u8 data[6][WLAN_MAX_KEY_LEN];
|
|
|
|
|
int def, defmgmt;
|
|
|
|
|
};
|
|
|
|
|
|
2009-07-07 01:56:11 +00:00
|
|
|
|
2007-04-23 19:20:05 +00:00
|
|
|
/* free object */
|
2009-07-07 01:56:12 +00:00
|
|
|
extern void cfg80211_dev_free(struct cfg80211_registered_device *rdev);
|
2007-04-23 19:20:05 +00:00
|
|
|
|
2009-07-07 01:56:12 +00:00
|
|
|
extern int cfg80211_dev_rename(struct cfg80211_registered_device *rdev,
|
2007-09-20 17:09:35 +00:00
|
|
|
char *newname);
|
|
|
|
|
|
2008-01-24 18:38:38 +00:00
|
|
|
void ieee80211_set_bitrate_flags(struct wiphy *wiphy);
|
2009-03-10 02:07:41 +00:00
|
|
|
void wiphy_update_regulatory(struct wiphy *wiphy,
|
|
|
|
|
enum nl80211_reg_initiator setby);
|
2008-01-24 18:38:38 +00:00
|
|
|
|
2009-02-10 20:25:55 +00:00
|
|
|
void cfg80211_bss_expire(struct cfg80211_registered_device *dev);
|
2009-02-11 22:14:43 +00:00
|
|
|
void cfg80211_bss_age(struct cfg80211_registered_device *dev,
|
|
|
|
|
unsigned long age_secs);
|
2009-02-10 20:25:55 +00:00
|
|
|
|
2009-04-19 19:24:32 +00:00
|
|
|
/* IBSS */
|
2009-07-07 01:56:11 +00:00
|
|
|
int __cfg80211_join_ibss(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 12:22:54 +00:00
|
|
|
struct cfg80211_ibss_params *params,
|
|
|
|
|
struct cfg80211_cached_keys *connkeys);
|
2009-04-19 19:24:32 +00:00
|
|
|
int cfg80211_join_ibss(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 12:22:54 +00:00
|
|
|
struct cfg80211_ibss_params *params,
|
|
|
|
|
struct cfg80211_cached_keys *connkeys);
|
2009-04-20 16:43:46 +00:00
|
|
|
void cfg80211_clear_ibss(struct net_device *dev, bool nowext);
|
2009-11-18 12:03:43 +00:00
|
|
|
int __cfg80211_leave_ibss(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct net_device *dev, bool nowext);
|
2009-04-19 19:24:32 +00:00
|
|
|
int cfg80211_leave_ibss(struct cfg80211_registered_device *rdev,
|
2009-04-20 16:43:46 +00:00
|
|
|
struct net_device *dev, bool nowext);
|
2009-07-07 01:56:11 +00:00
|
|
|
void __cfg80211_ibss_joined(struct net_device *dev, 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 12:22:54 +00:00
|
|
|
int cfg80211_ibss_wext_join(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct wireless_dev *wdev);
|
2009-04-19 19:24:32 +00:00
|
|
|
|
2010-12-03 08:20:44 +00:00
|
|
|
/* mesh */
|
|
|
|
|
extern const struct mesh_config default_mesh_config;
|
2010-12-17 01:37:49 +00:00
|
|
|
extern const struct mesh_setup default_mesh_setup;
|
2010-12-03 08:20:44 +00:00
|
|
|
int __cfg80211_join_mesh(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct net_device *dev,
|
2010-12-17 01:37:49 +00:00
|
|
|
const struct mesh_setup *setup,
|
2010-12-03 08:20:44 +00:00
|
|
|
const struct mesh_config *conf);
|
|
|
|
|
int cfg80211_join_mesh(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct net_device *dev,
|
2010-12-17 01:37:49 +00:00
|
|
|
const struct mesh_setup *setup,
|
2010-12-03 08:20:44 +00:00
|
|
|
const struct mesh_config *conf);
|
|
|
|
|
int cfg80211_leave_mesh(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct net_device *dev);
|
|
|
|
|
|
2009-07-02 15:20:43 +00:00
|
|
|
/* MLME */
|
2009-07-07 01:56:11 +00:00
|
|
|
int __cfg80211_mlme_auth(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct net_device *dev,
|
|
|
|
|
struct ieee80211_channel *chan,
|
|
|
|
|
enum nl80211_auth_type auth_type,
|
|
|
|
|
const u8 *bssid,
|
|
|
|
|
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 12:22:54 +00:00
|
|
|
const u8 *ie, int ie_len,
|
2010-04-04 06:37:19 +00:00
|
|
|
const u8 *key, int key_len, int key_idx,
|
|
|
|
|
bool local_state_change);
|
2009-07-02 15:20:43 +00:00
|
|
|
int cfg80211_mlme_auth(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct net_device *dev, struct ieee80211_channel *chan,
|
|
|
|
|
enum nl80211_auth_type auth_type, const u8 *bssid,
|
|
|
|
|
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 12:22:54 +00:00
|
|
|
const u8 *ie, int ie_len,
|
2010-04-04 06:37:19 +00:00
|
|
|
const u8 *key, int key_len, int key_idx,
|
|
|
|
|
bool local_state_change);
|
2009-07-07 01:56:11 +00:00
|
|
|
int __cfg80211_mlme_assoc(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct net_device *dev,
|
|
|
|
|
struct ieee80211_channel *chan,
|
|
|
|
|
const u8 *bssid, const u8 *prev_bssid,
|
|
|
|
|
const u8 *ssid, int ssid_len,
|
|
|
|
|
const u8 *ie, int ie_len, bool use_mfp,
|
|
|
|
|
struct cfg80211_crypto_settings *crypt);
|
2009-07-02 15:20:43 +00:00
|
|
|
int cfg80211_mlme_assoc(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct net_device *dev, struct ieee80211_channel *chan,
|
2009-07-07 12:37:26 +00:00
|
|
|
const u8 *bssid, const u8 *prev_bssid,
|
|
|
|
|
const u8 *ssid, int ssid_len,
|
2009-07-02 15:20:43 +00:00
|
|
|
const u8 *ie, int ie_len, bool use_mfp,
|
|
|
|
|
struct cfg80211_crypto_settings *crypt);
|
2009-07-07 01:56:11 +00:00
|
|
|
int __cfg80211_mlme_deauth(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct net_device *dev, const u8 *bssid,
|
2010-04-04 06:37:19 +00:00
|
|
|
const u8 *ie, int ie_len, u16 reason,
|
|
|
|
|
bool local_state_change);
|
2009-07-02 15:20:43 +00:00
|
|
|
int cfg80211_mlme_deauth(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct net_device *dev, const u8 *bssid,
|
2010-04-04 06:37:19 +00:00
|
|
|
const u8 *ie, int ie_len, u16 reason,
|
|
|
|
|
bool local_state_change);
|
2009-07-02 15:20:43 +00:00
|
|
|
int cfg80211_mlme_disassoc(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct net_device *dev, const u8 *bssid,
|
2010-04-04 06:37:19 +00:00
|
|
|
const u8 *ie, int ie_len, u16 reason,
|
|
|
|
|
bool local_state_change);
|
2009-07-02 15:20:43 +00:00
|
|
|
void cfg80211_mlme_down(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct net_device *dev);
|
2009-07-07 01:56:11 +00:00
|
|
|
void __cfg80211_connect_result(struct net_device *dev, const u8 *bssid,
|
|
|
|
|
const u8 *req_ie, size_t req_ie_len,
|
|
|
|
|
const u8 *resp_ie, size_t resp_ie_len,
|
2009-07-29 09:23:49 +00:00
|
|
|
u16 status, bool wextev,
|
|
|
|
|
struct cfg80211_bss *bss);
|
2010-08-12 13:38:38 +00:00
|
|
|
int cfg80211_mlme_register_mgmt(struct wireless_dev *wdev, u32 snd_pid,
|
|
|
|
|
u16 frame_type, const u8 *match_data,
|
|
|
|
|
int match_len);
|
|
|
|
|
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,
|
|
|
|
|
struct net_device *dev,
|
2010-11-25 09:02:29 +00:00
|
|
|
struct ieee80211_channel *chan, bool offchan,
|
2010-08-12 13:38:38 +00:00
|
|
|
enum nl80211_channel_type channel_type,
|
2010-11-25 09:02:29 +00:00
|
|
|
bool channel_type_valid, unsigned int wait,
|
2010-08-12 13:38:38 +00:00
|
|
|
const u8 *buf, size_t len, u64 *cookie);
|
2009-07-02 15:20:43 +00:00
|
|
|
|
2009-07-01 19:26:54 +00:00
|
|
|
/* SME */
|
2009-07-07 01:56:11 +00: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 12:22:54 +00:00
|
|
|
struct cfg80211_connect_params *connect,
|
2009-08-07 12:51:05 +00:00
|
|
|
struct cfg80211_cached_keys *connkeys,
|
|
|
|
|
const u8 *prev_bssid);
|
2009-07-01 19:26:54 +00: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 12:22:54 +00:00
|
|
|
struct cfg80211_connect_params *connect,
|
|
|
|
|
struct cfg80211_cached_keys *connkeys);
|
2009-07-07 01:56:11 +00:00
|
|
|
int __cfg80211_disconnect(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct net_device *dev, u16 reason,
|
|
|
|
|
bool wextev);
|
2009-07-01 19:26:54 +00:00
|
|
|
int cfg80211_disconnect(struct cfg80211_registered_device *rdev,
|
2009-07-01 19:26:56 +00:00
|
|
|
struct net_device *dev, u16 reason,
|
|
|
|
|
bool wextev);
|
2009-07-07 01:56:11 +00:00
|
|
|
void __cfg80211_roamed(struct wireless_dev *wdev, const u8 *bssid,
|
|
|
|
|
const u8 *req_ie, size_t req_ie_len,
|
|
|
|
|
const u8 *resp_ie, size_t resp_ie_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 12:22:54 +00:00
|
|
|
int cfg80211_mgd_wext_connect(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct wireless_dev *wdev);
|
2009-07-01 19:26:54 +00:00
|
|
|
|
2009-07-02 07:13:27 +00:00
|
|
|
void cfg80211_conn_work(struct work_struct *work);
|
2009-10-20 06:08:53 +00:00
|
|
|
void cfg80211_sme_failed_assoc(struct wireless_dev *wdev);
|
2009-08-07 12:51:05 +00:00
|
|
|
bool cfg80211_sme_failed_reassoc(struct wireless_dev *wdev);
|
2009-07-02 07:13:27 +00:00
|
|
|
|
2009-05-11 11:54:58 +00:00
|
|
|
/* internal helpers */
|
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 12:22:54 +00:00
|
|
|
int cfg80211_validate_key_settings(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct key_params *params, int key_idx,
|
2010-10-05 17:39:30 +00:00
|
|
|
bool pairwise, const u8 *mac_addr);
|
2009-07-07 01:56:11 +00:00
|
|
|
void __cfg80211_disconnected(struct net_device *dev, const u8 *ie,
|
2009-07-02 07:13:27 +00:00
|
|
|
size_t ie_len, u16 reason, bool from_ap);
|
|
|
|
|
void cfg80211_sme_scan_done(struct net_device *dev);
|
|
|
|
|
void cfg80211_sme_rx_auth(struct net_device *dev, const u8 *buf, size_t len);
|
2009-07-02 15:20:43 +00:00
|
|
|
void cfg80211_sme_disassoc(struct net_device *dev, int idx);
|
2009-07-07 01:56:11 +00:00
|
|
|
void __cfg80211_scan_done(struct work_struct *wk);
|
2009-08-20 19:36:16 +00:00
|
|
|
void ___cfg80211_scan_done(struct cfg80211_registered_device *rdev, bool leak);
|
2011-05-11 14:09:35 +00:00
|
|
|
void __cfg80211_sched_scan_results(struct work_struct *wk);
|
|
|
|
|
int __cfg80211_stop_sched_scan(struct cfg80211_registered_device *rdev,
|
|
|
|
|
bool driver_initiated);
|
|
|
|
|
void __cfg80211_sched_scan_stopped(struct work_struct *wk);
|
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 12:22:54 +00:00
|
|
|
void cfg80211_upload_connect_keys(struct wireless_dev *wdev);
|
2009-08-21 12:51:05 +00:00
|
|
|
int cfg80211_change_iface(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct net_device *dev, enum nl80211_iftype ntype,
|
|
|
|
|
u32 *flags, struct vif_params *params);
|
|
|
|
|
void cfg80211_process_rdev_events(struct cfg80211_registered_device *rdev);
|
2009-05-11 11:54:58 +00:00
|
|
|
|
2009-12-23 12:15:41 +00:00
|
|
|
struct ieee80211_channel *
|
|
|
|
|
rdev_freq_to_chan(struct cfg80211_registered_device *rdev,
|
|
|
|
|
int freq, enum nl80211_channel_type channel_type);
|
cfg80211/mac80211: better channel handling
Currently (all tested with hwsim) you can do stupid
things like setting up an AP on a certain channel,
then adding another virtual interface and making
that associate on another channel -- this will make
the beaconing to move channel but obviously without
the necessary IEs data update.
In order to improve this situation, first make the
configuration APIs (cfg80211 and nl80211) aware of
multi-channel operation -- we'll eventually need
that in the future anyway. There's one userland API
change and one API addition. The API change is that
now SET_WIPHY must be called with virtual interface
index rather than only wiphy index in order to take
effect for that interface -- luckily all current
users (hostapd) do that. For monitor interfaces, the
old setting is preserved, but monitors are always
slaved to other devices anyway so no guarantees.
The second userland API change is the introduction
of a per virtual interface SET_CHANNEL command, that
hostapd should use going forward to make it easier
to understand what's going on (it can automatically
detect a kernel with this command).
Other than mac80211, no existing cfg80211 drivers
are affected by this change because they only allow
a single virtual interface.
mac80211, however, now needs to be aware that the
channel settings are per interface now, and needs
to disallow (for now) real multi-channel operation,
which is another important part of this patch.
One of the immediate benefits is that you can now
start hostapd to operate on a hardware that already
has a connection on another virtual interface, as
long as you specify the same channel.
Note that two things are left unhandled (this is an
improvement -- not a complete fix):
* different HT/no-HT modes
currently you could start an HT AP and then
connect to a non-HT network on the same channel
which would configure the hardware for no HT;
that can be fixed fairly easily
* CSA
An AP we're connected to on a virtual interface
might indicate switching channels, and in that
case we would follow it, regardless of how many
other interfaces are operating; this requires
more effort to fix but is pretty rare after all
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2010-05-05 13:25:02 +00:00
|
|
|
int cfg80211_set_freq(struct cfg80211_registered_device *rdev,
|
|
|
|
|
struct wireless_dev *wdev, int freq,
|
|
|
|
|
enum nl80211_channel_type channel_type);
|
2009-08-07 15:22:35 +00:00
|
|
|
|
2009-12-09 21:43:52 +00:00
|
|
|
u16 cfg80211_calculate_bitrate(struct rate_info *rate);
|
|
|
|
|
|
2009-08-21 10:23:49 +00: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
|
|
|
|
|
|
2007-04-23 19:20:05 +00:00
|
|
|
#endif /* __NET_WIRELESS_CORE_H */
|