nl80211.c 366 KB
Newer Older
1 2 3
/*
 * This is the new netlink-based wireless configuration interface.
 *
4
 * Copyright 2006-2010	Johannes Berg <johannes@sipsolutions.net>
5
 * Copyright 2013-2014  Intel Mobile Communications GmbH
Beni Lev's avatar
Beni Lev committed
6
 * Copyright 2015-2016	Intel Deutschland GmbH
7 8 9 10 11
 */

#include <linux/if.h>
#include <linux/module.h>
#include <linux/err.h>
12
#include <linux/slab.h>
13 14 15 16 17 18
#include <linux/list.h>
#include <linux/if_ether.h>
#include <linux/ieee80211.h>
#include <linux/nl80211.h>
#include <linux/rtnetlink.h>
#include <linux/netlink.h>
19
#include <linux/etherdevice.h>
20
#include <net/net_namespace.h>
21 22
#include <net/genetlink.h>
#include <net/cfg80211.h>
23
#include <net/sock.h>
24
#include <net/inet_connection_sock.h>
25 26
#include "core.h"
#include "nl80211.h"
27
#include "reg.h"
28
#include "rdev-ops.h"
29

30 31 32 33 34
static int nl80211_crypto_settings(struct cfg80211_registered_device *rdev,
				   struct genl_info *info,
				   struct cfg80211_crypto_settings *settings,
				   int cipher_limit);

35
static int nl80211_pre_doit(const struct genl_ops *ops, struct sk_buff *skb,
36
			    struct genl_info *info);
37
static void nl80211_post_doit(const struct genl_ops *ops, struct sk_buff *skb,
38 39
			      struct genl_info *info);

40 41
/* the netlink family */
static struct genl_family nl80211_fam = {
42 43 44 45
	.id = GENL_ID_GENERATE,		/* don't bother with a hardcoded ID */
	.name = NL80211_GENL_NAME,	/* have users key off the name instead */
	.hdrsize = 0,			/* no private header */
	.version = 1,			/* no particular meaning now */
46
	.maxattr = NL80211_ATTR_MAX,
47
	.netnsok = true,
48 49
	.pre_doit = nl80211_pre_doit,
	.post_doit = nl80211_post_doit,
50 51
};

52 53 54 55 56 57
/* multicast groups */
enum nl80211_multicast_groups {
	NL80211_MCGRP_CONFIG,
	NL80211_MCGRP_SCAN,
	NL80211_MCGRP_REGULATORY,
	NL80211_MCGRP_MLME,
58
	NL80211_MCGRP_VENDOR,
59 60 61 62
	NL80211_MCGRP_TESTMODE /* keep last - ifdef! */
};

static const struct genl_multicast_group nl80211_mcgrps[] = {
63 64 65 66 67
	[NL80211_MCGRP_CONFIG] = { .name = NL80211_MULTICAST_GROUP_CONFIG },
	[NL80211_MCGRP_SCAN] = { .name = NL80211_MULTICAST_GROUP_SCAN },
	[NL80211_MCGRP_REGULATORY] = { .name = NL80211_MULTICAST_GROUP_REG },
	[NL80211_MCGRP_MLME] = { .name = NL80211_MULTICAST_GROUP_MLME },
	[NL80211_MCGRP_VENDOR] = { .name = NL80211_MULTICAST_GROUP_VENDOR },
68
#ifdef CONFIG_NL80211_TESTMODE
69
	[NL80211_MCGRP_TESTMODE] = { .name = NL80211_MULTICAST_GROUP_TESTMODE }
70 71 72
#endif
};

73 74 75
/* returns ERR_PTR values */
static struct wireless_dev *
__cfg80211_wdev_from_attrs(struct net *netns, struct nlattr **attrs)
76
{
77 78 79 80 81 82 83
	struct cfg80211_registered_device *rdev;
	struct wireless_dev *result = NULL;
	bool have_ifidx = attrs[NL80211_ATTR_IFINDEX];
	bool have_wdev_id = attrs[NL80211_ATTR_WDEV];
	u64 wdev_id;
	int wiphy_idx = -1;
	int ifidx = -1;
84

85
	ASSERT_RTNL();
86

87 88
	if (!have_ifidx && !have_wdev_id)
		return ERR_PTR(-EINVAL);
89

90 91 92 93 94
	if (have_ifidx)
		ifidx = nla_get_u32(attrs[NL80211_ATTR_IFINDEX]);
	if (have_wdev_id) {
		wdev_id = nla_get_u64(attrs[NL80211_ATTR_WDEV]);
		wiphy_idx = wdev_id >> 32;
95 96
	}

97 98 99 100 101 102 103 104 105
	list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
		struct wireless_dev *wdev;

		if (wiphy_net(&rdev->wiphy) != netns)
			continue;

		if (have_wdev_id && rdev->wiphy_idx != wiphy_idx)
			continue;

106
		list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124
			if (have_ifidx && wdev->netdev &&
			    wdev->netdev->ifindex == ifidx) {
				result = wdev;
				break;
			}
			if (have_wdev_id && wdev->identifier == (u32)wdev_id) {
				result = wdev;
				break;
			}
		}

		if (result)
			break;
	}

	if (result)
		return result;
	return ERR_PTR(-ENODEV);
125 126
}

