]> git.ipfire.org Git - thirdparty/hostap.git/blame - src/drivers/driver_nl80211.c
projects / thirdparty / hostap.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
nl80211: Add support for QoS Map configuration
[thirdparty/hostap.git] / src / drivers / driver_nl80211.c
CommitLineData
3f5285e8 1/*
c5121837 2 * Driver interaction with Linux nl80211/cfg80211
3d9975d5 3 * Copyright (c) 2002-2012, Jouni Malinen <j@w1.fi>
072ad14c
JM		 4 * Copyright (c) 2003-2004, Instant802 Networks, Inc.
5 * Copyright (c) 2005-2006, Devicescape Software, Inc.
6 * Copyright (c) 2007, Johannes Berg <johannes@sipsolutions.net>
58f6fbe0 7 * Copyright (c) 2009-2010, Atheros Communications
3f5285e8 8 *
0f3d578e
JM		 9 * This software may be distributed under the terms of the BSD license.
10 * See README for more details.
3f5285e8
JM		 11 */
12
13#include "includes.h"
14#include <sys/ioctl.h>
6859f1cb
BG		 15#include <sys/types.h>
16#include <sys/stat.h>
17#include <fcntl.h>
37b7d082 18#include <net/if.h>
3f5285e8
JM		 19#include <netlink/genl/genl.h>
20#include <netlink/genl/family.h>
21#include <netlink/genl/ctrl.h>
8602b0f2 22#include <linux/rtnetlink.h>
1b648c7e
JM		 23#include <netpacket/packet.h>
24#include <linux/filter.h>
32ab4855 25#include <linux/errqueue.h>
7e45830a 26#include "nl80211_copy.h"
625f587b 27
3f5285e8 28#include "common.h"
1b648c7e 29#include "eloop.h"
f2ed8023 30#include "utils/list.h"
1b648c7e 31#include "common/ieee802_11_defs.h"
9b90955e 32#include "common/ieee802_11_common.h"
f10bfc9a 33#include "l2_packet/l2_packet.h"
e2d02c29 34#include "netlink.h"
34f2f814 35#include "linux_ioctl.h"
e2d02c29
JM		 36#include "radiotap.h"
37#include "radiotap_iter.h"
8401a6b0 38#include "rfkill.h"
1b648c7e 39#include "driver.h"
0915d02c 40
32ab4855
JB		 41#ifndef SO_WIFI_STATUS
42# if defined(__sparc__)
43# define SO_WIFI_STATUS 0x0025
44# elif defined(__parisc__)
45# define SO_WIFI_STATUS 0x4022
46# else
47# define SO_WIFI_STATUS 41
48# endif
49
50# define SCM_WIFI_STATUS SO_WIFI_STATUS
51#endif
52
53#ifndef SO_EE_ORIGIN_TXSTATUS
54#define SO_EE_ORIGIN_TXSTATUS 4
55#endif
56
57#ifndef PACKET_TX_TIMESTAMP
58#define PACKET_TX_TIMESTAMP 16
59#endif
60
216eede8
DS		 61#ifdef ANDROID
62#include "android_drv.h"
63#endif /* ANDROID */
c5121837
JM		 64#ifdef CONFIG_LIBNL20
65/* libnl 2.0 compatibility code */
2e8eac2d 66#define nl_handle nl_sock
a65a9aed
JB		 67#define nl80211_handle_alloc nl_socket_alloc_cb
68#define nl80211_handle_destroy nl_socket_free
69#else
70/*
71 * libnl 1.1 has a bug, it tries to allocate socket numbers densely
72 * but when you free a socket again it will mess up its bitmap and
73 * and use the wrong number the next time it needs a socket ID.
74 * Therefore, we wrap the handle alloc/destroy and add our own pid
75 * accounting.
76 */
77static uint32_t port_bitmap[32] = { 0 };
78
79static struct nl_handle *nl80211_handle_alloc(void *cb)
80{
81 struct nl_handle *handle;
82 uint32_t pid = getpid() & 0x3FFFFF;
83 int i;
84
85 handle = nl_handle_alloc_cb(cb);
86
87 for (i = 0; i < 1024; i++) {
88 if (port_bitmap[i / 32] & (1 << (i % 32)))
89 continue;
90 port_bitmap[i / 32] |= 1 << (i % 32);
91 pid += i << 22;
92 break;
93 }
94
95 nl_socket_set_local_port(handle, pid);
96
97 return handle;
98}
99
100static void nl80211_handle_destroy(struct nl_handle *handle)
101{
102 uint32_t port = nl_socket_get_local_port(handle);
103
104 port >>= 22;
105 port_bitmap[port / 32] &= ~(1 << (port % 32));
106
107 nl_handle_destroy(handle);
108}
c5121837
JM		 109#endif /* CONFIG_LIBNL20 */
110
c5121837 111
1c6edec6
JM		 112#ifdef ANDROID
113/* system/core/libnl_2 does not include nl_socket_set_nonblocking() */
114static int android_nl_socket_set_nonblocking(struct nl_handle *handle)
115{
116 return fcntl(nl_socket_get_fd(handle), F_SETFL, O_NONBLOCK);
117}
118#undef nl_socket_set_nonblocking
119#define nl_socket_set_nonblocking(h) android_nl_socket_set_nonblocking(h)
120#endif /* ANDROID */
121
122
481234cf 123static struct nl_handle * nl_create_handle(struct nl_cb *cb, const char *dbg)
a92dfde8 124{
481234cf 125 struct nl_handle *handle;
a92dfde8 126
481234cf
JM		 127 handle = nl80211_handle_alloc(cb);
128 if (handle == NULL) {
a92dfde8
JB		 129 wpa_printf(MSG_ERROR, "nl80211: Failed to allocate netlink "
130 "callbacks (%s)", dbg);
481234cf 131 return NULL;
a92dfde8
JB		 132 }
133
481234cf 134 if (genl_connect(handle)) {
a92dfde8
JB		 135 wpa_printf(MSG_ERROR, "nl80211: Failed to connect to generic "
136 "netlink (%s)", dbg);
481234cf
JM		 137 nl80211_handle_destroy(handle);
138 return NULL;
a92dfde8
JB		 139 }
140
481234cf 141 return handle;
a92dfde8
JB		 142}
143
144
481234cf 145static void nl_destroy_handles(struct nl_handle **handle)
a92dfde8 146{
481234cf 147 if (*handle == NULL)
a92dfde8 148 return;
481234cf
JM		 149 nl80211_handle_destroy(*handle);
150 *handle = NULL;
a92dfde8
JB		 151}
152
153
10b85921
JB		 154#if __WORDSIZE == 64
155#define ELOOP_SOCKET_INVALID (intptr_t) 0x8888888888888889ULL
156#else
157#define ELOOP_SOCKET_INVALID (intptr_t) 0x88888889ULL
158#endif
159
5f65e9f7
JB		 160static void nl80211_register_eloop_read(struct nl_handle **handle,
161 eloop_sock_handler handler,
162 void *eloop_data)
163{
10b85921 164 nl_socket_set_nonblocking(*handle);
5f65e9f7
JB		 165 eloop_register_read_sock(nl_socket_get_fd(*handle), handler,
166 eloop_data, *handle);
10b85921 167 *handle = (void *) (((intptr_t) *handle) ^ ELOOP_SOCKET_INVALID);
5f65e9f7
JB		 168}
169
170
171static void nl80211_destroy_eloop_handle(struct nl_handle **handle)
172{
10b85921 173 *handle = (void *) (((intptr_t) *handle) ^ ELOOP_SOCKET_INVALID);
5f65e9f7
JB		 174 eloop_unregister_read_sock(nl_socket_get_fd(*handle));
175 nl_destroy_handles(handle);
176}
177
178
3f5285e8
JM		 179#ifndef IFF_LOWER_UP
180#define IFF_LOWER_UP 0x10000 /* driver signals L1 up */
181#endif
182#ifndef IFF_DORMANT
183#define IFF_DORMANT 0x20000 /* driver signals dormant */
184#endif
185
186#ifndef IF_OPER_DORMANT
187#define IF_OPER_DORMANT 5
188#endif
189#ifndef IF_OPER_UP
190#define IF_OPER_UP 6
191#endif
192
f2ed8023
JM		 193struct nl80211_global {
194 struct dl_list interfaces;
ff6a158b 195 int if_add_ifindex;
f632e483
AS		 196 u64 if_add_wdevid;
197 int if_add_wdevid_set;
36d84860 198 struct netlink_data *netlink;
2a7b66f5 199 struct nl_cb *nl_cb;
481234cf 200 struct nl_handle *nl;
335d42b1 201 int nl80211_id;
c81eff1a 202 int ioctl_sock; /* socket for ioctl() use */
d6c9aab8 203
481234cf 204 struct nl_handle *nl_event;
f2ed8023
JM		 205};
206
e32ad281
JB		 207struct nl80211_wiphy_data {
208 struct dl_list list;
209 struct dl_list bsss;
210 struct dl_list drvs;
211
481234cf 212 struct nl_handle *nl_beacons;
e32ad281
JB		 213 struct nl_cb *nl_cb;
214
215 int wiphy_idx;
216};
217
36d84860
BG		 218static void nl80211_global_deinit(void *priv);
219
c5121837 220struct i802_bss {
a2e40bb6 221 struct wpa_driver_nl80211_data *drv;
c5121837 222 struct i802_bss *next;
b4fd6fab 223 int ifindex;
d3aaef80 224 u64 wdev_id;
a2e40bb6 225 char ifname[IFNAMSIZ + 1];
e17a2477 226 char brname[IFNAMSIZ];
c5121837 227 unsigned int beacon_set:1;
e17a2477
JM		 228 unsigned int added_if_into_bridge:1;
229 unsigned int added_bridge:1;
873d0fcf 230 unsigned int in_deinit:1;
d3aaef80 231 unsigned int wdev_id_set:1;
390e489c 232 unsigned int added_if:1;
221a59c9 233
341eebee
JB		 234 u8 addr[ETH_ALEN];
235
e4fb2167 236 int freq;
60b13c20 237 int if_dynamic;
e4fb2167 238
a5e1eb20 239 void *ctx;
481234cf 240 struct nl_handle *nl_preq, *nl_mgmt;
cc7a48d1 241 struct nl_cb *nl_cb;
e32ad281
JB		 242
243 struct nl80211_wiphy_data *wiphy_data;
244 struct dl_list wiphy_list;
c5121837 245};
3f5285e8
JM		 246
247struct wpa_driver_nl80211_data {
f2ed8023
JM		 248 struct nl80211_global *global;
249 struct dl_list list;
e32ad281 250 struct dl_list wiphy_list;
6859f1cb 251 char phyname[32];
3f5285e8 252 void *ctx;
3f5285e8 253 int ifindex;
7524cfb1 254 int if_removed;
a63063b4 255 int if_disabled;
7d9c3698 256 int ignore_if_down_event;
8401a6b0 257 struct rfkill_data *rfkill;
c2a04078 258 struct wpa_driver_capa capa;
8cd6b7bc
JB		 259 u8 *extended_capa, *extended_capa_mask;
260 unsigned int extended_capa_len;
c2a04078 261 int has_capability;
c2a04078 262
3f5285e8
JM		 263 int operstate;
264
3f5285e8 265 int scan_complete_events;
a771c07d
JM		 266 enum scan_states {
267 NO_SCAN, SCAN_REQUESTED, SCAN_STARTED, SCAN_COMPLETED,
268 SCAN_ABORTED, SCHED_SCAN_STARTED, SCHED_SCAN_STOPPED,
269 SCHED_SCAN_RESULTS
270 } scan_state;
3f5285e8 271
1afc986d 272 struct nl_cb *nl_cb;
1c873584 273
e6b8efeb 274 u8 auth_bssid[ETH_ALEN];
add9b7a4 275 u8 auth_attempt_bssid[ETH_ALEN];
c2a04078 276 u8 bssid[ETH_ALEN];
add9b7a4 277 u8 prev_bssid[ETH_ALEN];
c2a04078 278 int associated;
fd05d64e
JM		 279 u8 ssid[32];
280 size_t ssid_len;
b1f625e0
EP		 281 enum nl80211_iftype nlmode;
282 enum nl80211_iftype ap_scan_as_station;
4832ecd7 283 unsigned int assoc_freq;
d2440ba0 284
0915d02c
JM		 285 int monitor_sock;
286 int monitor_ifidx;
3fd1cefb 287 int monitor_refcount;
7da3abe7 288
b3af99d2 289 unsigned int disabled_11b_rates:1;
55777702 290 unsigned int pending_remain_on_chan:1;
dac12351 291 unsigned int in_interface_list:1;
61cbe2ff 292 unsigned int device_ap_sme:1;
39718852 293 unsigned int poll_command_supported:1;
32ab4855 294 unsigned int data_tx_status:1;
536fd62d
JM		 295 unsigned int scan_for_auth:1;
296 unsigned int retry_auth:1;
a11241fa 297 unsigned int use_monitor:1;
a8c5b43a 298 unsigned int ignore_next_local_disconnect:1;
851b0c55 299 unsigned int allow_p2p_device:1;
0d547d5f 300 unsigned int hostapd:1;
49b4b205 301 unsigned int start_mode_ap:1;
146fa9b3 302 unsigned int start_iface_up:1;
1c4ffa87 303 unsigned int channel_switch_supported:1;
55777702
JM		 304
305 u64 remain_on_chan_cookie;
58f6fbe0 306 u64 send_action_cookie;
c5121837 307
5582a5d1
JB		 308 unsigned int last_mgmt_freq;
309
3812464c
JM		 310 struct wpa_driver_scan_filter *filter_ssids;
311 size_t num_filter_ssids;
312
834ee56f 313 struct i802_bss *first_bss;
a2e40bb6 314
d12dab4c 315 int eapol_tx_sock;
f10bfc9a 316
c5121837 317 int eapol_sock; /* socket for EAPOL frames */
c5121837
JM		 318
319 int default_if_indices[16];
320 int *if_indices;
321 int num_if_indices;
536fd62d
JM		 322
323 /* From failed authentication command */
324 int auth_freq;
325 u8 auth_bssid_[ETH_ALEN];
326 u8 auth_ssid[32];
327 size_t auth_ssid_len;
328 int auth_alg;
329 u8 *auth_ie;
330 size_t auth_ie_len;
331 u8 auth_wep_key[4][16];
332 size_t auth_wep_key_len[4];
333 int auth_wep_tx_keyidx;
334 int auth_local_state_change;
335 int auth_p2p;
3f5285e8
JM		 336};
337
338
9ebce9c5 339static void wpa_driver_nl80211_deinit(struct i802_bss *bss);
3f5285e8
JM		 340static void wpa_driver_nl80211_scan_timeout(void *eloop_ctx,
341 void *timeout_ctx);
b1f625e0
EP		 342static int wpa_driver_nl80211_set_mode(struct i802_bss *bss,
343 enum nl80211_iftype nlmode);
362f781e 344static int
0d547d5f 345wpa_driver_nl80211_finish_drv_init(struct wpa_driver_nl80211_data *drv,
49b4b205 346 const u8 *set_addr, int first);
d72aad94 347static int wpa_driver_nl80211_mlme(struct wpa_driver_nl80211_data *drv,
77339912
JM		 348 const u8 *addr, int cmd, u16 reason_code,
349 int local_state_change);
460456f8
JM		 350static void nl80211_remove_monitor_interface(
351 struct wpa_driver_nl80211_data *drv);
88df0ef7 352static int nl80211_send_frame_cmd(struct i802_bss *bss,
5dfca53f 353 unsigned int freq, unsigned int wait,
b106173a 354 const u8 *buf, size_t buf_len, u64 *cookie,
88df0ef7 355 int no_cck, int no_ack, int offchanok);
b21990b4
AQ		 356static int nl80211_register_frame(struct i802_bss *bss,
357 struct nl_handle *hl_handle,
358 u16 type, const u8 *match, size_t match_len);
9ebce9c5
JM		 359static int wpa_driver_nl80211_probe_req_report(struct i802_bss *bss,
360 int report);
216eede8
DS		 361#ifdef ANDROID
362static int android_pno_start(struct i802_bss *bss,
363 struct wpa_driver_scan_params *params);
364static int android_pno_stop(struct i802_bss *bss);
5e2c3490
JM		 365extern int wpa_driver_nl80211_driver_cmd(void *priv, char *cmd, char *buf,
366 size_t buf_len);
216eede8 367#endif /* ANDROID */
0de38036
JM		 368#ifdef ANDROID_P2P
369int wpa_driver_set_p2p_noa(void *priv, u8 count, int start, int duration);
370int wpa_driver_get_p2p_noa(void *priv, u8 *buf, size_t len);
371int wpa_driver_set_p2p_ps(void *priv, int legacy_ps, int opp_ps, int ctwindow);
372int wpa_driver_set_ap_wps_p2p_ie(void *priv, const struct wpabuf *beacon,
373 const struct wpabuf *proberesp,
374 const struct wpabuf *assocresp);
375#endif /* ANDROID_P2P */
0915d02c 376
2135f224
JM		 377static void add_ifidx(struct wpa_driver_nl80211_data *drv, int ifidx);
378static void del_ifidx(struct wpa_driver_nl80211_data *drv, int ifidx);
97cfcf64 379static int have_ifidx(struct wpa_driver_nl80211_data *drv, int ifidx);
9ebce9c5 380static int wpa_driver_nl80211_if_remove(struct i802_bss *bss,
fbbfcbac
FF		 381 enum wpa_driver_if_type type,
382 const char *ifname);
072ad14c 383
9ebce9c5
JM		 384static int wpa_driver_nl80211_set_freq(struct i802_bss *bss,
385 struct hostapd_freq_params *freq);
4e5cb1a3
JM		 386static int nl80211_disable_11b_rates(struct wpa_driver_nl80211_data *drv,
387 int ifindex, int disabled);
504e905c 388
21bdbe38 389static int nl80211_leave_ibss(struct wpa_driver_nl80211_data *drv);
536fd62d
JM		 390static int wpa_driver_nl80211_authenticate_retry(
391 struct wpa_driver_nl80211_data *drv);
21bdbe38 392
bf83eab5
IP		 393static int i802_set_iface_flags(struct i802_bss *bss, int up);
394
3f5285e8 395
2090a0b4
DS		 396static const char * nl80211_command_to_string(enum nl80211_commands cmd)
397{
398#define C2S(x) case x: return #x;
399 switch (cmd) {
400 C2S(NL80211_CMD_UNSPEC)
401 C2S(NL80211_CMD_GET_WIPHY)
402 C2S(NL80211_CMD_SET_WIPHY)
403 C2S(NL80211_CMD_NEW_WIPHY)
404 C2S(NL80211_CMD_DEL_WIPHY)
405 C2S(NL80211_CMD_GET_INTERFACE)
406 C2S(NL80211_CMD_SET_INTERFACE)
407 C2S(NL80211_CMD_NEW_INTERFACE)
408 C2S(NL80211_CMD_DEL_INTERFACE)
409 C2S(NL80211_CMD_GET_KEY)
410 C2S(NL80211_CMD_SET_KEY)
411 C2S(NL80211_CMD_NEW_KEY)
412 C2S(NL80211_CMD_DEL_KEY)
413 C2S(NL80211_CMD_GET_BEACON)
414 C2S(NL80211_CMD_SET_BEACON)
415 C2S(NL80211_CMD_START_AP)
416 C2S(NL80211_CMD_STOP_AP)
417 C2S(NL80211_CMD_GET_STATION)
418 C2S(NL80211_CMD_SET_STATION)
419 C2S(NL80211_CMD_NEW_STATION)
420 C2S(NL80211_CMD_DEL_STATION)
421 C2S(NL80211_CMD_GET_MPATH)
422 C2S(NL80211_CMD_SET_MPATH)
423 C2S(NL80211_CMD_NEW_MPATH)
424 C2S(NL80211_CMD_DEL_MPATH)
425 C2S(NL80211_CMD_SET_BSS)
426 C2S(NL80211_CMD_SET_REG)
427 C2S(NL80211_CMD_REQ_SET_REG)
428 C2S(NL80211_CMD_GET_MESH_CONFIG)
429 C2S(NL80211_CMD_SET_MESH_CONFIG)
430 C2S(NL80211_CMD_SET_MGMT_EXTRA_IE)
431 C2S(NL80211_CMD_GET_REG)
432 C2S(NL80211_CMD_GET_SCAN)
433 C2S(NL80211_CMD_TRIGGER_SCAN)
434 C2S(NL80211_CMD_NEW_SCAN_RESULTS)
435 C2S(NL80211_CMD_SCAN_ABORTED)
436 C2S(NL80211_CMD_REG_CHANGE)
437 C2S(NL80211_CMD_AUTHENTICATE)
438 C2S(NL80211_CMD_ASSOCIATE)
439 C2S(NL80211_CMD_DEAUTHENTICATE)
440 C2S(NL80211_CMD_DISASSOCIATE)
441 C2S(NL80211_CMD_MICHAEL_MIC_FAILURE)
442 C2S(NL80211_CMD_REG_BEACON_HINT)
443 C2S(NL80211_CMD_JOIN_IBSS)
444 C2S(NL80211_CMD_LEAVE_IBSS)
445 C2S(NL80211_CMD_TESTMODE)
446 C2S(NL80211_CMD_CONNECT)
447 C2S(NL80211_CMD_ROAM)
448 C2S(NL80211_CMD_DISCONNECT)
449 C2S(NL80211_CMD_SET_WIPHY_NETNS)
450 C2S(NL80211_CMD_GET_SURVEY)
451 C2S(NL80211_CMD_NEW_SURVEY_RESULTS)
452 C2S(NL80211_CMD_SET_PMKSA)
453 C2S(NL80211_CMD_DEL_PMKSA)
454 C2S(NL80211_CMD_FLUSH_PMKSA)
455 C2S(NL80211_CMD_REMAIN_ON_CHANNEL)
456 C2S(NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL)
457 C2S(NL80211_CMD_SET_TX_BITRATE_MASK)
458 C2S(NL80211_CMD_REGISTER_FRAME)
459 C2S(NL80211_CMD_FRAME)
460 C2S(NL80211_CMD_FRAME_TX_STATUS)
461 C2S(NL80211_CMD_SET_POWER_SAVE)
462 C2S(NL80211_CMD_GET_POWER_SAVE)
463 C2S(NL80211_CMD_SET_CQM)
464 C2S(NL80211_CMD_NOTIFY_CQM)
465 C2S(NL80211_CMD_SET_CHANNEL)
466 C2S(NL80211_CMD_SET_WDS_PEER)
467 C2S(NL80211_CMD_FRAME_WAIT_CANCEL)
468 C2S(NL80211_CMD_JOIN_MESH)
469 C2S(NL80211_CMD_LEAVE_MESH)
470 C2S(NL80211_CMD_UNPROT_DEAUTHENTICATE)
471 C2S(NL80211_CMD_UNPROT_DISASSOCIATE)
472 C2S(NL80211_CMD_NEW_PEER_CANDIDATE)
473 C2S(NL80211_CMD_GET_WOWLAN)
474 C2S(NL80211_CMD_SET_WOWLAN)
475 C2S(NL80211_CMD_START_SCHED_SCAN)
476 C2S(NL80211_CMD_STOP_SCHED_SCAN)
477 C2S(NL80211_CMD_SCHED_SCAN_RESULTS)
478 C2S(NL80211_CMD_SCHED_SCAN_STOPPED)
479 C2S(NL80211_CMD_SET_REKEY_OFFLOAD)
480 C2S(NL80211_CMD_PMKSA_CANDIDATE)
481 C2S(NL80211_CMD_TDLS_OPER)
482 C2S(NL80211_CMD_TDLS_MGMT)
483 C2S(NL80211_CMD_UNEXPECTED_FRAME)
484 C2S(NL80211_CMD_PROBE_CLIENT)
485 C2S(NL80211_CMD_REGISTER_BEACONS)
486 C2S(NL80211_CMD_UNEXPECTED_4ADDR_FRAME)
487 C2S(NL80211_CMD_SET_NOACK_MAP)
488 C2S(NL80211_CMD_CH_SWITCH_NOTIFY)
489 C2S(NL80211_CMD_START_P2P_DEVICE)
490 C2S(NL80211_CMD_STOP_P2P_DEVICE)
491 C2S(NL80211_CMD_CONN_FAILED)
492 C2S(NL80211_CMD_SET_MCAST_RATE)
493 C2S(NL80211_CMD_SET_MAC_ACL)
494 C2S(NL80211_CMD_RADAR_DETECT)
495 C2S(NL80211_CMD_GET_PROTOCOL_FEATURES)
496 C2S(NL80211_CMD_UPDATE_FT_IES)
497 C2S(NL80211_CMD_FT_EVENT)
498 C2S(NL80211_CMD_CRIT_PROTOCOL_START)
499 C2S(NL80211_CMD_CRIT_PROTOCOL_STOP)
500 default:
501 return "NL80211_CMD_UNKNOWN";
502 }
503#undef C2S
504}
505
506
8d1fdde7
JD		 507/* Converts nl80211_chan_width to a common format */
508static enum chan_width convert2width(int width)
509{
510 switch (width) {
511 case NL80211_CHAN_WIDTH_20_NOHT:
512 return CHAN_WIDTH_20_NOHT;
513 case NL80211_CHAN_WIDTH_20:
514 return CHAN_WIDTH_20;
515 case NL80211_CHAN_WIDTH_40:
516 return CHAN_WIDTH_40;
517 case NL80211_CHAN_WIDTH_80:
518 return CHAN_WIDTH_80;
519 case NL80211_CHAN_WIDTH_80P80:
520 return CHAN_WIDTH_80P80;
521 case NL80211_CHAN_WIDTH_160:
522 return CHAN_WIDTH_160;
523 }
524 return CHAN_WIDTH_UNKNOWN;
525}
526
527
b1f625e0
EP		 528static int is_ap_interface(enum nl80211_iftype nlmode)
529{
530 return (nlmode == NL80211_IFTYPE_AP ||
531 nlmode == NL80211_IFTYPE_P2P_GO);
532}
533
534
535static int is_sta_interface(enum nl80211_iftype nlmode)
536{
537 return (nlmode == NL80211_IFTYPE_STATION ||
538 nlmode == NL80211_IFTYPE_P2P_CLIENT);
539}
540
541
6a71413e 542static int is_p2p_net_interface(enum nl80211_iftype nlmode)
b3af99d2
JM		 543{
544 return (nlmode == NL80211_IFTYPE_P2P_CLIENT ||
545 nlmode == NL80211_IFTYPE_P2P_GO);
546}
547
548
add9b7a4
JM		 549static void nl80211_mark_disconnected(struct wpa_driver_nl80211_data *drv)
550{
551 if (drv->associated)
552 os_memcpy(drv->prev_bssid, drv->bssid, ETH_ALEN);
553 drv->associated = 0;
554 os_memset(drv->bssid, 0, ETH_ALEN);
555}
556
557
f5a8d422
JM		 558struct nl80211_bss_info_arg {
559 struct wpa_driver_nl80211_data *drv;
560 struct wpa_scan_results *res;
561 unsigned int assoc_freq;
20f5a4c2 562 u8 assoc_bssid[ETH_ALEN];
f5a8d422
JM		 563};
564
565static int bss_info_handler(struct nl_msg *msg, void *arg);
566
567
6241fcb1
JM		 568/* nl80211 code */
569static int ack_handler(struct nl_msg *msg, void *arg)
570{
571 int *err = arg;
572 *err = 0;
573 return NL_STOP;
574}
575
576static int finish_handler(struct nl_msg *msg, void *arg)
577{
8e8df255
JM		 578 int *ret = arg;
579 *ret = 0;
6241fcb1
JM		 580 return NL_SKIP;
581}
582
583static int error_handler(struct sockaddr_nl *nla, struct nlmsgerr *err,
584 void *arg)
585{
586 int *ret = arg;
587 *ret = err->error;
588 return NL_SKIP;
589}
590
5b7b85f6
JM		 591
592static int no_seq_check(struct nl_msg *msg, void *arg)
593{
594 return NL_OK;
595}
596
597
d6c9aab8 598static int send_and_recv(struct nl80211_global *global,
58f6fbe0
JM		 599 struct nl_handle *nl_handle, struct nl_msg *msg,
600 int (*valid_handler)(struct nl_msg *, void *),
601 void *valid_data)
6241fcb1
JM		 602{
603 struct nl_cb *cb;
604 int err = -ENOMEM;
605
d6c9aab8 606 cb = nl_cb_clone(global->nl_cb);
6241fcb1
JM		 607 if (!cb)
608 goto out;
609
58f6fbe0 610 err = nl_send_auto_complete(nl_handle, msg);
6241fcb1
JM		 611 if (err < 0)
612 goto out;
613
614 err = 1;
615
616 nl_cb_err(cb, NL_CB_CUSTOM, error_handler, &err);
8e8df255 617 nl_cb_set(cb, NL_CB_FINISH, NL_CB_CUSTOM, finish_handler, &err);
6241fcb1
JM		 618 nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, ack_handler, &err);
619
620 if (valid_handler)
621 nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM,
622 valid_handler, valid_data);
623
34068ac3
JM		 624 while (err > 0) {
625 int res = nl_recvmsgs(nl_handle, cb);
626 if (res) {
627 wpa_printf(MSG_INFO,
628 "nl80211: %s->nl_recvmsgs failed: %d",
629 __func__, res);
630 }
631 }
6241fcb1
JM		 632 out:
633 nl_cb_put(cb);
634 nlmsg_free(msg);
635 return err;
636}
637
638
d6c9aab8
JB		 639static int send_and_recv_msgs_global(struct nl80211_global *global,
640 struct nl_msg *msg,
641 int (*valid_handler)(struct nl_msg *, void *),
642 void *valid_data)
643{
481234cf 644 return send_and_recv(global, global->nl, msg, valid_handler,
d6c9aab8
JB		 645 valid_data);
646}
647
648
98218963
DS		 649static int send_and_recv_msgs(struct wpa_driver_nl80211_data *drv,
650 struct nl_msg *msg,
651 int (*valid_handler)(struct nl_msg *, void *),
652 void *valid_data)
58f6fbe0 653{
481234cf 654 return send_and_recv(drv->global, drv->global->nl, msg,
d6c9aab8 655 valid_handler, valid_data);
58f6fbe0
JM		 656}
657
658
97865538
JM		 659struct family_data {
660 const char *group;
661 int id;
662};
663
664
d3aaef80
DS		 665static int nl80211_set_iface_id(struct nl_msg *msg, struct i802_bss *bss)
666{
667 if (bss->wdev_id_set)
668 NLA_PUT_U64(msg, NL80211_ATTR_WDEV, bss->wdev_id);
669 else
670 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, bss->ifindex);
671 return 0;
672
673nla_put_failure:
674 return -1;
675}
676
677
97865538
JM		 678static int family_handler(struct nl_msg *msg, void *arg)
679{
680 struct family_data *res = arg;
681 struct nlattr *tb[CTRL_ATTR_MAX + 1];
682 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
683 struct nlattr *mcgrp;
684 int i;
685
686 nla_parse(tb, CTRL_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
687 genlmsg_attrlen(gnlh, 0), NULL);
688 if (!tb[CTRL_ATTR_MCAST_GROUPS])
689 return NL_SKIP;
690
691 nla_for_each_nested(mcgrp, tb[CTRL_ATTR_MCAST_GROUPS], i) {
692 struct nlattr *tb2[CTRL_ATTR_MCAST_GRP_MAX + 1];
693 nla_parse(tb2, CTRL_ATTR_MCAST_GRP_MAX, nla_data(mcgrp),
694 nla_len(mcgrp), NULL);
695 if (!tb2[CTRL_ATTR_MCAST_GRP_NAME] ||
696 !tb2[CTRL_ATTR_MCAST_GRP_ID] ||
697 os_strncmp(nla_data(tb2[CTRL_ATTR_MCAST_GRP_NAME]),
698 res->group,
699 nla_len(tb2[CTRL_ATTR_MCAST_GRP_NAME])) != 0)
700 continue;
701 res->id = nla_get_u32(tb2[CTRL_ATTR_MCAST_GRP_ID]);
702 break;
703 };
704
705 return NL_SKIP;
706}
707
708
d6c9aab8 709static int nl_get_multicast_id(struct nl80211_global *global,
97865538
JM		 710 const char *family, const char *group)
711{
712 struct nl_msg *msg;
713 int ret = -1;
714 struct family_data res = { group, -ENOENT };
715
716 msg = nlmsg_alloc();
717 if (!msg)
718 return -ENOMEM;
481234cf 719 genlmsg_put(msg, 0, 0, genl_ctrl_resolve(global->nl, "nlctrl"),
97865538
JM		 720 0, 0, CTRL_CMD_GETFAMILY, 0);
721 NLA_PUT_STRING(msg, CTRL_ATTR_FAMILY_NAME, family);
722
d6c9aab8 723 ret = send_and_recv_msgs_global(global, msg, family_handler, &res);
97865538
JM		 724 msg = NULL;
725 if (ret == 0)
726 ret = res.id;
727
728nla_put_failure:
729 nlmsg_free(msg);
730 return ret;
731}
732
733
9fb04070
JM		 734static void * nl80211_cmd(struct wpa_driver_nl80211_data *drv,
735 struct nl_msg *msg, int flags, uint8_t cmd)
736{
335d42b1 737 return genlmsg_put(msg, 0, 0, drv->global->nl80211_id,
276e2d67 738 0, flags, cmd, 0);
9fb04070
JM		 739}
740
741
e32ad281
JB		 742struct wiphy_idx_data {
743 int wiphy_idx;
01517c8b 744 enum nl80211_iftype nlmode;
597b94f5 745 u8 *macaddr;
e32ad281
JB		 746};
747
748
749static int netdev_info_handler(struct nl_msg *msg, void *arg)
750{
751 struct nlattr *tb[NL80211_ATTR_MAX + 1];
752 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
753 struct wiphy_idx_data *info = arg;
754
755 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
756 genlmsg_attrlen(gnlh, 0), NULL);
757
758 if (tb[NL80211_ATTR_WIPHY])
759 info->wiphy_idx = nla_get_u32(tb[NL80211_ATTR_WIPHY]);
760
01517c8b
JB		 761 if (tb[NL80211_ATTR_IFTYPE])
762 info->nlmode = nla_get_u32(tb[NL80211_ATTR_IFTYPE]);
763
597b94f5
AS		 764 if (tb[NL80211_ATTR_MAC] && info->macaddr)
765 os_memcpy(info->macaddr, nla_data(tb[NL80211_ATTR_MAC]),
766 ETH_ALEN);
767
e32ad281
JB		 768 return NL_SKIP;
769}
770
771
772static int nl80211_get_wiphy_index(struct i802_bss *bss)
773{
774 struct nl_msg *msg;
775 struct wiphy_idx_data data = {
776 .wiphy_idx = -1,
597b94f5 777 .macaddr = NULL,
e32ad281
JB		 778 };
779
780 msg = nlmsg_alloc();
781 if (!msg)
8e12685c 782 return NL80211_IFTYPE_UNSPECIFIED;
e32ad281
JB		 783
784 nl80211_cmd(bss->drv, msg, 0, NL80211_CMD_GET_INTERFACE);
785
27ce1d64
AS		 786 if (nl80211_set_iface_id(msg, bss) < 0)
787 goto nla_put_failure;
e32ad281
JB		 788
789 if (send_and_recv_msgs(bss->drv, msg, netdev_info_handler, &data) == 0)
790 return data.wiphy_idx;
791 msg = NULL;
792nla_put_failure:
793 nlmsg_free(msg);
794 return -1;
795}
796
797
01517c8b
JB		 798static enum nl80211_iftype nl80211_get_ifmode(struct i802_bss *bss)
799{
800 struct nl_msg *msg;
801 struct wiphy_idx_data data = {
597b94f5
AS		 802 .nlmode = NL80211_IFTYPE_UNSPECIFIED,
803 .macaddr = NULL,
01517c8b
JB		 804 };
805
806 msg = nlmsg_alloc();
807 if (!msg)
808 return -1;
809
810 nl80211_cmd(bss->drv, msg, 0, NL80211_CMD_GET_INTERFACE);
811
f632e483
AS		 812 if (nl80211_set_iface_id(msg, bss) < 0)
813 goto nla_put_failure;
01517c8b
JB		 814
815 if (send_and_recv_msgs(bss->drv, msg, netdev_info_handler, &data) == 0)
816 return data.nlmode;
817 msg = NULL;
818nla_put_failure:
819 nlmsg_free(msg);
820 return NL80211_IFTYPE_UNSPECIFIED;
821}
01517c8b
JB		 822
823
597b94f5
AS		 824static int nl80211_get_macaddr(struct i802_bss *bss)
825{
826 struct nl_msg *msg;
827 struct wiphy_idx_data data = {
828 .macaddr = bss->addr,
829 };
830
831 msg = nlmsg_alloc();
832 if (!msg)
833 return NL80211_IFTYPE_UNSPECIFIED;
834
835 nl80211_cmd(bss->drv, msg, 0, NL80211_CMD_GET_INTERFACE);
836 if (nl80211_set_iface_id(msg, bss) < 0)
837 goto nla_put_failure;
838
839 return send_and_recv_msgs(bss->drv, msg, netdev_info_handler, &data);
840
841nla_put_failure:
842 nlmsg_free(msg);
843 return NL80211_IFTYPE_UNSPECIFIED;
844}
597b94f5
AS		 845
846
e32ad281
JB		 847static int nl80211_register_beacons(struct wpa_driver_nl80211_data *drv,
848 struct nl80211_wiphy_data *w)
849{
850 struct nl_msg *msg;
851 int ret = -1;
852
853 msg = nlmsg_alloc();
854 if (!msg)
855 return -1;
856
857 nl80211_cmd(drv, msg, 0, NL80211_CMD_REGISTER_BEACONS);
858
859 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, w->wiphy_idx);
860
481234cf 861 ret = send_and_recv(drv->global, w->nl_beacons, msg, NULL, NULL);
e32ad281
JB		 862 msg = NULL;
863 if (ret) {
864 wpa_printf(MSG_DEBUG, "nl80211: Register beacons command "
865 "failed: ret=%d (%s)",
866 ret, strerror(-ret));
867 goto nla_put_failure;
868 }
869 ret = 0;
870nla_put_failure:
871 nlmsg_free(msg);
872 return ret;
873}
874
875
876static void nl80211_recv_beacons(int sock, void *eloop_ctx, void *handle)
877{
878 struct nl80211_wiphy_data *w = eloop_ctx;
34068ac3 879 int res;
e32ad281 880
ee9fc67a 881 wpa_printf(MSG_EXCESSIVE, "nl80211: Beacon event message available");
e32ad281 882
34068ac3
JM		 883 res = nl_recvmsgs(handle, w->nl_cb);
884 if (res) {
885 wpa_printf(MSG_INFO, "nl80211: %s->nl_recvmsgs failed: %d",
886 __func__, res);
887 }
e32ad281
JB		 888}
889
890
891static int process_beacon_event(struct nl_msg *msg, void *arg)
892{
893 struct nl80211_wiphy_data *w = arg;
894 struct wpa_driver_nl80211_data *drv;
895 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
896 struct nlattr *tb[NL80211_ATTR_MAX + 1];
897 union wpa_event_data event;
898
899 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
900 genlmsg_attrlen(gnlh, 0), NULL);
901
902 if (gnlh->cmd != NL80211_CMD_FRAME) {
903 wpa_printf(MSG_DEBUG, "nl80211: Unexpected beacon event? (%d)",
904 gnlh->cmd);
905 return NL_SKIP;
906 }
907
908 if (!tb[NL80211_ATTR_FRAME])
909 return NL_SKIP;
910
911 dl_list_for_each(drv, &w->drvs, struct wpa_driver_nl80211_data,
912 wiphy_list) {
913 os_memset(&event, 0, sizeof(event));
914 event.rx_mgmt.frame = nla_data(tb[NL80211_ATTR_FRAME]);
915 event.rx_mgmt.frame_len = nla_len(tb[NL80211_ATTR_FRAME]);
916 wpa_supplicant_event(drv->ctx, EVENT_RX_MGMT, &event);
917 }
918
919 return NL_SKIP;
920}
921
922
923static struct nl80211_wiphy_data *
924nl80211_get_wiphy_data_ap(struct i802_bss *bss)
925{
926 static DEFINE_DL_LIST(nl80211_wiphys);
927 struct nl80211_wiphy_data *w;
928 int wiphy_idx, found = 0;
929 struct i802_bss *tmp_bss;
930
931 if (bss->wiphy_data != NULL)
932 return bss->wiphy_data;
933
934 wiphy_idx = nl80211_get_wiphy_index(bss);
935
936 dl_list_for_each(w, &nl80211_wiphys, struct nl80211_wiphy_data, list) {
937 if (w->wiphy_idx == wiphy_idx)
938 goto add;
939 }
940
941 /* alloc new one */
942 w = os_zalloc(sizeof(*w));
943 if (w == NULL)
944 return NULL;
945 w->wiphy_idx = wiphy_idx;
946 dl_list_init(&w->bsss);
947 dl_list_init(&w->drvs);
948
949 w->nl_cb = nl_cb_alloc(NL_CB_DEFAULT);
950 if (!w->nl_cb) {
951 os_free(w);
952 return NULL;
953 }
954 nl_cb_set(w->nl_cb, NL_CB_SEQ_CHECK, NL_CB_CUSTOM, no_seq_check, NULL);
955 nl_cb_set(w->nl_cb, NL_CB_VALID, NL_CB_CUSTOM, process_beacon_event,
956 w);
957
481234cf
JM		 958 w->nl_beacons = nl_create_handle(bss->drv->global->nl_cb,
959 "wiphy beacons");
960 if (w->nl_beacons == NULL) {
e32ad281
JB		 961 os_free(w);
962 return NULL;
963 }
964
965 if (nl80211_register_beacons(bss->drv, w)) {
966 nl_destroy_handles(&w->nl_beacons);
967 os_free(w);
968 return NULL;
969 }
970
5f65e9f7 971 nl80211_register_eloop_read(&w->nl_beacons, nl80211_recv_beacons, w);
e32ad281
JB		 972
973 dl_list_add(&nl80211_wiphys, &w->list);
974
975add:
976 /* drv entry for this bss already there? */
977 dl_list_for_each(tmp_bss, &w->bsss, struct i802_bss, wiphy_list) {
978 if (tmp_bss->drv == bss->drv) {
979 found = 1;
980 break;
981 }
982 }
983 /* if not add it */
984 if (!found)
985 dl_list_add(&w->drvs, &bss->drv->wiphy_list);
986
987 dl_list_add(&w->bsss, &bss->wiphy_list);
988 bss->wiphy_data = w;
989 return w;
990}
991
992
993static void nl80211_put_wiphy_data_ap(struct i802_bss *bss)
994{
995 struct nl80211_wiphy_data *w = bss->wiphy_data;
996 struct i802_bss *tmp_bss;
997 int found = 0;
998
999 if (w == NULL)
1000 return;
1001 bss->wiphy_data = NULL;
1002 dl_list_del(&bss->wiphy_list);
1003
1004 /* still any for this drv present? */
1005 dl_list_for_each(tmp_bss, &w->bsss, struct i802_bss, wiphy_list) {
1006 if (tmp_bss->drv == bss->drv) {
1007 found = 1;
1008 break;
1009 }
1010 }
1011 /* if not remove it */
1012 if (!found)
1013 dl_list_del(&bss->drv->wiphy_list);
1014
1015 if (!dl_list_empty(&w->bsss))
1016 return;
1017
5f65e9f7 1018 nl80211_destroy_eloop_handle(&w->nl_beacons);
e32ad281
JB		 1019
1020 nl_cb_put(w->nl_cb);
e32ad281
JB		 1021 dl_list_del(&w->list);
1022 os_free(w);
1023}
1024
1025
3f5285e8
JM		 1026static int wpa_driver_nl80211_get_bssid(void *priv, u8 *bssid)
1027{
a2e40bb6
FF		 1028 struct i802_bss *bss = priv;
1029 struct wpa_driver_nl80211_data *drv = bss->drv;
c2a04078
JM		 1030 if (!drv->associated)
1031 return -1;
1032 os_memcpy(bssid, drv->bssid, ETH_ALEN);
1033 return 0;
3f5285e8
JM		 1034}
1035
1036
3f5285e8
JM		 1037static int wpa_driver_nl80211_get_ssid(void *priv, u8 *ssid)
1038{
a2e40bb6
FF		 1039 struct i802_bss *bss = priv;
1040 struct wpa_driver_nl80211_data *drv = bss->drv;
fd05d64e
JM		 1041 if (!drv->associated)
1042 return -1;
1043 os_memcpy(ssid, drv->ssid, drv->ssid_len);
1044 return drv->ssid_len;
3f5285e8
JM		 1045}
1046
1047
7524cfb1 1048static void wpa_driver_nl80211_event_link(struct wpa_driver_nl80211_data *drv,
08063178 1049 char *buf, size_t len, int del)
3f5285e8
JM		 1050{
1051 union wpa_event_data event;
1052
1053 os_memset(&event, 0, sizeof(event));
1054 if (len > sizeof(event.interface_status.ifname))
1055 len = sizeof(event.interface_status.ifname) - 1;
1056 os_memcpy(event.interface_status.ifname, buf, len);
1057 event.interface_status.ievent = del ? EVENT_INTERFACE_REMOVED :
1058 EVENT_INTERFACE_ADDED;
1059
1060 wpa_printf(MSG_DEBUG, "RTM_%sLINK, IFLA_IFNAME: Interface '%s' %s",
1061 del ? "DEL" : "NEW",
1062 event.interface_status.ifname,
1063 del ? "removed" : "added");
1064
834ee56f
KP		 1065 if (os_strcmp(drv->first_bss->ifname, event.interface_status.ifname) ==
1066 0) {
d1f4942b
JM		 1067 if (del) {
1068 if (drv->if_removed) {
1069 wpa_printf(MSG_DEBUG, "nl80211: if_removed "
1070 "already set - ignore event");
1071 return;
1072 }
7524cfb1 1073 drv->if_removed = 1;
d1f4942b 1074 } else {
834ee56f 1075 if (if_nametoindex(drv->first_bss->ifname) == 0) {
d1f4942b
JM		 1076 wpa_printf(MSG_DEBUG, "nl80211: Interface %s "
1077 "does not exist - ignore "
1078 "RTM_NEWLINK",
834ee56f 1079 drv->first_bss->ifname);
d1f4942b
JM		 1080 return;
1081 }
1082 if (!drv->if_removed) {
1083 wpa_printf(MSG_DEBUG, "nl80211: if_removed "
1084 "already cleared - ignore event");
1085 return;
1086 }
7524cfb1 1087 drv->if_removed = 0;
d1f4942b 1088 }
7524cfb1
JM		 1089 }
1090
08063178 1091 wpa_supplicant_event(drv->ctx, EVENT_INTERFACE_STATUS, &event);
3f5285e8
JM		 1092}
1093
1094
7524cfb1 1095static int wpa_driver_nl80211_own_ifname(struct wpa_driver_nl80211_data *drv,
62d680c3 1096 u8 *buf, size_t len)
7524cfb1 1097{
62d680c3 1098 int attrlen, rta_len;
7524cfb1
JM		 1099 struct rtattr *attr;
1100
62d680c3
JM		 1101 attrlen = len;
1102 attr = (struct rtattr *) buf;
7524cfb1
JM		 1103
1104 rta_len = RTA_ALIGN(sizeof(struct rtattr));
1105 while (RTA_OK(attr, attrlen)) {
1106 if (attr->rta_type == IFLA_IFNAME) {
834ee56f
KP		 1107 if (os_strcmp(((char *) attr) + rta_len,
1108 drv->first_bss->ifname) == 0)
7524cfb1
JM		 1109 return 1;
1110 else
1111 break;
1112 }
1113 attr = RTA_NEXT(attr, attrlen);
1114 }
1115
1116 return 0;
1117}
1118
1119
1120static int wpa_driver_nl80211_own_ifindex(struct wpa_driver_nl80211_data *drv,
62d680c3 1121 int ifindex, u8 *buf, size_t len)
7524cfb1
JM		 1122{
1123 if (drv->ifindex == ifindex)
1124 return 1;
1125
62d680c3 1126 if (drv->if_removed && wpa_driver_nl80211_own_ifname(drv, buf, len)) {
7524cfb1
JM		 1127 wpa_printf(MSG_DEBUG, "nl80211: Update ifindex for a removed "
1128 "interface");
49b4b205 1129 wpa_driver_nl80211_finish_drv_init(drv, NULL, 0);
7524cfb1
JM		 1130 return 1;
1131 }
1132
1133 return 0;
1134}
1135
1136
36d84860
BG		 1137static struct wpa_driver_nl80211_data *
1138nl80211_find_drv(struct nl80211_global *global, int idx, u8 *buf, size_t len)
1139{
1140 struct wpa_driver_nl80211_data *drv;
1141 dl_list_for_each(drv, &global->interfaces,
1142 struct wpa_driver_nl80211_data, list) {
1143 if (wpa_driver_nl80211_own_ifindex(drv, idx, buf, len) ||
1144 have_ifidx(drv, idx))
1145 return drv;
1146 }
1147 return NULL;
1148}
1149
1150
62d680c3
JM		 1151static void wpa_driver_nl80211_event_rtm_newlink(void *ctx,
1152 struct ifinfomsg *ifi,
1153 u8 *buf, size_t len)
3f5285e8 1154{
36d84860
BG		 1155 struct nl80211_global *global = ctx;
1156 struct wpa_driver_nl80211_data *drv;
62d680c3
JM		 1157 int attrlen, rta_len;
1158 struct rtattr *attr;
97cfcf64 1159 u32 brid = 0;
aef85ba2 1160 char namebuf[IFNAMSIZ];
3f5285e8 1161
36d84860
BG		 1162 drv = nl80211_find_drv(global, ifi->ifi_index, buf, len);
1163 if (!drv) {
97cfcf64
B		 1164 wpa_printf(MSG_DEBUG, "nl80211: Ignore event for foreign "
1165 "ifindex %d", ifi->ifi_index);
3f5285e8
JM		 1166 return;
1167 }
1168
1169 wpa_printf(MSG_DEBUG, "RTM_NEWLINK: operstate=%d ifi_flags=0x%x "
1170 "(%s%s%s%s)",
1171 drv->operstate, ifi->ifi_flags,
1172 (ifi->ifi_flags & IFF_UP) ? "[UP]" : "",
1173 (ifi->ifi_flags & IFF_RUNNING) ? "[RUNNING]" : "",
1174 (ifi->ifi_flags & IFF_LOWER_UP) ? "[LOWER_UP]" : "",
1175 (ifi->ifi_flags & IFF_DORMANT) ? "[DORMANT]" : "");
a63063b4
JM		 1176
1177 if (!drv->if_disabled && !(ifi->ifi_flags & IFF_UP)) {
59d24925
JM		 1178 if (if_indextoname(ifi->ifi_index, namebuf) &&
1179 linux_iface_up(drv->global->ioctl_sock,
834ee56f 1180 drv->first_bss->ifname) > 0) {
59d24925
JM		 1181 wpa_printf(MSG_DEBUG, "nl80211: Ignore interface down "
1182 "event since interface %s is up", namebuf);
1183 return;
1184 }
a63063b4 1185 wpa_printf(MSG_DEBUG, "nl80211: Interface down");
7d9c3698
JM		 1186 if (drv->ignore_if_down_event) {
1187 wpa_printf(MSG_DEBUG, "nl80211: Ignore interface down "
1188 "event generated by mode change");
1189 drv->ignore_if_down_event = 0;
1190 } else {
1191 drv->if_disabled = 1;
1192 wpa_supplicant_event(drv->ctx,
1193 EVENT_INTERFACE_DISABLED, NULL);
1194 }
a63063b4
JM		 1195 }
1196
1197 if (drv->if_disabled && (ifi->ifi_flags & IFF_UP)) {
aef85ba2
JM		 1198 if (if_indextoname(ifi->ifi_index, namebuf) &&
1199 linux_iface_up(drv->global->ioctl_sock,
834ee56f 1200 drv->first_bss->ifname) == 0) {
aef85ba2
JM		 1201 wpa_printf(MSG_DEBUG, "nl80211: Ignore interface up "
1202 "event since interface %s is down",
1203 namebuf);
834ee56f 1204 } else if (if_nametoindex(drv->first_bss->ifname) == 0) {
d1f4942b
JM		 1205 wpa_printf(MSG_DEBUG, "nl80211: Ignore interface up "
1206 "event since interface %s does not exist",
834ee56f 1207 drv->first_bss->ifname);
d1f4942b
JM		 1208 } else if (drv->if_removed) {
1209 wpa_printf(MSG_DEBUG, "nl80211: Ignore interface up "
1210 "event since interface %s is marked "
834ee56f 1211 "removed", drv->first_bss->ifname);
aef85ba2
JM		 1212 } else {
1213 wpa_printf(MSG_DEBUG, "nl80211: Interface up");
1214 drv->if_disabled = 0;
1215 wpa_supplicant_event(drv->ctx, EVENT_INTERFACE_ENABLED,
1216 NULL);
1217 }
a63063b4
JM		 1218 }
1219
3f5285e8
JM		 1220 /*
1221 * Some drivers send the association event before the operup event--in
1222 * this case, lifting operstate in wpa_driver_nl80211_set_operstate()
1223 * fails. This will hit us when wpa_supplicant does not need to do
1224 * IEEE 802.1X authentication
1225 */
1226 if (drv->operstate == 1 &&
1227 (ifi->ifi_flags & (IFF_LOWER_UP | IFF_DORMANT)) == IFF_LOWER_UP &&
1228 !(ifi->ifi_flags & IFF_RUNNING))
36d84860 1229 netlink_send_oper_ifla(drv->global->netlink, drv->ifindex,
e2d02c29 1230 -1, IF_OPER_UP);
3f5285e8 1231
62d680c3
JM		 1232 attrlen = len;
1233 attr = (struct rtattr *) buf;
3f5285e8
JM		 1234 rta_len = RTA_ALIGN(sizeof(struct rtattr));
1235 while (RTA_OK(attr, attrlen)) {
d8816397 1236 if (attr->rta_type == IFLA_IFNAME) {
7524cfb1 1237 wpa_driver_nl80211_event_link(
08063178 1238 drv,
7524cfb1
JM		 1239 ((char *) attr) + rta_len,
1240 attr->rta_len - rta_len, 0);
97cfcf64
B		 1241 } else if (attr->rta_type == IFLA_MASTER)
1242 brid = nla_get_u32((struct nlattr *) attr);
3f5285e8
JM		 1243 attr = RTA_NEXT(attr, attrlen);
1244 }
97cfcf64
B		 1245
1246 if (ifi->ifi_family == AF_BRIDGE && brid) {
1247 /* device has been added to bridge */
97cfcf64
B		 1248 if_indextoname(brid, namebuf);
1249 wpa_printf(MSG_DEBUG, "nl80211: Add ifindex %u for bridge %s",
1250 brid, namebuf);
1251 add_ifidx(drv, brid);
1252 }
3f5285e8
JM		 1253}
1254
1255
62d680c3
JM		 1256static void wpa_driver_nl80211_event_rtm_dellink(void *ctx,
1257 struct ifinfomsg *ifi,
1258 u8 *buf, size_t len)
3f5285e8 1259{
36d84860
BG		 1260 struct nl80211_global *global = ctx;
1261 struct wpa_driver_nl80211_data *drv;
62d680c3
JM		 1262 int attrlen, rta_len;
1263 struct rtattr *attr;
97cfcf64 1264 u32 brid = 0;
3f5285e8 1265
36d84860
BG		 1266 drv = nl80211_find_drv(global, ifi->ifi_index, buf, len);
1267 if (!drv) {
1268 wpa_printf(MSG_DEBUG, "nl80211: Ignore dellink event for "
1269 "foreign ifindex %d", ifi->ifi_index);
1270 return;
1271 }
1272
62d680c3
JM		 1273 attrlen = len;
1274 attr = (struct rtattr *) buf;
3f5285e8
JM		 1275
1276 rta_len = RTA_ALIGN(sizeof(struct rtattr));
1277 while (RTA_OK(attr, attrlen)) {
1278 if (attr->rta_type == IFLA_IFNAME) {
7524cfb1 1279 wpa_driver_nl80211_event_link(
08063178 1280 drv,
7524cfb1
JM		 1281 ((char *) attr) + rta_len,
1282 attr->rta_len - rta_len, 1);
97cfcf64
B		 1283 } else if (attr->rta_type == IFLA_MASTER)
1284 brid = nla_get_u32((struct nlattr *) attr);
3f5285e8
JM		 1285 attr = RTA_NEXT(attr, attrlen);
1286 }
97cfcf64
B		 1287
1288 if (ifi->ifi_family == AF_BRIDGE && brid) {
1289 /* device has been removed from bridge */
1290 char namebuf[IFNAMSIZ];
1291 if_indextoname(brid, namebuf);
1292 wpa_printf(MSG_DEBUG, "nl80211: Remove ifindex %u for bridge "
1293 "%s", brid, namebuf);
1294 del_ifidx(drv, brid);
1295 }
3f5285e8
JM		 1296}
1297
1298
c2a04078
JM		 1299static void mlme_event_auth(struct wpa_driver_nl80211_data *drv,
1300 const u8 *frame, size_t len)
1301{
1302 const struct ieee80211_mgmt *mgmt;
1303 union wpa_event_data event;
1304
7d81932d 1305 wpa_printf(MSG_DEBUG, "nl80211: Authenticate event");
c2a04078
JM		 1306 mgmt = (const struct ieee80211_mgmt *) frame;
1307 if (len < 24 + sizeof(mgmt->u.auth)) {
1308 wpa_printf(MSG_DEBUG, "nl80211: Too short association event "
1309 "frame");
1310 return;
1311 }
1312
e6b8efeb 1313 os_memcpy(drv->auth_bssid, mgmt->sa, ETH_ALEN);
add9b7a4 1314 os_memset(drv->auth_attempt_bssid, 0, ETH_ALEN);
c2a04078
JM		 1315 os_memset(&event, 0, sizeof(event));
1316 os_memcpy(event.auth.peer, mgmt->sa, ETH_ALEN);
1317 event.auth.auth_type = le_to_host16(mgmt->u.auth.auth_alg);
569fed90
JM		 1318 event.auth.auth_transaction =
1319 le_to_host16(mgmt->u.auth.auth_transaction);
c2a04078
JM		 1320 event.auth.status_code = le_to_host16(mgmt->u.auth.status_code);
1321 if (len > 24 + sizeof(mgmt->u.auth)) {
1322 event.auth.ies = mgmt->u.auth.variable;
1323 event.auth.ies_len = len - 24 - sizeof(mgmt->u.auth);
1324 }
1325
1326 wpa_supplicant_event(drv->ctx, EVENT_AUTH, &event);
1327}
1328
1329
f5a8d422
JM		 1330static unsigned int nl80211_get_assoc_freq(struct wpa_driver_nl80211_data *drv)
1331{
1332 struct nl_msg *msg;
1333 int ret;
1334 struct nl80211_bss_info_arg arg;
1335
1336 os_memset(&arg, 0, sizeof(arg));
1337 msg = nlmsg_alloc();
1338 if (!msg)
1339 goto nla_put_failure;
1340
9fb04070 1341 nl80211_cmd(drv, msg, NLM_F_DUMP, NL80211_CMD_GET_SCAN);
f5a8d422
JM		 1342 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
1343
1344 arg.drv = drv;
1345 ret = send_and_recv_msgs(drv, msg, bss_info_handler, &arg);
1346 msg = NULL;
1347 if (ret == 0) {
1348 wpa_printf(MSG_DEBUG, "nl80211: Operating frequency for the "
1349 "associated BSS from scan results: %u MHz",
1350 arg.assoc_freq);
30158a0d
SD		 1351 if (arg.assoc_freq)
1352 drv->assoc_freq = arg.assoc_freq;
1353 return drv->assoc_freq;
f5a8d422
JM		 1354 }
1355 wpa_printf(MSG_DEBUG, "nl80211: Scan result fetch failed: ret=%d "
1356 "(%s)", ret, strerror(-ret));
1357nla_put_failure:
1358 nlmsg_free(msg);
1359 return drv->assoc_freq;
1360}
1361
1362
c2a04078
JM		 1363static void mlme_event_assoc(struct wpa_driver_nl80211_data *drv,
1364 const u8 *frame, size_t len)
1365{
1366 const struct ieee80211_mgmt *mgmt;
1367 union wpa_event_data event;
1368 u16 status;
1369
7d81932d 1370 wpa_printf(MSG_DEBUG, "nl80211: Associate event");
c2a04078
JM		 1371 mgmt = (const struct ieee80211_mgmt *) frame;
1372 if (len < 24 + sizeof(mgmt->u.assoc_resp)) {
1373 wpa_printf(MSG_DEBUG, "nl80211: Too short association event "
1374 "frame");
1375 return;
1376 }
1377
1378 status = le_to_host16(mgmt->u.assoc_resp.status_code);
1379 if (status != WLAN_STATUS_SUCCESS) {
efa46078 1380 os_memset(&event, 0, sizeof(event));
59ddf221 1381 event.assoc_reject.bssid = mgmt->bssid;
efa46078
JM		 1382 if (len > 24 + sizeof(mgmt->u.assoc_resp)) {
1383 event.assoc_reject.resp_ies =
1384 (u8 *) mgmt->u.assoc_resp.variable;
1385 event.assoc_reject.resp_ies_len =
1386 len - 24 - sizeof(mgmt->u.assoc_resp);
1387 }
1388 event.assoc_reject.status_code = status;
1389
1390 wpa_supplicant_event(drv->ctx, EVENT_ASSOC_REJECT, &event);
c2a04078
JM		 1391 return;
1392 }
1393
1394 drv->associated = 1;
1395 os_memcpy(drv->bssid, mgmt->sa, ETH_ALEN);
add9b7a4 1396 os_memcpy(drv->prev_bssid, mgmt->sa, ETH_ALEN);
c2a04078
JM		 1397
1398 os_memset(&event, 0, sizeof(event));
1399 if (len > 24 + sizeof(mgmt->u.assoc_resp)) {
1400 event.assoc_info.resp_ies = (u8 *) mgmt->u.assoc_resp.variable;
1401 event.assoc_info.resp_ies_len =
efa46078 1402 len - 24 - sizeof(mgmt->u.assoc_resp);
c2a04078
JM		 1403 }
1404
4832ecd7
JM		 1405 event.assoc_info.freq = drv->assoc_freq;
1406
c2a04078
JM		 1407 wpa_supplicant_event(drv->ctx, EVENT_ASSOC, &event);
1408}
1409
c1bb3e0a 1410
da72a1c1
ZY		 1411static void mlme_event_connect(struct wpa_driver_nl80211_data *drv,
1412 enum nl80211_commands cmd, struct nlattr *status,
1413 struct nlattr *addr, struct nlattr *req_ie,
1414 struct nlattr *resp_ie)
1415{
1416 union wpa_event_data event;
1417
7da2c527
JM		 1418 if (drv->capa.flags & WPA_DRIVER_FLAGS_SME) {
1419 /*
1420 * Avoid reporting two association events that would confuse
1421 * the core code.
1422 */
1423 wpa_printf(MSG_DEBUG, "nl80211: Ignore connect event (cmd=%d) "
1424 "when using userspace SME", cmd);
1425 return;
1426 }
1427
7d81932d
JM		 1428 if (cmd == NL80211_CMD_CONNECT)
1429 wpa_printf(MSG_DEBUG, "nl80211: Connect event");
1430 else if (cmd == NL80211_CMD_ROAM)
1431 wpa_printf(MSG_DEBUG, "nl80211: Roam event");
1432
da72a1c1
ZY		 1433 os_memset(&event, 0, sizeof(event));
1434 if (cmd == NL80211_CMD_CONNECT &&
1435 nla_get_u16(status) != WLAN_STATUS_SUCCESS) {
df89c1c8
JM		 1436 if (addr)
1437 event.assoc_reject.bssid = nla_data(addr);
da72a1c1
ZY		 1438 if (resp_ie) {
1439 event.assoc_reject.resp_ies = nla_data(resp_ie);
1440 event.assoc_reject.resp_ies_len = nla_len(resp_ie);
1441 }
1442 event.assoc_reject.status_code = nla_get_u16(status);
1443 wpa_supplicant_event(drv->ctx, EVENT_ASSOC_REJECT, &event);
1444 return;
1445 }
1446
1447 drv->associated = 1;
add9b7a4 1448 if (addr) {
da72a1c1 1449 os_memcpy(drv->bssid, nla_data(addr), ETH_ALEN);
add9b7a4
JM		 1450 os_memcpy(drv->prev_bssid, drv->bssid, ETH_ALEN);
1451 }
da72a1c1
ZY		 1452
1453 if (req_ie) {
1454 event.assoc_info.req_ies = nla_data(req_ie);
1455 event.assoc_info.req_ies_len = nla_len(req_ie);
1456 }
1457 if (resp_ie) {
1458 event.assoc_info.resp_ies = nla_data(resp_ie);
1459 event.assoc_info.resp_ies_len = nla_len(resp_ie);
1460 }
1461
f5a8d422
JM		 1462 event.assoc_info.freq = nl80211_get_assoc_freq(drv);
1463
da72a1c1
ZY		 1464 wpa_supplicant_event(drv->ctx, EVENT_ASSOC, &event);
1465}
c2a04078 1466
c1bb3e0a 1467
20f5a4c2 1468static void mlme_event_disconnect(struct wpa_driver_nl80211_data *drv,
3d9975d5
JM		 1469 struct nlattr *reason, struct nlattr *addr,
1470 struct nlattr *by_ap)
20f5a4c2
JM		 1471{
1472 union wpa_event_data data;
a8c5b43a 1473 unsigned int locally_generated = by_ap == NULL;
20f5a4c2
JM		 1474
1475 if (drv->capa.flags & WPA_DRIVER_FLAGS_SME) {
1476 /*
1477 * Avoid reporting two disassociation events that could
1478 * confuse the core code.
1479 */
1480 wpa_printf(MSG_DEBUG, "nl80211: Ignore disconnect "
1481 "event when using userspace SME");
1482 return;
1483 }
1484
a8c5b43a
CW		 1485 if (drv->ignore_next_local_disconnect) {
1486 drv->ignore_next_local_disconnect = 0;
1487 if (locally_generated) {
1488 wpa_printf(MSG_DEBUG, "nl80211: Ignore disconnect "
1489 "event triggered during reassociation");
1490 return;
1491 }
1492 wpa_printf(MSG_WARNING, "nl80211: Was expecting local "
1493 "disconnect but got another disconnect "
1494 "event first");
1495 }
1496
7d81932d 1497 wpa_printf(MSG_DEBUG, "nl80211: Disconnect event");
add9b7a4 1498 nl80211_mark_disconnected(drv);
20f5a4c2
JM		 1499 os_memset(&data, 0, sizeof(data));
1500 if (reason)
2e9f078c
JM		 1501 data.deauth_info.reason_code = nla_get_u16(reason);
1502 data.deauth_info.locally_generated = by_ap == NULL;
1503 wpa_supplicant_event(drv->ctx, EVENT_DEAUTH, &data);
20f5a4c2
JM		 1504}
1505
1506
1b487b8b 1507static void mlme_event_ch_switch(struct wpa_driver_nl80211_data *drv,
8d1fdde7
JD		 1508 struct nlattr *ifindex, struct nlattr *freq,
1509 struct nlattr *type, struct nlattr *bw,
1510 struct nlattr *cf1, struct nlattr *cf2)
1b487b8b 1511{
8d1fdde7 1512 struct i802_bss *bss;
1b487b8b
TP		 1513 union wpa_event_data data;
1514 int ht_enabled = 1;
1515 int chan_offset = 0;
8d1fdde7 1516 int ifidx;
1b487b8b
TP		 1517
1518 wpa_printf(MSG_DEBUG, "nl80211: Channel switch event");
1519
8d1fdde7 1520 if (!freq)
1b487b8b
TP		 1521 return;
1522
8d1fdde7
JD		 1523 ifidx = nla_get_u32(ifindex);
1524 for (bss = drv->first_bss; bss; bss = bss->next)
1525 if (bss->ifindex == ifidx)
1526 break;
1527
1528 if (bss == NULL) {
1529 wpa_printf(MSG_WARNING, "nl80211: Unknown ifindex (%d) for channel switch, ignoring",
1530 ifidx);
1531 return;
1b487b8b
TP		 1532 }
1533
8d1fdde7
JD		 1534 if (type) {
1535 switch (nla_get_u32(type)) {
1536 case NL80211_CHAN_NO_HT:
1537 ht_enabled = 0;
1538 break;
1539 case NL80211_CHAN_HT20:
1540 break;
1541 case NL80211_CHAN_HT40PLUS:
1542 chan_offset = 1;
1543 break;
1544 case NL80211_CHAN_HT40MINUS:
1545 chan_offset = -1;
1546 break;
1547 }
1548 }
1549
1550 os_memset(&data, 0, sizeof(data));
1b487b8b
TP		 1551 data.ch_switch.freq = nla_get_u32(freq);
1552 data.ch_switch.ht_enabled = ht_enabled;
1553 data.ch_switch.ch_offset = chan_offset;
8d1fdde7
JD		 1554 if (bw)
1555 data.ch_switch.ch_width = convert2width(nla_get_u32(bw));
1556 if (cf1)
1557 data.ch_switch.cf1 = nla_get_u32(cf1);
1558 if (cf2)
1559 data.ch_switch.cf2 = nla_get_u32(cf2);
1b487b8b 1560
8d1fdde7 1561 bss->freq = data.ch_switch.freq;
1c4ffa87 1562
1b487b8b
TP		 1563 wpa_supplicant_event(drv->ctx, EVENT_CH_SWITCH, &data);
1564}
1565
1566
da1fb17c
JM		 1567static void mlme_timeout_event(struct wpa_driver_nl80211_data *drv,
1568 enum nl80211_commands cmd, struct nlattr *addr)
1569{
1570 union wpa_event_data event;
1571 enum wpa_event_type ev;
1572
1573 if (nla_len(addr) != ETH_ALEN)
1574 return;
1575
1576 wpa_printf(MSG_DEBUG, "nl80211: MLME event %d; timeout with " MACSTR,
1577 cmd, MAC2STR((u8 *) nla_data(addr)));
1578
1579 if (cmd == NL80211_CMD_AUTHENTICATE)
1580 ev = EVENT_AUTH_TIMED_OUT;
1581 else if (cmd == NL80211_CMD_ASSOCIATE)
1582 ev = EVENT_ASSOC_TIMED_OUT;
1583 else
1584 return;
1585
1586 os_memset(&event, 0, sizeof(event));
1587 os_memcpy(event.timeout_event.addr, nla_data(addr), ETH_ALEN);
1588 wpa_supplicant_event(drv->ctx, ev, &event);
1589}
1590
1591
5582a5d1 1592static void mlme_event_mgmt(struct wpa_driver_nl80211_data *drv,
da873dbb
JB		 1593 struct nlattr *freq, struct nlattr *sig,
1594 const u8 *frame, size_t len)
58f6fbe0
JM		 1595{
1596 const struct ieee80211_mgmt *mgmt;
1597 union wpa_event_data event;
1598 u16 fc, stype;
da873dbb 1599 int ssi_signal = 0;
f18b7817 1600 int rx_freq = 0;
58f6fbe0 1601
cc2ada86 1602 wpa_printf(MSG_MSGDUMP, "nl80211: Frame event");
58f6fbe0
JM		 1603 mgmt = (const struct ieee80211_mgmt *) frame;
1604 if (len < 24) {
1605 wpa_printf(MSG_DEBUG, "nl80211: Too short action frame");
1606 return;
1607 }
1608
1609 fc = le_to_host16(mgmt->frame_control);
1610 stype = WLAN_FC_GET_STYPE(fc);
1611
da873dbb
JB		 1612 if (sig)
1613 ssi_signal = (s32) nla_get_u32(sig);
1614
58f6fbe0 1615 os_memset(&event, 0, sizeof(event));
5582a5d1 1616 if (freq) {
58f6fbe0 1617 event.rx_action.freq = nla_get_u32(freq);
f18b7817 1618 rx_freq = drv->last_mgmt_freq = event.rx_action.freq;
5582a5d1 1619 }
f18b7817
JM		 1620 wpa_printf(MSG_DEBUG,
1621 "nl80211: RX frame freq=%d ssi_signal=%d stype=%u len=%u",
1622 rx_freq, ssi_signal, stype, (unsigned int) len);
5582a5d1
JB		 1623 if (stype == WLAN_FC_STYPE_ACTION) {
1624 event.rx_action.da = mgmt->da;
1625 event.rx_action.sa = mgmt->sa;
1626 event.rx_action.bssid = mgmt->bssid;
1627 event.rx_action.category = mgmt->u.action.category;
1628 event.rx_action.data = &mgmt->u.action.category + 1;
1629 event.rx_action.len = frame + len - event.rx_action.data;
1630 wpa_supplicant_event(drv->ctx, EVENT_RX_ACTION, &event);
1631 } else {
1632 event.rx_mgmt.frame = frame;
1633 event.rx_mgmt.frame_len = len;
da873dbb 1634 event.rx_mgmt.ssi_signal = ssi_signal;
5582a5d1
JB		 1635 wpa_supplicant_event(drv->ctx, EVENT_RX_MGMT, &event);
1636 }
58f6fbe0
JM		 1637}
1638
1639
a11241fa
JB		 1640static void mlme_event_mgmt_tx_status(struct wpa_driver_nl80211_data *drv,
1641 struct nlattr *cookie, const u8 *frame,
1642 size_t len, struct nlattr *ack)
58f6fbe0
JM		 1643{
1644 union wpa_event_data event;
1645 const struct ieee80211_hdr *hdr;
1646 u16 fc;
58f6fbe0 1647
7d81932d 1648 wpa_printf(MSG_DEBUG, "nl80211: Frame TX status event");
a11241fa
JB		 1649 if (!is_ap_interface(drv->nlmode)) {
1650 u64 cookie_val;
58f6fbe0 1651
a11241fa
JB		 1652 if (!cookie)
1653 return;
1654
1655 cookie_val = nla_get_u64(cookie);
1656 wpa_printf(MSG_DEBUG, "nl80211: Action TX status:"
1657 " cookie=0%llx%s (ack=%d)",
1658 (long long unsigned int) cookie_val,
1659 cookie_val == drv->send_action_cookie ?
1660 " (match)" : " (unknown)", ack != NULL);
1661 if (cookie_val != drv->send_action_cookie)
1662 return;
1663 }
58f6fbe0
JM		 1664
1665 hdr = (const struct ieee80211_hdr *) frame;
1666 fc = le_to_host16(hdr->frame_control);
1667
1668 os_memset(&event, 0, sizeof(event));
1669 event.tx_status.type = WLAN_FC_GET_TYPE(fc);
1670 event.tx_status.stype = WLAN_FC_GET_STYPE(fc);
1671 event.tx_status.dst = hdr->addr1;
1672 event.tx_status.data = frame;
1673 event.tx_status.data_len = len;
1674 event.tx_status.ack = ack != NULL;
1675 wpa_supplicant_event(drv->ctx, EVENT_TX_STATUS, &event);
1676}
1677
1678
0544b242
JM		 1679static void mlme_event_deauth_disassoc(struct wpa_driver_nl80211_data *drv,
1680 enum wpa_event_type type,
1681 const u8 *frame, size_t len)
1682{
1683 const struct ieee80211_mgmt *mgmt;
1684 union wpa_event_data event;
1685 const u8 *bssid = NULL;
1686 u16 reason_code = 0;
1687
7d81932d
JM		 1688 if (type == EVENT_DEAUTH)
1689 wpa_printf(MSG_DEBUG, "nl80211: Deauthenticate event");
1690 else
1691 wpa_printf(MSG_DEBUG, "nl80211: Disassociate event");
1692
cb30b297
PS		 1693 mgmt = (const struct ieee80211_mgmt *) frame;
1694 if (len >= 24) {
1695 bssid = mgmt->bssid;
1696
add9b7a4
JM		 1697 if ((drv->capa.flags & WPA_DRIVER_FLAGS_SME) &&
1698 !drv->associated &&
1699 os_memcmp(bssid, drv->auth_bssid, ETH_ALEN) != 0 &&
1700 os_memcmp(bssid, drv->auth_attempt_bssid, ETH_ALEN) != 0 &&
1701 os_memcmp(bssid, drv->prev_bssid, ETH_ALEN) == 0) {
1702 /*
1703 * Avoid issues with some roaming cases where
1704 * disconnection event for the old AP may show up after
1705 * we have started connection with the new AP.
1706 */
1707 wpa_printf(MSG_DEBUG, "nl80211: Ignore deauth/disassoc event from old AP " MACSTR " when already authenticating with " MACSTR,
1708 MAC2STR(bssid),
1709 MAC2STR(drv->auth_attempt_bssid));
1710 return;
1711 }
1712
cb30b297
PS		 1713 if (drv->associated != 0 &&
1714 os_memcmp(bssid, drv->bssid, ETH_ALEN) != 0 &&
1715 os_memcmp(bssid, drv->auth_bssid, ETH_ALEN) != 0) {
1716 /*
1717 * We have presumably received this deauth as a
1718 * response to a clear_state_mismatch() outgoing
1719 * deauth. Don't let it take us offline!
1720 */
1721 wpa_printf(MSG_DEBUG, "nl80211: Deauth received "
1722 "from Unknown BSSID " MACSTR " -- ignoring",
1723 MAC2STR(bssid));
1724 return;
1725 }
1726 }
1727
add9b7a4 1728 nl80211_mark_disconnected(drv);
0544b242
JM		 1729 os_memset(&event, 0, sizeof(event));
1730
0544b242
JM		 1731 /* Note: Same offset for Reason Code in both frame subtypes */
1732 if (len >= 24 + sizeof(mgmt->u.deauth))
1733 reason_code = le_to_host16(mgmt->u.deauth.reason_code);
1734
1735 if (type == EVENT_DISASSOC) {
3d9975d5 1736 event.disassoc_info.locally_generated =
834ee56f 1737 !os_memcmp(mgmt->sa, drv->first_bss->addr, ETH_ALEN);
0544b242
JM		 1738 event.disassoc_info.addr = bssid;
1739 event.disassoc_info.reason_code = reason_code;
046b26a2
JM		 1740 if (frame + len > mgmt->u.disassoc.variable) {
1741 event.disassoc_info.ie = mgmt->u.disassoc.variable;
1742 event.disassoc_info.ie_len = frame + len -
1743 mgmt->u.disassoc.variable;
1744 }
0544b242 1745 } else {
3d9975d5 1746 event.deauth_info.locally_generated =
834ee56f 1747 !os_memcmp(mgmt->sa, drv->first_bss->addr, ETH_ALEN);
0544b242
JM		 1748 event.deauth_info.addr = bssid;
1749 event.deauth_info.reason_code = reason_code;
046b26a2
JM		 1750 if (frame + len > mgmt->u.deauth.variable) {
1751 event.deauth_info.ie = mgmt->u.deauth.variable;
1752 event.deauth_info.ie_len = frame + len -
1753 mgmt->u.deauth.variable;
1754 }
0544b242
JM		 1755 }
1756
1757 wpa_supplicant_event(drv->ctx, type, &event);
1758}
1759
1760
7d878ca7
JM		 1761static void mlme_event_unprot_disconnect(struct wpa_driver_nl80211_data *drv,
1762 enum wpa_event_type type,
1763 const u8 *frame, size_t len)
1764{
1765 const struct ieee80211_mgmt *mgmt;
1766 union wpa_event_data event;
1767 u16 reason_code = 0;
1768
7d81932d
JM		 1769 if (type == EVENT_UNPROT_DEAUTH)
1770 wpa_printf(MSG_DEBUG, "nl80211: Unprot Deauthenticate event");
1771 else
1772 wpa_printf(MSG_DEBUG, "nl80211: Unprot Disassociate event");
1773
7d878ca7
JM		 1774 if (len < 24)
1775 return;
1776
1777 mgmt = (const struct ieee80211_mgmt *) frame;
1778
1779 os_memset(&event, 0, sizeof(event));
1780 /* Note: Same offset for Reason Code in both frame subtypes */
1781 if (len >= 24 + sizeof(mgmt->u.deauth))
1782 reason_code = le_to_host16(mgmt->u.deauth.reason_code);
1783
1784 if (type == EVENT_UNPROT_DISASSOC) {
1785 event.unprot_disassoc.sa = mgmt->sa;
1786 event.unprot_disassoc.da = mgmt->da;
1787 event.unprot_disassoc.reason_code = reason_code;
1788 } else {
1789 event.unprot_deauth.sa = mgmt->sa;
1790 event.unprot_deauth.da = mgmt->da;
1791 event.unprot_deauth.reason_code = reason_code;
1792 }
1793
1794 wpa_supplicant_event(drv->ctx, type, &event);
1795}
1796
1797
97279d8d 1798static void mlme_event(struct i802_bss *bss,
da1fb17c 1799 enum nl80211_commands cmd, struct nlattr *frame,
58f6fbe0
JM		 1800 struct nlattr *addr, struct nlattr *timed_out,
1801 struct nlattr *freq, struct nlattr *ack,
da873dbb 1802 struct nlattr *cookie, struct nlattr *sig)
c2a04078 1803{
97279d8d
JM		 1804 struct wpa_driver_nl80211_data *drv = bss->drv;
1805 const u8 *data;
1806 size_t len;
1807
da1fb17c
JM		 1808 if (timed_out && addr) {
1809 mlme_timeout_event(drv, cmd, addr);
1810 return;
1811 }
1812
c2a04078 1813 if (frame == NULL) {
2090a0b4
DS		 1814 wpa_printf(MSG_DEBUG,
1815 "nl80211: MLME event %d (%s) without frame data",
1816 cmd, nl80211_command_to_string(cmd));
c2a04078
JM		 1817 return;
1818 }
1819
97279d8d
JM		 1820 data = nla_data(frame);
1821 len = nla_len(frame);
455299fb 1822 if (len < 4 + 2 * ETH_ALEN) {
2090a0b4
DS		 1823 wpa_printf(MSG_MSGDUMP, "nl80211: MLME event %d (%s) on %s("
1824 MACSTR ") - too short",
1825 cmd, nl80211_command_to_string(cmd), bss->ifname,
1826 MAC2STR(bss->addr));
97279d8d
JM		 1827 return;
1828 }
2090a0b4
DS		 1829 wpa_printf(MSG_MSGDUMP, "nl80211: MLME event %d (%s) on %s(" MACSTR
1830 ") A1=" MACSTR " A2=" MACSTR, cmd,
1831 nl80211_command_to_string(cmd), bss->ifname,
1832 MAC2STR(bss->addr), MAC2STR(data + 4),
1833 MAC2STR(data + 4 + ETH_ALEN));
97279d8d 1834 if (cmd != NL80211_CMD_FRAME_TX_STATUS && !(data[4] & 0x01) &&
455299fb
JM		 1835 os_memcmp(bss->addr, data + 4, ETH_ALEN) != 0 &&
1836 os_memcmp(bss->addr, data + 4 + ETH_ALEN, ETH_ALEN) != 0) {
97279d8d
JM		 1837 wpa_printf(MSG_MSGDUMP, "nl80211: %s: Ignore MLME frame event "
1838 "for foreign address", bss->ifname);
1839 return;
1840 }
c2a04078
JM		 1841 wpa_hexdump(MSG_MSGDUMP, "nl80211: MLME event frame",
1842 nla_data(frame), nla_len(frame));
1843
1844 switch (cmd) {
1845 case NL80211_CMD_AUTHENTICATE:
1846 mlme_event_auth(drv, nla_data(frame), nla_len(frame));
1847 break;
1848 case NL80211_CMD_ASSOCIATE:
1849 mlme_event_assoc(drv, nla_data(frame), nla_len(frame));
1850 break;
1851 case NL80211_CMD_DEAUTHENTICATE:
0544b242
JM		 1852 mlme_event_deauth_disassoc(drv, EVENT_DEAUTH,
1853 nla_data(frame), nla_len(frame));
c2a04078
JM		 1854 break;
1855 case NL80211_CMD_DISASSOCIATE:
0544b242
JM		 1856 mlme_event_deauth_disassoc(drv, EVENT_DISASSOC,
1857 nla_data(frame), nla_len(frame));
c2a04078 1858 break;
bd94971e 1859 case NL80211_CMD_FRAME:
da873dbb
JB		 1860 mlme_event_mgmt(drv, freq, sig, nla_data(frame),
1861 nla_len(frame));
58f6fbe0 1862 break;
bd94971e 1863 case NL80211_CMD_FRAME_TX_STATUS:
a11241fa
JB		 1864 mlme_event_mgmt_tx_status(drv, cookie, nla_data(frame),
1865 nla_len(frame), ack);
58f6fbe0 1866 break;
7d878ca7
JM		 1867 case NL80211_CMD_UNPROT_DEAUTHENTICATE:
1868 mlme_event_unprot_disconnect(drv, EVENT_UNPROT_DEAUTH,
1869 nla_data(frame), nla_len(frame));
1870 break;
1871 case NL80211_CMD_UNPROT_DISASSOCIATE:
1872 mlme_event_unprot_disconnect(drv, EVENT_UNPROT_DISASSOC,
1873 nla_data(frame), nla_len(frame));
1874 break;
c2a04078
JM		 1875 default:
1876 break;
1877 }
1878}
1879
1880
a5e1eb20 1881static void mlme_event_michael_mic_failure(struct i802_bss *bss,
35583f3f
JM		 1882 struct nlattr *tb[])
1883{
1884 union wpa_event_data data;
1885
1886 wpa_printf(MSG_DEBUG, "nl80211: MLME event Michael MIC failure");
1887 os_memset(&data, 0, sizeof(data));
1888 if (tb[NL80211_ATTR_MAC]) {
1889 wpa_hexdump(MSG_DEBUG, "nl80211: Source MAC address",
1890 nla_data(tb[NL80211_ATTR_MAC]),
1891 nla_len(tb[NL80211_ATTR_MAC]));
ad1e68e6 1892 data.michael_mic_failure.src = nla_data(tb[NL80211_ATTR_MAC]);
35583f3f
JM		 1893 }
1894 if (tb[NL80211_ATTR_KEY_SEQ]) {
1895 wpa_hexdump(MSG_DEBUG, "nl80211: TSC",
1896 nla_data(tb[NL80211_ATTR_KEY_SEQ]),
1897 nla_len(tb[NL80211_ATTR_KEY_SEQ]));
1898 }
1899 if (tb[NL80211_ATTR_KEY_TYPE]) {
1900 enum nl80211_key_type key_type =
1901 nla_get_u32(tb[NL80211_ATTR_KEY_TYPE]);
1902 wpa_printf(MSG_DEBUG, "nl80211: Key Type %d", key_type);
1903 if (key_type == NL80211_KEYTYPE_PAIRWISE)
1904 data.michael_mic_failure.unicast = 1;
1905 } else
1906 data.michael_mic_failure.unicast = 1;
1907
1908 if (tb[NL80211_ATTR_KEY_IDX]) {
1909 u8 key_id = nla_get_u8(tb[NL80211_ATTR_KEY_IDX]);
1910 wpa_printf(MSG_DEBUG, "nl80211: Key Id %d", key_id);
1911 }
1912
a5e1eb20 1913 wpa_supplicant_event(bss->ctx, EVENT_MICHAEL_MIC_FAILURE, &data);
35583f3f
JM		 1914}
1915
1916
5cc4d64b
JM		 1917static void mlme_event_join_ibss(struct wpa_driver_nl80211_data *drv,
1918 struct nlattr *tb[])
1919{
1920 if (tb[NL80211_ATTR_MAC] == NULL) {
1921 wpa_printf(MSG_DEBUG, "nl80211: No address in IBSS joined "
1922 "event");
1923 return;
1924 }
1925 os_memcpy(drv->bssid, nla_data(tb[NL80211_ATTR_MAC]), ETH_ALEN);
b21990b4 1926
5cc4d64b
JM		 1927 drv->associated = 1;
1928 wpa_printf(MSG_DEBUG, "nl80211: IBSS " MACSTR " joined",
1929 MAC2STR(drv->bssid));
1930
1931 wpa_supplicant_event(drv->ctx, EVENT_ASSOC, NULL);
1932}
1933
1934
55777702
JM		 1935static void mlme_event_remain_on_channel(struct wpa_driver_nl80211_data *drv,
1936 int cancel_event, struct nlattr *tb[])
1937{
1938 unsigned int freq, chan_type, duration;
1939 union wpa_event_data data;
1940 u64 cookie;
1941
1942 if (tb[NL80211_ATTR_WIPHY_FREQ])
1943 freq = nla_get_u32(tb[NL80211_ATTR_WIPHY_FREQ]);
1944 else
1945 freq = 0;
1946
1947 if (tb[NL80211_ATTR_WIPHY_CHANNEL_TYPE])
1948 chan_type = nla_get_u32(tb[NL80211_ATTR_WIPHY_CHANNEL_TYPE]);
1949 else
1950 chan_type = 0;
1951
1952 if (tb[NL80211_ATTR_DURATION])
1953 duration = nla_get_u32(tb[NL80211_ATTR_DURATION]);
1954 else
1955 duration = 0;
1956
1957 if (tb[NL80211_ATTR_COOKIE])
1958 cookie = nla_get_u64(tb[NL80211_ATTR_COOKIE]);
1959 else
1960 cookie = 0;
1961
1962 wpa_printf(MSG_DEBUG, "nl80211: Remain-on-channel event (cancel=%d "
1963 "freq=%u channel_type=%u duration=%u cookie=0x%llx (%s))",
1964 cancel_event, freq, chan_type, duration,
1965 (long long unsigned int) cookie,
1966 cookie == drv->remain_on_chan_cookie ? "match" : "unknown");
1967
1968 if (cookie != drv->remain_on_chan_cookie)
1969 return; /* not for us */
1970
531f0331
JB		 1971 if (cancel_event)
1972 drv->pending_remain_on_chan = 0;
55777702
JM		 1973
1974 os_memset(&data, 0, sizeof(data));
1975 data.remain_on_channel.freq = freq;
1976 data.remain_on_channel.duration = duration;
1977 wpa_supplicant_event(drv->ctx, cancel_event ?
1978 EVENT_CANCEL_REMAIN_ON_CHANNEL :
1979 EVENT_REMAIN_ON_CHANNEL, &data);
1980}
1981
1982
6a1ce395
DG		 1983static void mlme_event_ft_event(struct wpa_driver_nl80211_data *drv,
1984 struct nlattr *tb[])
1985{
1986 union wpa_event_data data;
1987
1988 os_memset(&data, 0, sizeof(data));
1989
1990 if (tb[NL80211_ATTR_IE]) {
1991 data.ft_ies.ies = nla_data(tb[NL80211_ATTR_IE]);
1992 data.ft_ies.ies_len = nla_len(tb[NL80211_ATTR_IE]);
1993 }
1994
1995 if (tb[NL80211_ATTR_IE_RIC]) {
1996 data.ft_ies.ric_ies = nla_data(tb[NL80211_ATTR_IE_RIC]);
1997 data.ft_ies.ric_ies_len = nla_len(tb[NL80211_ATTR_IE_RIC]);
1998 }
1999
2000 if (tb[NL80211_ATTR_MAC])
2001 os_memcpy(data.ft_ies.target_ap,
2002 nla_data(tb[NL80211_ATTR_MAC]), ETH_ALEN);
2003
2004 wpa_printf(MSG_DEBUG, "nl80211: FT event target_ap " MACSTR,
2005 MAC2STR(data.ft_ies.target_ap));
2006
2007 wpa_supplicant_event(drv->ctx, EVENT_FT_RESPONSE, &data);
2008}
2009
2010
8d923a4a
JM		 2011static void send_scan_event(struct wpa_driver_nl80211_data *drv, int aborted,
2012 struct nlattr *tb[])
2013{
2014 union wpa_event_data event;
2015 struct nlattr *nl;
2016 int rem;
2017 struct scan_info *info;
2018#define MAX_REPORT_FREQS 50
2019 int freqs[MAX_REPORT_FREQS];
2020 int num_freqs = 0;
2021
536fd62d
JM		 2022 if (drv->scan_for_auth) {
2023 drv->scan_for_auth = 0;
2024 wpa_printf(MSG_DEBUG, "nl80211: Scan results for missing "
2025 "cfg80211 BSS entry");
2026 wpa_driver_nl80211_authenticate_retry(drv);
2027 return;
2028 }
2029
8d923a4a
JM		 2030 os_memset(&event, 0, sizeof(event));
2031 info = &event.scan_info;
2032 info->aborted = aborted;
2033
2034 if (tb[NL80211_ATTR_SCAN_SSIDS]) {
2035 nla_for_each_nested(nl, tb[NL80211_ATTR_SCAN_SSIDS], rem) {
2036 struct wpa_driver_scan_ssid *s =
2037 &info->ssids[info->num_ssids];
2038 s->ssid = nla_data(nl);
2039 s->ssid_len = nla_len(nl);
2040 info->num_ssids++;
2041 if (info->num_ssids == WPAS_MAX_SCAN_SSIDS)
2042 break;
2043 }
2044 }
2045 if (tb[NL80211_ATTR_SCAN_FREQUENCIES]) {
2046 nla_for_each_nested(nl, tb[NL80211_ATTR_SCAN_FREQUENCIES], rem)
2047 {
2048 freqs[num_freqs] = nla_get_u32(nl);
2049 num_freqs++;
2050 if (num_freqs == MAX_REPORT_FREQS - 1)
2051 break;
2052 }
2053 info->freqs = freqs;
2054 info->num_freqs = num_freqs;
2055 }
2056 wpa_supplicant_event(drv->ctx, EVENT_SCAN_RESULTS, &event);
2057}
2058
2059
60a972a6
JM		 2060static int get_link_signal(struct nl_msg *msg, void *arg)
2061{
2062 struct nlattr *tb[NL80211_ATTR_MAX + 1];
2063 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
2064 struct nlattr *sinfo[NL80211_STA_INFO_MAX + 1];
2065 static struct nla_policy policy[NL80211_STA_INFO_MAX + 1] = {
2066 [NL80211_STA_INFO_SIGNAL] = { .type = NLA_U8 },
95783298 2067 [NL80211_STA_INFO_SIGNAL_AVG] = { .type = NLA_U8 },
60a972a6 2068 };
7ee35bf3
PS		 2069 struct nlattr *rinfo[NL80211_RATE_INFO_MAX + 1];
2070 static struct nla_policy rate_policy[NL80211_RATE_INFO_MAX + 1] = {
2071 [NL80211_RATE_INFO_BITRATE] = { .type = NLA_U16 },
2072 [NL80211_RATE_INFO_MCS] = { .type = NLA_U8 },
2073 [NL80211_RATE_INFO_40_MHZ_WIDTH] = { .type = NLA_FLAG },
2074 [NL80211_RATE_INFO_SHORT_GI] = { .type = NLA_FLAG },
2075 };
1c5c7273 2076 struct wpa_signal_info *sig_change = arg;
60a972a6
JM		 2077
2078 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
2079 genlmsg_attrlen(gnlh, 0), NULL);
2080 if (!tb[NL80211_ATTR_STA_INFO] ||
2081 nla_parse_nested(sinfo, NL80211_STA_INFO_MAX,
2082 tb[NL80211_ATTR_STA_INFO], policy))
2083 return NL_SKIP;
2084 if (!sinfo[NL80211_STA_INFO_SIGNAL])
2085 return NL_SKIP;
2086
7ee35bf3
PS		 2087 sig_change->current_signal =
2088 (s8) nla_get_u8(sinfo[NL80211_STA_INFO_SIGNAL]);
2089
95783298
AO		 2090 if (sinfo[NL80211_STA_INFO_SIGNAL_AVG])
2091 sig_change->avg_signal =
2092 (s8) nla_get_u8(sinfo[NL80211_STA_INFO_SIGNAL_AVG]);
2093 else
2094 sig_change->avg_signal = 0;
2095
7ee35bf3
PS		 2096 if (sinfo[NL80211_STA_INFO_TX_BITRATE]) {
2097 if (nla_parse_nested(rinfo, NL80211_RATE_INFO_MAX,
2098 sinfo[NL80211_STA_INFO_TX_BITRATE],
2099 rate_policy)) {
2100 sig_change->current_txrate = 0;
2101 } else {
2102 if (rinfo[NL80211_RATE_INFO_BITRATE]) {
2103 sig_change->current_txrate =
2104 nla_get_u16(rinfo[
2105 NL80211_RATE_INFO_BITRATE]) * 100;
2106 }
2107 }
2108 }
2109
60a972a6
JM		 2110 return NL_SKIP;
2111}
2112
2113
2114static int nl80211_get_link_signal(struct wpa_driver_nl80211_data *drv,
1c5c7273 2115 struct wpa_signal_info *sig)
60a972a6
JM		 2116{
2117 struct nl_msg *msg;
2118
7ee35bf3
PS		 2119 sig->current_signal = -9999;
2120 sig->current_txrate = 0;
60a972a6
JM		 2121
2122 msg = nlmsg_alloc();
2123 if (!msg)
2124 return -ENOMEM;
2125
9fb04070 2126 nl80211_cmd(drv, msg, 0, NL80211_CMD_GET_STATION);
60a972a6
JM		 2127
2128 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
2129 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, drv->bssid);
2130
2131 return send_and_recv_msgs(drv, msg, get_link_signal, sig);
2132 nla_put_failure:
5883168a 2133 nlmsg_free(msg);
60a972a6
JM		 2134 return -ENOBUFS;
2135}
2136
2137
7ee35bf3
PS		 2138static int get_link_noise(struct nl_msg *msg, void *arg)
2139{
2140 struct nlattr *tb[NL80211_ATTR_MAX + 1];
2141 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
2142 struct nlattr *sinfo[NL80211_SURVEY_INFO_MAX + 1];
2143 static struct nla_policy survey_policy[NL80211_SURVEY_INFO_MAX + 1] = {
2144 [NL80211_SURVEY_INFO_FREQUENCY] = { .type = NLA_U32 },
2145 [NL80211_SURVEY_INFO_NOISE] = { .type = NLA_U8 },
2146 };
1c5c7273 2147 struct wpa_signal_info *sig_change = arg;
7ee35bf3
PS		 2148
2149 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
2150 genlmsg_attrlen(gnlh, 0), NULL);
2151
2152 if (!tb[NL80211_ATTR_SURVEY_INFO]) {
2153 wpa_printf(MSG_DEBUG, "nl80211: survey data missing!");
2154 return NL_SKIP;
2155 }
2156
2157 if (nla_parse_nested(sinfo, NL80211_SURVEY_INFO_MAX,
2158 tb[NL80211_ATTR_SURVEY_INFO],
2159 survey_policy)) {
2160 wpa_printf(MSG_DEBUG, "nl80211: failed to parse nested "
2161 "attributes!");
2162 return NL_SKIP;
2163 }
2164
2165 if (!sinfo[NL80211_SURVEY_INFO_FREQUENCY])
2166 return NL_SKIP;
2167
2168 if (nla_get_u32(sinfo[NL80211_SURVEY_INFO_FREQUENCY]) !=
2169 sig_change->frequency)
2170 return NL_SKIP;
2171
2172 if (!sinfo[NL80211_SURVEY_INFO_NOISE])
2173 return NL_SKIP;
2174
2175 sig_change->current_noise =
2176 (s8) nla_get_u8(sinfo[NL80211_SURVEY_INFO_NOISE]);
2177
2178 return NL_SKIP;
2179}
2180
2181
2182static int nl80211_get_link_noise(struct wpa_driver_nl80211_data *drv,
1c5c7273 2183 struct wpa_signal_info *sig_change)
7ee35bf3
PS		 2184{
2185 struct nl_msg *msg;
2186
2187 sig_change->current_noise = 9999;
2188 sig_change->frequency = drv->assoc_freq;
2189
2190 msg = nlmsg_alloc();
2191 if (!msg)
2192 return -ENOMEM;
2193
9fb04070 2194 nl80211_cmd(drv, msg, NLM_F_DUMP, NL80211_CMD_GET_SURVEY);
7ee35bf3
PS		 2195
2196 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
2197
2198 return send_and_recv_msgs(drv, msg, get_link_noise, sig_change);
2199 nla_put_failure:
5883168a 2200 nlmsg_free(msg);
7ee35bf3
PS		 2201 return -ENOBUFS;
2202}
2203
2204
577db0ae
GM		 2205static int get_noise_for_scan_results(struct nl_msg *msg, void *arg)
2206{
2207 struct nlattr *tb[NL80211_ATTR_MAX + 1];
2208 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
2209 struct nlattr *sinfo[NL80211_SURVEY_INFO_MAX + 1];
2210 static struct nla_policy survey_policy[NL80211_SURVEY_INFO_MAX + 1] = {
2211 [NL80211_SURVEY_INFO_FREQUENCY] = { .type = NLA_U32 },
2212 [NL80211_SURVEY_INFO_NOISE] = { .type = NLA_U8 },
2213 };
2214 struct wpa_scan_results *scan_results = arg;
2215 struct wpa_scan_res *scan_res;
2216 size_t i;
2217
2218 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
2219 genlmsg_attrlen(gnlh, 0), NULL);
2220
2221 if (!tb[NL80211_ATTR_SURVEY_INFO]) {
2222 wpa_printf(MSG_DEBUG, "nl80211: Survey data missing");
2223 return NL_SKIP;
2224 }
2225
2226 if (nla_parse_nested(sinfo, NL80211_SURVEY_INFO_MAX,
2227 tb[NL80211_ATTR_SURVEY_INFO],
2228 survey_policy)) {
2229 wpa_printf(MSG_DEBUG, "nl80211: Failed to parse nested "
2230 "attributes");
2231 return NL_SKIP;
2232 }
2233
2234 if (!sinfo[NL80211_SURVEY_INFO_NOISE])
2235 return NL_SKIP;
2236
2237 if (!sinfo[NL80211_SURVEY_INFO_FREQUENCY])
2238 return NL_SKIP;
2239
2240 for (i = 0; i < scan_results->num; ++i) {
2241 scan_res = scan_results->res[i];
2242 if (!scan_res)
2243 continue;
2244 if ((int) nla_get_u32(sinfo[NL80211_SURVEY_INFO_FREQUENCY]) !=
2245 scan_res->freq)
2246 continue;
2247 if (!(scan_res->flags & WPA_SCAN_NOISE_INVALID))
2248 continue;
2249 scan_res->noise = (s8)
2250 nla_get_u8(sinfo[NL80211_SURVEY_INFO_NOISE]);
2251 scan_res->flags &= ~WPA_SCAN_NOISE_INVALID;
2252 }
2253
2254 return NL_SKIP;
2255}
2256
2257
2258static int nl80211_get_noise_for_scan_results(
2259 struct wpa_driver_nl80211_data *drv,
2260 struct wpa_scan_results *scan_res)
2261{
2262 struct nl_msg *msg;
2263
2264 msg = nlmsg_alloc();
2265 if (!msg)
2266 return -ENOMEM;
2267
2268 nl80211_cmd(drv, msg, NLM_F_DUMP, NL80211_CMD_GET_SURVEY);
2269
2270 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
2271
2272 return send_and_recv_msgs(drv, msg, get_noise_for_scan_results,
2273 scan_res);
2274 nla_put_failure:
9e088e74 2275 nlmsg_free(msg);
577db0ae
GM		 2276 return -ENOBUFS;
2277}
2278
2279
93910401
JM		 2280static void nl80211_cqm_event(struct wpa_driver_nl80211_data *drv,
2281 struct nlattr *tb[])
2282{
2283 static struct nla_policy cqm_policy[NL80211_ATTR_CQM_MAX + 1] = {
2284 [NL80211_ATTR_CQM_RSSI_THOLD] = { .type = NLA_U32 },
2285 [NL80211_ATTR_CQM_RSSI_HYST] = { .type = NLA_U8 },
2286 [NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT] = { .type = NLA_U32 },
0d7e5a3a 2287 [NL80211_ATTR_CQM_PKT_LOSS_EVENT] = { .type = NLA_U32 },
93910401
JM		 2288 };
2289 struct nlattr *cqm[NL80211_ATTR_CQM_MAX + 1];
2290 enum nl80211_cqm_rssi_threshold_event event;
b625473c 2291 union wpa_event_data ed;
1c5c7273 2292 struct wpa_signal_info sig;
7ee35bf3 2293 int res;
93910401
JM		 2294
2295 if (tb[NL80211_ATTR_CQM] == NULL ||
2296 nla_parse_nested(cqm, NL80211_ATTR_CQM_MAX, tb[NL80211_ATTR_CQM],
2297 cqm_policy)) {
2298 wpa_printf(MSG_DEBUG, "nl80211: Ignore invalid CQM event");
2299 return;
2300 }
2301
0d7e5a3a
JB		 2302 os_memset(&ed, 0, sizeof(ed));
2303
2304 if (cqm[NL80211_ATTR_CQM_PKT_LOSS_EVENT]) {
2305 if (!tb[NL80211_ATTR_MAC])
2306 return;
2307 os_memcpy(ed.low_ack.addr, nla_data(tb[NL80211_ATTR_MAC]),
2308 ETH_ALEN);
2309 wpa_supplicant_event(drv->ctx, EVENT_STATION_LOW_ACK, &ed);
2310 return;
2311 }
2312
93910401
JM		 2313 if (cqm[NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT] == NULL)
2314 return;
2315 event = nla_get_u32(cqm[NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT]);
b625473c 2316
93910401
JM		 2317 if (event == NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH) {
2318 wpa_printf(MSG_DEBUG, "nl80211: Connection quality monitor "
2319 "event: RSSI high");
b625473c 2320 ed.signal_change.above_threshold = 1;
93910401
JM		 2321 } else if (event == NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW) {
2322 wpa_printf(MSG_DEBUG, "nl80211: Connection quality monitor "
2323 "event: RSSI low");
b625473c
JM		 2324 ed.signal_change.above_threshold = 0;
2325 } else
2326 return;
2327
60a972a6
JM		 2328 res = nl80211_get_link_signal(drv, &sig);
2329 if (res == 0) {
7ee35bf3
PS		 2330 ed.signal_change.current_signal = sig.current_signal;
2331 ed.signal_change.current_txrate = sig.current_txrate;
2332 wpa_printf(MSG_DEBUG, "nl80211: Signal: %d dBm txrate: %d",
2333 sig.current_signal, sig.current_txrate);
2334 }
2335
2336 res = nl80211_get_link_noise(drv, &sig);
2337 if (res == 0) {
2338 ed.signal_change.current_noise = sig.current_noise;
2339 wpa_printf(MSG_DEBUG, "nl80211: Noise: %d dBm",
2340 sig.current_noise);
60a972a6
JM		 2341 }
2342
b625473c 2343 wpa_supplicant_event(drv->ctx, EVENT_SIGNAL_CHANGE, &ed);
93910401
JM		 2344}
2345
2346
18d2ba08
JM		 2347static void nl80211_new_station_event(struct wpa_driver_nl80211_data *drv,
2348 struct nlattr **tb)
2349{
2350 u8 *addr;
2351 union wpa_event_data data;
2352
2353 if (tb[NL80211_ATTR_MAC] == NULL)
2354 return;
2355 addr = nla_data(tb[NL80211_ATTR_MAC]);
2356 wpa_printf(MSG_DEBUG, "nl80211: New station " MACSTR, MAC2STR(addr));
5f310a9e 2357
61cbe2ff 2358 if (is_ap_interface(drv->nlmode) && drv->device_ap_sme) {
5f310a9e
JM		 2359 u8 *ies = NULL;
2360 size_t ies_len = 0;
2361 if (tb[NL80211_ATTR_IE]) {
2362 ies = nla_data(tb[NL80211_ATTR_IE]);
2363 ies_len = nla_len(tb[NL80211_ATTR_IE]);
2364 }
2365 wpa_hexdump(MSG_DEBUG, "nl80211: Assoc Req IEs", ies, ies_len);
2366 drv_event_assoc(drv->ctx, addr, ies, ies_len, 0);
2367 return;
2368 }
2369
18d2ba08
JM		 2370 if (drv->nlmode != NL80211_IFTYPE_ADHOC)
2371 return;
2372
2373 os_memset(&data, 0, sizeof(data));
2374 os_memcpy(data.ibss_rsn_start.peer, addr, ETH_ALEN);
2375 wpa_supplicant_event(drv->ctx, EVENT_IBSS_RSN_START, &data);
2376}
2377
2378
ef985058
JM		 2379static void nl80211_del_station_event(struct wpa_driver_nl80211_data *drv,
2380 struct nlattr **tb)
2381{
2382 u8 *addr;
2383 union wpa_event_data data;
2384
2385 if (tb[NL80211_ATTR_MAC] == NULL)
2386 return;
2387 addr = nla_data(tb[NL80211_ATTR_MAC]);
2388 wpa_printf(MSG_DEBUG, "nl80211: Delete station " MACSTR,
2389 MAC2STR(addr));
5f310a9e 2390
61cbe2ff 2391 if (is_ap_interface(drv->nlmode) && drv->device_ap_sme) {
5f310a9e
JM		 2392 drv_event_disassoc(drv->ctx, addr);
2393 return;
2394 }
2395
ef985058
JM		 2396 if (drv->nlmode != NL80211_IFTYPE_ADHOC)
2397 return;
2398
2399 os_memset(&data, 0, sizeof(data));
2400 os_memcpy(data.ibss_peer_lost.peer, addr, ETH_ALEN);
2401 wpa_supplicant_event(drv->ctx, EVENT_IBSS_PEER_LOST, &data);
2402}
2403
2404
b14a210c
JB		 2405static void nl80211_rekey_offload_event(struct wpa_driver_nl80211_data *drv,
2406 struct nlattr **tb)
2407{
2408 struct nlattr *rekey_info[NUM_NL80211_REKEY_DATA];
2409 static struct nla_policy rekey_policy[NUM_NL80211_REKEY_DATA] = {
2410 [NL80211_REKEY_DATA_KEK] = {
2411 .minlen = NL80211_KEK_LEN,
2412 .maxlen = NL80211_KEK_LEN,
2413 },
2414 [NL80211_REKEY_DATA_KCK] = {
2415 .minlen = NL80211_KCK_LEN,
2416 .maxlen = NL80211_KCK_LEN,
2417 },
2418 [NL80211_REKEY_DATA_REPLAY_CTR] = {
2419 .minlen = NL80211_REPLAY_CTR_LEN,
2420 .maxlen = NL80211_REPLAY_CTR_LEN,
2421 },
2422 };
2423 union wpa_event_data data;
2424
2425 if (!tb[NL80211_ATTR_MAC])
2426 return;
2427 if (!tb[NL80211_ATTR_REKEY_DATA])
2428 return;
2429 if (nla_parse_nested(rekey_info, MAX_NL80211_REKEY_DATA,
2430 tb[NL80211_ATTR_REKEY_DATA], rekey_policy))
2431 return;
2432 if (!rekey_info[NL80211_REKEY_DATA_REPLAY_CTR])
2433 return;
2434
2435 os_memset(&data, 0, sizeof(data));
2436 data.driver_gtk_rekey.bssid = nla_data(tb[NL80211_ATTR_MAC]);
2437 wpa_printf(MSG_DEBUG, "nl80211: Rekey offload event for BSSID " MACSTR,
2438 MAC2STR(data.driver_gtk_rekey.bssid));
2439 data.driver_gtk_rekey.replay_ctr =
2440 nla_data(rekey_info[NL80211_REKEY_DATA_REPLAY_CTR]);
2441 wpa_hexdump(MSG_DEBUG, "nl80211: Rekey offload - Replay Counter",
2442 data.driver_gtk_rekey.replay_ctr, NL80211_REPLAY_CTR_LEN);
2443 wpa_supplicant_event(drv->ctx, EVENT_DRIVER_GTK_REKEY, &data);
2444}
2445
2446
c36d5242
JM		 2447static void nl80211_pmksa_candidate_event(struct wpa_driver_nl80211_data *drv,
2448 struct nlattr **tb)
2449{
2450 struct nlattr *cand[NUM_NL80211_PMKSA_CANDIDATE];
2451 static struct nla_policy cand_policy[NUM_NL80211_PMKSA_CANDIDATE] = {
2452 [NL80211_PMKSA_CANDIDATE_INDEX] = { .type = NLA_U32 },
2453 [NL80211_PMKSA_CANDIDATE_BSSID] = {
2454 .minlen = ETH_ALEN,
2455 .maxlen = ETH_ALEN,
2456 },
2457 [NL80211_PMKSA_CANDIDATE_PREAUTH] = { .type = NLA_FLAG },
2458 };
2459 union wpa_event_data data;
2460
7d81932d
JM		 2461 wpa_printf(MSG_DEBUG, "nl80211: PMKSA candidate event");
2462
c36d5242
JM		 2463 if (!tb[NL80211_ATTR_PMKSA_CANDIDATE])
2464 return;
2465 if (nla_parse_nested(cand, MAX_NL80211_PMKSA_CANDIDATE,
2466 tb[NL80211_ATTR_PMKSA_CANDIDATE], cand_policy))
2467 return;
2468 if (!cand[NL80211_PMKSA_CANDIDATE_INDEX] ||
2469 !cand[NL80211_PMKSA_CANDIDATE_BSSID])
2470 return;
2471
2472 os_memset(&data, 0, sizeof(data));
2473 os_memcpy(data.pmkid_candidate.bssid,
2474 nla_data(cand[NL80211_PMKSA_CANDIDATE_BSSID]), ETH_ALEN);
2475 data.pmkid_candidate.index =
2476 nla_get_u32(cand[NL80211_PMKSA_CANDIDATE_INDEX]);
2477 data.pmkid_candidate.preauth =
2478 cand[NL80211_PMKSA_CANDIDATE_PREAUTH] != NULL;
2479 wpa_supplicant_event(drv->ctx, EVENT_PMKID_CANDIDATE, &data);
2480}
2481
2482
39718852
JB		 2483static void nl80211_client_probe_event(struct wpa_driver_nl80211_data *drv,
2484 struct nlattr **tb)
2485{
2486 union wpa_event_data data;
2487
7d81932d
JM		 2488 wpa_printf(MSG_DEBUG, "nl80211: Probe client event");
2489
39718852
JB		 2490 if (!tb[NL80211_ATTR_MAC] || !tb[NL80211_ATTR_ACK])
2491 return;
2492
2493 os_memset(&data, 0, sizeof(data));
2494 os_memcpy(data.client_poll.addr,
2495 nla_data(tb[NL80211_ATTR_MAC]), ETH_ALEN);
2496
2497 wpa_supplicant_event(drv->ctx, EVENT_DRIVER_CLIENT_POLL_OK, &data);
2498}
2499
2500
6201b052
JM		 2501static void nl80211_tdls_oper_event(struct wpa_driver_nl80211_data *drv,
2502 struct nlattr **tb)
2503{
2504 union wpa_event_data data;
2505
2506 wpa_printf(MSG_DEBUG, "nl80211: TDLS operation event");
2507
2508 if (!tb[NL80211_ATTR_MAC] || !tb[NL80211_ATTR_TDLS_OPERATION])
2509 return;
2510
2511 os_memset(&data, 0, sizeof(data));
2512 os_memcpy(data.tdls.peer, nla_data(tb[NL80211_ATTR_MAC]), ETH_ALEN);
2513 switch (nla_get_u8(tb[NL80211_ATTR_TDLS_OPERATION])) {
2514 case NL80211_TDLS_SETUP:
2515 wpa_printf(MSG_DEBUG, "nl80211: TDLS setup request for peer "
2516 MACSTR, MAC2STR(data.tdls.peer));
2517 data.tdls.oper = TDLS_REQUEST_SETUP;
2518 break;
2519 case NL80211_TDLS_TEARDOWN:
2520 wpa_printf(MSG_DEBUG, "nl80211: TDLS teardown request for peer "
2521 MACSTR, MAC2STR(data.tdls.peer));
2522 data.tdls.oper = TDLS_REQUEST_TEARDOWN;
2523 break;
2524 default:
2525 wpa_printf(MSG_DEBUG, "nl80211: Unsupported TDLS operatione "
2526 "event");
2527 return;
2528 }
2529 if (tb[NL80211_ATTR_REASON_CODE]) {
2530 data.tdls.reason_code =
2531 nla_get_u16(tb[NL80211_ATTR_REASON_CODE]);
2532 }
2533
2534 wpa_supplicant_event(drv->ctx, EVENT_TDLS, &data);
2535}
2536
2537
7239ea7f
ST		 2538static void nl80211_stop_ap(struct wpa_driver_nl80211_data *drv,
2539 struct nlattr **tb)
2540{
2541 wpa_supplicant_event(drv->ctx, EVENT_INTERFACE_UNAVAILABLE, NULL);
2542}
2543
2544
3140803b
RM		 2545static void nl80211_connect_failed_event(struct wpa_driver_nl80211_data *drv,
2546 struct nlattr **tb)
2547{
2548 union wpa_event_data data;
2549 u32 reason;
2550
2551 wpa_printf(MSG_DEBUG, "nl80211: Connect failed event");
2552
2553 if (!tb[NL80211_ATTR_MAC] || !tb[NL80211_ATTR_CONN_FAILED_REASON])
2554 return;
2555
2556 os_memset(&data, 0, sizeof(data));
2557 os_memcpy(data.connect_failed_reason.addr,
2558 nla_data(tb[NL80211_ATTR_MAC]), ETH_ALEN);
2559
2560 reason = nla_get_u32(tb[NL80211_ATTR_CONN_FAILED_REASON]);
2561 switch (reason) {
2562 case NL80211_CONN_FAIL_MAX_CLIENTS:
2563 wpa_printf(MSG_DEBUG, "nl80211: Max client reached");
2564 data.connect_failed_reason.code = MAX_CLIENT_REACHED;
2565 break;
2566 case NL80211_CONN_FAIL_BLOCKED_CLIENT:
2567 wpa_printf(MSG_DEBUG, "nl80211: Blocked client " MACSTR
2568 " tried to connect",
2569 MAC2STR(data.connect_failed_reason.addr));
2570 data.connect_failed_reason.code = BLOCKED_CLIENT;
2571 break;
2572 default:
2573 wpa_printf(MSG_DEBUG, "nl8021l: Unknown connect failed reason "
2574 "%u", reason);
2575 return;
2576 }
2577
2578 wpa_supplicant_event(drv->ctx, EVENT_CONNECT_FAILED_REASON, &data);
2579}
2580
2581
04be54fa
SW		 2582static void nl80211_radar_event(struct wpa_driver_nl80211_data *drv,
2583 struct nlattr **tb)
2584{
2585 union wpa_event_data data;
2586 enum nl80211_radar_event event_type;
2587
2588 if (!tb[NL80211_ATTR_WIPHY_FREQ] || !tb[NL80211_ATTR_RADAR_EVENT])
2589 return;
2590
2591 os_memset(&data, 0, sizeof(data));
cd3b0700
MK		 2592 data.dfs_event.freq = nla_get_u32(tb[NL80211_ATTR_WIPHY_FREQ]);
2593 event_type = nla_get_u32(tb[NL80211_ATTR_RADAR_EVENT]);
04be54fa 2594
846de15d
JD		 2595 /* Check HT params */
2596 if (tb[NL80211_ATTR_WIPHY_CHANNEL_TYPE]) {
2597 data.dfs_event.ht_enabled = 1;
2598 data.dfs_event.chan_offset = 0;
2599
2600 switch (nla_get_u32(tb[NL80211_ATTR_WIPHY_CHANNEL_TYPE])) {
2601 case NL80211_CHAN_NO_HT:
2602 data.dfs_event.ht_enabled = 0;
2603 break;
2604 case NL80211_CHAN_HT20:
2605 break;
2606 case NL80211_CHAN_HT40PLUS:
2607 data.dfs_event.chan_offset = 1;
2608 break;
2609 case NL80211_CHAN_HT40MINUS:
2610 data.dfs_event.chan_offset = -1;
2611 break;
2612 }
2613 }
2614
2615 /* Get VHT params */
884f1a3c
JM		 2616 if (tb[NL80211_ATTR_CHANNEL_WIDTH])
2617 data.dfs_event.chan_width =
2618 convert2width(nla_get_u32(
2619 tb[NL80211_ATTR_CHANNEL_WIDTH]));
2620 if (tb[NL80211_ATTR_CENTER_FREQ1])
2621 data.dfs_event.cf1 = nla_get_u32(tb[NL80211_ATTR_CENTER_FREQ1]);
846de15d
JD		 2622 if (tb[NL80211_ATTR_CENTER_FREQ2])
2623 data.dfs_event.cf2 = nla_get_u32(tb[NL80211_ATTR_CENTER_FREQ2]);
2624
2625 wpa_printf(MSG_DEBUG, "nl80211: DFS event on freq %d MHz, ht: %d, offset: %d, width: %d, cf1: %dMHz, cf2: %dMHz",
2626 data.dfs_event.freq, data.dfs_event.ht_enabled,
2627 data.dfs_event.chan_offset, data.dfs_event.chan_width,
2628 data.dfs_event.cf1, data.dfs_event.cf2);
04be54fa
SW		 2629
2630 switch (event_type) {
2631 case NL80211_RADAR_DETECTED:
2632 wpa_supplicant_event(drv->ctx, EVENT_DFS_RADAR_DETECTED, &data);
2633 break;
2634 case NL80211_RADAR_CAC_FINISHED:
2635 wpa_supplicant_event(drv->ctx, EVENT_DFS_CAC_FINISHED, &data);
2636 break;
2637 case NL80211_RADAR_CAC_ABORTED:
2638 wpa_supplicant_event(drv->ctx, EVENT_DFS_CAC_ABORTED, &data);
2639 break;
2640 case NL80211_RADAR_NOP_FINISHED:
2641 wpa_supplicant_event(drv->ctx, EVENT_DFS_NOP_FINISHED, &data);
2642 break;
2643 default:
2644 wpa_printf(MSG_DEBUG, "nl80211: Unknown radar event %d "
2645 "received", event_type);
2646 break;
2647 }
2648}
2649
2650
3088e4e5
JB		 2651static void nl80211_spurious_frame(struct i802_bss *bss, struct nlattr **tb,
2652 int wds)
02bb32c3
JB		 2653{
2654 struct wpa_driver_nl80211_data *drv = bss->drv;
2655 union wpa_event_data event;
02bb32c3
JB		 2656
2657 if (!tb[NL80211_ATTR_MAC])
2658 return;
2659
02bb32c3 2660 os_memset(&event, 0, sizeof(event));
341eebee 2661 event.rx_from_unknown.bssid = bss->addr;
02bb32c3 2662 event.rx_from_unknown.addr = nla_data(tb[NL80211_ATTR_MAC]);
3088e4e5 2663 event.rx_from_unknown.wds = wds;
02bb32c3
JB		 2664
2665 wpa_supplicant_event(drv->ctx, EVENT_RX_FROM_UNKNOWN, &event);
2666}
2667
2668
a5e1eb20
SE		 2669static void do_process_drv_event(struct i802_bss *bss, int cmd,
2670 struct nlattr **tb)
97865538 2671{
a5e1eb20 2672 struct wpa_driver_nl80211_data *drv = bss->drv;
795baf77 2673 union wpa_event_data data;
a5e1eb20 2674
2090a0b4
DS		 2675 wpa_printf(MSG_DEBUG, "nl80211: Drv Event %d (%s) received for %s",
2676 cmd, nl80211_command_to_string(cmd), bss->ifname);
2677
b1f625e0 2678 if (drv->ap_scan_as_station != NL80211_IFTYPE_UNSPECIFIED &&
d6c9aab8
JB		 2679 (cmd == NL80211_CMD_NEW_SCAN_RESULTS ||
2680 cmd == NL80211_CMD_SCAN_ABORTED)) {
834ee56f 2681 wpa_driver_nl80211_set_mode(drv->first_bss,
b1f625e0
EP		 2682 drv->ap_scan_as_station);
2683 drv->ap_scan_as_station = NL80211_IFTYPE_UNSPECIFIED;
ad1e68e6
JM		 2684 }
2685
d6c9aab8 2686 switch (cmd) {
d942a79e 2687 case NL80211_CMD_TRIGGER_SCAN:
565110cd 2688 wpa_dbg(drv->ctx, MSG_DEBUG, "nl80211: Scan trigger");
a771c07d 2689 drv->scan_state = SCAN_STARTED;
d942a79e 2690 break;
d21c63b9 2691 case NL80211_CMD_START_SCHED_SCAN:
565110cd 2692 wpa_dbg(drv->ctx, MSG_DEBUG, "nl80211: Sched scan started");
a771c07d 2693 drv->scan_state = SCHED_SCAN_STARTED;
d21c63b9
LC		 2694 break;
2695 case NL80211_CMD_SCHED_SCAN_STOPPED:
565110cd 2696 wpa_dbg(drv->ctx, MSG_DEBUG, "nl80211: Sched scan stopped");
a771c07d 2697 drv->scan_state = SCHED_SCAN_STOPPED;
d21c63b9
LC		 2698 wpa_supplicant_event(drv->ctx, EVENT_SCHED_SCAN_STOPPED, NULL);
2699 break;
97865538 2700 case NL80211_CMD_NEW_SCAN_RESULTS:
565110cd
JM		 2701 wpa_dbg(drv->ctx, MSG_DEBUG,
2702 "nl80211: New scan results available");
a771c07d 2703 drv->scan_state = SCAN_COMPLETED;
97865538
JM		 2704 drv->scan_complete_events = 1;
2705 eloop_cancel_timeout(wpa_driver_nl80211_scan_timeout, drv,
2706 drv->ctx);
8d923a4a 2707 send_scan_event(drv, 0, tb);
97865538 2708 break;
d21c63b9 2709 case NL80211_CMD_SCHED_SCAN_RESULTS:
565110cd
JM		 2710 wpa_dbg(drv->ctx, MSG_DEBUG,
2711 "nl80211: New sched scan results available");
a771c07d 2712 drv->scan_state = SCHED_SCAN_RESULTS;
d21c63b9
LC		 2713 send_scan_event(drv, 0, tb);
2714 break;
97865538 2715 case NL80211_CMD_SCAN_ABORTED:
565110cd 2716 wpa_dbg(drv->ctx, MSG_DEBUG, "nl80211: Scan aborted");
a771c07d 2717 drv->scan_state = SCAN_ABORTED;
97865538
JM		 2718 /*
2719 * Need to indicate that scan results are available in order
2720 * not to make wpa_supplicant stop its scanning.
2721 */
2722 eloop_cancel_timeout(wpa_driver_nl80211_scan_timeout, drv,
2723 drv->ctx);
8d923a4a 2724 send_scan_event(drv, 1, tb);
97865538 2725 break;
c2a04078
JM		 2726 case NL80211_CMD_AUTHENTICATE:
2727 case NL80211_CMD_ASSOCIATE:
2728 case NL80211_CMD_DEAUTHENTICATE:
2729 case NL80211_CMD_DISASSOCIATE:
bd94971e 2730 case NL80211_CMD_FRAME_TX_STATUS:
7d878ca7
JM		 2731 case NL80211_CMD_UNPROT_DEAUTHENTICATE:
2732 case NL80211_CMD_UNPROT_DISASSOCIATE:
97279d8d 2733 mlme_event(bss, cmd, tb[NL80211_ATTR_FRAME],
58f6fbe0
JM		 2734 tb[NL80211_ATTR_MAC], tb[NL80211_ATTR_TIMED_OUT],
2735 tb[NL80211_ATTR_WIPHY_FREQ], tb[NL80211_ATTR_ACK],
da873dbb
JB		 2736 tb[NL80211_ATTR_COOKIE],
2737 tb[NL80211_ATTR_RX_SIGNAL_DBM]);
c2a04078 2738 break;
da72a1c1
ZY		 2739 case NL80211_CMD_CONNECT:
2740 case NL80211_CMD_ROAM:
d6c9aab8 2741 mlme_event_connect(drv, cmd,
da72a1c1
ZY		 2742 tb[NL80211_ATTR_STATUS_CODE],
2743 tb[NL80211_ATTR_MAC],
2744 tb[NL80211_ATTR_REQ_IE],
2745 tb[NL80211_ATTR_RESP_IE]);
2746 break;
1b487b8b 2747 case NL80211_CMD_CH_SWITCH_NOTIFY:
8d1fdde7
JD		 2748 mlme_event_ch_switch(drv,
2749 tb[NL80211_ATTR_IFINDEX],
2750 tb[NL80211_ATTR_WIPHY_FREQ],
2751 tb[NL80211_ATTR_WIPHY_CHANNEL_TYPE],
2752 tb[NL80211_ATTR_CHANNEL_WIDTH],
2753 tb[NL80211_ATTR_CENTER_FREQ1],
2754 tb[NL80211_ATTR_CENTER_FREQ2]);
1b487b8b 2755 break;
da72a1c1 2756 case NL80211_CMD_DISCONNECT:
20f5a4c2 2757 mlme_event_disconnect(drv, tb[NL80211_ATTR_REASON_CODE],
3d9975d5
JM		 2758 tb[NL80211_ATTR_MAC],
2759 tb[NL80211_ATTR_DISCONNECTED_BY_AP]);
da72a1c1 2760 break;
35583f3f 2761 case NL80211_CMD_MICHAEL_MIC_FAILURE:
a5e1eb20 2762 mlme_event_michael_mic_failure(bss, tb);
35583f3f 2763 break;
5cc4d64b
JM		 2764 case NL80211_CMD_JOIN_IBSS:
2765 mlme_event_join_ibss(drv, tb);
2766 break;
55777702
JM		 2767 case NL80211_CMD_REMAIN_ON_CHANNEL:
2768 mlme_event_remain_on_channel(drv, 0, tb);
2769 break;
2770 case NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL:
2771 mlme_event_remain_on_channel(drv, 1, tb);
2772 break;
93910401
JM		 2773 case NL80211_CMD_NOTIFY_CQM:
2774 nl80211_cqm_event(drv, tb);
2775 break;
33c5deb8
JM		 2776 case NL80211_CMD_REG_CHANGE:
2777 wpa_printf(MSG_DEBUG, "nl80211: Regulatory domain change");
795baf77
AS		 2778 if (tb[NL80211_ATTR_REG_INITIATOR] == NULL)
2779 break;
2780 os_memset(&data, 0, sizeof(data));
2781 switch (nla_get_u8(tb[NL80211_ATTR_REG_INITIATOR])) {
2782 case NL80211_REGDOM_SET_BY_CORE:
2783 data.channel_list_changed.initiator =
2784 REGDOM_SET_BY_CORE;
2785 break;
2786 case NL80211_REGDOM_SET_BY_USER:
2787 data.channel_list_changed.initiator =
2788 REGDOM_SET_BY_USER;
2789 break;
2790 case NL80211_REGDOM_SET_BY_DRIVER:
2791 data.channel_list_changed.initiator =
2792 REGDOM_SET_BY_DRIVER;
2793 break;
2794 case NL80211_REGDOM_SET_BY_COUNTRY_IE:
2795 data.channel_list_changed.initiator =
2796 REGDOM_SET_BY_COUNTRY_IE;
2797 break;
2798 default:
2799 wpa_printf(MSG_DEBUG, "nl80211: Unknown reg change initiator %d received",
2800 nla_get_u8(tb[NL80211_ATTR_REG_INITIATOR]));
2801 break;
2802 }
33c5deb8 2803 wpa_supplicant_event(drv->ctx, EVENT_CHANNEL_LIST_CHANGED,
795baf77 2804 &data);
33c5deb8
JM		 2805 break;
2806 case NL80211_CMD_REG_BEACON_HINT:
2807 wpa_printf(MSG_DEBUG, "nl80211: Regulatory beacon hint");
2808 wpa_supplicant_event(drv->ctx, EVENT_CHANNEL_LIST_CHANGED,
2809 NULL);
2810 break;
18d2ba08
JM		 2811 case NL80211_CMD_NEW_STATION:
2812 nl80211_new_station_event(drv, tb);
2813 break;
ef985058
JM		 2814 case NL80211_CMD_DEL_STATION:
2815 nl80211_del_station_event(drv, tb);
2816 break;
b14a210c
JB		 2817 case NL80211_CMD_SET_REKEY_OFFLOAD:
2818 nl80211_rekey_offload_event(drv, tb);
2819 break;
c36d5242
JM		 2820 case NL80211_CMD_PMKSA_CANDIDATE:
2821 nl80211_pmksa_candidate_event(drv, tb);
2822 break;
39718852
JB		 2823 case NL80211_CMD_PROBE_CLIENT:
2824 nl80211_client_probe_event(drv, tb);
2825 break;
6201b052
JM		 2826 case NL80211_CMD_TDLS_OPER:
2827 nl80211_tdls_oper_event(drv, tb);
2828 break;
3140803b
RM		 2829 case NL80211_CMD_CONN_FAILED:
2830 nl80211_connect_failed_event(drv, tb);
2831 break;
6a1ce395
DG		 2832 case NL80211_CMD_FT_EVENT:
2833 mlme_event_ft_event(drv, tb);
2834 break;
04be54fa
SW		 2835 case NL80211_CMD_RADAR_DETECT:
2836 nl80211_radar_event(drv, tb);
2837 break;
7239ea7f
ST		 2838 case NL80211_CMD_STOP_AP:
2839 nl80211_stop_ap(drv, tb);
2840 break;
97865538 2841 default:
565110cd
JM		 2842 wpa_dbg(drv->ctx, MSG_DEBUG, "nl80211: Ignored unknown event "
2843 "(cmd=%d)", cmd);
97865538
JM		 2844 break;
2845 }
d6c9aab8
JB		 2846}
2847
2848
2849static int process_drv_event(struct nl_msg *msg, void *arg)
2850{
2851 struct wpa_driver_nl80211_data *drv = arg;
2852 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
2853 struct nlattr *tb[NL80211_ATTR_MAX + 1];
a5e1eb20
SE		 2854 struct i802_bss *bss;
2855 int ifidx = -1;
d6c9aab8
JB		 2856
2857 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
2858 genlmsg_attrlen(gnlh, 0), NULL);
2859
d3aaef80 2860 if (tb[NL80211_ATTR_IFINDEX]) {
a5e1eb20
SE		 2861 ifidx = nla_get_u32(tb[NL80211_ATTR_IFINDEX]);
2862
834ee56f 2863 for (bss = drv->first_bss; bss; bss = bss->next)
d3aaef80
DS		 2864 if (ifidx == -1 || ifidx == bss->ifindex) {
2865 do_process_drv_event(bss, gnlh->cmd, tb);
2866 return NL_SKIP;
2867 }
2868 wpa_printf(MSG_DEBUG,
2869 "nl80211: Ignored event (cmd=%d) for foreign interface (ifindex %d)",
2870 gnlh->cmd, ifidx);
2871 } else if (tb[NL80211_ATTR_WDEV]) {
2872 u64 wdev_id = nla_get_u64(tb[NL80211_ATTR_WDEV]);
2873 wpa_printf(MSG_DEBUG, "nl80211: Process event on P2P device");
834ee56f 2874 for (bss = drv->first_bss; bss; bss = bss->next) {
d3aaef80
DS		 2875 if (bss->wdev_id_set && wdev_id == bss->wdev_id) {
2876 do_process_drv_event(bss, gnlh->cmd, tb);
2877 return NL_SKIP;
2878 }
d6c9aab8 2879 }
d3aaef80
DS		 2880 wpa_printf(MSG_DEBUG,
2881 "nl80211: Ignored event (cmd=%d) for foreign interface (wdev 0x%llx)",
2882 gnlh->cmd, (long long unsigned int) wdev_id);
d6c9aab8
JB		 2883 }
2884
d6c9aab8
JB		 2885 return NL_SKIP;
2886}
2887
2888
2889static int process_global_event(struct nl_msg *msg, void *arg)
2890{
2891 struct nl80211_global *global = arg;
2892 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
2893 struct nlattr *tb[NL80211_ATTR_MAX + 1];
24b5bd8b 2894 struct wpa_driver_nl80211_data *drv, *tmp;
d6c9aab8 2895 int ifidx = -1;
a5e1eb20 2896 struct i802_bss *bss;
54d4ba42 2897 u64 wdev_id = 0;
d3aaef80 2898 int wdev_id_set = 0;
d6c9aab8
JB		 2899
2900 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
2901 genlmsg_attrlen(gnlh, 0), NULL);
2902
2903 if (tb[NL80211_ATTR_IFINDEX])
2904 ifidx = nla_get_u32(tb[NL80211_ATTR_IFINDEX]);
d3aaef80
DS		 2905 else if (tb[NL80211_ATTR_WDEV]) {
2906 wdev_id = nla_get_u64(tb[NL80211_ATTR_WDEV]);
2907 wdev_id_set = 1;
2908 }
d6c9aab8 2909
24b5bd8b
JB		 2910 dl_list_for_each_safe(drv, tmp, &global->interfaces,
2911 struct wpa_driver_nl80211_data, list) {
834ee56f 2912 for (bss = drv->first_bss; bss; bss = bss->next) {
d3aaef80
DS		 2913 if ((ifidx == -1 && !wdev_id_set) ||
2914 ifidx == bss->ifindex ||
2915 (wdev_id_set && bss->wdev_id_set &&
2916 wdev_id == bss->wdev_id)) {
a5e1eb20
SE		 2917 do_process_drv_event(bss, gnlh->cmd, tb);
2918 return NL_SKIP;
2919 }
2920 }
d6c9aab8 2921 }
97865538
JM		 2922
2923 return NL_SKIP;
2924}
2925
2926
cc7a48d1
JB		 2927static int process_bss_event(struct nl_msg *msg, void *arg)
2928{
a11241fa 2929 struct i802_bss *bss = arg;
cc7a48d1
JB		 2930 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
2931 struct nlattr *tb[NL80211_ATTR_MAX + 1];
2932
2933 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
2934 genlmsg_attrlen(gnlh, 0), NULL);
2935
2090a0b4
DS		 2936 wpa_printf(MSG_DEBUG, "nl80211: BSS Event %d (%s) received for %s",
2937 gnlh->cmd, nl80211_command_to_string(gnlh->cmd),
2938 bss->ifname);
2939
cc7a48d1 2940 switch (gnlh->cmd) {
a11241fa
JB		 2941 case NL80211_CMD_FRAME:
2942 case NL80211_CMD_FRAME_TX_STATUS:
97279d8d 2943 mlme_event(bss, gnlh->cmd, tb[NL80211_ATTR_FRAME],
a11241fa
JB		 2944 tb[NL80211_ATTR_MAC], tb[NL80211_ATTR_TIMED_OUT],
2945 tb[NL80211_ATTR_WIPHY_FREQ], tb[NL80211_ATTR_ACK],
da873dbb
JB		 2946 tb[NL80211_ATTR_COOKIE],
2947 tb[NL80211_ATTR_RX_SIGNAL_DBM]);
a11241fa 2948 break;
02bb32c3 2949 case NL80211_CMD_UNEXPECTED_FRAME:
3088e4e5
JB		 2950 nl80211_spurious_frame(bss, tb, 0);
2951 break;
2952 case NL80211_CMD_UNEXPECTED_4ADDR_FRAME:
2953 nl80211_spurious_frame(bss, tb, 1);
02bb32c3 2954 break;
cc7a48d1
JB		 2955 default:
2956 wpa_printf(MSG_DEBUG, "nl80211: Ignored unknown event "
2957 "(cmd=%d)", gnlh->cmd);
2958 break;
2959 }
2960
2961 return NL_SKIP;
2962}
2963
2964
97865538 2965static void wpa_driver_nl80211_event_receive(int sock, void *eloop_ctx,
5582a5d1 2966 void *handle)
97865538 2967{
a4ae123c 2968 struct nl_cb *cb = eloop_ctx;
34068ac3 2969 int res;
97865538 2970
cc2ada86 2971 wpa_printf(MSG_MSGDUMP, "nl80211: Event message available");
97865538 2972
34068ac3
JM		 2973 res = nl_recvmsgs(handle, cb);
2974 if (res) {
2975 wpa_printf(MSG_INFO, "nl80211: %s->nl_recvmsgs failed: %d",
2976 __func__, res);
2977 }
97865538
JM		 2978}
2979
2980
6d158490
LR		 2981/**
2982 * wpa_driver_nl80211_set_country - ask nl80211 to set the regulatory domain
2983 * @priv: driver_nl80211 private data
2984 * @alpha2_arg: country to which to switch to
2985 * Returns: 0 on success, -1 on failure
2986 *
2987 * This asks nl80211 to set the regulatory domain for given
2988 * country ISO / IEC alpha2.
2989 */
2990static int wpa_driver_nl80211_set_country(void *priv, const char *alpha2_arg)
2991{
a2e40bb6
FF		 2992 struct i802_bss *bss = priv;
2993 struct wpa_driver_nl80211_data *drv = bss->drv;
6d158490
LR		 2994 char alpha2[3];
2995 struct nl_msg *msg;
2996
2997 msg = nlmsg_alloc();
2998 if (!msg)
e785c2ba 2999 return -ENOMEM;
6d158490
LR		 3000
3001 alpha2[0] = alpha2_arg[0];
3002 alpha2[1] = alpha2_arg[1];
3003 alpha2[2] = '\0';
3004
9fb04070 3005 nl80211_cmd(drv, msg, 0, NL80211_CMD_REQ_SET_REG);
6d158490
LR		 3006
3007 NLA_PUT_STRING(msg, NL80211_ATTR_REG_ALPHA2, alpha2);
3008 if (send_and_recv_msgs(drv, msg, NULL, NULL))
3009 return -EINVAL;
3010 return 0;
3011nla_put_failure:
5883168a 3012 nlmsg_free(msg);
6d158490
LR		 3013 return -EINVAL;
3014}
3015
3016
f0793bf1
JM		 3017static int nl80211_get_country(struct nl_msg *msg, void *arg)
3018{
3019 char *alpha2 = arg;
3020 struct nlattr *tb_msg[NL80211_ATTR_MAX + 1];
3021 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
3022
3023 nla_parse(tb_msg, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
3024 genlmsg_attrlen(gnlh, 0), NULL);
3025 if (!tb_msg[NL80211_ATTR_REG_ALPHA2]) {
3026 wpa_printf(MSG_DEBUG, "nl80211: No country information available");
3027 return NL_SKIP;
3028 }
3029 os_strlcpy(alpha2, nla_data(tb_msg[NL80211_ATTR_REG_ALPHA2]), 3);
3030 return NL_SKIP;
3031}
3032
3033
3034static int wpa_driver_nl80211_get_country(void *priv, char *alpha2)
3035{
3036 struct i802_bss *bss = priv;
3037 struct wpa_driver_nl80211_data *drv = bss->drv;
3038 struct nl_msg *msg;
3039 int ret;
3040
3041 msg = nlmsg_alloc();
3042 if (!msg)
3043 return -ENOMEM;
3044
3045 nl80211_cmd(drv, msg, 0, NL80211_CMD_GET_REG);
3046 alpha2[0] = '\0';
3047 ret = send_and_recv_msgs(drv, msg, nl80211_get_country, alpha2);
3048 if (!alpha2[0])
3049 ret = -1;
3050
3051 return ret;
3052}
3053
3054
43245552
DJ		 3055static int protocol_feature_handler(struct nl_msg *msg, void *arg)
3056{
3057 u32 *feat = arg;
3058 struct nlattr *tb_msg[NL80211_ATTR_MAX + 1];
3059 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
3060
3061 nla_parse(tb_msg, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
3062 genlmsg_attrlen(gnlh, 0), NULL);
3063
3064 if (tb_msg[NL80211_ATTR_PROTOCOL_FEATURES])
3065 *feat = nla_get_u32(tb_msg[NL80211_ATTR_PROTOCOL_FEATURES]);
3066
3067 return NL_SKIP;
3068}
3069
3070
3071static u32 get_nl80211_protocol_features(struct wpa_driver_nl80211_data *drv)
3072{
3073 u32 feat = 0;
3074 struct nl_msg *msg;
3075
3076 msg = nlmsg_alloc();
3077 if (!msg)
3078 goto nla_put_failure;
3079
3080 nl80211_cmd(drv, msg, 0, NL80211_CMD_GET_PROTOCOL_FEATURES);
3081 if (send_and_recv_msgs(drv, msg, protocol_feature_handler, &feat) == 0)
3082 return feat;
3083
3084 msg = NULL;
3085nla_put_failure:
3086 nlmsg_free(msg);
3087 return 0;
3088}
3089
3090
80bc75f1 3091struct wiphy_info_data {
8cd6b7bc 3092 struct wpa_driver_nl80211_data *drv;
e8b5e24e
JB		 3093 struct wpa_driver_capa *capa;
3094
4752147d
IP		 3095 unsigned int num_multichan_concurrent;
3096
e8b5e24e 3097 unsigned int error:1;
61cbe2ff 3098 unsigned int device_ap_sme:1;
39718852 3099 unsigned int poll_command_supported:1;
32ab4855 3100 unsigned int data_tx_status:1;
536062f2 3101 unsigned int monitor_supported:1;
43245552
DJ		 3102 unsigned int auth_supported:1;
3103 unsigned int connect_supported:1;
3104 unsigned int p2p_go_supported:1;
3105 unsigned int p2p_client_supported:1;
3106 unsigned int p2p_concurrent:1;
1c4ffa87 3107 unsigned int channel_switch_supported:1;
80bc75f1
JM		 3108};
3109
3110
562c9d97
AN		 3111static unsigned int probe_resp_offload_support(int supp_protocols)
3112{
3113 unsigned int prot = 0;
3114
3115 if (supp_protocols & NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS)
3116 prot |= WPA_DRIVER_PROBE_RESP_OFFLOAD_WPS;
3117 if (supp_protocols & NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2)
3118 prot |= WPA_DRIVER_PROBE_RESP_OFFLOAD_WPS2;
3119 if (supp_protocols & NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P)
3120 prot |= WPA_DRIVER_PROBE_RESP_OFFLOAD_P2P;
3121 if (supp_protocols & NL80211_PROBE_RESP_OFFLOAD_SUPPORT_80211U)
3122 prot |= WPA_DRIVER_PROBE_RESP_OFFLOAD_INTERWORKING;
3123
3124 return prot;
3125}
3126
3127
5f439107
JM		 3128static void wiphy_info_supported_iftypes(struct wiphy_info_data *info,
3129 struct nlattr *tb)
80bc75f1 3130{
5f439107
JM		 3131 struct nlattr *nl_mode;
3132 int i;
3133
3134 if (tb == NULL)
3135 return;
3136
3137 nla_for_each_nested(nl_mode, tb, i) {
3138 switch (nla_type(nl_mode)) {
3139 case NL80211_IFTYPE_AP:
3140 info->capa->flags |= WPA_DRIVER_FLAGS_AP;
3141 break;
65d52fc1
BR		 3142 case NL80211_IFTYPE_ADHOC:
3143 info->capa->flags |= WPA_DRIVER_FLAGS_IBSS;
3144 break;
7aad838c
NS		 3145 case NL80211_IFTYPE_P2P_DEVICE:
3146 info->capa->flags |=
3147 WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE;
3148 break;
5f439107
JM		 3149 case NL80211_IFTYPE_P2P_GO:
3150 info->p2p_go_supported = 1;
3151 break;
3152 case NL80211_IFTYPE_P2P_CLIENT:
3153 info->p2p_client_supported = 1;
3154 break;
3155 case NL80211_IFTYPE_MONITOR:
3156 info->monitor_supported = 1;
3157 break;
3158 }
3159 }
3160}
3161
3162
3163static int wiphy_info_iface_comb_process(struct wiphy_info_data *info,
3164 struct nlattr *nl_combi)
3165{
3166 struct nlattr *tb_comb[NUM_NL80211_IFACE_COMB];
3167 struct nlattr *tb_limit[NUM_NL80211_IFACE_LIMIT];
3168 struct nlattr *nl_limit, *nl_mode;
3169 int err, rem_limit, rem_mode;
3170 int combination_has_p2p = 0, combination_has_mgd = 0;
7626850d
JB		 3171 static struct nla_policy
3172 iface_combination_policy[NUM_NL80211_IFACE_COMB] = {
3173 [NL80211_IFACE_COMB_LIMITS] = { .type = NLA_NESTED },
3174 [NL80211_IFACE_COMB_MAXNUM] = { .type = NLA_U32 },
3175 [NL80211_IFACE_COMB_STA_AP_BI_MATCH] = { .type = NLA_FLAG },
3176 [NL80211_IFACE_COMB_NUM_CHANNELS] = { .type = NLA_U32 },
f295d0c8 3177 [NL80211_IFACE_COMB_RADAR_DETECT_WIDTHS] = { .type = NLA_U32 },
7626850d
JB		 3178 },
3179 iface_limit_policy[NUM_NL80211_IFACE_LIMIT] = {
3180 [NL80211_IFACE_LIMIT_TYPES] = { .type = NLA_NESTED },
3181 [NL80211_IFACE_LIMIT_MAX] = { .type = NLA_U32 },
3182 };
80bc75f1 3183
5f439107
JM		 3184 err = nla_parse_nested(tb_comb, MAX_NL80211_IFACE_COMB,
3185 nl_combi, iface_combination_policy);
3186 if (err || !tb_comb[NL80211_IFACE_COMB_LIMITS] ||
3187 !tb_comb[NL80211_IFACE_COMB_MAXNUM] ||
3188 !tb_comb[NL80211_IFACE_COMB_NUM_CHANNELS])
3189 return 0; /* broken combination */
3190
f295d0c8
SW		 3191 if (tb_comb[NL80211_IFACE_COMB_RADAR_DETECT_WIDTHS])
3192 info->capa->flags |= WPA_DRIVER_FLAGS_RADAR;
3193
5f439107
JM		 3194 nla_for_each_nested(nl_limit, tb_comb[NL80211_IFACE_COMB_LIMITS],
3195 rem_limit) {
3196 err = nla_parse_nested(tb_limit, MAX_NL80211_IFACE_LIMIT,
3197 nl_limit, iface_limit_policy);
3198 if (err || !tb_limit[NL80211_IFACE_LIMIT_TYPES])
3199 return 0; /* broken combination */
3200
3201 nla_for_each_nested(nl_mode,
3202 tb_limit[NL80211_IFACE_LIMIT_TYPES],
3203 rem_mode) {
3204 int ift = nla_type(nl_mode);
3205 if (ift == NL80211_IFTYPE_P2P_GO ||
3206 ift == NL80211_IFTYPE_P2P_CLIENT)
3207 combination_has_p2p = 1;
3208 if (ift == NL80211_IFTYPE_STATION)
3209 combination_has_mgd = 1;
3210 }
3211 if (combination_has_p2p && combination_has_mgd)
3212 break;
3213 }
3214
3215 if (combination_has_p2p && combination_has_mgd) {
3216 info->p2p_concurrent = 1;
4752147d
IP		 3217 info->num_multichan_concurrent =
3218 nla_get_u32(tb_comb[NL80211_IFACE_COMB_NUM_CHANNELS]);
5f439107
JM		 3219 return 1;
3220 }
3221
3222 return 0;
3223}
3224
3225
3226static void wiphy_info_iface_comb(struct wiphy_info_data *info,
3227 struct nlattr *tb)
3228{
3229 struct nlattr *nl_combi;
3230 int rem_combi;
3231
3232 if (tb == NULL)
3233 return;
3234
3235 nla_for_each_nested(nl_combi, tb, rem_combi) {
3236 if (wiphy_info_iface_comb_process(info, nl_combi) > 0)
3237 break;
3238 }
3239}
3240
3241
3242static void wiphy_info_supp_cmds(struct wiphy_info_data *info,
3243 struct nlattr *tb)
3244{
3245 struct nlattr *nl_cmd;
3246 int i;
3247
3248 if (tb == NULL)
3249 return;
3250
3251 nla_for_each_nested(nl_cmd, tb, i) {
3252 switch (nla_get_u32(nl_cmd)) {
3253 case NL80211_CMD_AUTHENTICATE:
3254 info->auth_supported = 1;
3255 break;
3256 case NL80211_CMD_CONNECT:
3257 info->connect_supported = 1;
3258 break;
3259 case NL80211_CMD_START_SCHED_SCAN:
3260 info->capa->sched_scan_supported = 1;
3261 break;
3262 case NL80211_CMD_PROBE_CLIENT:
3263 info->poll_command_supported = 1;
3264 break;
1c4ffa87
AO		 3265 case NL80211_CMD_CHANNEL_SWITCH:
3266 info->channel_switch_supported = 1;
3267 break;
5f439107
JM		 3268 }
3269 }
3270}
3271
3272
3273static void wiphy_info_max_roc(struct wpa_driver_capa *capa,
3274 struct nlattr *tb)
3275{
5f439107
JM		 3276 if (tb)
3277 capa->max_remain_on_chan = nla_get_u32(tb);
3278}
3279
3280
3281static void wiphy_info_tdls(struct wpa_driver_capa *capa, struct nlattr *tdls,
3282 struct nlattr *ext_setup)
3283{
3284 if (tdls == NULL)
3285 return;
3286
3287 wpa_printf(MSG_DEBUG, "nl80211: TDLS supported");
3288 capa->flags |= WPA_DRIVER_FLAGS_TDLS_SUPPORT;
3289
3290 if (ext_setup) {
3291 wpa_printf(MSG_DEBUG, "nl80211: TDLS external setup");
3292 capa->flags |= WPA_DRIVER_FLAGS_TDLS_EXTERNAL_SETUP;
3293 }
3294}
3295
3296
3297static void wiphy_info_feature_flags(struct wiphy_info_data *info,
3298 struct nlattr *tb)
3299{
3300 u32 flags;
3301 struct wpa_driver_capa *capa = info->capa;
3302
3303 if (tb == NULL)
3304 return;
3305
3306 flags = nla_get_u32(tb);
3307
3308 if (flags & NL80211_FEATURE_SK_TX_STATUS)
3309 info->data_tx_status = 1;
3310
3311 if (flags & NL80211_FEATURE_INACTIVITY_TIMER)
3312 capa->flags |= WPA_DRIVER_FLAGS_INACTIVITY_TIMER;
3313
3314 if (flags & NL80211_FEATURE_SAE)
3315 capa->flags |= WPA_DRIVER_FLAGS_SAE;
3316
3317 if (flags & NL80211_FEATURE_NEED_OBSS_SCAN)
3318 capa->flags |= WPA_DRIVER_FLAGS_OBSS_SCAN;
3319}
3320
3321
3322static void wiphy_info_probe_resp_offload(struct wpa_driver_capa *capa,
3323 struct nlattr *tb)
3324{
3325 u32 protocols;
3326
3327 if (tb == NULL)
3328 return;
3329
3330 protocols = nla_get_u32(tb);
3331 wpa_printf(MSG_DEBUG, "nl80211: Supports Probe Response offload in AP "
3332 "mode");
3333 capa->flags |= WPA_DRIVER_FLAGS_PROBE_RESP_OFFLOAD;
3334 capa->probe_resp_offloads = probe_resp_offload_support(protocols);
3335}
3336
3337
3338static int wiphy_info_handler(struct nl_msg *msg, void *arg)
3339{
3340 struct nlattr *tb[NL80211_ATTR_MAX + 1];
3341 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
3342 struct wiphy_info_data *info = arg;
3343 struct wpa_driver_capa *capa = info->capa;
8cd6b7bc 3344 struct wpa_driver_nl80211_data *drv = info->drv;
5f439107 3345
80bc75f1
JM		 3346 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
3347 genlmsg_attrlen(gnlh, 0), NULL);
3348
5fbcb45d 3349 if (tb[NL80211_ATTR_WIPHY_NAME])
24f051eb 3350 os_strlcpy(drv->phyname,
5fbcb45d
AS		 3351 nla_get_string(tb[NL80211_ATTR_WIPHY_NAME]),
3352 sizeof(drv->phyname));
80bc75f1 3353 if (tb[NL80211_ATTR_MAX_NUM_SCAN_SSIDS])
e8b5e24e 3354 capa->max_scan_ssids =
80bc75f1
JM		 3355 nla_get_u8(tb[NL80211_ATTR_MAX_NUM_SCAN_SSIDS]);
3356
d21c63b9 3357 if (tb[NL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDS])
e8b5e24e 3358 capa->max_sched_scan_ssids =
d21c63b9
LC		 3359 nla_get_u8(tb[NL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDS]);
3360
bd525934 3361 if (tb[NL80211_ATTR_MAX_MATCH_SETS])
e8b5e24e 3362 capa->max_match_sets =
bd525934
LC		 3363 nla_get_u8(tb[NL80211_ATTR_MAX_MATCH_SETS]);
3364
3c4ca363
VN		 3365 if (tb[NL80211_ATTR_MAC_ACL_MAX])
3366 capa->max_acl_mac_addrs =
3367 nla_get_u8(tb[NL80211_ATTR_MAC_ACL_MAX]);
3368
5f439107
JM		 3369 wiphy_info_supported_iftypes(info, tb[NL80211_ATTR_SUPPORTED_IFTYPES]);
3370 wiphy_info_iface_comb(info, tb[NL80211_ATTR_INTERFACE_COMBINATIONS]);
3371 wiphy_info_supp_cmds(info, tb[NL80211_ATTR_SUPPORTED_COMMANDS]);
93d11400 3372
e8b5e24e
JB		 3373 if (tb[NL80211_ATTR_OFFCHANNEL_TX_OK]) {
3374 wpa_printf(MSG_DEBUG, "nl80211: Using driver-based "
3375 "off-channel TX");
3376 capa->flags |= WPA_DRIVER_FLAGS_OFFCHANNEL_TX;
3377 }
3378
3379 if (tb[NL80211_ATTR_ROAM_SUPPORT]) {
3380 wpa_printf(MSG_DEBUG, "nl80211: Using driver-based roaming");
3381 capa->flags |= WPA_DRIVER_FLAGS_BSS_SELECTION;
3382 }
5dfca53f 3383
5f439107
JM		 3384 wiphy_info_max_roc(capa,
3385 tb[NL80211_ATTR_MAX_REMAIN_ON_CHANNEL_DURATION]);
004ba773 3386
70619a5d
EP		 3387 if (tb[NL80211_ATTR_SUPPORT_AP_UAPSD])
3388 capa->flags |= WPA_DRIVER_FLAGS_AP_UAPSD;
3389
5f439107
JM		 3390 wiphy_info_tdls(capa, tb[NL80211_ATTR_TDLS_SUPPORT],
3391 tb[NL80211_ATTR_TDLS_EXTERNAL_SETUP]);
03ea1786 3392
61cbe2ff
JB		 3393 if (tb[NL80211_ATTR_DEVICE_AP_SME])
3394 info->device_ap_sme = 1;
3395
5f439107
JM		 3396 wiphy_info_feature_flags(info, tb[NL80211_ATTR_FEATURE_FLAGS]);
3397 wiphy_info_probe_resp_offload(capa,
3398 tb[NL80211_ATTR_PROBE_RESP_OFFLOAD]);
562c9d97 3399
8cd6b7bc
JB		 3400 if (tb[NL80211_ATTR_EXT_CAPA] && tb[NL80211_ATTR_EXT_CAPA_MASK] &&
3401 drv->extended_capa == NULL) {
3402 drv->extended_capa =
3403 os_malloc(nla_len(tb[NL80211_ATTR_EXT_CAPA]));
3404 if (drv->extended_capa) {
3405 os_memcpy(drv->extended_capa,
3406 nla_data(tb[NL80211_ATTR_EXT_CAPA]),
3407 nla_len(tb[NL80211_ATTR_EXT_CAPA]));
3408 drv->extended_capa_len =
3409 nla_len(tb[NL80211_ATTR_EXT_CAPA]);
3410 }
3411 drv->extended_capa_mask =
3412 os_malloc(nla_len(tb[NL80211_ATTR_EXT_CAPA]));
3413 if (drv->extended_capa_mask) {
3414 os_memcpy(drv->extended_capa_mask,
3415 nla_data(tb[NL80211_ATTR_EXT_CAPA]),
3416 nla_len(tb[NL80211_ATTR_EXT_CAPA]));
3417 } else {
3418 os_free(drv->extended_capa);
3419 drv->extended_capa = NULL;
3420 drv->extended_capa_len = 0;
3421 }
3422 }
3423
80bc75f1
JM		 3424 return NL_SKIP;
3425}
3426
3427
3428static int wpa_driver_nl80211_get_info(struct wpa_driver_nl80211_data *drv,
3429 struct wiphy_info_data *info)
3430{
43245552 3431 u32 feat;
80bc75f1
JM		 3432 struct nl_msg *msg;
3433
3434 os_memset(info, 0, sizeof(*info));
e8b5e24e 3435 info->capa = &drv->capa;
8cd6b7bc 3436 info->drv = drv;
89e07afb 3437
80bc75f1
JM		 3438 msg = nlmsg_alloc();
3439 if (!msg)
3440 return -1;
3441
43245552
DJ		 3442 feat = get_nl80211_protocol_features(drv);
3443 if (feat & NL80211_PROTOCOL_FEATURE_SPLIT_WIPHY_DUMP)
3444 nl80211_cmd(drv, msg, NLM_F_DUMP, NL80211_CMD_GET_WIPHY);
3445 else
3446 nl80211_cmd(drv, msg, 0, NL80211_CMD_GET_WIPHY);
80bc75f1 3447
43245552 3448 NLA_PUT_FLAG(msg, NL80211_ATTR_SPLIT_WIPHY_DUMP);
834ee56f 3449 if (nl80211_set_iface_id(msg, drv->first_bss) < 0)
f632e483 3450 goto nla_put_failure;
80bc75f1 3451
43245552
DJ		 3452 if (send_and_recv_msgs(drv, msg, wiphy_info_handler, info))
3453 return -1;
3454
3455 if (info->auth_supported)
3456 drv->capa.flags |= WPA_DRIVER_FLAGS_SME;
3457 else if (!info->connect_supported) {
3458 wpa_printf(MSG_INFO, "nl80211: Driver does not support "
3459 "authentication/association or connect commands");
3460 info->error = 1;
3461 }
3462
3463 if (info->p2p_go_supported && info->p2p_client_supported)
3464 drv->capa.flags |= WPA_DRIVER_FLAGS_P2P_CAPABLE;
3465 if (info->p2p_concurrent) {
3466 wpa_printf(MSG_DEBUG, "nl80211: Use separate P2P group "
3467 "interface (driver advertised support)");
3468 drv->capa.flags |= WPA_DRIVER_FLAGS_P2P_CONCURRENT;
3469 drv->capa.flags |= WPA_DRIVER_FLAGS_P2P_MGMT_AND_NON_P2P;
3470 }
4752147d 3471 if (info->num_multichan_concurrent > 1) {
43245552
DJ		 3472 wpa_printf(MSG_DEBUG, "nl80211: Enable multi-channel "
3473 "concurrent (driver advertised support)");
4752147d
IP		 3474 drv->capa.num_multichan_concurrent =
3475 info->num_multichan_concurrent;
43245552 3476 }
b691dcb1
IP		 3477
3478 /* default to 5000 since early versions of mac80211 don't set it */
3479 if (!drv->capa.max_remain_on_chan)
3480 drv->capa.max_remain_on_chan = 5000;
3481
43245552 3482 return 0;
80bc75f1
JM		 3483nla_put_failure:
3484 nlmsg_free(msg);
3485 return -1;
3486}
3487
3488
93d11400 3489static int wpa_driver_nl80211_capa(struct wpa_driver_nl80211_data *drv)
80bc75f1
JM		 3490{
3491 struct wiphy_info_data info;
3492 if (wpa_driver_nl80211_get_info(drv, &info))
93d11400 3493 return -1;
e8b5e24e
JB		 3494
3495 if (info.error)
3496 return -1;
3497
80bc75f1 3498 drv->has_capability = 1;
1b2a72e8
JM		 3499 /* For now, assume TKIP, CCMP, WPA, WPA2 are supported */
3500 drv->capa.key_mgmt = WPA_DRIVER_CAPA_KEY_MGMT_WPA |
3501 WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK |
3502 WPA_DRIVER_CAPA_KEY_MGMT_WPA2 |
3503 WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK;
3504 drv->capa.enc = WPA_DRIVER_CAPA_ENC_WEP40 |
3505 WPA_DRIVER_CAPA_ENC_WEP104 |
3506 WPA_DRIVER_CAPA_ENC_TKIP |
3507 WPA_DRIVER_CAPA_ENC_CCMP;
291b6068
JM		 3508 drv->capa.auth = WPA_DRIVER_AUTH_OPEN |
3509 WPA_DRIVER_AUTH_SHARED |
3510 WPA_DRIVER_AUTH_LEAP;
1b2a72e8 3511
871f4dd0 3512 drv->capa.flags |= WPA_DRIVER_FLAGS_SANE_ERROR_CODES;
0194fedb 3513 drv->capa.flags |= WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC_DONE;
2fee890a 3514 drv->capa.flags |= WPA_DRIVER_FLAGS_EAPOL_TX_STATUS;
e1bd4e19 3515
e5091674 3516 if (!info.device_ap_sme) {
e1bd4e19 3517 drv->capa.flags |= WPA_DRIVER_FLAGS_DEAUTH_TX_STATUS;
0194fedb 3518
e5091674
JM		 3519 /*
3520 * No AP SME is currently assumed to also indicate no AP MLME
3521 * in the driver/firmware.
3522 */
3523 drv->capa.flags |= WPA_DRIVER_FLAGS_AP_MLME;
3524 }
3525
61cbe2ff 3526 drv->device_ap_sme = info.device_ap_sme;
39718852 3527 drv->poll_command_supported = info.poll_command_supported;
32ab4855 3528 drv->data_tx_status = info.data_tx_status;
1c4ffa87 3529 drv->channel_switch_supported = info.channel_switch_supported;
61cbe2ff 3530
a11241fa 3531 /*
73a3c6ff
FF		 3532 * If poll command and tx status are supported, mac80211 is new enough
3533 * to have everything we need to not need monitor interfaces.
a11241fa 3534 */
73a3c6ff 3535 drv->use_monitor = !info.poll_command_supported || !info.data_tx_status;
a11241fa 3536
536062f2
JM		 3537 if (drv->device_ap_sme && drv->use_monitor) {
3538 /*
3539 * Non-mac80211 drivers may not support monitor interface.
3540 * Make sure we do not get stuck with incorrect capability here
3541 * by explicitly testing this.
3542 */
3543 if (!info.monitor_supported) {
3544 wpa_printf(MSG_DEBUG, "nl80211: Disable use_monitor "
3545 "with device_ap_sme since no monitor mode "
3546 "support detected");
3547 drv->use_monitor = 0;
3548 }
3549 }
3550
a11241fa
JB		 3551 /*
3552 * If we aren't going to use monitor interfaces, but the
3553 * driver doesn't support data TX status, we won't get TX
3554 * status for EAPOL frames.
3555 */
3556 if (!drv->use_monitor && !info.data_tx_status)
3557 drv->capa.flags &= ~WPA_DRIVER_FLAGS_EAPOL_TX_STATUS;
3558
93d11400 3559 return 0;
80bc75f1
JM		 3560}
3561
3562
b088cf82
JM		 3563#ifdef ANDROID
3564static int android_genl_ctrl_resolve(struct nl_handle *handle,
3565 const char *name)
3566{
3567 /*
3568 * Android ICS has very minimal genl_ctrl_resolve() implementation, so
3569 * need to work around that.
3570 */
3571 struct nl_cache *cache = NULL;
3572 struct genl_family *nl80211 = NULL;
3573 int id = -1;
3574
3575 if (genl_ctrl_alloc_cache(handle, &cache) < 0) {
3576 wpa_printf(MSG_ERROR, "nl80211: Failed to allocate generic "
3577 "netlink cache");
3578 goto fail;
3579 }
3580
3581 nl80211 = genl_ctrl_search_by_name(cache, name);
3582 if (nl80211 == NULL)
3583 goto fail;
3584
3585 id = genl_family_get_id(nl80211);
3586
3587fail:
3588 if (nl80211)
3589 genl_family_put(nl80211);
3590 if (cache)
3591 nl_cache_free(cache);
3592
3593 return id;
3594}
3595#define genl_ctrl_resolve android_genl_ctrl_resolve
3596#endif /* ANDROID */
3597
3598
2a7b66f5
BG		 3599static int wpa_driver_nl80211_init_nl_global(struct nl80211_global *global)
3600{
d6c9aab8
JB		 3601 int ret;
3602
2a7b66f5
BG		 3603 global->nl_cb = nl_cb_alloc(NL_CB_DEFAULT);
3604 if (global->nl_cb == NULL) {
3605 wpa_printf(MSG_ERROR, "nl80211: Failed to allocate netlink "
3606 "callbacks");
3607 return -1;
3608 }
3609
481234cf
JM		 3610 global->nl = nl_create_handle(global->nl_cb, "nl");
3611 if (global->nl == NULL)
d6c9aab8 3612 goto err;
276e2d67 3613
481234cf 3614 global->nl80211_id = genl_ctrl_resolve(global->nl, "nl80211");
335d42b1 3615 if (global->nl80211_id < 0) {
276e2d67
BG		 3616 wpa_printf(MSG_ERROR, "nl80211: 'nl80211' generic netlink not "
3617 "found");
d6c9aab8 3618 goto err;
276e2d67
BG		 3619 }
3620
481234cf
JM		 3621 global->nl_event = nl_create_handle(global->nl_cb, "event");
3622 if (global->nl_event == NULL)
d6c9aab8 3623 goto err;
9fff9fdc 3624
d6c9aab8 3625 ret = nl_get_multicast_id(global, "nl80211", "scan");
97865538 3626 if (ret >= 0)
481234cf 3627 ret = nl_socket_add_membership(global->nl_event, ret);
97865538
JM		 3628 if (ret < 0) {
3629 wpa_printf(MSG_ERROR, "nl80211: Could not add multicast "
3630 "membership for scan events: %d (%s)",
3631 ret, strerror(-ret));
d6c9aab8 3632 goto err;
97865538 3633 }
c2a04078 3634
d6c9aab8 3635 ret = nl_get_multicast_id(global, "nl80211", "mlme");
c2a04078 3636 if (ret >= 0)
481234cf 3637 ret = nl_socket_add_membership(global->nl_event, ret);
c2a04078
JM		 3638 if (ret < 0) {
3639 wpa_printf(MSG_ERROR, "nl80211: Could not add multicast "
3640 "membership for mlme events: %d (%s)",
3641 ret, strerror(-ret));
d6c9aab8 3642 goto err;
c2a04078 3643 }
c2a04078 3644
d6c9aab8 3645 ret = nl_get_multicast_id(global, "nl80211", "regulatory");
33c5deb8 3646 if (ret >= 0)
481234cf 3647 ret = nl_socket_add_membership(global->nl_event, ret);
33c5deb8
JM		 3648 if (ret < 0) {
3649 wpa_printf(MSG_DEBUG, "nl80211: Could not add multicast "
3650 "membership for regulatory events: %d (%s)",
3651 ret, strerror(-ret));
3652 /* Continue without regulatory events */
3653 }
3654
d6c9aab8
JB		 3655 nl_cb_set(global->nl_cb, NL_CB_SEQ_CHECK, NL_CB_CUSTOM,
3656 no_seq_check, NULL);
3657 nl_cb_set(global->nl_cb, NL_CB_VALID, NL_CB_CUSTOM,
3658 process_global_event, global);
3659
5f65e9f7
JB		 3660 nl80211_register_eloop_read(&global->nl_event,
3661 wpa_driver_nl80211_event_receive,
3662 global->nl_cb);
d6c9aab8
JB		 3663
3664 return 0;
3665
3666err:
3667 nl_destroy_handles(&global->nl_event);
3668 nl_destroy_handles(&global->nl);
3669 nl_cb_put(global->nl_cb);
671a5039 3670 global->nl_cb = NULL;
d6c9aab8
JB		 3671 return -1;
3672}
3673
3674
3675static int wpa_driver_nl80211_init_nl(struct wpa_driver_nl80211_data *drv)
3676{
1afc986d
JB		 3677 drv->nl_cb = nl_cb_alloc(NL_CB_DEFAULT);
3678 if (!drv->nl_cb) {
3679 wpa_printf(MSG_ERROR, "nl80211: Failed to alloc cb struct");
d6c9aab8 3680 return -1;
1afc986d
JB		 3681 }
3682
3683 nl_cb_set(drv->nl_cb, NL_CB_SEQ_CHECK, NL_CB_CUSTOM,
3684 no_seq_check, NULL);
f06aedd9
JB		 3685 nl_cb_set(drv->nl_cb, NL_CB_VALID, NL_CB_CUSTOM,
3686 process_drv_event, drv);
1afc986d 3687
9fff9fdc 3688 return 0;
9fff9fdc
JM		 3689}
3690
3691
8401a6b0
JM		 3692static void wpa_driver_nl80211_rfkill_blocked(void *ctx)
3693{
8401a6b0 3694 wpa_printf(MSG_DEBUG, "nl80211: RFKILL blocked");
a63063b4
JM		 3695 /*
3696 * This may be for any interface; use ifdown event to disable
3697 * interface.
3698 */
8401a6b0
JM		 3699}
3700
3701
3702static void wpa_driver_nl80211_rfkill_unblocked(void *ctx)
3703{
3704 struct wpa_driver_nl80211_data *drv = ctx;
3705 wpa_printf(MSG_DEBUG, "nl80211: RFKILL unblocked");
834ee56f 3706 if (i802_set_iface_flags(drv->first_bss, 1)) {
8401a6b0
JM		 3707 wpa_printf(MSG_DEBUG, "nl80211: Could not set interface UP "
3708 "after rfkill unblock");
3709 return;
3710 }
a63063b4 3711 /* rtnetlink ifup handler will report interface as enabled */
8401a6b0
JM		 3712}
3713
3714
32ab4855
JB		 3715static void wpa_driver_nl80211_handle_eapol_tx_status(int sock,
3716 void *eloop_ctx,
3717 void *handle)
3718{
3719 struct wpa_driver_nl80211_data *drv = eloop_ctx;
3720 u8 data[2048];
3721 struct msghdr msg;
3722 struct iovec entry;
cad0f50e 3723 u8 control[512];
32ab4855
JB		 3724 struct cmsghdr *cmsg;
3725 int res, found_ee = 0, found_wifi = 0, acked = 0;
3726 union wpa_event_data event;
3727
3728 memset(&msg, 0, sizeof(msg));
3729 msg.msg_iov = &entry;
3730 msg.msg_iovlen = 1;
3731 entry.iov_base = data;
3732 entry.iov_len = sizeof(data);
3733 msg.msg_control = &control;
3734 msg.msg_controllen = sizeof(control);
3735
3736 res = recvmsg(sock, &msg, MSG_ERRQUEUE);
3737 /* if error or not fitting 802.3 header, return */
3738 if (res < 14)
3739 return;
3740
3741 for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg))
3742 {
3743 if (cmsg->cmsg_level == SOL_SOCKET &&
3744 cmsg->cmsg_type == SCM_WIFI_STATUS) {
3745 int *ack;
3746
3747 found_wifi = 1;
3748 ack = (void *)CMSG_DATA(cmsg);
3749 acked = *ack;
3750 }
3751
3752 if (cmsg->cmsg_level == SOL_PACKET &&
3753 cmsg->cmsg_type == PACKET_TX_TIMESTAMP) {
3754 struct sock_extended_err *err =
3755 (struct sock_extended_err *)CMSG_DATA(cmsg);
3756
3757 if (err->ee_origin == SO_EE_ORIGIN_TXSTATUS)
3758 found_ee = 1;
3759 }
3760 }
3761
3762 if (!found_ee || !found_wifi)
3763 return;
3764
3765 memset(&event, 0, sizeof(event));
3766 event.eapol_tx_status.dst = data;
3767 event.eapol_tx_status.data = data + 14;
3768 event.eapol_tx_status.data_len = res - 14;
3769 event.eapol_tx_status.ack = acked;
3770 wpa_supplicant_event(drv->ctx, EVENT_EAPOL_TX_STATUS, &event);
3771}
3772
3773
cc7a48d1
JB		 3774static int nl80211_init_bss(struct i802_bss *bss)
3775{
3776 bss->nl_cb = nl_cb_alloc(NL_CB_DEFAULT);
3777 if (!bss->nl_cb)
3778 return -1;
3779
3780 nl_cb_set(bss->nl_cb, NL_CB_SEQ_CHECK, NL_CB_CUSTOM,
3781 no_seq_check, NULL);
3782 nl_cb_set(bss->nl_cb, NL_CB_VALID, NL_CB_CUSTOM,
3783 process_bss_event, bss);
3784
3785 return 0;
3786}
3787
3788
3789static void nl80211_destroy_bss(struct i802_bss *bss)
3790{
3791 nl_cb_put(bss->nl_cb);
3792 bss->nl_cb = NULL;
3793}
3794
3795
0d547d5f
JM		 3796static void * wpa_driver_nl80211_drv_init(void *ctx, const char *ifname,
3797 void *global_priv, int hostapd,
3798 const u8 *set_addr)
9fff9fdc 3799{
9fff9fdc 3800 struct wpa_driver_nl80211_data *drv;
8401a6b0 3801 struct rfkill_config *rcfg;
a2e40bb6 3802 struct i802_bss *bss;
9fff9fdc 3803
a5c696ad
JM		 3804 if (global_priv == NULL)
3805 return NULL;
9fff9fdc
JM		 3806 drv = os_zalloc(sizeof(*drv));
3807 if (drv == NULL)
3808 return NULL;
f2ed8023 3809 drv->global = global_priv;
9fff9fdc 3810 drv->ctx = ctx;
0d547d5f
JM		 3811 drv->hostapd = !!hostapd;
3812 drv->eapol_sock = -1;
3813 drv->num_if_indices = sizeof(drv->default_if_indices) / sizeof(int);
3814 drv->if_indices = drv->default_if_indices;
834ee56f
KP		 3815
3816 drv->first_bss = os_zalloc(sizeof(*drv->first_bss));
3817 if (!drv->first_bss) {
3818 os_free(drv);
3819 return NULL;
3820 }
3821 bss = drv->first_bss;
a2e40bb6 3822 bss->drv = drv;
a5e1eb20
SE		 3823 bss->ctx = ctx;
3824
a2e40bb6 3825 os_strlcpy(bss->ifname, ifname, sizeof(bss->ifname));
9fff9fdc
JM		 3826 drv->monitor_ifidx = -1;
3827 drv->monitor_sock = -1;
d12dab4c 3828 drv->eapol_tx_sock = -1;
b1f625e0 3829 drv->ap_scan_as_station = NL80211_IFTYPE_UNSPECIFIED;
9fff9fdc 3830
ba2d0d7d 3831 if (wpa_driver_nl80211_init_nl(drv)) {
bbaf0837
JM		 3832 os_free(drv);
3833 return NULL;
3834 }
9fff9fdc 3835
cc7a48d1
JB		 3836 if (nl80211_init_bss(bss))
3837 goto failed;
3838
8401a6b0
JM		 3839 rcfg = os_zalloc(sizeof(*rcfg));
3840 if (rcfg == NULL)
3841 goto failed;
3842 rcfg->ctx = drv;
3843 os_strlcpy(rcfg->ifname, ifname, sizeof(rcfg->ifname));
3844 rcfg->blocked_cb = wpa_driver_nl80211_rfkill_blocked;
3845 rcfg->unblocked_cb = wpa_driver_nl80211_rfkill_unblocked;
3846 drv->rfkill = rfkill_init(rcfg);
52169389 3847 if (drv->rfkill == NULL) {
8401a6b0 3848 wpa_printf(MSG_DEBUG, "nl80211: RFKILL status not available");
52169389
JM		 3849 os_free(rcfg);
3850 }
8401a6b0 3851
146fa9b3
JM		 3852 if (linux_iface_up(drv->global->ioctl_sock, ifname) > 0)
3853 drv->start_iface_up = 1;
3854
49b4b205 3855 if (wpa_driver_nl80211_finish_drv_init(drv, set_addr, 1))
bbaf0837 3856 goto failed;
7524cfb1 3857
d12dab4c 3858 drv->eapol_tx_sock = socket(PF_PACKET, SOCK_DGRAM, 0);
32ab4855
JB		 3859 if (drv->eapol_tx_sock < 0)
3860 goto failed;
3861
3862 if (drv->data_tx_status) {
3863 int enabled = 1;
3864
3865 if (setsockopt(drv->eapol_tx_sock, SOL_SOCKET, SO_WIFI_STATUS,
3866 &enabled, sizeof(enabled)) < 0) {
3867 wpa_printf(MSG_DEBUG,
3868 "nl80211: wifi status sockopt failed\n");
3869 drv->data_tx_status = 0;
a11241fa
JB		 3870 if (!drv->use_monitor)
3871 drv->capa.flags &=
3872 ~WPA_DRIVER_FLAGS_EAPOL_TX_STATUS;
32ab4855
JB		 3873 } else {
3874 eloop_register_read_sock(drv->eapol_tx_sock,
3875 wpa_driver_nl80211_handle_eapol_tx_status,
3876 drv, NULL);
3877 }
3878 }
f10bfc9a 3879
dac12351 3880 if (drv->global) {
c4bb8817 3881 dl_list_add(&drv->global->interfaces, &drv->list);
dac12351
BG		 3882 drv->in_interface_list = 1;
3883 }
c4bb8817 3884
a2e40bb6 3885 return bss;
7524cfb1 3886
bbaf0837 3887failed:
dac12351 3888 wpa_driver_nl80211_deinit(bss);
7524cfb1
JM		 3889 return NULL;
3890}
3891
3892
0d547d5f
JM		 3893/**
3894 * wpa_driver_nl80211_init - Initialize nl80211 driver interface
3895 * @ctx: context to be used when calling wpa_supplicant functions,
3896 * e.g., wpa_supplicant_event()
3897 * @ifname: interface name, e.g., wlan0
3898 * @global_priv: private driver global data from global_init()
3899 * Returns: Pointer to private data, %NULL on failure
3900 */
3901static void * wpa_driver_nl80211_init(void *ctx, const char *ifname,
3902 void *global_priv)
3903{
3904 return wpa_driver_nl80211_drv_init(ctx, ifname, global_priv, 0, NULL);
3905}
3906
3907
a11241fa 3908static int nl80211_register_frame(struct i802_bss *bss,
5582a5d1 3909 struct nl_handle *nl_handle,
bd94971e 3910 u16 type, const u8 *match, size_t match_len)
58f6fbe0 3911{
a11241fa 3912 struct wpa_driver_nl80211_data *drv = bss->drv;
58f6fbe0
JM		 3913 struct nl_msg *msg;
3914 int ret = -1;
3915
3916 msg = nlmsg_alloc();
3917 if (!msg)
3918 return -1;
3919
36488c05
JM		 3920 wpa_printf(MSG_DEBUG, "nl80211: Register frame type=0x%x nl_handle=%p",
3921 type, nl_handle);
3922 wpa_hexdump(MSG_DEBUG, "nl80211: Register frame match",
3923 match, match_len);
3924
9fb04070 3925 nl80211_cmd(drv, msg, 0, NL80211_CMD_REGISTER_ACTION);
58f6fbe0 3926
f632e483 3927 if (nl80211_set_iface_id(msg, bss) < 0)
d3aaef80
DS		 3928 goto nla_put_failure;
3929
bd94971e 3930 NLA_PUT_U16(msg, NL80211_ATTR_FRAME_TYPE, type);
58f6fbe0
JM		 3931 NLA_PUT(msg, NL80211_ATTR_FRAME_MATCH, match_len, match);
3932
d6c9aab8 3933 ret = send_and_recv(drv->global, nl_handle, msg, NULL, NULL);
58f6fbe0
JM		 3934 msg = NULL;
3935 if (ret) {
5582a5d1
JB		 3936 wpa_printf(MSG_DEBUG, "nl80211: Register frame command "
3937 "failed (type=%u): ret=%d (%s)",
3938 type, ret, strerror(-ret));
3939 wpa_hexdump(MSG_DEBUG, "nl80211: Register frame match",
58f6fbe0
JM		 3940 match, match_len);
3941 goto nla_put_failure;
3942 }
3943 ret = 0;
3944nla_put_failure:
3945 nlmsg_free(msg);
3946 return ret;
3947}
3948
3949
a11241fa
JB		 3950static int nl80211_alloc_mgmt_handle(struct i802_bss *bss)
3951{
3952 struct wpa_driver_nl80211_data *drv = bss->drv;
3953
481234cf 3954 if (bss->nl_mgmt) {
a11241fa 3955 wpa_printf(MSG_DEBUG, "nl80211: Mgmt reporting "
36488c05 3956 "already on! (nl_mgmt=%p)", bss->nl_mgmt);
a11241fa
JB		 3957 return -1;
3958 }
3959
481234cf
JM		 3960 bss->nl_mgmt = nl_create_handle(drv->nl_cb, "mgmt");
3961 if (bss->nl_mgmt == NULL)
a11241fa
JB		 3962 return -1;
3963
a11241fa
JB		 3964 return 0;
3965}
3966
3967
5f65e9f7
JB		 3968static void nl80211_mgmt_handle_register_eloop(struct i802_bss *bss)
3969{
3970 nl80211_register_eloop_read(&bss->nl_mgmt,
3971 wpa_driver_nl80211_event_receive,
3972 bss->nl_cb);
3973}
3974
3975
a11241fa 3976static int nl80211_register_action_frame(struct i802_bss *bss,
bd94971e
JB		 3977 const u8 *match, size_t match_len)
3978{
3979 u16 type = (WLAN_FC_TYPE_MGMT << 2) | (WLAN_FC_STYPE_ACTION << 4);
481234cf 3980 return nl80211_register_frame(bss, bss->nl_mgmt,
5582a5d1 3981 type, match, match_len);
bd94971e
JB		 3982}
3983
3984
a11241fa 3985static int nl80211_mgmt_subscribe_non_ap(struct i802_bss *bss)
58f6fbe0 3986{
a11241fa
JB		 3987 struct wpa_driver_nl80211_data *drv = bss->drv;
3988
3989 if (nl80211_alloc_mgmt_handle(bss))
3990 return -1;
36488c05
JM		 3991 wpa_printf(MSG_DEBUG, "nl80211: Subscribe to mgmt frames with non-AP "
3992 "handle %p", bss->nl_mgmt);
a11241fa 3993
e8d1168b
JB		 3994 if (drv->nlmode == NL80211_IFTYPE_ADHOC) {
3995 u16 type = (WLAN_FC_TYPE_MGMT << 2) | (WLAN_FC_STYPE_AUTH << 4);
3996
3997 /* register for any AUTH message */
3998 nl80211_register_frame(bss, bss->nl_mgmt, type, NULL, 0);
3999 }
4000
56f5af48
JM		 4001#ifdef CONFIG_INTERWORKING
4002 /* QoS Map Configure */
4003 if (nl80211_register_action_frame(bss, (u8 *) "\x01\x04", 2) < 0)
4004 return -1;
4005#endif /* CONFIG_INTERWORKING */
4fe9fa0d 4006#if defined(CONFIG_P2P) || defined(CONFIG_INTERWORKING)
046b26a2 4007 /* GAS Initial Request */
a11241fa 4008 if (nl80211_register_action_frame(bss, (u8 *) "\x04\x0a", 2) < 0)
046b26a2
JM		 4009 return -1;
4010 /* GAS Initial Response */
a11241fa 4011 if (nl80211_register_action_frame(bss, (u8 *) "\x04\x0b", 2) < 0)
046b26a2 4012 return -1;
18708aad 4013 /* GAS Comeback Request */
a11241fa 4014 if (nl80211_register_action_frame(bss, (u8 *) "\x04\x0c", 2) < 0)
18708aad
JM		 4015 return -1;
4016 /* GAS Comeback Response */
a11241fa 4017 if (nl80211_register_action_frame(bss, (u8 *) "\x04\x0d", 2) < 0)
18708aad 4018 return -1;
4fe9fa0d
JM		 4019#endif /* CONFIG_P2P || CONFIG_INTERWORKING */
4020#ifdef CONFIG_P2P
046b26a2 4021 /* P2P Public Action */
a11241fa 4022 if (nl80211_register_action_frame(bss,
046b26a2
JM		 4023 (u8 *) "\x04\x09\x50\x6f\x9a\x09",
4024 6) < 0)
4025 return -1;
4026 /* P2P Action */
a11241fa 4027 if (nl80211_register_action_frame(bss,
046b26a2
JM		 4028 (u8 *) "\x7f\x50\x6f\x9a\x09",
4029 5) < 0)
4030 return -1;
4031#endif /* CONFIG_P2P */
7d878ca7
JM		 4032#ifdef CONFIG_IEEE80211W
4033 /* SA Query Response */
a11241fa 4034 if (nl80211_register_action_frame(bss, (u8 *) "\x08\x01", 2) < 0)
7d878ca7
JM		 4035 return -1;
4036#endif /* CONFIG_IEEE80211W */
35287637
AN		 4037#ifdef CONFIG_TDLS
4038 if ((drv->capa.flags & WPA_DRIVER_FLAGS_TDLS_SUPPORT)) {
4039 /* TDLS Discovery Response */
aa543c0c 4040 if (nl80211_register_action_frame(bss, (u8 *) "\x04\x0e", 2) <
35287637
AN		 4041 0)
4042 return -1;
4043 }
4044#endif /* CONFIG_TDLS */
046b26a2 4045
7b90c16a 4046 /* FT Action frames */
a11241fa 4047 if (nl80211_register_action_frame(bss, (u8 *) "\x06", 1) < 0)
7b90c16a
JM		 4048 return -1;
4049 else
4050 drv->capa.key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_FT |
4051 WPA_DRIVER_CAPA_KEY_MGMT_FT_PSK;
4052
71269b37 4053 /* WNM - BSS Transition Management Request */
a11241fa
JB		 4054 if (nl80211_register_action_frame(bss, (u8 *) "\x0a\x07", 2) < 0)
4055 return -1;
bd896433
JM		 4056 /* WNM-Sleep Mode Response */
4057 if (nl80211_register_action_frame(bss, (u8 *) "\x0a\x11", 2) < 0)
4058 return -1;
a11241fa 4059
5f65e9f7
JB		 4060 nl80211_mgmt_handle_register_eloop(bss);
4061
a11241fa
JB		 4062 return 0;
4063}
4064
4065
02bb32c3
JB		 4066static int nl80211_register_spurious_class3(struct i802_bss *bss)
4067{
4068 struct wpa_driver_nl80211_data *drv = bss->drv;
4069 struct nl_msg *msg;
4070 int ret = -1;
4071
4072 msg = nlmsg_alloc();
4073 if (!msg)
4074 return -1;
4075
4076 nl80211_cmd(drv, msg, 0, NL80211_CMD_UNEXPECTED_FRAME);
4077
4078 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, bss->ifindex);
4079
481234cf 4080 ret = send_and_recv(drv->global, bss->nl_mgmt, msg, NULL, NULL);
02bb32c3
JB		 4081 msg = NULL;
4082 if (ret) {
4083 wpa_printf(MSG_DEBUG, "nl80211: Register spurious class3 "
4084 "failed: ret=%d (%s)",
4085 ret, strerror(-ret));
4086 goto nla_put_failure;
4087 }
4088 ret = 0;
4089nla_put_failure:
4090 nlmsg_free(msg);
4091 return ret;
4092}
4093
4094
a11241fa
JB		 4095static int nl80211_mgmt_subscribe_ap(struct i802_bss *bss)
4096{
4097 static const int stypes[] = {
4098 WLAN_FC_STYPE_AUTH,
4099 WLAN_FC_STYPE_ASSOC_REQ,
4100 WLAN_FC_STYPE_REASSOC_REQ,
4101 WLAN_FC_STYPE_DISASSOC,
4102 WLAN_FC_STYPE_DEAUTH,
4103 WLAN_FC_STYPE_ACTION,
4104 WLAN_FC_STYPE_PROBE_REQ,
4105/* Beacon doesn't work as mac80211 doesn't currently allow
4106 * it, but it wouldn't really be the right thing anyway as
4107 * it isn't per interface ... maybe just dump the scan
4108 * results periodically for OLBC?
4109 */
4110// WLAN_FC_STYPE_BEACON,
4111 };
4112 unsigned int i;
4113
4114 if (nl80211_alloc_mgmt_handle(bss))
71269b37 4115 return -1;
36488c05
JM		 4116 wpa_printf(MSG_DEBUG, "nl80211: Subscribe to mgmt frames with AP "
4117 "handle %p", bss->nl_mgmt);
71269b37 4118
e7ecab4a 4119 for (i = 0; i < ARRAY_SIZE(stypes); i++) {
481234cf 4120 if (nl80211_register_frame(bss, bss->nl_mgmt,
a11241fa
JB		 4121 (WLAN_FC_TYPE_MGMT << 2) |
4122 (stypes[i] << 4),
4123 NULL, 0) < 0) {
4124 goto out_err;
4125 }
4126 }
4127
02bb32c3
JB		 4128 if (nl80211_register_spurious_class3(bss))
4129 goto out_err;
4130
e32ad281
JB		 4131 if (nl80211_get_wiphy_data_ap(bss) == NULL)
4132 goto out_err;
4133
5f65e9f7 4134 nl80211_mgmt_handle_register_eloop(bss);
58f6fbe0 4135 return 0;
a11241fa
JB		 4136
4137out_err:
a11241fa
JB		 4138 nl_destroy_handles(&bss->nl_mgmt);
4139 return -1;
4140}
4141
4142
a6cc0602
JM		 4143static int nl80211_mgmt_subscribe_ap_dev_sme(struct i802_bss *bss)
4144{
4145 if (nl80211_alloc_mgmt_handle(bss))
4146 return -1;
4147 wpa_printf(MSG_DEBUG, "nl80211: Subscribe to mgmt frames with AP "
4148 "handle %p (device SME)", bss->nl_mgmt);
4149
4150 if (nl80211_register_frame(bss, bss->nl_mgmt,
4151 (WLAN_FC_TYPE_MGMT << 2) |
4152 (WLAN_FC_STYPE_ACTION << 4),
4153 NULL, 0) < 0)
4154 goto out_err;
4155
5f65e9f7 4156 nl80211_mgmt_handle_register_eloop(bss);
a6cc0602
JM		 4157 return 0;
4158
4159out_err:
a6cc0602
JM		 4160 nl_destroy_handles(&bss->nl_mgmt);
4161 return -1;
4162}
4163
4164
36488c05 4165static void nl80211_mgmt_unsubscribe(struct i802_bss *bss, const char *reason)
a11241fa 4166{
481234cf 4167 if (bss->nl_mgmt == NULL)
a11241fa 4168 return;
36488c05
JM		 4169 wpa_printf(MSG_DEBUG, "nl80211: Unsubscribe mgmt frames handle %p "
4170 "(%s)", bss->nl_mgmt, reason);
5f65e9f7 4171 nl80211_destroy_eloop_handle(&bss->nl_mgmt);
e32ad281
JB		 4172
4173 nl80211_put_wiphy_data_ap(bss);
58f6fbe0
JM		 4174}
4175
4176
8401a6b0
JM		 4177static void wpa_driver_nl80211_send_rfkill(void *eloop_ctx, void *timeout_ctx)
4178{
4179 wpa_supplicant_event(timeout_ctx, EVENT_INTERFACE_DISABLED, NULL);
4180}
4181
4182
eb4582f2
AS		 4183static void nl80211_del_p2pdev(struct i802_bss *bss)
4184{
4185 struct wpa_driver_nl80211_data *drv = bss->drv;
4186 struct nl_msg *msg;
4187 int ret;
4188
4189 msg = nlmsg_alloc();
4190 if (!msg)
4191 return;
4192
4193 nl80211_cmd(drv, msg, 0, NL80211_CMD_DEL_INTERFACE);
4194 NLA_PUT_U64(msg, NL80211_ATTR_WDEV, bss->wdev_id);
4195
4196 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
4197 msg = NULL;
4198
4199 wpa_printf(MSG_DEBUG, "nl80211: Delete P2P Device %s (0x%llx): %s",
4200 bss->ifname, (long long unsigned int) bss->wdev_id,
6cb4f11d 4201 strerror(-ret));
eb4582f2
AS		 4202
4203nla_put_failure:
4204 nlmsg_free(msg);
4205}
4206
4207
eb4582f2 4208static int nl80211_set_p2pdev(struct i802_bss *bss, int start)
f632e483
AS		 4209{
4210 struct wpa_driver_nl80211_data *drv = bss->drv;
4211 struct nl_msg *msg;
4212 int ret = -1;
4213
f632e483
AS		 4214 msg = nlmsg_alloc();
4215 if (!msg)
4216 return -1;
4217
eb4582f2
AS		 4218 if (start)
4219 nl80211_cmd(drv, msg, 0, NL80211_CMD_START_P2P_DEVICE);
4220 else
4221 nl80211_cmd(drv, msg, 0, NL80211_CMD_STOP_P2P_DEVICE);
4222
f632e483
AS		 4223 NLA_PUT_U64(msg, NL80211_ATTR_WDEV, bss->wdev_id);
4224
4225 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
4226 msg = NULL;
4227
eb4582f2
AS		 4228 wpa_printf(MSG_DEBUG, "nl80211: %s P2P Device %s (0x%llx): %s",
4229 start ? "Start" : "Stop",
4230 bss->ifname, (long long unsigned int) bss->wdev_id,
6cb4f11d 4231 strerror(-ret));
eb4582f2 4232
f632e483
AS		 4233nla_put_failure:
4234 nlmsg_free(msg);
4235 return ret;
4236}
f632e483
AS		 4237
4238
91724d6f
AS		 4239static int i802_set_iface_flags(struct i802_bss *bss, int up)
4240{
4241 enum nl80211_iftype nlmode;
4242
4243 nlmode = nl80211_get_ifmode(bss);
4244 if (nlmode != NL80211_IFTYPE_P2P_DEVICE) {
4245 return linux_set_iface_flags(bss->drv->global->ioctl_sock,
4246 bss->ifname, up);
4247 }
4248
4249 /* P2P Device has start/stop which is equivalent */
4250 return nl80211_set_p2pdev(bss, up);
4251}
4252
4253
362f781e 4254static int
0d547d5f 4255wpa_driver_nl80211_finish_drv_init(struct wpa_driver_nl80211_data *drv,
49b4b205 4256 const u8 *set_addr, int first)
7524cfb1 4257{
834ee56f 4258 struct i802_bss *bss = drv->first_bss;
8401a6b0 4259 int send_rfkill_event = 0;
0d547d5f 4260 enum nl80211_iftype nlmode;
a2e40bb6
FF		 4261
4262 drv->ifindex = if_nametoindex(bss->ifname);
f632e483
AS		 4263 bss->ifindex = drv->ifindex;
4264 bss->wdev_id = drv->global->if_add_wdevid;
4265 bss->wdev_id_set = drv->global->if_add_wdevid_set;
4266
60b13c20
IP		 4267 bss->if_dynamic = drv->ifindex == drv->global->if_add_ifindex;
4268 bss->if_dynamic = bss->if_dynamic || drv->global->if_add_wdevid_set;
f632e483
AS		 4269 drv->global->if_add_wdevid_set = 0;
4270
4271 if (wpa_driver_nl80211_capa(drv))
4272 return -1;
a87c9d96 4273
5fbcb45d
AS		 4274 wpa_printf(MSG_DEBUG, "nl80211: interface %s in phy %s",
4275 bss->ifname, drv->phyname);
4276
0d547d5f
JM		 4277 if (set_addr &&
4278 (linux_set_iface_flags(drv->global->ioctl_sock, bss->ifname, 0) ||
4279 linux_set_ifhwaddr(drv->global->ioctl_sock, bss->ifname,
4280 set_addr)))
4281 return -1;
4282
49b4b205
JM		 4283 if (first && nl80211_get_ifmode(bss) == NL80211_IFTYPE_AP)
4284 drv->start_mode_ap = 1;
4285
0d547d5f
JM		 4286 if (drv->hostapd)
4287 nlmode = NL80211_IFTYPE_AP;
4288 else if (bss->if_dynamic)
8e12685c 4289 nlmode = nl80211_get_ifmode(bss);
0d547d5f
JM		 4290 else
4291 nlmode = NL80211_IFTYPE_STATION;
f632e483 4292
8e12685c 4293 if (wpa_driver_nl80211_set_mode(bss, nlmode) < 0) {
0d547d5f 4294 wpa_printf(MSG_ERROR, "nl80211: Could not configure driver mode");
8e12685c 4295 return -1;
a87c9d96
JM		 4296 }
4297
f632e483 4298 if (nlmode == NL80211_IFTYPE_P2P_DEVICE) {
eb4582f2 4299 int ret = nl80211_set_p2pdev(bss, 1);
f632e483
AS		 4300 if (ret < 0)
4301 wpa_printf(MSG_ERROR, "nl80211: Could not start P2P device");
597b94f5 4302 nl80211_get_macaddr(bss);
f632e483
AS		 4303 return ret;
4304 }
4305
c81eff1a 4306 if (linux_set_iface_flags(drv->global->ioctl_sock, bss->ifname, 1)) {
8401a6b0
JM		 4307 if (rfkill_is_blocked(drv->rfkill)) {
4308 wpa_printf(MSG_DEBUG, "nl80211: Could not yet enable "
4309 "interface '%s' due to rfkill",
4310 bss->ifname);
a63063b4 4311 drv->if_disabled = 1;
8401a6b0
JM		 4312 send_rfkill_event = 1;
4313 } else {
4314 wpa_printf(MSG_ERROR, "nl80211: Could not set "
4315 "interface '%s' UP", bss->ifname);
4316 return -1;
4317 }
362f781e 4318 }
3f5285e8 4319
0d547d5f
JM		 4320 if (!drv->hostapd)
4321 netlink_send_oper_ifla(drv->global->netlink, drv->ifindex,
4322 1, IF_OPER_DORMANT);
362f781e 4323
c81eff1a 4324 if (linux_get_ifhwaddr(drv->global->ioctl_sock, bss->ifname,
341eebee 4325 bss->addr))
2136f480 4326 return -1;
f2ed8023 4327
8401a6b0
JM		 4328 if (send_rfkill_event) {
4329 eloop_register_timeout(0, 0, wpa_driver_nl80211_send_rfkill,
4330 drv, drv->ctx);
4331 }
4332
362f781e 4333 return 0;
3f5285e8
JM		 4334}
4335
4336
8a27af5c
JM		 4337static int wpa_driver_nl80211_del_beacon(struct wpa_driver_nl80211_data *drv)
4338{
4339 struct nl_msg *msg;
4340
4341 msg = nlmsg_alloc();
4342 if (!msg)
4343 return -ENOMEM;
4344
08e55ebb
JM		 4345 wpa_printf(MSG_DEBUG, "nl80211: Remove beacon (ifindex=%d)",
4346 drv->ifindex);
9fb04070 4347 nl80211_cmd(drv, msg, 0, NL80211_CMD_DEL_BEACON);
8a27af5c
JM		 4348 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
4349
4350 return send_and_recv_msgs(drv, msg, NULL, NULL);
4351 nla_put_failure:
5883168a 4352 nlmsg_free(msg);
8a27af5c
JM		 4353 return -ENOBUFS;
4354}
8a27af5c
JM		 4355
4356
3f5285e8 4357/**
7e5ba1b9 4358 * wpa_driver_nl80211_deinit - Deinitialize nl80211 driver interface
9ebce9c5 4359 * @bss: Pointer to private nl80211 data from wpa_driver_nl80211_init()
3f5285e8
JM		 4360 *
4361 * Shut down driver interface and processing of driver events. Free
4362 * private data buffer if one was allocated in wpa_driver_nl80211_init().
4363 */
9ebce9c5 4364static void wpa_driver_nl80211_deinit(struct i802_bss *bss)
3f5285e8 4365{
a2e40bb6 4366 struct wpa_driver_nl80211_data *drv = bss->drv;
3f5285e8 4367
873d0fcf 4368 bss->in_deinit = 1;
32ab4855
JB		 4369 if (drv->data_tx_status)
4370 eloop_unregister_read_sock(drv->eapol_tx_sock);
d12dab4c
JB		 4371 if (drv->eapol_tx_sock >= 0)
4372 close(drv->eapol_tx_sock);
f10bfc9a 4373
481234cf 4374 if (bss->nl_preq)
5582a5d1 4375 wpa_driver_nl80211_probe_req_report(bss, 0);
e17a2477 4376 if (bss->added_if_into_bridge) {
c81eff1a
BG		 4377 if (linux_br_del_if(drv->global->ioctl_sock, bss->brname,
4378 bss->ifname) < 0)
94627f6c
JM		 4379 wpa_printf(MSG_INFO, "nl80211: Failed to remove "
4380 "interface %s from bridge %s: %s",
e17a2477 4381 bss->ifname, bss->brname, strerror(errno));
94627f6c 4382 }
e17a2477 4383 if (bss->added_bridge) {
c81eff1a 4384 if (linux_br_del(drv->global->ioctl_sock, bss->brname) < 0)
94627f6c
JM		 4385 wpa_printf(MSG_INFO, "nl80211: Failed to remove "
4386 "bridge %s: %s",
e17a2477 4387 bss->brname, strerror(errno));
94627f6c
JM		 4388 }
4389
460456f8 4390 nl80211_remove_monitor_interface(drv);
8a27af5c 4391
b1f625e0 4392 if (is_ap_interface(drv->nlmode))
8a27af5c 4393 wpa_driver_nl80211_del_beacon(drv);
0915d02c 4394
bbaf0837
JM		 4395 if (drv->eapol_sock >= 0) {
4396 eloop_unregister_read_sock(drv->eapol_sock);
4397 close(drv->eapol_sock);
4398 }
4399
4400 if (drv->if_indices != drv->default_if_indices)
4401 os_free(drv->if_indices);
3f5285e8 4402
b3af99d2 4403 if (drv->disabled_11b_rates)
4e5cb1a3
JM		 4404 nl80211_disable_11b_rates(drv, drv->ifindex, 0);
4405
36d84860
BG		 4406 netlink_send_oper_ifla(drv->global->netlink, drv->ifindex, 0,
4407 IF_OPER_UP);
8401a6b0 4408 rfkill_deinit(drv->rfkill);
3f5285e8 4409
bbaf0837
JM		 4410 eloop_cancel_timeout(wpa_driver_nl80211_scan_timeout, drv, drv->ctx);
4411
146fa9b3
JM		 4412 if (!drv->start_iface_up)
4413 (void) i802_set_iface_flags(bss, 0);
8e12685c 4414 if (drv->nlmode != NL80211_IFTYPE_P2P_DEVICE) {
49b4b205
JM		 4415 if (!drv->hostapd || !drv->start_mode_ap)
4416 wpa_driver_nl80211_set_mode(bss,
4417 NL80211_IFTYPE_STATION);
b378c41f 4418 nl80211_mgmt_unsubscribe(bss, "deinit");
8e12685c
AS		 4419 } else {
4420 nl80211_mgmt_unsubscribe(bss, "deinit");
eb4582f2 4421 nl80211_del_p2pdev(bss);
8e12685c 4422 }
1afc986d 4423 nl_cb_put(drv->nl_cb);
3f5285e8 4424
834ee56f 4425 nl80211_destroy_bss(drv->first_bss);
cc7a48d1 4426
3812464c
JM		 4427 os_free(drv->filter_ssids);
4428
536fd62d
JM		 4429 os_free(drv->auth_ie);
4430
dac12351 4431 if (drv->in_interface_list)
f2ed8023
JM		 4432 dl_list_del(&drv->list);
4433
8cd6b7bc
JB		 4434 os_free(drv->extended_capa);
4435 os_free(drv->extended_capa_mask);
834ee56f 4436 os_free(drv->first_bss);
3f5285e8
JM		 4437 os_free(drv);
4438}
4439
4440
4441/**
4442 * wpa_driver_nl80211_scan_timeout - Scan timeout to report scan completion
ad1e68e6 4443 * @eloop_ctx: Driver private data
3f5285e8
JM		 4444 * @timeout_ctx: ctx argument given to wpa_driver_nl80211_init()
4445 *
4446 * This function can be used as registered timeout when starting a scan to
4447 * generate a scan completed event if the driver does not report this.
4448 */
4449static void wpa_driver_nl80211_scan_timeout(void *eloop_ctx, void *timeout_ctx)
4450{
ad1e68e6 4451 struct wpa_driver_nl80211_data *drv = eloop_ctx;
b1f625e0 4452 if (drv->ap_scan_as_station != NL80211_IFTYPE_UNSPECIFIED) {
834ee56f 4453 wpa_driver_nl80211_set_mode(drv->first_bss,
b1f625e0
EP		 4454 drv->ap_scan_as_station);
4455 drv->ap_scan_as_station = NL80211_IFTYPE_UNSPECIFIED;
ad1e68e6 4456 }
3f5285e8
JM		 4457 wpa_printf(MSG_DEBUG, "Scan timeout - try to get results");
4458 wpa_supplicant_event(timeout_ctx, EVENT_SCAN_RESULTS, NULL);
4459}
4460
4461
95ac3bf4
JM		 4462static struct nl_msg *
4463nl80211_scan_common(struct wpa_driver_nl80211_data *drv, u8 cmd,
d3aaef80 4464 struct wpa_driver_scan_params *params, u64 *wdev_id)
3f5285e8 4465{
95ac3bf4 4466 struct nl_msg *msg;
6a1063e0 4467 size_t i;
3f5285e8 4468
0e75527f 4469 msg = nlmsg_alloc();
f0494d0f 4470 if (!msg)
95ac3bf4 4471 return NULL;
3812464c 4472
95ac3bf4 4473 nl80211_cmd(drv, msg, 0, cmd);
0e75527f 4474
d3aaef80
DS		 4475 if (!wdev_id)
4476 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
4477 else
4478 NLA_PUT_U64(msg, NL80211_ATTR_WDEV, *wdev_id);
3f5285e8 4479
f0494d0f 4480 if (params->num_ssids) {
8970bae8
JB		 4481 struct nlattr *ssids;
4482
4483 ssids = nla_nest_start(msg, NL80211_ATTR_SCAN_SSIDS);
f0494d0f 4484 if (ssids == NULL)
95ac3bf4 4485 goto fail;
f0494d0f
JM		 4486 for (i = 0; i < params->num_ssids; i++) {
4487 wpa_hexdump_ascii(MSG_MSGDUMP, "nl80211: Scan SSID",
4488 params->ssids[i].ssid,
4489 params->ssids[i].ssid_len);
8970bae8
JB		 4490 if (nla_put(msg, i + 1, params->ssids[i].ssid_len,
4491 params->ssids[i].ssid) < 0)
95ac3bf4 4492 goto fail;
f0494d0f 4493 }
8970bae8 4494 nla_nest_end(msg, ssids);
3f5285e8
JM		 4495 }
4496
d173df52 4497 if (params->extra_ies) {
3b1c7bfd
JM		 4498 wpa_hexdump(MSG_MSGDUMP, "nl80211: Scan extra IEs",
4499 params->extra_ies, params->extra_ies_len);
95ac3bf4
JM		 4500 if (nla_put(msg, NL80211_ATTR_IE, params->extra_ies_len,
4501 params->extra_ies) < 0)
4502 goto fail;
d173df52
JM		 4503 }
4504
d3a98225 4505 if (params->freqs) {
8970bae8
JB		 4506 struct nlattr *freqs;
4507 freqs = nla_nest_start(msg, NL80211_ATTR_SCAN_FREQUENCIES);
f0494d0f 4508 if (freqs == NULL)
95ac3bf4 4509 goto fail;
9fad706c
JM		 4510 for (i = 0; params->freqs[i]; i++) {
4511 wpa_printf(MSG_MSGDUMP, "nl80211: Scan frequency %u "
4512 "MHz", params->freqs[i]);
8970bae8 4513 if (nla_put_u32(msg, i + 1, params->freqs[i]) < 0)
95ac3bf4 4514 goto fail;
9fad706c 4515 }
8970bae8 4516 nla_nest_end(msg, freqs);
d3a98225
JM		 4517 }
4518
95ac3bf4
JM		 4519 os_free(drv->filter_ssids);
4520 drv->filter_ssids = params->filter_ssids;
4521 params->filter_ssids = NULL;
4522 drv->num_filter_ssids = params->num_filter_ssids;
4523
4524 return msg;
4525
4526fail:
d3aaef80 4527nla_put_failure:
95ac3bf4
JM		 4528 nlmsg_free(msg);
4529 return NULL;
4530}
4531
4532
4533/**
4534 * wpa_driver_nl80211_scan - Request the driver to initiate scan
9ebce9c5 4535 * @bss: Pointer to private driver data from wpa_driver_nl80211_init()
95ac3bf4
JM		 4536 * @params: Scan parameters
4537 * Returns: 0 on success, -1 on failure
4538 */
9ebce9c5 4539static int wpa_driver_nl80211_scan(struct i802_bss *bss,
95ac3bf4
JM		 4540 struct wpa_driver_scan_params *params)
4541{
95ac3bf4
JM		 4542 struct wpa_driver_nl80211_data *drv = bss->drv;
4543 int ret = -1, timeout;
8970bae8 4544 struct nl_msg *msg = NULL;
95ac3bf4 4545
565110cd 4546 wpa_dbg(drv->ctx, MSG_DEBUG, "nl80211: scan request");
95ac3bf4
JM		 4547 drv->scan_for_auth = 0;
4548
d3aaef80
DS		 4549 msg = nl80211_scan_common(drv, NL80211_CMD_TRIGGER_SCAN, params,
4550 bss->wdev_id_set ? &bss->wdev_id : NULL);
95ac3bf4
JM		 4551 if (!msg)
4552 return -1;
4553
47185fc7 4554 if (params->p2p_probe) {
8970bae8
JB		 4555 struct nlattr *rates;
4556
8a6a1e1b
JM		 4557 wpa_printf(MSG_DEBUG, "nl80211: P2P probe - mask SuppRates");
4558
8970bae8 4559 rates = nla_nest_start(msg, NL80211_ATTR_SCAN_SUPP_RATES);
f0494d0f
JM		 4560 if (rates == NULL)
4561 goto nla_put_failure;
4562
47185fc7
RM		 4563 /*
4564 * Remove 2.4 GHz rates 1, 2, 5.5, 11 Mbps from supported rates
4565 * by masking out everything else apart from the OFDM rates 6,
4566 * 9, 12, 18, 24, 36, 48, 54 Mbps from non-MCS rates. All 5 GHz
4567 * rates are left enabled.
4568 */
8970bae8 4569 NLA_PUT(msg, NL80211_BAND_2GHZ, 8,
47185fc7 4570 "\x0c\x12\x18\x24\x30\x48\x60\x6c");
8970bae8 4571 nla_nest_end(msg, rates);
970fa12e
RM		 4572
4573 NLA_PUT_FLAG(msg, NL80211_ATTR_TX_NO_CCK_RATE);
47185fc7
RM		 4574 }
4575
0e75527f
JM		 4576 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
4577 msg = NULL;
4578 if (ret) {
4579 wpa_printf(MSG_DEBUG, "nl80211: Scan trigger failed: ret=%d "
4580 "(%s)", ret, strerror(-ret));
04eff7d5 4581 if (drv->hostapd && is_ap_interface(drv->nlmode)) {
ad1e68e6
JM		 4582 /*
4583 * mac80211 does not allow scan requests in AP mode, so
4584 * try to do this in station mode.
4585 */
b1f625e0
EP		 4586 if (wpa_driver_nl80211_set_mode(
4587 bss, NL80211_IFTYPE_STATION))
ad1e68e6
JM		 4588 goto nla_put_failure;
4589
085b29f1 4590 if (wpa_driver_nl80211_scan(bss, params)) {
b1f625e0 4591 wpa_driver_nl80211_set_mode(bss, drv->nlmode);
ad1e68e6
JM		 4592 goto nla_put_failure;
4593 }
4594
4595 /* Restore AP mode when processing scan results */
b1f625e0 4596 drv->ap_scan_as_station = drv->nlmode;
ad1e68e6
JM		 4597 ret = 0;
4598 } else
4599 goto nla_put_failure;
3f5285e8
JM		 4600 }
4601
a771c07d 4602 drv->scan_state = SCAN_REQUESTED;
3f5285e8
JM		 4603 /* Not all drivers generate "scan completed" wireless event, so try to
4604 * read results after a timeout. */
0e75527f 4605 timeout = 10;
3f5285e8
JM		 4606 if (drv->scan_complete_events) {
4607 /*
d173df52
JM		 4608 * The driver seems to deliver events to notify when scan is
4609 * complete, so use longer timeout to avoid race conditions
4610 * with scanning and following association request.
3f5285e8
JM		 4611 */
4612 timeout = 30;
4613 }
4614 wpa_printf(MSG_DEBUG, "Scan requested (ret=%d) - scan timeout %d "
4615 "seconds", ret, timeout);
4616 eloop_cancel_timeout(wpa_driver_nl80211_scan_timeout, drv, drv->ctx);
0e75527f
JM		 4617 eloop_register_timeout(timeout, 0, wpa_driver_nl80211_scan_timeout,
4618 drv, drv->ctx);
3f5285e8 4619
0e75527f 4620nla_put_failure:
0e75527f 4621 nlmsg_free(msg);
3f5285e8
JM		 4622 return ret;
4623}
4624
4625
d21c63b9
LC		 4626/**
4627 * wpa_driver_nl80211_sched_scan - Initiate a scheduled scan
4628 * @priv: Pointer to private driver data from wpa_driver_nl80211_init()
4629 * @params: Scan parameters
4630 * @interval: Interval between scan cycles in milliseconds
4631 * Returns: 0 on success, -1 on failure or if not supported
4632 */
4633static int wpa_driver_nl80211_sched_scan(void *priv,
4634 struct wpa_driver_scan_params *params,
4635 u32 interval)
4636{
4637 struct i802_bss *bss = priv;
4638 struct wpa_driver_nl80211_data *drv = bss->drv;
6afbc3d6 4639 int ret = -1;
95ac3bf4 4640 struct nl_msg *msg;
d21c63b9
LC		 4641 size_t i;
4642
565110cd
JM		 4643 wpa_dbg(drv->ctx, MSG_DEBUG, "nl80211: sched_scan request");
4644
216eede8
DS		 4645#ifdef ANDROID
4646 if (!drv->capa.sched_scan_supported)
4647 return android_pno_start(bss, params);
4648#endif /* ANDROID */
4649
d3aaef80
DS		 4650 msg = nl80211_scan_common(drv, NL80211_CMD_START_SCHED_SCAN, params,
4651 bss->wdev_id_set ? &bss->wdev_id : NULL);
6afbc3d6
JM		 4652 if (!msg)
4653 goto nla_put_failure;
d21c63b9 4654
d21c63b9
LC		 4655 NLA_PUT_U32(msg, NL80211_ATTR_SCHED_SCAN_INTERVAL, interval);
4656
bf8d6d24
TP		 4657 if ((drv->num_filter_ssids &&
4658 (int) drv->num_filter_ssids <= drv->capa.max_match_sets) ||
4659 params->filter_rssi) {
8970bae8
JB		 4660 struct nlattr *match_sets;
4661 match_sets = nla_nest_start(msg, NL80211_ATTR_SCHED_SCAN_MATCH);
6afbc3d6
JM		 4662 if (match_sets == NULL)
4663 goto nla_put_failure;
bd525934
LC		 4664
4665 for (i = 0; i < drv->num_filter_ssids; i++) {
8970bae8 4666 struct nlattr *match_set_ssid;
bd525934
LC		 4667 wpa_hexdump_ascii(MSG_MSGDUMP,
4668 "nl80211: Sched scan filter SSID",
4669 drv->filter_ssids[i].ssid,
4670 drv->filter_ssids[i].ssid_len);
4671
8970bae8 4672 match_set_ssid = nla_nest_start(msg, i + 1);
6afbc3d6
JM		 4673 if (match_set_ssid == NULL)
4674 goto nla_put_failure;
8970bae8 4675 NLA_PUT(msg, NL80211_ATTR_SCHED_SCAN_MATCH_SSID,
bd525934
LC		 4676 drv->filter_ssids[i].ssid_len,
4677 drv->filter_ssids[i].ssid);
4678
adc96dc2 4679 nla_nest_end(msg, match_set_ssid);
bd525934
LC		 4680 }
4681
bf8d6d24 4682 if (params->filter_rssi) {
8970bae8
JB		 4683 struct nlattr *match_set_rssi;
4684 match_set_rssi = nla_nest_start(msg, 0);
6afbc3d6
JM		 4685 if (match_set_rssi == NULL)
4686 goto nla_put_failure;
8970bae8 4687 NLA_PUT_U32(msg, NL80211_SCHED_SCAN_MATCH_ATTR_RSSI,
bf8d6d24
TP		 4688 params->filter_rssi);
4689 wpa_printf(MSG_MSGDUMP,
4690 "nl80211: Sched scan RSSI filter %d dBm",
4691 params->filter_rssi);
8970bae8 4692 nla_nest_end(msg, match_set_rssi);
bf8d6d24
TP		 4693 }
4694
8970bae8 4695 nla_nest_end(msg, match_sets);
bd525934
LC		 4696 }
4697
d21c63b9
LC		 4698 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
4699
4700 /* TODO: if we get an error here, we should fall back to normal scan */
4701
4702 msg = NULL;
4703 if (ret) {
4704 wpa_printf(MSG_DEBUG, "nl80211: Sched scan start failed: "
4705 "ret=%d (%s)", ret, strerror(-ret));
4706 goto nla_put_failure;
4707 }
4708
4709 wpa_printf(MSG_DEBUG, "nl80211: Sched scan requested (ret=%d) - "
4710 "scan interval %d msec", ret, interval);
4711
4712nla_put_failure:
d21c63b9 4713 nlmsg_free(msg);
d21c63b9
LC		 4714 return ret;
4715}
4716
4717
4718/**
4719 * wpa_driver_nl80211_stop_sched_scan - Stop a scheduled scan
4720 * @priv: Pointer to private driver data from wpa_driver_nl80211_init()
4721 * Returns: 0 on success, -1 on failure or if not supported
4722 */
4723static int wpa_driver_nl80211_stop_sched_scan(void *priv)
4724{
4725 struct i802_bss *bss = priv;
4726 struct wpa_driver_nl80211_data *drv = bss->drv;
4727 int ret = 0;
4728 struct nl_msg *msg;
4729
216eede8
DS		 4730#ifdef ANDROID
4731 if (!drv->capa.sched_scan_supported)
4732 return android_pno_stop(bss);
4733#endif /* ANDROID */
4734
d21c63b9
LC		 4735 msg = nlmsg_alloc();
4736 if (!msg)
4737 return -1;
4738
9fb04070 4739 nl80211_cmd(drv, msg, 0, NL80211_CMD_STOP_SCHED_SCAN);
d21c63b9
LC		 4740
4741 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
4742
4743 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
4744 msg = NULL;
4745 if (ret) {
4746 wpa_printf(MSG_DEBUG, "nl80211: Sched scan stop failed: "
4747 "ret=%d (%s)", ret, strerror(-ret));
4748 goto nla_put_failure;
4749 }
4750
4751 wpa_printf(MSG_DEBUG, "nl80211: Sched scan stop sent (ret=%d)", ret);
4752
4753nla_put_failure:
4754 nlmsg_free(msg);
4755 return ret;
4756}
4757
4758
3812464c
JM		 4759static const u8 * nl80211_get_ie(const u8 *ies, size_t ies_len, u8 ie)
4760{
4761 const u8 *end, *pos;
4762
4763 if (ies == NULL)
4764 return NULL;
4765
4766 pos = ies;
4767 end = ies + ies_len;
4768
4769 while (pos + 1 < end) {
4770 if (pos + 2 + pos[1] > end)
4771 break;
4772 if (pos[0] == ie)
4773 return pos;
4774 pos += 2 + pos[1];
4775 }
4776
4777 return NULL;
4778}
4779
4780
4781static int nl80211_scan_filtered(struct wpa_driver_nl80211_data *drv,
4782 const u8 *ie, size_t ie_len)
4783{
4784 const u8 *ssid;
4785 size_t i;
4786
4787 if (drv->filter_ssids == NULL)
4788 return 0;
4789
4790 ssid = nl80211_get_ie(ie, ie_len, WLAN_EID_SSID);
4791 if (ssid == NULL)
4792 return 1;
4793
4794 for (i = 0; i < drv->num_filter_ssids; i++) {
4795 if (ssid[1] == drv->filter_ssids[i].ssid_len &&
4796 os_memcmp(ssid + 2, drv->filter_ssids[i].ssid, ssid[1]) ==
4797 0)
4798 return 0;
4799 }
4800
4801 return 1;
4802}
4803
4804
b3db1e1c 4805static int bss_info_handler(struct nl_msg *msg, void *arg)
3f5285e8 4806{
b3db1e1c
JM		 4807 struct nlattr *tb[NL80211_ATTR_MAX + 1];
4808 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
4809 struct nlattr *bss[NL80211_BSS_MAX + 1];
4810 static struct nla_policy bss_policy[NL80211_BSS_MAX + 1] = {
4811 [NL80211_BSS_BSSID] = { .type = NLA_UNSPEC },
4812 [NL80211_BSS_FREQUENCY] = { .type = NLA_U32 },
4813 [NL80211_BSS_TSF] = { .type = NLA_U64 },
4814 [NL80211_BSS_BEACON_INTERVAL] = { .type = NLA_U16 },
4815 [NL80211_BSS_CAPABILITY] = { .type = NLA_U16 },
4816 [NL80211_BSS_INFORMATION_ELEMENTS] = { .type = NLA_UNSPEC },
4817 [NL80211_BSS_SIGNAL_MBM] = { .type = NLA_U32 },
4818 [NL80211_BSS_SIGNAL_UNSPEC] = { .type = NLA_U8 },
e6b8efeb 4819 [NL80211_BSS_STATUS] = { .type = NLA_U32 },
b3ad11bb 4820 [NL80211_BSS_SEEN_MS_AGO] = { .type = NLA_U32 },
8c090654 4821 [NL80211_BSS_BEACON_IES] = { .type = NLA_UNSPEC },
b3db1e1c 4822 };
3812464c
JM		 4823 struct nl80211_bss_info_arg *_arg = arg;
4824 struct wpa_scan_results *res = _arg->res;
3f5285e8
JM		 4825 struct wpa_scan_res **tmp;
4826 struct wpa_scan_res *r;
8c090654
JM		 4827 const u8 *ie, *beacon_ie;
4828 size_t ie_len, beacon_ie_len;
4829 u8 *pos;
46957a9b 4830 size_t i;
3f5285e8 4831
b3db1e1c
JM		 4832 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
4833 genlmsg_attrlen(gnlh, 0), NULL);
4834 if (!tb[NL80211_ATTR_BSS])
4835 return NL_SKIP;
4836 if (nla_parse_nested(bss, NL80211_BSS_MAX, tb[NL80211_ATTR_BSS],
4837 bss_policy))
4838 return NL_SKIP;
f5a8d422
JM		 4839 if (bss[NL80211_BSS_STATUS]) {
4840 enum nl80211_bss_status status;
4841 status = nla_get_u32(bss[NL80211_BSS_STATUS]);
4842 if (status == NL80211_BSS_STATUS_ASSOCIATED &&
4843 bss[NL80211_BSS_FREQUENCY]) {
4844 _arg->assoc_freq =
4845 nla_get_u32(bss[NL80211_BSS_FREQUENCY]);
4846 wpa_printf(MSG_DEBUG, "nl80211: Associated on %u MHz",
4847 _arg->assoc_freq);
4848 }
20f5a4c2
JM		 4849 if (status == NL80211_BSS_STATUS_ASSOCIATED &&
4850 bss[NL80211_BSS_BSSID]) {
4851 os_memcpy(_arg->assoc_bssid,
4852 nla_data(bss[NL80211_BSS_BSSID]), ETH_ALEN);
4853 wpa_printf(MSG_DEBUG, "nl80211: Associated with "
4854 MACSTR, MAC2STR(_arg->assoc_bssid));
4855 }
f5a8d422
JM		 4856 }
4857 if (!res)
4858 return NL_SKIP;
b3db1e1c
JM		 4859 if (bss[NL80211_BSS_INFORMATION_ELEMENTS]) {
4860 ie = nla_data(bss[NL80211_BSS_INFORMATION_ELEMENTS]);
4861 ie_len = nla_len(bss[NL80211_BSS_INFORMATION_ELEMENTS]);
4862 } else {
4863 ie = NULL;
4864 ie_len = 0;
4865 }
8c090654
JM		 4866 if (bss[NL80211_BSS_BEACON_IES]) {
4867 beacon_ie = nla_data(bss[NL80211_BSS_BEACON_IES]);
4868 beacon_ie_len = nla_len(bss[NL80211_BSS_BEACON_IES]);
4869 } else {
4870 beacon_ie = NULL;
4871 beacon_ie_len = 0;
4872 }
3f5285e8 4873
3812464c
JM		 4874 if (nl80211_scan_filtered(_arg->drv, ie ? ie : beacon_ie,
4875 ie ? ie_len : beacon_ie_len))
4876 return NL_SKIP;
4877
8c090654 4878 r = os_zalloc(sizeof(*r) + ie_len + beacon_ie_len);
3f5285e8 4879 if (r == NULL)
b3db1e1c
JM		 4880 return NL_SKIP;
4881 if (bss[NL80211_BSS_BSSID])
4882 os_memcpy(r->bssid, nla_data(bss[NL80211_BSS_BSSID]),
4883 ETH_ALEN);
4884 if (bss[NL80211_BSS_FREQUENCY])
4885 r->freq = nla_get_u32(bss[NL80211_BSS_FREQUENCY]);
4886 if (bss[NL80211_BSS_BEACON_INTERVAL])
4887 r->beacon_int = nla_get_u16(bss[NL80211_BSS_BEACON_INTERVAL]);
4888 if (bss[NL80211_BSS_CAPABILITY])
4889 r->caps = nla_get_u16(bss[NL80211_BSS_CAPABILITY]);
7c2849d2
JM		 4890 r->flags |= WPA_SCAN_NOISE_INVALID;
4891 if (bss[NL80211_BSS_SIGNAL_MBM]) {
b3db1e1c 4892 r->level = nla_get_u32(bss[NL80211_BSS_SIGNAL_MBM]);
7c2849d2
JM		 4893 r->level /= 100; /* mBm to dBm */
4894 r->flags |= WPA_SCAN_LEVEL_DBM | WPA_SCAN_QUAL_INVALID;
4895 } else if (bss[NL80211_BSS_SIGNAL_UNSPEC]) {
4896 r->level = nla_get_u8(bss[NL80211_BSS_SIGNAL_UNSPEC]);
98ac6763 4897 r->flags |= WPA_SCAN_QUAL_INVALID;
7c2849d2
JM		 4898 } else
4899 r->flags |= WPA_SCAN_LEVEL_INVALID | WPA_SCAN_QUAL_INVALID;
b3db1e1c
JM		 4900 if (bss[NL80211_BSS_TSF])
4901 r->tsf = nla_get_u64(bss[NL80211_BSS_TSF]);
b3ad11bb
JM		 4902 if (bss[NL80211_BSS_SEEN_MS_AGO])
4903 r->age = nla_get_u32(bss[NL80211_BSS_SEEN_MS_AGO]);
b3db1e1c 4904 r->ie_len = ie_len;
8c090654
JM		 4905 pos = (u8 *) (r + 1);
4906 if (ie) {
4907 os_memcpy(pos, ie, ie_len);
4908 pos += ie_len;
4909 }
4910 r->beacon_ie_len = beacon_ie_len;
4911 if (beacon_ie)
4912 os_memcpy(pos, beacon_ie, beacon_ie_len);
3f5285e8 4913
e6b8efeb
JM		 4914 if (bss[NL80211_BSS_STATUS]) {
4915 enum nl80211_bss_status status;
4916 status = nla_get_u32(bss[NL80211_BSS_STATUS]);
4917 switch (status) {
4918 case NL80211_BSS_STATUS_AUTHENTICATED:
4919 r->flags |= WPA_SCAN_AUTHENTICATED;
4920 break;
4921 case NL80211_BSS_STATUS_ASSOCIATED:
4922 r->flags |= WPA_SCAN_ASSOCIATED;
4923 break;
4924 default:
4925 break;
4926 }
4927 }
4928
46957a9b
JM		 4929 /*
4930 * cfg80211 maintains separate BSS table entries for APs if the same
4931 * BSSID,SSID pair is seen on multiple channels. wpa_supplicant does
4932 * not use frequency as a separate key in the BSS table, so filter out
4933 * duplicated entries. Prefer associated BSS entry in such a case in
4934 * order to get the correct frequency into the BSS table.
4935 */
4936 for (i = 0; i < res->num; i++) {
4937 const u8 *s1, *s2;
4938 if (os_memcmp(res->res[i]->bssid, r->bssid, ETH_ALEN) != 0)
4939 continue;
4940
4941 s1 = nl80211_get_ie((u8 *) (res->res[i] + 1),
4942 res->res[i]->ie_len, WLAN_EID_SSID);
4943 s2 = nl80211_get_ie((u8 *) (r + 1), r->ie_len, WLAN_EID_SSID);
4944 if (s1 == NULL || s2 == NULL || s1[1] != s2[1] ||
4945 os_memcmp(s1, s2, 2 + s1[1]) != 0)
4946 continue;
4947
4948 /* Same BSSID,SSID was already included in scan results */
4949 wpa_printf(MSG_DEBUG, "nl80211: Remove duplicated scan result "
4950 "for " MACSTR, MAC2STR(r->bssid));
4951
4952 if ((r->flags & WPA_SCAN_ASSOCIATED) &&
4953 !(res->res[i]->flags & WPA_SCAN_ASSOCIATED)) {
4954 os_free(res->res[i]);
4955 res->res[i] = r;
4956 } else
4957 os_free(r);
4958 return NL_SKIP;
4959 }
4960
067ffa26
JM		 4961 tmp = os_realloc_array(res->res, res->num + 1,
4962 sizeof(struct wpa_scan_res *));
3f5285e8
JM		 4963 if (tmp == NULL) {
4964 os_free(r);
b3db1e1c 4965 return NL_SKIP;
3f5285e8
JM		 4966 }
4967 tmp[res->num++] = r;
4968 res->res = tmp;
b3db1e1c
JM		 4969
4970 return NL_SKIP;
3f5285e8 4971}
b3db1e1c 4972
3f5285e8 4973
d72aad94
JM		 4974static void clear_state_mismatch(struct wpa_driver_nl80211_data *drv,
4975 const u8 *addr)
4976{
4977 if (drv->capa.flags & WPA_DRIVER_FLAGS_SME) {
4978 wpa_printf(MSG_DEBUG, "nl80211: Clear possible state "
582507be 4979 "mismatch (" MACSTR ")", MAC2STR(addr));
d72aad94
JM		 4980 wpa_driver_nl80211_mlme(drv, addr,
4981 NL80211_CMD_DEAUTHENTICATE,
77339912 4982 WLAN_REASON_PREV_AUTH_NOT_VALID, 1);
d72aad94
JM		 4983 }
4984}
4985
4986
e6b8efeb
JM		 4987static void wpa_driver_nl80211_check_bss_status(
4988 struct wpa_driver_nl80211_data *drv, struct wpa_scan_results *res)
4989{
4990 size_t i;
4991
4992 for (i = 0; i < res->num; i++) {
4993 struct wpa_scan_res *r = res->res[i];
4994 if (r->flags & WPA_SCAN_AUTHENTICATED) {
4995 wpa_printf(MSG_DEBUG, "nl80211: Scan results "
4996 "indicates BSS status with " MACSTR
4997 " as authenticated",
4998 MAC2STR(r->bssid));
b1f625e0 4999 if (is_sta_interface(drv->nlmode) &&
e6b8efeb
JM		 5000 os_memcmp(r->bssid, drv->bssid, ETH_ALEN) != 0 &&
5001 os_memcmp(r->bssid, drv->auth_bssid, ETH_ALEN) !=
5002 0) {
5003 wpa_printf(MSG_DEBUG, "nl80211: Unknown BSSID"
5004 " in local state (auth=" MACSTR
5005 " assoc=" MACSTR ")",
5006 MAC2STR(drv->auth_bssid),
5007 MAC2STR(drv->bssid));
582507be 5008 clear_state_mismatch(drv, r->bssid);
e6b8efeb
JM		 5009 }
5010 }
5011
5012 if (r->flags & WPA_SCAN_ASSOCIATED) {
5013 wpa_printf(MSG_DEBUG, "nl80211: Scan results "
5014 "indicate BSS status with " MACSTR
5015 " as associated",
5016 MAC2STR(r->bssid));
b1f625e0 5017 if (is_sta_interface(drv->nlmode) &&
e6b8efeb
JM		 5018 !drv->associated) {
5019 wpa_printf(MSG_DEBUG, "nl80211: Local state "
5020 "(not associated) does not match "
5021 "with BSS state");
d72aad94 5022 clear_state_mismatch(drv, r->bssid);
b1f625e0 5023 } else if (is_sta_interface(drv->nlmode) &&
e6b8efeb
JM		 5024 os_memcmp(drv->bssid, r->bssid, ETH_ALEN) !=
5025 0) {
5026 wpa_printf(MSG_DEBUG, "nl80211: Local state "
5027 "(associated with " MACSTR ") does "
5028 "not match with BSS state",
d72aad94
JM		 5029 MAC2STR(drv->bssid));
5030 clear_state_mismatch(drv, r->bssid);
5031 clear_state_mismatch(drv, drv->bssid);
e6b8efeb
JM		 5032 }
5033 }
5034 }
5035}
5036
5037
7e5ba1b9 5038static struct wpa_scan_results *
8856462d 5039nl80211_get_scan_results(struct wpa_driver_nl80211_data *drv)
3f5285e8 5040{
b3db1e1c 5041 struct nl_msg *msg;
3f5285e8 5042 struct wpa_scan_results *res;
b3db1e1c 5043 int ret;
3812464c 5044 struct nl80211_bss_info_arg arg;
3f5285e8
JM		 5045
5046 res = os_zalloc(sizeof(*res));
b3db1e1c 5047 if (res == NULL)
8e2c104f 5048 return NULL;
b3db1e1c
JM		 5049 msg = nlmsg_alloc();
5050 if (!msg)
5051 goto nla_put_failure;
3f5285e8 5052
9fb04070 5053 nl80211_cmd(drv, msg, NLM_F_DUMP, NL80211_CMD_GET_SCAN);
834ee56f 5054 if (nl80211_set_iface_id(msg, drv->first_bss) < 0)
fdc554b8 5055 goto nla_put_failure;
3f5285e8 5056
3812464c
JM		 5057 arg.drv = drv;
5058 arg.res = res;
5059 ret = send_and_recv_msgs(drv, msg, bss_info_handler, &arg);
b3db1e1c
JM		 5060 msg = NULL;
5061 if (ret == 0) {
577db0ae
GM		 5062 wpa_printf(MSG_DEBUG, "nl80211: Received scan results (%lu "
5063 "BSSes)", (unsigned long) res->num);
5064 nl80211_get_noise_for_scan_results(drv, res);
b3db1e1c 5065 return res;
3f5285e8 5066 }
b3db1e1c
JM		 5067 wpa_printf(MSG_DEBUG, "nl80211: Scan result fetch failed: ret=%d "
5068 "(%s)", ret, strerror(-ret));
5069nla_put_failure:
5070 nlmsg_free(msg);
5071 wpa_scan_results_free(res);
5072 return NULL;
3f5285e8
JM		 5073}
5074
5075
8856462d
JM		 5076/**
5077 * wpa_driver_nl80211_get_scan_results - Fetch the latest scan results
5078 * @priv: Pointer to private wext data from wpa_driver_nl80211_init()
5079 * Returns: Scan results on success, -1 on failure
5080 */
5081static struct wpa_scan_results *
5082wpa_driver_nl80211_get_scan_results(void *priv)
5083{
a2e40bb6
FF		 5084 struct i802_bss *bss = priv;
5085 struct wpa_driver_nl80211_data *drv = bss->drv;
8856462d
JM		 5086 struct wpa_scan_results *res;
5087
5088 res = nl80211_get_scan_results(drv);
5089 if (res)
5090 wpa_driver_nl80211_check_bss_status(drv, res);
5091 return res;
5092}
5093
5094
5095static void nl80211_dump_scan(struct wpa_driver_nl80211_data *drv)
5096{
5097 struct wpa_scan_results *res;
5098 size_t i;
5099
5100 res = nl80211_get_scan_results(drv);
5101 if (res == NULL) {
5102 wpa_printf(MSG_DEBUG, "nl80211: Failed to get scan results");
5103 return;
5104 }
5105
5106 wpa_printf(MSG_DEBUG, "nl80211: Scan result dump");
5107 for (i = 0; i < res->num; i++) {
5108 struct wpa_scan_res *r = res->res[i];
5109 wpa_printf(MSG_DEBUG, "nl80211: %d/%d " MACSTR "%s%s",
5110 (int) i, (int) res->num, MAC2STR(r->bssid),
5111 r->flags & WPA_SCAN_AUTHENTICATED ? " [auth]" : "",
5112 r->flags & WPA_SCAN_ASSOCIATED ? " [assoc]" : "");
5113 }
5114
5115 wpa_scan_results_free(res);
5116}
5117
5118
9ebce9c5 5119static int wpa_driver_nl80211_set_key(const char *ifname, struct i802_bss *bss,
71934751
JM		 5120 enum wpa_alg alg, const u8 *addr,
5121 int key_idx, int set_tx,
642187d6
JM		 5122 const u8 *seq, size_t seq_len,
5123 const u8 *key, size_t key_len)
3f5285e8 5124{
a2e40bb6 5125 struct wpa_driver_nl80211_data *drv = bss->drv;
e472e1b4 5126 int ifindex;
3f5285e8 5127 struct nl_msg *msg;
1ad1cdc2 5128 int ret;
dc01de8a 5129 int tdls = 0;
3f5285e8 5130
e472e1b4
AS		 5131 /* Ignore for P2P Device */
5132 if (drv->nlmode == NL80211_IFTYPE_P2P_DEVICE)
5133 return 0;
5134
5135 ifindex = if_nametoindex(ifname);
8393e1a0 5136 wpa_printf(MSG_DEBUG, "%s: ifindex=%d (%s) alg=%d addr=%p key_idx=%d "
1ad1cdc2 5137 "set_tx=%d seq_len=%lu key_len=%lu",
8393e1a0 5138 __func__, ifindex, ifname, alg, addr, key_idx, set_tx,
3f5285e8 5139 (unsigned long) seq_len, (unsigned long) key_len);
8c66e185 5140#ifdef CONFIG_TDLS
dc01de8a 5141 if (key_idx == -1) {
8c66e185 5142 key_idx = 0;
dc01de8a
JM		 5143 tdls = 1;
5144 }
8c66e185 5145#endif /* CONFIG_TDLS */
3f5285e8
JM		 5146
5147 msg = nlmsg_alloc();
1ad1cdc2
JM		 5148 if (!msg)
5149 return -ENOMEM;
3f5285e8
JM		 5150
5151 if (alg == WPA_ALG_NONE) {
9fb04070 5152 nl80211_cmd(drv, msg, 0, NL80211_CMD_DEL_KEY);
3f5285e8 5153 } else {
9fb04070 5154 nl80211_cmd(drv, msg, 0, NL80211_CMD_NEW_KEY);
3f5285e8 5155 NLA_PUT(msg, NL80211_ATTR_KEY_DATA, key_len, key);
d723bab4
JM		 5156 switch (alg) {
5157 case WPA_ALG_WEP:
5158 if (key_len == 5)
5159 NLA_PUT_U32(msg, NL80211_ATTR_KEY_CIPHER,
5160 WLAN_CIPHER_SUITE_WEP40);
5161 else
5162 NLA_PUT_U32(msg, NL80211_ATTR_KEY_CIPHER,
5163 WLAN_CIPHER_SUITE_WEP104);
5164 break;
5165 case WPA_ALG_TKIP:
5166 NLA_PUT_U32(msg, NL80211_ATTR_KEY_CIPHER,
5167 WLAN_CIPHER_SUITE_TKIP);
5168 break;
5169 case WPA_ALG_CCMP:
5170 NLA_PUT_U32(msg, NL80211_ATTR_KEY_CIPHER,
5171 WLAN_CIPHER_SUITE_CCMP);
5172 break;
eb7719ff
JM		 5173 case WPA_ALG_GCMP:
5174 NLA_PUT_U32(msg, NL80211_ATTR_KEY_CIPHER,
5175 WLAN_CIPHER_SUITE_GCMP);
5176 break;
d723bab4
JM		 5177 case WPA_ALG_IGTK:
5178 NLA_PUT_U32(msg, NL80211_ATTR_KEY_CIPHER,
5179 WLAN_CIPHER_SUITE_AES_CMAC);
5180 break;
369c8d7b
JM		 5181 case WPA_ALG_SMS4:
5182 NLA_PUT_U32(msg, NL80211_ATTR_KEY_CIPHER,
5183 WLAN_CIPHER_SUITE_SMS4);
5184 break;
5185 case WPA_ALG_KRK:
5186 NLA_PUT_U32(msg, NL80211_ATTR_KEY_CIPHER,
5187 WLAN_CIPHER_SUITE_KRK);
5188 break;
d723bab4
JM		 5189 default:
5190 wpa_printf(MSG_ERROR, "%s: Unsupported encryption "
5191 "algorithm %d", __func__, alg);
3f5285e8
JM		 5192 nlmsg_free(msg);
5193 return -1;
5194 }
5195 }
5196
849ef835 5197 if (seq && seq_len)
1ad1cdc2
JM		 5198 NLA_PUT(msg, NL80211_ATTR_KEY_SEQ, seq_len, seq);
5199
0382097e 5200 if (addr && !is_broadcast_ether_addr(addr)) {
3f5285e8
JM		 5201 wpa_printf(MSG_DEBUG, " addr=" MACSTR, MAC2STR(addr));
5202 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, addr);
89c38e32
JM		 5203
5204 if (alg != WPA_ALG_WEP && key_idx && !set_tx) {
5205 wpa_printf(MSG_DEBUG, " RSN IBSS RX GTK");
5206 NLA_PUT_U32(msg, NL80211_ATTR_KEY_TYPE,
5207 NL80211_KEYTYPE_GROUP);
5208 }
60ea8187 5209 } else if (addr && is_broadcast_ether_addr(addr)) {
8970bae8
JB		 5210 struct nlattr *types;
5211
60ea8187 5212 wpa_printf(MSG_DEBUG, " broadcast key");
8970bae8
JB		 5213
5214 types = nla_nest_start(msg, NL80211_ATTR_KEY_DEFAULT_TYPES);
60ea8187
JM		 5215 if (!types)
5216 goto nla_put_failure;
8970bae8
JB		 5217 NLA_PUT_FLAG(msg, NL80211_KEY_DEFAULT_TYPE_MULTICAST);
5218 nla_nest_end(msg, types);
3f5285e8
JM		 5219 }
5220 NLA_PUT_U8(msg, NL80211_ATTR_KEY_IDX, key_idx);
1ad1cdc2 5221 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, ifindex);
3f5285e8 5222
1ad1cdc2 5223 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
15664ad0 5224 if ((ret == -ENOENT || ret == -ENOLINK) && alg == WPA_ALG_NONE)
1ad1cdc2
JM		 5225 ret = 0;
5226 if (ret)
5227 wpa_printf(MSG_DEBUG, "nl80211: set_key failed; err=%d %s)",
5228 ret, strerror(-ret));
3f5285e8 5229
1ad1cdc2
JM		 5230 /*
5231 * If we failed or don't need to set the default TX key (below),
5232 * we're done here.
5233 */
dc01de8a 5234 if (ret || !set_tx || alg == WPA_ALG_NONE || tdls)
1ad1cdc2 5235 return ret;
b1f625e0 5236 if (is_ap_interface(drv->nlmode) && addr &&
0382097e 5237 !is_broadcast_ether_addr(addr))
de12717a 5238 return ret;
3f5285e8 5239
1ad1cdc2
JM		 5240 msg = nlmsg_alloc();
5241 if (!msg)
5242 return -ENOMEM;
3f5285e8 5243
9fb04070 5244 nl80211_cmd(drv, msg, 0, NL80211_CMD_SET_KEY);
1ad1cdc2
JM		 5245 NLA_PUT_U8(msg, NL80211_ATTR_KEY_IDX, key_idx);
5246 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, ifindex);
5247 if (alg == WPA_ALG_IGTK)
5248 NLA_PUT_FLAG(msg, NL80211_ATTR_KEY_DEFAULT_MGMT);
5249 else
5250 NLA_PUT_FLAG(msg, NL80211_ATTR_KEY_DEFAULT);
60ea8187 5251 if (addr && is_broadcast_ether_addr(addr)) {
8970bae8
JB		 5252 struct nlattr *types;
5253
5254 types = nla_nest_start(msg, NL80211_ATTR_KEY_DEFAULT_TYPES);
60ea8187
JM		 5255 if (!types)
5256 goto nla_put_failure;
8970bae8
JB		 5257 NLA_PUT_FLAG(msg, NL80211_KEY_DEFAULT_TYPE_MULTICAST);
5258 nla_nest_end(msg, types);
60ea8187 5259 } else if (addr) {
8970bae8
JB		 5260 struct nlattr *types;
5261
5262 types = nla_nest_start(msg, NL80211_ATTR_KEY_DEFAULT_TYPES);
60ea8187
JM		 5263 if (!types)
5264 goto nla_put_failure;
8970bae8
JB		 5265 NLA_PUT_FLAG(msg, NL80211_KEY_DEFAULT_TYPE_UNICAST);
5266 nla_nest_end(msg, types);
60ea8187 5267 }
3f5285e8 5268
1ad1cdc2
JM		 5269 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
5270 if (ret == -ENOENT)
5271 ret = 0;
5272 if (ret)
5273 wpa_printf(MSG_DEBUG, "nl80211: set_key default failed; "
5274 "err=%d %s)", ret, strerror(-ret));
5275 return ret;
3f5285e8
JM		 5276
5277nla_put_failure:
5883168a 5278 nlmsg_free(msg);
6241fcb1 5279 return -ENOBUFS;
3f5285e8
JM		 5280}
5281
5282
71934751 5283static int nl_add_key(struct nl_msg *msg, enum wpa_alg alg,
0194fedb
JB		 5284 int key_idx, int defkey,
5285 const u8 *seq, size_t seq_len,
5286 const u8 *key, size_t key_len)
5287{
5288 struct nlattr *key_attr = nla_nest_start(msg, NL80211_ATTR_KEY);
5289 if (!key_attr)
5290 return -1;
5291
5292 if (defkey && alg == WPA_ALG_IGTK)
5293 NLA_PUT_FLAG(msg, NL80211_KEY_DEFAULT_MGMT);
5294 else if (defkey)
5295 NLA_PUT_FLAG(msg, NL80211_KEY_DEFAULT);
5296
5297 NLA_PUT_U8(msg, NL80211_KEY_IDX, key_idx);
5298
d723bab4
JM		 5299 switch (alg) {
5300 case WPA_ALG_WEP:
5301 if (key_len == 5)
2aa5f847
JM		 5302 NLA_PUT_U32(msg, NL80211_KEY_CIPHER,
5303 WLAN_CIPHER_SUITE_WEP40);
d723bab4 5304 else
2aa5f847
JM		 5305 NLA_PUT_U32(msg, NL80211_KEY_CIPHER,
5306 WLAN_CIPHER_SUITE_WEP104);
d723bab4
JM		 5307 break;
5308 case WPA_ALG_TKIP:
2aa5f847 5309 NLA_PUT_U32(msg, NL80211_KEY_CIPHER, WLAN_CIPHER_SUITE_TKIP);
d723bab4
JM		 5310 break;
5311 case WPA_ALG_CCMP:
2aa5f847 5312 NLA_PUT_U32(msg, NL80211_KEY_CIPHER, WLAN_CIPHER_SUITE_CCMP);
d723bab4 5313 break;
eb7719ff
JM		 5314 case WPA_ALG_GCMP:
5315 NLA_PUT_U32(msg, NL80211_KEY_CIPHER, WLAN_CIPHER_SUITE_GCMP);
5316 break;
d723bab4 5317 case WPA_ALG_IGTK:
2aa5f847
JM		 5318 NLA_PUT_U32(msg, NL80211_KEY_CIPHER,
5319 WLAN_CIPHER_SUITE_AES_CMAC);
d723bab4
JM		 5320 break;
5321 default:
5322 wpa_printf(MSG_ERROR, "%s: Unsupported encryption "
5323 "algorithm %d", __func__, alg);
0194fedb 5324 return -1;
d723bab4 5325 }
0194fedb
JB		 5326
5327 if (seq && seq_len)
5328 NLA_PUT(msg, NL80211_KEY_SEQ, seq_len, seq);
5329
5330 NLA_PUT(msg, NL80211_KEY_DATA, key_len, key);
5331
5332 nla_nest_end(msg, key_attr);
5333
5334 return 0;
5335 nla_put_failure:
5336 return -1;
5337}
5338
c811d5bc 5339
cfaab580
ZY		 5340static int nl80211_set_conn_keys(struct wpa_driver_associate_params *params,
5341 struct nl_msg *msg)
5342{
5343 int i, privacy = 0;
5344 struct nlattr *nl_keys, *nl_key;
5345
5346 for (i = 0; i < 4; i++) {
5347 if (!params->wep_key[i])
5348 continue;
5349 privacy = 1;
5350 break;
5351 }
ce04af5a
JM		 5352 if (params->wps == WPS_MODE_PRIVACY)
5353 privacy = 1;
5354 if (params->pairwise_suite &&
5355 params->pairwise_suite != WPA_CIPHER_NONE)
5356 privacy = 1;
5357
cfaab580
ZY		 5358 if (!privacy)
5359 return 0;
5360
5361 NLA_PUT_FLAG(msg, NL80211_ATTR_PRIVACY);
5362
5363 nl_keys = nla_nest_start(msg, NL80211_ATTR_KEYS);
5364 if (!nl_keys)
5365 goto nla_put_failure;
5366
5367 for (i = 0; i < 4; i++) {
5368 if (!params->wep_key[i])
5369 continue;
5370
5371 nl_key = nla_nest_start(msg, i);
5372 if (!nl_key)
5373 goto nla_put_failure;
5374
5375 NLA_PUT(msg, NL80211_KEY_DATA, params->wep_key_len[i],
5376 params->wep_key[i]);
5377 if (params->wep_key_len[i] == 5)
5378 NLA_PUT_U32(msg, NL80211_KEY_CIPHER,
5379 WLAN_CIPHER_SUITE_WEP40);
5380 else
5381 NLA_PUT_U32(msg, NL80211_KEY_CIPHER,
5382 WLAN_CIPHER_SUITE_WEP104);
5383
5384 NLA_PUT_U8(msg, NL80211_KEY_IDX, i);
5385
5386 if (i == params->wep_tx_keyidx)
5387 NLA_PUT_FLAG(msg, NL80211_KEY_DEFAULT);
5388
5389 nla_nest_end(msg, nl_key);
5390 }
5391 nla_nest_end(msg, nl_keys);
5392
5393 return 0;
5394
5395nla_put_failure:
5396 return -ENOBUFS;
5397}
5398
5399
c2a04078 5400static int wpa_driver_nl80211_mlme(struct wpa_driver_nl80211_data *drv,
77339912
JM		 5401 const u8 *addr, int cmd, u16 reason_code,
5402 int local_state_change)
c2a04078
JM		 5403{
5404 int ret = -1;
5405 struct nl_msg *msg;
5406
5407 msg = nlmsg_alloc();
5408 if (!msg)
5409 return -1;
5410
9fb04070 5411 nl80211_cmd(drv, msg, 0, cmd);
c2a04078
JM		 5412
5413 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
5414 NLA_PUT_U16(msg, NL80211_ATTR_REASON_CODE, reason_code);
817762d9
MI		 5415 if (addr)
5416 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, addr);
77339912
JM		 5417 if (local_state_change)
5418 NLA_PUT_FLAG(msg, NL80211_ATTR_LOCAL_STATE_CHANGE);
c2a04078
JM		 5419
5420 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
5421 msg = NULL;
5422 if (ret) {
3b7ea880
BG		 5423 wpa_dbg(drv->ctx, MSG_DEBUG,
5424 "nl80211: MLME command failed: reason=%u ret=%d (%s)",
5425 reason_code, ret, strerror(-ret));
c2a04078
JM		 5426 goto nla_put_failure;
5427 }
5428 ret = 0;
5429
5430nla_put_failure:
5431 nlmsg_free(msg);
5432 return ret;
5433}
3f5285e8
JM		 5434
5435
cfaab580 5436static int wpa_driver_nl80211_disconnect(struct wpa_driver_nl80211_data *drv,
817762d9 5437 int reason_code)
cfaab580 5438{
3f53c006
JJ		 5439 int ret;
5440
817762d9 5441 wpa_printf(MSG_DEBUG, "%s(reason_code=%d)", __func__, reason_code);
add9b7a4 5442 nl80211_mark_disconnected(drv);
817762d9 5443 /* Disconnect command doesn't need BSSID - it uses cached value */
3f53c006
JJ		 5444 ret = wpa_driver_nl80211_mlme(drv, NULL, NL80211_CMD_DISCONNECT,
5445 reason_code, 0);
5446 /*
5447 * For locally generated disconnect, supplicant already generates a
5448 * DEAUTH event, so ignore the event from NL80211.
5449 */
5450 drv->ignore_next_local_disconnect = ret == 0;
5451
5452 return ret;
cfaab580
ZY		 5453}
5454
5455
9ebce9c5
JM		 5456static int wpa_driver_nl80211_deauthenticate(struct i802_bss *bss,
5457 const u8 *addr, int reason_code)
3f5285e8 5458{
a2e40bb6 5459 struct wpa_driver_nl80211_data *drv = bss->drv;
cfaab580 5460 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_SME))
817762d9 5461 return wpa_driver_nl80211_disconnect(drv, reason_code);
2e75a2b3
JM		 5462 wpa_printf(MSG_DEBUG, "%s(addr=" MACSTR " reason_code=%d)",
5463 __func__, MAC2STR(addr), reason_code);
add9b7a4 5464 nl80211_mark_disconnected(drv);
21bdbe38
JM		 5465 if (drv->nlmode == NL80211_IFTYPE_ADHOC)
5466 return nl80211_leave_ibss(drv);
c2a04078 5467 return wpa_driver_nl80211_mlme(drv, addr, NL80211_CMD_DEAUTHENTICATE,
77339912 5468 reason_code, 0);
3f5285e8
JM		 5469}
5470
5471
536fd62d
JM		 5472static void nl80211_copy_auth_params(struct wpa_driver_nl80211_data *drv,
5473 struct wpa_driver_auth_params *params)
5474{
5475 int i;
5476
5477 drv->auth_freq = params->freq;
5478 drv->auth_alg = params->auth_alg;
5479 drv->auth_wep_tx_keyidx = params->wep_tx_keyidx;
5480 drv->auth_local_state_change = params->local_state_change;
5481 drv->auth_p2p = params->p2p;
5482
5483 if (params->bssid)
5484 os_memcpy(drv->auth_bssid_, params->bssid, ETH_ALEN);
5485 else
5486 os_memset(drv->auth_bssid_, 0, ETH_ALEN);
5487
5488 if (params->ssid) {
5489 os_memcpy(drv->auth_ssid, params->ssid, params->ssid_len);
5490 drv->auth_ssid_len = params->ssid_len;
5491 } else
5492 drv->auth_ssid_len = 0;
5493
5494
5495 os_free(drv->auth_ie);
5496 drv->auth_ie = NULL;
5497 drv->auth_ie_len = 0;
5498 if (params->ie) {
5499 drv->auth_ie = os_malloc(params->ie_len);
5500 if (drv->auth_ie) {
5501 os_memcpy(drv->auth_ie, params->ie, params->ie_len);
5502 drv->auth_ie_len = params->ie_len;
5503 }
5504 }
5505
5506 for (i = 0; i < 4; i++) {
5507 if (params->wep_key[i] && params->wep_key_len[i] &&
5508 params->wep_key_len[i] <= 16) {
5509 os_memcpy(drv->auth_wep_key[i], params->wep_key[i],
5510 params->wep_key_len[i]);
5511 drv->auth_wep_key_len[i] = params->wep_key_len[i];
5512 } else
5513 drv->auth_wep_key_len[i] = 0;
5514 }
5515}
5516
5517
c2a04078 5518static int wpa_driver_nl80211_authenticate(
9ebce9c5 5519 struct i802_bss *bss, struct wpa_driver_auth_params *params)
c2a04078 5520{
a2e40bb6 5521 struct wpa_driver_nl80211_data *drv = bss->drv;
a0b2f99b 5522 int ret = -1, i;
c2a04078
JM		 5523 struct nl_msg *msg;
5524 enum nl80211_auth_type type;
2f4f73b1 5525 enum nl80211_iftype nlmode;
6d6f4bb8 5526 int count = 0;
536fd62d
JM		 5527 int is_retry;
5528
5529 is_retry = drv->retry_auth;
5530 drv->retry_auth = 0;
c2a04078 5531
add9b7a4 5532 nl80211_mark_disconnected(drv);
e6b8efeb 5533 os_memset(drv->auth_bssid, 0, ETH_ALEN);
add9b7a4
JM		 5534 if (params->bssid)
5535 os_memcpy(drv->auth_attempt_bssid, params->bssid, ETH_ALEN);
5536 else
5537 os_memset(drv->auth_attempt_bssid, 0, ETH_ALEN);
af473088 5538 /* FIX: IBSS mode */
2f4f73b1
EP		 5539 nlmode = params->p2p ?
5540 NL80211_IFTYPE_P2P_CLIENT : NL80211_IFTYPE_STATION;
5541 if (drv->nlmode != nlmode &&
9ebce9c5 5542 wpa_driver_nl80211_set_mode(bss, nlmode) < 0)
4a867032
JM		 5543 return -1;
5544
6d6f4bb8 5545retry:
c2a04078
JM		 5546 msg = nlmsg_alloc();
5547 if (!msg)
5548 return -1;
5549
5550 wpa_printf(MSG_DEBUG, "nl80211: Authenticate (ifindex=%d)",
5551 drv->ifindex);
a0b2f99b 5552
9fb04070 5553 nl80211_cmd(drv, msg, 0, NL80211_CMD_AUTHENTICATE);
0194fedb 5554
a0b2f99b
JM		 5555 for (i = 0; i < 4; i++) {
5556 if (!params->wep_key[i])
5557 continue;
9ebce9c5 5558 wpa_driver_nl80211_set_key(bss->ifname, bss, WPA_ALG_WEP,
2ea2fcc7 5559 NULL, i,
a0b2f99b
JM		 5560 i == params->wep_tx_keyidx, NULL, 0,
5561 params->wep_key[i],
5562 params->wep_key_len[i]);
0194fedb
JB		 5563 if (params->wep_tx_keyidx != i)
5564 continue;
5565 if (nl_add_key(msg, WPA_ALG_WEP, i, 1, NULL, 0,
5566 params->wep_key[i], params->wep_key_len[i])) {
5567 nlmsg_free(msg);
5568 return -1;
5569 }
a0b2f99b
JM		 5570 }
5571
c2a04078
JM		 5572 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
5573 if (params->bssid) {
5574 wpa_printf(MSG_DEBUG, " * bssid=" MACSTR,
5575 MAC2STR(params->bssid));
5576 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, params->bssid);
5577 }
5578 if (params->freq) {
5579 wpa_printf(MSG_DEBUG, " * freq=%d", params->freq);
5580 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_FREQ, params->freq);
5581 }
5582 if (params->ssid) {
5583 wpa_hexdump_ascii(MSG_DEBUG, " * SSID",
5584 params->ssid, params->ssid_len);
5585 NLA_PUT(msg, NL80211_ATTR_SSID, params->ssid_len,
5586 params->ssid);
5587 }
5588 wpa_hexdump(MSG_DEBUG, " * IEs", params->ie, params->ie_len);
5589 if (params->ie)
5590 NLA_PUT(msg, NL80211_ATTR_IE, params->ie_len, params->ie);
569fed90
JM		 5591 if (params->sae_data) {
5592 wpa_hexdump(MSG_DEBUG, " * SAE data", params->sae_data,
5593 params->sae_data_len);
5594 NLA_PUT(msg, NL80211_ATTR_SAE_DATA, params->sae_data_len,
5595 params->sae_data);
5596 }
abd9fafa 5597 if (params->auth_alg & WPA_AUTH_ALG_OPEN)
c2a04078 5598 type = NL80211_AUTHTYPE_OPEN_SYSTEM;
abd9fafa 5599 else if (params->auth_alg & WPA_AUTH_ALG_SHARED)
c2a04078 5600 type = NL80211_AUTHTYPE_SHARED_KEY;
abd9fafa 5601 else if (params->auth_alg & WPA_AUTH_ALG_LEAP)
c2a04078 5602 type = NL80211_AUTHTYPE_NETWORK_EAP;
abd9fafa 5603 else if (params->auth_alg & WPA_AUTH_ALG_FT)
c2a04078 5604 type = NL80211_AUTHTYPE_FT;
569fed90
JM		 5605 else if (params->auth_alg & WPA_AUTH_ALG_SAE)
5606 type = NL80211_AUTHTYPE_SAE;
c2a04078
JM		 5607 else
5608 goto nla_put_failure;
5609 wpa_printf(MSG_DEBUG, " * Auth Type %d", type);
5610 NLA_PUT_U32(msg, NL80211_ATTR_AUTH_TYPE, type);
77339912
JM		 5611 if (params->local_state_change) {
5612 wpa_printf(MSG_DEBUG, " * Local state change only");
5613 NLA_PUT_FLAG(msg, NL80211_ATTR_LOCAL_STATE_CHANGE);
5614 }
c2a04078
JM		 5615
5616 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
5617 msg = NULL;
5618 if (ret) {
3b7ea880
BG		 5619 wpa_dbg(drv->ctx, MSG_DEBUG,
5620 "nl80211: MLME command failed (auth): ret=%d (%s)",
5621 ret, strerror(-ret));
6d6f4bb8 5622 count++;
77339912
JM		 5623 if (ret == -EALREADY && count == 1 && params->bssid &&
5624 !params->local_state_change) {
6d6f4bb8
JM		 5625 /*
5626 * mac80211 does not currently accept new
5627 * authentication if we are already authenticated. As a
5628 * workaround, force deauthentication and try again.
5629 */
5630 wpa_printf(MSG_DEBUG, "nl80211: Retry authentication "
5631 "after forced deauthentication");
5632 wpa_driver_nl80211_deauthenticate(
5205c4f9 5633 bss, params->bssid,
6d6f4bb8
JM		 5634 WLAN_REASON_PREV_AUTH_NOT_VALID);
5635 nlmsg_free(msg);
5636 goto retry;
5637 }
536fd62d
JM		 5638
5639 if (ret == -ENOENT && params->freq && !is_retry) {
5640 /*
5641 * cfg80211 has likely expired the BSS entry even
5642 * though it was previously available in our internal
5643 * BSS table. To recover quickly, start a single
5644 * channel scan on the specified channel.
5645 */
5646 struct wpa_driver_scan_params scan;
5647 int freqs[2];
5648
5649 os_memset(&scan, 0, sizeof(scan));
5650 scan.num_ssids = 1;
5651 if (params->ssid) {
5652 scan.ssids[0].ssid = params->ssid;
5653 scan.ssids[0].ssid_len = params->ssid_len;
5654 }
5655 freqs[0] = params->freq;
5656 freqs[1] = 0;
5657 scan.freqs = freqs;
5658 wpa_printf(MSG_DEBUG, "nl80211: Trigger single "
5659 "channel scan to refresh cfg80211 BSS "
5660 "entry");
5661 ret = wpa_driver_nl80211_scan(bss, &scan);
5662 if (ret == 0) {
5663 nl80211_copy_auth_params(drv, params);
5664 drv->scan_for_auth = 1;
5665 }
8c3ba078
JM		 5666 } else if (is_retry) {
5667 /*
5668 * Need to indicate this with an event since the return
5669 * value from the retry is not delivered to core code.
5670 */
5671 union wpa_event_data event;
5672 wpa_printf(MSG_DEBUG, "nl80211: Authentication retry "
5673 "failed");
5674 os_memset(&event, 0, sizeof(event));
5675 os_memcpy(event.timeout_event.addr, drv->auth_bssid_,
5676 ETH_ALEN);
5677 wpa_supplicant_event(drv->ctx, EVENT_AUTH_TIMED_OUT,
5678 &event);
536fd62d
JM		 5679 }
5680
c2a04078
JM		 5681 goto nla_put_failure;
5682 }
5683 ret = 0;
5684 wpa_printf(MSG_DEBUG, "nl80211: Authentication request send "
5685 "successfully");
5686
5687nla_put_failure:
5688 nlmsg_free(msg);
5689 return ret;
5690}
5691
5692
536fd62d
JM		 5693static int wpa_driver_nl80211_authenticate_retry(
5694 struct wpa_driver_nl80211_data *drv)
5695{
5696 struct wpa_driver_auth_params params;
834ee56f 5697 struct i802_bss *bss = drv->first_bss;
536fd62d
JM		 5698 int i;
5699
5700 wpa_printf(MSG_DEBUG, "nl80211: Try to authenticate again");
5701
5702 os_memset(&params, 0, sizeof(params));
5703 params.freq = drv->auth_freq;
5704 params.auth_alg = drv->auth_alg;
5705 params.wep_tx_keyidx = drv->auth_wep_tx_keyidx;
5706 params.local_state_change = drv->auth_local_state_change;
5707 params.p2p = drv->auth_p2p;
5708
5709 if (!is_zero_ether_addr(drv->auth_bssid_))
5710 params.bssid = drv->auth_bssid_;
5711
5712 if (drv->auth_ssid_len) {
5713 params.ssid = drv->auth_ssid;
5714 params.ssid_len = drv->auth_ssid_len;
5715 }
5716
5717 params.ie = drv->auth_ie;
5718 params.ie_len = drv->auth_ie_len;
5719
5720 for (i = 0; i < 4; i++) {
5721 if (drv->auth_wep_key_len[i]) {
5722 params.wep_key[i] = drv->auth_wep_key[i];
5723 params.wep_key_len[i] = drv->auth_wep_key_len[i];
5724 }
5725 }
5726
5727 drv->retry_auth = 1;
5728 return wpa_driver_nl80211_authenticate(bss, &params);
5729}
5730
5731
282d5590
JM		 5732struct phy_info_arg {
5733 u16 *num_modes;
5734 struct hostapd_hw_modes *modes;
43245552 5735 int last_mode, last_chan_idx;
282d5590
JM		 5736};
5737
e62a1d43
JM		 5738static void phy_info_ht_capa(struct hostapd_hw_modes *mode, struct nlattr *capa,
5739 struct nlattr *ampdu_factor,
5740 struct nlattr *ampdu_density,
5741 struct nlattr *mcs_set)
5742{
5743 if (capa)
5744 mode->ht_capab = nla_get_u16(capa);
5745
5746 if (ampdu_factor)
5747 mode->a_mpdu_params |= nla_get_u8(ampdu_factor) & 0x03;
5748
5749 if (ampdu_density)
5750 mode->a_mpdu_params |= nla_get_u8(ampdu_density) << 2;
5751
5752 if (mcs_set && nla_len(mcs_set) >= 16) {
5753 u8 *mcs;
5754 mcs = nla_data(mcs_set);
5755 os_memcpy(mode->mcs_set, mcs, 16);
5756 }
5757}
5758
5759
5760static void phy_info_vht_capa(struct hostapd_hw_modes *mode,
5761 struct nlattr *capa,
5762 struct nlattr *mcs_set)
5763{
5764 if (capa)
5765 mode->vht_capab = nla_get_u32(capa);
5766
5767 if (mcs_set && nla_len(mcs_set) >= 8) {
5768 u8 *mcs;
5769 mcs = nla_data(mcs_set);
5770 os_memcpy(mode->vht_mcs_set, mcs, 8);
5771 }
5772}
5773
5774
214a77b0
JM		 5775static void phy_info_freq(struct hostapd_hw_modes *mode,
5776 struct hostapd_channel_data *chan,
5777 struct nlattr *tb_freq[])
5778{
e864c0ae 5779 u8 channel;
214a77b0
JM		 5780 chan->freq = nla_get_u32(tb_freq[NL80211_FREQUENCY_ATTR_FREQ]);
5781 chan->flag = 0;
e864c0ae
JM		 5782 if (ieee80211_freq_to_chan(chan->freq, &channel) != NUM_HOSTAPD_MODES)
5783 chan->chan = channel;
214a77b0
JM		 5784
5785 if (tb_freq[NL80211_FREQUENCY_ATTR_DISABLED])
5786 chan->flag |= HOSTAPD_CHAN_DISABLED;
9fcd300d
JM		 5787 if (tb_freq[NL80211_FREQUENCY_ATTR_NO_IR])
5788 chan->flag |= HOSTAPD_CHAN_PASSIVE_SCAN | HOSTAPD_CHAN_NO_IBSS;
214a77b0
JM		 5789 if (tb_freq[NL80211_FREQUENCY_ATTR_RADAR])
5790 chan->flag |= HOSTAPD_CHAN_RADAR;
5791
fc96522e
SW		 5792 if (tb_freq[NL80211_FREQUENCY_ATTR_DFS_STATE]) {
5793 enum nl80211_dfs_state state =
5794 nla_get_u32(tb_freq[NL80211_FREQUENCY_ATTR_DFS_STATE]);
5795
5796 switch (state) {
5797 case NL80211_DFS_USABLE:
5798 chan->flag |= HOSTAPD_CHAN_DFS_USABLE;
5799 break;
5800 case NL80211_DFS_AVAILABLE:
5801 chan->flag |= HOSTAPD_CHAN_DFS_AVAILABLE;
5802 break;
5803 case NL80211_DFS_UNAVAILABLE:
5804 chan->flag |= HOSTAPD_CHAN_DFS_UNAVAILABLE;
5805 break;
5806 }
5807 }
214a77b0
JM		 5808}
5809
5810
e62a1d43
JM		 5811static int phy_info_freqs(struct phy_info_arg *phy_info,
5812 struct hostapd_hw_modes *mode, struct nlattr *tb)
282d5590 5813{
282d5590
JM		 5814 static struct nla_policy freq_policy[NL80211_FREQUENCY_ATTR_MAX + 1] = {
5815 [NL80211_FREQUENCY_ATTR_FREQ] = { .type = NLA_U32 },
5816 [NL80211_FREQUENCY_ATTR_DISABLED] = { .type = NLA_FLAG },
9fcd300d 5817 [NL80211_FREQUENCY_ATTR_NO_IR] = { .type = NLA_FLAG },
282d5590
JM		 5818 [NL80211_FREQUENCY_ATTR_RADAR] = { .type = NLA_FLAG },
5819 [NL80211_FREQUENCY_ATTR_MAX_TX_POWER] = { .type = NLA_U32 },
fc96522e 5820 [NL80211_FREQUENCY_ATTR_DFS_STATE] = { .type = NLA_U32 },
282d5590 5821 };
e62a1d43
JM		 5822 int new_channels = 0;
5823 struct hostapd_channel_data *channel;
5824 struct nlattr *tb_freq[NL80211_FREQUENCY_ATTR_MAX + 1];
5825 struct nlattr *nl_freq;
5826 int rem_freq, idx;
5827
5828 if (tb == NULL)
5829 return NL_OK;
5830
5831 nla_for_each_nested(nl_freq, tb, rem_freq) {
5832 nla_parse(tb_freq, NL80211_FREQUENCY_ATTR_MAX,
5833 nla_data(nl_freq), nla_len(nl_freq), freq_policy);
5834 if (!tb_freq[NL80211_FREQUENCY_ATTR_FREQ])
5835 continue;
5836 new_channels++;
5837 }
5838
5839 channel = os_realloc_array(mode->channels,
5840 mode->num_channels + new_channels,
5841 sizeof(struct hostapd_channel_data));
5842 if (!channel)
5843 return NL_SKIP;
5844
5845 mode->channels = channel;
5846 mode->num_channels += new_channels;
5847
5848 idx = phy_info->last_chan_idx;
5849
5850 nla_for_each_nested(nl_freq, tb, rem_freq) {
5851 nla_parse(tb_freq, NL80211_FREQUENCY_ATTR_MAX,
5852 nla_data(nl_freq), nla_len(nl_freq), freq_policy);
5853 if (!tb_freq[NL80211_FREQUENCY_ATTR_FREQ])
5854 continue;
214a77b0 5855 phy_info_freq(mode, &mode->channels[idx], tb_freq);
e62a1d43
JM		 5856 idx++;
5857 }
5858 phy_info->last_chan_idx = idx;
5859
5860 return NL_OK;
5861}
5862
5863
5864static int phy_info_rates(struct hostapd_hw_modes *mode, struct nlattr *tb)
5865{
282d5590
JM		 5866 static struct nla_policy rate_policy[NL80211_BITRATE_ATTR_MAX + 1] = {
5867 [NL80211_BITRATE_ATTR_RATE] = { .type = NLA_U32 },
3cfcad1b
JM		 5868 [NL80211_BITRATE_ATTR_2GHZ_SHORTPREAMBLE] =
5869 { .type = NLA_FLAG },
282d5590 5870 };
e62a1d43 5871 struct nlattr *tb_rate[NL80211_BITRATE_ATTR_MAX + 1];
282d5590 5872 struct nlattr *nl_rate;
e62a1d43
JM		 5873 int rem_rate, idx;
5874
5875 if (tb == NULL)
5876 return NL_OK;
5877
5878 nla_for_each_nested(nl_rate, tb, rem_rate) {
5879 nla_parse(tb_rate, NL80211_BITRATE_ATTR_MAX,
5880 nla_data(nl_rate), nla_len(nl_rate),
5881 rate_policy);
5882 if (!tb_rate[NL80211_BITRATE_ATTR_RATE])
5883 continue;
5884 mode->num_rates++;
5885 }
5886
5887 mode->rates = os_calloc(mode->num_rates, sizeof(int));
5888 if (!mode->rates)
5889 return NL_SKIP;
5890
5891 idx = 0;
5892
5893 nla_for_each_nested(nl_rate, tb, rem_rate) {
5894 nla_parse(tb_rate, NL80211_BITRATE_ATTR_MAX,
5895 nla_data(nl_rate), nla_len(nl_rate),
5896 rate_policy);
5897 if (!tb_rate[NL80211_BITRATE_ATTR_RATE])
5898 continue;
5899 mode->rates[idx] = nla_get_u32(
5900 tb_rate[NL80211_BITRATE_ATTR_RATE]);
e62a1d43
JM		 5901 idx++;
5902 }
5903
5904 return NL_OK;
5905}
5906
5907
5908static int phy_info_band(struct phy_info_arg *phy_info, struct nlattr *nl_band)
5909{
5910 struct nlattr *tb_band[NL80211_BAND_ATTR_MAX + 1];
282d5590 5911 struct hostapd_hw_modes *mode;
e62a1d43 5912 int ret;
282d5590 5913
3cfcad1b
JM		 5914 if (phy_info->last_mode != nl_band->nla_type) {
5915 mode = os_realloc_array(phy_info->modes,
5916 *phy_info->num_modes + 1,
5917 sizeof(*mode));
5918 if (!mode)
5919 return NL_SKIP;
5920 phy_info->modes = mode;
5921
5922 mode = &phy_info->modes[*(phy_info->num_modes)];
5923 os_memset(mode, 0, sizeof(*mode));
5924 mode->mode = NUM_HOSTAPD_MODES;
c8ebeda4
MK		 5925 mode->flags = HOSTAPD_MODE_FLAG_HT_INFO_KNOWN |
5926 HOSTAPD_MODE_FLAG_VHT_INFO_KNOWN;
5927
5928 /*
5929 * Unsupported VHT MCS stream is defined as value 3, so the VHT
5930 * MCS RX/TX map must be initialized with 0xffff to mark all 8
5931 * possible streams as unsupported. This will be overridden if
5932 * driver advertises VHT support.
5933 */
5934 mode->vht_mcs_set[0] = 0xff;
5935 mode->vht_mcs_set[1] = 0xff;
5936 mode->vht_mcs_set[4] = 0xff;
5937 mode->vht_mcs_set[5] = 0xff;
5938
3cfcad1b
JM		 5939 *(phy_info->num_modes) += 1;
5940 phy_info->last_mode = nl_band->nla_type;
5941 phy_info->last_chan_idx = 0;
5942 } else
5943 mode = &phy_info->modes[*(phy_info->num_modes) - 1];
282d5590 5944
3cfcad1b
JM		 5945 nla_parse(tb_band, NL80211_BAND_ATTR_MAX, nla_data(nl_band),
5946 nla_len(nl_band), NULL);
282d5590 5947
e62a1d43
JM		 5948 phy_info_ht_capa(mode, tb_band[NL80211_BAND_ATTR_HT_CAPA],
5949 tb_band[NL80211_BAND_ATTR_HT_AMPDU_FACTOR],
5950 tb_band[NL80211_BAND_ATTR_HT_AMPDU_DENSITY],
5951 tb_band[NL80211_BAND_ATTR_HT_MCS_SET]);
5952 phy_info_vht_capa(mode, tb_band[NL80211_BAND_ATTR_VHT_CAPA],
5953 tb_band[NL80211_BAND_ATTR_VHT_MCS_SET]);
5954 ret = phy_info_freqs(phy_info, mode, tb_band[NL80211_BAND_ATTR_FREQS]);
5955 if (ret != NL_OK)
5956 return ret;
5957 ret = phy_info_rates(mode, tb_band[NL80211_BAND_ATTR_RATES]);
5958 if (ret != NL_OK)
5959 return ret;
282d5590 5960
3cfcad1b
JM		 5961 return NL_OK;
5962}
5963
5964
5965static int phy_info_handler(struct nl_msg *msg, void *arg)
5966{
5967 struct nlattr *tb_msg[NL80211_ATTR_MAX + 1];
5968 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
5969 struct phy_info_arg *phy_info = arg;
5970 struct nlattr *nl_band;
5971 int rem_band;
5972
5973 nla_parse(tb_msg, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
5974 genlmsg_attrlen(gnlh, 0), NULL);
5975
5976 if (!tb_msg[NL80211_ATTR_WIPHY_BANDS])
5977 return NL_SKIP;
5978
5979 nla_for_each_nested(nl_band, tb_msg[NL80211_ATTR_WIPHY_BANDS], rem_band)
5980 {
5981 int res = phy_info_band(phy_info, nl_band);
5982 if (res != NL_OK)
5983 return res;
5984 }
5985
282d5590
JM		 5986 return NL_SKIP;
5987}
5988
3cfcad1b 5989
282d5590 5990static struct hostapd_hw_modes *
c30a4ab0
JB		 5991wpa_driver_nl80211_postprocess_modes(struct hostapd_hw_modes *modes,
5992 u16 *num_modes)
282d5590
JM		 5993{
5994 u16 m;
5995 struct hostapd_hw_modes *mode11g = NULL, *nmodes, *mode;
5996 int i, mode11g_idx = -1;
5997
c30a4ab0
JB		 5998 /* heuristic to set up modes */
5999 for (m = 0; m < *num_modes; m++) {
6000 if (!modes[m].num_channels)
6001 continue;
6002 if (modes[m].channels[0].freq < 4000) {
6003 modes[m].mode = HOSTAPD_MODE_IEEE80211B;
6004 for (i = 0; i < modes[m].num_rates; i++) {
6005 if (modes[m].rates[i] > 200) {
6006 modes[m].mode = HOSTAPD_MODE_IEEE80211G;
6007 break;
6008 }
6009 }
6010 } else if (modes[m].channels[0].freq > 50000)
6011 modes[m].mode = HOSTAPD_MODE_IEEE80211AD;
6012 else
6013 modes[m].mode = HOSTAPD_MODE_IEEE80211A;
6014 }
6015
282d5590
JM		 6016 /* If only 802.11g mode is included, use it to construct matching
6017 * 802.11b mode data. */
6018
6019 for (m = 0; m < *num_modes; m++) {
6020 if (modes[m].mode == HOSTAPD_MODE_IEEE80211B)
6021 return modes; /* 802.11b already included */
6022 if (modes[m].mode == HOSTAPD_MODE_IEEE80211G)
6023 mode11g_idx = m;
6024 }
6025
6026 if (mode11g_idx < 0)
6027 return modes; /* 2.4 GHz band not supported at all */
6028
067ffa26 6029 nmodes = os_realloc_array(modes, *num_modes + 1, sizeof(*nmodes));
282d5590
JM		 6030 if (nmodes == NULL)
6031 return modes; /* Could not add 802.11b mode */
6032
6033 mode = &nmodes[*num_modes];
6034 os_memset(mode, 0, sizeof(*mode));
6035 (*num_modes)++;
6036 modes = nmodes;
6037
6038 mode->mode = HOSTAPD_MODE_IEEE80211B;
6039
6040 mode11g = &modes[mode11g_idx];
6041 mode->num_channels = mode11g->num_channels;
6042 mode->channels = os_malloc(mode11g->num_channels *
6043 sizeof(struct hostapd_channel_data));
6044 if (mode->channels == NULL) {
6045 (*num_modes)--;
6046 return modes; /* Could not add 802.11b mode */
6047 }
6048 os_memcpy(mode->channels, mode11g->channels,
6049 mode11g->num_channels * sizeof(struct hostapd_channel_data));
6050
6051 mode->num_rates = 0;
fb7842aa 6052 mode->rates = os_malloc(4 * sizeof(int));
282d5590
JM		 6053 if (mode->rates == NULL) {
6054 os_free(mode->channels);
6055 (*num_modes)--;
6056 return modes; /* Could not add 802.11b mode */
6057 }
6058
6059 for (i = 0; i < mode11g->num_rates; i++) {
fb7842aa
JM		 6060 if (mode11g->rates[i] != 10 && mode11g->rates[i] != 20 &&
6061 mode11g->rates[i] != 55 && mode11g->rates[i] != 110)
282d5590
JM		 6062 continue;
6063 mode->rates[mode->num_rates] = mode11g->rates[i];
6064 mode->num_rates++;
6065 if (mode->num_rates == 4)
6066 break;
6067 }
6068
6069 if (mode->num_rates == 0) {
6070 os_free(mode->channels);
6071 os_free(mode->rates);
6072 (*num_modes)--;
6073 return modes; /* No 802.11b rates */
6074 }
6075
6076 wpa_printf(MSG_DEBUG, "nl80211: Added 802.11b mode based on 802.11g "
6077 "information");
6078
6079 return modes;
6080}
6081
6082
d8e66e80
JM		 6083static void nl80211_set_ht40_mode(struct hostapd_hw_modes *mode, int start,
6084 int end)
6085{
6086 int c;
6087
6088 for (c = 0; c < mode->num_channels; c++) {
6089 struct hostapd_channel_data *chan = &mode->channels[c];
6090 if (chan->freq - 10 >= start && chan->freq + 10 <= end)
6091 chan->flag |= HOSTAPD_CHAN_HT40;
6092 }
6093}
6094
6095
6096static void nl80211_set_ht40_mode_sec(struct hostapd_hw_modes *mode, int start,
6097 int end)
6098{
6099 int c;
6100
6101 for (c = 0; c < mode->num_channels; c++) {
6102 struct hostapd_channel_data *chan = &mode->channels[c];
6103 if (!(chan->flag & HOSTAPD_CHAN_HT40))
6104 continue;
6105 if (chan->freq - 30 >= start && chan->freq - 10 <= end)
6106 chan->flag |= HOSTAPD_CHAN_HT40MINUS;
6107 if (chan->freq + 10 >= start && chan->freq + 30 <= end)
6108 chan->flag |= HOSTAPD_CHAN_HT40PLUS;
6109 }
6110}
6111
6112
6651f1f9
HS		 6113static void nl80211_reg_rule_max_eirp(struct nlattr *tb[],
6114 struct phy_info_arg *results)
6115{
6116 u32 start, end, max_eirp;
6117 u16 m;
6118
6119 if (tb[NL80211_ATTR_FREQ_RANGE_START] == NULL ||
6120 tb[NL80211_ATTR_FREQ_RANGE_END] == NULL ||
6121 tb[NL80211_ATTR_POWER_RULE_MAX_EIRP] == NULL)
6122 return;
6123
6124 start = nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_START]) / 1000;
6125 end = nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_END]) / 1000;
6126 max_eirp = nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_EIRP]) / 100;
6127
6128 wpa_printf(MSG_DEBUG, "nl80211: %u-%u @ %u mBm",
6129 start, end, max_eirp);
6130
6131 for (m = 0; m < *results->num_modes; m++) {
6132 int c;
6133 struct hostapd_hw_modes *mode = &results->modes[m];
6134
6135 for (c = 0; c < mode->num_channels; c++) {
6136 struct hostapd_channel_data *chan = &mode->channels[c];
6137 if ((u32) chan->freq - 10 >= start &&
6138 (u32) chan->freq + 10 <= end)
6139 chan->max_tx_power = max_eirp;
6140 }
6141 }
6142}
6143
6144
d8e66e80
JM		 6145static void nl80211_reg_rule_ht40(struct nlattr *tb[],
6146 struct phy_info_arg *results)
6147{
6148 u32 start, end, max_bw;
6149 u16 m;
6150
6151 if (tb[NL80211_ATTR_FREQ_RANGE_START] == NULL ||
6152 tb[NL80211_ATTR_FREQ_RANGE_END] == NULL ||
6153 tb[NL80211_ATTR_FREQ_RANGE_MAX_BW] == NULL)
6154 return;
6155
6156 start = nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_START]) / 1000;
6157 end = nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_END]) / 1000;
6158 max_bw = nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_MAX_BW]) / 1000;
6159
6160 wpa_printf(MSG_DEBUG, "nl80211: %u-%u @ %u MHz",
6161 start, end, max_bw);
6162 if (max_bw < 40)
6163 return;
6164
6165 for (m = 0; m < *results->num_modes; m++) {
6166 if (!(results->modes[m].ht_capab &
6167 HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET))
6168 continue;
6169 nl80211_set_ht40_mode(&results->modes[m], start, end);
6170 }
6171}
6172
6173
6174static void nl80211_reg_rule_sec(struct nlattr *tb[],
6175 struct phy_info_arg *results)
6176{
6177 u32 start, end, max_bw;
6178 u16 m;
6179
6180 if (tb[NL80211_ATTR_FREQ_RANGE_START] == NULL ||
6181 tb[NL80211_ATTR_FREQ_RANGE_END] == NULL ||
6182 tb[NL80211_ATTR_FREQ_RANGE_MAX_BW] == NULL)
6183 return;
6184
6185 start = nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_START]) / 1000;
6186 end = nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_END]) / 1000;
6187 max_bw = nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_MAX_BW]) / 1000;
6188
6189 if (max_bw < 20)
6190 return;
6191
6192 for (m = 0; m < *results->num_modes; m++) {
6193 if (!(results->modes[m].ht_capab &
6194 HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET))
6195 continue;
6196 nl80211_set_ht40_mode_sec(&results->modes[m], start, end);
6197 }
6198}
6199
6200
53cfad46
EP		 6201static void nl80211_set_vht_mode(struct hostapd_hw_modes *mode, int start,
6202 int end)
6203{
6204 int c;
6205
6206 for (c = 0; c < mode->num_channels; c++) {
6207 struct hostapd_channel_data *chan = &mode->channels[c];
6208 if (chan->freq - 10 >= start && chan->freq + 70 <= end)
6209 chan->flag |= HOSTAPD_CHAN_VHT_10_70;
6210
6211 if (chan->freq - 30 >= start && chan->freq + 50 <= end)
6212 chan->flag |= HOSTAPD_CHAN_VHT_30_50;
6213
6214 if (chan->freq - 50 >= start && chan->freq + 30 <= end)
6215 chan->flag |= HOSTAPD_CHAN_VHT_50_30;
6216
6217 if (chan->freq - 70 >= start && chan->freq + 10 <= end)
6218 chan->flag |= HOSTAPD_CHAN_VHT_70_10;
6219 }
6220}
6221
6222
6223static void nl80211_reg_rule_vht(struct nlattr *tb[],
6224 struct phy_info_arg *results)
6225{
6226 u32 start, end, max_bw;
6227 u16 m;
6228
6229 if (tb[NL80211_ATTR_FREQ_RANGE_START] == NULL ||
6230 tb[NL80211_ATTR_FREQ_RANGE_END] == NULL ||
6231 tb[NL80211_ATTR_FREQ_RANGE_MAX_BW] == NULL)
6232 return;
6233
6234 start = nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_START]) / 1000;
6235 end = nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_END]) / 1000;
6236 max_bw = nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_MAX_BW]) / 1000;
6237
6238 if (max_bw < 80)
6239 return;
6240
6241 for (m = 0; m < *results->num_modes; m++) {
6242 if (!(results->modes[m].ht_capab &
6243 HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET))
6244 continue;
6245 /* TODO: use a real VHT support indication */
6246 if (!results->modes[m].vht_capab)
6247 continue;
6248
6249 nl80211_set_vht_mode(&results->modes[m], start, end);
6250 }
6251}
6252
6253
d8e66e80
JM		 6254static int nl80211_get_reg(struct nl_msg *msg, void *arg)
6255{
6256 struct phy_info_arg *results = arg;
6257 struct nlattr *tb_msg[NL80211_ATTR_MAX + 1];
6258 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
6259 struct nlattr *nl_rule;
6260 struct nlattr *tb_rule[NL80211_FREQUENCY_ATTR_MAX + 1];
6261 int rem_rule;
6262 static struct nla_policy reg_policy[NL80211_FREQUENCY_ATTR_MAX + 1] = {
6263 [NL80211_ATTR_REG_RULE_FLAGS] = { .type = NLA_U32 },
6264 [NL80211_ATTR_FREQ_RANGE_START] = { .type = NLA_U32 },
6265 [NL80211_ATTR_FREQ_RANGE_END] = { .type = NLA_U32 },
6266 [NL80211_ATTR_FREQ_RANGE_MAX_BW] = { .type = NLA_U32 },
6267 [NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN] = { .type = NLA_U32 },
6268 [NL80211_ATTR_POWER_RULE_MAX_EIRP] = { .type = NLA_U32 },
6269 };
6270
6271 nla_parse(tb_msg, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
6272 genlmsg_attrlen(gnlh, 0), NULL);
6273 if (!tb_msg[NL80211_ATTR_REG_ALPHA2] ||
6274 !tb_msg[NL80211_ATTR_REG_RULES]) {
6275 wpa_printf(MSG_DEBUG, "nl80211: No regulatory information "
6276 "available");
6277 return NL_SKIP;
6278 }
6279
6280 wpa_printf(MSG_DEBUG, "nl80211: Regulatory information - country=%s",
6281 (char *) nla_data(tb_msg[NL80211_ATTR_REG_ALPHA2]));
6282
6283 nla_for_each_nested(nl_rule, tb_msg[NL80211_ATTR_REG_RULES], rem_rule)
6284 {
6285 nla_parse(tb_rule, NL80211_FREQUENCY_ATTR_MAX,
6286 nla_data(nl_rule), nla_len(nl_rule), reg_policy);
6287 nl80211_reg_rule_ht40(tb_rule, results);
6651f1f9 6288 nl80211_reg_rule_max_eirp(tb_rule, results);
d8e66e80
JM		 6289 }
6290
6291 nla_for_each_nested(nl_rule, tb_msg[NL80211_ATTR_REG_RULES], rem_rule)
6292 {
6293 nla_parse(tb_rule, NL80211_FREQUENCY_ATTR_MAX,
6294 nla_data(nl_rule), nla_len(nl_rule), reg_policy);
6295 nl80211_reg_rule_sec(tb_rule, results);
6296 }
6297
53cfad46
EP		 6298 nla_for_each_nested(nl_rule, tb_msg[NL80211_ATTR_REG_RULES], rem_rule)
6299 {
6300 nla_parse(tb_rule, NL80211_FREQUENCY_ATTR_MAX,
6301 nla_data(nl_rule), nla_len(nl_rule), reg_policy);
6302 nl80211_reg_rule_vht(tb_rule, results);
6303 }
6304
d8e66e80
JM		 6305 return NL_SKIP;
6306}
6307
6308
53cfad46
EP		 6309static int nl80211_set_regulatory_flags(struct wpa_driver_nl80211_data *drv,
6310 struct phy_info_arg *results)
d8e66e80
JM		 6311{
6312 struct nl_msg *msg;
6313
6314 msg = nlmsg_alloc();
6315 if (!msg)
6316 return -ENOMEM;
6317
9fb04070 6318 nl80211_cmd(drv, msg, 0, NL80211_CMD_GET_REG);
d8e66e80
JM		 6319 return send_and_recv_msgs(drv, msg, nl80211_get_reg, results);
6320}
6321
6322
282d5590
JM		 6323static struct hostapd_hw_modes *
6324wpa_driver_nl80211_get_hw_feature_data(void *priv, u16 *num_modes, u16 *flags)
6325{
43245552 6326 u32 feat;
a2e40bb6
FF		 6327 struct i802_bss *bss = priv;
6328 struct wpa_driver_nl80211_data *drv = bss->drv;
282d5590
JM		 6329 struct nl_msg *msg;
6330 struct phy_info_arg result = {
6331 .num_modes = num_modes,
6332 .modes = NULL,
43245552 6333 .last_mode = -1,
282d5590
JM		 6334 };
6335
6336 *num_modes = 0;
6337 *flags = 0;
6338
6339 msg = nlmsg_alloc();
6340 if (!msg)
6341 return NULL;
6342
43245552
DJ		 6343 feat = get_nl80211_protocol_features(drv);
6344 if (feat & NL80211_PROTOCOL_FEATURE_SPLIT_WIPHY_DUMP)
6345 nl80211_cmd(drv, msg, NLM_F_DUMP, NL80211_CMD_GET_WIPHY);
6346 else
6347 nl80211_cmd(drv, msg, 0, NL80211_CMD_GET_WIPHY);
282d5590 6348
43245552 6349 NLA_PUT_FLAG(msg, NL80211_ATTR_SPLIT_WIPHY_DUMP);
282d5590
JM		 6350 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
6351
d8e66e80 6352 if (send_and_recv_msgs(drv, msg, phy_info_handler, &result) == 0) {
53cfad46 6353 nl80211_set_regulatory_flags(drv, &result);
c30a4ab0
JB		 6354 return wpa_driver_nl80211_postprocess_modes(result.modes,
6355 num_modes);
d8e66e80 6356 }
5883168a 6357 msg = NULL;
282d5590 6358 nla_put_failure:
5883168a 6359 nlmsg_free(msg);
282d5590
JM		 6360 return NULL;
6361}
6362
6363
a11241fa
JB		 6364static int wpa_driver_nl80211_send_mntr(struct wpa_driver_nl80211_data *drv,
6365 const void *data, size_t len,
6366 int encrypt, int noack)
2c2010ac
JM		 6367{
6368 __u8 rtap_hdr[] = {
6369 0x00, 0x00, /* radiotap version */
6370 0x0e, 0x00, /* radiotap length */
6371 0x02, 0xc0, 0x00, 0x00, /* bmap: flags, tx and rx flags */
6372 IEEE80211_RADIOTAP_F_FRAG, /* F_FRAG (fragment if required) */
6373 0x00, /* padding */
6374 0x00, 0x00, /* RX and TX flags to indicate that */
6375 0x00, 0x00, /* this is the injected frame directly */
6376 };
6377 struct iovec iov[2] = {
6378 {
6379 .iov_base = &rtap_hdr,
6380 .iov_len = sizeof(rtap_hdr),
6381 },
6382 {
6383 .iov_base = (void *) data,
6384 .iov_len = len,
6385 }
6386 };
6387 struct msghdr msg = {
6388 .msg_name = NULL,
6389 .msg_namelen = 0,
6390 .msg_iov = iov,
6391 .msg_iovlen = 2,
6392 .msg_control = NULL,
6393 .msg_controllen = 0,
6394 .msg_flags = 0,
6395 };
ebbec8b2 6396 int res;
fab25336 6397 u16 txflags = 0;
2c2010ac
JM		 6398
6399 if (encrypt)
6400 rtap_hdr[8] |= IEEE80211_RADIOTAP_F_WEP;
6401
866af8b6
JM		 6402 if (drv->monitor_sock < 0) {
6403 wpa_printf(MSG_DEBUG, "nl80211: No monitor socket available "
6404 "for %s", __func__);
6405 return -1;
6406 }
6407
fab25336
HS		 6408 if (noack)
6409 txflags |= IEEE80211_RADIOTAP_F_TX_NOACK;
9d7a63dc 6410 WPA_PUT_LE16(&rtap_hdr[12], txflags);
fab25336 6411
ebbec8b2
JM		 6412 res = sendmsg(drv->monitor_sock, &msg, 0);
6413 if (res < 0) {
6414 wpa_printf(MSG_INFO, "nl80211: sendmsg: %s", strerror(errno));
6415 return -1;
6416 }
6417 return 0;
2c2010ac
JM		 6418}
6419
6420
a11241fa
JB		 6421static int wpa_driver_nl80211_send_frame(struct i802_bss *bss,
6422 const void *data, size_t len,
55231068
JM		 6423 int encrypt, int noack,
6424 unsigned int freq, int no_cck,
6425 int offchanok, unsigned int wait_time)
a11241fa
JB		 6426{
6427 struct wpa_driver_nl80211_data *drv = bss->drv;
6428 u64 cookie;
41cc50d1 6429 int res;
a11241fa 6430
af964484
JM		 6431 if (freq == 0) {
6432 wpa_printf(MSG_DEBUG, "nl80211: send_frame - Use bss->freq=%u",
6433 bss->freq);
55231068 6434 freq = bss->freq;
af964484 6435 }
55231068 6436
739faee2
JM		 6437 if (drv->use_monitor) {
6438 wpa_printf(MSG_DEBUG, "nl80211: send_frame(freq=%u bss->freq=%u) -> send_mntr",
6439 freq, bss->freq);
a11241fa
JB		 6440 return wpa_driver_nl80211_send_mntr(drv, data, len,
6441 encrypt, noack);
739faee2 6442 }
a11241fa 6443
739faee2 6444 wpa_printf(MSG_DEBUG, "nl80211: send_frame -> send_frame_cmd");
41cc50d1
JM		 6445 res = nl80211_send_frame_cmd(bss, freq, wait_time, data, len,
6446 &cookie, no_cck, noack, offchanok);
6447 if (res == 0 && !noack) {
6448 const struct ieee80211_mgmt *mgmt;
6449 u16 fc;
6450
6451 mgmt = (const struct ieee80211_mgmt *) data;
6452 fc = le_to_host16(mgmt->frame_control);
6453 if (WLAN_FC_GET_TYPE(fc) == WLAN_FC_TYPE_MGMT &&
6454 WLAN_FC_GET_STYPE(fc) == WLAN_FC_STYPE_ACTION) {
6455 wpa_printf(MSG_MSGDUMP,
6456 "nl80211: Update send_action_cookie from 0x%llx to 0x%llx",
6457 (long long unsigned int)
6458 drv->send_action_cookie,
6459 (long long unsigned int) cookie);
6460 drv->send_action_cookie = cookie;
6461 }
6462 }
6463
6464 return res;
a11241fa
JB		 6465}
6466
6467
9ebce9c5
JM		 6468static int wpa_driver_nl80211_send_mlme(struct i802_bss *bss, const u8 *data,
6469 size_t data_len, int noack,
6470 unsigned int freq, int no_cck,
6471 int offchanok,
6472 unsigned int wait_time)
2c2010ac 6473{
a2e40bb6 6474 struct wpa_driver_nl80211_data *drv = bss->drv;
2c2010ac 6475 struct ieee80211_mgmt *mgmt;
7a47d567 6476 int encrypt = 1;
2c2010ac
JM		 6477 u16 fc;
6478
6479 mgmt = (struct ieee80211_mgmt *) data;
6480 fc = le_to_host16(mgmt->frame_control);
af964484
JM		 6481 wpa_printf(MSG_DEBUG, "nl80211: send_mlme - noack=%d freq=%u no_cck=%d offchanok=%d wait_time=%u fc=0x%x nlmode=%d",
6482 noack, freq, no_cck, offchanok, wait_time, fc, drv->nlmode);
2c2010ac 6483
8e12685c
AS		 6484 if ((is_sta_interface(drv->nlmode) ||
6485 drv->nlmode == NL80211_IFTYPE_P2P_DEVICE) &&
5582a5d1
JB		 6486 WLAN_FC_GET_TYPE(fc) == WLAN_FC_TYPE_MGMT &&
6487 WLAN_FC_GET_STYPE(fc) == WLAN_FC_STYPE_PROBE_RESP) {
6488 /*
6489 * The use of last_mgmt_freq is a bit of a hack,
6490 * but it works due to the single-threaded nature
6491 * of wpa_supplicant.
6492 */
af964484
JM		 6493 if (freq == 0) {
6494 wpa_printf(MSG_DEBUG, "nl80211: Use last_mgmt_freq=%d",
6495 drv->last_mgmt_freq);
55231068 6496 freq = drv->last_mgmt_freq;
af964484 6497 }
55231068 6498 return nl80211_send_frame_cmd(bss, freq, 0,
88df0ef7
JB		 6499 data, data_len, NULL, 1, noack,
6500 1);
5582a5d1
JB		 6501 }
6502
61cbe2ff 6503 if (drv->device_ap_sme && is_ap_interface(drv->nlmode)) {
af964484
JM		 6504 if (freq == 0) {
6505 wpa_printf(MSG_DEBUG, "nl80211: Use bss->freq=%d",
6506 bss->freq);
55231068 6507 freq = bss->freq;
af964484 6508 }
b5671498
JM		 6509 return nl80211_send_frame_cmd(bss, freq,
6510 (int) freq == bss->freq ? 0 :
6511 wait_time,
d8d6b32e
DG		 6512 data, data_len,
6513 &drv->send_action_cookie,
55231068 6514 no_cck, noack, offchanok);
86957e62
JM		 6515 }
6516
2c2010ac
JM		 6517 if (WLAN_FC_GET_TYPE(fc) == WLAN_FC_TYPE_MGMT &&
6518 WLAN_FC_GET_STYPE(fc) == WLAN_FC_STYPE_AUTH) {
6519 /*
6520 * Only one of the authentication frame types is encrypted.
6521 * In order for static WEP encryption to work properly (i.e.,
6522 * to not encrypt the frame), we need to tell mac80211 about
6523 * the frames that must not be encrypted.
6524 */
6525 u16 auth_alg = le_to_host16(mgmt->u.auth.auth_alg);
6526 u16 auth_trans = le_to_host16(mgmt->u.auth.auth_transaction);
7a47d567
JB		 6527 if (auth_alg != WLAN_AUTH_SHARED_KEY || auth_trans != 3)
6528 encrypt = 0;
2c2010ac
JM		 6529 }
6530
739faee2 6531 wpa_printf(MSG_DEBUG, "nl80211: send_mlme -> send_frame");
a11241fa 6532 return wpa_driver_nl80211_send_frame(bss, data, data_len, encrypt,
55231068
JM		 6533 noack, freq, no_cck, offchanok,
6534 wait_time);
6535}
6536
6537
31357268 6538static int nl80211_set_bss(struct i802_bss *bss, int cts, int preamble,
e5693c47
JM		 6539 int slot, int ht_opmode, int ap_isolate,
6540 int *basic_rates)
31357268
JM		 6541{
6542 struct wpa_driver_nl80211_data *drv = bss->drv;
6543 struct nl_msg *msg;
6544
6545 msg = nlmsg_alloc();
6546 if (!msg)
6547 return -ENOMEM;
6548
9fb04070 6549 nl80211_cmd(drv, msg, 0, NL80211_CMD_SET_BSS);
31357268
JM		 6550
6551 if (cts >= 0)
6552 NLA_PUT_U8(msg, NL80211_ATTR_BSS_CTS_PROT, cts);
6553 if (preamble >= 0)
6554 NLA_PUT_U8(msg, NL80211_ATTR_BSS_SHORT_PREAMBLE, preamble);
6555 if (slot >= 0)
6556 NLA_PUT_U8(msg, NL80211_ATTR_BSS_SHORT_SLOT_TIME, slot);
6557 if (ht_opmode >= 0)
6558 NLA_PUT_U16(msg, NL80211_ATTR_BSS_HT_OPMODE, ht_opmode);
d03e8d11
JM		 6559 if (ap_isolate >= 0)
6560 NLA_PUT_U8(msg, NL80211_ATTR_AP_ISOLATE, ap_isolate);
e5693c47
JM		 6561
6562 if (basic_rates) {
6563 u8 rates[NL80211_MAX_SUPP_RATES];
6564 u8 rates_len = 0;
6565 int i;
6566
6567 for (i = 0; i < NL80211_MAX_SUPP_RATES && basic_rates[i] >= 0;
6568 i++)
6569 rates[rates_len++] = basic_rates[i] / 5;
6570
6571 NLA_PUT(msg, NL80211_ATTR_BSS_BASIC_RATES, rates_len, rates);
6572 }
6573
31357268
JM		 6574 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, if_nametoindex(bss->ifname));
6575
6576 return send_and_recv_msgs(drv, msg, NULL, NULL);
6577 nla_put_failure:
5883168a 6578 nlmsg_free(msg);
31357268
JM		 6579 return -ENOBUFS;
6580}
6581
6582
3c4ca363
VN		 6583static int wpa_driver_nl80211_set_acl(void *priv,
6584 struct hostapd_acl_params *params)
6585{
6586 struct i802_bss *bss = priv;
6587 struct wpa_driver_nl80211_data *drv = bss->drv;
6588 struct nl_msg *msg;
6589 struct nlattr *acl;
6590 unsigned int i;
6591 int ret = 0;
6592
6593 if (!(drv->capa.max_acl_mac_addrs))
6594 return -ENOTSUP;
6595
6596 if (params->num_mac_acl > drv->capa.max_acl_mac_addrs)
6597 return -ENOTSUP;
6598
6599 msg = nlmsg_alloc();
6600 if (!msg)
6601 return -ENOMEM;
6602
6603 wpa_printf(MSG_DEBUG, "nl80211: Set %s ACL (num_mac_acl=%u)",
6604 params->acl_policy ? "Accept" : "Deny", params->num_mac_acl);
6605
6606 nl80211_cmd(drv, msg, 0, NL80211_CMD_SET_MAC_ACL);
6607
6608 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
6609
6610 NLA_PUT_U32(msg, NL80211_ATTR_ACL_POLICY, params->acl_policy ?
6611 NL80211_ACL_POLICY_DENY_UNLESS_LISTED :
6612 NL80211_ACL_POLICY_ACCEPT_UNLESS_LISTED);
6613
6614 acl = nla_nest_start(msg, NL80211_ATTR_MAC_ADDRS);
6615 if (acl == NULL)
6616 goto nla_put_failure;
6617
6618 for (i = 0; i < params->num_mac_acl; i++)
6619 NLA_PUT(msg, i + 1, ETH_ALEN, params->mac_acl[i].addr);
6620
6621 nla_nest_end(msg, acl);
6622
6623 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
6624 msg = NULL;
6625 if (ret) {
6626 wpa_printf(MSG_DEBUG, "nl80211: Failed to set MAC ACL: %d (%s)",
6627 ret, strerror(-ret));
6628 }
6629
6630nla_put_failure:
6631 nlmsg_free(msg);
6632
6633 return ret;
6634}
6635
6636
19c3b566
JM		 6637static int wpa_driver_nl80211_set_ap(void *priv,
6638 struct wpa_driver_ap_params *params)
d2440ba0 6639{
a2e40bb6
FF		 6640 struct i802_bss *bss = priv;
6641 struct wpa_driver_nl80211_data *drv = bss->drv;
d2440ba0
JM		 6642 struct nl_msg *msg;
6643 u8 cmd = NL80211_CMD_NEW_BEACON;
6644 int ret;
b4fd6fab 6645 int beacon_set;
8b897f5a 6646 int ifindex = if_nametoindex(bss->ifname);
b11d1d64
JM		 6647 int num_suites;
6648 u32 suites[10];
6649 u32 ver;
b4fd6fab 6650
b4fd6fab 6651 beacon_set = bss->beacon_set;
d2440ba0
JM		 6652
6653 msg = nlmsg_alloc();
6654 if (!msg)
6655 return -ENOMEM;
6656
6657 wpa_printf(MSG_DEBUG, "nl80211: Set beacon (beacon_set=%d)",
b4fd6fab
JM		 6658 beacon_set);
6659 if (beacon_set)
d2440ba0
JM		 6660 cmd = NL80211_CMD_SET_BEACON;
6661
9fb04070 6662 nl80211_cmd(drv, msg, 0, cmd);
b92e08fc
JM		 6663 wpa_hexdump(MSG_DEBUG, "nl80211: Beacon head",
6664 params->head, params->head_len);
19c3b566 6665 NLA_PUT(msg, NL80211_ATTR_BEACON_HEAD, params->head_len, params->head);
b92e08fc
JM		 6666 wpa_hexdump(MSG_DEBUG, "nl80211: Beacon tail",
6667 params->tail, params->tail_len);
19c3b566 6668 NLA_PUT(msg, NL80211_ATTR_BEACON_TAIL, params->tail_len, params->tail);
b92e08fc 6669 wpa_printf(MSG_DEBUG, "nl80211: ifindex=%d", ifindex);
b4fd6fab 6670 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, ifindex);
b92e08fc 6671 wpa_printf(MSG_DEBUG, "nl80211: beacon_int=%d", params->beacon_int);
19c3b566 6672 NLA_PUT_U32(msg, NL80211_ATTR_BEACON_INTERVAL, params->beacon_int);
b92e08fc 6673 wpa_printf(MSG_DEBUG, "nl80211: dtim_period=%d", params->dtim_period);
19c3b566 6674 NLA_PUT_U32(msg, NL80211_ATTR_DTIM_PERIOD, params->dtim_period);
b92e08fc
JM		 6675 wpa_hexdump_ascii(MSG_DEBUG, "nl80211: ssid",
6676 params->ssid, params->ssid_len);
ccb941e6
JM		 6677 NLA_PUT(msg, NL80211_ATTR_SSID, params->ssid_len,
6678 params->ssid);
b92e08fc
JM		 6679 if (params->proberesp && params->proberesp_len) {
6680 wpa_hexdump(MSG_DEBUG, "nl80211: proberesp (offload)",
6681 params->proberesp, params->proberesp_len);
5ed33546
AN		 6682 NLA_PUT(msg, NL80211_ATTR_PROBE_RESP, params->proberesp_len,
6683 params->proberesp);
b92e08fc 6684 }
97a7a0b5
JM		 6685 switch (params->hide_ssid) {
6686 case NO_SSID_HIDING:
b92e08fc 6687 wpa_printf(MSG_DEBUG, "nl80211: hidden SSID not in use");
97a7a0b5
JM		 6688 NLA_PUT_U32(msg, NL80211_ATTR_HIDDEN_SSID,
6689 NL80211_HIDDEN_SSID_NOT_IN_USE);
6690 break;
6691 case HIDDEN_SSID_ZERO_LEN:
b92e08fc 6692 wpa_printf(MSG_DEBUG, "nl80211: hidden SSID zero len");
97a7a0b5
JM		 6693 NLA_PUT_U32(msg, NL80211_ATTR_HIDDEN_SSID,
6694 NL80211_HIDDEN_SSID_ZERO_LEN);
6695 break;
6696 case HIDDEN_SSID_ZERO_CONTENTS:
b92e08fc 6697 wpa_printf(MSG_DEBUG, "nl80211: hidden SSID zero contents");
97a7a0b5
JM		 6698 NLA_PUT_U32(msg, NL80211_ATTR_HIDDEN_SSID,
6699 NL80211_HIDDEN_SSID_ZERO_CONTENTS);
6700 break;
6701 }
b92e08fc 6702 wpa_printf(MSG_DEBUG, "nl80211: privacy=%d", params->privacy);
b11d1d64
JM		 6703 if (params->privacy)
6704 NLA_PUT_FLAG(msg, NL80211_ATTR_PRIVACY);
b92e08fc 6705 wpa_printf(MSG_DEBUG, "nl80211: auth_algs=0x%x", params->auth_algs);
b11d1d64
JM		 6706 if ((params->auth_algs & (WPA_AUTH_ALG_OPEN | WPA_AUTH_ALG_SHARED)) ==
6707 (WPA_AUTH_ALG_OPEN | WPA_AUTH_ALG_SHARED)) {
6708 /* Leave out the attribute */
6709 } else if (params->auth_algs & WPA_AUTH_ALG_SHARED)
6710 NLA_PUT_U32(msg, NL80211_ATTR_AUTH_TYPE,
6711 NL80211_AUTHTYPE_SHARED_KEY);
6712 else
6713 NLA_PUT_U32(msg, NL80211_ATTR_AUTH_TYPE,
6714 NL80211_AUTHTYPE_OPEN_SYSTEM);
6715
b92e08fc 6716 wpa_printf(MSG_DEBUG, "nl80211: wpa_version=0x%x", params->wpa_version);
b11d1d64
JM		 6717 ver = 0;
6718 if (params->wpa_version & WPA_PROTO_WPA)
6719 ver |= NL80211_WPA_VERSION_1;
6720 if (params->wpa_version & WPA_PROTO_RSN)
6721 ver |= NL80211_WPA_VERSION_2;
6722 if (ver)
6723 NLA_PUT_U32(msg, NL80211_ATTR_WPA_VERSIONS, ver);
6724
b92e08fc
JM		 6725 wpa_printf(MSG_DEBUG, "nl80211: key_mgmt_suites=0x%x",
6726 params->key_mgmt_suites);
b11d1d64
JM		 6727 num_suites = 0;
6728 if (params->key_mgmt_suites & WPA_KEY_MGMT_IEEE8021X)
6729 suites[num_suites++] = WLAN_AKM_SUITE_8021X;
6730 if (params->key_mgmt_suites & WPA_KEY_MGMT_PSK)
6731 suites[num_suites++] = WLAN_AKM_SUITE_PSK;
6732 if (num_suites) {
6733 NLA_PUT(msg, NL80211_ATTR_AKM_SUITES,
6734 num_suites * sizeof(u32), suites);
6735 }
6736
9f12614b
JB		 6737 if (params->key_mgmt_suites & WPA_KEY_MGMT_IEEE8021X &&
6738 params->pairwise_ciphers & (WPA_CIPHER_WEP104 | WPA_CIPHER_WEP40))
6739 NLA_PUT_FLAG(msg, NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT);
6740
b92e08fc
JM		 6741 wpa_printf(MSG_DEBUG, "nl80211: pairwise_ciphers=0x%x",
6742 params->pairwise_ciphers);
b11d1d64
JM		 6743 num_suites = 0;
6744 if (params->pairwise_ciphers & WPA_CIPHER_CCMP)
6745 suites[num_suites++] = WLAN_CIPHER_SUITE_CCMP;
eb7719ff
JM		 6746 if (params->pairwise_ciphers & WPA_CIPHER_GCMP)
6747 suites[num_suites++] = WLAN_CIPHER_SUITE_GCMP;
b11d1d64
JM		 6748 if (params->pairwise_ciphers & WPA_CIPHER_TKIP)
6749 suites[num_suites++] = WLAN_CIPHER_SUITE_TKIP;
6750 if (params->pairwise_ciphers & WPA_CIPHER_WEP104)
6751 suites[num_suites++] = WLAN_CIPHER_SUITE_WEP104;
6752 if (params->pairwise_ciphers & WPA_CIPHER_WEP40)
6753 suites[num_suites++] = WLAN_CIPHER_SUITE_WEP40;
6754 if (num_suites) {
6755 NLA_PUT(msg, NL80211_ATTR_CIPHER_SUITES_PAIRWISE,
6756 num_suites * sizeof(u32), suites);
6757 }
6758
b92e08fc
JM		 6759 wpa_printf(MSG_DEBUG, "nl80211: group_cipher=0x%x",
6760 params->group_cipher);
b11d1d64
JM		 6761 switch (params->group_cipher) {
6762 case WPA_CIPHER_CCMP:
6763 NLA_PUT_U32(msg, NL80211_ATTR_CIPHER_SUITE_GROUP,
6764 WLAN_CIPHER_SUITE_CCMP);
6765 break;
eb7719ff
JM		 6766 case WPA_CIPHER_GCMP:
6767 NLA_PUT_U32(msg, NL80211_ATTR_CIPHER_SUITE_GROUP,
6768 WLAN_CIPHER_SUITE_GCMP);
6769 break;
b11d1d64
JM		 6770 case WPA_CIPHER_TKIP:
6771 NLA_PUT_U32(msg, NL80211_ATTR_CIPHER_SUITE_GROUP,
6772 WLAN_CIPHER_SUITE_TKIP);
6773 break;
6774 case WPA_CIPHER_WEP104:
6775 NLA_PUT_U32(msg, NL80211_ATTR_CIPHER_SUITE_GROUP,
6776 WLAN_CIPHER_SUITE_WEP104);
6777 break;
6778 case WPA_CIPHER_WEP40:
6779 NLA_PUT_U32(msg, NL80211_ATTR_CIPHER_SUITE_GROUP,
6780 WLAN_CIPHER_SUITE_WEP40);
6781 break;
6782 }
d2440ba0 6783
fb91db56 6784 if (params->beacon_ies) {
b92e08fc
JM		 6785 wpa_hexdump_buf(MSG_DEBUG, "nl80211: beacon_ies",
6786 params->beacon_ies);
fb91db56
JM		 6787 NLA_PUT(msg, NL80211_ATTR_IE, wpabuf_len(params->beacon_ies),
6788 wpabuf_head(params->beacon_ies));
6789 }
6790 if (params->proberesp_ies) {
b92e08fc
JM		 6791 wpa_hexdump_buf(MSG_DEBUG, "nl80211: proberesp_ies",
6792 params->proberesp_ies);
fb91db56
JM		 6793 NLA_PUT(msg, NL80211_ATTR_IE_PROBE_RESP,
6794 wpabuf_len(params->proberesp_ies),
6795 wpabuf_head(params->proberesp_ies));
6796 }
6797 if (params->assocresp_ies) {
b92e08fc
JM		 6798 wpa_hexdump_buf(MSG_DEBUG, "nl80211: assocresp_ies",
6799 params->assocresp_ies);
fb91db56
JM		 6800 NLA_PUT(msg, NL80211_ATTR_IE_ASSOC_RESP,
6801 wpabuf_len(params->assocresp_ies),
6802 wpabuf_head(params->assocresp_ies));
6803 }
6804
a0133ee1 6805 if (drv->capa.flags & WPA_DRIVER_FLAGS_INACTIVITY_TIMER) {
b92e08fc
JM		 6806 wpa_printf(MSG_DEBUG, "nl80211: ap_max_inactivity=%d",
6807 params->ap_max_inactivity);
a0133ee1
VT		 6808 NLA_PUT_U16(msg, NL80211_ATTR_INACTIVITY_TIMEOUT,
6809 params->ap_max_inactivity);
6810 }
6811
d2440ba0
JM		 6812 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
6813 if (ret) {
6814 wpa_printf(MSG_DEBUG, "nl80211: Beacon set failed: %d (%s)",
6815 ret, strerror(-ret));
b4fd6fab 6816 } else {
b4fd6fab 6817 bss->beacon_set = 1;
31357268 6818 nl80211_set_bss(bss, params->cts_protect, params->preamble,
d03e8d11 6819 params->short_slot_time, params->ht_opmode,
e5693c47 6820 params->isolate, params->basic_rates);
b4fd6fab 6821 }
d2440ba0
JM		 6822 return ret;
6823 nla_put_failure:
5883168a 6824 nlmsg_free(msg);
d2440ba0
JM		 6825 return -ENOBUFS;
6826}
6827
6828
1c4ffa87
AO		 6829static int nl80211_put_freq_params(struct nl_msg *msg,
6830 struct hostapd_freq_params *freq)
1581b38b 6831{
89b800d7
JB		 6832 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_FREQ, freq->freq);
6833 if (freq->vht_enabled) {
6834 switch (freq->bandwidth) {
6835 case 20:
6836 NLA_PUT_U32(msg, NL80211_ATTR_CHANNEL_WIDTH,
6837 NL80211_CHAN_WIDTH_20);
6838 break;
6839 case 40:
6840 NLA_PUT_U32(msg, NL80211_ATTR_CHANNEL_WIDTH,
6841 NL80211_CHAN_WIDTH_40);
6842 break;
6843 case 80:
6844 if (freq->center_freq2)
6845 NLA_PUT_U32(msg, NL80211_ATTR_CHANNEL_WIDTH,
6846 NL80211_CHAN_WIDTH_80P80);
6847 else
6848 NLA_PUT_U32(msg, NL80211_ATTR_CHANNEL_WIDTH,
6849 NL80211_CHAN_WIDTH_80);
6850 break;
6851 case 160:
6852 NLA_PUT_U32(msg, NL80211_ATTR_CHANNEL_WIDTH,
6853 NL80211_CHAN_WIDTH_160);
6854 break;
6855 default:
1c4ffa87 6856 return -EINVAL;
89b800d7
JB		 6857 }
6858 NLA_PUT_U32(msg, NL80211_ATTR_CENTER_FREQ1, freq->center_freq1);
6859 if (freq->center_freq2)
6860 NLA_PUT_U32(msg, NL80211_ATTR_CENTER_FREQ2,
6861 freq->center_freq2);
6862 } else if (freq->ht_enabled) {
6863 switch (freq->sec_channel_offset) {
f019981a
JM		 6864 case -1:
6865 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE,
6866 NL80211_CHAN_HT40MINUS);
6867 break;
6868 case 1:
6869 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE,
6870 NL80211_CHAN_HT40PLUS);
6871 break;
6872 default:
6873 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE,
6874 NL80211_CHAN_HT20);
6875 break;
6876 }
6877 }
1c4ffa87
AO		 6878 return 0;
6879
6880nla_put_failure:
6881 return -ENOBUFS;
6882}
6883
6884
6885static int wpa_driver_nl80211_set_freq(struct i802_bss *bss,
6886 struct hostapd_freq_params *freq)
6887{
6888 struct wpa_driver_nl80211_data *drv = bss->drv;
6889 struct nl_msg *msg;
6890 int ret;
6891
6892 wpa_printf(MSG_DEBUG,
6893 "nl80211: Set freq %d (ht_enabled=%d, vht_enabled=%d, bandwidth=%d MHz, cf1=%d MHz, cf2=%d MHz)",
6894 freq->freq, freq->ht_enabled, freq->vht_enabled,
6895 freq->bandwidth, freq->center_freq1, freq->center_freq2);
6896 msg = nlmsg_alloc();
6897 if (!msg)
6898 return -1;
6899
6900 nl80211_cmd(drv, msg, 0, NL80211_CMD_SET_WIPHY);
6901
6902 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
6903 if (nl80211_put_freq_params(msg, freq) < 0)
6904 goto nla_put_failure;
1581b38b 6905
d2440ba0 6906 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
5883168a 6907 msg = NULL;
e4fb2167 6908 if (ret == 0) {
89b800d7 6909 bss->freq = freq->freq;
1581b38b 6910 return 0;
e4fb2167 6911 }
f019981a 6912 wpa_printf(MSG_DEBUG, "nl80211: Failed to set channel (freq=%d): "
89b800d7 6913 "%d (%s)", freq->freq, ret, strerror(-ret));
1581b38b 6914nla_put_failure:
5883168a 6915 nlmsg_free(msg);
1581b38b
JM		 6916 return -1;
6917}
6918
0f4e8b4f 6919
95ab6063
AN		 6920static u32 sta_flags_nl80211(int flags)
6921{
6922 u32 f = 0;
6923
6924 if (flags & WPA_STA_AUTHORIZED)
6925 f |= BIT(NL80211_STA_FLAG_AUTHORIZED);
6926 if (flags & WPA_STA_WMM)
6927 f |= BIT(NL80211_STA_FLAG_WME);
6928 if (flags & WPA_STA_SHORT_PREAMBLE)
6929 f |= BIT(NL80211_STA_FLAG_SHORT_PREAMBLE);
6930 if (flags & WPA_STA_MFP)
6931 f |= BIT(NL80211_STA_FLAG_MFP);
45b722f1
AN		 6932 if (flags & WPA_STA_TDLS_PEER)
6933 f |= BIT(NL80211_STA_FLAG_TDLS_PEER);
95ab6063
AN		 6934
6935 return f;
6936}
6937
6938
62847751 6939static int wpa_driver_nl80211_sta_add(void *priv,
0f4e8b4f
JM		 6940 struct hostapd_sta_add_params *params)
6941{
a2e40bb6
FF		 6942 struct i802_bss *bss = priv;
6943 struct wpa_driver_nl80211_data *drv = bss->drv;
8970bae8 6944 struct nl_msg *msg;
95ab6063 6945 struct nl80211_sta_flag_update upd;
0f4e8b4f
JM		 6946 int ret = -ENOBUFS;
6947
45b722f1
AN		 6948 if ((params->flags & WPA_STA_TDLS_PEER) &&
6949 !(drv->capa.flags & WPA_DRIVER_FLAGS_TDLS_SUPPORT))
6950 return -EOPNOTSUPP;
6951
0f4e8b4f
JM		 6952 msg = nlmsg_alloc();
6953 if (!msg)
6954 return -ENOMEM;
6955
e4dea253
JM		 6956 wpa_printf(MSG_DEBUG, "nl80211: %s STA " MACSTR,
6957 params->set ? "Set" : "Add", MAC2STR(params->addr));
45b722f1
AN		 6958 nl80211_cmd(drv, msg, 0, params->set ? NL80211_CMD_SET_STATION :
6959 NL80211_CMD_NEW_STATION);
0f4e8b4f 6960
62847751 6961 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, if_nametoindex(bss->ifname));
0f4e8b4f 6962 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, params->addr);
0f4e8b4f
JM		 6963 NLA_PUT(msg, NL80211_ATTR_STA_SUPPORTED_RATES, params->supp_rates_len,
6964 params->supp_rates);
e4dea253
JM		 6965 wpa_hexdump(MSG_DEBUG, " * supported rates", params->supp_rates,
6966 params->supp_rates_len);
45b722f1 6967 if (!params->set) {
f11b72c3
JM		 6968 if (params->aid) {
6969 wpa_printf(MSG_DEBUG, " * aid=%u", params->aid);
6970 NLA_PUT_U16(msg, NL80211_ATTR_STA_AID, params->aid);
6971 } else {
6972 /*
6973 * cfg80211 validates that AID is non-zero, so we have
6974 * to make this a non-zero value for the TDLS case where
6975 * a dummy STA entry is used for now.
6976 */
6977 wpa_printf(MSG_DEBUG, " * aid=1 (TDLS workaround)");
6978 NLA_PUT_U16(msg, NL80211_ATTR_STA_AID, 1);
6979 }
e4dea253
JM		 6980 wpa_printf(MSG_DEBUG, " * listen_interval=%u",
6981 params->listen_interval);
45b722f1
AN		 6982 NLA_PUT_U16(msg, NL80211_ATTR_STA_LISTEN_INTERVAL,
6983 params->listen_interval);
e112764e
JM		 6984 } else if (params->aid && (params->flags & WPA_STA_TDLS_PEER)) {
6985 wpa_printf(MSG_DEBUG, " * peer_aid=%u", params->aid);
6986 NLA_PUT_U16(msg, NL80211_ATTR_PEER_AID, params->aid);
45b722f1 6987 }
0f4e8b4f 6988 if (params->ht_capabilities) {
e4dea253
JM		 6989 wpa_hexdump(MSG_DEBUG, " * ht_capabilities",
6990 (u8 *) params->ht_capabilities,
6991 sizeof(*params->ht_capabilities));
0f4e8b4f 6992 NLA_PUT(msg, NL80211_ATTR_HT_CAPABILITY,
fc4e2d95
JM		 6993 sizeof(*params->ht_capabilities),
6994 params->ht_capabilities);
0f4e8b4f 6995 }
0f4e8b4f 6996
05a8d422 6997 if (params->vht_capabilities) {
e4dea253
JM		 6998 wpa_hexdump(MSG_DEBUG, " * vht_capabilities",
6999 (u8 *) params->vht_capabilities,
7000 sizeof(*params->vht_capabilities));
05a8d422
JB		 7001 NLA_PUT(msg, NL80211_ATTR_VHT_CAPABILITY,
7002 sizeof(*params->vht_capabilities),
7003 params->vht_capabilities);
7004 }
7005
122d16f2
SD		 7006 wpa_printf(MSG_DEBUG, " * capability=0x%x", params->capability);
7007 NLA_PUT_U16(msg, NL80211_ATTR_STA_CAPABILITY, params->capability);
7008
7009 if (params->ext_capab) {
7010 wpa_hexdump(MSG_DEBUG, " * ext_capab",
7011 params->ext_capab, params->ext_capab_len);
7012 NLA_PUT(msg, NL80211_ATTR_STA_EXT_CAPABILITY,
7013 params->ext_capab_len, params->ext_capab);
7014 }
7015
95ab6063
AN		 7016 os_memset(&upd, 0, sizeof(upd));
7017 upd.mask = sta_flags_nl80211(params->flags);
7018 upd.set = upd.mask;
e4dea253
JM		 7019 wpa_printf(MSG_DEBUG, " * flags set=0x%x mask=0x%x",
7020 upd.set, upd.mask);
95ab6063
AN		 7021 NLA_PUT(msg, NL80211_ATTR_STA_FLAGS2, sizeof(upd), &upd);
7022
774bfa62 7023 if (params->flags & WPA_STA_WMM) {
8970bae8
JB		 7024 struct nlattr *wme = nla_nest_start(msg, NL80211_ATTR_STA_WME);
7025
774bfa62
EP		 7026 if (!wme)
7027 goto nla_put_failure;
7028
e4dea253 7029 wpa_printf(MSG_DEBUG, " * qosinfo=0x%x", params->qosinfo);
8970bae8 7030 NLA_PUT_U8(msg, NL80211_STA_WME_UAPSD_QUEUES,
5d061637 7031 params->qosinfo & WMM_QOSINFO_STA_AC_MASK);
8970bae8 7032 NLA_PUT_U8(msg, NL80211_STA_WME_MAX_SP,
bdaf1748 7033 (params->qosinfo >> WMM_QOSINFO_STA_SP_SHIFT) &
5d061637 7034 WMM_QOSINFO_STA_SP_MASK);
8970bae8 7035 nla_nest_end(msg, wme);
774bfa62
EP		 7036 }
7037
0f4e8b4f 7038 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
5883168a 7039 msg = NULL;
0f4e8b4f 7040 if (ret)
45b722f1
AN		 7041 wpa_printf(MSG_DEBUG, "nl80211: NL80211_CMD_%s_STATION "
7042 "result: %d (%s)", params->set ? "SET" : "NEW", ret,
7043 strerror(-ret));
0f4e8b4f
JM		 7044 if (ret == -EEXIST)
7045 ret = 0;
7046 nla_put_failure:
5883168a 7047 nlmsg_free(msg);
0f4e8b4f
JM		 7048 return ret;
7049}
7050
7051
9ebce9c5 7052static int wpa_driver_nl80211_sta_remove(struct i802_bss *bss, const u8 *addr)
0f4e8b4f 7053{
a2e40bb6 7054 struct wpa_driver_nl80211_data *drv = bss->drv;
0f4e8b4f
JM		 7055 struct nl_msg *msg;
7056 int ret;
7057
7058 msg = nlmsg_alloc();
7059 if (!msg)
7060 return -ENOMEM;
7061
9fb04070 7062 nl80211_cmd(drv, msg, 0, NL80211_CMD_DEL_STATION);
0f4e8b4f
JM		 7063
7064 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX,
a2e40bb6 7065 if_nametoindex(bss->ifname));
0f4e8b4f
JM		 7066 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, addr);
7067
7068 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
83e7bb0e
JM		 7069 wpa_printf(MSG_DEBUG, "nl80211: sta_remove -> DEL_STATION %s " MACSTR
7070 " --> %d (%s)",
7071 bss->ifname, MAC2STR(addr), ret, strerror(-ret));
0f4e8b4f
JM		 7072 if (ret == -ENOENT)
7073 return 0;
7074 return ret;
7075 nla_put_failure:
5883168a 7076 nlmsg_free(msg);
0f4e8b4f
JM		 7077 return -ENOBUFS;
7078}
7079
1581b38b 7080
0915d02c
JM		 7081static void nl80211_remove_iface(struct wpa_driver_nl80211_data *drv,
7082 int ifidx)
7083{
7084 struct nl_msg *msg;
7085
c6e8e8e4
JM		 7086 wpa_printf(MSG_DEBUG, "nl80211: Remove interface ifindex=%d", ifidx);
7087
2135f224
JM		 7088 /* stop listening for EAPOL on this interface */
7089 del_ifidx(drv, ifidx);
2135f224 7090
0915d02c
JM		 7091 msg = nlmsg_alloc();
7092 if (!msg)
7093 goto nla_put_failure;
7094
9fb04070 7095 nl80211_cmd(drv, msg, 0, NL80211_CMD_DEL_INTERFACE);
0915d02c
JM		 7096 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, ifidx);
7097
7098 if (send_and_recv_msgs(drv, msg, NULL, NULL) == 0)
7099 return;
5883168a 7100 msg = NULL;
0915d02c 7101 nla_put_failure:
5883168a 7102 nlmsg_free(msg);
e748062b 7103 wpa_printf(MSG_ERROR, "Failed to remove interface (ifidx=%d)", ifidx);
0915d02c
JM		 7104}
7105
7106
a1922f93
JM		 7107static const char * nl80211_iftype_str(enum nl80211_iftype mode)
7108{
7109 switch (mode) {
7110 case NL80211_IFTYPE_ADHOC:
7111 return "ADHOC";
7112 case NL80211_IFTYPE_STATION:
7113 return "STATION";
7114 case NL80211_IFTYPE_AP:
7115 return "AP";
1045ec36
JM		 7116 case NL80211_IFTYPE_AP_VLAN:
7117 return "AP_VLAN";
7118 case NL80211_IFTYPE_WDS:
7119 return "WDS";
a1922f93
JM		 7120 case NL80211_IFTYPE_MONITOR:
7121 return "MONITOR";
1045ec36
JM		 7122 case NL80211_IFTYPE_MESH_POINT:
7123 return "MESH_POINT";
a1922f93
JM		 7124 case NL80211_IFTYPE_P2P_CLIENT:
7125 return "P2P_CLIENT";
7126 case NL80211_IFTYPE_P2P_GO:
7127 return "P2P_GO";
7aad838c
NS		 7128 case NL80211_IFTYPE_P2P_DEVICE:
7129 return "P2P_DEVICE";
a1922f93
JM		 7130 default:
7131 return "unknown";
7132 }
7133}
7134
7135
a35187e7
KH		 7136static int nl80211_create_iface_once(struct wpa_driver_nl80211_data *drv,
7137 const char *ifname,
7138 enum nl80211_iftype iftype,
d6dcfcda
DS		 7139 const u8 *addr, int wds,
7140 int (*handler)(struct nl_msg *, void *),
7141 void *arg)
0915d02c 7142{
8970bae8 7143 struct nl_msg *msg;
0915d02c
JM		 7144 int ifidx;
7145 int ret = -ENOBUFS;
7146
a1922f93
JM		 7147 wpa_printf(MSG_DEBUG, "nl80211: Create interface iftype %d (%s)",
7148 iftype, nl80211_iftype_str(iftype));
7149
0915d02c
JM		 7150 msg = nlmsg_alloc();
7151 if (!msg)
7152 return -1;
7153
9fb04070 7154 nl80211_cmd(drv, msg, 0, NL80211_CMD_NEW_INTERFACE);
834ee56f 7155 if (nl80211_set_iface_id(msg, drv->first_bss) < 0)
fa93de40 7156 goto nla_put_failure;
0915d02c
JM		 7157 NLA_PUT_STRING(msg, NL80211_ATTR_IFNAME, ifname);
7158 NLA_PUT_U32(msg, NL80211_ATTR_IFTYPE, iftype);
7159
7160 if (iftype == NL80211_IFTYPE_MONITOR) {
8970bae8 7161 struct nlattr *flags;
0915d02c 7162
8970bae8 7163 flags = nla_nest_start(msg, NL80211_ATTR_MNTR_FLAGS);
0915d02c
JM		 7164 if (!flags)
7165 goto nla_put_failure;
7166
8970bae8 7167 NLA_PUT_FLAG(msg, NL80211_MNTR_FLAG_COOK_FRAMES);
0915d02c 7168
8970bae8 7169 nla_nest_end(msg, flags);
fbbfcbac
FF		 7170 } else if (wds) {
7171 NLA_PUT_U8(msg, NL80211_ATTR_4ADDR, wds);
0915d02c
JM		 7172 }
7173
d6dcfcda 7174 ret = send_and_recv_msgs(drv, msg, handler, arg);
5883168a 7175 msg = NULL;
0915d02c
JM		 7176 if (ret) {
7177 nla_put_failure:
5883168a 7178 nlmsg_free(msg);
a35187e7
KH		 7179 wpa_printf(MSG_ERROR, "Failed to create interface %s: %d (%s)",
7180 ifname, ret, strerror(-ret));
0915d02c
JM		 7181 return ret;
7182 }
7183
f632e483 7184 if (iftype == NL80211_IFTYPE_P2P_DEVICE)
6bae92e0 7185 return 0;
6bae92e0 7186
0915d02c 7187 ifidx = if_nametoindex(ifname);
c6e8e8e4
JM		 7188 wpa_printf(MSG_DEBUG, "nl80211: New interface %s created: ifindex=%d",
7189 ifname, ifidx);
0915d02c
JM		 7190
7191 if (ifidx <= 0)
7192 return -1;
7193
2135f224
JM		 7194 /* start listening for EAPOL on this interface */
7195 add_ifidx(drv, ifidx);
7196
7bfc47c3 7197 if (addr && iftype != NL80211_IFTYPE_MONITOR &&
c81eff1a 7198 linux_set_ifhwaddr(drv->global->ioctl_sock, ifname, addr)) {
41d931ee
JM		 7199 nl80211_remove_iface(drv, ifidx);
7200 return -1;
2135f224 7201 }
2135f224 7202
0915d02c
JM		 7203 return ifidx;
7204}
22a7c9d7
JM		 7205
7206
a35187e7
KH		 7207static int nl80211_create_iface(struct wpa_driver_nl80211_data *drv,
7208 const char *ifname, enum nl80211_iftype iftype,
d6dcfcda
DS		 7209 const u8 *addr, int wds,
7210 int (*handler)(struct nl_msg *, void *),
2aec4f3c 7211 void *arg, int use_existing)
a35187e7
KH		 7212{
7213 int ret;
7214
d6dcfcda
DS		 7215 ret = nl80211_create_iface_once(drv, ifname, iftype, addr, wds, handler,
7216 arg);
a35187e7 7217
ffbf1eaa 7218 /* if error occurred and interface exists already */
a35187e7 7219 if (ret == -ENFILE && if_nametoindex(ifname)) {
2aec4f3c
JM		 7220 if (use_existing) {
7221 wpa_printf(MSG_DEBUG, "nl80211: Continue using existing interface %s",
7222 ifname);
7223 return -ENFILE;
7224 }
a35187e7
KH		 7225 wpa_printf(MSG_INFO, "Try to remove and re-create %s", ifname);
7226
7227 /* Try to remove the interface that was already there. */
7228 nl80211_remove_iface(drv, if_nametoindex(ifname));
7229
7230 /* Try to create the interface again */
fbbfcbac 7231 ret = nl80211_create_iface_once(drv, ifname, iftype, addr,
d6dcfcda 7232 wds, handler, arg);
a35187e7
KH		 7233 }
7234
6a71413e 7235 if (ret >= 0 && is_p2p_net_interface(iftype))
4e5cb1a3
JM		 7236 nl80211_disable_11b_rates(drv, ret, 1);
7237
a35187e7
KH		 7238 return ret;
7239}
0915d02c 7240
2135f224 7241
0915d02c
JM		 7242static void handle_tx_callback(void *ctx, u8 *buf, size_t len, int ok)
7243{
7244 struct ieee80211_hdr *hdr;
f8b1f695
JM		 7245 u16 fc;
7246 union wpa_event_data event;
0915d02c
JM		 7247
7248 hdr = (struct ieee80211_hdr *) buf;
7249 fc = le_to_host16(hdr->frame_control);
7250
f8b1f695
JM		 7251 os_memset(&event, 0, sizeof(event));
7252 event.tx_status.type = WLAN_FC_GET_TYPE(fc);
7253 event.tx_status.stype = WLAN_FC_GET_STYPE(fc);
7254 event.tx_status.dst = hdr->addr1;
7255 event.tx_status.data = buf;
7256 event.tx_status.data_len = len;
7257 event.tx_status.ack = ok;
7258 wpa_supplicant_event(ctx, EVENT_TX_STATUS, &event);
0915d02c
JM		 7259}
7260
7261
4b9841d3 7262static void from_unknown_sta(struct wpa_driver_nl80211_data *drv,
0d9fc3d8 7263 u8 *buf, size_t len)
0915d02c 7264{
9b90955e
JB		 7265 struct ieee80211_hdr *hdr = (void *)buf;
7266 u16 fc;
f8b1f695 7267 union wpa_event_data event;
9b90955e
JB		 7268
7269 if (len < sizeof(*hdr))
7270 return;
7271
7272 fc = le_to_host16(hdr->frame_control);
7273
f8b1f695 7274 os_memset(&event, 0, sizeof(event));
9b90955e
JB		 7275 event.rx_from_unknown.bssid = get_hdr_bssid(hdr, len);
7276 event.rx_from_unknown.addr = hdr->addr2;
7277 event.rx_from_unknown.wds = (fc & (WLAN_FC_FROMDS | WLAN_FC_TODS)) ==
7278 (WLAN_FC_FROMDS | WLAN_FC_TODS);
f8b1f695 7279 wpa_supplicant_event(drv->ctx, EVENT_RX_FROM_UNKNOWN, &event);
4b9841d3 7280}
0915d02c 7281
4b9841d3
JM		 7282
7283static void handle_frame(struct wpa_driver_nl80211_data *drv,
2a8b7416 7284 u8 *buf, size_t len, int datarate, int ssi_signal)
4b9841d3
JM		 7285{
7286 struct ieee80211_hdr *hdr;
f8b1f695
JM		 7287 u16 fc;
7288 union wpa_event_data event;
0915d02c
JM		 7289
7290 hdr = (struct ieee80211_hdr *) buf;
7291 fc = le_to_host16(hdr->frame_control);
0915d02c 7292
4b9841d3 7293 switch (WLAN_FC_GET_TYPE(fc)) {
0915d02c 7294 case WLAN_FC_TYPE_MGMT:
f8b1f695
JM		 7295 os_memset(&event, 0, sizeof(event));
7296 event.rx_mgmt.frame = buf;
7297 event.rx_mgmt.frame_len = len;
2a8b7416
JM		 7298 event.rx_mgmt.datarate = datarate;
7299 event.rx_mgmt.ssi_signal = ssi_signal;
f8b1f695 7300 wpa_supplicant_event(drv->ctx, EVENT_RX_MGMT, &event);
0915d02c
JM		 7301 break;
7302 case WLAN_FC_TYPE_CTRL:
7303 /* can only get here with PS-Poll frames */
7304 wpa_printf(MSG_DEBUG, "CTRL");
0d9fc3d8 7305 from_unknown_sta(drv, buf, len);
0915d02c
JM		 7306 break;
7307 case WLAN_FC_TYPE_DATA:
0d9fc3d8 7308 from_unknown_sta(drv, buf, len);
0915d02c
JM		 7309 break;
7310 }
7311}
7312
7313
7314static void handle_monitor_read(int sock, void *eloop_ctx, void *sock_ctx)
7315{
7316 struct wpa_driver_nl80211_data *drv = eloop_ctx;
7317 int len;
7318 unsigned char buf[3000];
7319 struct ieee80211_radiotap_iterator iter;
7320 int ret;
2a8b7416 7321 int datarate = 0, ssi_signal = 0;
4b9841d3 7322 int injected = 0, failed = 0, rxflags = 0;
0915d02c
JM		 7323
7324 len = recv(sock, buf, sizeof(buf), 0);
7325 if (len < 0) {
7ac3616d
JM		 7326 wpa_printf(MSG_ERROR, "nl80211: Monitor socket recv failed: %s",
7327 strerror(errno));
0915d02c
JM		 7328 return;
7329 }
7330
7331 if (ieee80211_radiotap_iterator_init(&iter, (void*)buf, len)) {
7ac3616d 7332 wpa_printf(MSG_INFO, "nl80211: received invalid radiotap frame");
0915d02c
JM		 7333 return;
7334 }
7335
0915d02c
JM		 7336 while (1) {
7337 ret = ieee80211_radiotap_iterator_next(&iter);
7338 if (ret == -ENOENT)
7339 break;
7340 if (ret) {
7ac3616d
JM		 7341 wpa_printf(MSG_INFO, "nl80211: received invalid radiotap frame (%d)",
7342 ret);
0915d02c
JM		 7343 return;
7344 }
7345 switch (iter.this_arg_index) {
7346 case IEEE80211_RADIOTAP_FLAGS:
7347 if (*iter.this_arg & IEEE80211_RADIOTAP_F_FCS)
7348 len -= 4;
7349 break;
7350 case IEEE80211_RADIOTAP_RX_FLAGS:
7351 rxflags = 1;
7352 break;
7353 case IEEE80211_RADIOTAP_TX_FLAGS:
7354 injected = 1;
7355 failed = le_to_host16((*(uint16_t *) iter.this_arg)) &
7356 IEEE80211_RADIOTAP_F_TX_FAIL;
7357 break;
7358 case IEEE80211_RADIOTAP_DATA_RETRIES:
7359 break;
7360 case IEEE80211_RADIOTAP_CHANNEL:
2a8b7416 7361 /* TODO: convert from freq/flags to channel number */
0915d02c
JM		 7362 break;
7363 case IEEE80211_RADIOTAP_RATE:
2a8b7416 7364 datarate = *iter.this_arg * 5;
0915d02c 7365 break;
baf513d6
JB		 7366 case IEEE80211_RADIOTAP_DBM_ANTSIGNAL:
7367 ssi_signal = (s8) *iter.this_arg;
0915d02c
JM		 7368 break;
7369 }
7370 }
7371
7372 if (rxflags && injected)
7373 return;
7374
7375 if (!injected)
4b9841d3 7376 handle_frame(drv, buf + iter.max_length,
2a8b7416 7377 len - iter.max_length, datarate, ssi_signal);
0915d02c 7378 else
4b9841d3
JM		 7379 handle_tx_callback(drv->ctx, buf + iter.max_length,
7380 len - iter.max_length, !failed);
0915d02c
JM		 7381}
7382
7383
7384/*
7385 * we post-process the filter code later and rewrite
7386 * this to the offset to the last instruction
7387 */
7388#define PASS 0xFF
7389#define FAIL 0xFE
7390
7391static struct sock_filter msock_filter_insns[] = {
7392 /*
7393 * do a little-endian load of the radiotap length field
7394 */
7395 /* load lower byte into A */
7396 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
7397 /* put it into X (== index register) */
7398 BPF_STMT(BPF_MISC| BPF_TAX, 0),
7399 /* load upper byte into A */
7400 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 3),
7401 /* left-shift it by 8 */
7402 BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 8),
7403 /* or with X */
7404 BPF_STMT(BPF_ALU | BPF_OR | BPF_X, 0),
7405 /* put result into X */
7406 BPF_STMT(BPF_MISC| BPF_TAX, 0),
7407
7408 /*
7409 * Allow management frames through, this also gives us those
7410 * management frames that we sent ourselves with status
7411 */
7412 /* load the lower byte of the IEEE 802.11 frame control field */
7413 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
7414 /* mask off frame type and version */
7415 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xF),
7416 /* accept frame if it's both 0, fall through otherwise */
7417 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0, PASS, 0),
7418
7419 /*
7420 * TODO: add a bit to radiotap RX flags that indicates
7421 * that the sending station is not associated, then
7422 * add a filter here that filters on our DA and that flag
7423 * to allow us to deauth frames to that bad station.
7424 *
65ae1afd 7425 * For now allow all To DS data frames through.
0915d02c 7426 */
65ae1afd
HS		 7427 /* load the IEEE 802.11 frame control field */
7428 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 0),
7429 /* mask off frame type, version and DS status */
7430 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0x0F03),
7431 /* accept frame if version 0, type 2 and To DS, fall through otherwise
7432 */
7433 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0801, PASS, 0),
0915d02c
JM		 7434
7435#if 0
7436 /*
fbbfcbac 7437 * drop non-data frames
0915d02c
JM		 7438 */
7439 /* load the lower byte of the frame control field */
7440 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
7441 /* mask off QoS bit */
7442 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0x0c),
7443 /* drop non-data frames */
7444 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 8, 0, FAIL),
fbbfcbac 7445#endif
0915d02c 7446 /* load the upper byte of the frame control field */
fbbfcbac 7447 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 1),
0915d02c
JM		 7448 /* mask off toDS/fromDS */
7449 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0x03),
fbbfcbac
FF		 7450 /* accept WDS frames */
7451 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 3, PASS, 0),
0915d02c
JM		 7452
7453 /*
7454 * add header length to index
7455 */
7456 /* load the lower byte of the frame control field */
7457 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
7458 /* mask off QoS bit */
7459 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0x80),
7460 /* right shift it by 6 to give 0 or 2 */
7461 BPF_STMT(BPF_ALU | BPF_RSH | BPF_K, 6),
7462 /* add data frame header length */
7463 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 24),
7464 /* add index, was start of 802.11 header */
7465 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
7466 /* move to index, now start of LL header */
7467 BPF_STMT(BPF_MISC | BPF_TAX, 0),
7468
7469 /*
7470 * Accept empty data frames, we use those for
7471 * polling activity.
7472 */
7473 BPF_STMT(BPF_LD | BPF_W | BPF_LEN, 0),
7474 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, PASS, 0),
7475
7476 /*
7477 * Accept EAPOL frames
7478 */
7479 BPF_STMT(BPF_LD | BPF_W | BPF_IND, 0),
7480 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0xAAAA0300, 0, FAIL),
7481 BPF_STMT(BPF_LD | BPF_W | BPF_IND, 4),
7482 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0000888E, PASS, FAIL),
7483
7484 /* keep these last two statements or change the code below */
7485 /* return 0 == "DROP" */
7486 BPF_STMT(BPF_RET | BPF_K, 0),
7487 /* return ~0 == "keep all" */
7488 BPF_STMT(BPF_RET | BPF_K, ~0),
7489};
7490
7491static struct sock_fprog msock_filter = {
e7ecab4a 7492 .len = ARRAY_SIZE(msock_filter_insns),
0915d02c
JM		 7493 .filter = msock_filter_insns,
7494};
7495
7496
7497static int add_monitor_filter(int s)
7498{
7499 int idx;
7500
7501 /* rewrite all PASS/FAIL jump offsets */
7502 for (idx = 0; idx < msock_filter.len; idx++) {
7503 struct sock_filter *insn = &msock_filter_insns[idx];
7504
7505 if (BPF_CLASS(insn->code) == BPF_JMP) {
7506 if (insn->code == (BPF_JMP|BPF_JA)) {
7507 if (insn->k == PASS)
7508 insn->k = msock_filter.len - idx - 2;
7509 else if (insn->k == FAIL)
7510 insn->k = msock_filter.len - idx - 3;
7511 }
7512
7513 if (insn->jt == PASS)
7514 insn->jt = msock_filter.len - idx - 2;
7515 else if (insn->jt == FAIL)
7516 insn->jt = msock_filter.len - idx - 3;
7517
7518 if (insn->jf == PASS)
7519 insn->jf = msock_filter.len - idx - 2;
7520 else if (insn->jf == FAIL)
7521 insn->jf = msock_filter.len - idx - 3;
7522 }
7523 }
7524
7525 if (setsockopt(s, SOL_SOCKET, SO_ATTACH_FILTER,
7526 &msock_filter, sizeof(msock_filter))) {
7ac3616d
JM		 7527 wpa_printf(MSG_ERROR, "nl80211: setsockopt(SO_ATTACH_FILTER) failed: %s",
7528 strerror(errno));
0915d02c
JM		 7529 return -1;
7530 }
7531
7532 return 0;
7533}
7534
7535
460456f8
JM		 7536static void nl80211_remove_monitor_interface(
7537 struct wpa_driver_nl80211_data *drv)
7538{
748c0ac0
JM		 7539 if (drv->monitor_refcount > 0)
7540 drv->monitor_refcount--;
7541 wpa_printf(MSG_DEBUG, "nl80211: Remove monitor interface: refcount=%d",
7542 drv->monitor_refcount);
3fd1cefb
JB		 7543 if (drv->monitor_refcount > 0)
7544 return;
7545
460456f8
JM		 7546 if (drv->monitor_ifidx >= 0) {
7547 nl80211_remove_iface(drv, drv->monitor_ifidx);
7548 drv->monitor_ifidx = -1;
7549 }
504e905c
JM		 7550 if (drv->monitor_sock >= 0) {
7551 eloop_unregister_read_sock(drv->monitor_sock);
7552 close(drv->monitor_sock);
7553 drv->monitor_sock = -1;
7554 }
460456f8
JM		 7555}
7556
7557
0915d02c
JM		 7558static int
7559nl80211_create_monitor_interface(struct wpa_driver_nl80211_data *drv)
7560{
7561 char buf[IFNAMSIZ];
7562 struct sockaddr_ll ll;
7563 int optval;
7564 socklen_t optlen;
0915d02c 7565
3fd1cefb
JB		 7566 if (drv->monitor_ifidx >= 0) {
7567 drv->monitor_refcount++;
748c0ac0
JM		 7568 wpa_printf(MSG_DEBUG, "nl80211: Re-use existing monitor interface: refcount=%d",
7569 drv->monitor_refcount);
3fd1cefb
JB		 7570 return 0;
7571 }
7572
834ee56f 7573 if (os_strncmp(drv->first_bss->ifname, "p2p-", 4) == 0) {
6758b167
JJ		 7574 /*
7575 * P2P interface name is of the format p2p-%s-%d. For monitor
7576 * interface name corresponding to P2P GO, replace "p2p-" with
7577 * "mon-" to retain the same interface name length and to
7578 * indicate that it is a monitor interface.
7579 */
834ee56f 7580 snprintf(buf, IFNAMSIZ, "mon-%s", drv->first_bss->ifname + 4);
6758b167
JJ		 7581 } else {
7582 /* Non-P2P interface with AP functionality. */
834ee56f 7583 snprintf(buf, IFNAMSIZ, "mon.%s", drv->first_bss->ifname);
6758b167
JJ		 7584 }
7585
0915d02c
JM		 7586 buf[IFNAMSIZ - 1] = '\0';
7587
7588 drv->monitor_ifidx =
fbbfcbac 7589 nl80211_create_iface(drv, buf, NL80211_IFTYPE_MONITOR, NULL,
2aec4f3c 7590 0, NULL, NULL, 0);
0915d02c 7591
866af8b6 7592 if (drv->monitor_ifidx == -EOPNOTSUPP) {
61cbe2ff
JB		 7593 /*
7594 * This is backward compatibility for a few versions of
7595 * the kernel only that didn't advertise the right
7596 * attributes for the only driver that then supported
7597 * AP mode w/o monitor -- ath6kl.
7598 */
866af8b6
JM		 7599 wpa_printf(MSG_DEBUG, "nl80211: Driver does not support "
7600 "monitor interface type - try to run without it");
61cbe2ff 7601 drv->device_ap_sme = 1;
866af8b6
JM		 7602 }
7603
0915d02c
JM		 7604 if (drv->monitor_ifidx < 0)
7605 return -1;
7606
c81eff1a 7607 if (linux_set_iface_flags(drv->global->ioctl_sock, buf, 1))
0915d02c 7608 goto error;
0915d02c
JM		 7609
7610 memset(&ll, 0, sizeof(ll));
7611 ll.sll_family = AF_PACKET;
7612 ll.sll_ifindex = drv->monitor_ifidx;
7613 drv->monitor_sock = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
7614 if (drv->monitor_sock < 0) {
7ac3616d
JM		 7615 wpa_printf(MSG_ERROR, "nl80211: socket[PF_PACKET,SOCK_RAW] failed: %s",
7616 strerror(errno));
0915d02c
JM		 7617 goto error;
7618 }
7619
7620 if (add_monitor_filter(drv->monitor_sock)) {
7621 wpa_printf(MSG_INFO, "Failed to set socket filter for monitor "
7622 "interface; do filtering in user space");
7623 /* This works, but will cost in performance. */
7624 }
7625
2135f224 7626 if (bind(drv->monitor_sock, (struct sockaddr *) &ll, sizeof(ll)) < 0) {
7ac3616d
JM		 7627 wpa_printf(MSG_ERROR, "nl80211: monitor socket bind failed: %s",
7628 strerror(errno));
0915d02c
JM		 7629 goto error;
7630 }
7631
7632 optlen = sizeof(optval);
7633 optval = 20;
7634 if (setsockopt
7635 (drv->monitor_sock, SOL_SOCKET, SO_PRIORITY, &optval, optlen)) {
7ac3616d
JM		 7636 wpa_printf(MSG_ERROR, "nl80211: Failed to set socket priority: %s",
7637 strerror(errno));
0915d02c
JM		 7638 goto error;
7639 }
7640
7641 if (eloop_register_read_sock(drv->monitor_sock, handle_monitor_read,
7642 drv, NULL)) {
7ac3616d 7643 wpa_printf(MSG_INFO, "nl80211: Could not register monitor read socket");
0915d02c
JM		 7644 goto error;
7645 }
7646
748c0ac0 7647 drv->monitor_refcount++;
0915d02c
JM		 7648 return 0;
7649 error:
460456f8 7650 nl80211_remove_monitor_interface(drv);
0915d02c
JM		 7651 return -1;
7652}
7653
db149ac9 7654
3fd1cefb
JB		 7655static int nl80211_setup_ap(struct i802_bss *bss)
7656{
7657 struct wpa_driver_nl80211_data *drv = bss->drv;
7658
748c0ac0
JM		 7659 wpa_printf(MSG_DEBUG, "nl80211: Setup AP(%s) - device_ap_sme=%d use_monitor=%d",
7660 bss->ifname, drv->device_ap_sme, drv->use_monitor);
36488c05 7661
a11241fa
JB		 7662 /*
7663 * Disable Probe Request reporting unless we need it in this way for
7664 * devices that include the AP SME, in the other case (unless using
7665 * monitor iface) we'll get it through the nl_mgmt socket instead.
7666 */
7667 if (!drv->device_ap_sme)
7668 wpa_driver_nl80211_probe_req_report(bss, 0);
7669
7670 if (!drv->device_ap_sme && !drv->use_monitor)
7671 if (nl80211_mgmt_subscribe_ap(bss))
7672 return -1;
7673
a6cc0602
JM		 7674 if (drv->device_ap_sme && !drv->use_monitor)
7675 if (nl80211_mgmt_subscribe_ap_dev_sme(bss))
7676 return -1;
7677
a11241fa 7678 if (!drv->device_ap_sme && drv->use_monitor &&
3fd1cefb
JB		 7679 nl80211_create_monitor_interface(drv) &&
7680 !drv->device_ap_sme)
7681 return -1;
7682
7683 if (drv->device_ap_sme &&
7684 wpa_driver_nl80211_probe_req_report(bss, 1) < 0) {
7685 wpa_printf(MSG_DEBUG, "nl80211: Failed to enable "
7686 "Probe Request frame reporting in AP mode");
7687 /* Try to survive without this */
7688 }
7689
7690 return 0;
7691}
7692
7693
7694static void nl80211_teardown_ap(struct i802_bss *bss)
7695{
7696 struct wpa_driver_nl80211_data *drv = bss->drv;
7697
748c0ac0
JM		 7698 wpa_printf(MSG_DEBUG, "nl80211: Teardown AP(%s) - device_ap_sme=%d use_monitor=%d",
7699 bss->ifname, drv->device_ap_sme, drv->use_monitor);
a6cc0602 7700 if (drv->device_ap_sme) {
3fd1cefb 7701 wpa_driver_nl80211_probe_req_report(bss, 0);
a6cc0602
JM		 7702 if (!drv->use_monitor)
7703 nl80211_mgmt_unsubscribe(bss, "AP teardown (dev SME)");
7704 } else if (drv->use_monitor)
3fd1cefb 7705 nl80211_remove_monitor_interface(drv);
a11241fa 7706 else
36488c05 7707 nl80211_mgmt_unsubscribe(bss, "AP teardown");
a11241fa 7708
3fd1cefb
JB		 7709 bss->beacon_set = 0;
7710}
7711
7712
f10bfc9a
JM		 7713static int nl80211_send_eapol_data(struct i802_bss *bss,
7714 const u8 *addr, const u8 *data,
d12dab4c 7715 size_t data_len)
f10bfc9a 7716{
d12dab4c
JB		 7717 struct sockaddr_ll ll;
7718 int ret;
7719
7720 if (bss->drv->eapol_tx_sock < 0) {
7721 wpa_printf(MSG_DEBUG, "nl80211: No socket to send EAPOL");
f10bfc9a
JM		 7722 return -1;
7723 }
7724
d12dab4c
JB		 7725 os_memset(&ll, 0, sizeof(ll));
7726 ll.sll_family = AF_PACKET;
7727 ll.sll_ifindex = bss->ifindex;
7728 ll.sll_protocol = htons(ETH_P_PAE);
7729 ll.sll_halen = ETH_ALEN;
7730 os_memcpy(ll.sll_addr, addr, ETH_ALEN);
7731 ret = sendto(bss->drv->eapol_tx_sock, data, data_len, 0,
7732 (struct sockaddr *) &ll, sizeof(ll));
7733 if (ret < 0)
7734 wpa_printf(MSG_ERROR, "nl80211: EAPOL TX: %s",
7735 strerror(errno));
7736
7737 return ret;
f10bfc9a 7738}
5fb1a232 7739
f10bfc9a 7740
db149ac9
JM		 7741static const u8 rfc1042_header[6] = { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00 };
7742
7743static int wpa_driver_nl80211_hapd_send_eapol(
7744 void *priv, const u8 *addr, const u8 *data,
4378fc14 7745 size_t data_len, int encrypt, const u8 *own_addr, u32 flags)
db149ac9 7746{
a2e40bb6
FF		 7747 struct i802_bss *bss = priv;
7748 struct wpa_driver_nl80211_data *drv = bss->drv;
db149ac9
JM		 7749 struct ieee80211_hdr *hdr;
7750 size_t len;
7751 u8 *pos;
7752 int res;
4378fc14 7753 int qos = flags & WPA_STA_WMM;
db149ac9 7754
a11241fa 7755 if (drv->device_ap_sme || !drv->use_monitor)
d12dab4c 7756 return nl80211_send_eapol_data(bss, addr, data, data_len);
f10bfc9a 7757
db149ac9
JM		 7758 len = sizeof(*hdr) + (qos ? 2 : 0) + sizeof(rfc1042_header) + 2 +
7759 data_len;
7760 hdr = os_zalloc(len);
7761 if (hdr == NULL) {
7ac3616d
JM		 7762 wpa_printf(MSG_INFO, "nl80211: Failed to allocate EAPOL buffer(len=%lu)",
7763 (unsigned long) len);
db149ac9
JM		 7764 return -1;
7765 }
7766
7767 hdr->frame_control =
7768 IEEE80211_FC(WLAN_FC_TYPE_DATA, WLAN_FC_STYPE_DATA);
7769 hdr->frame_control |= host_to_le16(WLAN_FC_FROMDS);
7770 if (encrypt)
7771 hdr->frame_control |= host_to_le16(WLAN_FC_ISWEP);
db149ac9
JM		 7772 if (qos) {
7773 hdr->frame_control |=
7774 host_to_le16(WLAN_FC_STYPE_QOS_DATA << 4);
7775 }
db149ac9
JM		 7776
7777 memcpy(hdr->IEEE80211_DA_FROMDS, addr, ETH_ALEN);
7778 memcpy(hdr->IEEE80211_BSSID_FROMDS, own_addr, ETH_ALEN);
7779 memcpy(hdr->IEEE80211_SA_FROMDS, own_addr, ETH_ALEN);
7780 pos = (u8 *) (hdr + 1);
7781
db149ac9 7782 if (qos) {
92d521d8
FF		 7783 /* Set highest priority in QoS header */
7784 pos[0] = 7;
db149ac9
JM		 7785 pos[1] = 0;
7786 pos += 2;
7787 }
db149ac9
JM		 7788
7789 memcpy(pos, rfc1042_header, sizeof(rfc1042_header));
7790 pos += sizeof(rfc1042_header);
7791 WPA_PUT_BE16(pos, ETH_P_PAE);
7792 pos += 2;
7793 memcpy(pos, data, data_len);
7794
55231068
JM		 7795 res = wpa_driver_nl80211_send_frame(bss, (u8 *) hdr, len, encrypt, 0,
7796 0, 0, 0, 0);
db149ac9
JM		 7797 if (res < 0) {
7798 wpa_printf(MSG_ERROR, "i802_send_eapol - packet len: %lu - "
7799 "failed: %d (%s)",
7800 (unsigned long) len, errno, strerror(errno));
7801 }
7bf12757 7802 os_free(hdr);
db149ac9
JM		 7803
7804 return res;
7805}
7806
a8d6ffa4 7807
3234cba4
JM		 7808static int wpa_driver_nl80211_sta_set_flags(void *priv, const u8 *addr,
7809 int total_flags,
4c32757d 7810 int flags_or, int flags_and)
a8d6ffa4 7811{
a2e40bb6
FF		 7812 struct i802_bss *bss = priv;
7813 struct wpa_driver_nl80211_data *drv = bss->drv;
8970bae8
JB		 7814 struct nl_msg *msg;
7815 struct nlattr *flags;
7e76ee9c 7816 struct nl80211_sta_flag_update upd;
a8d6ffa4
JM		 7817
7818 msg = nlmsg_alloc();
7819 if (!msg)
7820 return -ENOMEM;
7821
9fb04070 7822 nl80211_cmd(drv, msg, 0, NL80211_CMD_SET_STATION);
a8d6ffa4
JM		 7823
7824 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX,
3234cba4 7825 if_nametoindex(bss->ifname));
a8d6ffa4
JM		 7826 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, addr);
7827
7e76ee9c
JM		 7828 /*
7829 * Backwards compatibility version using NL80211_ATTR_STA_FLAGS. This
7830 * can be removed eventually.
7831 */
8970bae8
JB		 7832 flags = nla_nest_start(msg, NL80211_ATTR_STA_FLAGS);
7833 if (!flags)
7834 goto nla_put_failure;
0de39516 7835 if (total_flags & WPA_STA_AUTHORIZED)
8970bae8 7836 NLA_PUT_FLAG(msg, NL80211_STA_FLAG_AUTHORIZED);
a8d6ffa4 7837
0de39516 7838 if (total_flags & WPA_STA_WMM)
8970bae8 7839 NLA_PUT_FLAG(msg, NL80211_STA_FLAG_WME);
a8d6ffa4 7840
0de39516 7841 if (total_flags & WPA_STA_SHORT_PREAMBLE)
8970bae8 7842 NLA_PUT_FLAG(msg, NL80211_STA_FLAG_SHORT_PREAMBLE);
a8d6ffa4 7843
0de39516 7844 if (total_flags & WPA_STA_MFP)
8970bae8 7845 NLA_PUT_FLAG(msg, NL80211_STA_FLAG_MFP);
a8d6ffa4 7846
45b722f1 7847 if (total_flags & WPA_STA_TDLS_PEER)
8970bae8 7848 NLA_PUT_FLAG(msg, NL80211_STA_FLAG_TDLS_PEER);
45b722f1 7849
8970bae8 7850 nla_nest_end(msg, flags);
a8d6ffa4 7851
7e76ee9c
JM		 7852 os_memset(&upd, 0, sizeof(upd));
7853 upd.mask = sta_flags_nl80211(flags_or | ~flags_and);
7854 upd.set = sta_flags_nl80211(flags_or);
7855 NLA_PUT(msg, NL80211_ATTR_STA_FLAGS2, sizeof(upd), &upd);
7856
a8d6ffa4
JM		 7857 return send_and_recv_msgs(drv, msg, NULL, NULL);
7858 nla_put_failure:
5883168a 7859 nlmsg_free(msg);
a8d6ffa4
JM		 7860 return -ENOBUFS;
7861}
7862
0915d02c 7863
1581b38b
JM		 7864static int wpa_driver_nl80211_ap(struct wpa_driver_nl80211_data *drv,
7865 struct wpa_driver_associate_params *params)
7866{
708bc8e0 7867 enum nl80211_iftype nlmode, old_mode;
89b800d7
JB		 7868 struct hostapd_freq_params freq = {
7869 .freq = params->freq,
7870 };
b1f625e0
EP		 7871
7872 if (params->p2p) {
046b26a2
JM		 7873 wpa_printf(MSG_DEBUG, "nl80211: Setup AP operations for P2P "
7874 "group (GO)");
b1f625e0
EP		 7875 nlmode = NL80211_IFTYPE_P2P_GO;
7876 } else
7877 nlmode = NL80211_IFTYPE_AP;
7878
708bc8e0 7879 old_mode = drv->nlmode;
834ee56f 7880 if (wpa_driver_nl80211_set_mode(drv->first_bss, nlmode)) {
708bc8e0
JM		 7881 nl80211_remove_monitor_interface(drv);
7882 return -1;
7883 }
7884
834ee56f 7885 if (wpa_driver_nl80211_set_freq(drv->first_bss, &freq)) {
708bc8e0 7886 if (old_mode != nlmode)
834ee56f 7887 wpa_driver_nl80211_set_mode(drv->first_bss, old_mode);
460456f8 7888 nl80211_remove_monitor_interface(drv);
1581b38b 7889 return -1;
0915d02c 7890 }
1581b38b 7891
1581b38b
JM		 7892 return 0;
7893}
1581b38b
JM		 7894
7895
5cc4d64b
JM		 7896static int nl80211_leave_ibss(struct wpa_driver_nl80211_data *drv)
7897{
7898 struct nl_msg *msg;
7899 int ret = -1;
7900
7901 msg = nlmsg_alloc();
7902 if (!msg)
7903 return -1;
7904
9fb04070 7905 nl80211_cmd(drv, msg, 0, NL80211_CMD_LEAVE_IBSS);
5cc4d64b
JM		 7906 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
7907 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
7908 msg = NULL;
7909 if (ret) {
7910 wpa_printf(MSG_DEBUG, "nl80211: Leave IBSS failed: ret=%d "
7911 "(%s)", ret, strerror(-ret));
7912 goto nla_put_failure;
7913 }
7914
7915 ret = 0;
7916 wpa_printf(MSG_DEBUG, "nl80211: Leave IBSS request sent successfully");
7917
7918nla_put_failure:
834ee56f 7919 if (wpa_driver_nl80211_set_mode(drv->first_bss,
5d4c78fb
JM		 7920 NL80211_IFTYPE_STATION)) {
7921 wpa_printf(MSG_INFO, "nl80211: Failed to set interface into "
7922 "station mode");
7923 }
7924
5cc4d64b
JM		 7925 nlmsg_free(msg);
7926 return ret;
7927}
7928
7929
7930static int wpa_driver_nl80211_ibss(struct wpa_driver_nl80211_data *drv,
7931 struct wpa_driver_associate_params *params)
7932{
7933 struct nl_msg *msg;
7934 int ret = -1;
7935 int count = 0;
7936
7937 wpa_printf(MSG_DEBUG, "nl80211: Join IBSS (ifindex=%d)", drv->ifindex);
7938
834ee56f 7939 if (wpa_driver_nl80211_set_mode(drv->first_bss,
b1f625e0 7940 NL80211_IFTYPE_ADHOC)) {
5cc4d64b
JM		 7941 wpa_printf(MSG_INFO, "nl80211: Failed to set interface into "
7942 "IBSS mode");
7943 return -1;
7944 }
7945
7946retry:
7947 msg = nlmsg_alloc();
7948 if (!msg)
7949 return -1;
7950
9fb04070 7951 nl80211_cmd(drv, msg, 0, NL80211_CMD_JOIN_IBSS);
5cc4d64b
JM		 7952 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
7953
7954 if (params->ssid == NULL || params->ssid_len > sizeof(drv->ssid))
7955 goto nla_put_failure;
7956
7957 wpa_hexdump_ascii(MSG_DEBUG, " * SSID",
7958 params->ssid, params->ssid_len);
7959 NLA_PUT(msg, NL80211_ATTR_SSID, params->ssid_len,
7960 params->ssid);
7961 os_memcpy(drv->ssid, params->ssid, params->ssid_len);
7962 drv->ssid_len = params->ssid_len;
7963
7964 wpa_printf(MSG_DEBUG, " * freq=%d", params->freq);
7965 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_FREQ, params->freq);
7966
7967 ret = nl80211_set_conn_keys(params, msg);
7968 if (ret)
7969 goto nla_put_failure;
7970
913e3cf7
NC		 7971 if (params->bssid && params->fixed_bssid) {
7972 wpa_printf(MSG_DEBUG, " * BSSID=" MACSTR,
7973 MAC2STR(params->bssid));
7974 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, params->bssid);
7975 }
7976
e640888c
AQ		 7977 if (params->key_mgmt_suite == KEY_MGMT_802_1X ||
7978 params->key_mgmt_suite == KEY_MGMT_PSK ||
7979 params->key_mgmt_suite == KEY_MGMT_802_1X_SHA256 ||
7980 params->key_mgmt_suite == KEY_MGMT_PSK_SHA256) {
7981 wpa_printf(MSG_DEBUG, " * control port");
7982 NLA_PUT_FLAG(msg, NL80211_ATTR_CONTROL_PORT);
7983 }
7984
a95795ad
JM		 7985 if (params->wpa_ie) {
7986 wpa_hexdump(MSG_DEBUG,
7987 " * Extra IEs for Beacon/Probe Response frames",
7988 params->wpa_ie, params->wpa_ie_len);
7989 NLA_PUT(msg, NL80211_ATTR_IE, params->wpa_ie_len,
7990 params->wpa_ie);
7991 }
7992
5cc4d64b
JM		 7993 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
7994 msg = NULL;
7995 if (ret) {
7996 wpa_printf(MSG_DEBUG, "nl80211: Join IBSS failed: ret=%d (%s)",
7997 ret, strerror(-ret));
7998 count++;
7999 if (ret == -EALREADY && count == 1) {
8000 wpa_printf(MSG_DEBUG, "nl80211: Retry IBSS join after "
8001 "forced leave");
8002 nl80211_leave_ibss(drv);
8003 nlmsg_free(msg);
8004 goto retry;
8005 }
8006
8007 goto nla_put_failure;
8008 }
8009 ret = 0;
8010 wpa_printf(MSG_DEBUG, "nl80211: Join IBSS request sent successfully");
8011
8012nla_put_failure:
8013 nlmsg_free(msg);
8014 return ret;
8015}
8016
8017
a8c5b43a 8018static int wpa_driver_nl80211_try_connect(
cfaab580
ZY		 8019 struct wpa_driver_nl80211_data *drv,
8020 struct wpa_driver_associate_params *params)
8021{
8022 struct nl_msg *msg;
8023 enum nl80211_auth_type type;
8024 int ret = 0;
3f360238 8025 int algs;
cfaab580
ZY		 8026
8027 msg = nlmsg_alloc();
8028 if (!msg)
8029 return -1;
8030
8031 wpa_printf(MSG_DEBUG, "nl80211: Connect (ifindex=%d)", drv->ifindex);
9fb04070 8032 nl80211_cmd(drv, msg, 0, NL80211_CMD_CONNECT);
cfaab580
ZY		 8033
8034 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
8035 if (params->bssid) {
8036 wpa_printf(MSG_DEBUG, " * bssid=" MACSTR,
8037 MAC2STR(params->bssid));
8038 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, params->bssid);
8039 }
8040 if (params->freq) {
8041 wpa_printf(MSG_DEBUG, " * freq=%d", params->freq);
8042 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_FREQ, params->freq);
30158a0d
SD		 8043 drv->assoc_freq = params->freq;
8044 } else
8045 drv->assoc_freq = 0;
1f6c0ab8
BS		 8046 if (params->bg_scan_period >= 0) {
8047 wpa_printf(MSG_DEBUG, " * bg scan period=%d",
8048 params->bg_scan_period);
8049 NLA_PUT_U16(msg, NL80211_ATTR_BG_SCAN_PERIOD,
8050 params->bg_scan_period);
8051 }
cfaab580
ZY		 8052 if (params->ssid) {
8053 wpa_hexdump_ascii(MSG_DEBUG, " * SSID",
8054 params->ssid, params->ssid_len);
8055 NLA_PUT(msg, NL80211_ATTR_SSID, params->ssid_len,
8056 params->ssid);
8057 if (params->ssid_len > sizeof(drv->ssid))
8058 goto nla_put_failure;
8059 os_memcpy(drv->ssid, params->ssid, params->ssid_len);
8060 drv->ssid_len = params->ssid_len;
8061 }
8062 wpa_hexdump(MSG_DEBUG, " * IEs", params->wpa_ie, params->wpa_ie_len);
8063 if (params->wpa_ie)
8064 NLA_PUT(msg, NL80211_ATTR_IE, params->wpa_ie_len,
8065 params->wpa_ie);
8066
3f360238
JM		 8067 algs = 0;
8068 if (params->auth_alg & WPA_AUTH_ALG_OPEN)
8069 algs++;
8070 if (params->auth_alg & WPA_AUTH_ALG_SHARED)
8071 algs++;
8072 if (params->auth_alg & WPA_AUTH_ALG_LEAP)
8073 algs++;
8074 if (algs > 1) {
8075 wpa_printf(MSG_DEBUG, " * Leave out Auth Type for automatic "
8076 "selection");
8077 goto skip_auth_type;
8078 }
8079
abd9fafa 8080 if (params->auth_alg & WPA_AUTH_ALG_OPEN)
cfaab580 8081 type = NL80211_AUTHTYPE_OPEN_SYSTEM;
abd9fafa 8082 else if (params->auth_alg & WPA_AUTH_ALG_SHARED)
cfaab580 8083 type = NL80211_AUTHTYPE_SHARED_KEY;
abd9fafa 8084 else if (params->auth_alg & WPA_AUTH_ALG_LEAP)
cfaab580 8085 type = NL80211_AUTHTYPE_NETWORK_EAP;
abd9fafa 8086 else if (params->auth_alg & WPA_AUTH_ALG_FT)
cfaab580
ZY		 8087 type = NL80211_AUTHTYPE_FT;
8088 else
8089 goto nla_put_failure;
8090
8091 wpa_printf(MSG_DEBUG, " * Auth Type %d", type);
8092 NLA_PUT_U32(msg, NL80211_ATTR_AUTH_TYPE, type);
8093
3f360238 8094skip_auth_type:
64fa840a
JM		 8095 if (params->wpa_proto) {
8096 enum nl80211_wpa_versions ver = 0;
cfaab580 8097
64fa840a
JM		 8098 if (params->wpa_proto & WPA_PROTO_WPA)
8099 ver |= NL80211_WPA_VERSION_1;
8100 if (params->wpa_proto & WPA_PROTO_RSN)
8101 ver |= NL80211_WPA_VERSION_2;
cfaab580 8102
64fa840a 8103 wpa_printf(MSG_DEBUG, " * WPA Versions 0x%x", ver);
cfaab580
ZY		 8104 NLA_PUT_U32(msg, NL80211_ATTR_WPA_VERSIONS, ver);
8105 }
8106
8107 if (params->pairwise_suite != CIPHER_NONE) {
c1bb3e0a 8108 int cipher;
cfaab580
ZY		 8109
8110 switch (params->pairwise_suite) {
369c8d7b
JM		 8111 case CIPHER_SMS4:
8112 cipher = WLAN_CIPHER_SUITE_SMS4;
8113 break;
cfaab580
ZY		 8114 case CIPHER_WEP40:
8115 cipher = WLAN_CIPHER_SUITE_WEP40;
8116 break;
8117 case CIPHER_WEP104:
8118 cipher = WLAN_CIPHER_SUITE_WEP104;
8119 break;
8120 case CIPHER_CCMP:
8121 cipher = WLAN_CIPHER_SUITE_CCMP;
8122 break;
eb7719ff
JM		 8123 case CIPHER_GCMP:
8124 cipher = WLAN_CIPHER_SUITE_GCMP;
8125 break;
cfaab580
ZY		 8126 case CIPHER_TKIP:
8127 default:
8128 cipher = WLAN_CIPHER_SUITE_TKIP;
8129 break;
8130 }
8131 NLA_PUT_U32(msg, NL80211_ATTR_CIPHER_SUITES_PAIRWISE, cipher);
8132 }
8133
8134 if (params->group_suite != CIPHER_NONE) {
c1bb3e0a 8135 int cipher;
cfaab580
ZY		 8136
8137 switch (params->group_suite) {
369c8d7b
JM		 8138 case CIPHER_SMS4:
8139 cipher = WLAN_CIPHER_SUITE_SMS4;
8140 break;
cfaab580
ZY		 8141 case CIPHER_WEP40:
8142 cipher = WLAN_CIPHER_SUITE_WEP40;
8143 break;
8144 case CIPHER_WEP104:
8145 cipher = WLAN_CIPHER_SUITE_WEP104;
8146 break;
8147 case CIPHER_CCMP:
8148 cipher = WLAN_CIPHER_SUITE_CCMP;
8149 break;
eb7719ff
JM		 8150 case CIPHER_GCMP:
8151 cipher = WLAN_CIPHER_SUITE_GCMP;
8152 break;
cfaab580
ZY		 8153 case CIPHER_TKIP:
8154 default:
8155 cipher = WLAN_CIPHER_SUITE_TKIP;
8156 break;
8157 }
8158 NLA_PUT_U32(msg, NL80211_ATTR_CIPHER_SUITE_GROUP, cipher);
8159 }
8160
8161 if (params->key_mgmt_suite == KEY_MGMT_802_1X ||
369c8d7b 8162 params->key_mgmt_suite == KEY_MGMT_PSK ||
6a1ce395
DG		 8163 params->key_mgmt_suite == KEY_MGMT_FT_802_1X ||
8164 params->key_mgmt_suite == KEY_MGMT_FT_PSK ||
369c8d7b 8165 params->key_mgmt_suite == KEY_MGMT_CCKM) {
cfaab580
ZY		 8166 int mgmt = WLAN_AKM_SUITE_PSK;
8167
8168 switch (params->key_mgmt_suite) {
369c8d7b
JM		 8169 case KEY_MGMT_CCKM:
8170 mgmt = WLAN_AKM_SUITE_CCKM;
8171 break;
cfaab580
ZY		 8172 case KEY_MGMT_802_1X:
8173 mgmt = WLAN_AKM_SUITE_8021X;
8174 break;
6a1ce395
DG		 8175 case KEY_MGMT_FT_802_1X:
8176 mgmt = WLAN_AKM_SUITE_FT_8021X;
8177 break;
8178 case KEY_MGMT_FT_PSK:
8179 mgmt = WLAN_AKM_SUITE_FT_PSK;
8180 break;
cfaab580
ZY		 8181 case KEY_MGMT_PSK:
8182 default:
8183 mgmt = WLAN_AKM_SUITE_PSK;
8184 break;
8185 }
8186 NLA_PUT_U32(msg, NL80211_ATTR_AKM_SUITES, mgmt);
8187 }
8188
8b706a99
JM		 8189#ifdef CONFIG_IEEE80211W
8190 if (params->mgmt_frame_protection == MGMT_FRAME_PROTECTION_REQUIRED)
8191 NLA_PUT_U32(msg, NL80211_ATTR_USE_MFP, NL80211_MFP_REQUIRED);
8192#endif /* CONFIG_IEEE80211W */
8193
80e8a5ee
BG		 8194 if (params->disable_ht)
8195 NLA_PUT_FLAG(msg, NL80211_ATTR_DISABLE_HT);
8196
8197 if (params->htcaps && params->htcaps_mask) {
8198 int sz = sizeof(struct ieee80211_ht_capabilities);
8199 NLA_PUT(msg, NL80211_ATTR_HT_CAPABILITY, sz, params->htcaps);
8200 NLA_PUT(msg, NL80211_ATTR_HT_CAPABILITY_MASK, sz,
8201 params->htcaps_mask);
8202 }
8203
e9ee8dc3
JB		 8204#ifdef CONFIG_VHT_OVERRIDES
8205 if (params->disable_vht) {
8206 wpa_printf(MSG_DEBUG, " * VHT disabled");
8207 NLA_PUT_FLAG(msg, NL80211_ATTR_DISABLE_VHT);
8208 }
8209
8210 if (params->vhtcaps && params->vhtcaps_mask) {
8211 int sz = sizeof(struct ieee80211_vht_capabilities);
8212 NLA_PUT(msg, NL80211_ATTR_VHT_CAPABILITY, sz, params->vhtcaps);
8213 NLA_PUT(msg, NL80211_ATTR_VHT_CAPABILITY_MASK, sz,
8214 params->vhtcaps_mask);
8215 }
8216#endif /* CONFIG_VHT_OVERRIDES */
8217
cfaab580
ZY		 8218 ret = nl80211_set_conn_keys(params, msg);
8219 if (ret)
8220 goto nla_put_failure;
8221
8222 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
8223 msg = NULL;
8224 if (ret) {
8225 wpa_printf(MSG_DEBUG, "nl80211: MLME connect failed: ret=%d "
8226 "(%s)", ret, strerror(-ret));
8227 goto nla_put_failure;
8228 }
8229 ret = 0;
8230 wpa_printf(MSG_DEBUG, "nl80211: Connect request send successfully");
8231
8232nla_put_failure:
8233 nlmsg_free(msg);
8234 return ret;
8235
8236}
8237
8238
a8c5b43a
CW		 8239static int wpa_driver_nl80211_connect(
8240 struct wpa_driver_nl80211_data *drv,
8241 struct wpa_driver_associate_params *params)
8242{
8243 int ret = wpa_driver_nl80211_try_connect(drv, params);
8244 if (ret == -EALREADY) {
8245 /*
8246 * cfg80211 does not currently accept new connections if
8247 * we are already connected. As a workaround, force
8248 * disconnection and try again.
8249 */
8250 wpa_printf(MSG_DEBUG, "nl80211: Explicitly "
8251 "disconnecting before reassociation "
8252 "attempt");
8253 if (wpa_driver_nl80211_disconnect(
8254 drv, WLAN_REASON_PREV_AUTH_NOT_VALID))
8255 return -1;
a8c5b43a
CW		 8256 ret = wpa_driver_nl80211_try_connect(drv, params);
8257 }
8258 return ret;
8259}
8260
8261
c2a04078
JM		 8262static int wpa_driver_nl80211_associate(
8263 void *priv, struct wpa_driver_associate_params *params)
8264{
a2e40bb6
FF		 8265 struct i802_bss *bss = priv;
8266 struct wpa_driver_nl80211_data *drv = bss->drv;
c2a04078
JM		 8267 int ret = -1;
8268 struct nl_msg *msg;
8269
5cc4d64b 8270 if (params->mode == IEEE80211_MODE_AP)
1581b38b 8271 return wpa_driver_nl80211_ap(drv, params);
1581b38b 8272
5cc4d64b
JM		 8273 if (params->mode == IEEE80211_MODE_IBSS)
8274 return wpa_driver_nl80211_ibss(drv, params);
8275
4a867032 8276 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_SME)) {
b1f625e0
EP		 8277 enum nl80211_iftype nlmode = params->p2p ?
8278 NL80211_IFTYPE_P2P_CLIENT : NL80211_IFTYPE_STATION;
8279
8280 if (wpa_driver_nl80211_set_mode(priv, nlmode) < 0)
4a867032 8281 return -1;
cfaab580 8282 return wpa_driver_nl80211_connect(drv, params);
4a867032 8283 }
cfaab580 8284
add9b7a4 8285 nl80211_mark_disconnected(drv);
c2a04078
JM		 8286
8287 msg = nlmsg_alloc();
8288 if (!msg)
8289 return -1;
8290
8291 wpa_printf(MSG_DEBUG, "nl80211: Associate (ifindex=%d)",
8292 drv->ifindex);
9fb04070 8293 nl80211_cmd(drv, msg, 0, NL80211_CMD_ASSOCIATE);
c2a04078
JM		 8294
8295 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
8296 if (params->bssid) {
8297 wpa_printf(MSG_DEBUG, " * bssid=" MACSTR,
8298 MAC2STR(params->bssid));
8299 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, params->bssid);
8300 }
8301 if (params->freq) {
8302 wpa_printf(MSG_DEBUG, " * freq=%d", params->freq);
8303 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_FREQ, params->freq);
4832ecd7
JM		 8304 drv->assoc_freq = params->freq;
8305 } else
8306 drv->assoc_freq = 0;
1f6c0ab8
BS		 8307 if (params->bg_scan_period >= 0) {
8308 wpa_printf(MSG_DEBUG, " * bg scan period=%d",
8309 params->bg_scan_period);
8310 NLA_PUT_U16(msg, NL80211_ATTR_BG_SCAN_PERIOD,
8311 params->bg_scan_period);
8312 }
c2a04078
JM		 8313 if (params->ssid) {
8314 wpa_hexdump_ascii(MSG_DEBUG, " * SSID",
8315 params->ssid, params->ssid_len);
8316 NLA_PUT(msg, NL80211_ATTR_SSID, params->ssid_len,
8317 params->ssid);
fd05d64e
JM		 8318 if (params->ssid_len > sizeof(drv->ssid))
8319 goto nla_put_failure;
8320 os_memcpy(drv->ssid, params->ssid, params->ssid_len);
8321 drv->ssid_len = params->ssid_len;
c2a04078
JM		 8322 }
8323 wpa_hexdump(MSG_DEBUG, " * IEs", params->wpa_ie, params->wpa_ie_len);
8324 if (params->wpa_ie)
8325 NLA_PUT(msg, NL80211_ATTR_IE, params->wpa_ie_len,
8326 params->wpa_ie);
8327
aca01605
JM		 8328 if (params->pairwise_suite != CIPHER_NONE) {
8329 int cipher;
8330
8331 switch (params->pairwise_suite) {
8332 case CIPHER_WEP40:
8333 cipher = WLAN_CIPHER_SUITE_WEP40;
8334 break;
8335 case CIPHER_WEP104:
8336 cipher = WLAN_CIPHER_SUITE_WEP104;
8337 break;
8338 case CIPHER_CCMP:
8339 cipher = WLAN_CIPHER_SUITE_CCMP;
8340 break;
eb7719ff
JM		 8341 case CIPHER_GCMP:
8342 cipher = WLAN_CIPHER_SUITE_GCMP;
8343 break;
aca01605
JM		 8344 case CIPHER_TKIP:
8345 default:
8346 cipher = WLAN_CIPHER_SUITE_TKIP;
8347 break;
8348 }
79c3124c 8349 wpa_printf(MSG_DEBUG, " * pairwise=0x%x", cipher);
aca01605
JM		 8350 NLA_PUT_U32(msg, NL80211_ATTR_CIPHER_SUITES_PAIRWISE, cipher);
8351 }
8352
8353 if (params->group_suite != CIPHER_NONE) {
8354 int cipher;
8355
8356 switch (params->group_suite) {
8357 case CIPHER_WEP40:
8358 cipher = WLAN_CIPHER_SUITE_WEP40;
8359 break;
8360 case CIPHER_WEP104:
8361 cipher = WLAN_CIPHER_SUITE_WEP104;
8362 break;
8363 case CIPHER_CCMP:
8364 cipher = WLAN_CIPHER_SUITE_CCMP;
8365 break;
eb7719ff
JM		 8366 case CIPHER_GCMP:
8367 cipher = WLAN_CIPHER_SUITE_GCMP;
8368 break;
aca01605
JM		 8369 case CIPHER_TKIP:
8370 default:
8371 cipher = WLAN_CIPHER_SUITE_TKIP;
8372 break;
8373 }
79c3124c 8374 wpa_printf(MSG_DEBUG, " * group=0x%x", cipher);
aca01605
JM		 8375 NLA_PUT_U32(msg, NL80211_ATTR_CIPHER_SUITE_GROUP, cipher);
8376 }
8377
e572fa33
JM		 8378#ifdef CONFIG_IEEE80211W
8379 if (params->mgmt_frame_protection == MGMT_FRAME_PROTECTION_REQUIRED)
8380 NLA_PUT_U32(msg, NL80211_ATTR_USE_MFP, NL80211_MFP_REQUIRED);
8381#endif /* CONFIG_IEEE80211W */
8382
01652550
JM		 8383 NLA_PUT_FLAG(msg, NL80211_ATTR_CONTROL_PORT);
8384
62fa124c
JM		 8385 if (params->prev_bssid) {
8386 wpa_printf(MSG_DEBUG, " * prev_bssid=" MACSTR,
8387 MAC2STR(params->prev_bssid));
8388 NLA_PUT(msg, NL80211_ATTR_PREV_BSSID, ETH_ALEN,
8389 params->prev_bssid);
8390 }
8391
80e8a5ee
BG		 8392 if (params->disable_ht)
8393 NLA_PUT_FLAG(msg, NL80211_ATTR_DISABLE_HT);
8394
8395 if (params->htcaps && params->htcaps_mask) {
8396 int sz = sizeof(struct ieee80211_ht_capabilities);
8397 NLA_PUT(msg, NL80211_ATTR_HT_CAPABILITY, sz, params->htcaps);
8398 NLA_PUT(msg, NL80211_ATTR_HT_CAPABILITY_MASK, sz,
8399 params->htcaps_mask);
8400 }
8401
e9ee8dc3
JB		 8402#ifdef CONFIG_VHT_OVERRIDES
8403 if (params->disable_vht) {
8404 wpa_printf(MSG_DEBUG, " * VHT disabled");
8405 NLA_PUT_FLAG(msg, NL80211_ATTR_DISABLE_VHT);
8406 }
8407
8408 if (params->vhtcaps && params->vhtcaps_mask) {
8409 int sz = sizeof(struct ieee80211_vht_capabilities);
8410 NLA_PUT(msg, NL80211_ATTR_VHT_CAPABILITY, sz, params->vhtcaps);
8411 NLA_PUT(msg, NL80211_ATTR_VHT_CAPABILITY_MASK, sz,
8412 params->vhtcaps_mask);
8413 }
8414#endif /* CONFIG_VHT_OVERRIDES */
8415
046b26a2
JM		 8416 if (params->p2p)
8417 wpa_printf(MSG_DEBUG, " * P2P group");
8418
c2a04078
JM		 8419 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
8420 msg = NULL;
8421 if (ret) {
3b7ea880
BG		 8422 wpa_dbg(drv->ctx, MSG_DEBUG,
8423 "nl80211: MLME command failed (assoc): ret=%d (%s)",
8424 ret, strerror(-ret));
8856462d 8425 nl80211_dump_scan(drv);
c2a04078
JM		 8426 goto nla_put_failure;
8427 }
8428 ret = 0;
8429 wpa_printf(MSG_DEBUG, "nl80211: Association request send "
8430 "successfully");
8431
8432nla_put_failure:
8433 nlmsg_free(msg);
8434 return ret;
8435}
3f5285e8
JM		 8436
8437
ad1e68e6 8438static int nl80211_set_mode(struct wpa_driver_nl80211_data *drv,
a1922f93 8439 int ifindex, enum nl80211_iftype mode)
3f5285e8 8440{
3f5285e8 8441 struct nl_msg *msg;
ad1e68e6
JM		 8442 int ret = -ENOBUFS;
8443
a1922f93
JM		 8444 wpa_printf(MSG_DEBUG, "nl80211: Set mode ifindex %d iftype %d (%s)",
8445 ifindex, mode, nl80211_iftype_str(mode));
8446
ad1e68e6
JM		 8447 msg = nlmsg_alloc();
8448 if (!msg)
8449 return -ENOMEM;
8450
9fb04070 8451 nl80211_cmd(drv, msg, 0, NL80211_CMD_SET_INTERFACE);
834ee56f 8452 if (nl80211_set_iface_id(msg, drv->first_bss) < 0)
f632e483 8453 goto nla_put_failure;
ad1e68e6
JM		 8454 NLA_PUT_U32(msg, NL80211_ATTR_IFTYPE, mode);
8455
8456 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
5883168a 8457 msg = NULL;
ad1e68e6
JM		 8458 if (!ret)
8459 return 0;
8460nla_put_failure:
5883168a 8461 nlmsg_free(msg);
ad1e68e6
JM		 8462 wpa_printf(MSG_DEBUG, "nl80211: Failed to set interface %d to mode %d:"
8463 " %d (%s)", ifindex, mode, ret, strerror(-ret));
8464 return ret;
8465}
8466
8467
b1f625e0
EP		 8468static int wpa_driver_nl80211_set_mode(struct i802_bss *bss,
8469 enum nl80211_iftype nlmode)
ad1e68e6 8470{
a2e40bb6 8471 struct wpa_driver_nl80211_data *drv = bss->drv;
ad1e68e6 8472 int ret = -1;
26af9dca 8473 int i;
86957e62 8474 int was_ap = is_ap_interface(drv->nlmode);
671a5039 8475 int res;
1581b38b 8476
671a5039 8477 res = nl80211_set_mode(drv, drv->ifindex, nlmode);
8e12685c
AS		 8478 if (res && nlmode == nl80211_get_ifmode(bss))
8479 res = 0;
8480
671a5039 8481 if (res == 0) {
ad1e68e6 8482 drv->nlmode = nlmode;
460456f8
JM		 8483 ret = 0;
8484 goto done;
ad1e68e6 8485 }
3f5285e8 8486
671a5039
JM		 8487 if (res == -ENODEV)
8488 return -1;
8489
460456f8 8490 if (nlmode == drv->nlmode) {
c6e8e8e4
JM		 8491 wpa_printf(MSG_DEBUG, "nl80211: Interface already in "
8492 "requested mode - ignore error");
460456f8
JM		 8493 ret = 0;
8494 goto done; /* Already in the requested mode */
8495 }
3f5285e8 8496
3f5285e8
JM		 8497 /* mac80211 doesn't allow mode changes while the device is up, so
8498 * take the device down, try to set the mode again, and bring the
8499 * device back up.
8500 */
26af9dca
JM		 8501 wpa_printf(MSG_DEBUG, "nl80211: Try mode change after setting "
8502 "interface down");
8503 for (i = 0; i < 10; i++) {
91724d6f 8504 res = i802_set_iface_flags(bss, 0);
6e8183d7
JM		 8505 if (res == -EACCES || res == -ENODEV)
8506 break;
8507 if (res == 0) {
26af9dca
JM		 8508 /* Try to set the mode again while the interface is
8509 * down */
8510 ret = nl80211_set_mode(drv, drv->ifindex, nlmode);
6e8183d7
JM		 8511 if (ret == -EACCES)
8512 break;
91724d6f 8513 res = i802_set_iface_flags(bss, 1);
6e8183d7 8514 if (res && !ret)
26af9dca 8515 ret = -1;
6e8183d7 8516 else if (ret != -EBUSY)
26af9dca
JM		 8517 break;
8518 } else
8519 wpa_printf(MSG_DEBUG, "nl80211: Failed to set "
8520 "interface down");
8521 os_sleep(0, 100000);
3f5285e8
JM		 8522 }
8523
c6e8e8e4
JM		 8524 if (!ret) {
8525 wpa_printf(MSG_DEBUG, "nl80211: Mode change succeeded while "
8526 "interface is down");
ad1e68e6 8527 drv->nlmode = nlmode;
7d9c3698 8528 drv->ignore_if_down_event = 1;
c6e8e8e4 8529 }
ad1e68e6 8530
460456f8 8531done:
3fd1cefb
JB		 8532 if (ret) {
8533 wpa_printf(MSG_DEBUG, "nl80211: Interface mode change to %d "
8534 "from %d failed", nlmode, drv->nlmode);
8535 return ret;
8536 }
8537
6a71413e 8538 if (is_p2p_net_interface(nlmode))
edb9bfba 8539 nl80211_disable_11b_rates(drv, drv->ifindex, 1);
1d0c6fb1
JM		 8540 else if (drv->disabled_11b_rates)
8541 nl80211_disable_11b_rates(drv, drv->ifindex, 0);
edb9bfba 8542
3fd1cefb 8543 if (is_ap_interface(nlmode)) {
36488c05 8544 nl80211_mgmt_unsubscribe(bss, "start AP");
460456f8 8545 /* Setup additional AP mode functionality if needed */
3fd1cefb 8546 if (nl80211_setup_ap(bss))
460456f8 8547 return -1;
3fd1cefb 8548 } else if (was_ap) {
460456f8 8549 /* Remove additional AP mode functionality */
3fd1cefb 8550 nl80211_teardown_ap(bss);
a11241fa 8551 } else {
36488c05 8552 nl80211_mgmt_unsubscribe(bss, "mode change");
460456f8 8553 }
460456f8 8554
873d0fcf 8555 if (!bss->in_deinit && !is_ap_interface(nlmode) &&
a11241fa
JB		 8556 nl80211_mgmt_subscribe_non_ap(bss) < 0)
8557 wpa_printf(MSG_DEBUG, "nl80211: Failed to register Action "
8558 "frame processing - ignore for now");
08359050 8559
3fd1cefb 8560 return 0;
3f5285e8
JM		 8561}
8562
8563
3f5285e8
JM		 8564static int wpa_driver_nl80211_get_capa(void *priv,
8565 struct wpa_driver_capa *capa)
8566{
a2e40bb6
FF		 8567 struct i802_bss *bss = priv;
8568 struct wpa_driver_nl80211_data *drv = bss->drv;
3f5285e8
JM		 8569 if (!drv->has_capability)
8570 return -1;
8571 os_memcpy(capa, &drv->capa, sizeof(*capa));
8cd6b7bc
JB		 8572 if (drv->extended_capa && drv->extended_capa_mask) {
8573 capa->extended_capa = drv->extended_capa;
8574 capa->extended_capa_mask = drv->extended_capa_mask;
8575 capa->extended_capa_len = drv->extended_capa_len;
8576 }
851b0c55
JM		 8577
8578 if ((capa->flags & WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE) &&
8579 !drv->allow_p2p_device) {
8580 wpa_printf(MSG_DEBUG, "nl80211: Do not indicate P2P_DEVICE support (p2p_device=1 driver param not specified)");
8581 capa->flags &= ~WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE;
8582 }
8583
3f5285e8
JM		 8584 return 0;
8585}
8586
8587
8588static int wpa_driver_nl80211_set_operstate(void *priv, int state)
8589{
a2e40bb6
FF		 8590 struct i802_bss *bss = priv;
8591 struct wpa_driver_nl80211_data *drv = bss->drv;
3f5285e8
JM		 8592
8593 wpa_printf(MSG_DEBUG, "%s: operstate %d->%d (%s)",
8594 __func__, drv->operstate, state, state ? "UP" : "DORMANT");
8595 drv->operstate = state;
36d84860 8596 return netlink_send_oper_ifla(drv->global->netlink, drv->ifindex, -1,
e2d02c29 8597 state ? IF_OPER_UP : IF_OPER_DORMANT);
3f5285e8
JM		 8598}
8599
01652550
JM		 8600
8601static int wpa_driver_nl80211_set_supp_port(void *priv, int authorized)
8602{
a2e40bb6
FF		 8603 struct i802_bss *bss = priv;
8604 struct wpa_driver_nl80211_data *drv = bss->drv;
01652550
JM		 8605 struct nl_msg *msg;
8606 struct nl80211_sta_flag_update upd;
8607
1ba51ec0
JM		 8608 wpa_printf(MSG_DEBUG, "nl80211: Set supplicant port %sauthorized for "
8609 MACSTR, authorized ? "" : "un", MAC2STR(drv->bssid));
8610
01652550
JM		 8611 msg = nlmsg_alloc();
8612 if (!msg)
8613 return -ENOMEM;
8614
9fb04070 8615 nl80211_cmd(drv, msg, 0, NL80211_CMD_SET_STATION);
01652550
JM		 8616
8617 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX,
a2e40bb6 8618 if_nametoindex(bss->ifname));
01652550
JM		 8619 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, drv->bssid);
8620
8621 os_memset(&upd, 0, sizeof(upd));
8622 upd.mask = BIT(NL80211_STA_FLAG_AUTHORIZED);
8623 if (authorized)
8624 upd.set = BIT(NL80211_STA_FLAG_AUTHORIZED);
8625 NLA_PUT(msg, NL80211_ATTR_STA_FLAGS2, sizeof(upd), &upd);
8626
8627 return send_and_recv_msgs(drv, msg, NULL, NULL);
8628 nla_put_failure:
5883168a 8629 nlmsg_free(msg);
01652550
JM		 8630 return -ENOBUFS;
8631}
8632
3f5285e8 8633
f07ead6a
JM		 8634/* Set kernel driver on given frequency (MHz) */
8635static int i802_set_freq(void *priv, struct hostapd_freq_params *freq)
c5121837 8636{
f07ead6a 8637 struct i802_bss *bss = priv;
89b800d7 8638 return wpa_driver_nl80211_set_freq(bss, freq);
c5121837
JM		 8639}
8640
f7b3920c 8641
c5121837
JM		 8642static inline int min_int(int a, int b)
8643{
8644 if (a < b)
8645 return a;
8646 return b;
8647}
8648
8649
8650static int get_key_handler(struct nl_msg *msg, void *arg)
8651{
8652 struct nlattr *tb[NL80211_ATTR_MAX + 1];
8653 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
8654
8655 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
8656 genlmsg_attrlen(gnlh, 0), NULL);
8657
8658 /*
8659 * TODO: validate the key index and mac address!
8660 * Otherwise, there's a race condition as soon as
8661 * the kernel starts sending key notifications.
8662 */
8663
8664 if (tb[NL80211_ATTR_KEY_SEQ])
8665 memcpy(arg, nla_data(tb[NL80211_ATTR_KEY_SEQ]),
8666 min_int(nla_len(tb[NL80211_ATTR_KEY_SEQ]), 6));
8667 return NL_SKIP;
8668}
8669
8670
8671static int i802_get_seqnum(const char *iface, void *priv, const u8 *addr,
8672 int idx, u8 *seq)
8673{
a2e40bb6
FF		 8674 struct i802_bss *bss = priv;
8675 struct wpa_driver_nl80211_data *drv = bss->drv;
c5121837
JM		 8676 struct nl_msg *msg;
8677
8678 msg = nlmsg_alloc();
8679 if (!msg)
8680 return -ENOMEM;
8681
9fb04070 8682 nl80211_cmd(drv, msg, 0, NL80211_CMD_GET_KEY);
c5121837
JM		 8683
8684 if (addr)
8685 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, addr);
8686 NLA_PUT_U8(msg, NL80211_ATTR_KEY_IDX, idx);
8687 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, if_nametoindex(iface));
8688
8689 memset(seq, 0, 6);
8690
8691 return send_and_recv_msgs(drv, msg, get_key_handler, seq);
8692 nla_put_failure:
9e088e74 8693 nlmsg_free(msg);
c5121837
JM		 8694 return -ENOBUFS;
8695}
8696
8697
c5121837
JM		 8698static int i802_set_rts(void *priv, int rts)
8699{
a2e40bb6
FF		 8700 struct i802_bss *bss = priv;
8701 struct wpa_driver_nl80211_data *drv = bss->drv;
ad649451
JM		 8702 struct nl_msg *msg;
8703 int ret = -ENOBUFS;
8704 u32 val;
c5121837 8705
ad649451
JM		 8706 msg = nlmsg_alloc();
8707 if (!msg)
8708 return -ENOMEM;
c5121837 8709
ad649451
JM		 8710 if (rts >= 2347)
8711 val = (u32) -1;
8712 else
8713 val = rts;
c5121837 8714
9fb04070 8715 nl80211_cmd(drv, msg, 0, NL80211_CMD_SET_WIPHY);
ad649451
JM		 8716 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
8717 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_RTS_THRESHOLD, val);
8718
8719 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
5883168a 8720 msg = NULL;
ad649451
JM		 8721 if (!ret)
8722 return 0;
8723nla_put_failure:
5883168a 8724 nlmsg_free(msg);
ad649451
JM		 8725 wpa_printf(MSG_DEBUG, "nl80211: Failed to set RTS threshold %d: "
8726 "%d (%s)", rts, ret, strerror(-ret));
8727 return ret;
c5121837
JM		 8728}
8729
8730
8731static int i802_set_frag(void *priv, int frag)
8732{
a2e40bb6
FF		 8733 struct i802_bss *bss = priv;
8734 struct wpa_driver_nl80211_data *drv = bss->drv;
ad649451
JM		 8735 struct nl_msg *msg;
8736 int ret = -ENOBUFS;
8737 u32 val;
c5121837 8738
ad649451
JM		 8739 msg = nlmsg_alloc();
8740 if (!msg)
8741 return -ENOMEM;
c5121837 8742
ad649451
JM		 8743 if (frag >= 2346)
8744 val = (u32) -1;
8745 else
8746 val = frag;
c5121837 8747
9fb04070 8748 nl80211_cmd(drv, msg, 0, NL80211_CMD_SET_WIPHY);
ad649451
JM		 8749 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
8750 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_FRAG_THRESHOLD, val);
8751
8752 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
5883168a 8753 msg = NULL;
ad649451
JM		 8754 if (!ret)
8755 return 0;
8756nla_put_failure:
5883168a 8757 nlmsg_free(msg);
ad649451
JM		 8758 wpa_printf(MSG_DEBUG, "nl80211: Failed to set fragmentation threshold "
8759 "%d: %d (%s)", frag, ret, strerror(-ret));
8760 return ret;
c5121837
JM		 8761}
8762
8763
c5121837
JM		 8764static int i802_flush(void *priv)
8765{
a2e40bb6
FF		 8766 struct i802_bss *bss = priv;
8767 struct wpa_driver_nl80211_data *drv = bss->drv;
c5121837 8768 struct nl_msg *msg;
82554b10 8769 int res;
c5121837
JM		 8770
8771 msg = nlmsg_alloc();
8772 if (!msg)
8773 return -1;
8774
83e7bb0e
JM		 8775 wpa_printf(MSG_DEBUG, "nl80211: flush -> DEL_STATION %s (all)",
8776 bss->ifname);
9fb04070 8777 nl80211_cmd(drv, msg, 0, NL80211_CMD_DEL_STATION);
c5121837
JM		 8778
8779 /*
8780 * XXX: FIX! this needs to flush all VLANs too
8781 */
8782 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX,
a2e40bb6 8783 if_nametoindex(bss->ifname));
c5121837 8784
82554b10
JM		 8785 res = send_and_recv_msgs(drv, msg, NULL, NULL);
8786 if (res) {
8787 wpa_printf(MSG_DEBUG, "nl80211: Station flush failed: ret=%d "
8788 "(%s)", res, strerror(-res));
8789 }
8790 return res;
c5121837 8791 nla_put_failure:
9e088e74 8792 nlmsg_free(msg);
c5121837
JM		 8793 return -ENOBUFS;
8794}
8795
8796
8797static int get_sta_handler(struct nl_msg *msg, void *arg)
8798{
8799 struct nlattr *tb[NL80211_ATTR_MAX + 1];
8800 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
8801 struct hostap_sta_driver_data *data = arg;
8802 struct nlattr *stats[NL80211_STA_INFO_MAX + 1];
8803 static struct nla_policy stats_policy[NL80211_STA_INFO_MAX + 1] = {
8804 [NL80211_STA_INFO_INACTIVE_TIME] = { .type = NLA_U32 },
8805 [NL80211_STA_INFO_RX_BYTES] = { .type = NLA_U32 },
8806 [NL80211_STA_INFO_TX_BYTES] = { .type = NLA_U32 },
8807 [NL80211_STA_INFO_RX_PACKETS] = { .type = NLA_U32 },
8808 [NL80211_STA_INFO_TX_PACKETS] = { .type = NLA_U32 },
dc7785f8 8809 [NL80211_STA_INFO_TX_FAILED] = { .type = NLA_U32 },
c5121837
JM		 8810 };
8811
8812 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
8813 genlmsg_attrlen(gnlh, 0), NULL);
8814
8815 /*
8816 * TODO: validate the interface and mac address!
8817 * Otherwise, there's a race condition as soon as
8818 * the kernel starts sending station notifications.
8819 */
8820
8821 if (!tb[NL80211_ATTR_STA_INFO]) {
8822 wpa_printf(MSG_DEBUG, "sta stats missing!");
8823 return NL_SKIP;
8824 }
8825 if (nla_parse_nested(stats, NL80211_STA_INFO_MAX,
8826 tb[NL80211_ATTR_STA_INFO],
8827 stats_policy)) {
8828 wpa_printf(MSG_DEBUG, "failed to parse nested attributes!");
8829 return NL_SKIP;
8830 }
8831
8832 if (stats[NL80211_STA_INFO_INACTIVE_TIME])
8833 data->inactive_msec =
8834 nla_get_u32(stats[NL80211_STA_INFO_INACTIVE_TIME]);
8835 if (stats[NL80211_STA_INFO_RX_BYTES])
8836 data->rx_bytes = nla_get_u32(stats[NL80211_STA_INFO_RX_BYTES]);
8837 if (stats[NL80211_STA_INFO_TX_BYTES])
8838 data->tx_bytes = nla_get_u32(stats[NL80211_STA_INFO_TX_BYTES]);
8839 if (stats[NL80211_STA_INFO_RX_PACKETS])
8840 data->rx_packets =
8841 nla_get_u32(stats[NL80211_STA_INFO_RX_PACKETS]);
8842 if (stats[NL80211_STA_INFO_TX_PACKETS])
8843 data->tx_packets =
8844 nla_get_u32(stats[NL80211_STA_INFO_TX_PACKETS]);
dc7785f8
YZ		 8845 if (stats[NL80211_STA_INFO_TX_FAILED])
8846 data->tx_retry_failed =
8847 nla_get_u32(stats[NL80211_STA_INFO_TX_FAILED]);
c5121837
JM		 8848
8849 return NL_SKIP;
8850}
8851
9ebce9c5
JM		 8852static int i802_read_sta_data(struct i802_bss *bss,
8853 struct hostap_sta_driver_data *data,
c5121837
JM		 8854 const u8 *addr)
8855{
a2e40bb6 8856 struct wpa_driver_nl80211_data *drv = bss->drv;
c5121837
JM		 8857 struct nl_msg *msg;
8858
8859 os_memset(data, 0, sizeof(*data));
8860 msg = nlmsg_alloc();
8861 if (!msg)
8862 return -ENOMEM;
8863
9fb04070 8864 nl80211_cmd(drv, msg, 0, NL80211_CMD_GET_STATION);
c5121837
JM		 8865
8866 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, addr);
a2e40bb6 8867 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, if_nametoindex(bss->ifname));
c5121837
JM		 8868
8869 return send_and_recv_msgs(drv, msg, get_sta_handler, data);
8870 nla_put_failure:
9e088e74 8871 nlmsg_free(msg);
c5121837
JM		 8872 return -ENOBUFS;
8873}
8874
8875
c5121837
JM		 8876static int i802_set_tx_queue_params(void *priv, int queue, int aifs,
8877 int cw_min, int cw_max, int burst_time)
8878{
a2e40bb6
FF		 8879 struct i802_bss *bss = priv;
8880 struct wpa_driver_nl80211_data *drv = bss->drv;
c5121837
JM		 8881 struct nl_msg *msg;
8882 struct nlattr *txq, *params;
8883
8884 msg = nlmsg_alloc();
8885 if (!msg)
8886 return -1;
8887
9fb04070 8888 nl80211_cmd(drv, msg, 0, NL80211_CMD_SET_WIPHY);
c5121837 8889
a2e40bb6 8890 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, if_nametoindex(bss->ifname));
c5121837
JM		 8891
8892 txq = nla_nest_start(msg, NL80211_ATTR_WIPHY_TXQ_PARAMS);
8893 if (!txq)
8894 goto nla_put_failure;
8895
8896 /* We are only sending parameters for a single TXQ at a time */
8897 params = nla_nest_start(msg, 1);
8898 if (!params)
8899 goto nla_put_failure;
8900
7e3c1781
JM		 8901 switch (queue) {
8902 case 0:
8903 NLA_PUT_U8(msg, NL80211_TXQ_ATTR_QUEUE, NL80211_TXQ_Q_VO);
8904 break;
8905 case 1:
8906 NLA_PUT_U8(msg, NL80211_TXQ_ATTR_QUEUE, NL80211_TXQ_Q_VI);
8907 break;
8908 case 2:
8909 NLA_PUT_U8(msg, NL80211_TXQ_ATTR_QUEUE, NL80211_TXQ_Q_BE);
8910 break;
8911 case 3:
8912 NLA_PUT_U8(msg, NL80211_TXQ_ATTR_QUEUE, NL80211_TXQ_Q_BK);
8913 break;
8914 }
c5121837
JM		 8915 /* Burst time is configured in units of 0.1 msec and TXOP parameter in
8916 * 32 usec, so need to convert the value here. */
8917 NLA_PUT_U16(msg, NL80211_TXQ_ATTR_TXOP, (burst_time * 100 + 16) / 32);
8918 NLA_PUT_U16(msg, NL80211_TXQ_ATTR_CWMIN, cw_min);
8919 NLA_PUT_U16(msg, NL80211_TXQ_ATTR_CWMAX, cw_max);
8920 NLA_PUT_U8(msg, NL80211_TXQ_ATTR_AIFS, aifs);
8921
8922 nla_nest_end(msg, params);
8923
8924 nla_nest_end(msg, txq);
8925
8926 if (send_and_recv_msgs(drv, msg, NULL, NULL) == 0)
8927 return 0;
9e088e74 8928 msg = NULL;
c5121837 8929 nla_put_failure:
9e088e74 8930 nlmsg_free(msg);
c5121837
JM		 8931 return -1;
8932}
8933
8934
9ebce9c5 8935static int i802_set_sta_vlan(struct i802_bss *bss, const u8 *addr,
c5121837
JM		 8936 const char *ifname, int vlan_id)
8937{
a2e40bb6 8938 struct wpa_driver_nl80211_data *drv = bss->drv;
c5121837 8939 struct nl_msg *msg;
cd1d72c1 8940 int ret = -ENOBUFS;
c5121837
JM		 8941
8942 msg = nlmsg_alloc();
8943 if (!msg)
8944 return -ENOMEM;
8945
bbc706a3
JM		 8946 wpa_printf(MSG_DEBUG, "nl80211: %s[%d]: set_sta_vlan(" MACSTR
8947 ", ifname=%s[%d], vlan_id=%d)",
8948 bss->ifname, if_nametoindex(bss->ifname),
8949 MAC2STR(addr), ifname, if_nametoindex(ifname), vlan_id);
9fb04070 8950 nl80211_cmd(drv, msg, 0, NL80211_CMD_SET_STATION);
c5121837
JM		 8951
8952 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX,
a2e40bb6 8953 if_nametoindex(bss->ifname));
c5121837 8954 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, addr);
1c766b09 8955 NLA_PUT_U32(msg, NL80211_ATTR_STA_VLAN,
c5121837
JM		 8956 if_nametoindex(ifname));
8957
cd1d72c1 8958 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
9e088e74 8959 msg = NULL;
cd1d72c1
JM		 8960 if (ret < 0) {
8961 wpa_printf(MSG_ERROR, "nl80211: NL80211_ATTR_STA_VLAN (addr="
8962 MACSTR " ifname=%s vlan_id=%d) failed: %d (%s)",
8963 MAC2STR(addr), ifname, vlan_id, ret,
8964 strerror(-ret));
8965 }
c5121837 8966 nla_put_failure:
9e088e74 8967 nlmsg_free(msg);
cd1d72c1 8968 return ret;
c5121837
JM		 8969}
8970
fbbfcbac 8971
c5121837
JM		 8972static int i802_get_inact_sec(void *priv, const u8 *addr)
8973{
8974 struct hostap_sta_driver_data data;
8975 int ret;
8976
8977 data.inactive_msec = (unsigned long) -1;
8978 ret = i802_read_sta_data(priv, &data, addr);
8979 if (ret || data.inactive_msec == (unsigned long) -1)
8980 return -1;
8981 return data.inactive_msec / 1000;
8982}
8983
8984
8985static int i802_sta_clear_stats(void *priv, const u8 *addr)
8986{
8987#if 0
8988 /* TODO */
8989#endif
8990 return 0;
8991}
8992
8993
731723a5
JM		 8994static int i802_sta_deauth(void *priv, const u8 *own_addr, const u8 *addr,
8995 int reason)
c5121837 8996{
a2e40bb6 8997 struct i802_bss *bss = priv;
e1bd4e19 8998 struct wpa_driver_nl80211_data *drv = bss->drv;
c5121837
JM		 8999 struct ieee80211_mgmt mgmt;
9000
e1bd4e19
AT		 9001 if (drv->device_ap_sme)
9002 return wpa_driver_nl80211_sta_remove(bss, addr);
9003
c5121837
JM		 9004 memset(&mgmt, 0, sizeof(mgmt));
9005 mgmt.frame_control = IEEE80211_FC(WLAN_FC_TYPE_MGMT,
9006 WLAN_FC_STYPE_DEAUTH);
9007 memcpy(mgmt.da, addr, ETH_ALEN);
731723a5
JM		 9008 memcpy(mgmt.sa, own_addr, ETH_ALEN);
9009 memcpy(mgmt.bssid, own_addr, ETH_ALEN);
c5121837 9010 mgmt.u.deauth.reason_code = host_to_le16(reason);
a2e40bb6 9011 return wpa_driver_nl80211_send_mlme(bss, (u8 *) &mgmt,
9f324b61 9012 IEEE80211_HDRLEN +
9ebce9c5
JM		 9013 sizeof(mgmt.u.deauth), 0, 0, 0, 0,
9014 0);
c5121837
JM		 9015}
9016
9017
731723a5
JM		 9018static int i802_sta_disassoc(void *priv, const u8 *own_addr, const u8 *addr,
9019 int reason)
c5121837 9020{
a2e40bb6 9021 struct i802_bss *bss = priv;
e1bd4e19 9022 struct wpa_driver_nl80211_data *drv = bss->drv;
c5121837
JM		 9023 struct ieee80211_mgmt mgmt;
9024
e1bd4e19
AT		 9025 if (drv->device_ap_sme)
9026 return wpa_driver_nl80211_sta_remove(bss, addr);
9027
c5121837
JM		 9028 memset(&mgmt, 0, sizeof(mgmt));
9029 mgmt.frame_control = IEEE80211_FC(WLAN_FC_TYPE_MGMT,
9030 WLAN_FC_STYPE_DISASSOC);
9031 memcpy(mgmt.da, addr, ETH_ALEN);
731723a5
JM		 9032 memcpy(mgmt.sa, own_addr, ETH_ALEN);
9033 memcpy(mgmt.bssid, own_addr, ETH_ALEN);
c5121837 9034 mgmt.u.disassoc.reason_code = host_to_le16(reason);
a2e40bb6 9035 return wpa_driver_nl80211_send_mlme(bss, (u8 *) &mgmt,
9f324b61 9036 IEEE80211_HDRLEN +
9ebce9c5
JM		 9037 sizeof(mgmt.u.disassoc), 0, 0, 0, 0,
9038 0);
c5121837
JM		 9039}
9040
9041
f07ead6a
JM		 9042static void add_ifidx(struct wpa_driver_nl80211_data *drv, int ifidx)
9043{
9044 int i;
9045 int *old;
9046
9047 wpa_printf(MSG_DEBUG, "nl80211: Add own interface ifindex %d",
9048 ifidx);
9049 for (i = 0; i < drv->num_if_indices; i++) {
9050 if (drv->if_indices[i] == 0) {
9051 drv->if_indices[i] = ifidx;
9052 return;
9053 }
9054 }
9055
9056 if (drv->if_indices != drv->default_if_indices)
9057 old = drv->if_indices;
9058 else
9059 old = NULL;
9060
067ffa26
JM		 9061 drv->if_indices = os_realloc_array(old, drv->num_if_indices + 1,
9062 sizeof(int));
f07ead6a
JM		 9063 if (!drv->if_indices) {
9064 if (!old)
9065 drv->if_indices = drv->default_if_indices;
9066 else
9067 drv->if_indices = old;
9068 wpa_printf(MSG_ERROR, "Failed to reallocate memory for "
9069 "interfaces");
9070 wpa_printf(MSG_ERROR, "Ignoring EAPOL on interface %d", ifidx);
9071 return;
9072 } else if (!old)
9073 os_memcpy(drv->if_indices, drv->default_if_indices,
9074 sizeof(drv->default_if_indices));
9075 drv->if_indices[drv->num_if_indices] = ifidx;
9076 drv->num_if_indices++;
9077}
9078
9079
9080static void del_ifidx(struct wpa_driver_nl80211_data *drv, int ifidx)
9081{
9082 int i;
9083
9084 for (i = 0; i < drv->num_if_indices; i++) {
9085 if (drv->if_indices[i] == ifidx) {
9086 drv->if_indices[i] = 0;
9087 break;
9088 }
9089 }
9090}
9091
9092
9093static int have_ifidx(struct wpa_driver_nl80211_data *drv, int ifidx)
9094{
9095 int i;
9096
9097 for (i = 0; i < drv->num_if_indices; i++)
9098 if (drv->if_indices[i] == ifidx)
9099 return 1;
9100
9101 return 0;
9102}
9103
9104
9105static int i802_set_wds_sta(void *priv, const u8 *addr, int aid, int val,
69dd2967 9106 const char *bridge_ifname, char *ifname_wds)
f07ead6a
JM		 9107{
9108 struct i802_bss *bss = priv;
9109 struct wpa_driver_nl80211_data *drv = bss->drv;
9110 char name[IFNAMSIZ + 1];
9111
9112 os_snprintf(name, sizeof(name), "%s.sta%d", bss->ifname, aid);
69dd2967
SM		 9113 if (ifname_wds)
9114 os_strlcpy(ifname_wds, name, IFNAMSIZ + 1);
9115
f07ead6a
JM		 9116 wpa_printf(MSG_DEBUG, "nl80211: Set WDS STA addr=" MACSTR
9117 " aid=%d val=%d name=%s", MAC2STR(addr), aid, val, name);
9118 if (val) {
9119 if (!if_nametoindex(name)) {
9120 if (nl80211_create_iface(drv, name,
9121 NL80211_IFTYPE_AP_VLAN,
2aec4f3c
JM		 9122 bss->addr, 1, NULL, NULL, 0) <
9123 0)
f07ead6a
JM		 9124 return -1;
9125 if (bridge_ifname &&
c81eff1a
BG		 9126 linux_br_add_if(drv->global->ioctl_sock,
9127 bridge_ifname, name) < 0)
f07ead6a
JM		 9128 return -1;
9129 }
75227f3a
JM		 9130 if (linux_set_iface_flags(drv->global->ioctl_sock, name, 1)) {
9131 wpa_printf(MSG_ERROR, "nl80211: Failed to set WDS STA "
9132 "interface %s up", name);
9133 }
f07ead6a
JM		 9134 return i802_set_sta_vlan(priv, addr, name, 0);
9135 } else {
c34e618d
FF		 9136 if (bridge_ifname)
9137 linux_br_del_if(drv->global->ioctl_sock, bridge_ifname,
9138 name);
9139
f07ead6a
JM		 9140 i802_set_sta_vlan(priv, addr, bss->ifname, 0);
9141 return wpa_driver_nl80211_if_remove(priv, WPA_IF_AP_VLAN,
9142 name);
9143 }
9144}
9145
9146
9147static void handle_eapol(int sock, void *eloop_ctx, void *sock_ctx)
9148{
9149 struct wpa_driver_nl80211_data *drv = eloop_ctx;
9150 struct sockaddr_ll lladdr;
9151 unsigned char buf[3000];
9152 int len;
9153 socklen_t fromlen = sizeof(lladdr);
9154
9155 len = recvfrom(sock, buf, sizeof(buf), 0,
9156 (struct sockaddr *)&lladdr, &fromlen);
9157 if (len < 0) {
7ac3616d
JM		 9158 wpa_printf(MSG_ERROR, "nl80211: EAPOL recv failed: %s",
9159 strerror(errno));
f07ead6a
JM		 9160 return;
9161 }
9162
9163 if (have_ifidx(drv, lladdr.sll_ifindex))
9164 drv_event_eapol_rx(drv->ctx, lladdr.sll_addr, buf, len);
9165}
9166
9167
94627f6c 9168static int i802_check_bridge(struct wpa_driver_nl80211_data *drv,
e17a2477 9169 struct i802_bss *bss,
94627f6c
JM		 9170 const char *brname, const char *ifname)
9171{
9172 int ifindex;
9173 char in_br[IFNAMSIZ];
9174
e17a2477 9175 os_strlcpy(bss->brname, brname, IFNAMSIZ);
94627f6c
JM		 9176 ifindex = if_nametoindex(brname);
9177 if (ifindex == 0) {
9178 /*
9179 * Bridge was configured, but the bridge device does
9180 * not exist. Try to add it now.
9181 */
c81eff1a 9182 if (linux_br_add(drv->global->ioctl_sock, brname) < 0) {
94627f6c
JM		 9183 wpa_printf(MSG_ERROR, "nl80211: Failed to add the "
9184 "bridge interface %s: %s",
9185 brname, strerror(errno));
9186 return -1;
9187 }
e17a2477 9188 bss->added_bridge = 1;
94627f6c
JM		 9189 add_ifidx(drv, if_nametoindex(brname));
9190 }
9191
9192 if (linux_br_get(in_br, ifname) == 0) {
9193 if (os_strcmp(in_br, brname) == 0)
9194 return 0; /* already in the bridge */
9195
9196 wpa_printf(MSG_DEBUG, "nl80211: Removing interface %s from "
9197 "bridge %s", ifname, in_br);
c81eff1a
BG		 9198 if (linux_br_del_if(drv->global->ioctl_sock, in_br, ifname) <
9199 0) {
94627f6c
JM		 9200 wpa_printf(MSG_ERROR, "nl80211: Failed to "
9201 "remove interface %s from bridge "
9202 "%s: %s",
9203 ifname, brname, strerror(errno));
9204 return -1;
9205 }
9206 }
9207
9208 wpa_printf(MSG_DEBUG, "nl80211: Adding interface %s into bridge %s",
9209 ifname, brname);
c81eff1a 9210 if (linux_br_add_if(drv->global->ioctl_sock, brname, ifname) < 0) {
94627f6c
JM		 9211 wpa_printf(MSG_ERROR, "nl80211: Failed to add interface %s "
9212 "into bridge %s: %s",
9213 ifname, brname, strerror(errno));
9214 return -1;
9215 }
e17a2477 9216 bss->added_if_into_bridge = 1;
94627f6c
JM		 9217
9218 return 0;
9219}
9220
9221
92f475b4
JM		 9222static void *i802_init(struct hostapd_data *hapd,
9223 struct wpa_init_params *params)
c5121837
JM		 9224{
9225 struct wpa_driver_nl80211_data *drv;
a2e40bb6 9226 struct i802_bss *bss;
c5121837 9227 size_t i;
94627f6c
JM		 9228 char brname[IFNAMSIZ];
9229 int ifindex, br_ifindex;
9230 int br_added = 0;
c5121837 9231
0d547d5f
JM		 9232 bss = wpa_driver_nl80211_drv_init(hapd, params->ifname,
9233 params->global_priv, 1,
9234 params->bssid);
a2e40bb6 9235 if (bss == NULL)
c5121837 9236 return NULL;
c5121837 9237
a2e40bb6 9238 drv = bss->drv;
7635bfb0 9239
94627f6c
JM		 9240 if (linux_br_get(brname, params->ifname) == 0) {
9241 wpa_printf(MSG_DEBUG, "nl80211: Interface %s is in bridge %s",
9242 params->ifname, brname);
9243 br_ifindex = if_nametoindex(brname);
9244 } else {
9245 brname[0] = '\0';
9246 br_ifindex = 0;
9247 }
9248
92f475b4 9249 for (i = 0; i < params->num_bridge; i++) {
94627f6c
JM		 9250 if (params->bridge[i]) {
9251 ifindex = if_nametoindex(params->bridge[i]);
9252 if (ifindex)
9253 add_ifidx(drv, ifindex);
9254 if (ifindex == br_ifindex)
9255 br_added = 1;
9256 }
c5121837 9257 }
94627f6c
JM		 9258 if (!br_added && br_ifindex &&
9259 (params->num_bridge == 0 || !params->bridge[0]))
9260 add_ifidx(drv, br_ifindex);
c5121837 9261
ad1e68e6
JM		 9262 /* start listening for EAPOL on the default AP interface */
9263 add_ifidx(drv, drv->ifindex);
9264
94627f6c 9265 if (params->num_bridge && params->bridge[0] &&
e17a2477 9266 i802_check_bridge(drv, bss, params->bridge[0], params->ifname) < 0)
94627f6c
JM		 9267 goto failed;
9268
ad1e68e6
JM		 9269 drv->eapol_sock = socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_PAE));
9270 if (drv->eapol_sock < 0) {
7ac3616d
JM		 9271 wpa_printf(MSG_ERROR, "nl80211: socket(PF_PACKET, SOCK_DGRAM, ETH_P_PAE) failed: %s",
9272 strerror(errno));
bbaf0837 9273 goto failed;
ad1e68e6
JM		 9274 }
9275
9276 if (eloop_register_read_sock(drv->eapol_sock, handle_eapol, drv, NULL))
9277 {
7ac3616d 9278 wpa_printf(MSG_INFO, "nl80211: Could not register read socket for eapol");
c5121837 9279 goto failed;
ad1e68e6
JM		 9280 }
9281
c81eff1a
BG		 9282 if (linux_get_ifhwaddr(drv->global->ioctl_sock, bss->ifname,
9283 params->own_addr))
bbaf0837 9284 goto failed;
c5121837 9285
341eebee
JB		 9286 memcpy(bss->addr, params->own_addr, ETH_ALEN);
9287
a2e40bb6 9288 return bss;
c5121837
JM		 9289
9290failed:
7635bfb0 9291 wpa_driver_nl80211_deinit(bss);
bbaf0837
JM		 9292 return NULL;
9293}
c5121837 9294
c5121837 9295
bbaf0837
JM		 9296static void i802_deinit(void *priv)
9297{
9ebce9c5
JM		 9298 struct i802_bss *bss = priv;
9299 wpa_driver_nl80211_deinit(bss);
c5121837
JM		 9300}
9301
c5121837 9302
22a7c9d7
JM		 9303static enum nl80211_iftype wpa_driver_nl80211_if_type(
9304 enum wpa_driver_if_type type)
9305{
9306 switch (type) {
9307 case WPA_IF_STATION:
9f51b113 9308 return NL80211_IFTYPE_STATION;
75bde05d
JM		 9309 case WPA_IF_P2P_CLIENT:
9310 case WPA_IF_P2P_GROUP:
9f51b113 9311 return NL80211_IFTYPE_P2P_CLIENT;
22a7c9d7
JM		 9312 case WPA_IF_AP_VLAN:
9313 return NL80211_IFTYPE_AP_VLAN;
9314 case WPA_IF_AP_BSS:
9315 return NL80211_IFTYPE_AP;
9f51b113
JB		 9316 case WPA_IF_P2P_GO:
9317 return NL80211_IFTYPE_P2P_GO;
7aad838c
NS		 9318 case WPA_IF_P2P_DEVICE:
9319 return NL80211_IFTYPE_P2P_DEVICE;
22a7c9d7
JM		 9320 }
9321 return -1;
9322}
9323
9324
482856c8
JM		 9325#ifdef CONFIG_P2P
9326
f2ed8023
JM		 9327static int nl80211_addr_in_use(struct nl80211_global *global, const u8 *addr)
9328{
9329 struct wpa_driver_nl80211_data *drv;
9330 dl_list_for_each(drv, &global->interfaces,
9331 struct wpa_driver_nl80211_data, list) {
834ee56f 9332 if (os_memcmp(addr, drv->first_bss->addr, ETH_ALEN) == 0)
f2ed8023
JM		 9333 return 1;
9334 }
9335 return 0;
9336}
9337
9338
9339static int nl80211_p2p_interface_addr(struct wpa_driver_nl80211_data *drv,
9340 u8 *new_addr)
9341{
9342 unsigned int idx;
9343
9344 if (!drv->global)
9345 return -1;
9346
834ee56f 9347 os_memcpy(new_addr, drv->first_bss->addr, ETH_ALEN);
f2ed8023 9348 for (idx = 0; idx < 64; idx++) {
834ee56f 9349 new_addr[0] = drv->first_bss->addr[0] | 0x02;
f2ed8023
JM		 9350 new_addr[0] ^= idx << 2;
9351 if (!nl80211_addr_in_use(drv->global, new_addr))
9352 break;
9353 }
9354 if (idx == 64)
9355 return -1;
9356
9357 wpa_printf(MSG_DEBUG, "nl80211: Assigned new P2P Interface Address "
9358 MACSTR, MAC2STR(new_addr));
9359
9360 return 0;
9361}
9362
482856c8
JM		 9363#endif /* CONFIG_P2P */
9364
f2ed8023 9365
f632e483
AS		 9366struct wdev_info {
9367 u64 wdev_id;
9368 int wdev_id_set;
9369 u8 macaddr[ETH_ALEN];
9370};
9371
9372static int nl80211_wdev_handler(struct nl_msg *msg, void *arg)
e472e1b4
AS		 9373{
9374 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
9375 struct nlattr *tb[NL80211_ATTR_MAX + 1];
f632e483 9376 struct wdev_info *wi = arg;
e472e1b4
AS		 9377
9378 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
9379 genlmsg_attrlen(gnlh, 0), NULL);
9380 if (tb[NL80211_ATTR_WDEV]) {
f632e483
AS		 9381 wi->wdev_id = nla_get_u64(tb[NL80211_ATTR_WDEV]);
9382 wi->wdev_id_set = 1;
e472e1b4
AS		 9383 }
9384
9385 if (tb[NL80211_ATTR_MAC])
f632e483 9386 os_memcpy(wi->macaddr, nla_data(tb[NL80211_ATTR_MAC]),
e472e1b4
AS		 9387 ETH_ALEN);
9388
9389 return NL_SKIP;
9390}
9391
9392
7ab68865 9393static int wpa_driver_nl80211_if_add(void *priv, enum wpa_driver_if_type type,
8043e725 9394 const char *ifname, const u8 *addr,
f3585c8a 9395 void *bss_ctx, void **drv_priv,
e17a2477 9396 char *force_ifname, u8 *if_addr,
2aec4f3c 9397 const char *bridge, int use_existing)
22a7c9d7 9398{
e472e1b4 9399 enum nl80211_iftype nlmode;
a2e40bb6
FF		 9400 struct i802_bss *bss = priv;
9401 struct wpa_driver_nl80211_data *drv = bss->drv;
22a7c9d7 9402 int ifidx;
2aec4f3c 9403 int added = 1;
22a7c9d7 9404
f3585c8a
JM		 9405 if (addr)
9406 os_memcpy(if_addr, addr, ETH_ALEN);
e472e1b4
AS		 9407 nlmode = wpa_driver_nl80211_if_type(type);
9408 if (nlmode == NL80211_IFTYPE_P2P_DEVICE) {
f632e483
AS		 9409 struct wdev_info p2pdev_info;
9410
9411 os_memset(&p2pdev_info, 0, sizeof(p2pdev_info));
e472e1b4 9412 ifidx = nl80211_create_iface(drv, ifname, nlmode, addr,
f632e483 9413 0, nl80211_wdev_handler,
2aec4f3c 9414 &p2pdev_info, use_existing);
f632e483 9415 if (!p2pdev_info.wdev_id_set || ifidx != 0) {
e472e1b4
AS		 9416 wpa_printf(MSG_ERROR, "nl80211: Failed to create a P2P Device interface %s",
9417 ifname);
e472e1b4
AS		 9418 return -1;
9419 }
f632e483
AS		 9420
9421 drv->global->if_add_wdevid = p2pdev_info.wdev_id;
9422 drv->global->if_add_wdevid_set = p2pdev_info.wdev_id_set;
9423 if (!is_zero_ether_addr(p2pdev_info.macaddr))
9424 os_memcpy(if_addr, p2pdev_info.macaddr, ETH_ALEN);
9425 wpa_printf(MSG_DEBUG, "nl80211: New P2P Device interface %s (0x%llx) created",
9426 ifname,
9427 (long long unsigned int) p2pdev_info.wdev_id);
e472e1b4
AS		 9428 } else {
9429 ifidx = nl80211_create_iface(drv, ifname, nlmode, addr,
2aec4f3c
JM		 9430 0, NULL, NULL, use_existing);
9431 if (use_existing && ifidx == -ENFILE) {
9432 added = 0;
9433 ifidx = if_nametoindex(ifname);
9434 } else if (ifidx < 0) {
e472e1b4
AS		 9435 return -1;
9436 }
22a7c9d7
JM		 9437 }
9438
ab7a1add
AS		 9439 if (!addr) {
9440 if (drv->nlmode == NL80211_IFTYPE_P2P_DEVICE)
9441 os_memcpy(if_addr, bss->addr, ETH_ALEN);
9442 else if (linux_get_ifhwaddr(drv->global->ioctl_sock,
9443 bss->ifname, if_addr) < 0) {
2aec4f3c
JM		 9444 if (added)
9445 nl80211_remove_iface(drv, ifidx);
ab7a1add
AS		 9446 return -1;
9447 }
c55f774d
JM		 9448 }
9449
9450#ifdef CONFIG_P2P
9451 if (!addr &&
9452 (type == WPA_IF_P2P_CLIENT || type == WPA_IF_P2P_GROUP ||
9453 type == WPA_IF_P2P_GO)) {
9454 /* Enforce unique P2P Interface Address */
ab7a1add 9455 u8 new_addr[ETH_ALEN];
c55f774d 9456
ab7a1add 9457 if (linux_get_ifhwaddr(drv->global->ioctl_sock, ifname,
c81eff1a 9458 new_addr) < 0) {
c55f774d
JM		 9459 nl80211_remove_iface(drv, ifidx);
9460 return -1;
9461 }
f608081c 9462 if (nl80211_addr_in_use(drv->global, new_addr)) {
c55f774d
JM		 9463 wpa_printf(MSG_DEBUG, "nl80211: Allocate new address "
9464 "for P2P group interface");
f2ed8023 9465 if (nl80211_p2p_interface_addr(drv, new_addr) < 0) {
c55f774d
JM		 9466 nl80211_remove_iface(drv, ifidx);
9467 return -1;
9468 }
c81eff1a 9469 if (linux_set_ifhwaddr(drv->global->ioctl_sock, ifname,
c55f774d
JM		 9470 new_addr) < 0) {
9471 nl80211_remove_iface(drv, ifidx);
9472 return -1;
9473 }
c55f774d 9474 }
f67eeb5c 9475 os_memcpy(if_addr, new_addr, ETH_ALEN);
c55f774d
JM		 9476 }
9477#endif /* CONFIG_P2P */
f3585c8a 9478
22a7c9d7 9479 if (type == WPA_IF_AP_BSS) {
f5eb9da3
JM		 9480 struct i802_bss *new_bss = os_zalloc(sizeof(*new_bss));
9481 if (new_bss == NULL) {
2aec4f3c
JM		 9482 if (added)
9483 nl80211_remove_iface(drv, ifidx);
f5eb9da3
JM		 9484 return -1;
9485 }
9486
9487 if (bridge &&
9488 i802_check_bridge(drv, new_bss, bridge, ifname) < 0) {
9489 wpa_printf(MSG_ERROR, "nl80211: Failed to add the new "
9490 "interface %s to a bridge %s",
9491 ifname, bridge);
2aec4f3c
JM		 9492 if (added)
9493 nl80211_remove_iface(drv, ifidx);
f5eb9da3
JM		 9494 os_free(new_bss);
9495 return -1;
9496 }
9497
c81eff1a
BG		 9498 if (linux_set_iface_flags(drv->global->ioctl_sock, ifname, 1))
9499 {
34f2f814 9500 nl80211_remove_iface(drv, ifidx);
07179987 9501 os_free(new_bss);
22a7c9d7
JM		 9502 return -1;
9503 }
a2e40bb6 9504 os_strlcpy(new_bss->ifname, ifname, IFNAMSIZ);
341eebee 9505 os_memcpy(new_bss->addr, if_addr, ETH_ALEN);
a2e40bb6
FF		 9506 new_bss->ifindex = ifidx;
9507 new_bss->drv = drv;
834ee56f
KP		 9508 new_bss->next = drv->first_bss->next;
9509 new_bss->freq = drv->first_bss->freq;
a5e1eb20 9510 new_bss->ctx = bss_ctx;
2aec4f3c 9511 new_bss->added_if = added;
834ee56f 9512 drv->first_bss->next = new_bss;
a2e40bb6
FF		 9513 if (drv_priv)
9514 *drv_priv = new_bss;
cc7a48d1 9515 nl80211_init_bss(new_bss);
3dd1d890
YAP		 9516
9517 /* Subscribe management frames for this WPA_IF_AP_BSS */
9518 if (nl80211_setup_ap(new_bss))
9519 return -1;
22a7c9d7 9520 }
22a7c9d7 9521
ff6a158b
JM		 9522 if (drv->global)
9523 drv->global->if_add_ifindex = ifidx;
9524
22a7c9d7
JM		 9525 return 0;
9526}
9527
9528
9ebce9c5 9529static int wpa_driver_nl80211_if_remove(struct i802_bss *bss,
22a7c9d7
JM		 9530 enum wpa_driver_if_type type,
9531 const char *ifname)
9532{
a2e40bb6 9533 struct wpa_driver_nl80211_data *drv = bss->drv;
22a7c9d7
JM		 9534 int ifindex = if_nametoindex(ifname);
9535
2aec4f3c
JM		 9536 wpa_printf(MSG_DEBUG, "nl80211: %s(type=%d ifname=%s) ifindex=%d added_if=%d",
9537 __func__, type, ifname, ifindex, bss->added_if);
158b090c 9538 if (ifindex > 0 && (bss->added_if || bss->ifindex != ifindex))
2b72df63 9539 nl80211_remove_iface(drv, ifindex);
c34e618d 9540
c34e618d
FF		 9541 if (type != WPA_IF_AP_BSS)
9542 return 0;
9543
e17a2477 9544 if (bss->added_if_into_bridge) {
c81eff1a
BG		 9545 if (linux_br_del_if(drv->global->ioctl_sock, bss->brname,
9546 bss->ifname) < 0)
e17a2477
JM		 9547 wpa_printf(MSG_INFO, "nl80211: Failed to remove "
9548 "interface %s from bridge %s: %s",
9549 bss->ifname, bss->brname, strerror(errno));
9550 }
9551 if (bss->added_bridge) {
c81eff1a 9552 if (linux_br_del(drv->global->ioctl_sock, bss->brname) < 0)
e17a2477
JM		 9553 wpa_printf(MSG_INFO, "nl80211: Failed to remove "
9554 "bridge %s: %s",
9555 bss->brname, strerror(errno));
9556 }
a2e40bb6 9557
834ee56f 9558 if (bss != drv->first_bss) {
8546ea19 9559 struct i802_bss *tbss;
a2e40bb6 9560
2aec4f3c 9561 wpa_printf(MSG_DEBUG, "nl80211: Not the first BSS - remove it");
834ee56f 9562 for (tbss = drv->first_bss; tbss; tbss = tbss->next) {
8546ea19
JM		 9563 if (tbss->next == bss) {
9564 tbss->next = bss->next;
3dd1d890
YAP		 9565 /* Unsubscribe management frames */
9566 nl80211_teardown_ap(bss);
cc7a48d1 9567 nl80211_destroy_bss(bss);
8546ea19
JM		 9568 os_free(bss);
9569 bss = NULL;
9570 break;
9571 }
22a7c9d7 9572 }
8546ea19
JM		 9573 if (bss)
9574 wpa_printf(MSG_INFO, "nl80211: %s - could not find "
9575 "BSS %p in the list", __func__, bss);
390e489c 9576 } else {
2aec4f3c 9577 wpa_printf(MSG_DEBUG, "nl80211: First BSS - reassign context");
390e489c 9578 nl80211_teardown_ap(bss);
2aec4f3c
JM		 9579 if (!bss->added_if && !drv->first_bss->next)
9580 wpa_driver_nl80211_del_beacon(drv);
390e489c 9581 nl80211_destroy_bss(bss);
2aec4f3c
JM		 9582 if (!bss->added_if)
9583 i802_set_iface_flags(bss, 0);
390e489c
KP		 9584 if (drv->first_bss->next) {
9585 drv->first_bss = drv->first_bss->next;
9586 drv->ctx = drv->first_bss->ctx;
9587 os_free(bss);
9588 } else {
9589 wpa_printf(MSG_DEBUG, "nl80211: No second BSS to reassign context to");
9590 }
22a7c9d7 9591 }
22a7c9d7
JM		 9592
9593 return 0;
9594}
9595
9596
55777702
JM		 9597static int cookie_handler(struct nl_msg *msg, void *arg)
9598{
9599 struct nlattr *tb[NL80211_ATTR_MAX + 1];
9600 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
9601 u64 *cookie = arg;
9602 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
9603 genlmsg_attrlen(gnlh, 0), NULL);
9604 if (tb[NL80211_ATTR_COOKIE])
9605 *cookie = nla_get_u64(tb[NL80211_ATTR_COOKIE]);
9606 return NL_SKIP;
9607}
9608
9609
88df0ef7 9610static int nl80211_send_frame_cmd(struct i802_bss *bss,
5dfca53f
JB		 9611 unsigned int freq, unsigned int wait,
9612 const u8 *buf, size_t buf_len,
88df0ef7
JB		 9613 u64 *cookie_out, int no_cck, int no_ack,
9614 int offchanok)
9884f9cc 9615{
88df0ef7 9616 struct wpa_driver_nl80211_data *drv = bss->drv;
9884f9cc
JB		 9617 struct nl_msg *msg;
9618 u64 cookie;
9619 int ret = -1;
9620
9621 msg = nlmsg_alloc();
9622 if (!msg)
9623 return -1;
9624
cc2ada86 9625 wpa_printf(MSG_MSGDUMP, "nl80211: CMD_FRAME freq=%u wait=%u no_cck=%d "
2e3e4566
JM		 9626 "no_ack=%d offchanok=%d",
9627 freq, wait, no_cck, no_ack, offchanok);
c91f796f 9628 wpa_hexdump(MSG_MSGDUMP, "CMD_FRAME", buf, buf_len);
9fb04070 9629 nl80211_cmd(drv, msg, 0, NL80211_CMD_FRAME);
9884f9cc 9630
f632e483 9631 if (nl80211_set_iface_id(msg, bss) < 0)
d3aaef80 9632 goto nla_put_failure;
c91f796f
NC		 9633 if (freq)
9634 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_FREQ, freq);
9db931ed
JM		 9635 if (wait)
9636 NLA_PUT_U32(msg, NL80211_ATTR_DURATION, wait);
b9fd8ce8 9637 if (offchanok && (drv->capa.flags & WPA_DRIVER_FLAGS_OFFCHANNEL_TX))
88df0ef7 9638 NLA_PUT_FLAG(msg, NL80211_ATTR_OFFCHANNEL_TX_OK);
b106173a
JM		 9639 if (no_cck)
9640 NLA_PUT_FLAG(msg, NL80211_ATTR_TX_NO_CCK_RATE);
ddc53271
JM		 9641 if (no_ack)
9642 NLA_PUT_FLAG(msg, NL80211_ATTR_DONT_WAIT_FOR_ACK);
970fa12e 9643
9884f9cc
JB		 9644 NLA_PUT(msg, NL80211_ATTR_FRAME, buf_len, buf);
9645
9646 cookie = 0;
9647 ret = send_and_recv_msgs(drv, msg, cookie_handler, &cookie);
9648 msg = NULL;
9649 if (ret) {
9650 wpa_printf(MSG_DEBUG, "nl80211: Frame command failed: ret=%d "
a05225c8
JM		 9651 "(%s) (freq=%u wait=%u)", ret, strerror(-ret),
9652 freq, wait);
9884f9cc
JB		 9653 goto nla_put_failure;
9654 }
cc2ada86 9655 wpa_printf(MSG_MSGDUMP, "nl80211: Frame TX command accepted%s; "
ddc53271
JM		 9656 "cookie 0x%llx", no_ack ? " (no ACK)" : "",
9657 (long long unsigned int) cookie);
9884f9cc
JB		 9658
9659 if (cookie_out)
ddc53271 9660 *cookie_out = no_ack ? (u64) -1 : cookie;
9884f9cc
JB		 9661
9662nla_put_failure:
9663 nlmsg_free(msg);
9664 return ret;
9665}
9666
9667
9ebce9c5
JM		 9668static int wpa_driver_nl80211_send_action(struct i802_bss *bss,
9669 unsigned int freq,
190b9062 9670 unsigned int wait_time,
58f6fbe0
JM		 9671 const u8 *dst, const u8 *src,
9672 const u8 *bssid,
b106173a
JM		 9673 const u8 *data, size_t data_len,
9674 int no_cck)
58f6fbe0 9675{
a2e40bb6 9676 struct wpa_driver_nl80211_data *drv = bss->drv;
58f6fbe0 9677 int ret = -1;
58f6fbe0
JM		 9678 u8 *buf;
9679 struct ieee80211_hdr *hdr;
58f6fbe0 9680
5dfca53f 9681 wpa_printf(MSG_DEBUG, "nl80211: Send Action frame (ifindex=%d, "
55231068
JM		 9682 "freq=%u MHz wait=%d ms no_cck=%d)",
9683 drv->ifindex, freq, wait_time, no_cck);
58f6fbe0
JM		 9684
9685 buf = os_zalloc(24 + data_len);
9686 if (buf == NULL)
9687 return ret;
9688 os_memcpy(buf + 24, data, data_len);
9689 hdr = (struct ieee80211_hdr *) buf;
9690 hdr->frame_control =
9691 IEEE80211_FC(WLAN_FC_TYPE_MGMT, WLAN_FC_STYPE_ACTION);
9692 os_memcpy(hdr->addr1, dst, ETH_ALEN);
9693 os_memcpy(hdr->addr2, src, ETH_ALEN);
9694 os_memcpy(hdr->addr3, bssid, ETH_ALEN);
9695
f78f2785
JM		 9696 if (is_ap_interface(drv->nlmode) &&
9697 (!(drv->capa.flags & WPA_DRIVER_FLAGS_OFFCHANNEL_TX) ||
9698 (int) freq == bss->freq || drv->device_ap_sme ||
9699 !drv->use_monitor))
9ebce9c5
JM		 9700 ret = wpa_driver_nl80211_send_mlme(bss, buf, 24 + data_len,
9701 0, freq, no_cck, 1,
9702 wait_time);
9884f9cc 9703 else
88df0ef7 9704 ret = nl80211_send_frame_cmd(bss, freq, wait_time, buf,
5dfca53f 9705 24 + data_len,
b106173a 9706 &drv->send_action_cookie,
88df0ef7 9707 no_cck, 0, 1);
58f6fbe0 9708
f8bf1421 9709 os_free(buf);
58f6fbe0
JM		 9710 return ret;
9711}
9712
9713
5dfca53f
JB		 9714static void wpa_driver_nl80211_send_action_cancel_wait(void *priv)
9715{
9716 struct i802_bss *bss = priv;
9717 struct wpa_driver_nl80211_data *drv = bss->drv;
9718 struct nl_msg *msg;
9719 int ret;
9720
9721 msg = nlmsg_alloc();
9722 if (!msg)
9723 return;
9724
316a9e4d
JM		 9725 wpa_printf(MSG_DEBUG, "nl80211: Cancel TX frame wait: cookie=0x%llx",
9726 (long long unsigned int) drv->send_action_cookie);
9fb04070 9727 nl80211_cmd(drv, msg, 0, NL80211_CMD_FRAME_WAIT_CANCEL);
5dfca53f 9728
7940c790
AS		 9729 if (nl80211_set_iface_id(msg, bss) < 0)
9730 goto nla_put_failure;
5dfca53f
JB		 9731 NLA_PUT_U64(msg, NL80211_ATTR_COOKIE, drv->send_action_cookie);
9732
9733 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
9734 msg = NULL;
9735 if (ret)
9736 wpa_printf(MSG_DEBUG, "nl80211: wait cancel failed: ret=%d "
9737 "(%s)", ret, strerror(-ret));
9738
9739 nla_put_failure:
9740 nlmsg_free(msg);
9741}
9742
9743
55777702
JM		 9744static int wpa_driver_nl80211_remain_on_channel(void *priv, unsigned int freq,
9745 unsigned int duration)
9746{
a2e40bb6
FF		 9747 struct i802_bss *bss = priv;
9748 struct wpa_driver_nl80211_data *drv = bss->drv;
55777702
JM		 9749 struct nl_msg *msg;
9750 int ret;
9751 u64 cookie;
9752
9753 msg = nlmsg_alloc();
9754 if (!msg)
9755 return -1;
9756
9fb04070 9757 nl80211_cmd(drv, msg, 0, NL80211_CMD_REMAIN_ON_CHANNEL);
55777702 9758
f632e483 9759 if (nl80211_set_iface_id(msg, bss) < 0)
d3aaef80
DS		 9760 goto nla_put_failure;
9761
55777702
JM		 9762 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_FREQ, freq);
9763 NLA_PUT_U32(msg, NL80211_ATTR_DURATION, duration);
9764
9765 cookie = 0;
9766 ret = send_and_recv_msgs(drv, msg, cookie_handler, &cookie);
5883168a 9767 msg = NULL;
55777702
JM		 9768 if (ret == 0) {
9769 wpa_printf(MSG_DEBUG, "nl80211: Remain-on-channel cookie "
9770 "0x%llx for freq=%u MHz duration=%u",
9771 (long long unsigned int) cookie, freq, duration);
9772 drv->remain_on_chan_cookie = cookie;
531f0331 9773 drv->pending_remain_on_chan = 1;
55777702
JM		 9774 return 0;
9775 }
9776 wpa_printf(MSG_DEBUG, "nl80211: Failed to request remain-on-channel "
15ed5535
JM		 9777 "(freq=%d duration=%u): %d (%s)",
9778 freq, duration, ret, strerror(-ret));
55777702 9779nla_put_failure:
5883168a 9780 nlmsg_free(msg);
55777702
JM		 9781 return -1;
9782}
9783
9784
9785static int wpa_driver_nl80211_cancel_remain_on_channel(void *priv)
9786{
a2e40bb6
FF		 9787 struct i802_bss *bss = priv;
9788 struct wpa_driver_nl80211_data *drv = bss->drv;
55777702
JM		 9789 struct nl_msg *msg;
9790 int ret;
9791
9792 if (!drv->pending_remain_on_chan) {
9793 wpa_printf(MSG_DEBUG, "nl80211: No pending remain-on-channel "
9794 "to cancel");
9795 return -1;
9796 }
9797
9798 wpa_printf(MSG_DEBUG, "nl80211: Cancel remain-on-channel with cookie "
9799 "0x%llx",
9800 (long long unsigned int) drv->remain_on_chan_cookie);
9801
9802 msg = nlmsg_alloc();
9803 if (!msg)
9804 return -1;
9805
9fb04070 9806 nl80211_cmd(drv, msg, 0, NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL);
55777702 9807
f632e483 9808 if (nl80211_set_iface_id(msg, bss) < 0)
d3aaef80
DS		 9809 goto nla_put_failure;
9810
55777702
JM		 9811 NLA_PUT_U64(msg, NL80211_ATTR_COOKIE, drv->remain_on_chan_cookie);
9812
9813 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
5883168a 9814 msg = NULL;
55777702
JM		 9815 if (ret == 0)
9816 return 0;
9817 wpa_printf(MSG_DEBUG, "nl80211: Failed to cancel remain-on-channel: "
9818 "%d (%s)", ret, strerror(-ret));
9819nla_put_failure:
5883168a 9820 nlmsg_free(msg);
55777702
JM		 9821 return -1;
9822}
9823
9824
9ebce9c5 9825static int wpa_driver_nl80211_probe_req_report(struct i802_bss *bss, int report)
504e905c 9826{
a2e40bb6 9827 struct wpa_driver_nl80211_data *drv = bss->drv;
504e905c 9828
5582a5d1 9829 if (!report) {
0d891981
JM		 9830 if (bss->nl_preq && drv->device_ap_sme &&
9831 is_ap_interface(drv->nlmode)) {
9832 /*
9833 * Do not disable Probe Request reporting that was
9834 * enabled in nl80211_setup_ap().
9835 */
9836 wpa_printf(MSG_DEBUG, "nl80211: Skip disabling of "
9837 "Probe Request reporting nl_preq=%p while "
9838 "in AP mode", bss->nl_preq);
9839 } else if (bss->nl_preq) {
36488c05
JM		 9840 wpa_printf(MSG_DEBUG, "nl80211: Disable Probe Request "
9841 "reporting nl_preq=%p", bss->nl_preq);
5f65e9f7 9842 nl80211_destroy_eloop_handle(&bss->nl_preq);
5582a5d1
JB		 9843 }
9844 return 0;
9845 }
9846
481234cf 9847 if (bss->nl_preq) {
5582a5d1 9848 wpa_printf(MSG_DEBUG, "nl80211: Probe Request reporting "
36488c05 9849 "already on! nl_preq=%p", bss->nl_preq);
5582a5d1
JB		 9850 return 0;
9851 }
9852
481234cf
JM		 9853 bss->nl_preq = nl_create_handle(drv->global->nl_cb, "preq");
9854 if (bss->nl_preq == NULL)
5582a5d1 9855 return -1;
36488c05
JM		 9856 wpa_printf(MSG_DEBUG, "nl80211: Enable Probe Request "
9857 "reporting nl_preq=%p", bss->nl_preq);
5582a5d1 9858
481234cf 9859 if (nl80211_register_frame(bss, bss->nl_preq,
5582a5d1
JB		 9860 (WLAN_FC_TYPE_MGMT << 2) |
9861 (WLAN_FC_STYPE_PROBE_REQ << 4),
a92dfde8
JB		 9862 NULL, 0) < 0)
9863 goto out_err;
5582a5d1 9864
5f65e9f7
JB		 9865 nl80211_register_eloop_read(&bss->nl_preq,
9866 wpa_driver_nl80211_event_receive,
9867 bss->nl_cb);
5582a5d1 9868
504e905c 9869 return 0;
5582a5d1 9870
a92dfde8 9871 out_err:
221a59c9 9872 nl_destroy_handles(&bss->nl_preq);
5582a5d1 9873 return -1;
504e905c
JM		 9874}
9875
9876
4e5cb1a3
JM		 9877static int nl80211_disable_11b_rates(struct wpa_driver_nl80211_data *drv,
9878 int ifindex, int disabled)
9879{
9880 struct nl_msg *msg;
9881 struct nlattr *bands, *band;
9882 int ret;
9883
9884 msg = nlmsg_alloc();
9885 if (!msg)
9886 return -1;
9887
9fb04070 9888 nl80211_cmd(drv, msg, 0, NL80211_CMD_SET_TX_BITRATE_MASK);
4e5cb1a3
JM		 9889 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, ifindex);
9890
9891 bands = nla_nest_start(msg, NL80211_ATTR_TX_RATES);
9892 if (!bands)
9893 goto nla_put_failure;
9894
9895 /*
9896 * Disable 2 GHz rates 1, 2, 5.5, 11 Mbps by masking out everything
9897 * else apart from 6, 9, 12, 18, 24, 36, 48, 54 Mbps from non-MCS
9898 * rates. All 5 GHz rates are left enabled.
9899 */
9900 band = nla_nest_start(msg, NL80211_BAND_2GHZ);
9901 if (!band)
9902 goto nla_put_failure;
1dea5882
JM		 9903 if (disabled) {
9904 NLA_PUT(msg, NL80211_TXRATE_LEGACY, 8,
9905 "\x0c\x12\x18\x24\x30\x48\x60\x6c");
9906 }
4e5cb1a3
JM		 9907 nla_nest_end(msg, band);
9908
9909 nla_nest_end(msg, bands);
9910
9911 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
9912 msg = NULL;
9913 if (ret) {
9914 wpa_printf(MSG_DEBUG, "nl80211: Set TX rates failed: ret=%d "
9915 "(%s)", ret, strerror(-ret));
1d0c6fb1
JM		 9916 } else
9917 drv->disabled_11b_rates = disabled;
4e5cb1a3
JM		 9918
9919 return ret;
9920
9921nla_put_failure:
9922 nlmsg_free(msg);
9923 return -1;
9924}
9925
9926
af473088
JM		 9927static int wpa_driver_nl80211_deinit_ap(void *priv)
9928{
a2e40bb6
FF		 9929 struct i802_bss *bss = priv;
9930 struct wpa_driver_nl80211_data *drv = bss->drv;
b1f625e0 9931 if (!is_ap_interface(drv->nlmode))
af473088
JM		 9932 return -1;
9933 wpa_driver_nl80211_del_beacon(drv);
60b13c20
IP		 9934
9935 /*
9936 * If the P2P GO interface was dynamically added, then it is
9937 * possible that the interface change to station is not possible.
9938 */
9939 if (drv->nlmode == NL80211_IFTYPE_P2P_GO && bss->if_dynamic)
9940 return 0;
9941
b1f625e0 9942 return wpa_driver_nl80211_set_mode(priv, NL80211_IFTYPE_STATION);
af473088
JM		 9943}
9944
9945
695c7038
SW		 9946static int wpa_driver_nl80211_stop_ap(void *priv)
9947{
9948 struct i802_bss *bss = priv;
9949 struct wpa_driver_nl80211_data *drv = bss->drv;
9950 if (!is_ap_interface(drv->nlmode))
9951 return -1;
9952 wpa_driver_nl80211_del_beacon(drv);
9953 bss->beacon_set = 0;
9954 return 0;
9955}
9956
9957
3c29244e
EP		 9958static int wpa_driver_nl80211_deinit_p2p_cli(void *priv)
9959{
9960 struct i802_bss *bss = priv;
9961 struct wpa_driver_nl80211_data *drv = bss->drv;
9962 if (drv->nlmode != NL80211_IFTYPE_P2P_CLIENT)
9963 return -1;
60b13c20
IP		 9964
9965 /*
9966 * If the P2P Client interface was dynamically added, then it is
9967 * possible that the interface change to station is not possible.
9968 */
9969 if (bss->if_dynamic)
9970 return 0;
9971
3c29244e
EP		 9972 return wpa_driver_nl80211_set_mode(priv, NL80211_IFTYPE_STATION);
9973}
9974
9975
207ef3fb
JM		 9976static void wpa_driver_nl80211_resume(void *priv)
9977{
a2e40bb6 9978 struct i802_bss *bss = priv;
91724d6f
AS		 9979
9980 if (i802_set_iface_flags(bss, 1))
9981 wpa_printf(MSG_DEBUG, "nl80211: Failed to set interface up on resume event");
207ef3fb
JM		 9982}
9983
9984
7b90c16a
JM		 9985static int nl80211_send_ft_action(void *priv, u8 action, const u8 *target_ap,
9986 const u8 *ies, size_t ies_len)
9987{
9988 struct i802_bss *bss = priv;
9989 struct wpa_driver_nl80211_data *drv = bss->drv;
9990 int ret;
9991 u8 *data, *pos;
9992 size_t data_len;
341eebee 9993 const u8 *own_addr = bss->addr;
7b90c16a
JM		 9994
9995 if (action != 1) {
9996 wpa_printf(MSG_ERROR, "nl80211: Unsupported send_ft_action "
9997 "action %d", action);
9998 return -1;
9999 }
10000
10001 /*
10002 * Action frame payload:
10003 * Category[1] = 6 (Fast BSS Transition)
10004 * Action[1] = 1 (Fast BSS Transition Request)
10005 * STA Address
10006 * Target AP Address
10007 * FT IEs
10008 */
10009
73fc617d
JM		 10010 data_len = 2 + 2 * ETH_ALEN + ies_len;
10011 data = os_malloc(data_len);
7b90c16a
JM		 10012 if (data == NULL)
10013 return -1;
10014 pos = data;
10015 *pos++ = 0x06; /* FT Action category */
10016 *pos++ = action;
10017 os_memcpy(pos, own_addr, ETH_ALEN);
10018 pos += ETH_ALEN;
10019 os_memcpy(pos, target_ap, ETH_ALEN);
10020 pos += ETH_ALEN;
10021 os_memcpy(pos, ies, ies_len);
10022
190b9062
JB		 10023 ret = wpa_driver_nl80211_send_action(bss, drv->assoc_freq, 0,
10024 drv->bssid, own_addr, drv->bssid,
b106173a 10025 data, data_len, 0);
7b90c16a
JM		 10026 os_free(data);
10027
10028 return ret;
10029}
10030
10031
b625473c
JM		 10032static int nl80211_signal_monitor(void *priv, int threshold, int hysteresis)
10033{
10034 struct i802_bss *bss = priv;
10035 struct wpa_driver_nl80211_data *drv = bss->drv;
8970bae8
JB		 10036 struct nl_msg *msg;
10037 struct nlattr *cqm;
f0494d0f 10038 int ret = -1;
b625473c
JM		 10039
10040 wpa_printf(MSG_DEBUG, "nl80211: Signal monitor threshold=%d "
10041 "hysteresis=%d", threshold, hysteresis);
10042
10043 msg = nlmsg_alloc();
10044 if (!msg)
10045 return -1;
10046
9fb04070 10047 nl80211_cmd(drv, msg, 0, NL80211_CMD_SET_CQM);
b625473c
JM		 10048
10049 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, bss->ifindex);
10050
8970bae8 10051 cqm = nla_nest_start(msg, NL80211_ATTR_CQM);
b625473c 10052 if (cqm == NULL)
21270bb4 10053 goto nla_put_failure;
b625473c 10054
8970bae8
JB		 10055 NLA_PUT_U32(msg, NL80211_ATTR_CQM_RSSI_THOLD, threshold);
10056 NLA_PUT_U32(msg, NL80211_ATTR_CQM_RSSI_HYST, hysteresis);
10057 nla_nest_end(msg, cqm);
21270bb4 10058
f0494d0f 10059 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
b625473c
JM		 10060 msg = NULL;
10061
10062nla_put_failure:
b625473c 10063 nlmsg_free(msg);
f0494d0f 10064 return ret;
b625473c
JM		 10065}
10066
10067
2cc8d8f4
AO		 10068static int get_channel_width(struct nl_msg *msg, void *arg)
10069{
10070 struct nlattr *tb[NL80211_ATTR_MAX + 1];
10071 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
10072 struct wpa_signal_info *sig_change = arg;
10073
10074 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
10075 genlmsg_attrlen(gnlh, 0), NULL);
10076
10077 sig_change->center_frq1 = -1;
10078 sig_change->center_frq2 = -1;
10079 sig_change->chanwidth = CHAN_WIDTH_UNKNOWN;
10080
10081 if (tb[NL80211_ATTR_CHANNEL_WIDTH]) {
10082 sig_change->chanwidth = convert2width(
10083 nla_get_u32(tb[NL80211_ATTR_CHANNEL_WIDTH]));
10084 if (tb[NL80211_ATTR_CENTER_FREQ1])
10085 sig_change->center_frq1 =
10086 nla_get_u32(tb[NL80211_ATTR_CENTER_FREQ1]);
10087 if (tb[NL80211_ATTR_CENTER_FREQ2])
10088 sig_change->center_frq2 =
10089 nla_get_u32(tb[NL80211_ATTR_CENTER_FREQ2]);
10090 }
10091
10092 return NL_SKIP;
10093}
10094
10095
10096static int nl80211_get_channel_width(struct wpa_driver_nl80211_data *drv,
10097 struct wpa_signal_info *sig)
10098{
10099 struct nl_msg *msg;
10100
10101 msg = nlmsg_alloc();
10102 if (!msg)
10103 return -ENOMEM;
10104
10105 nl80211_cmd(drv, msg, 0, NL80211_CMD_GET_INTERFACE);
10106 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
10107
10108 return send_and_recv_msgs(drv, msg, get_channel_width, sig);
10109
10110nla_put_failure:
10111 nlmsg_free(msg);
10112 return -ENOBUFS;
10113}
10114
10115
1c5c7273
PS		 10116static int nl80211_signal_poll(void *priv, struct wpa_signal_info *si)
10117{
10118 struct i802_bss *bss = priv;
10119 struct wpa_driver_nl80211_data *drv = bss->drv;
10120 int res;
10121
10122 os_memset(si, 0, sizeof(*si));
10123 res = nl80211_get_link_signal(drv, si);
10124 if (res != 0)
10125 return res;
10126
2cc8d8f4
AO		 10127 res = nl80211_get_channel_width(drv, si);
10128 if (res != 0)
10129 return res;
10130
1c5c7273
PS		 10131 return nl80211_get_link_noise(drv, si);
10132}
10133
10134
57ebba59
JJ		 10135static int wpa_driver_nl80211_shared_freq(void *priv)
10136{
10137 struct i802_bss *bss = priv;
10138 struct wpa_driver_nl80211_data *drv = bss->drv;
10139 struct wpa_driver_nl80211_data *driver;
10140 int freq = 0;
10141
10142 /*
10143 * If the same PHY is in connected state with some other interface,
10144 * then retrieve the assoc freq.
10145 */
10146 wpa_printf(MSG_DEBUG, "nl80211: Get shared freq for PHY %s",
10147 drv->phyname);
10148
10149 dl_list_for_each(driver, &drv->global->interfaces,
10150 struct wpa_driver_nl80211_data, list) {
10151 if (drv == driver ||
10152 os_strcmp(drv->phyname, driver->phyname) != 0 ||
10153 !driver->associated)
10154 continue;
10155
10156 wpa_printf(MSG_DEBUG, "nl80211: Found a match for PHY %s - %s "
10157 MACSTR,
834ee56f
KP		 10158 driver->phyname, driver->first_bss->ifname,
10159 MAC2STR(driver->first_bss->addr));
d3bd0f05 10160 if (is_ap_interface(driver->nlmode))
834ee56f 10161 freq = driver->first_bss->freq;
d3bd0f05
JJ		 10162 else
10163 freq = nl80211_get_assoc_freq(driver);
57ebba59
JJ		 10164 wpa_printf(MSG_DEBUG, "nl80211: Shared freq for PHY %s: %d",
10165 drv->phyname, freq);
10166 }
10167
10168 if (!freq)
10169 wpa_printf(MSG_DEBUG, "nl80211: No shared interface for "
10170 "PHY (%s) in associated state", drv->phyname);
10171
10172 return freq;
10173}
10174
10175
b91ab76e
JM		 10176static int nl80211_send_frame(void *priv, const u8 *data, size_t data_len,
10177 int encrypt)
10178{
10179 struct i802_bss *bss = priv;
55231068
JM		 10180 return wpa_driver_nl80211_send_frame(bss, data, data_len, encrypt, 0,
10181 0, 0, 0, 0);
b91ab76e
JM		 10182}
10183
10184
c55f774d
JM		 10185static int nl80211_set_param(void *priv, const char *param)
10186{
c55f774d
JM		 10187 wpa_printf(MSG_DEBUG, "nl80211: driver param='%s'", param);
10188 if (param == NULL)
10189 return 0;
10190
10191#ifdef CONFIG_P2P
10192 if (os_strstr(param, "use_p2p_group_interface=1")) {
482856c8
JM		 10193 struct i802_bss *bss = priv;
10194 struct wpa_driver_nl80211_data *drv = bss->drv;
10195
c55f774d
JM		 10196 wpa_printf(MSG_DEBUG, "nl80211: Use separate P2P group "
10197 "interface");
10198 drv->capa.flags |= WPA_DRIVER_FLAGS_P2P_CONCURRENT;
10199 drv->capa.flags |= WPA_DRIVER_FLAGS_P2P_MGMT_AND_NON_P2P;
10200 }
851b0c55
JM		 10201
10202 if (os_strstr(param, "p2p_device=1")) {
10203 struct i802_bss *bss = priv;
10204 struct wpa_driver_nl80211_data *drv = bss->drv;
10205 drv->allow_p2p_device = 1;
10206 }
c55f774d
JM		 10207#endif /* CONFIG_P2P */
10208
10209 return 0;
10210}
10211
10212
f2ed8023
JM		 10213static void * nl80211_global_init(void)
10214{
10215 struct nl80211_global *global;
36d84860
BG		 10216 struct netlink_config *cfg;
10217
f2ed8023
JM		 10218 global = os_zalloc(sizeof(*global));
10219 if (global == NULL)
10220 return NULL;
c81eff1a 10221 global->ioctl_sock = -1;
f2ed8023 10222 dl_list_init(&global->interfaces);
ff6a158b 10223 global->if_add_ifindex = -1;
36d84860
BG		 10224
10225 cfg = os_zalloc(sizeof(*cfg));
10226 if (cfg == NULL)
10227 goto err;
10228
10229 cfg->ctx = global;
10230 cfg->newlink_cb = wpa_driver_nl80211_event_rtm_newlink;
10231 cfg->dellink_cb = wpa_driver_nl80211_event_rtm_dellink;
10232 global->netlink = netlink_init(cfg);
10233 if (global->netlink == NULL) {
10234 os_free(cfg);
10235 goto err;
10236 }
10237
2a7b66f5
BG		 10238 if (wpa_driver_nl80211_init_nl_global(global) < 0)
10239 goto err;
10240
c81eff1a
BG		 10241 global->ioctl_sock = socket(PF_INET, SOCK_DGRAM, 0);
10242 if (global->ioctl_sock < 0) {
7ac3616d
JM		 10243 wpa_printf(MSG_ERROR, "nl80211: socket(PF_INET,SOCK_DGRAM) failed: %s",
10244 strerror(errno));
c81eff1a
BG		 10245 goto err;
10246 }
10247
f2ed8023 10248 return global;
36d84860
BG		 10249
10250err:
10251 nl80211_global_deinit(global);
10252 return NULL;
f2ed8023
JM		 10253}
10254
10255
10256static void nl80211_global_deinit(void *priv)
10257{
10258 struct nl80211_global *global = priv;
10259 if (global == NULL)
10260 return;
10261 if (!dl_list_empty(&global->interfaces)) {
10262 wpa_printf(MSG_ERROR, "nl80211: %u interface(s) remain at "
10263 "nl80211_global_deinit",
10264 dl_list_len(&global->interfaces));
10265 }
36d84860
BG		 10266
10267 if (global->netlink)
10268 netlink_deinit(global->netlink);
10269
276e2d67
BG		 10270 nl_destroy_handles(&global->nl);
10271
5f65e9f7
JB		 10272 if (global->nl_event)
10273 nl80211_destroy_eloop_handle(&global->nl_event);
d6c9aab8
JB		 10274
10275 nl_cb_put(global->nl_cb);
2a7b66f5 10276
c81eff1a
BG		 10277 if (global->ioctl_sock >= 0)
10278 close(global->ioctl_sock);
10279
f2ed8023
JM		 10280 os_free(global);
10281}
10282
10283
6859f1cb
BG		 10284static const char * nl80211_get_radio_name(void *priv)
10285{
10286 struct i802_bss *bss = priv;
10287 struct wpa_driver_nl80211_data *drv = bss->drv;
10288 return drv->phyname;
10289}
10290
10291
a6efc65d
JM		 10292static int nl80211_pmkid(struct i802_bss *bss, int cmd, const u8 *bssid,
10293 const u8 *pmkid)
10294{
10295 struct nl_msg *msg;
10296
10297 msg = nlmsg_alloc();
10298 if (!msg)
10299 return -ENOMEM;
10300
9fb04070 10301 nl80211_cmd(bss->drv, msg, 0, cmd);
a6efc65d
JM		 10302
10303 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, if_nametoindex(bss->ifname));
10304 if (pmkid)
10305 NLA_PUT(msg, NL80211_ATTR_PMKID, 16, pmkid);
10306 if (bssid)
10307 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid);
10308
10309 return send_and_recv_msgs(bss->drv, msg, NULL, NULL);
10310 nla_put_failure:
9e088e74 10311 nlmsg_free(msg);
a6efc65d
JM		 10312 return -ENOBUFS;
10313}
10314
10315
10316static int nl80211_add_pmkid(void *priv, const u8 *bssid, const u8 *pmkid)
10317{
10318 struct i802_bss *bss = priv;
10319 wpa_printf(MSG_DEBUG, "nl80211: Add PMKID for " MACSTR, MAC2STR(bssid));
10320 return nl80211_pmkid(bss, NL80211_CMD_SET_PMKSA, bssid, pmkid);
10321}
10322
10323
10324static int nl80211_remove_pmkid(void *priv, const u8 *bssid, const u8 *pmkid)
10325{
10326 struct i802_bss *bss = priv;
10327 wpa_printf(MSG_DEBUG, "nl80211: Delete PMKID for " MACSTR,
10328 MAC2STR(bssid));
10329 return nl80211_pmkid(bss, NL80211_CMD_DEL_PMKSA, bssid, pmkid);
10330}
10331
10332
10333static int nl80211_flush_pmkid(void *priv)
10334{
10335 struct i802_bss *bss = priv;
10336 wpa_printf(MSG_DEBUG, "nl80211: Flush PMKIDs");
10337 return nl80211_pmkid(bss, NL80211_CMD_FLUSH_PMKSA, NULL, NULL);
10338}
10339
10340
0185007c
MK		 10341static void clean_survey_results(struct survey_results *survey_results)
10342{
10343 struct freq_survey *survey, *tmp;
10344
10345 if (dl_list_empty(&survey_results->survey_list))
10346 return;
10347
10348 dl_list_for_each_safe(survey, tmp, &survey_results->survey_list,
10349 struct freq_survey, list) {
10350 dl_list_del(&survey->list);
10351 os_free(survey);
10352 }
10353}
10354
10355
10356static void add_survey(struct nlattr **sinfo, u32 ifidx,
10357 struct dl_list *survey_list)
10358{
10359 struct freq_survey *survey;
10360
10361 survey = os_zalloc(sizeof(struct freq_survey));
10362 if (!survey)
10363 return;
10364
10365 survey->ifidx = ifidx;
10366 survey->freq = nla_get_u32(sinfo[NL80211_SURVEY_INFO_FREQUENCY]);
10367 survey->filled = 0;
10368
10369 if (sinfo[NL80211_SURVEY_INFO_NOISE]) {
10370 survey->nf = (int8_t)
10371 nla_get_u8(sinfo[NL80211_SURVEY_INFO_NOISE]);
10372 survey->filled |= SURVEY_HAS_NF;
10373 }
10374
10375 if (sinfo[NL80211_SURVEY_INFO_CHANNEL_TIME]) {
10376 survey->channel_time =
10377 nla_get_u64(sinfo[NL80211_SURVEY_INFO_CHANNEL_TIME]);
10378 survey->filled |= SURVEY_HAS_CHAN_TIME;
10379 }
10380
10381 if (sinfo[NL80211_SURVEY_INFO_CHANNEL_TIME_BUSY]) {
10382 survey->channel_time_busy =
10383 nla_get_u64(sinfo[NL80211_SURVEY_INFO_CHANNEL_TIME_BUSY]);
10384 survey->filled |= SURVEY_HAS_CHAN_TIME_BUSY;
10385 }
10386
10387 if (sinfo[NL80211_SURVEY_INFO_CHANNEL_TIME_RX]) {
10388 survey->channel_time_rx =
10389 nla_get_u64(sinfo[NL80211_SURVEY_INFO_CHANNEL_TIME_RX]);
10390 survey->filled |= SURVEY_HAS_CHAN_TIME_RX;
10391 }
10392
10393 if (sinfo[NL80211_SURVEY_INFO_CHANNEL_TIME_TX]) {
10394 survey->channel_time_tx =
10395 nla_get_u64(sinfo[NL80211_SURVEY_INFO_CHANNEL_TIME_TX]);
10396 survey->filled |= SURVEY_HAS_CHAN_TIME_TX;
10397 }
10398
10399 wpa_printf(MSG_DEBUG, "nl80211: Freq survey dump event (freq=%d MHz noise=%d channel_time=%ld busy_time=%ld tx_time=%ld rx_time=%ld filled=%04x)",
10400 survey->freq,
10401 survey->nf,
10402 (unsigned long int) survey->channel_time,
10403 (unsigned long int) survey->channel_time_busy,
10404 (unsigned long int) survey->channel_time_tx,
10405 (unsigned long int) survey->channel_time_rx,
10406 survey->filled);
10407
10408 dl_list_add_tail(survey_list, &survey->list);
10409}
10410
10411
10412static int check_survey_ok(struct nlattr **sinfo, u32 surveyed_freq,
10413 unsigned int freq_filter)
10414{
10415 if (!freq_filter)
10416 return 1;
10417
10418 return freq_filter == surveyed_freq;
10419}
10420
10421
10422static int survey_handler(struct nl_msg *msg, void *arg)
10423{
10424 struct nlattr *tb[NL80211_ATTR_MAX + 1];
10425 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
10426 struct nlattr *sinfo[NL80211_SURVEY_INFO_MAX + 1];
10427 struct survey_results *survey_results;
10428 u32 surveyed_freq = 0;
10429 u32 ifidx;
10430
10431 static struct nla_policy survey_policy[NL80211_SURVEY_INFO_MAX + 1] = {
10432 [NL80211_SURVEY_INFO_FREQUENCY] = { .type = NLA_U32 },
10433 [NL80211_SURVEY_INFO_NOISE] = { .type = NLA_U8 },
10434 };
10435
10436 survey_results = (struct survey_results *) arg;
10437
10438 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
10439 genlmsg_attrlen(gnlh, 0), NULL);
10440
10441 ifidx = nla_get_u32(tb[NL80211_ATTR_IFINDEX]);
10442
10443 if (!tb[NL80211_ATTR_SURVEY_INFO])
10444 return NL_SKIP;
10445
10446 if (nla_parse_nested(sinfo, NL80211_SURVEY_INFO_MAX,
10447 tb[NL80211_ATTR_SURVEY_INFO],
10448 survey_policy))
10449 return NL_SKIP;
10450
10451 if (!sinfo[NL80211_SURVEY_INFO_FREQUENCY]) {
10452 wpa_printf(MSG_ERROR, "nl80211: Invalid survey data");
10453 return NL_SKIP;
10454 }
10455
10456 surveyed_freq = nla_get_u32(sinfo[NL80211_SURVEY_INFO_FREQUENCY]);
10457
10458 if (!check_survey_ok(sinfo, surveyed_freq,
10459 survey_results->freq_filter))
10460 return NL_SKIP;
10461
10462 if (survey_results->freq_filter &&
10463 survey_results->freq_filter != surveyed_freq) {
10464 wpa_printf(MSG_EXCESSIVE, "nl80211: Ignoring survey data for freq %d MHz",
10465 surveyed_freq);
10466 return NL_SKIP;
10467 }
10468
10469 add_survey(sinfo, ifidx, &survey_results->survey_list);
10470
10471 return NL_SKIP;
10472}
10473
10474
10475static int wpa_driver_nl80211_get_survey(void *priv, unsigned int freq)
10476{
10477 struct i802_bss *bss = priv;
10478 struct wpa_driver_nl80211_data *drv = bss->drv;
10479 struct nl_msg *msg;
10480 int err = -ENOBUFS;
10481 union wpa_event_data data;
10482 struct survey_results *survey_results;
10483
10484 os_memset(&data, 0, sizeof(data));
10485 survey_results = &data.survey_results;
10486
10487 dl_list_init(&survey_results->survey_list);
10488
10489 msg = nlmsg_alloc();
10490 if (!msg)
10491 goto nla_put_failure;
10492
10493 nl80211_cmd(drv, msg, NLM_F_DUMP, NL80211_CMD_GET_SURVEY);
10494
10495 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
10496
10497 if (freq)
10498 data.survey_results.freq_filter = freq;
10499
10500 do {
10501 wpa_printf(MSG_DEBUG, "nl80211: Fetch survey data");
10502 err = send_and_recv_msgs(drv, msg, survey_handler,
10503 survey_results);
10504 } while (err > 0);
10505
10506 if (err) {
10507 wpa_printf(MSG_ERROR, "nl80211: Failed to process survey data");
10508 goto out_clean;
10509 }
10510
10511 wpa_supplicant_event(drv->ctx, EVENT_SURVEY, &data);
10512
10513out_clean:
10514 clean_survey_results(survey_results);
10515nla_put_failure:
10516 return err;
10517}
10518
10519
b14a210c
JB		 10520static void nl80211_set_rekey_info(void *priv, const u8 *kek, const u8 *kck,
10521 const u8 *replay_ctr)
10522{
10523 struct i802_bss *bss = priv;
10524 struct wpa_driver_nl80211_data *drv = bss->drv;
10525 struct nlattr *replay_nested;
10526 struct nl_msg *msg;
10527
10528 msg = nlmsg_alloc();
10529 if (!msg)
10530 return;
10531
9fb04070 10532 nl80211_cmd(drv, msg, 0, NL80211_CMD_SET_REKEY_OFFLOAD);
b14a210c
JB		 10533
10534 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, bss->ifindex);
10535
10536 replay_nested = nla_nest_start(msg, NL80211_ATTR_REKEY_DATA);
10537 if (!replay_nested)
10538 goto nla_put_failure;
10539
10540 NLA_PUT(msg, NL80211_REKEY_DATA_KEK, NL80211_KEK_LEN, kek);
10541 NLA_PUT(msg, NL80211_REKEY_DATA_KCK, NL80211_KCK_LEN, kck);
10542 NLA_PUT(msg, NL80211_REKEY_DATA_REPLAY_CTR, NL80211_REPLAY_CTR_LEN,
10543 replay_ctr);
10544
10545 nla_nest_end(msg, replay_nested);
10546
10547 send_and_recv_msgs(drv, msg, NULL, NULL);
10548 return;
10549 nla_put_failure:
10550 nlmsg_free(msg);
10551}
10552
10553
39718852
JB		 10554static void nl80211_send_null_frame(struct i802_bss *bss, const u8 *own_addr,
10555 const u8 *addr, int qos)
bcf24348 10556{
39718852
JB		 10557 /* send data frame to poll STA and check whether
10558 * this frame is ACKed */
bcf24348
JB		 10559 struct {
10560 struct ieee80211_hdr hdr;
10561 u16 qos_ctl;
10562 } STRUCT_PACKED nulldata;
10563 size_t size;
10564
10565 /* Send data frame to poll STA and check whether this frame is ACKed */
10566
10567 os_memset(&nulldata, 0, sizeof(nulldata));
10568
10569 if (qos) {
10570 nulldata.hdr.frame_control =
10571 IEEE80211_FC(WLAN_FC_TYPE_DATA,
10572 WLAN_FC_STYPE_QOS_NULL);
10573 size = sizeof(nulldata);
10574 } else {
10575 nulldata.hdr.frame_control =
10576 IEEE80211_FC(WLAN_FC_TYPE_DATA,
10577 WLAN_FC_STYPE_NULLFUNC);
10578 size = sizeof(struct ieee80211_hdr);
10579 }
10580
10581 nulldata.hdr.frame_control |= host_to_le16(WLAN_FC_FROMDS);
10582 os_memcpy(nulldata.hdr.IEEE80211_DA_FROMDS, addr, ETH_ALEN);
10583 os_memcpy(nulldata.hdr.IEEE80211_BSSID_FROMDS, own_addr, ETH_ALEN);
10584 os_memcpy(nulldata.hdr.IEEE80211_SA_FROMDS, own_addr, ETH_ALEN);
10585
9ebce9c5
JM		 10586 if (wpa_driver_nl80211_send_mlme(bss, (u8 *) &nulldata, size, 0, 0, 0,
10587 0, 0) < 0)
bcf24348
JB		 10588 wpa_printf(MSG_DEBUG, "nl80211_send_null_frame: Failed to "
10589 "send poll frame");
10590}
10591
39718852
JB		 10592static void nl80211_poll_client(void *priv, const u8 *own_addr, const u8 *addr,
10593 int qos)
10594{
10595 struct i802_bss *bss = priv;
10596 struct wpa_driver_nl80211_data *drv = bss->drv;
10597 struct nl_msg *msg;
10598
10599 if (!drv->poll_command_supported) {
10600 nl80211_send_null_frame(bss, own_addr, addr, qos);
10601 return;
10602 }
10603
10604 msg = nlmsg_alloc();
10605 if (!msg)
10606 return;
10607
10608 nl80211_cmd(drv, msg, 0, NL80211_CMD_PROBE_CLIENT);
10609
10610 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, bss->ifindex);
10611 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, addr);
10612
10613 send_and_recv_msgs(drv, msg, NULL, NULL);
10614 return;
10615 nla_put_failure:
10616 nlmsg_free(msg);
10617}
10618
bcf24348 10619
29f338af
JM		 10620static int nl80211_set_power_save(struct i802_bss *bss, int enabled)
10621{
10622 struct nl_msg *msg;
10623
10624 msg = nlmsg_alloc();
10625 if (!msg)
10626 return -ENOMEM;
10627
10628 nl80211_cmd(bss->drv, msg, 0, NL80211_CMD_SET_POWER_SAVE);
10629 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, bss->ifindex);
10630 NLA_PUT_U32(msg, NL80211_ATTR_PS_STATE,
10631 enabled ? NL80211_PS_ENABLED : NL80211_PS_DISABLED);
10632 return send_and_recv_msgs(bss->drv, msg, NULL, NULL);
10633nla_put_failure:
10634 nlmsg_free(msg);
10635 return -ENOBUFS;
10636}
10637
10638
10639static int nl80211_set_p2p_powersave(void *priv, int legacy_ps, int opp_ps,
10640 int ctwindow)
10641{
10642 struct i802_bss *bss = priv;
10643
10644 wpa_printf(MSG_DEBUG, "nl80211: set_p2p_powersave (legacy_ps=%d "
10645 "opp_ps=%d ctwindow=%d)", legacy_ps, opp_ps, ctwindow);
10646
0de38036
JM		 10647 if (opp_ps != -1 || ctwindow != -1) {
10648#ifdef ANDROID_P2P
10649 wpa_driver_set_p2p_ps(priv, legacy_ps, opp_ps, ctwindow);
10650#else /* ANDROID_P2P */
29f338af 10651 return -1; /* Not yet supported */
0de38036
JM		 10652#endif /* ANDROID_P2P */
10653 }
29f338af
JM		 10654
10655 if (legacy_ps == -1)
10656 return 0;
10657 if (legacy_ps != 0 && legacy_ps != 1)
10658 return -1; /* Not yet supported */
10659
10660 return nl80211_set_power_save(bss, legacy_ps);
10661}
10662
10663
04e8003c
JD		 10664static int nl80211_start_radar_detection(void *priv,
10665 struct hostapd_freq_params *freq)
f90e9c1c
SW		 10666{
10667 struct i802_bss *bss = priv;
10668 struct wpa_driver_nl80211_data *drv = bss->drv;
10669 struct nl_msg *msg;
10670 int ret;
10671
04e8003c
JD		 10672 wpa_printf(MSG_DEBUG, "nl80211: Start radar detection (CAC) %d MHz (ht_enabled=%d, vht_enabled=%d, bandwidth=%d MHz, cf1=%d MHz, cf2=%d MHz)",
10673 freq->freq, freq->ht_enabled, freq->vht_enabled,
10674 freq->bandwidth, freq->center_freq1, freq->center_freq2);
10675
f90e9c1c
SW		 10676 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_RADAR)) {
10677 wpa_printf(MSG_DEBUG, "nl80211: Driver does not support radar "
10678 "detection");
10679 return -1;
10680 }
10681
10682 msg = nlmsg_alloc();
10683 if (!msg)
10684 return -1;
10685
10686 nl80211_cmd(bss->drv, msg, 0, NL80211_CMD_RADAR_DETECT);
10687 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
04e8003c 10688 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_FREQ, freq->freq);
f90e9c1c 10689
04e8003c
JD		 10690 if (freq->vht_enabled) {
10691 switch (freq->bandwidth) {
10692 case 20:
10693 NLA_PUT_U32(msg, NL80211_ATTR_CHANNEL_WIDTH,
10694 NL80211_CHAN_WIDTH_20);
10695 break;
10696 case 40:
10697 NLA_PUT_U32(msg, NL80211_ATTR_CHANNEL_WIDTH,
10698 NL80211_CHAN_WIDTH_40);
10699 break;
10700 case 80:
10701 if (freq->center_freq2)
10702 NLA_PUT_U32(msg, NL80211_ATTR_CHANNEL_WIDTH,
10703 NL80211_CHAN_WIDTH_80P80);
10704 else
10705 NLA_PUT_U32(msg, NL80211_ATTR_CHANNEL_WIDTH,
10706 NL80211_CHAN_WIDTH_80);
10707 break;
10708 case 160:
10709 NLA_PUT_U32(msg, NL80211_ATTR_CHANNEL_WIDTH,
10710 NL80211_CHAN_WIDTH_160);
10711 break;
10712 default:
10713 return -1;
10714 }
10715 NLA_PUT_U32(msg, NL80211_ATTR_CENTER_FREQ1, freq->center_freq1);
10716 if (freq->center_freq2)
10717 NLA_PUT_U32(msg, NL80211_ATTR_CENTER_FREQ2,
10718 freq->center_freq2);
10719 } else if (freq->ht_enabled) {
10720 switch (freq->sec_channel_offset) {
10721 case -1:
10722 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE,
10723 NL80211_CHAN_HT40MINUS);
10724 break;
10725 case 1:
10726 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE,
10727 NL80211_CHAN_HT40PLUS);
10728 break;
10729 default:
10730 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE,
10731 NL80211_CHAN_HT20);
10732 break;
10733 }
10734 }
f90e9c1c
SW		 10735
10736 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
10737 if (ret == 0)
10738 return 0;
10739 wpa_printf(MSG_DEBUG, "nl80211: Failed to start radar detection: "
10740 "%d (%s)", ret, strerror(-ret));
10741nla_put_failure:
10742 return -1;
10743}
10744
03ea1786
AN		 10745#ifdef CONFIG_TDLS
10746
10747static int nl80211_send_tdls_mgmt(void *priv, const u8 *dst, u8 action_code,
10748 u8 dialog_token, u16 status_code,
10749 const u8 *buf, size_t len)
10750{
10751 struct i802_bss *bss = priv;
10752 struct wpa_driver_nl80211_data *drv = bss->drv;
10753 struct nl_msg *msg;
10754
10755 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_TDLS_SUPPORT))
10756 return -EOPNOTSUPP;
10757
10758 if (!dst)
10759 return -EINVAL;
10760
10761 msg = nlmsg_alloc();
10762 if (!msg)
10763 return -ENOMEM;
10764
10765 nl80211_cmd(drv, msg, 0, NL80211_CMD_TDLS_MGMT);
10766 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
10767 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, dst);
10768 NLA_PUT_U8(msg, NL80211_ATTR_TDLS_ACTION, action_code);
10769 NLA_PUT_U8(msg, NL80211_ATTR_TDLS_DIALOG_TOKEN, dialog_token);
10770 NLA_PUT_U16(msg, NL80211_ATTR_STATUS_CODE, status_code);
10771 NLA_PUT(msg, NL80211_ATTR_IE, len, buf);
10772
10773 return send_and_recv_msgs(drv, msg, NULL, NULL);
10774
10775nla_put_failure:
10776 nlmsg_free(msg);
10777 return -ENOBUFS;
10778}
10779
10780
10781static int nl80211_tdls_oper(void *priv, enum tdls_oper oper, const u8 *peer)
10782{
10783 struct i802_bss *bss = priv;
10784 struct wpa_driver_nl80211_data *drv = bss->drv;
10785 struct nl_msg *msg;
10786 enum nl80211_tdls_operation nl80211_oper;
10787
10788 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_TDLS_SUPPORT))
10789 return -EOPNOTSUPP;
10790
10791 switch (oper) {
10792 case TDLS_DISCOVERY_REQ:
10793 nl80211_oper = NL80211_TDLS_DISCOVERY_REQ;
10794 break;
10795 case TDLS_SETUP:
10796 nl80211_oper = NL80211_TDLS_SETUP;
10797 break;
10798 case TDLS_TEARDOWN:
10799 nl80211_oper = NL80211_TDLS_TEARDOWN;
10800 break;
10801 case TDLS_ENABLE_LINK:
10802 nl80211_oper = NL80211_TDLS_ENABLE_LINK;
10803 break;
10804 case TDLS_DISABLE_LINK:
10805 nl80211_oper = NL80211_TDLS_DISABLE_LINK;
10806 break;
10807 case TDLS_ENABLE:
10808 return 0;
10809 case TDLS_DISABLE:
10810 return 0;
10811 default:
10812 return -EINVAL;
10813 }
10814
10815 msg = nlmsg_alloc();
10816 if (!msg)
10817 return -ENOMEM;
10818
10819 nl80211_cmd(drv, msg, 0, NL80211_CMD_TDLS_OPER);
10820 NLA_PUT_U8(msg, NL80211_ATTR_TDLS_OPERATION, nl80211_oper);
10821 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
10822 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, peer);
10823
10824 return send_and_recv_msgs(drv, msg, NULL, NULL);
10825
10826nla_put_failure:
10827 nlmsg_free(msg);
10828 return -ENOBUFS;
10829}
10830
10831#endif /* CONFIG TDLS */
10832
10833
216eede8
DS		 10834#ifdef ANDROID
10835
10836typedef struct android_wifi_priv_cmd {
10837 char *buf;
10838 int used_len;
10839 int total_len;
10840} android_wifi_priv_cmd;
10841
10842static int drv_errors = 0;
10843
10844static void wpa_driver_send_hang_msg(struct wpa_driver_nl80211_data *drv)
10845{
10846 drv_errors++;
10847 if (drv_errors > DRV_NUMBER_SEQUENTIAL_ERRORS) {
10848 drv_errors = 0;
10849 wpa_msg(drv->ctx, MSG_INFO, WPA_EVENT_DRIVER_STATE "HANGED");
10850 }
10851}
10852
10853
10854static int android_priv_cmd(struct i802_bss *bss, const char *cmd)
10855{
10856 struct wpa_driver_nl80211_data *drv = bss->drv;
10857 struct ifreq ifr;
10858 android_wifi_priv_cmd priv_cmd;
10859 char buf[MAX_DRV_CMD_SIZE];
10860 int ret;
10861
10862 os_memset(&ifr, 0, sizeof(ifr));
10863 os_memset(&priv_cmd, 0, sizeof(priv_cmd));
10864 os_strlcpy(ifr.ifr_name, bss->ifname, IFNAMSIZ);
10865
10866 os_memset(buf, 0, sizeof(buf));
10867 os_strlcpy(buf, cmd, sizeof(buf));
10868
10869 priv_cmd.buf = buf;
10870 priv_cmd.used_len = sizeof(buf);
10871 priv_cmd.total_len = sizeof(buf);
10872 ifr.ifr_data = &priv_cmd;
10873
10874 ret = ioctl(drv->global->ioctl_sock, SIOCDEVPRIVATE + 1, &ifr);
10875 if (ret < 0) {
10876 wpa_printf(MSG_ERROR, "%s: failed to issue private commands",
10877 __func__);
10878 wpa_driver_send_hang_msg(drv);
10879 return ret;
10880 }
10881
10882 drv_errors = 0;
10883 return 0;
10884}
10885
10886
10887static int android_pno_start(struct i802_bss *bss,
10888 struct wpa_driver_scan_params *params)
10889{
10890 struct wpa_driver_nl80211_data *drv = bss->drv;
10891 struct ifreq ifr;
10892 android_wifi_priv_cmd priv_cmd;
10893 int ret = 0, i = 0, bp;
10894 char buf[WEXT_PNO_MAX_COMMAND_SIZE];
10895
10896 bp = WEXT_PNOSETUP_HEADER_SIZE;
10897 os_memcpy(buf, WEXT_PNOSETUP_HEADER, bp);
10898 buf[bp++] = WEXT_PNO_TLV_PREFIX;
10899 buf[bp++] = WEXT_PNO_TLV_VERSION;
10900 buf[bp++] = WEXT_PNO_TLV_SUBVERSION;
10901 buf[bp++] = WEXT_PNO_TLV_RESERVED;
10902
10903 while (i < WEXT_PNO_AMOUNT && (size_t) i < params->num_ssids) {
10904 /* Check that there is enough space needed for 1 more SSID, the
10905 * other sections and null termination */
10906 if ((bp + WEXT_PNO_SSID_HEADER_SIZE + MAX_SSID_LEN +
10907 WEXT_PNO_NONSSID_SECTIONS_SIZE + 1) >= (int) sizeof(buf))
10908 break;
10909 wpa_hexdump_ascii(MSG_DEBUG, "For PNO Scan",
a97bde0a
JM		 10910 params->ssids[i].ssid,
10911 params->ssids[i].ssid_len);
216eede8
DS		 10912 buf[bp++] = WEXT_PNO_SSID_SECTION;
10913 buf[bp++] = params->ssids[i].ssid_len;
10914 os_memcpy(&buf[bp], params->ssids[i].ssid,
10915 params->ssids[i].ssid_len);
10916 bp += params->ssids[i].ssid_len;
10917 i++;
10918 }
10919
10920 buf[bp++] = WEXT_PNO_SCAN_INTERVAL_SECTION;
10921 os_snprintf(&buf[bp], WEXT_PNO_SCAN_INTERVAL_LENGTH + 1, "%x",
10922 WEXT_PNO_SCAN_INTERVAL);
10923 bp += WEXT_PNO_SCAN_INTERVAL_LENGTH;
10924
10925 buf[bp++] = WEXT_PNO_REPEAT_SECTION;
10926 os_snprintf(&buf[bp], WEXT_PNO_REPEAT_LENGTH + 1, "%x",
10927 WEXT_PNO_REPEAT);
10928 bp += WEXT_PNO_REPEAT_LENGTH;
10929
10930 buf[bp++] = WEXT_PNO_MAX_REPEAT_SECTION;
10931 os_snprintf(&buf[bp], WEXT_PNO_MAX_REPEAT_LENGTH + 1, "%x",
10932 WEXT_PNO_MAX_REPEAT);
10933 bp += WEXT_PNO_MAX_REPEAT_LENGTH + 1;
10934
10935 memset(&ifr, 0, sizeof(ifr));
10936 memset(&priv_cmd, 0, sizeof(priv_cmd));
24f051eb 10937 os_strlcpy(ifr.ifr_name, bss->ifname, IFNAMSIZ);
216eede8
DS		 10938
10939 priv_cmd.buf = buf;
10940 priv_cmd.used_len = bp;
10941 priv_cmd.total_len = bp;
10942 ifr.ifr_data = &priv_cmd;
10943
10944 ret = ioctl(drv->global->ioctl_sock, SIOCDEVPRIVATE + 1, &ifr);
10945
10946 if (ret < 0) {
10947 wpa_printf(MSG_ERROR, "ioctl[SIOCSIWPRIV] (pnosetup): %d",
10948 ret);
10949 wpa_driver_send_hang_msg(drv);
10950 return ret;
10951 }
10952
10953 drv_errors = 0;
10954
10955 return android_priv_cmd(bss, "PNOFORCE 1");
10956}
10957
10958
10959static int android_pno_stop(struct i802_bss *bss)
10960{
10961 return android_priv_cmd(bss, "PNOFORCE 0");
10962}
10963
10964#endif /* ANDROID */
10965
10966
9ebce9c5
JM		 10967static int driver_nl80211_set_key(const char *ifname, void *priv,
10968 enum wpa_alg alg, const u8 *addr,
10969 int key_idx, int set_tx,
10970 const u8 *seq, size_t seq_len,
10971 const u8 *key, size_t key_len)
10972{
10973 struct i802_bss *bss = priv;
10974 return wpa_driver_nl80211_set_key(ifname, bss, alg, addr, key_idx,
10975 set_tx, seq, seq_len, key, key_len);
10976}
10977
10978
10979static int driver_nl80211_scan2(void *priv,
10980 struct wpa_driver_scan_params *params)
10981{
10982 struct i802_bss *bss = priv;
10983 return wpa_driver_nl80211_scan(bss, params);
10984}
10985
10986
10987static int driver_nl80211_deauthenticate(void *priv, const u8 *addr,
10988 int reason_code)
10989{
10990 struct i802_bss *bss = priv;
10991 return wpa_driver_nl80211_deauthenticate(bss, addr, reason_code);
10992}
10993
10994
10995static int driver_nl80211_authenticate(void *priv,
10996 struct wpa_driver_auth_params *params)
10997{
10998 struct i802_bss *bss = priv;
10999 return wpa_driver_nl80211_authenticate(bss, params);
11000}
11001
11002
11003static void driver_nl80211_deinit(void *priv)
11004{
11005 struct i802_bss *bss = priv;
11006 wpa_driver_nl80211_deinit(bss);
11007}
11008
11009
11010static int driver_nl80211_if_remove(void *priv, enum wpa_driver_if_type type,
11011 const char *ifname)
11012{
11013 struct i802_bss *bss = priv;
11014 return wpa_driver_nl80211_if_remove(bss, type, ifname);
11015}
11016
11017
11018static int driver_nl80211_send_mlme(void *priv, const u8 *data,
11019 size_t data_len, int noack)
11020{
11021 struct i802_bss *bss = priv;
11022 return wpa_driver_nl80211_send_mlme(bss, data, data_len, noack,
11023 0, 0, 0, 0);
11024}
11025
11026
11027static int driver_nl80211_sta_remove(void *priv, const u8 *addr)
11028{
11029 struct i802_bss *bss = priv;
11030 return wpa_driver_nl80211_sta_remove(bss, addr);
11031}
11032
11033
9ebce9c5
JM		 11034static int driver_nl80211_set_sta_vlan(void *priv, const u8 *addr,
11035 const char *ifname, int vlan_id)
11036{
11037 struct i802_bss *bss = priv;
11038 return i802_set_sta_vlan(bss, addr, ifname, vlan_id);
11039}
9ebce9c5
JM		 11040
11041
11042static int driver_nl80211_read_sta_data(void *priv,
11043 struct hostap_sta_driver_data *data,
11044 const u8 *addr)
11045{
11046 struct i802_bss *bss = priv;
11047 return i802_read_sta_data(bss, data, addr);
11048}
11049
11050
11051static int driver_nl80211_send_action(void *priv, unsigned int freq,
11052 unsigned int wait_time,
11053 const u8 *dst, const u8 *src,
11054 const u8 *bssid,
11055 const u8 *data, size_t data_len,
11056 int no_cck)
11057{
11058 struct i802_bss *bss = priv;
11059 return wpa_driver_nl80211_send_action(bss, freq, wait_time, dst, src,
11060 bssid, data, data_len, no_cck);
11061}
11062
11063
11064static int driver_nl80211_probe_req_report(void *priv, int report)
11065{
11066 struct i802_bss *bss = priv;
11067 return wpa_driver_nl80211_probe_req_report(bss, report);
11068}
11069
11070
6a1ce395
DG		 11071static int wpa_driver_nl80211_update_ft_ies(void *priv, const u8 *md,
11072 const u8 *ies, size_t ies_len)
11073{
11074 int ret;
11075 struct nl_msg *msg;
11076 struct i802_bss *bss = priv;
11077 struct wpa_driver_nl80211_data *drv = bss->drv;
11078 u16 mdid = WPA_GET_LE16(md);
11079
11080 msg = nlmsg_alloc();
11081 if (!msg)
11082 return -ENOMEM;
11083
11084 wpa_printf(MSG_DEBUG, "nl80211: Updating FT IEs");
11085 nl80211_cmd(drv, msg, 0, NL80211_CMD_UPDATE_FT_IES);
11086 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
11087 NLA_PUT(msg, NL80211_ATTR_IE, ies_len, ies);
11088 NLA_PUT_U16(msg, NL80211_ATTR_MDID, mdid);
11089
11090 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
11091 if (ret) {
11092 wpa_printf(MSG_DEBUG, "nl80211: update_ft_ies failed "
11093 "err=%d (%s)", ret, strerror(-ret));
11094 }
11095
11096 return ret;
11097
11098nla_put_failure:
11099 nlmsg_free(msg);
11100 return -ENOBUFS;
11101}
11102
11103
597b94f5
AS		 11104const u8 * wpa_driver_nl80211_get_macaddr(void *priv)
11105{
11106 struct i802_bss *bss = priv;
11107 struct wpa_driver_nl80211_data *drv = bss->drv;
11108
11109 if (drv->nlmode != NL80211_IFTYPE_P2P_DEVICE)
11110 return NULL;
11111
11112 return bss->addr;
11113}
11114
11115
a771c07d
JM		 11116static const char * scan_state_str(enum scan_states scan_state)
11117{
11118 switch (scan_state) {
11119 case NO_SCAN:
11120 return "NO_SCAN";
11121 case SCAN_REQUESTED:
11122 return "SCAN_REQUESTED";
11123 case SCAN_STARTED:
11124 return "SCAN_STARTED";
11125 case SCAN_COMPLETED:
11126 return "SCAN_COMPLETED";
11127 case SCAN_ABORTED:
11128 return "SCAN_ABORTED";
11129 case SCHED_SCAN_STARTED:
11130 return "SCHED_SCAN_STARTED";
11131 case SCHED_SCAN_STOPPED:
11132 return "SCHED_SCAN_STOPPED";
11133 case SCHED_SCAN_RESULTS:
11134 return "SCHED_SCAN_RESULTS";
11135 }
11136
11137 return "??";
11138}
11139
11140
11141static int wpa_driver_nl80211_status(void *priv, char *buf, size_t buflen)
11142{
11143 struct i802_bss *bss = priv;
11144 struct wpa_driver_nl80211_data *drv = bss->drv;
11145 int res;
11146 char *pos, *end;
11147
11148 pos = buf;
11149 end = buf + buflen;
11150
11151 res = os_snprintf(pos, end - pos,
11152 "ifindex=%d\n"
11153 "ifname=%s\n"
11154 "brname=%s\n"
11155 "addr=" MACSTR "\n"
11156 "freq=%d\n"
11157 "%s%s%s%s%s",
11158 bss->ifindex,
11159 bss->ifname,
11160 bss->brname,
11161 MAC2STR(bss->addr),
11162 bss->freq,
11163 bss->beacon_set ? "beacon_set=1\n" : "",
11164 bss->added_if_into_bridge ?
11165 "added_if_into_bridge=1\n" : "",
11166 bss->added_bridge ? "added_bridge=1\n" : "",
11167 bss->in_deinit ? "in_deinit=1\n" : "",
11168 bss->if_dynamic ? "if_dynamic=1\n" : "");
11169 if (res < 0 || res >= end - pos)
11170 return pos - buf;
11171 pos += res;
11172
11173 if (bss->wdev_id_set) {
11174 res = os_snprintf(pos, end - pos, "wdev_id=%llu\n",
11175 (unsigned long long) bss->wdev_id);
11176 if (res < 0 || res >= end - pos)
11177 return pos - buf;
11178 pos += res;
11179 }
11180
11181 res = os_snprintf(pos, end - pos,
11182 "phyname=%s\n"
11183 "drv_ifindex=%d\n"
11184 "operstate=%d\n"
11185 "scan_state=%s\n"
11186 "auth_bssid=" MACSTR "\n"
11187 "auth_attempt_bssid=" MACSTR "\n"
11188 "bssid=" MACSTR "\n"
11189 "prev_bssid=" MACSTR "\n"
11190 "associated=%d\n"
11191 "assoc_freq=%u\n"
11192 "monitor_sock=%d\n"
11193 "monitor_ifidx=%d\n"
11194 "monitor_refcount=%d\n"
11195 "last_mgmt_freq=%u\n"
11196 "eapol_tx_sock=%d\n"
11197 "%s%s%s%s%s%s%s%s%s%s%s%s%s",
11198 drv->phyname,
11199 drv->ifindex,
11200 drv->operstate,
11201 scan_state_str(drv->scan_state),
11202 MAC2STR(drv->auth_bssid),
11203 MAC2STR(drv->auth_attempt_bssid),
11204 MAC2STR(drv->bssid),
11205 MAC2STR(drv->prev_bssid),
11206 drv->associated,
11207 drv->assoc_freq,
11208 drv->monitor_sock,
11209 drv->monitor_ifidx,
11210 drv->monitor_refcount,
11211 drv->last_mgmt_freq,
11212 drv->eapol_tx_sock,
11213 drv->ignore_if_down_event ?
11214 "ignore_if_down_event=1\n" : "",
11215 drv->scan_complete_events ?
11216 "scan_complete_events=1\n" : "",
11217 drv->disabled_11b_rates ?
11218 "disabled_11b_rates=1\n" : "",
11219 drv->pending_remain_on_chan ?
11220 "pending_remain_on_chan=1\n" : "",
11221 drv->in_interface_list ? "in_interface_list=1\n" : "",
11222 drv->device_ap_sme ? "device_ap_sme=1\n" : "",
11223 drv->poll_command_supported ?
11224 "poll_command_supported=1\n" : "",
11225 drv->data_tx_status ? "data_tx_status=1\n" : "",
11226 drv->scan_for_auth ? "scan_for_auth=1\n" : "",
11227 drv->retry_auth ? "retry_auth=1\n" : "",
11228 drv->use_monitor ? "use_monitor=1\n" : "",
11229 drv->ignore_next_local_disconnect ?
11230 "ignore_next_local_disconnect=1\n" : "",
11231 drv->allow_p2p_device ? "allow_p2p_device=1\n" : "");
11232 if (res < 0 || res >= end - pos)
11233 return pos - buf;
11234 pos += res;
11235
11236 if (drv->has_capability) {
11237 res = os_snprintf(pos, end - pos,
11238 "capa.key_mgmt=0x%x\n"
11239 "capa.enc=0x%x\n"
11240 "capa.auth=0x%x\n"
11241 "capa.flags=0x%x\n"
11242 "capa.max_scan_ssids=%d\n"
11243 "capa.max_sched_scan_ssids=%d\n"
11244 "capa.sched_scan_supported=%d\n"
11245 "capa.max_match_sets=%d\n"
11246 "capa.max_remain_on_chan=%u\n"
11247 "capa.max_stations=%u\n"
11248 "capa.probe_resp_offloads=0x%x\n"
11249 "capa.max_acl_mac_addrs=%u\n"
11250 "capa.num_multichan_concurrent=%u\n",
11251 drv->capa.key_mgmt,
11252 drv->capa.enc,
11253 drv->capa.auth,
11254 drv->capa.flags,
11255 drv->capa.max_scan_ssids,
11256 drv->capa.max_sched_scan_ssids,
11257 drv->capa.sched_scan_supported,
11258 drv->capa.max_match_sets,
11259 drv->capa.max_remain_on_chan,
11260 drv->capa.max_stations,
11261 drv->capa.probe_resp_offloads,
11262 drv->capa.max_acl_mac_addrs,
11263 drv->capa.num_multichan_concurrent);
11264 if (res < 0 || res >= end - pos)
11265 return pos - buf;
11266 pos += res;
11267 }
11268
11269 return pos - buf;
11270}
11271
11272
1c4ffa87
AO		 11273static int set_beacon_data(struct nl_msg *msg, struct beacon_data *settings)
11274{
11275 if (settings->head)
11276 NLA_PUT(msg, NL80211_ATTR_BEACON_HEAD,
11277 settings->head_len, settings->head);
11278
11279 if (settings->tail)
11280 NLA_PUT(msg, NL80211_ATTR_BEACON_TAIL,
11281 settings->tail_len, settings->tail);
11282
11283 if (settings->beacon_ies)
11284 NLA_PUT(msg, NL80211_ATTR_IE,
11285 settings->beacon_ies_len, settings->beacon_ies);
11286
11287 if (settings->proberesp_ies)
11288 NLA_PUT(msg, NL80211_ATTR_IE_PROBE_RESP,
11289 settings->proberesp_ies_len, settings->proberesp_ies);
11290
11291 if (settings->assocresp_ies)
11292 NLA_PUT(msg,
11293 NL80211_ATTR_IE_ASSOC_RESP,
11294 settings->assocresp_ies_len, settings->assocresp_ies);
11295
11296 if (settings->probe_resp)
11297 NLA_PUT(msg, NL80211_ATTR_PROBE_RESP,
11298 settings->probe_resp_len, settings->probe_resp);
11299
11300 return 0;
11301
11302nla_put_failure:
11303 return -ENOBUFS;
11304}
11305
11306
11307static int nl80211_switch_channel(void *priv, struct csa_settings *settings)
11308{
11309 struct nl_msg *msg;
11310 struct i802_bss *bss = priv;
11311 struct wpa_driver_nl80211_data *drv = bss->drv;
11312 struct nlattr *beacon_csa;
11313 int ret = -ENOBUFS;
11314
8d1fdde7 11315 wpa_printf(MSG_DEBUG, "nl80211: Channel switch request (cs_count=%u block_tx=%u freq=%d width=%d cf1=%d cf2=%d)",
1c4ffa87 11316 settings->cs_count, settings->block_tx,
8d1fdde7
JD		 11317 settings->freq_params.freq, settings->freq_params.bandwidth,
11318 settings->freq_params.center_freq1,
11319 settings->freq_params.center_freq2);
1c4ffa87
AO		 11320
11321 if (!drv->channel_switch_supported) {
11322 wpa_printf(MSG_DEBUG, "nl80211: Driver does not support channel switch command");
11323 return -EOPNOTSUPP;
11324 }
11325
11326 if ((drv->nlmode != NL80211_IFTYPE_AP) &&
11327 (drv->nlmode != NL80211_IFTYPE_P2P_GO))
11328 return -EOPNOTSUPP;
11329
11330 /* check settings validity */
11331 if (!settings->beacon_csa.tail ||
11332 ((settings->beacon_csa.tail_len <=
11333 settings->counter_offset_beacon) ||
11334 (settings->beacon_csa.tail[settings->counter_offset_beacon] !=
11335 settings->cs_count)))
11336 return -EINVAL;
11337
11338 if (settings->beacon_csa.probe_resp &&
11339 ((settings->beacon_csa.probe_resp_len <=
11340 settings->counter_offset_presp) ||
11341 (settings->beacon_csa.probe_resp[settings->counter_offset_presp] !=
11342 settings->cs_count)))
11343 return -EINVAL;
11344
11345 msg = nlmsg_alloc();
11346 if (!msg)
11347 return -ENOMEM;
11348
11349 nl80211_cmd(drv, msg, 0, NL80211_CMD_CHANNEL_SWITCH);
11350 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
11351 NLA_PUT_U32(msg, NL80211_ATTR_CH_SWITCH_COUNT, settings->cs_count);
11352 ret = nl80211_put_freq_params(msg, &settings->freq_params);
11353 if (ret)
11354 goto error;
11355
11356 if (settings->block_tx)
11357 NLA_PUT_FLAG(msg, NL80211_ATTR_CH_SWITCH_BLOCK_TX);
11358
11359 /* beacon_after params */
11360 ret = set_beacon_data(msg, &settings->beacon_after);
11361 if (ret)
11362 goto error;
11363
11364 /* beacon_csa params */
11365 beacon_csa = nla_nest_start(msg, NL80211_ATTR_CSA_IES);
11366 if (!beacon_csa)
11367 goto nla_put_failure;
11368
11369 ret = set_beacon_data(msg, &settings->beacon_csa);
11370 if (ret)
11371 goto error;
11372
11373 NLA_PUT_U16(msg, NL80211_ATTR_CSA_C_OFF_BEACON,
11374 settings->counter_offset_beacon);
11375
11376 if (settings->beacon_csa.probe_resp)
11377 NLA_PUT_U16(msg, NL80211_ATTR_CSA_C_OFF_PRESP,
11378 settings->counter_offset_presp);
11379
11380 nla_nest_end(msg, beacon_csa);
11381 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
11382 if (ret) {
11383 wpa_printf(MSG_DEBUG, "nl80211: switch_channel failed err=%d (%s)",
11384 ret, strerror(-ret));
11385 }
11386 return ret;
11387
11388nla_put_failure:
11389 ret = -ENOBUFS;
11390error:
11391 nlmsg_free(msg);
11392 wpa_printf(MSG_DEBUG, "nl80211: Could not build channel switch request");
11393 return ret;
11394}
11395
11396
049105b4
KP		 11397static int nl80211_set_qos_map(void *priv, const u8 *qos_map_set,
11398 u8 qos_map_set_len)
11399{
11400 struct i802_bss *bss = priv;
11401 struct wpa_driver_nl80211_data *drv = bss->drv;
11402 struct nl_msg *msg;
11403 int ret;
11404
11405 msg = nlmsg_alloc();
11406 if (!msg)
11407 return -ENOMEM;
11408
11409 wpa_hexdump(MSG_DEBUG, "nl80211: Setting QoS Map",
11410 qos_map_set, qos_map_set_len);
11411
11412 nl80211_cmd(drv, msg, 0, NL80211_CMD_SET_QOS_MAP);
11413 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
11414 NLA_PUT(msg, NL80211_ATTR_QOS_MAP, qos_map_set_len, qos_map_set);
11415
11416 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
11417 if (ret)
11418 wpa_printf(MSG_DEBUG, "nl80211: Setting QoS Map failed");
11419
11420 return ret;
11421
11422nla_put_failure:
11423 nlmsg_free(msg);
11424 return -ENOBUFS;
11425}
11426
11427
3f5285e8
JM		 11428const struct wpa_driver_ops wpa_driver_nl80211_ops = {
11429 .name = "nl80211",
11430 .desc = "Linux nl80211/cfg80211",
11431 .get_bssid = wpa_driver_nl80211_get_bssid,
11432 .get_ssid = wpa_driver_nl80211_get_ssid,
9ebce9c5
JM		 11433 .set_key = driver_nl80211_set_key,
11434 .scan2 = driver_nl80211_scan2,
d21c63b9
LC		 11435 .sched_scan = wpa_driver_nl80211_sched_scan,
11436 .stop_sched_scan = wpa_driver_nl80211_stop_sched_scan,
3f5285e8 11437 .get_scan_results2 = wpa_driver_nl80211_get_scan_results,
9ebce9c5
JM		 11438 .deauthenticate = driver_nl80211_deauthenticate,
11439 .authenticate = driver_nl80211_authenticate,
3f5285e8 11440 .associate = wpa_driver_nl80211_associate,
f2ed8023
JM		 11441 .global_init = nl80211_global_init,
11442 .global_deinit = nl80211_global_deinit,
11443 .init2 = wpa_driver_nl80211_init,
9ebce9c5 11444 .deinit = driver_nl80211_deinit,
3f5285e8
JM		 11445 .get_capa = wpa_driver_nl80211_get_capa,
11446 .set_operstate = wpa_driver_nl80211_set_operstate,
01652550 11447 .set_supp_port = wpa_driver_nl80211_set_supp_port,
6d158490 11448 .set_country = wpa_driver_nl80211_set_country,
f0793bf1 11449 .get_country = wpa_driver_nl80211_get_country,
19c3b566 11450 .set_ap = wpa_driver_nl80211_set_ap,
3c4ca363 11451 .set_acl = wpa_driver_nl80211_set_acl,
22a7c9d7 11452 .if_add = wpa_driver_nl80211_if_add,
9ebce9c5
JM		 11453 .if_remove = driver_nl80211_if_remove,
11454 .send_mlme = driver_nl80211_send_mlme,
c3965310 11455 .get_hw_feature_data = wpa_driver_nl80211_get_hw_feature_data,
0f4e8b4f 11456 .sta_add = wpa_driver_nl80211_sta_add,
9ebce9c5 11457 .sta_remove = driver_nl80211_sta_remove,
db149ac9 11458 .hapd_send_eapol = wpa_driver_nl80211_hapd_send_eapol,
a8d6ffa4 11459 .sta_set_flags = wpa_driver_nl80211_sta_set_flags,
c5121837 11460 .hapd_init = i802_init,
c5121837 11461 .hapd_deinit = i802_deinit,
f7b3920c 11462 .set_wds_sta = i802_set_wds_sta,
c5121837
JM		 11463 .get_seqnum = i802_get_seqnum,
11464 .flush = i802_flush,
c5121837
JM		 11465 .get_inact_sec = i802_get_inact_sec,
11466 .sta_clear_stats = i802_sta_clear_stats,
c5121837
JM		 11467 .set_rts = i802_set_rts,
11468 .set_frag = i802_set_frag,
c5121837 11469 .set_tx_queue_params = i802_set_tx_queue_params,
9ebce9c5 11470 .set_sta_vlan = driver_nl80211_set_sta_vlan,
ee7ab173
JB		 11471 .sta_deauth = i802_sta_deauth,
11472 .sta_disassoc = i802_sta_disassoc,
9ebce9c5 11473 .read_sta_data = driver_nl80211_read_sta_data,
e3802622 11474 .set_freq = i802_set_freq,
9ebce9c5 11475 .send_action = driver_nl80211_send_action,
5dfca53f 11476 .send_action_cancel_wait = wpa_driver_nl80211_send_action_cancel_wait,
55777702
JM		 11477 .remain_on_channel = wpa_driver_nl80211_remain_on_channel,
11478 .cancel_remain_on_channel =
11479 wpa_driver_nl80211_cancel_remain_on_channel,
9ebce9c5 11480 .probe_req_report = driver_nl80211_probe_req_report,
af473088 11481 .deinit_ap = wpa_driver_nl80211_deinit_ap,
3c29244e 11482 .deinit_p2p_cli = wpa_driver_nl80211_deinit_p2p_cli,
207ef3fb 11483 .resume = wpa_driver_nl80211_resume,
7b90c16a 11484 .send_ft_action = nl80211_send_ft_action,
b625473c 11485 .signal_monitor = nl80211_signal_monitor,
1c5c7273 11486 .signal_poll = nl80211_signal_poll,
b91ab76e 11487 .send_frame = nl80211_send_frame,
57ebba59 11488 .shared_freq = wpa_driver_nl80211_shared_freq,
c55f774d 11489 .set_param = nl80211_set_param,
6859f1cb 11490 .get_radio_name = nl80211_get_radio_name,
a6efc65d
JM		 11491 .add_pmkid = nl80211_add_pmkid,
11492 .remove_pmkid = nl80211_remove_pmkid,
11493 .flush_pmkid = nl80211_flush_pmkid,
b14a210c 11494 .set_rekey_info = nl80211_set_rekey_info,
bcf24348 11495 .poll_client = nl80211_poll_client,
29f338af 11496 .set_p2p_powersave = nl80211_set_p2p_powersave,
f90e9c1c 11497 .start_dfs_cac = nl80211_start_radar_detection,
695c7038 11498 .stop_ap = wpa_driver_nl80211_stop_ap,
03ea1786
AN		 11499#ifdef CONFIG_TDLS
11500 .send_tdls_mgmt = nl80211_send_tdls_mgmt,
11501 .tdls_oper = nl80211_tdls_oper,
11502#endif /* CONFIG_TDLS */
6a1ce395 11503 .update_ft_ies = wpa_driver_nl80211_update_ft_ies,
597b94f5 11504 .get_mac_addr = wpa_driver_nl80211_get_macaddr,
0185007c 11505 .get_survey = wpa_driver_nl80211_get_survey,
a771c07d 11506 .status = wpa_driver_nl80211_status,
1c4ffa87 11507 .switch_channel = nl80211_switch_channel,
0de38036
JM		 11508#ifdef ANDROID_P2P
11509 .set_noa = wpa_driver_set_p2p_noa,
11510 .get_noa = wpa_driver_get_p2p_noa,
11511 .set_ap_wps_ie = wpa_driver_set_ap_wps_p2p_ie,
11512#endif /* ANDROID_P2P */
5e2c3490
JM		 11513#ifdef ANDROID
11514 .driver_cmd = wpa_driver_nl80211_driver_cmd,
11515#endif /* ANDROID */
049105b4 11516 .set_qos_map = nl80211_set_qos_map,
3f5285e8 11517};
Unnamed repository; edit this file 'description' to name the repository.