127
static struct cfg80211_registered_device *
128
__cfg80211_rdev_from_attrs(struct net *netns, struct nlattr **attrs)
129
{
130 131
	struct cfg80211_registered_device *rdev = NULL, *tmp;
	struct net_device *netdev;
132

133
	ASSERT_RTNL();
134

135
	if (!attrs[NL80211_ATTR_WIPHY] &&
136 137
	    !attrs[NL80211_ATTR_IFINDEX] &&
	    !attrs[NL80211_ATTR_WDEV])
138 139
		return ERR_PTR(-EINVAL);

140
	if (attrs[NL80211_ATTR_WIPHY])
141
		rdev = cfg80211_rdev_by_wiphy_idx(
142
				nla_get_u32(attrs[NL80211_ATTR_WIPHY]));
143

144 145 146 147 148 149 150 151
	if (attrs[NL80211_ATTR_WDEV]) {
		u64 wdev_id = nla_get_u64(attrs[NL80211_ATTR_WDEV]);
		struct wireless_dev *wdev;
		bool found = false;

		tmp = cfg80211_rdev_by_wiphy_idx(wdev_id >> 32);
		if (tmp) {
			/* make sure wdev exists */
152
			list_for_each_entry(wdev, &tmp->wiphy.wdev_list, list) {
153 154 155 156 157 158 159 160 161 162 163 164 165 166 167
				if (wdev->identifier != (u32)wdev_id)
					continue;
				found = true;
				break;
			}

			if (!found)
				tmp = NULL;

			if (rdev && tmp != rdev)
				return ERR_PTR(-EINVAL);
			rdev = tmp;
		}
	}

168 169
	if (attrs[NL80211_ATTR_IFINDEX]) {
		int ifindex = nla_get_u32(attrs[NL80211_ATTR_IFINDEX]);
170

171
		netdev = __dev_get_by_index(netns, ifindex);
172 173
		if (netdev) {
			if (netdev->ieee80211_ptr)
174 175
				tmp = wiphy_to_rdev(
					netdev->ieee80211_ptr->wiphy);
176 177 178 179 180 181 182 183 184 185 186 187
			else
				tmp = NULL;

			/* not wireless device -- return error */
			if (!tmp)
				return ERR_PTR(-EINVAL);

			/* mismatch -- return error */
			if (rdev && tmp != rdev)
				return ERR_PTR(-EINVAL);

			rdev = tmp;
188 189 190
		}
	}

Johannes Berg's avatar
Johannes Berg committed
191 192
	if (!rdev)
		return ERR_PTR(-ENODEV);
193

Johannes Berg's avatar
Johannes Berg committed
194 195 196 197
	if (netns != wiphy_net(&rdev->wiphy))
		return ERR_PTR(-ENODEV);

	return rdev;
198 199 200 201 202 203 204 205 206 207
}

/*
 * This function returns a pointer to the driver
 * that the genl_info item that is passed refers to.
 *
 * The result of this can be a PTR_ERR and hence must
 * be checked with IS_ERR() for errors.
 */
static struct cfg80211_registered_device *
Johannes Berg's avatar
Johannes Berg committed
208
cfg80211_get_dev_from_info(struct net *netns, struct genl_info *info)
209
{
210
	return __cfg80211_rdev_from_attrs(netns, info->attrs);
211 212
}

213
/* policy for the attributes */
214
static const struct nla_policy nl80211_policy[NUM_NL80211_ATTR] = {
215 216
	[NL80211_ATTR_WIPHY] = { .type = NLA_U32 },
	[NL80211_ATTR_WIPHY_NAME] = { .type = NLA_NUL_STRING,
217
				      .len = 20-1 },
218
	[NL80211_ATTR_WIPHY_TXQ_PARAMS] = { .type = NLA_NESTED },
219

220
	[NL80211_ATTR_WIPHY_FREQ] = { .type = NLA_U32 },
Sujith's avatar
Sujith committed
221
	[NL80211_ATTR_WIPHY_CHANNEL_TYPE] = { .type = NLA_U32 },
222 223 224 225
	[NL80211_ATTR_CHANNEL_WIDTH] = { .type = NLA_U32 },
	[NL80211_ATTR_CENTER_FREQ1] = { .type = NLA_U32 },
	[NL80211_ATTR_CENTER_FREQ2] = { .type = NLA_U32 },

226 227 228 229
	[NL80211_ATTR_WIPHY_RETRY_SHORT] = { .type = NLA_U8 },
	[NL80211_ATTR_WIPHY_RETRY_LONG] = { .type = NLA_U8 },
	[NL80211_ATTR_WIPHY_FRAG_THRESHOLD] = { .type = NLA_U32 },
	[NL80211_ATTR_WIPHY_RTS_THRESHOLD] = { .type = NLA_U32 },
230
	[NL80211_ATTR_WIPHY_COVERAGE_CLASS] = { .type = NLA_U8 },
231
	[NL80211_ATTR_WIPHY_DYN_ACK] = { .type = NLA_FLAG },
232 233 234 235

	[NL80211_ATTR_IFTYPE] = { .type = NLA_U32 },
	[NL80211_ATTR_IFINDEX] = { .type = NLA_U32 },
	[NL80211_ATTR_IFNAME] = { .type = NLA_NUL_STRING, .len = IFNAMSIZ-1 },
236

237 238
	[NL80211_ATTR_MAC] = { .len = ETH_ALEN },
	[NL80211_ATTR_PREV_BSSID] = { .len = ETH_ALEN },
239

240
	[NL80211_ATTR_KEY] = { .type = NLA_NESTED, },
241 242 243 244 245
	[NL80211_ATTR_KEY_DATA] = { .type = NLA_BINARY,
				    .len = WLAN_MAX_KEY_LEN },
	[NL80211_ATTR_KEY_IDX] = { .type = NLA_U8 },
	[NL80211_ATTR_KEY_CIPHER] = { .type = NLA_U32 },
	[NL80211_ATTR_KEY_DEFAULT] = { .type = NLA_FLAG },
246
	[NL80211_ATTR_KEY_SEQ] = { .type = NLA_BINARY, .len = 16 },
247
	[NL80211_ATTR_KEY_TYPE] = { .type = NLA_U32 },
248 249 250 251 252 253 254

	[NL80211_ATTR_BEACON_INTERVAL] = { .type = NLA_U32 },
	[NL80211_ATTR_DTIM_PERIOD] = { .type = NLA_U32 },
	[NL80211_ATTR_BEACON_HEAD] = { .type = NLA_BINARY,
				       .len = IEEE80211_MAX_DATA_LEN },
	[NL80211_ATTR_BEACON_TAIL] = { .type = NLA_BINARY,
				       .len = IEEE80211_MAX_DATA_LEN },
255 256 257 258 259
	[NL80211_ATTR_STA_AID] = { .type = NLA_U16 },
	[NL80211_ATTR_STA_FLAGS] = { .type = NLA_NESTED },
	[NL80211_ATTR_STA_LISTEN_INTERVAL] = { .type = NLA_U16 },
	[NL80211_ATTR_STA_SUPPORTED_RATES] = { .type = NLA_BINARY,
					       .len = NL80211_MAX_SUPP_RATES },
260
	[NL80211_ATTR_STA_PLINK_ACTION] = { .type = NLA_U8 },
261
	[NL80211_ATTR_STA_VLAN] = { .type = NLA_U32 },
Johannes Berg's avatar
Johannes Berg committed
262
	[NL80211_ATTR_MNTR_FLAGS] = { /* NLA_NESTED can't be empty */ },
263
	[NL80211_ATTR_MESH_ID] = { .type = NLA_BINARY,
264
				   .len = IEEE80211_MAX_MESH_ID_LEN },
265
	[NL80211_ATTR_MPATH_NEXT_HOP] = { .type = NLA_U32 },
266

267 268 269
	[NL80211_ATTR_REG_ALPHA2] = { .type = NLA_STRING, .len = 2 },
	[NL80211_ATTR_REG_RULES] = { .type = NLA_NESTED },

270 271 272
	[NL80211_ATTR_BSS_CTS_PROT] = { .type = NLA_U8 },
	[NL80211_ATTR_BSS_SHORT_PREAMBLE] = { .type = NLA_U8 },
	[NL80211_ATTR_BSS_SHORT_SLOT_TIME] = { .type = NLA_U8 },
273 274
	[NL80211_ATTR_BSS_BASIC_RATES] = { .type = NLA_BINARY,
					   .len = NL80211_MAX_SUPP_RATES },
275
	[NL80211_ATTR_BSS_HT_OPMODE] = { .type = NLA_U16 },
276

277
	[NL80211_ATTR_MESH_CONFIG] = { .type = NLA_NESTED },
278
	[NL80211_ATTR_SUPPORT_MESH_AUTH] = { .type = NLA_FLAG },
279

280
	[NL80211_ATTR_HT_CAPABILITY] = { .len = NL80211_HT_CAPABILITY_LEN },
281 282 283 284

	[NL80211_ATTR_MGMT_SUBTYPE] = { .type = NLA_U8 },
	[NL80211_ATTR_IE] = { .type = NLA_BINARY,
			      .len = IEEE80211_MAX_DATA_LEN },
285 286
	[NL80211_ATTR_SCAN_FREQUENCIES] = { .type = NLA_NESTED },
	[NL80211_ATTR_SCAN_SSIDS] = { .type = NLA_NESTED },
287 288 289 290 291

	[NL80211_ATTR_SSID] = { .type = NLA_BINARY,
				.len = IEEE80211_MAX_SSID_LEN },
	[NL80211_ATTR_AUTH_TYPE] = { .type = NLA_U32 },
	[NL80211_ATTR_REASON_CODE] = { .type = NLA_U16 },
Johannes Berg's avatar
Johannes Berg committed
292
	[NL80211_ATTR_FREQ_FIXED] = { .type = NLA_FLAG },
293
	[NL80211_ATTR_TIMED_OUT] = { .type = NLA_FLAG },
294
	[NL80211_ATTR_USE_MFP] = { .type = NLA_U32 },
295 296 297
	[NL80211_ATTR_STA_FLAGS2] = {
		.len = sizeof(struct nl80211_sta_flag_update),
	},
298
	[NL80211_ATTR_CONTROL_PORT] = { .type = NLA_FLAG },
299 300
	[NL80211_ATTR_CONTROL_PORT_ETHERTYPE] = { .type = NLA_U16 },
	[NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT] = { .type = NLA_FLAG },
301 302 303
	[NL80211_ATTR_PRIVACY] = { .type = NLA_FLAG },
	[NL80211_ATTR_CIPHER_SUITE_GROUP] = { .type = NLA_U32 },
	[NL80211_ATTR_WPA_VERSIONS] = { .type = NLA_U32 },
304
	[NL80211_ATTR_PID] = { .type = NLA_U32 },
305
	[NL80211_ATTR_4ADDR] = { .type = NLA_U8 },
Samuel Ortiz's avatar
Samuel Ortiz committed
306 307
	[NL80211_ATTR_PMKID] = { .type = NLA_BINARY,
				 .len = WLAN_PMKID_LEN },
308 309
	[NL80211_ATTR_DURATION] = { .type = NLA_U32 },
	[NL80211_ATTR_COOKIE] = { .type = NLA_U64 },
310
	[NL80211_ATTR_TX_RATES] = { .type = NLA_NESTED },
311 312 313
	[NL80211_ATTR_FRAME] = { .type = NLA_BINARY,
				 .len = IEEE80211_MAX_DATA_LEN },
	[NL80211_ATTR_FRAME_MATCH] = { .type = NLA_BINARY, },
Kalle Valo's avatar
Kalle Valo committed
314
	[NL80211_ATTR_PS_STATE] = { .type = NLA_U32 },
315
	[NL80211_ATTR_CQM] = { .type = NLA_NESTED, },
316
	[NL80211_ATTR_LOCAL_STATE_CHANGE] = { .type = NLA_FLAG },
317
	[NL80211_ATTR_AP_ISOLATE] = { .type = NLA_U8 },
318 319
	[NL80211_ATTR_WIPHY_TX_POWER_SETTING] = { .type = NLA_U32 },
	[NL80211_ATTR_WIPHY_TX_POWER_LEVEL] = { .type = NLA_U32 },
320
	[NL80211_ATTR_FRAME_TYPE] = { .type = NLA_U16 },
321 322
	[NL80211_ATTR_WIPHY_ANTENNA_TX] = { .type = NLA_U32 },
	[NL80211_ATTR_WIPHY_ANTENNA_RX] = { .type = NLA_U32 },
323
	[NL80211_ATTR_MCAST_RATE] = { .type = NLA_U32 },
324
	[NL80211_ATTR_OFFCHANNEL_TX_OK] = { .type = NLA_FLAG },
325
	[NL80211_ATTR_KEY_DEFAULT_TYPES] = { .type = NLA_NESTED },
326
	[NL80211_ATTR_WOWLAN_TRIGGERS] = { .type = NLA_NESTED },
327
	[NL80211_ATTR_STA_PLINK_STATE] = { .type = NLA_U8 },
328
	[NL80211_ATTR_SCHED_SCAN_INTERVAL] = { .type = NLA_U32 },
329
	[NL80211_ATTR_REKEY_DATA] = { .type = NLA_NESTED },
330
	[NL80211_ATTR_SCAN_SUPP_RATES] = { .type = NLA_NESTED },
331
	[NL80211_ATTR_HIDDEN_SSID] = { .type = NLA_U32 },
332 333 334 335
	[NL80211_ATTR_IE_PROBE_RESP] = { .type = NLA_BINARY,
					 .len = IEEE80211_MAX_DATA_LEN },
	[NL80211_ATTR_IE_ASSOC_RESP] = { .type = NLA_BINARY,
					 .len = IEEE80211_MAX_DATA_LEN },
336
	[NL80211_ATTR_ROAM_SUPPORT] = { .type = NLA_FLAG },
337
	[NL80211_ATTR_SCHED_SCAN_MATCH] = { .type = NLA_NESTED },
338
	[NL80211_ATTR_TX_NO_CCK_RATE] = { .type = NLA_FLAG },
339 340 341 342 343
	[NL80211_ATTR_TDLS_ACTION] = { .type = NLA_U8 },
	[NL80211_ATTR_TDLS_DIALOG_TOKEN] = { .type = NLA_U8 },
	[NL80211_ATTR_TDLS_OPERATION] = { .type = NLA_U8 },
	[NL80211_ATTR_TDLS_SUPPORT] = { .type = NLA_FLAG },
	[NL80211_ATTR_TDLS_EXTERNAL_SETUP] = { .type = NLA_FLAG },
344
	[NL80211_ATTR_TDLS_INITIATOR] = { .type = NLA_FLAG },
345
	[NL80211_ATTR_DONT_WAIT_FOR_ACK] = { .type = NLA_FLAG },
346 347
	[NL80211_ATTR_PROBE_RESP] = { .type = NLA_BINARY,
				      .len = IEEE80211_MAX_DATA_LEN },
348
	[NL80211_ATTR_DFS_REGION] = { .type = NLA_U8 },
349 350 351 352
	[NL80211_ATTR_DISABLE_HT] = { .type = NLA_FLAG },
	[NL80211_ATTR_HT_CAPABILITY_MASK] = {
		.len = NL80211_HT_CAPABILITY_LEN
	},
353
	[NL80211_ATTR_NOACK_MAP] = { .type = NLA_U16 },
354
	[NL80211_ATTR_INACTIVITY_TIMEOUT] = { .type = NLA_U16 },
355
	[NL80211_ATTR_BG_SCAN_PERIOD] = { .type = NLA_U16 },
356
	[NL80211_ATTR_WDEV] = { .type = NLA_U64 },
357
	[NL80211_ATTR_USER_REG_HINT_TYPE] = { .type = NLA_U32 },
358
	[NL80211_ATTR_SAE_DATA] = { .type = NLA_BINARY, },
359
	[NL80211_ATTR_VHT_CAPABILITY] = { .len = NL80211_VHT_CAPABILITY_LEN },
360
	[NL80211_ATTR_SCAN_FLAGS] = { .type = NLA_U32 },
361 362
	[NL80211_ATTR_P2P_CTWINDOW] = { .type = NLA_U8 },
	[NL80211_ATTR_P2P_OPPPS] = { .type = NLA_U8 },
363 364
	[NL80211_ATTR_ACL_POLICY] = {. type = NLA_U32 },
	[NL80211_ATTR_MAC_ADDRS] = { .type = NLA_NESTED },
365 366
	[NL80211_ATTR_STA_CAPABILITY] = { .type = NLA_U16 },
	[NL80211_ATTR_STA_EXT_CAPABILITY] = { .type = NLA_BINARY, },
367
	[NL80211_ATTR_SPLIT_WIPHY_DUMP] = { .type = NLA_FLAG, },
368 369 370 371
	[NL80211_ATTR_DISABLE_VHT] = { .type = NLA_FLAG },
	[NL80211_ATTR_VHT_CAPABILITY_MASK] = {
		.len = NL80211_VHT_CAPABILITY_LEN,
	},
372 373 374
	[NL80211_ATTR_MDID] = { .type = NLA_U16 },
	[NL80211_ATTR_IE_RIC] = { .type = NLA_BINARY,
				  .len = IEEE80211_MAX_DATA_LEN },
375
	[NL80211_ATTR_PEER_AID] = { .type = NLA_U16 },
376 377 378
	[NL80211_ATTR_CH_SWITCH_COUNT] = { .type = NLA_U32 },
	[NL80211_ATTR_CH_SWITCH_BLOCK_TX] = { .type = NLA_FLAG },
	[NL80211_ATTR_CSA_IES] = { .type = NLA_NESTED },
379 380
	[NL80211_ATTR_CSA_C_OFF_BEACON] = { .type = NLA_BINARY },
	[NL80211_ATTR_CSA_C_OFF_PRESP] = { .type = NLA_BINARY },
381 382
	[NL80211_ATTR_STA_SUPPORTED_CHANNELS] = { .type = NLA_BINARY },
	[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES] = { .type = NLA_BINARY },
383
	[NL80211_ATTR_HANDLE_DFS] = { .type = NLA_FLAG },
384
	[NL80211_ATTR_OPMODE_NOTIF] = { .type = NLA_U8 },
385 386 387
	[NL80211_ATTR_VENDOR_ID] = { .type = NLA_U32 },
	[NL80211_ATTR_VENDOR_SUBCMD] = { .type = NLA_U32 },
	[NL80211_ATTR_VENDOR_DATA] = { .type = NLA_BINARY },
388 389
	[NL80211_ATTR_QOS_MAP] = { .type = NLA_BINARY,
				   .len = IEEE80211_QOS_MAP_LEN_MAX },
390 391
	[NL80211_ATTR_MAC_HINT] = { .len = ETH_ALEN },
	[NL80211_ATTR_WIPHY_FREQ_HINT] = { .type = NLA_U32 },
392
	[NL80211_ATTR_TDLS_PEER_CAPABILITY] = { .type = NLA_U32 },
393
	[NL80211_ATTR_SOCKET_OWNER] = { .type = NLA_FLAG },
394
	[NL80211_ATTR_CSA_C_OFFSETS_TX] = { .type = NLA_BINARY },
395
	[NL80211_ATTR_USE_RRM] = { .type = NLA_FLAG },
396 397 398
	[NL80211_ATTR_TSID] = { .type = NLA_U8 },
	[NL80211_ATTR_USER_PRIO] = { .type = NLA_U8 },
	[NL80211_ATTR_ADMITTED_TIME] = { .type = NLA_U16 },
399
	[NL80211_ATTR_SMPS_MODE] = { .type = NLA_U8 },
400
	[NL80211_ATTR_MAC_MASK] = { .len = ETH_ALEN },
401
	[NL80211_ATTR_WIPHY_SELF_MANAGED_REG] = { .type = NLA_FLAG },
402
	[NL80211_ATTR_NETNS_FD] = { .type = NLA_U32 },
403
	[NL80211_ATTR_SCHED_SCAN_DELAY] = { .type = NLA_U32 },
404
	[NL80211_ATTR_REG_INDOOR] = { .type = NLA_FLAG },
405
	[NL80211_ATTR_PBSS] = { .type = NLA_FLAG },
406
	[NL80211_ATTR_BSS_SELECT] = { .type = NLA_NESTED },
407
	[NL80211_ATTR_STA_SUPPORT_P2P_PS] = { .type = NLA_U8 },
408 409 410 411
	[NL80211_ATTR_MU_MIMO_GROUP_DATA] = {
		.len = VHT_MUMIMO_GROUPS_DATA_LEN
	},
	[NL80211_ATTR_MU_MIMO_FOLLOW_MAC_ADDR] = { .len = ETH_ALEN },
412 413
};

414
/* policy for the key attributes */
Alexey Dobriyan's avatar
Alexey Dobriyan committed
415
static const struct nla_policy nl80211_key_policy[NL80211_KEY_MAX + 1] = {
Johannes Berg's avatar
Johannes Berg committed
416
	[NL80211_KEY_DATA] = { .type = NLA_BINARY, .len = WLAN_MAX_KEY_LEN },
417 418
	[NL80211_KEY_IDX] = { .type = NLA_U8 },
	[NL80211_KEY_CIPHER] = { .type = NLA_U32 },
419
	[NL80211_KEY_SEQ] = { .type = NLA_BINARY, .len = 16 },
420 421
	[NL80211_KEY_DEFAULT] = { .type = NLA_FLAG },
	[NL80211_KEY_DEFAULT_MGMT] = { .type = NLA_FLAG },
422
	[NL80211_KEY_TYPE] = { .type = NLA_U32 },
423 424 425 426 427 428 429 430
	[NL80211_KEY_DEFAULT_TYPES] = { .type = NLA_NESTED },
};

/* policy for the key default flags */
static const struct nla_policy
nl80211_key_default_policy[NUM_NL80211_KEY_DEFAULT_TYPES] = {
	[NL80211_KEY_DEFAULT_TYPE_UNICAST] = { .type = NLA_FLAG },
	[NL80211_KEY_DEFAULT_TYPE_MULTICAST] = { .type = NLA_FLAG },
431 432
};

433 434 435 436 437 438 439
/* policy for WoWLAN attributes */
static const struct nla_policy
nl80211_wowlan_policy[NUM_NL80211_WOWLAN_TRIG] = {
	[NL80211_WOWLAN_TRIG_ANY] = { .type = NLA_FLAG },
	[NL80211_WOWLAN_TRIG_DISCONNECT] = { .type = NLA_FLAG },
	[NL80211_WOWLAN_TRIG_MAGIC_PKT] = { .type = NLA_FLAG },
	[NL80211_WOWLAN_TRIG_PKT_PATTERN] = { .type = NLA_NESTED },
440 441 442 443
	[NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE] = { .type = NLA_FLAG },
	[NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST] = { .type = NLA_FLAG },
	[NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE] = { .type = NLA_FLAG },
	[NL80211_WOWLAN_TRIG_RFKILL_RELEASE] = { .type = NLA_FLAG },
444
	[NL80211_WOWLAN_TRIG_TCP_CONNECTION] = { .type = NLA_NESTED },
445
	[NL80211_WOWLAN_TRIG_NET_DETECT] = { .type = NLA_NESTED },
446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464
};

static const struct nla_policy
nl80211_wowlan_tcp_policy[NUM_NL80211_WOWLAN_TCP] = {
	[NL80211_WOWLAN_TCP_SRC_IPV4] = { .type = NLA_U32 },
	[NL80211_WOWLAN_TCP_DST_IPV4] = { .type = NLA_U32 },
	[NL80211_WOWLAN_TCP_DST_MAC] = { .len = ETH_ALEN },
	[NL80211_WOWLAN_TCP_SRC_PORT] = { .type = NLA_U16 },
	[NL80211_WOWLAN_TCP_DST_PORT] = { .type = NLA_U16 },
	[NL80211_WOWLAN_TCP_DATA_PAYLOAD] = { .len = 1 },
	[NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ] = {
		.len = sizeof(struct nl80211_wowlan_tcp_data_seq)
	},
	[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN] = {
		.len = sizeof(struct nl80211_wowlan_tcp_data_token)
	},
	[NL80211_WOWLAN_TCP_DATA_INTERVAL] = { .type = NLA_U32 },
	[NL80211_WOWLAN_TCP_WAKE_PAYLOAD] = { .len = 1 },
	[NL80211_WOWLAN_TCP_WAKE_MASK] = { .len = 1 },
465 466
};

467 468 469 470 471 472 473 474
/* policy for coalesce rule attributes */
static const struct nla_policy
nl80211_coalesce_policy[NUM_NL80211_ATTR_COALESCE_RULE] = {
	[NL80211_ATTR_COALESCE_RULE_DELAY] = { .type = NLA_U32 },
	[NL80211_ATTR_COALESCE_RULE_CONDITION] = { .type = NLA_U32 },
	[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN] = { .type = NLA_NESTED },
};

475 476 477 478 479 480 481 482
/* policy for GTK rekey offload attributes */
static const struct nla_policy
nl80211_rekey_policy[NUM_NL80211_REKEY_DATA] = {
	[NL80211_REKEY_DATA_KEK] = { .len = NL80211_KEK_LEN },
	[NL80211_REKEY_DATA_KCK] = { .len = NL80211_KCK_LEN },
	[NL80211_REKEY_DATA_REPLAY_CTR] = { .len = NL80211_REPLAY_CTR_LEN },
};

483 484
static const struct nla_policy
nl80211_match_policy[NL80211_SCHED_SCAN_MATCH_ATTR_MAX + 1] = {
485
	[NL80211_SCHED_SCAN_MATCH_ATTR_SSID] = { .type = NLA_BINARY,
486
						 .len = IEEE80211_MAX_SSID_LEN },
487
	[NL80211_SCHED_SCAN_MATCH_ATTR_RSSI] = { .type = NLA_U32 },
488 489
};

490 491 492 493 494 495
static const struct nla_policy
nl80211_plan_policy[NL80211_SCHED_SCAN_PLAN_MAX + 1] = {
	[NL80211_SCHED_SCAN_PLAN_INTERVAL] = { .type = NLA_U32 },
	[NL80211_SCHED_SCAN_PLAN_ITERATIONS] = { .type = NLA_U32 },
};

496 497 498 499 500 501 502 503 504
static const struct nla_policy
nl80211_bss_select_policy[NL80211_BSS_SELECT_ATTR_MAX + 1] = {
	[NL80211_BSS_SELECT_ATTR_RSSI] = { .type = NLA_FLAG },
	[NL80211_BSS_SELECT_ATTR_BAND_PREF] = { .type = NLA_U32 },
	[NL80211_BSS_SELECT_ATTR_RSSI_ADJUST] = {
		.len = sizeof(struct nl80211_bss_select_rssi_adjust)
	},
};

505 506 507 508
static int nl80211_prepare_wdev_dump(struct sk_buff *skb,
				     struct netlink_callback *cb,
				     struct cfg80211_registered_device **rdev,
				     struct wireless_dev **wdev)
509
{
510
	int err;
511

512
	rtnl_lock();
513

514 515 516 517 518 519
	if (!cb->args[0]) {
		err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
				  nl80211_fam.attrbuf, nl80211_fam.maxattr,
				  nl80211_policy);
		if (err)
			goto out_unlock;
520

521 522 523 524 525 526
		*wdev = __cfg80211_wdev_from_attrs(sock_net(skb->sk),
						   nl80211_fam.attrbuf);
		if (IS_ERR(*wdev)) {
			err = PTR_ERR(*wdev);
			goto out_unlock;
		}
527
		*rdev = wiphy_to_rdev((*wdev)->wiphy);
528 529
		/* 0 is the first index - add 1 to parse only once */
		cb->args[0] = (*rdev)->wiphy_idx + 1;
530 531
		cb->args[1] = (*wdev)->identifier;
	} else {
532 533
		/* subtract the 1 again here */
		struct wiphy *wiphy = wiphy_idx_to_wiphy(cb->args[0] - 1);
534
		struct wireless_dev *tmp;
535

536 537 538 539
		if (!wiphy) {
			err = -ENODEV;
			goto out_unlock;
		}
540
		*rdev = wiphy_to_rdev(wiphy);
541
		*wdev = NULL;
542

543
		list_for_each_entry(tmp, &(*rdev)->wiphy.wdev_list, list) {
544 545 546 547 548
			if (tmp->identifier == cb->args[1]) {
				*wdev = tmp;
				break;
			}
		}
549

550 551 552 553
		if (!*wdev) {
			err = -ENODEV;
			goto out_unlock;
		}
554 555 556
	}

	return 0;
557
 out_unlock:
558 559 560 561
	rtnl_unlock();
	return err;
}

562
static void nl80211_finish_wdev_dump(struct cfg80211_registered_device *rdev)
563 564 565 566
{
	rtnl_unlock();
}

567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596
/* IE validation */
static bool is_valid_ie_attr(const struct nlattr *attr)
{
	const u8 *pos;
	int len;

	if (!attr)
		return true;

	pos = nla_data(attr);
	len = nla_len(attr);

	while (len) {
		u8 elemlen;

		if (len < 2)
			return false;
		len -= 2;

		elemlen = pos[1];
		if (elemlen > len)
			return false;

		len -= elemlen;
		pos += 2 + elemlen;
	}

	return true;
}

597
/* message building helper */
598
static inline void *nl80211hdr_put(struct sk_buff *skb, u32 portid, u32 seq,
599 600 601
				   int flags, u8 cmd)
{
	/* since there is no private header just add the generic one */
602
	return genlmsg_put(skb, portid, seq, &nl80211_fam, flags, cmd);
603 604
}

605
static int nl80211_msg_put_channel(struct sk_buff *msg,
606 607
				   struct ieee80211_channel *chan,
				   bool large)
608
{
609 610 611 612 613 614 615
	/* Some channels must be completely excluded from the
	 * list to protect old user-space tools from breaking
	 */
	if (!large && chan->flags &
	    (IEEE80211_CHAN_NO_10MHZ | IEEE80211_CHAN_NO_20MHZ))
		return 0;

616 617 618
	if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_FREQ,
			chan->center_freq))
		goto nla_put_failure;
619

620 621 622
	if ((chan->flags & IEEE80211_CHAN_DISABLED) &&
	    nla_put_flag(msg, NL80211_FREQUENCY_ATTR_DISABLED))
		goto nla_put_failure;
623 624 625 626 627 628
	if (chan->flags & IEEE80211_CHAN_NO_IR) {
		if (nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_IR))
			goto nla_put_failure;
		if (nla_put_flag(msg, __NL80211_FREQUENCY_ATTR_NO_IBSS))
			goto nla_put_failure;
	}
629 630 631 632 633 634 635 636 637 638 639 640 641 642
	if (chan->flags & IEEE80211_CHAN_RADAR) {
		if (nla_put_flag(msg, NL80211_FREQUENCY_ATTR_RADAR))
			goto nla_put_failure;
		if (large) {
			u32 time;

			time = elapsed_jiffies_msecs(chan->dfs_state_entered);

			if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_DFS_STATE,
					chan->dfs_state))
				goto nla_put_failure;
			if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_DFS_TIME,
					time))
				goto nla_put_failure;
643 644 645 646
			if (nla_put_u32(msg,
					NL80211_FREQUENCY_ATTR_DFS_CAC_TIME,
					chan->dfs_cac_ms))
				goto nla_put_failure;
647 648
		}
	}
649

650 651 652 653 654 655 656 657 658 659 660 661 662
	if (large) {
		if ((chan->flags & IEEE80211_CHAN_NO_HT40MINUS) &&
		    nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_HT40_MINUS))
			goto nla_put_failure;
		if ((chan->flags & IEEE80211_CHAN_NO_HT40PLUS) &&
		    nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_HT40_PLUS))
			goto nla_put_failure;
		if ((chan->flags & IEEE80211_CHAN_NO_80MHZ) &&
		    nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_80MHZ))
			goto nla_put_failure;
		if ((chan->flags & IEEE80211_CHAN_NO_160MHZ) &&
		    nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_160MHZ))
			goto nla_put_failure;
663 664 665
		if ((chan->flags & IEEE80211_CHAN_INDOOR_ONLY) &&
		    nla_put_flag(msg, NL80211_FREQUENCY_ATTR_INDOOR_ONLY))
			goto nla_put_failure;
666 667
		if ((chan->flags & IEEE80211_CHAN_IR_CONCURRENT) &&
		    nla_put_flag(msg, NL80211_FREQUENCY_ATTR_IR_CONCURRENT))
668
			goto nla_put_failure;
669 670 671 672 673 674
		if ((chan->flags & IEEE80211_CHAN_NO_20MHZ) &&
		    nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_20MHZ))
			goto nla_put_failure;
		if ((chan->flags & IEEE80211_CHAN_NO_10MHZ) &&
		    nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_10MHZ))
			goto nla_put_failure;
675 676
	}

677 678 679
	if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_MAX_TX_POWER,
			DBM_TO_MBM(chan->max_power)))
		goto nla_put_failure;
680 681 682 683 684 685 686

	return 0;

 nla_put_failure:
	return -ENOBUFS;
}

687 688
/* netlink command implementations */

689 690 691
struct key_parse {
	struct key_params p;
	int idx;
692
	int type;
693
	bool def, defmgmt;
694
	bool def_uni, def_multi;
695 696 697 698 699 700 701 702 703 704 705 706 707
};

static int nl80211_parse_key_new(struct nlattr *key, struct key_parse *k)
{
	struct nlattr *tb[NL80211_KEY_MAX + 1];
	int err = nla_parse_nested(tb, NL80211_KEY_MAX, key,
				   nl80211_key_policy);
	if (err)
		return err;

	k->def = !!tb[NL80211_KEY_DEFAULT];
	k->defmgmt = !!tb[NL80211_KEY_DEFAULT_MGMT];

708 709 710 711 712 713 714
	if (k->def) {
		k->def_uni = true;
		k->def_multi = true;
	}
	if (k->defmgmt)
		k->def_multi = true;

715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730
	if (tb[NL80211_KEY_IDX])
		k->idx = nla_get_u8(tb[NL80211_KEY_IDX]);

	if (tb[NL80211_KEY_DATA]) {
		k->p.key = nla_data(tb[NL80211_KEY_DATA]);
		k->p.key_len = nla_len(tb[NL80211_KEY_DATA]);
	}

	if (tb[NL80211_KEY_SEQ]) {
		k->p.seq = nla_data(tb[NL80211_KEY_SEQ]);
		k->p.seq_len = nla_len(tb[NL80211_KEY_SEQ]);
	}

	if (tb[NL80211_KEY_CIPHER])
		k->p.cipher = nla_get_u32(tb[NL80211_KEY_CIPHER]);

731 732 733 734 735 736
	if (tb[NL80211_KEY_TYPE]) {
		k->type = nla_get_u32(tb[NL80211_KEY_TYPE]);
		if (k->type < 0 || k->type >= NUM_NL80211_KEYTYPES)
			return -EINVAL;
	}

737 738
	if (tb[NL80211_KEY_DEFAULT_TYPES]) {
		struct nlattr *kdt[NUM_NL80211_KEY_DEFAULT_TYPES];
739

740 741 742
		err = nla_parse_nested(kdt, NUM_NL80211_KEY_DEFAULT_TYPES - 1,
				       tb[NL80211_KEY_DEFAULT_TYPES],
				       nl80211_key_default_policy);
743 744 745 746 747 748 749
		if (err)
			return err;

		k->def_uni = kdt[NL80211_KEY_DEFAULT_TYPE_UNICAST];
		k->def_multi = kdt[NL80211_KEY_DEFAULT_TYPE_MULTICAST];
	}

750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773
	return 0;
}

static int nl80211_parse_key_old(struct genl_info *info, struct key_parse *k)
{
	if (info->attrs[NL80211_ATTR_KEY_DATA]) {
		k->p.key = nla_data(info->attrs[NL80211_ATTR_KEY_DATA]);
		k->p.key_len = nla_len(info->attrs[NL80211_ATTR_KEY_DATA]);
	}

	if (info->attrs[NL80211_ATTR_KEY_SEQ]) {
		k->p.seq = nla_data(info->attrs[NL80211_ATTR_KEY_SEQ]);
		k->p.seq_len = nla_len(info->attrs[NL80211_ATTR_KEY_SEQ]);
	}

	if (info->attrs[NL80211_ATTR_KEY_IDX])
		k->idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);

	if (info->attrs[NL80211_ATTR_KEY_CIPHER])
		k->p.cipher = nla_get_u32(info->attrs[NL80211_ATTR_KEY_CIPHER]);

	k->def = !!info->attrs[NL80211_ATTR_KEY_DEFAULT];
	k->defmgmt = !!info->attrs[NL80211_ATTR_KEY_DEFAULT_MGMT];

774 775 776 777 778 779 780
	if (k->def) {
		k->def_uni = true;
		k->def_multi = true;
	}
	if (k->defmgmt)
		k->def_multi = true;

781 782 783 784 785 786
	if (info->attrs[NL80211_ATTR_KEY_TYPE]) {
		k->type = nla_get_u32(info->attrs[NL80211_ATTR_KEY_TYPE]);
		if (k->type < 0 || k->type >= NUM_NL80211_KEYTYPES)
			return -EINVAL;
	}

787 788 789 790 791 792 793 794 795 796 797 798 799
	if (info->attrs[NL80211_ATTR_KEY_DEFAULT_TYPES]) {
		struct nlattr *kdt[NUM_NL80211_KEY_DEFAULT_TYPES];
		int err = nla_parse_nested(
				kdt, NUM_NL80211_KEY_DEFAULT_TYPES - 1,
				info->attrs[NL80211_ATTR_KEY_DEFAULT_TYPES],
				nl80211_key_default_policy);
		if (err)
			return err;

		k->def_uni = kdt[NL80211_KEY_DEFAULT_TYPE_UNICAST];
		k->def_multi = kdt[NL80211_KEY_DEFAULT_TYPE_MULTICAST];
	}

800 801 802 803 804 805 806 807 808
	return 0;
}

static int nl80211_parse_key(struct genl_info *info, struct key_parse *k)
{
	int err;

	memset(k, 0, sizeof(*k));
	k->idx = -1;
809
	k->type = -1;
810 811 812 813 814 815 816 817 818 819 820 821

	if (info->attrs[NL80211_ATTR_KEY])
		err = nl80211_parse_key_new(info->attrs[NL80211_ATTR_KEY], k);
	else
		err = nl80211_parse_key_old(info, k);

	if (err)
		return err;

	if (k->def && k->defmgmt)
		return -EINVAL;

822 823 824 825 826
	if (k->defmgmt) {
		if (k->def_uni || !k->def_multi)
			return -EINVAL;
	}

827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842
	if (k->idx != -1) {
		if (k->defmgmt) {
			if (k->idx < 4 || k->idx > 5)
				return -EINVAL;
		} else if (k->def) {
			if (k->idx < 0 || k->idx > 3)
				return -EINVAL;
		} else {
			if (k->idx < 0 || k->idx > 5)
				return -EINVAL;
		}
	}

	return 0;
}

Johannes Berg's avatar
Johannes Berg committed
843 844
static struct cfg80211_cached_keys *
nl80211_parse_connkeys(struct cfg80211_registered_device *rdev,
845
		       struct nlattr *keys, bool *no_ht)
Johannes Berg's avatar
Johannes Berg committed
846 847 848 849 850
{
	struct key_parse parse;
	struct nlattr *key;
	struct cfg80211_cached_keys *result;
	int rem, err, def = 0;
851 852 853 854 855 856 857 858 859
	bool have_key = false;

	nla_for_each_nested(key, keys, rem) {
		have_key = true;
		break;
	}

	if (!have_key)
		return NULL;
Johannes Berg's avatar
Johannes Berg committed
860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876

	result = kzalloc(sizeof(*result), GFP_KERNEL);
	if (!result)
		return ERR_PTR(-ENOMEM);

	result->def = -1;

	nla_for_each_nested(key, keys, rem) {
		memset(&parse, 0, sizeof(parse));
		parse.idx = -1;

		err = nl80211_parse_key_new(key, &parse);
		if (err)
			goto error;
		err = -EINVAL;
		if (!parse.p.key)
			goto error;
877
		if (parse.idx < 0 || parse.idx > 3)
Johannes Berg's avatar
Johannes Berg committed
878 879 880 881 882 883
			goto error;
		if (parse.def) {
			if (def)
				goto error;
			def = 1;
			result->def = parse.idx;
884 885
			if (!parse.def_uni || !parse.def_multi)
				goto error;
Johannes Berg's avatar
Johannes Berg committed
886 887 888
		} else if (parse.defmgmt)
			goto error;
		err = cfg80211_validate_key_settings(rdev, &parse.p,
889
						     parse.idx, false, NULL);
Johannes Berg's avatar
Johannes Berg committed
890 891
		if (err)
			goto error;
892 893 894 895 896
		if (parse.p.cipher != WLAN_CIPHER_SUITE_WEP40 &&
		    parse.p.cipher != WLAN_CIPHER_SUITE_WEP104) {
			err = -EINVAL;
			goto error;
		}
Johannes Berg's avatar
Johannes Berg committed
897 898 899 900
		result->params[parse.idx].cipher = parse.p.cipher;
		result->params[parse.idx].key_len = parse.p.key_len;
		result->params[parse.idx].key = result->data[parse.idx];
		memcpy(result->data[parse.idx], parse.p.key, parse.p.key_len);
901

902 903 904
		/* must be WEP key if we got here */
		if (no_ht)
			*no_ht = true;
Johannes Berg's avatar
Johannes Berg committed
905 906
	}

907 908 909 910 911
	if (result->def < 0) {
		err = -EINVAL;
		goto error;
	}

Johannes Berg's avatar
Johannes Berg committed
912 913 914 915 916 917 918 919 920 921 922 923 924
	return result;
 error:
	kfree(result);
	return ERR_PTR(err);
}

static int nl80211_key_allowed(struct wireless_dev *wdev)
{
	ASSERT_WDEV_LOCK(wdev);

	switch (wdev->iftype) {
	case NL80211_IFTYPE_AP:
	case NL80211_IFTYPE_AP_VLAN:
925
	case NL80211_IFTYPE_P2P_GO:
926
	case NL80211_IFTYPE_MESH_POINT:
Johannes Berg's avatar
Johannes Berg committed
927 928 929
		break;
	case NL80211_IFTYPE_ADHOC:
	case NL80211_IFTYPE_STATION:
930
	case NL80211_IFTYPE_P2P_CLIENT:
931
		if (!wdev->current_bss)
Johannes Berg's avatar
Johannes Berg committed
932 933
			return -ENOLINK;
		break;
934
	case NL80211_IFTYPE_UNSPECIFIED:
935
	case NL80211_IFTYPE_OCB:
936 937 938 939
	case NL80211_IFTYPE_MONITOR:
	case NL80211_IFTYPE_P2P_DEVICE:
	case NL80211_IFTYPE_WDS:
	case NUM_NL80211_IFTYPES:
Johannes Berg's avatar
Johannes Berg committed
940 941 942 943 944 945
		return -EINVAL;
	}

	return 0;
}

946 947 948 949 950 951 952 953 954 955 956 957 958
static struct ieee80211_channel *nl80211_get_valid_chan(struct wiphy *wiphy,
							struct nlattr *tb)
{
	struct ieee80211_channel *chan;

	if (tb == NULL)
		return NULL;
	chan = ieee80211_get_channel(wiphy, nla_get_u32(tb));
	if (!chan || chan->flags & IEEE80211_CHAN_DISABLED)
		return NULL;
	return chan;
}

959 960 961 962 963 964 965 966 967 968
static int nl80211_put_iftypes(struct sk_buff *msg, u32 attr, u16 ifmodes)
{
	struct nlattr *nl_modes = nla_nest_start(msg, attr);
	int i;

	if (!nl_modes)
		goto nla_put_failure;

	i = 0;
	while (ifmodes) {
969 970
		if ((ifmodes & 1) && nla_put_flag(msg, i))
			goto nla_put_failure;
971 972 973 974 975 976 977 978 979 980 981 982
		ifmodes >>= 1;
		i++;
	}

	nla_nest_end(msg, nl_modes);
	return 0;

nla_put_failure:
	return -ENOBUFS;
}

static int nl80211_put_iface_combinations(struct wiphy *wiphy,
983 984
					  struct sk_buff *msg,
					  bool large)
985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001