2 * Driver interaction with Linux nl80211/cfg80211
3 * Copyright (c) 2002-2014, Jouni Malinen <j@w1.fi>
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>
7 * Copyright (c) 2009-2010, Atheros Communications
9 * This software may be distributed under the terms of the BSD license.
10 * See README for more details.
14 #include <sys/ioctl.h>
15 #include <sys/types.h>
19 #include <netlink/genl/genl.h>
20 #include <netlink/genl/family.h>
21 #include <netlink/genl/ctrl.h>
22 #include <linux/rtnetlink.h>
23 #include <netpacket/packet.h>
24 #include <linux/filter.h>
25 #include <linux/errqueue.h>
26 #include "nl80211_copy.h"
30 #include "utils/list.h"
31 #include "common/qca-vendor.h"
32 #include "common/ieee802_11_defs.h"
33 #include "common/ieee802_11_common.h"
34 #include "l2_packet/l2_packet.h"
36 #include "linux_ioctl.h"
38 #include "radiotap_iter.h"
42 #ifndef SO_WIFI_STATUS
43 # if defined(__sparc__)
44 # define SO_WIFI_STATUS 0x0025
45 # elif defined(__parisc__)
46 # define SO_WIFI_STATUS 0x4022
48 # define SO_WIFI_STATUS 41
51 # define SCM_WIFI_STATUS SO_WIFI_STATUS
54 #ifndef SO_EE_ORIGIN_TXSTATUS
55 #define SO_EE_ORIGIN_TXSTATUS 4
58 #ifndef PACKET_TX_TIMESTAMP
59 #define PACKET_TX_TIMESTAMP 16
63 #include "android_drv.h"
66 /* libnl 2.0 compatibility code */
67 #define nl_handle nl_sock
68 #define nl80211_handle_alloc nl_socket_alloc_cb
69 #define nl80211_handle_destroy nl_socket_free
72 * libnl 1.1 has a bug, it tries to allocate socket numbers densely
73 * but when you free a socket again it will mess up its bitmap and
74 * and use the wrong number the next time it needs a socket ID.
75 * Therefore, we wrap the handle alloc/destroy and add our own pid
78 static uint32_t port_bitmap
[32] = { 0 };
80 static struct nl_handle
*nl80211_handle_alloc(void *cb
)
82 struct nl_handle
*handle
;
83 uint32_t pid
= getpid() & 0x3FFFFF;
86 handle
= nl_handle_alloc_cb(cb
);
88 for (i
= 0; i
< 1024; i
++) {
89 if (port_bitmap
[i
/ 32] & (1 << (i
% 32)))
91 port_bitmap
[i
/ 32] |= 1 << (i
% 32);
96 nl_socket_set_local_port(handle
, pid
);
101 static void nl80211_handle_destroy(struct nl_handle
*handle
)
103 uint32_t port
= nl_socket_get_local_port(handle
);
106 port_bitmap
[port
/ 32] &= ~(1 << (port
% 32));
108 nl_handle_destroy(handle
);
110 #endif /* CONFIG_LIBNL20 */
114 /* system/core/libnl_2 does not include nl_socket_set_nonblocking() */
115 static int android_nl_socket_set_nonblocking(struct nl_handle
*handle
)
117 return fcntl(nl_socket_get_fd(handle
), F_SETFL
, O_NONBLOCK
);
119 #undef nl_socket_set_nonblocking
120 #define nl_socket_set_nonblocking(h) android_nl_socket_set_nonblocking(h)
124 static struct nl_handle
* nl_create_handle(struct nl_cb
*cb
, const char *dbg
)
126 struct nl_handle
*handle
;
128 handle
= nl80211_handle_alloc(cb
);
129 if (handle
== NULL
) {
130 wpa_printf(MSG_ERROR
, "nl80211: Failed to allocate netlink "
131 "callbacks (%s)", dbg
);
135 if (genl_connect(handle
)) {
136 wpa_printf(MSG_ERROR
, "nl80211: Failed to connect to generic "
137 "netlink (%s)", dbg
);
138 nl80211_handle_destroy(handle
);
146 static void nl_destroy_handles(struct nl_handle
**handle
)
150 nl80211_handle_destroy(*handle
);
156 #define ELOOP_SOCKET_INVALID (intptr_t) 0x8888888888888889ULL
158 #define ELOOP_SOCKET_INVALID (intptr_t) 0x88888889ULL
161 static void nl80211_register_eloop_read(struct nl_handle
**handle
,
162 eloop_sock_handler handler
,
165 nl_socket_set_nonblocking(*handle
);
166 eloop_register_read_sock(nl_socket_get_fd(*handle
), handler
,
167 eloop_data
, *handle
);
168 *handle
= (void *) (((intptr_t) *handle
) ^ ELOOP_SOCKET_INVALID
);
172 static void nl80211_destroy_eloop_handle(struct nl_handle
**handle
)
174 *handle
= (void *) (((intptr_t) *handle
) ^ ELOOP_SOCKET_INVALID
);
175 eloop_unregister_read_sock(nl_socket_get_fd(*handle
));
176 nl_destroy_handles(handle
);
181 #define IFF_LOWER_UP 0x10000 /* driver signals L1 up */
184 #define IFF_DORMANT 0x20000 /* driver signals dormant */
187 #ifndef IF_OPER_DORMANT
188 #define IF_OPER_DORMANT 5
194 struct nl80211_global
{
195 struct dl_list interfaces
;
198 int if_add_wdevid_set
;
199 struct netlink_data
*netlink
;
201 struct nl_handle
*nl
;
203 int ioctl_sock
; /* socket for ioctl() use */
205 struct nl_handle
*nl_event
;
208 struct nl80211_wiphy_data
{
213 struct nl_handle
*nl_beacons
;
219 static void nl80211_global_deinit(void *priv
);
222 struct wpa_driver_nl80211_data
*drv
;
223 struct i802_bss
*next
;
226 char ifname
[IFNAMSIZ
+ 1];
227 char brname
[IFNAMSIZ
];
228 unsigned int beacon_set
:1;
229 unsigned int added_if_into_bridge
:1;
230 unsigned int added_bridge
:1;
231 unsigned int in_deinit
:1;
232 unsigned int wdev_id_set
:1;
233 unsigned int added_if
:1;
241 struct nl_handle
*nl_preq
, *nl_mgmt
;
244 struct nl80211_wiphy_data
*wiphy_data
;
245 struct dl_list wiphy_list
;
248 struct wpa_driver_nl80211_data
{
249 struct nl80211_global
*global
;
251 struct dl_list wiphy_list
;
257 int ignore_if_down_event
;
258 struct rfkill_data
*rfkill
;
259 struct wpa_driver_capa capa
;
260 u8
*extended_capa
, *extended_capa_mask
;
261 unsigned int extended_capa_len
;
266 int scan_complete_events
;
268 NO_SCAN
, SCAN_REQUESTED
, SCAN_STARTED
, SCAN_COMPLETED
,
269 SCAN_ABORTED
, SCHED_SCAN_STARTED
, SCHED_SCAN_STOPPED
,
275 u8 auth_bssid
[ETH_ALEN
];
276 u8 auth_attempt_bssid
[ETH_ALEN
];
278 u8 prev_bssid
[ETH_ALEN
];
282 enum nl80211_iftype nlmode
;
283 enum nl80211_iftype ap_scan_as_station
;
284 unsigned int assoc_freq
;
288 int monitor_refcount
;
290 unsigned int disabled_11b_rates
:1;
291 unsigned int pending_remain_on_chan
:1;
292 unsigned int in_interface_list
:1;
293 unsigned int device_ap_sme
:1;
294 unsigned int poll_command_supported
:1;
295 unsigned int data_tx_status
:1;
296 unsigned int scan_for_auth
:1;
297 unsigned int retry_auth
:1;
298 unsigned int use_monitor
:1;
299 unsigned int ignore_next_local_disconnect
:1;
300 unsigned int allow_p2p_device
:1;
301 unsigned int hostapd
:1;
302 unsigned int start_mode_ap
:1;
303 unsigned int start_iface_up
:1;
304 unsigned int test_use_roc_tx
:1;
305 unsigned int ignore_deauth_event
:1;
306 unsigned int dfs_vendor_cmd_avail
:1;
308 u64 remain_on_chan_cookie
;
309 u64 send_action_cookie
;
311 unsigned int last_mgmt_freq
;
313 struct wpa_driver_scan_filter
*filter_ssids
;
314 size_t num_filter_ssids
;
316 struct i802_bss
*first_bss
;
320 int eapol_sock
; /* socket for EAPOL frames */
322 int default_if_indices
[16];
326 /* From failed authentication command */
328 u8 auth_bssid_
[ETH_ALEN
];
330 size_t auth_ssid_len
;
334 u8 auth_wep_key
[4][16];
335 size_t auth_wep_key_len
[4];
336 int auth_wep_tx_keyidx
;
337 int auth_local_state_change
;
342 static void wpa_driver_nl80211_deinit(struct i802_bss
*bss
);
343 static void wpa_driver_nl80211_scan_timeout(void *eloop_ctx
,
345 static int wpa_driver_nl80211_set_mode(struct i802_bss
*bss
,
346 enum nl80211_iftype nlmode
);
348 wpa_driver_nl80211_finish_drv_init(struct wpa_driver_nl80211_data
*drv
,
349 const u8
*set_addr
, int first
);
350 static int wpa_driver_nl80211_mlme(struct wpa_driver_nl80211_data
*drv
,
351 const u8
*addr
, int cmd
, u16 reason_code
,
352 int local_state_change
);
353 static void nl80211_remove_monitor_interface(
354 struct wpa_driver_nl80211_data
*drv
);
355 static int nl80211_send_frame_cmd(struct i802_bss
*bss
,
356 unsigned int freq
, unsigned int wait
,
357 const u8
*buf
, size_t buf_len
, u64
*cookie
,
358 int no_cck
, int no_ack
, int offchanok
);
359 static int nl80211_register_frame(struct i802_bss
*bss
,
360 struct nl_handle
*hl_handle
,
361 u16 type
, const u8
*match
, size_t match_len
);
362 static int wpa_driver_nl80211_probe_req_report(struct i802_bss
*bss
,
365 static int android_pno_start(struct i802_bss
*bss
,
366 struct wpa_driver_scan_params
*params
);
367 static int android_pno_stop(struct i802_bss
*bss
);
368 extern int wpa_driver_nl80211_driver_cmd(void *priv
, char *cmd
, char *buf
,
372 int wpa_driver_set_p2p_noa(void *priv
, u8 count
, int start
, int duration
);
373 int wpa_driver_get_p2p_noa(void *priv
, u8
*buf
, size_t len
);
374 int wpa_driver_set_p2p_ps(void *priv
, int legacy_ps
, int opp_ps
, int ctwindow
);
375 int wpa_driver_set_ap_wps_p2p_ie(void *priv
, const struct wpabuf
*beacon
,
376 const struct wpabuf
*proberesp
,
377 const struct wpabuf
*assocresp
);
378 #endif /* ANDROID_P2P */
380 static void add_ifidx(struct wpa_driver_nl80211_data
*drv
, int ifidx
);
381 static void del_ifidx(struct wpa_driver_nl80211_data
*drv
, int ifidx
);
382 static int have_ifidx(struct wpa_driver_nl80211_data
*drv
, int ifidx
);
383 static int wpa_driver_nl80211_if_remove(struct i802_bss
*bss
,
384 enum wpa_driver_if_type type
,
387 static int wpa_driver_nl80211_set_freq(struct i802_bss
*bss
,
388 struct hostapd_freq_params
*freq
);
389 static int nl80211_disable_11b_rates(struct wpa_driver_nl80211_data
*drv
,
390 int ifindex
, int disabled
);
392 static int nl80211_leave_ibss(struct wpa_driver_nl80211_data
*drv
);
393 static int wpa_driver_nl80211_authenticate_retry(
394 struct wpa_driver_nl80211_data
*drv
);
396 static int i802_set_iface_flags(struct i802_bss
*bss
, int up
);
399 static const char * nl80211_command_to_string(enum nl80211_commands cmd
)
401 #define C2S(x) case x: return #x;
403 C2S(NL80211_CMD_UNSPEC
)
404 C2S(NL80211_CMD_GET_WIPHY
)
405 C2S(NL80211_CMD_SET_WIPHY
)
406 C2S(NL80211_CMD_NEW_WIPHY
)
407 C2S(NL80211_CMD_DEL_WIPHY
)
408 C2S(NL80211_CMD_GET_INTERFACE
)
409 C2S(NL80211_CMD_SET_INTERFACE
)
410 C2S(NL80211_CMD_NEW_INTERFACE
)
411 C2S(NL80211_CMD_DEL_INTERFACE
)
412 C2S(NL80211_CMD_GET_KEY
)
413 C2S(NL80211_CMD_SET_KEY
)
414 C2S(NL80211_CMD_NEW_KEY
)
415 C2S(NL80211_CMD_DEL_KEY
)
416 C2S(NL80211_CMD_GET_BEACON
)
417 C2S(NL80211_CMD_SET_BEACON
)
418 C2S(NL80211_CMD_START_AP
)
419 C2S(NL80211_CMD_STOP_AP
)
420 C2S(NL80211_CMD_GET_STATION
)
421 C2S(NL80211_CMD_SET_STATION
)
422 C2S(NL80211_CMD_NEW_STATION
)
423 C2S(NL80211_CMD_DEL_STATION
)
424 C2S(NL80211_CMD_GET_MPATH
)
425 C2S(NL80211_CMD_SET_MPATH
)
426 C2S(NL80211_CMD_NEW_MPATH
)
427 C2S(NL80211_CMD_DEL_MPATH
)
428 C2S(NL80211_CMD_SET_BSS
)
429 C2S(NL80211_CMD_SET_REG
)
430 C2S(NL80211_CMD_REQ_SET_REG
)
431 C2S(NL80211_CMD_GET_MESH_CONFIG
)
432 C2S(NL80211_CMD_SET_MESH_CONFIG
)
433 C2S(NL80211_CMD_SET_MGMT_EXTRA_IE
)
434 C2S(NL80211_CMD_GET_REG
)
435 C2S(NL80211_CMD_GET_SCAN
)
436 C2S(NL80211_CMD_TRIGGER_SCAN
)
437 C2S(NL80211_CMD_NEW_SCAN_RESULTS
)
438 C2S(NL80211_CMD_SCAN_ABORTED
)
439 C2S(NL80211_CMD_REG_CHANGE
)
440 C2S(NL80211_CMD_AUTHENTICATE
)
441 C2S(NL80211_CMD_ASSOCIATE
)
442 C2S(NL80211_CMD_DEAUTHENTICATE
)
443 C2S(NL80211_CMD_DISASSOCIATE
)
444 C2S(NL80211_CMD_MICHAEL_MIC_FAILURE
)
445 C2S(NL80211_CMD_REG_BEACON_HINT
)
446 C2S(NL80211_CMD_JOIN_IBSS
)
447 C2S(NL80211_CMD_LEAVE_IBSS
)
448 C2S(NL80211_CMD_TESTMODE
)
449 C2S(NL80211_CMD_CONNECT
)
450 C2S(NL80211_CMD_ROAM
)
451 C2S(NL80211_CMD_DISCONNECT
)
452 C2S(NL80211_CMD_SET_WIPHY_NETNS
)
453 C2S(NL80211_CMD_GET_SURVEY
)
454 C2S(NL80211_CMD_NEW_SURVEY_RESULTS
)
455 C2S(NL80211_CMD_SET_PMKSA
)
456 C2S(NL80211_CMD_DEL_PMKSA
)
457 C2S(NL80211_CMD_FLUSH_PMKSA
)
458 C2S(NL80211_CMD_REMAIN_ON_CHANNEL
)
459 C2S(NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL
)
460 C2S(NL80211_CMD_SET_TX_BITRATE_MASK
)
461 C2S(NL80211_CMD_REGISTER_FRAME
)
462 C2S(NL80211_CMD_FRAME
)
463 C2S(NL80211_CMD_FRAME_TX_STATUS
)
464 C2S(NL80211_CMD_SET_POWER_SAVE
)
465 C2S(NL80211_CMD_GET_POWER_SAVE
)
466 C2S(NL80211_CMD_SET_CQM
)
467 C2S(NL80211_CMD_NOTIFY_CQM
)
468 C2S(NL80211_CMD_SET_CHANNEL
)
469 C2S(NL80211_CMD_SET_WDS_PEER
)
470 C2S(NL80211_CMD_FRAME_WAIT_CANCEL
)
471 C2S(NL80211_CMD_JOIN_MESH
)
472 C2S(NL80211_CMD_LEAVE_MESH
)
473 C2S(NL80211_CMD_UNPROT_DEAUTHENTICATE
)
474 C2S(NL80211_CMD_UNPROT_DISASSOCIATE
)
475 C2S(NL80211_CMD_NEW_PEER_CANDIDATE
)
476 C2S(NL80211_CMD_GET_WOWLAN
)
477 C2S(NL80211_CMD_SET_WOWLAN
)
478 C2S(NL80211_CMD_START_SCHED_SCAN
)
479 C2S(NL80211_CMD_STOP_SCHED_SCAN
)
480 C2S(NL80211_CMD_SCHED_SCAN_RESULTS
)
481 C2S(NL80211_CMD_SCHED_SCAN_STOPPED
)
482 C2S(NL80211_CMD_SET_REKEY_OFFLOAD
)
483 C2S(NL80211_CMD_PMKSA_CANDIDATE
)
484 C2S(NL80211_CMD_TDLS_OPER
)
485 C2S(NL80211_CMD_TDLS_MGMT
)
486 C2S(NL80211_CMD_UNEXPECTED_FRAME
)
487 C2S(NL80211_CMD_PROBE_CLIENT
)
488 C2S(NL80211_CMD_REGISTER_BEACONS
)
489 C2S(NL80211_CMD_UNEXPECTED_4ADDR_FRAME
)
490 C2S(NL80211_CMD_SET_NOACK_MAP
)
491 C2S(NL80211_CMD_CH_SWITCH_NOTIFY
)
492 C2S(NL80211_CMD_START_P2P_DEVICE
)
493 C2S(NL80211_CMD_STOP_P2P_DEVICE
)
494 C2S(NL80211_CMD_CONN_FAILED
)
495 C2S(NL80211_CMD_SET_MCAST_RATE
)
496 C2S(NL80211_CMD_SET_MAC_ACL
)
497 C2S(NL80211_CMD_RADAR_DETECT
)
498 C2S(NL80211_CMD_GET_PROTOCOL_FEATURES
)
499 C2S(NL80211_CMD_UPDATE_FT_IES
)
500 C2S(NL80211_CMD_FT_EVENT
)
501 C2S(NL80211_CMD_CRIT_PROTOCOL_START
)
502 C2S(NL80211_CMD_CRIT_PROTOCOL_STOP
)
503 C2S(NL80211_CMD_GET_COALESCE
)
504 C2S(NL80211_CMD_SET_COALESCE
)
505 C2S(NL80211_CMD_CHANNEL_SWITCH
)
506 C2S(NL80211_CMD_VENDOR
)
507 C2S(NL80211_CMD_SET_QOS_MAP
)
509 return "NL80211_CMD_UNKNOWN";
515 /* Converts nl80211_chan_width to a common format */
516 static enum chan_width
convert2width(int width
)
519 case NL80211_CHAN_WIDTH_20_NOHT
:
520 return CHAN_WIDTH_20_NOHT
;
521 case NL80211_CHAN_WIDTH_20
:
522 return CHAN_WIDTH_20
;
523 case NL80211_CHAN_WIDTH_40
:
524 return CHAN_WIDTH_40
;
525 case NL80211_CHAN_WIDTH_80
:
526 return CHAN_WIDTH_80
;
527 case NL80211_CHAN_WIDTH_80P80
:
528 return CHAN_WIDTH_80P80
;
529 case NL80211_CHAN_WIDTH_160
:
530 return CHAN_WIDTH_160
;
532 return CHAN_WIDTH_UNKNOWN
;
536 static int is_ap_interface(enum nl80211_iftype nlmode
)
538 return (nlmode
== NL80211_IFTYPE_AP
||
539 nlmode
== NL80211_IFTYPE_P2P_GO
);
543 static int is_sta_interface(enum nl80211_iftype nlmode
)
545 return (nlmode
== NL80211_IFTYPE_STATION
||
546 nlmode
== NL80211_IFTYPE_P2P_CLIENT
);
550 static int is_p2p_net_interface(enum nl80211_iftype nlmode
)
552 return (nlmode
== NL80211_IFTYPE_P2P_CLIENT
||
553 nlmode
== NL80211_IFTYPE_P2P_GO
);
557 static void nl80211_mark_disconnected(struct wpa_driver_nl80211_data
*drv
)
560 os_memcpy(drv
->prev_bssid
, drv
->bssid
, ETH_ALEN
);
562 os_memset(drv
->bssid
, 0, ETH_ALEN
);
566 struct nl80211_bss_info_arg
{
567 struct wpa_driver_nl80211_data
*drv
;
568 struct wpa_scan_results
*res
;
569 unsigned int assoc_freq
;
570 u8 assoc_bssid
[ETH_ALEN
];
573 static int bss_info_handler(struct nl_msg
*msg
, void *arg
);
577 static int ack_handler(struct nl_msg
*msg
, void *arg
)
584 static int finish_handler(struct nl_msg
*msg
, void *arg
)
591 static int error_handler(struct sockaddr_nl
*nla
, struct nlmsgerr
*err
,
600 static int no_seq_check(struct nl_msg
*msg
, void *arg
)
606 static int send_and_recv(struct nl80211_global
*global
,
607 struct nl_handle
*nl_handle
, struct nl_msg
*msg
,
608 int (*valid_handler
)(struct nl_msg
*, void *),
614 cb
= nl_cb_clone(global
->nl_cb
);
618 err
= nl_send_auto_complete(nl_handle
, msg
);
624 nl_cb_err(cb
, NL_CB_CUSTOM
, error_handler
, &err
);
625 nl_cb_set(cb
, NL_CB_FINISH
, NL_CB_CUSTOM
, finish_handler
, &err
);
626 nl_cb_set(cb
, NL_CB_ACK
, NL_CB_CUSTOM
, ack_handler
, &err
);
629 nl_cb_set(cb
, NL_CB_VALID
, NL_CB_CUSTOM
,
630 valid_handler
, valid_data
);
633 int res
= nl_recvmsgs(nl_handle
, cb
);
636 "nl80211: %s->nl_recvmsgs failed: %d",
647 static int send_and_recv_msgs_global(struct nl80211_global
*global
,
649 int (*valid_handler
)(struct nl_msg
*, void *),
652 return send_and_recv(global
, global
->nl
, msg
, valid_handler
,
657 static int send_and_recv_msgs(struct wpa_driver_nl80211_data
*drv
,
659 int (*valid_handler
)(struct nl_msg
*, void *),
662 return send_and_recv(drv
->global
, drv
->global
->nl
, msg
,
663 valid_handler
, valid_data
);
673 static int nl80211_set_iface_id(struct nl_msg
*msg
, struct i802_bss
*bss
)
675 if (bss
->wdev_id_set
)
676 NLA_PUT_U64(msg
, NL80211_ATTR_WDEV
, bss
->wdev_id
);
678 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, bss
->ifindex
);
686 static int family_handler(struct nl_msg
*msg
, void *arg
)
688 struct family_data
*res
= arg
;
689 struct nlattr
*tb
[CTRL_ATTR_MAX
+ 1];
690 struct genlmsghdr
*gnlh
= nlmsg_data(nlmsg_hdr(msg
));
691 struct nlattr
*mcgrp
;
694 nla_parse(tb
, CTRL_ATTR_MAX
, genlmsg_attrdata(gnlh
, 0),
695 genlmsg_attrlen(gnlh
, 0), NULL
);
696 if (!tb
[CTRL_ATTR_MCAST_GROUPS
])
699 nla_for_each_nested(mcgrp
, tb
[CTRL_ATTR_MCAST_GROUPS
], i
) {
700 struct nlattr
*tb2
[CTRL_ATTR_MCAST_GRP_MAX
+ 1];
701 nla_parse(tb2
, CTRL_ATTR_MCAST_GRP_MAX
, nla_data(mcgrp
),
702 nla_len(mcgrp
), NULL
);
703 if (!tb2
[CTRL_ATTR_MCAST_GRP_NAME
] ||
704 !tb2
[CTRL_ATTR_MCAST_GRP_ID
] ||
705 os_strncmp(nla_data(tb2
[CTRL_ATTR_MCAST_GRP_NAME
]),
707 nla_len(tb2
[CTRL_ATTR_MCAST_GRP_NAME
])) != 0)
709 res
->id
= nla_get_u32(tb2
[CTRL_ATTR_MCAST_GRP_ID
]);
717 static int nl_get_multicast_id(struct nl80211_global
*global
,
718 const char *family
, const char *group
)
722 struct family_data res
= { group
, -ENOENT
};
727 genlmsg_put(msg
, 0, 0, genl_ctrl_resolve(global
->nl
, "nlctrl"),
728 0, 0, CTRL_CMD_GETFAMILY
, 0);
729 NLA_PUT_STRING(msg
, CTRL_ATTR_FAMILY_NAME
, family
);
731 ret
= send_and_recv_msgs_global(global
, msg
, family_handler
, &res
);
742 static void * nl80211_cmd(struct wpa_driver_nl80211_data
*drv
,
743 struct nl_msg
*msg
, int flags
, uint8_t cmd
)
745 return genlmsg_put(msg
, 0, 0, drv
->global
->nl80211_id
,
750 struct wiphy_idx_data
{
752 enum nl80211_iftype nlmode
;
757 static int netdev_info_handler(struct nl_msg
*msg
, void *arg
)
759 struct nlattr
*tb
[NL80211_ATTR_MAX
+ 1];
760 struct genlmsghdr
*gnlh
= nlmsg_data(nlmsg_hdr(msg
));
761 struct wiphy_idx_data
*info
= arg
;
763 nla_parse(tb
, NL80211_ATTR_MAX
, genlmsg_attrdata(gnlh
, 0),
764 genlmsg_attrlen(gnlh
, 0), NULL
);
766 if (tb
[NL80211_ATTR_WIPHY
])
767 info
->wiphy_idx
= nla_get_u32(tb
[NL80211_ATTR_WIPHY
]);
769 if (tb
[NL80211_ATTR_IFTYPE
])
770 info
->nlmode
= nla_get_u32(tb
[NL80211_ATTR_IFTYPE
]);
772 if (tb
[NL80211_ATTR_MAC
] && info
->macaddr
)
773 os_memcpy(info
->macaddr
, nla_data(tb
[NL80211_ATTR_MAC
]),
780 static int nl80211_get_wiphy_index(struct i802_bss
*bss
)
783 struct wiphy_idx_data data
= {
790 return NL80211_IFTYPE_UNSPECIFIED
;
792 nl80211_cmd(bss
->drv
, msg
, 0, NL80211_CMD_GET_INTERFACE
);
794 if (nl80211_set_iface_id(msg
, bss
) < 0)
795 goto nla_put_failure
;
797 if (send_and_recv_msgs(bss
->drv
, msg
, netdev_info_handler
, &data
) == 0)
798 return data
.wiphy_idx
;
806 static enum nl80211_iftype
nl80211_get_ifmode(struct i802_bss
*bss
)
809 struct wiphy_idx_data data
= {
810 .nlmode
= NL80211_IFTYPE_UNSPECIFIED
,
818 nl80211_cmd(bss
->drv
, msg
, 0, NL80211_CMD_GET_INTERFACE
);
820 if (nl80211_set_iface_id(msg
, bss
) < 0)
821 goto nla_put_failure
;
823 if (send_and_recv_msgs(bss
->drv
, msg
, netdev_info_handler
, &data
) == 0)
828 return NL80211_IFTYPE_UNSPECIFIED
;
832 static int nl80211_get_macaddr(struct i802_bss
*bss
)
835 struct wiphy_idx_data data
= {
836 .macaddr
= bss
->addr
,
841 return NL80211_IFTYPE_UNSPECIFIED
;
843 nl80211_cmd(bss
->drv
, msg
, 0, NL80211_CMD_GET_INTERFACE
);
844 if (nl80211_set_iface_id(msg
, bss
) < 0)
845 goto nla_put_failure
;
847 return send_and_recv_msgs(bss
->drv
, msg
, netdev_info_handler
, &data
);
851 return NL80211_IFTYPE_UNSPECIFIED
;
855 static int nl80211_register_beacons(struct wpa_driver_nl80211_data
*drv
,
856 struct nl80211_wiphy_data
*w
)
865 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_REGISTER_BEACONS
);
867 NLA_PUT_U32(msg
, NL80211_ATTR_WIPHY
, w
->wiphy_idx
);
869 ret
= send_and_recv(drv
->global
, w
->nl_beacons
, msg
, NULL
, NULL
);
872 wpa_printf(MSG_DEBUG
, "nl80211: Register beacons command "
873 "failed: ret=%d (%s)",
874 ret
, strerror(-ret
));
875 goto nla_put_failure
;
884 static void nl80211_recv_beacons(int sock
, void *eloop_ctx
, void *handle
)
886 struct nl80211_wiphy_data
*w
= eloop_ctx
;
889 wpa_printf(MSG_EXCESSIVE
, "nl80211: Beacon event message available");
891 res
= nl_recvmsgs(handle
, w
->nl_cb
);
893 wpa_printf(MSG_INFO
, "nl80211: %s->nl_recvmsgs failed: %d",
899 static int process_beacon_event(struct nl_msg
*msg
, void *arg
)
901 struct nl80211_wiphy_data
*w
= arg
;
902 struct wpa_driver_nl80211_data
*drv
;
903 struct genlmsghdr
*gnlh
= nlmsg_data(nlmsg_hdr(msg
));
904 struct nlattr
*tb
[NL80211_ATTR_MAX
+ 1];
905 union wpa_event_data event
;
907 nla_parse(tb
, NL80211_ATTR_MAX
, genlmsg_attrdata(gnlh
, 0),
908 genlmsg_attrlen(gnlh
, 0), NULL
);
910 if (gnlh
->cmd
!= NL80211_CMD_FRAME
) {
911 wpa_printf(MSG_DEBUG
, "nl80211: Unexpected beacon event? (%d)",
916 if (!tb
[NL80211_ATTR_FRAME
])
919 dl_list_for_each(drv
, &w
->drvs
, struct wpa_driver_nl80211_data
,
921 os_memset(&event
, 0, sizeof(event
));
922 event
.rx_mgmt
.frame
= nla_data(tb
[NL80211_ATTR_FRAME
]);
923 event
.rx_mgmt
.frame_len
= nla_len(tb
[NL80211_ATTR_FRAME
]);
924 wpa_supplicant_event(drv
->ctx
, EVENT_RX_MGMT
, &event
);
931 static struct nl80211_wiphy_data
*
932 nl80211_get_wiphy_data_ap(struct i802_bss
*bss
)
934 static DEFINE_DL_LIST(nl80211_wiphys
);
935 struct nl80211_wiphy_data
*w
;
936 int wiphy_idx
, found
= 0;
937 struct i802_bss
*tmp_bss
;
939 if (bss
->wiphy_data
!= NULL
)
940 return bss
->wiphy_data
;
942 wiphy_idx
= nl80211_get_wiphy_index(bss
);
944 dl_list_for_each(w
, &nl80211_wiphys
, struct nl80211_wiphy_data
, list
) {
945 if (w
->wiphy_idx
== wiphy_idx
)
950 w
= os_zalloc(sizeof(*w
));
953 w
->wiphy_idx
= wiphy_idx
;
954 dl_list_init(&w
->bsss
);
955 dl_list_init(&w
->drvs
);
957 w
->nl_cb
= nl_cb_alloc(NL_CB_DEFAULT
);
962 nl_cb_set(w
->nl_cb
, NL_CB_SEQ_CHECK
, NL_CB_CUSTOM
, no_seq_check
, NULL
);
963 nl_cb_set(w
->nl_cb
, NL_CB_VALID
, NL_CB_CUSTOM
, process_beacon_event
,
966 w
->nl_beacons
= nl_create_handle(bss
->drv
->global
->nl_cb
,
968 if (w
->nl_beacons
== NULL
) {
973 if (nl80211_register_beacons(bss
->drv
, w
)) {
974 nl_destroy_handles(&w
->nl_beacons
);
979 nl80211_register_eloop_read(&w
->nl_beacons
, nl80211_recv_beacons
, w
);
981 dl_list_add(&nl80211_wiphys
, &w
->list
);
984 /* drv entry for this bss already there? */
985 dl_list_for_each(tmp_bss
, &w
->bsss
, struct i802_bss
, wiphy_list
) {
986 if (tmp_bss
->drv
== bss
->drv
) {
993 dl_list_add(&w
->drvs
, &bss
->drv
->wiphy_list
);
995 dl_list_add(&w
->bsss
, &bss
->wiphy_list
);
1001 static void nl80211_put_wiphy_data_ap(struct i802_bss
*bss
)
1003 struct nl80211_wiphy_data
*w
= bss
->wiphy_data
;
1004 struct i802_bss
*tmp_bss
;
1009 bss
->wiphy_data
= NULL
;
1010 dl_list_del(&bss
->wiphy_list
);
1012 /* still any for this drv present? */
1013 dl_list_for_each(tmp_bss
, &w
->bsss
, struct i802_bss
, wiphy_list
) {
1014 if (tmp_bss
->drv
== bss
->drv
) {
1019 /* if not remove it */
1021 dl_list_del(&bss
->drv
->wiphy_list
);
1023 if (!dl_list_empty(&w
->bsss
))
1026 nl80211_destroy_eloop_handle(&w
->nl_beacons
);
1028 nl_cb_put(w
->nl_cb
);
1029 dl_list_del(&w
->list
);
1034 static int wpa_driver_nl80211_get_bssid(void *priv
, u8
*bssid
)
1036 struct i802_bss
*bss
= priv
;
1037 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
1038 if (!drv
->associated
)
1040 os_memcpy(bssid
, drv
->bssid
, ETH_ALEN
);
1045 static int wpa_driver_nl80211_get_ssid(void *priv
, u8
*ssid
)
1047 struct i802_bss
*bss
= priv
;
1048 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
1049 if (!drv
->associated
)
1051 os_memcpy(ssid
, drv
->ssid
, drv
->ssid_len
);
1052 return drv
->ssid_len
;
1056 static void wpa_driver_nl80211_event_newlink(
1057 struct wpa_driver_nl80211_data
*drv
, char *ifname
)
1059 union wpa_event_data event
;
1061 if (os_strcmp(drv
->first_bss
->ifname
, ifname
) == 0) {
1062 if (if_nametoindex(drv
->first_bss
->ifname
) == 0) {
1063 wpa_printf(MSG_DEBUG
, "nl80211: Interface %s does not exist - ignore RTM_NEWLINK",
1064 drv
->first_bss
->ifname
);
1067 if (!drv
->if_removed
)
1069 wpa_printf(MSG_DEBUG
, "nl80211: Mark if_removed=0 for %s based on RTM_NEWLINK event",
1070 drv
->first_bss
->ifname
);
1071 drv
->if_removed
= 0;
1074 os_memset(&event
, 0, sizeof(event
));
1075 os_strlcpy(event
.interface_status
.ifname
, ifname
,
1076 sizeof(event
.interface_status
.ifname
));
1077 event
.interface_status
.ievent
= EVENT_INTERFACE_ADDED
;
1078 wpa_supplicant_event(drv
->ctx
, EVENT_INTERFACE_STATUS
, &event
);
1082 static void wpa_driver_nl80211_event_dellink(
1083 struct wpa_driver_nl80211_data
*drv
, char *ifname
)
1085 union wpa_event_data event
;
1087 if (os_strcmp(drv
->first_bss
->ifname
, ifname
) == 0) {
1088 if (drv
->if_removed
) {
1089 wpa_printf(MSG_DEBUG
, "nl80211: if_removed already set - ignore RTM_DELLINK event for %s",
1093 wpa_printf(MSG_DEBUG
, "RTM_DELLINK: Interface '%s' removed - mark if_removed=1",
1095 drv
->if_removed
= 1;
1097 wpa_printf(MSG_DEBUG
, "RTM_DELLINK: Interface '%s' removed",
1101 os_memset(&event
, 0, sizeof(event
));
1102 os_strlcpy(event
.interface_status
.ifname
, ifname
,
1103 sizeof(event
.interface_status
.ifname
));
1104 event
.interface_status
.ievent
= EVENT_INTERFACE_REMOVED
;
1105 wpa_supplicant_event(drv
->ctx
, EVENT_INTERFACE_STATUS
, &event
);
1109 static int wpa_driver_nl80211_own_ifname(struct wpa_driver_nl80211_data
*drv
,
1110 u8
*buf
, size_t len
)
1112 int attrlen
, rta_len
;
1113 struct rtattr
*attr
;
1116 attr
= (struct rtattr
*) buf
;
1118 rta_len
= RTA_ALIGN(sizeof(struct rtattr
));
1119 while (RTA_OK(attr
, attrlen
)) {
1120 if (attr
->rta_type
== IFLA_IFNAME
) {
1121 if (os_strcmp(((char *) attr
) + rta_len
,
1122 drv
->first_bss
->ifname
) == 0)
1127 attr
= RTA_NEXT(attr
, attrlen
);
1134 static int wpa_driver_nl80211_own_ifindex(struct wpa_driver_nl80211_data
*drv
,
1135 int ifindex
, u8
*buf
, size_t len
)
1137 if (drv
->ifindex
== ifindex
)
1140 if (drv
->if_removed
&& wpa_driver_nl80211_own_ifname(drv
, buf
, len
)) {
1141 wpa_printf(MSG_DEBUG
, "nl80211: Update ifindex for a removed "
1143 wpa_driver_nl80211_finish_drv_init(drv
, NULL
, 0);
1151 static struct wpa_driver_nl80211_data
*
1152 nl80211_find_drv(struct nl80211_global
*global
, int idx
, u8
*buf
, size_t len
)
1154 struct wpa_driver_nl80211_data
*drv
;
1155 dl_list_for_each(drv
, &global
->interfaces
,
1156 struct wpa_driver_nl80211_data
, list
) {
1157 if (wpa_driver_nl80211_own_ifindex(drv
, idx
, buf
, len
) ||
1158 have_ifidx(drv
, idx
))
1165 static void wpa_driver_nl80211_event_rtm_newlink(void *ctx
,
1166 struct ifinfomsg
*ifi
,
1167 u8
*buf
, size_t len
)
1169 struct nl80211_global
*global
= ctx
;
1170 struct wpa_driver_nl80211_data
*drv
;
1172 struct rtattr
*attr
;
1174 char namebuf
[IFNAMSIZ
];
1175 char ifname
[IFNAMSIZ
+ 1];
1176 char extra
[100], *pos
, *end
;
1178 drv
= nl80211_find_drv(global
, ifi
->ifi_index
, buf
, len
);
1180 wpa_printf(MSG_DEBUG
, "nl80211: Ignore RTM_NEWLINK event for foreign ifindex %d",
1187 end
= pos
+ sizeof(extra
);
1191 attr
= (struct rtattr
*) buf
;
1192 while (RTA_OK(attr
, attrlen
)) {
1193 switch (attr
->rta_type
) {
1195 if (RTA_PAYLOAD(attr
) >= IFNAMSIZ
)
1197 os_memcpy(ifname
, RTA_DATA(attr
), RTA_PAYLOAD(attr
));
1198 ifname
[RTA_PAYLOAD(attr
)] = '\0';
1201 brid
= nla_get_u32((struct nlattr
*) attr
);
1202 pos
+= os_snprintf(pos
, end
- pos
, " master=%u", brid
);
1205 pos
+= os_snprintf(pos
, end
- pos
, " wext");
1207 case IFLA_OPERSTATE
:
1208 pos
+= os_snprintf(pos
, end
- pos
, " operstate=%u",
1209 nla_get_u32((struct nlattr
*) attr
));
1212 pos
+= os_snprintf(pos
, end
- pos
, " linkmode=%u",
1213 nla_get_u32((struct nlattr
*) attr
));
1216 attr
= RTA_NEXT(attr
, attrlen
);
1218 extra
[sizeof(extra
) - 1] = '\0';
1220 wpa_printf(MSG_DEBUG
, "RTM_NEWLINK: ifi_index=%d ifname=%s%s ifi_flags=0x%x (%s%s%s%s)",
1221 ifi
->ifi_index
, ifname
, extra
, ifi
->ifi_flags
,
1222 (ifi
->ifi_flags
& IFF_UP
) ? "[UP]" : "",
1223 (ifi
->ifi_flags
& IFF_RUNNING
) ? "[RUNNING]" : "",
1224 (ifi
->ifi_flags
& IFF_LOWER_UP
) ? "[LOWER_UP]" : "",
1225 (ifi
->ifi_flags
& IFF_DORMANT
) ? "[DORMANT]" : "");
1227 if (!drv
->if_disabled
&& !(ifi
->ifi_flags
& IFF_UP
)) {
1228 if (if_indextoname(ifi
->ifi_index
, namebuf
) &&
1229 linux_iface_up(drv
->global
->ioctl_sock
,
1230 drv
->first_bss
->ifname
) > 0) {
1231 wpa_printf(MSG_DEBUG
, "nl80211: Ignore interface down "
1232 "event since interface %s is up", namebuf
);
1235 wpa_printf(MSG_DEBUG
, "nl80211: Interface down");
1236 if (drv
->ignore_if_down_event
) {
1237 wpa_printf(MSG_DEBUG
, "nl80211: Ignore interface down "
1238 "event generated by mode change");
1239 drv
->ignore_if_down_event
= 0;
1241 drv
->if_disabled
= 1;
1242 wpa_supplicant_event(drv
->ctx
,
1243 EVENT_INTERFACE_DISABLED
, NULL
);
1246 * Try to get drv again, since it may be removed as
1247 * part of the EVENT_INTERFACE_DISABLED handling for
1248 * dynamic interfaces
1250 drv
= nl80211_find_drv(global
, ifi
->ifi_index
,
1257 if (drv
->if_disabled
&& (ifi
->ifi_flags
& IFF_UP
)) {
1258 if (if_indextoname(ifi
->ifi_index
, namebuf
) &&
1259 linux_iface_up(drv
->global
->ioctl_sock
,
1260 drv
->first_bss
->ifname
) == 0) {
1261 wpa_printf(MSG_DEBUG
, "nl80211: Ignore interface up "
1262 "event since interface %s is down",
1264 } else if (if_nametoindex(drv
->first_bss
->ifname
) == 0) {
1265 wpa_printf(MSG_DEBUG
, "nl80211: Ignore interface up "
1266 "event since interface %s does not exist",
1267 drv
->first_bss
->ifname
);
1268 } else if (drv
->if_removed
) {
1269 wpa_printf(MSG_DEBUG
, "nl80211: Ignore interface up "
1270 "event since interface %s is marked "
1271 "removed", drv
->first_bss
->ifname
);
1273 wpa_printf(MSG_DEBUG
, "nl80211: Interface up");
1274 drv
->if_disabled
= 0;
1275 wpa_supplicant_event(drv
->ctx
, EVENT_INTERFACE_ENABLED
,
1281 * Some drivers send the association event before the operup event--in
1282 * this case, lifting operstate in wpa_driver_nl80211_set_operstate()
1283 * fails. This will hit us when wpa_supplicant does not need to do
1284 * IEEE 802.1X authentication
1286 if (drv
->operstate
== 1 &&
1287 (ifi
->ifi_flags
& (IFF_LOWER_UP
| IFF_DORMANT
)) == IFF_LOWER_UP
&&
1288 !(ifi
->ifi_flags
& IFF_RUNNING
)) {
1289 wpa_printf(MSG_DEBUG
, "nl80211: Set IF_OPER_UP again based on ifi_flags and expected operstate");
1290 netlink_send_oper_ifla(drv
->global
->netlink
, drv
->ifindex
,
1295 wpa_driver_nl80211_event_newlink(drv
, ifname
);
1297 if (ifi
->ifi_family
== AF_BRIDGE
&& brid
) {
1298 /* device has been added to bridge */
1299 if_indextoname(brid
, namebuf
);
1300 wpa_printf(MSG_DEBUG
, "nl80211: Add ifindex %u for bridge %s",
1302 add_ifidx(drv
, brid
);
1307 static void wpa_driver_nl80211_event_rtm_dellink(void *ctx
,
1308 struct ifinfomsg
*ifi
,
1309 u8
*buf
, size_t len
)
1311 struct nl80211_global
*global
= ctx
;
1312 struct wpa_driver_nl80211_data
*drv
;
1314 struct rtattr
*attr
;
1316 char ifname
[IFNAMSIZ
+ 1];
1318 drv
= nl80211_find_drv(global
, ifi
->ifi_index
, buf
, len
);
1320 wpa_printf(MSG_DEBUG
, "nl80211: Ignore RTM_DELLINK event for foreign ifindex %d",
1328 attr
= (struct rtattr
*) buf
;
1329 while (RTA_OK(attr
, attrlen
)) {
1330 switch (attr
->rta_type
) {
1332 if (RTA_PAYLOAD(attr
) >= IFNAMSIZ
)
1334 os_memcpy(ifname
, RTA_DATA(attr
), RTA_PAYLOAD(attr
));
1335 ifname
[RTA_PAYLOAD(attr
)] = '\0';
1338 brid
= nla_get_u32((struct nlattr
*) attr
);
1341 attr
= RTA_NEXT(attr
, attrlen
);
1345 wpa_driver_nl80211_event_dellink(drv
, ifname
);
1347 if (ifi
->ifi_family
== AF_BRIDGE
&& brid
) {
1348 /* device has been removed from bridge */
1349 char namebuf
[IFNAMSIZ
];
1350 if_indextoname(brid
, namebuf
);
1351 wpa_printf(MSG_DEBUG
, "nl80211: Remove ifindex %u for bridge "
1352 "%s", brid
, namebuf
);
1353 del_ifidx(drv
, brid
);
1358 static void mlme_event_auth(struct wpa_driver_nl80211_data
*drv
,
1359 const u8
*frame
, size_t len
)
1361 const struct ieee80211_mgmt
*mgmt
;
1362 union wpa_event_data event
;
1364 wpa_printf(MSG_DEBUG
, "nl80211: Authenticate event");
1365 mgmt
= (const struct ieee80211_mgmt
*) frame
;
1366 if (len
< 24 + sizeof(mgmt
->u
.auth
)) {
1367 wpa_printf(MSG_DEBUG
, "nl80211: Too short association event "
1372 os_memcpy(drv
->auth_bssid
, mgmt
->sa
, ETH_ALEN
);
1373 os_memset(drv
->auth_attempt_bssid
, 0, ETH_ALEN
);
1374 os_memset(&event
, 0, sizeof(event
));
1375 os_memcpy(event
.auth
.peer
, mgmt
->sa
, ETH_ALEN
);
1376 event
.auth
.auth_type
= le_to_host16(mgmt
->u
.auth
.auth_alg
);
1377 event
.auth
.auth_transaction
=
1378 le_to_host16(mgmt
->u
.auth
.auth_transaction
);
1379 event
.auth
.status_code
= le_to_host16(mgmt
->u
.auth
.status_code
);
1380 if (len
> 24 + sizeof(mgmt
->u
.auth
)) {
1381 event
.auth
.ies
= mgmt
->u
.auth
.variable
;
1382 event
.auth
.ies_len
= len
- 24 - sizeof(mgmt
->u
.auth
);
1385 wpa_supplicant_event(drv
->ctx
, EVENT_AUTH
, &event
);
1389 static unsigned int nl80211_get_assoc_freq(struct wpa_driver_nl80211_data
*drv
)
1393 struct nl80211_bss_info_arg arg
;
1395 os_memset(&arg
, 0, sizeof(arg
));
1396 msg
= nlmsg_alloc();
1398 goto nla_put_failure
;
1400 nl80211_cmd(drv
, msg
, NLM_F_DUMP
, NL80211_CMD_GET_SCAN
);
1401 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, drv
->ifindex
);
1404 ret
= send_and_recv_msgs(drv
, msg
, bss_info_handler
, &arg
);
1407 wpa_printf(MSG_DEBUG
, "nl80211: Operating frequency for the "
1408 "associated BSS from scan results: %u MHz",
1411 drv
->assoc_freq
= arg
.assoc_freq
;
1412 return drv
->assoc_freq
;
1414 wpa_printf(MSG_DEBUG
, "nl80211: Scan result fetch failed: ret=%d "
1415 "(%s)", ret
, strerror(-ret
));
1418 return drv
->assoc_freq
;
1422 static void mlme_event_assoc(struct wpa_driver_nl80211_data
*drv
,
1423 const u8
*frame
, size_t len
)
1425 const struct ieee80211_mgmt
*mgmt
;
1426 union wpa_event_data event
;
1429 wpa_printf(MSG_DEBUG
, "nl80211: Associate event");
1430 mgmt
= (const struct ieee80211_mgmt
*) frame
;
1431 if (len
< 24 + sizeof(mgmt
->u
.assoc_resp
)) {
1432 wpa_printf(MSG_DEBUG
, "nl80211: Too short association event "
1437 status
= le_to_host16(mgmt
->u
.assoc_resp
.status_code
);
1438 if (status
!= WLAN_STATUS_SUCCESS
) {
1439 os_memset(&event
, 0, sizeof(event
));
1440 event
.assoc_reject
.bssid
= mgmt
->bssid
;
1441 if (len
> 24 + sizeof(mgmt
->u
.assoc_resp
)) {
1442 event
.assoc_reject
.resp_ies
=
1443 (u8
*) mgmt
->u
.assoc_resp
.variable
;
1444 event
.assoc_reject
.resp_ies_len
=
1445 len
- 24 - sizeof(mgmt
->u
.assoc_resp
);
1447 event
.assoc_reject
.status_code
= status
;
1449 wpa_supplicant_event(drv
->ctx
, EVENT_ASSOC_REJECT
, &event
);
1453 drv
->associated
= 1;
1454 os_memcpy(drv
->bssid
, mgmt
->sa
, ETH_ALEN
);
1455 os_memcpy(drv
->prev_bssid
, mgmt
->sa
, ETH_ALEN
);
1457 os_memset(&event
, 0, sizeof(event
));
1458 if (len
> 24 + sizeof(mgmt
->u
.assoc_resp
)) {
1459 event
.assoc_info
.resp_ies
= (u8
*) mgmt
->u
.assoc_resp
.variable
;
1460 event
.assoc_info
.resp_ies_len
=
1461 len
- 24 - sizeof(mgmt
->u
.assoc_resp
);
1464 event
.assoc_info
.freq
= drv
->assoc_freq
;
1466 wpa_supplicant_event(drv
->ctx
, EVENT_ASSOC
, &event
);
1470 static void mlme_event_connect(struct wpa_driver_nl80211_data
*drv
,
1471 enum nl80211_commands cmd
, struct nlattr
*status
,
1472 struct nlattr
*addr
, struct nlattr
*req_ie
,
1473 struct nlattr
*resp_ie
)
1475 union wpa_event_data event
;
1477 if (drv
->capa
.flags
& WPA_DRIVER_FLAGS_SME
) {
1479 * Avoid reporting two association events that would confuse
1482 wpa_printf(MSG_DEBUG
, "nl80211: Ignore connect event (cmd=%d) "
1483 "when using userspace SME", cmd
);
1487 if (cmd
== NL80211_CMD_CONNECT
)
1488 wpa_printf(MSG_DEBUG
, "nl80211: Connect event");
1489 else if (cmd
== NL80211_CMD_ROAM
)
1490 wpa_printf(MSG_DEBUG
, "nl80211: Roam event");
1492 os_memset(&event
, 0, sizeof(event
));
1493 if (cmd
== NL80211_CMD_CONNECT
&&
1494 nla_get_u16(status
) != WLAN_STATUS_SUCCESS
) {
1496 event
.assoc_reject
.bssid
= nla_data(addr
);
1498 event
.assoc_reject
.resp_ies
= nla_data(resp_ie
);
1499 event
.assoc_reject
.resp_ies_len
= nla_len(resp_ie
);
1501 event
.assoc_reject
.status_code
= nla_get_u16(status
);
1502 wpa_supplicant_event(drv
->ctx
, EVENT_ASSOC_REJECT
, &event
);
1506 drv
->associated
= 1;
1508 os_memcpy(drv
->bssid
, nla_data(addr
), ETH_ALEN
);
1509 os_memcpy(drv
->prev_bssid
, drv
->bssid
, ETH_ALEN
);
1513 event
.assoc_info
.req_ies
= nla_data(req_ie
);
1514 event
.assoc_info
.req_ies_len
= nla_len(req_ie
);
1517 event
.assoc_info
.resp_ies
= nla_data(resp_ie
);
1518 event
.assoc_info
.resp_ies_len
= nla_len(resp_ie
);
1521 event
.assoc_info
.freq
= nl80211_get_assoc_freq(drv
);
1523 wpa_supplicant_event(drv
->ctx
, EVENT_ASSOC
, &event
);
1527 static void mlme_event_disconnect(struct wpa_driver_nl80211_data
*drv
,
1528 struct nlattr
*reason
, struct nlattr
*addr
,
1529 struct nlattr
*by_ap
)
1531 union wpa_event_data data
;
1532 unsigned int locally_generated
= by_ap
== NULL
;
1534 if (drv
->capa
.flags
& WPA_DRIVER_FLAGS_SME
) {
1536 * Avoid reporting two disassociation events that could
1537 * confuse the core code.
1539 wpa_printf(MSG_DEBUG
, "nl80211: Ignore disconnect "
1540 "event when using userspace SME");
1544 if (drv
->ignore_next_local_disconnect
) {
1545 drv
->ignore_next_local_disconnect
= 0;
1546 if (locally_generated
) {
1547 wpa_printf(MSG_DEBUG
, "nl80211: Ignore disconnect "
1548 "event triggered during reassociation");
1551 wpa_printf(MSG_WARNING
, "nl80211: Was expecting local "
1552 "disconnect but got another disconnect "
1556 wpa_printf(MSG_DEBUG
, "nl80211: Disconnect event");
1557 nl80211_mark_disconnected(drv
);
1558 os_memset(&data
, 0, sizeof(data
));
1560 data
.deauth_info
.reason_code
= nla_get_u16(reason
);
1561 data
.deauth_info
.locally_generated
= by_ap
== NULL
;
1562 wpa_supplicant_event(drv
->ctx
, EVENT_DEAUTH
, &data
);
1566 static int calculate_chan_offset(int width
, int freq
, int cf1
, int cf2
)
1570 switch (convert2width(width
)) {
1571 case CHAN_WIDTH_20_NOHT
:
1580 case CHAN_WIDTH_160
:
1583 case CHAN_WIDTH_UNKNOWN
:
1584 case CHAN_WIDTH_80P80
:
1585 /* FIXME: implement this */
1589 return (abs(freq
- freq1
) / 20) % 2 == 0 ? 1 : -1;
1593 static void mlme_event_ch_switch(struct wpa_driver_nl80211_data
*drv
,
1594 struct nlattr
*ifindex
, struct nlattr
*freq
,
1595 struct nlattr
*type
, struct nlattr
*bw
,
1596 struct nlattr
*cf1
, struct nlattr
*cf2
)
1598 struct i802_bss
*bss
;
1599 union wpa_event_data data
;
1601 int chan_offset
= 0;
1604 wpa_printf(MSG_DEBUG
, "nl80211: Channel switch event");
1609 ifidx
= nla_get_u32(ifindex
);
1610 for (bss
= drv
->first_bss
; bss
; bss
= bss
->next
)
1611 if (bss
->ifindex
== ifidx
)
1615 wpa_printf(MSG_WARNING
, "nl80211: Unknown ifindex (%d) for channel switch, ignoring",
1621 switch (nla_get_u32(type
)) {
1622 case NL80211_CHAN_NO_HT
:
1625 case NL80211_CHAN_HT20
:
1627 case NL80211_CHAN_HT40PLUS
:
1630 case NL80211_CHAN_HT40MINUS
:
1634 } else if (bw
&& cf1
) {
1635 /* This can happen for example with VHT80 ch switch */
1636 chan_offset
= calculate_chan_offset(nla_get_u32(bw
),
1639 cf2
? nla_get_u32(cf2
) : 0);
1641 wpa_printf(MSG_WARNING
, "nl80211: Unknown secondary channel information - following channel definition calculations may fail");
1644 os_memset(&data
, 0, sizeof(data
));
1645 data
.ch_switch
.freq
= nla_get_u32(freq
);
1646 data
.ch_switch
.ht_enabled
= ht_enabled
;
1647 data
.ch_switch
.ch_offset
= chan_offset
;
1649 data
.ch_switch
.ch_width
= convert2width(nla_get_u32(bw
));
1651 data
.ch_switch
.cf1
= nla_get_u32(cf1
);
1653 data
.ch_switch
.cf2
= nla_get_u32(cf2
);
1655 bss
->freq
= data
.ch_switch
.freq
;
1657 wpa_supplicant_event(drv
->ctx
, EVENT_CH_SWITCH
, &data
);
1661 static void mlme_timeout_event(struct wpa_driver_nl80211_data
*drv
,
1662 enum nl80211_commands cmd
, struct nlattr
*addr
)
1664 union wpa_event_data event
;
1665 enum wpa_event_type ev
;
1667 if (nla_len(addr
) != ETH_ALEN
)
1670 wpa_printf(MSG_DEBUG
, "nl80211: MLME event %d; timeout with " MACSTR
,
1671 cmd
, MAC2STR((u8
*) nla_data(addr
)));
1673 if (cmd
== NL80211_CMD_AUTHENTICATE
)
1674 ev
= EVENT_AUTH_TIMED_OUT
;
1675 else if (cmd
== NL80211_CMD_ASSOCIATE
)
1676 ev
= EVENT_ASSOC_TIMED_OUT
;
1680 os_memset(&event
, 0, sizeof(event
));
1681 os_memcpy(event
.timeout_event
.addr
, nla_data(addr
), ETH_ALEN
);
1682 wpa_supplicant_event(drv
->ctx
, ev
, &event
);
1686 static void mlme_event_mgmt(struct i802_bss
*bss
,
1687 struct nlattr
*freq
, struct nlattr
*sig
,
1688 const u8
*frame
, size_t len
)
1690 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
1691 const struct ieee80211_mgmt
*mgmt
;
1692 union wpa_event_data event
;
1697 wpa_printf(MSG_MSGDUMP
, "nl80211: Frame event");
1698 mgmt
= (const struct ieee80211_mgmt
*) frame
;
1700 wpa_printf(MSG_DEBUG
, "nl80211: Too short management frame");
1704 fc
= le_to_host16(mgmt
->frame_control
);
1705 stype
= WLAN_FC_GET_STYPE(fc
);
1708 ssi_signal
= (s32
) nla_get_u32(sig
);
1710 os_memset(&event
, 0, sizeof(event
));
1712 event
.rx_mgmt
.freq
= nla_get_u32(freq
);
1713 rx_freq
= drv
->last_mgmt_freq
= event
.rx_mgmt
.freq
;
1715 wpa_printf(MSG_DEBUG
,
1716 "nl80211: RX frame freq=%d ssi_signal=%d stype=%u len=%u",
1717 rx_freq
, ssi_signal
, stype
, (unsigned int) len
);
1718 event
.rx_mgmt
.frame
= frame
;
1719 event
.rx_mgmt
.frame_len
= len
;
1720 event
.rx_mgmt
.ssi_signal
= ssi_signal
;
1721 event
.rx_mgmt
.drv_priv
= bss
;
1722 wpa_supplicant_event(drv
->ctx
, EVENT_RX_MGMT
, &event
);
1726 static void mlme_event_mgmt_tx_status(struct wpa_driver_nl80211_data
*drv
,
1727 struct nlattr
*cookie
, const u8
*frame
,
1728 size_t len
, struct nlattr
*ack
)
1730 union wpa_event_data event
;
1731 const struct ieee80211_hdr
*hdr
;
1734 wpa_printf(MSG_DEBUG
, "nl80211: Frame TX status event");
1735 if (!is_ap_interface(drv
->nlmode
)) {
1741 cookie_val
= nla_get_u64(cookie
);
1742 wpa_printf(MSG_DEBUG
, "nl80211: Action TX status:"
1743 " cookie=0%llx%s (ack=%d)",
1744 (long long unsigned int) cookie_val
,
1745 cookie_val
== drv
->send_action_cookie
?
1746 " (match)" : " (unknown)", ack
!= NULL
);
1747 if (cookie_val
!= drv
->send_action_cookie
)
1751 hdr
= (const struct ieee80211_hdr
*) frame
;
1752 fc
= le_to_host16(hdr
->frame_control
);
1754 os_memset(&event
, 0, sizeof(event
));
1755 event
.tx_status
.type
= WLAN_FC_GET_TYPE(fc
);
1756 event
.tx_status
.stype
= WLAN_FC_GET_STYPE(fc
);
1757 event
.tx_status
.dst
= hdr
->addr1
;
1758 event
.tx_status
.data
= frame
;
1759 event
.tx_status
.data_len
= len
;
1760 event
.tx_status
.ack
= ack
!= NULL
;
1761 wpa_supplicant_event(drv
->ctx
, EVENT_TX_STATUS
, &event
);
1765 static void mlme_event_deauth_disassoc(struct wpa_driver_nl80211_data
*drv
,
1766 enum wpa_event_type type
,
1767 const u8
*frame
, size_t len
)
1769 const struct ieee80211_mgmt
*mgmt
;
1770 union wpa_event_data event
;
1771 const u8
*bssid
= NULL
;
1772 u16 reason_code
= 0;
1774 if (type
== EVENT_DEAUTH
)
1775 wpa_printf(MSG_DEBUG
, "nl80211: Deauthenticate event");
1777 wpa_printf(MSG_DEBUG
, "nl80211: Disassociate event");
1779 mgmt
= (const struct ieee80211_mgmt
*) frame
;
1781 bssid
= mgmt
->bssid
;
1783 if ((drv
->capa
.flags
& WPA_DRIVER_FLAGS_SME
) &&
1785 os_memcmp(bssid
, drv
->auth_bssid
, ETH_ALEN
) != 0 &&
1786 os_memcmp(bssid
, drv
->auth_attempt_bssid
, ETH_ALEN
) != 0 &&
1787 os_memcmp(bssid
, drv
->prev_bssid
, ETH_ALEN
) == 0) {
1789 * Avoid issues with some roaming cases where
1790 * disconnection event for the old AP may show up after
1791 * we have started connection with the new AP.
1793 wpa_printf(MSG_DEBUG
, "nl80211: Ignore deauth/disassoc event from old AP " MACSTR
" when already authenticating with " MACSTR
,
1795 MAC2STR(drv
->auth_attempt_bssid
));
1799 if (drv
->associated
!= 0 &&
1800 os_memcmp(bssid
, drv
->bssid
, ETH_ALEN
) != 0 &&
1801 os_memcmp(bssid
, drv
->auth_bssid
, ETH_ALEN
) != 0) {
1803 * We have presumably received this deauth as a
1804 * response to a clear_state_mismatch() outgoing
1805 * deauth. Don't let it take us offline!
1807 wpa_printf(MSG_DEBUG
, "nl80211: Deauth received "
1808 "from Unknown BSSID " MACSTR
" -- ignoring",
1814 nl80211_mark_disconnected(drv
);
1815 os_memset(&event
, 0, sizeof(event
));
1817 /* Note: Same offset for Reason Code in both frame subtypes */
1818 if (len
>= 24 + sizeof(mgmt
->u
.deauth
))
1819 reason_code
= le_to_host16(mgmt
->u
.deauth
.reason_code
);
1821 if (type
== EVENT_DISASSOC
) {
1822 event
.disassoc_info
.locally_generated
=
1823 !os_memcmp(mgmt
->sa
, drv
->first_bss
->addr
, ETH_ALEN
);
1824 event
.disassoc_info
.addr
= bssid
;
1825 event
.disassoc_info
.reason_code
= reason_code
;
1826 if (frame
+ len
> mgmt
->u
.disassoc
.variable
) {
1827 event
.disassoc_info
.ie
= mgmt
->u
.disassoc
.variable
;
1828 event
.disassoc_info
.ie_len
= frame
+ len
-
1829 mgmt
->u
.disassoc
.variable
;
1832 if (drv
->ignore_deauth_event
) {
1833 wpa_printf(MSG_DEBUG
, "nl80211: Ignore deauth event due to previous forced deauth-during-auth");
1834 drv
->ignore_deauth_event
= 0;
1837 event
.deauth_info
.locally_generated
=
1838 !os_memcmp(mgmt
->sa
, drv
->first_bss
->addr
, ETH_ALEN
);
1839 event
.deauth_info
.addr
= bssid
;
1840 event
.deauth_info
.reason_code
= reason_code
;
1841 if (frame
+ len
> mgmt
->u
.deauth
.variable
) {
1842 event
.deauth_info
.ie
= mgmt
->u
.deauth
.variable
;
1843 event
.deauth_info
.ie_len
= frame
+ len
-
1844 mgmt
->u
.deauth
.variable
;
1848 wpa_supplicant_event(drv
->ctx
, type
, &event
);
1852 static void mlme_event_unprot_disconnect(struct wpa_driver_nl80211_data
*drv
,
1853 enum wpa_event_type type
,
1854 const u8
*frame
, size_t len
)
1856 const struct ieee80211_mgmt
*mgmt
;
1857 union wpa_event_data event
;
1858 u16 reason_code
= 0;
1860 if (type
== EVENT_UNPROT_DEAUTH
)
1861 wpa_printf(MSG_DEBUG
, "nl80211: Unprot Deauthenticate event");
1863 wpa_printf(MSG_DEBUG
, "nl80211: Unprot Disassociate event");
1868 mgmt
= (const struct ieee80211_mgmt
*) frame
;
1870 os_memset(&event
, 0, sizeof(event
));
1871 /* Note: Same offset for Reason Code in both frame subtypes */
1872 if (len
>= 24 + sizeof(mgmt
->u
.deauth
))
1873 reason_code
= le_to_host16(mgmt
->u
.deauth
.reason_code
);
1875 if (type
== EVENT_UNPROT_DISASSOC
) {
1876 event
.unprot_disassoc
.sa
= mgmt
->sa
;
1877 event
.unprot_disassoc
.da
= mgmt
->da
;
1878 event
.unprot_disassoc
.reason_code
= reason_code
;
1880 event
.unprot_deauth
.sa
= mgmt
->sa
;
1881 event
.unprot_deauth
.da
= mgmt
->da
;
1882 event
.unprot_deauth
.reason_code
= reason_code
;
1885 wpa_supplicant_event(drv
->ctx
, type
, &event
);
1889 static void mlme_event(struct i802_bss
*bss
,
1890 enum nl80211_commands cmd
, struct nlattr
*frame
,
1891 struct nlattr
*addr
, struct nlattr
*timed_out
,
1892 struct nlattr
*freq
, struct nlattr
*ack
,
1893 struct nlattr
*cookie
, struct nlattr
*sig
)
1895 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
1899 if (timed_out
&& addr
) {
1900 mlme_timeout_event(drv
, cmd
, addr
);
1904 if (frame
== NULL
) {
1905 wpa_printf(MSG_DEBUG
,
1906 "nl80211: MLME event %d (%s) without frame data",
1907 cmd
, nl80211_command_to_string(cmd
));
1911 data
= nla_data(frame
);
1912 len
= nla_len(frame
);
1913 if (len
< 4 + 2 * ETH_ALEN
) {
1914 wpa_printf(MSG_MSGDUMP
, "nl80211: MLME event %d (%s) on %s("
1915 MACSTR
") - too short",
1916 cmd
, nl80211_command_to_string(cmd
), bss
->ifname
,
1917 MAC2STR(bss
->addr
));
1920 wpa_printf(MSG_MSGDUMP
, "nl80211: MLME event %d (%s) on %s(" MACSTR
1921 ") A1=" MACSTR
" A2=" MACSTR
, cmd
,
1922 nl80211_command_to_string(cmd
), bss
->ifname
,
1923 MAC2STR(bss
->addr
), MAC2STR(data
+ 4),
1924 MAC2STR(data
+ 4 + ETH_ALEN
));
1925 if (cmd
!= NL80211_CMD_FRAME_TX_STATUS
&& !(data
[4] & 0x01) &&
1926 os_memcmp(bss
->addr
, data
+ 4, ETH_ALEN
) != 0 &&
1927 os_memcmp(bss
->addr
, data
+ 4 + ETH_ALEN
, ETH_ALEN
) != 0) {
1928 wpa_printf(MSG_MSGDUMP
, "nl80211: %s: Ignore MLME frame event "
1929 "for foreign address", bss
->ifname
);
1932 wpa_hexdump(MSG_MSGDUMP
, "nl80211: MLME event frame",
1933 nla_data(frame
), nla_len(frame
));
1936 case NL80211_CMD_AUTHENTICATE
:
1937 mlme_event_auth(drv
, nla_data(frame
), nla_len(frame
));
1939 case NL80211_CMD_ASSOCIATE
:
1940 mlme_event_assoc(drv
, nla_data(frame
), nla_len(frame
));
1942 case NL80211_CMD_DEAUTHENTICATE
:
1943 mlme_event_deauth_disassoc(drv
, EVENT_DEAUTH
,
1944 nla_data(frame
), nla_len(frame
));
1946 case NL80211_CMD_DISASSOCIATE
:
1947 mlme_event_deauth_disassoc(drv
, EVENT_DISASSOC
,
1948 nla_data(frame
), nla_len(frame
));
1950 case NL80211_CMD_FRAME
:
1951 mlme_event_mgmt(bss
, freq
, sig
, nla_data(frame
),
1954 case NL80211_CMD_FRAME_TX_STATUS
:
1955 mlme_event_mgmt_tx_status(drv
, cookie
, nla_data(frame
),
1956 nla_len(frame
), ack
);
1958 case NL80211_CMD_UNPROT_DEAUTHENTICATE
:
1959 mlme_event_unprot_disconnect(drv
, EVENT_UNPROT_DEAUTH
,
1960 nla_data(frame
), nla_len(frame
));
1962 case NL80211_CMD_UNPROT_DISASSOCIATE
:
1963 mlme_event_unprot_disconnect(drv
, EVENT_UNPROT_DISASSOC
,
1964 nla_data(frame
), nla_len(frame
));
1972 static void mlme_event_michael_mic_failure(struct i802_bss
*bss
,
1973 struct nlattr
*tb
[])
1975 union wpa_event_data data
;
1977 wpa_printf(MSG_DEBUG
, "nl80211: MLME event Michael MIC failure");
1978 os_memset(&data
, 0, sizeof(data
));
1979 if (tb
[NL80211_ATTR_MAC
]) {
1980 wpa_hexdump(MSG_DEBUG
, "nl80211: Source MAC address",
1981 nla_data(tb
[NL80211_ATTR_MAC
]),
1982 nla_len(tb
[NL80211_ATTR_MAC
]));
1983 data
.michael_mic_failure
.src
= nla_data(tb
[NL80211_ATTR_MAC
]);
1985 if (tb
[NL80211_ATTR_KEY_SEQ
]) {
1986 wpa_hexdump(MSG_DEBUG
, "nl80211: TSC",
1987 nla_data(tb
[NL80211_ATTR_KEY_SEQ
]),
1988 nla_len(tb
[NL80211_ATTR_KEY_SEQ
]));
1990 if (tb
[NL80211_ATTR_KEY_TYPE
]) {
1991 enum nl80211_key_type key_type
=
1992 nla_get_u32(tb
[NL80211_ATTR_KEY_TYPE
]);
1993 wpa_printf(MSG_DEBUG
, "nl80211: Key Type %d", key_type
);
1994 if (key_type
== NL80211_KEYTYPE_PAIRWISE
)
1995 data
.michael_mic_failure
.unicast
= 1;
1997 data
.michael_mic_failure
.unicast
= 1;
1999 if (tb
[NL80211_ATTR_KEY_IDX
]) {
2000 u8 key_id
= nla_get_u8(tb
[NL80211_ATTR_KEY_IDX
]);
2001 wpa_printf(MSG_DEBUG
, "nl80211: Key Id %d", key_id
);
2004 wpa_supplicant_event(bss
->ctx
, EVENT_MICHAEL_MIC_FAILURE
, &data
);
2008 static void mlme_event_join_ibss(struct wpa_driver_nl80211_data
*drv
,
2009 struct nlattr
*tb
[])
2011 if (tb
[NL80211_ATTR_MAC
] == NULL
) {
2012 wpa_printf(MSG_DEBUG
, "nl80211: No address in IBSS joined "
2016 os_memcpy(drv
->bssid
, nla_data(tb
[NL80211_ATTR_MAC
]), ETH_ALEN
);
2018 drv
->associated
= 1;
2019 wpa_printf(MSG_DEBUG
, "nl80211: IBSS " MACSTR
" joined",
2020 MAC2STR(drv
->bssid
));
2022 wpa_supplicant_event(drv
->ctx
, EVENT_ASSOC
, NULL
);
2026 static void mlme_event_remain_on_channel(struct wpa_driver_nl80211_data
*drv
,
2027 int cancel_event
, struct nlattr
*tb
[])
2029 unsigned int freq
, chan_type
, duration
;
2030 union wpa_event_data data
;
2033 if (tb
[NL80211_ATTR_WIPHY_FREQ
])
2034 freq
= nla_get_u32(tb
[NL80211_ATTR_WIPHY_FREQ
]);
2038 if (tb
[NL80211_ATTR_WIPHY_CHANNEL_TYPE
])
2039 chan_type
= nla_get_u32(tb
[NL80211_ATTR_WIPHY_CHANNEL_TYPE
]);
2043 if (tb
[NL80211_ATTR_DURATION
])
2044 duration
= nla_get_u32(tb
[NL80211_ATTR_DURATION
]);
2048 if (tb
[NL80211_ATTR_COOKIE
])
2049 cookie
= nla_get_u64(tb
[NL80211_ATTR_COOKIE
]);
2053 wpa_printf(MSG_DEBUG
, "nl80211: Remain-on-channel event (cancel=%d "
2054 "freq=%u channel_type=%u duration=%u cookie=0x%llx (%s))",
2055 cancel_event
, freq
, chan_type
, duration
,
2056 (long long unsigned int) cookie
,
2057 cookie
== drv
->remain_on_chan_cookie
? "match" : "unknown");
2059 if (cookie
!= drv
->remain_on_chan_cookie
)
2060 return; /* not for us */
2063 drv
->pending_remain_on_chan
= 0;
2065 os_memset(&data
, 0, sizeof(data
));
2066 data
.remain_on_channel
.freq
= freq
;
2067 data
.remain_on_channel
.duration
= duration
;
2068 wpa_supplicant_event(drv
->ctx
, cancel_event
?
2069 EVENT_CANCEL_REMAIN_ON_CHANNEL
:
2070 EVENT_REMAIN_ON_CHANNEL
, &data
);
2074 static void mlme_event_ft_event(struct wpa_driver_nl80211_data
*drv
,
2075 struct nlattr
*tb
[])
2077 union wpa_event_data data
;
2079 os_memset(&data
, 0, sizeof(data
));
2081 if (tb
[NL80211_ATTR_IE
]) {
2082 data
.ft_ies
.ies
= nla_data(tb
[NL80211_ATTR_IE
]);
2083 data
.ft_ies
.ies_len
= nla_len(tb
[NL80211_ATTR_IE
]);
2086 if (tb
[NL80211_ATTR_IE_RIC
]) {
2087 data
.ft_ies
.ric_ies
= nla_data(tb
[NL80211_ATTR_IE_RIC
]);
2088 data
.ft_ies
.ric_ies_len
= nla_len(tb
[NL80211_ATTR_IE_RIC
]);
2091 if (tb
[NL80211_ATTR_MAC
])
2092 os_memcpy(data
.ft_ies
.target_ap
,
2093 nla_data(tb
[NL80211_ATTR_MAC
]), ETH_ALEN
);
2095 wpa_printf(MSG_DEBUG
, "nl80211: FT event target_ap " MACSTR
,
2096 MAC2STR(data
.ft_ies
.target_ap
));
2098 wpa_supplicant_event(drv
->ctx
, EVENT_FT_RESPONSE
, &data
);
2102 static void send_scan_event(struct wpa_driver_nl80211_data
*drv
, int aborted
,
2103 struct nlattr
*tb
[])
2105 union wpa_event_data event
;
2108 struct scan_info
*info
;
2109 #define MAX_REPORT_FREQS 50
2110 int freqs
[MAX_REPORT_FREQS
];
2113 if (drv
->scan_for_auth
) {
2114 drv
->scan_for_auth
= 0;
2115 wpa_printf(MSG_DEBUG
, "nl80211: Scan results for missing "
2116 "cfg80211 BSS entry");
2117 wpa_driver_nl80211_authenticate_retry(drv
);
2121 os_memset(&event
, 0, sizeof(event
));
2122 info
= &event
.scan_info
;
2123 info
->aborted
= aborted
;
2125 if (tb
[NL80211_ATTR_SCAN_SSIDS
]) {
2126 nla_for_each_nested(nl
, tb
[NL80211_ATTR_SCAN_SSIDS
], rem
) {
2127 struct wpa_driver_scan_ssid
*s
=
2128 &info
->ssids
[info
->num_ssids
];
2129 s
->ssid
= nla_data(nl
);
2130 s
->ssid_len
= nla_len(nl
);
2131 wpa_printf(MSG_DEBUG
, "nl80211: Scan probed for SSID '%s'",
2132 wpa_ssid_txt(s
->ssid
, s
->ssid_len
));
2134 if (info
->num_ssids
== WPAS_MAX_SCAN_SSIDS
)
2138 if (tb
[NL80211_ATTR_SCAN_FREQUENCIES
]) {
2139 char msg
[200], *pos
, *end
;
2143 end
= pos
+ sizeof(msg
);
2146 nla_for_each_nested(nl
, tb
[NL80211_ATTR_SCAN_FREQUENCIES
], rem
)
2148 freqs
[num_freqs
] = nla_get_u32(nl
);
2149 res
= os_snprintf(pos
, end
- pos
, " %d",
2151 if (res
> 0 && end
- pos
> res
)
2154 if (num_freqs
== MAX_REPORT_FREQS
- 1)
2157 info
->freqs
= freqs
;
2158 info
->num_freqs
= num_freqs
;
2159 wpa_printf(MSG_DEBUG
, "nl80211: Scan included frequencies:%s",
2162 wpa_supplicant_event(drv
->ctx
, EVENT_SCAN_RESULTS
, &event
);
2166 static int get_link_signal(struct nl_msg
*msg
, void *arg
)
2168 struct nlattr
*tb
[NL80211_ATTR_MAX
+ 1];
2169 struct genlmsghdr
*gnlh
= nlmsg_data(nlmsg_hdr(msg
));
2170 struct nlattr
*sinfo
[NL80211_STA_INFO_MAX
+ 1];
2171 static struct nla_policy policy
[NL80211_STA_INFO_MAX
+ 1] = {
2172 [NL80211_STA_INFO_SIGNAL
] = { .type
= NLA_U8
},
2173 [NL80211_STA_INFO_SIGNAL_AVG
] = { .type
= NLA_U8
},
2175 struct nlattr
*rinfo
[NL80211_RATE_INFO_MAX
+ 1];
2176 static struct nla_policy rate_policy
[NL80211_RATE_INFO_MAX
+ 1] = {
2177 [NL80211_RATE_INFO_BITRATE
] = { .type
= NLA_U16
},
2178 [NL80211_RATE_INFO_MCS
] = { .type
= NLA_U8
},
2179 [NL80211_RATE_INFO_40_MHZ_WIDTH
] = { .type
= NLA_FLAG
},
2180 [NL80211_RATE_INFO_SHORT_GI
] = { .type
= NLA_FLAG
},
2182 struct wpa_signal_info
*sig_change
= arg
;
2184 nla_parse(tb
, NL80211_ATTR_MAX
, genlmsg_attrdata(gnlh
, 0),
2185 genlmsg_attrlen(gnlh
, 0), NULL
);
2186 if (!tb
[NL80211_ATTR_STA_INFO
] ||
2187 nla_parse_nested(sinfo
, NL80211_STA_INFO_MAX
,
2188 tb
[NL80211_ATTR_STA_INFO
], policy
))
2190 if (!sinfo
[NL80211_STA_INFO_SIGNAL
])
2193 sig_change
->current_signal
=
2194 (s8
) nla_get_u8(sinfo
[NL80211_STA_INFO_SIGNAL
]);
2196 if (sinfo
[NL80211_STA_INFO_SIGNAL_AVG
])
2197 sig_change
->avg_signal
=
2198 (s8
) nla_get_u8(sinfo
[NL80211_STA_INFO_SIGNAL_AVG
]);
2200 sig_change
->avg_signal
= 0;
2202 if (sinfo
[NL80211_STA_INFO_TX_BITRATE
]) {
2203 if (nla_parse_nested(rinfo
, NL80211_RATE_INFO_MAX
,
2204 sinfo
[NL80211_STA_INFO_TX_BITRATE
],
2206 sig_change
->current_txrate
= 0;
2208 if (rinfo
[NL80211_RATE_INFO_BITRATE
]) {
2209 sig_change
->current_txrate
=
2211 NL80211_RATE_INFO_BITRATE
]) * 100;
2220 static int nl80211_get_link_signal(struct wpa_driver_nl80211_data
*drv
,
2221 struct wpa_signal_info
*sig
)
2225 sig
->current_signal
= -9999;
2226 sig
->current_txrate
= 0;
2228 msg
= nlmsg_alloc();
2232 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_GET_STATION
);
2234 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, drv
->ifindex
);
2235 NLA_PUT(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, drv
->bssid
);
2237 return send_and_recv_msgs(drv
, msg
, get_link_signal
, sig
);
2244 static int get_link_noise(struct nl_msg
*msg
, void *arg
)
2246 struct nlattr
*tb
[NL80211_ATTR_MAX
+ 1];
2247 struct genlmsghdr
*gnlh
= nlmsg_data(nlmsg_hdr(msg
));
2248 struct nlattr
*sinfo
[NL80211_SURVEY_INFO_MAX
+ 1];
2249 static struct nla_policy survey_policy
[NL80211_SURVEY_INFO_MAX
+ 1] = {
2250 [NL80211_SURVEY_INFO_FREQUENCY
] = { .type
= NLA_U32
},
2251 [NL80211_SURVEY_INFO_NOISE
] = { .type
= NLA_U8
},
2253 struct wpa_signal_info
*sig_change
= arg
;
2255 nla_parse(tb
, NL80211_ATTR_MAX
, genlmsg_attrdata(gnlh
, 0),
2256 genlmsg_attrlen(gnlh
, 0), NULL
);
2258 if (!tb
[NL80211_ATTR_SURVEY_INFO
]) {
2259 wpa_printf(MSG_DEBUG
, "nl80211: survey data missing!");
2263 if (nla_parse_nested(sinfo
, NL80211_SURVEY_INFO_MAX
,
2264 tb
[NL80211_ATTR_SURVEY_INFO
],
2266 wpa_printf(MSG_DEBUG
, "nl80211: failed to parse nested "
2271 if (!sinfo
[NL80211_SURVEY_INFO_FREQUENCY
])
2274 if (nla_get_u32(sinfo
[NL80211_SURVEY_INFO_FREQUENCY
]) !=
2275 sig_change
->frequency
)
2278 if (!sinfo
[NL80211_SURVEY_INFO_NOISE
])
2281 sig_change
->current_noise
=
2282 (s8
) nla_get_u8(sinfo
[NL80211_SURVEY_INFO_NOISE
]);
2288 static int nl80211_get_link_noise(struct wpa_driver_nl80211_data
*drv
,
2289 struct wpa_signal_info
*sig_change
)
2293 sig_change
->current_noise
= 9999;
2294 sig_change
->frequency
= drv
->assoc_freq
;
2296 msg
= nlmsg_alloc();
2300 nl80211_cmd(drv
, msg
, NLM_F_DUMP
, NL80211_CMD_GET_SURVEY
);
2302 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, drv
->ifindex
);
2304 return send_and_recv_msgs(drv
, msg
, get_link_noise
, sig_change
);
2311 static int get_noise_for_scan_results(struct nl_msg
*msg
, void *arg
)
2313 struct nlattr
*tb
[NL80211_ATTR_MAX
+ 1];
2314 struct genlmsghdr
*gnlh
= nlmsg_data(nlmsg_hdr(msg
));
2315 struct nlattr
*sinfo
[NL80211_SURVEY_INFO_MAX
+ 1];
2316 static struct nla_policy survey_policy
[NL80211_SURVEY_INFO_MAX
+ 1] = {
2317 [NL80211_SURVEY_INFO_FREQUENCY
] = { .type
= NLA_U32
},
2318 [NL80211_SURVEY_INFO_NOISE
] = { .type
= NLA_U8
},
2320 struct wpa_scan_results
*scan_results
= arg
;
2321 struct wpa_scan_res
*scan_res
;
2324 nla_parse(tb
, NL80211_ATTR_MAX
, genlmsg_attrdata(gnlh
, 0),
2325 genlmsg_attrlen(gnlh
, 0), NULL
);
2327 if (!tb
[NL80211_ATTR_SURVEY_INFO
]) {
2328 wpa_printf(MSG_DEBUG
, "nl80211: Survey data missing");
2332 if (nla_parse_nested(sinfo
, NL80211_SURVEY_INFO_MAX
,
2333 tb
[NL80211_ATTR_SURVEY_INFO
],
2335 wpa_printf(MSG_DEBUG
, "nl80211: Failed to parse nested "
2340 if (!sinfo
[NL80211_SURVEY_INFO_NOISE
])
2343 if (!sinfo
[NL80211_SURVEY_INFO_FREQUENCY
])
2346 for (i
= 0; i
< scan_results
->num
; ++i
) {
2347 scan_res
= scan_results
->res
[i
];
2350 if ((int) nla_get_u32(sinfo
[NL80211_SURVEY_INFO_FREQUENCY
]) !=
2353 if (!(scan_res
->flags
& WPA_SCAN_NOISE_INVALID
))
2355 scan_res
->noise
= (s8
)
2356 nla_get_u8(sinfo
[NL80211_SURVEY_INFO_NOISE
]);
2357 scan_res
->flags
&= ~WPA_SCAN_NOISE_INVALID
;
2364 static int nl80211_get_noise_for_scan_results(
2365 struct wpa_driver_nl80211_data
*drv
,
2366 struct wpa_scan_results
*scan_res
)
2370 msg
= nlmsg_alloc();
2374 nl80211_cmd(drv
, msg
, NLM_F_DUMP
, NL80211_CMD_GET_SURVEY
);
2376 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, drv
->ifindex
);
2378 return send_and_recv_msgs(drv
, msg
, get_noise_for_scan_results
,
2386 static void nl80211_cqm_event(struct wpa_driver_nl80211_data
*drv
,
2387 struct nlattr
*tb
[])
2389 static struct nla_policy cqm_policy
[NL80211_ATTR_CQM_MAX
+ 1] = {
2390 [NL80211_ATTR_CQM_RSSI_THOLD
] = { .type
= NLA_U32
},
2391 [NL80211_ATTR_CQM_RSSI_HYST
] = { .type
= NLA_U8
},
2392 [NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT
] = { .type
= NLA_U32
},
2393 [NL80211_ATTR_CQM_PKT_LOSS_EVENT
] = { .type
= NLA_U32
},
2395 struct nlattr
*cqm
[NL80211_ATTR_CQM_MAX
+ 1];
2396 enum nl80211_cqm_rssi_threshold_event event
;
2397 union wpa_event_data ed
;
2398 struct wpa_signal_info sig
;
2401 if (tb
[NL80211_ATTR_CQM
] == NULL
||
2402 nla_parse_nested(cqm
, NL80211_ATTR_CQM_MAX
, tb
[NL80211_ATTR_CQM
],
2404 wpa_printf(MSG_DEBUG
, "nl80211: Ignore invalid CQM event");
2408 os_memset(&ed
, 0, sizeof(ed
));
2410 if (cqm
[NL80211_ATTR_CQM_PKT_LOSS_EVENT
]) {
2411 if (!tb
[NL80211_ATTR_MAC
])
2413 os_memcpy(ed
.low_ack
.addr
, nla_data(tb
[NL80211_ATTR_MAC
]),
2415 wpa_supplicant_event(drv
->ctx
, EVENT_STATION_LOW_ACK
, &ed
);
2419 if (cqm
[NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT
] == NULL
)
2421 event
= nla_get_u32(cqm
[NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT
]);
2423 if (event
== NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH
) {
2424 wpa_printf(MSG_DEBUG
, "nl80211: Connection quality monitor "
2425 "event: RSSI high");
2426 ed
.signal_change
.above_threshold
= 1;
2427 } else if (event
== NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW
) {
2428 wpa_printf(MSG_DEBUG
, "nl80211: Connection quality monitor "
2430 ed
.signal_change
.above_threshold
= 0;
2434 res
= nl80211_get_link_signal(drv
, &sig
);
2436 ed
.signal_change
.current_signal
= sig
.current_signal
;
2437 ed
.signal_change
.current_txrate
= sig
.current_txrate
;
2438 wpa_printf(MSG_DEBUG
, "nl80211: Signal: %d dBm txrate: %d",
2439 sig
.current_signal
, sig
.current_txrate
);
2442 res
= nl80211_get_link_noise(drv
, &sig
);
2444 ed
.signal_change
.current_noise
= sig
.current_noise
;
2445 wpa_printf(MSG_DEBUG
, "nl80211: Noise: %d dBm",
2449 wpa_supplicant_event(drv
->ctx
, EVENT_SIGNAL_CHANGE
, &ed
);
2453 static void nl80211_new_station_event(struct wpa_driver_nl80211_data
*drv
,
2457 union wpa_event_data data
;
2459 if (tb
[NL80211_ATTR_MAC
] == NULL
)
2461 addr
= nla_data(tb
[NL80211_ATTR_MAC
]);
2462 wpa_printf(MSG_DEBUG
, "nl80211: New station " MACSTR
, MAC2STR(addr
));
2464 if (is_ap_interface(drv
->nlmode
) && drv
->device_ap_sme
) {
2467 if (tb
[NL80211_ATTR_IE
]) {
2468 ies
= nla_data(tb
[NL80211_ATTR_IE
]);
2469 ies_len
= nla_len(tb
[NL80211_ATTR_IE
]);
2471 wpa_hexdump(MSG_DEBUG
, "nl80211: Assoc Req IEs", ies
, ies_len
);
2472 drv_event_assoc(drv
->ctx
, addr
, ies
, ies_len
, 0);
2476 if (drv
->nlmode
!= NL80211_IFTYPE_ADHOC
)
2479 os_memset(&data
, 0, sizeof(data
));
2480 os_memcpy(data
.ibss_rsn_start
.peer
, addr
, ETH_ALEN
);
2481 wpa_supplicant_event(drv
->ctx
, EVENT_IBSS_RSN_START
, &data
);
2485 static void nl80211_del_station_event(struct wpa_driver_nl80211_data
*drv
,
2489 union wpa_event_data data
;
2491 if (tb
[NL80211_ATTR_MAC
] == NULL
)
2493 addr
= nla_data(tb
[NL80211_ATTR_MAC
]);
2494 wpa_printf(MSG_DEBUG
, "nl80211: Delete station " MACSTR
,
2497 if (is_ap_interface(drv
->nlmode
) && drv
->device_ap_sme
) {
2498 drv_event_disassoc(drv
->ctx
, addr
);
2502 if (drv
->nlmode
!= NL80211_IFTYPE_ADHOC
)
2505 os_memset(&data
, 0, sizeof(data
));
2506 os_memcpy(data
.ibss_peer_lost
.peer
, addr
, ETH_ALEN
);
2507 wpa_supplicant_event(drv
->ctx
, EVENT_IBSS_PEER_LOST
, &data
);
2511 static void nl80211_rekey_offload_event(struct wpa_driver_nl80211_data
*drv
,
2514 struct nlattr
*rekey_info
[NUM_NL80211_REKEY_DATA
];
2515 static struct nla_policy rekey_policy
[NUM_NL80211_REKEY_DATA
] = {
2516 [NL80211_REKEY_DATA_KEK
] = {
2517 .minlen
= NL80211_KEK_LEN
,
2518 .maxlen
= NL80211_KEK_LEN
,
2520 [NL80211_REKEY_DATA_KCK
] = {
2521 .minlen
= NL80211_KCK_LEN
,
2522 .maxlen
= NL80211_KCK_LEN
,
2524 [NL80211_REKEY_DATA_REPLAY_CTR
] = {
2525 .minlen
= NL80211_REPLAY_CTR_LEN
,
2526 .maxlen
= NL80211_REPLAY_CTR_LEN
,
2529 union wpa_event_data data
;
2531 if (!tb
[NL80211_ATTR_MAC
])
2533 if (!tb
[NL80211_ATTR_REKEY_DATA
])
2535 if (nla_parse_nested(rekey_info
, MAX_NL80211_REKEY_DATA
,
2536 tb
[NL80211_ATTR_REKEY_DATA
], rekey_policy
))
2538 if (!rekey_info
[NL80211_REKEY_DATA_REPLAY_CTR
])
2541 os_memset(&data
, 0, sizeof(data
));
2542 data
.driver_gtk_rekey
.bssid
= nla_data(tb
[NL80211_ATTR_MAC
]);
2543 wpa_printf(MSG_DEBUG
, "nl80211: Rekey offload event for BSSID " MACSTR
,
2544 MAC2STR(data
.driver_gtk_rekey
.bssid
));
2545 data
.driver_gtk_rekey
.replay_ctr
=
2546 nla_data(rekey_info
[NL80211_REKEY_DATA_REPLAY_CTR
]);
2547 wpa_hexdump(MSG_DEBUG
, "nl80211: Rekey offload - Replay Counter",
2548 data
.driver_gtk_rekey
.replay_ctr
, NL80211_REPLAY_CTR_LEN
);
2549 wpa_supplicant_event(drv
->ctx
, EVENT_DRIVER_GTK_REKEY
, &data
);
2553 static void nl80211_pmksa_candidate_event(struct wpa_driver_nl80211_data
*drv
,
2556 struct nlattr
*cand
[NUM_NL80211_PMKSA_CANDIDATE
];
2557 static struct nla_policy cand_policy
[NUM_NL80211_PMKSA_CANDIDATE
] = {
2558 [NL80211_PMKSA_CANDIDATE_INDEX
] = { .type
= NLA_U32
},
2559 [NL80211_PMKSA_CANDIDATE_BSSID
] = {
2563 [NL80211_PMKSA_CANDIDATE_PREAUTH
] = { .type
= NLA_FLAG
},
2565 union wpa_event_data data
;
2567 wpa_printf(MSG_DEBUG
, "nl80211: PMKSA candidate event");
2569 if (!tb
[NL80211_ATTR_PMKSA_CANDIDATE
])
2571 if (nla_parse_nested(cand
, MAX_NL80211_PMKSA_CANDIDATE
,
2572 tb
[NL80211_ATTR_PMKSA_CANDIDATE
], cand_policy
))
2574 if (!cand
[NL80211_PMKSA_CANDIDATE_INDEX
] ||
2575 !cand
[NL80211_PMKSA_CANDIDATE_BSSID
])
2578 os_memset(&data
, 0, sizeof(data
));
2579 os_memcpy(data
.pmkid_candidate
.bssid
,
2580 nla_data(cand
[NL80211_PMKSA_CANDIDATE_BSSID
]), ETH_ALEN
);
2581 data
.pmkid_candidate
.index
=
2582 nla_get_u32(cand
[NL80211_PMKSA_CANDIDATE_INDEX
]);
2583 data
.pmkid_candidate
.preauth
=
2584 cand
[NL80211_PMKSA_CANDIDATE_PREAUTH
] != NULL
;
2585 wpa_supplicant_event(drv
->ctx
, EVENT_PMKID_CANDIDATE
, &data
);
2589 static void nl80211_client_probe_event(struct wpa_driver_nl80211_data
*drv
,
2592 union wpa_event_data data
;
2594 wpa_printf(MSG_DEBUG
, "nl80211: Probe client event");
2596 if (!tb
[NL80211_ATTR_MAC
] || !tb
[NL80211_ATTR_ACK
])
2599 os_memset(&data
, 0, sizeof(data
));
2600 os_memcpy(data
.client_poll
.addr
,
2601 nla_data(tb
[NL80211_ATTR_MAC
]), ETH_ALEN
);
2603 wpa_supplicant_event(drv
->ctx
, EVENT_DRIVER_CLIENT_POLL_OK
, &data
);
2607 static void nl80211_tdls_oper_event(struct wpa_driver_nl80211_data
*drv
,
2610 union wpa_event_data data
;
2612 wpa_printf(MSG_DEBUG
, "nl80211: TDLS operation event");
2614 if (!tb
[NL80211_ATTR_MAC
] || !tb
[NL80211_ATTR_TDLS_OPERATION
])
2617 os_memset(&data
, 0, sizeof(data
));
2618 os_memcpy(data
.tdls
.peer
, nla_data(tb
[NL80211_ATTR_MAC
]), ETH_ALEN
);
2619 switch (nla_get_u8(tb
[NL80211_ATTR_TDLS_OPERATION
])) {
2620 case NL80211_TDLS_SETUP
:
2621 wpa_printf(MSG_DEBUG
, "nl80211: TDLS setup request for peer "
2622 MACSTR
, MAC2STR(data
.tdls
.peer
));
2623 data
.tdls
.oper
= TDLS_REQUEST_SETUP
;
2625 case NL80211_TDLS_TEARDOWN
:
2626 wpa_printf(MSG_DEBUG
, "nl80211: TDLS teardown request for peer "
2627 MACSTR
, MAC2STR(data
.tdls
.peer
));
2628 data
.tdls
.oper
= TDLS_REQUEST_TEARDOWN
;
2631 wpa_printf(MSG_DEBUG
, "nl80211: Unsupported TDLS operatione "
2635 if (tb
[NL80211_ATTR_REASON_CODE
]) {
2636 data
.tdls
.reason_code
=
2637 nla_get_u16(tb
[NL80211_ATTR_REASON_CODE
]);
2640 wpa_supplicant_event(drv
->ctx
, EVENT_TDLS
, &data
);
2644 static void nl80211_stop_ap(struct wpa_driver_nl80211_data
*drv
,
2647 wpa_supplicant_event(drv
->ctx
, EVENT_INTERFACE_UNAVAILABLE
, NULL
);
2651 static void nl80211_connect_failed_event(struct wpa_driver_nl80211_data
*drv
,
2654 union wpa_event_data data
;
2657 wpa_printf(MSG_DEBUG
, "nl80211: Connect failed event");
2659 if (!tb
[NL80211_ATTR_MAC
] || !tb
[NL80211_ATTR_CONN_FAILED_REASON
])
2662 os_memset(&data
, 0, sizeof(data
));
2663 os_memcpy(data
.connect_failed_reason
.addr
,
2664 nla_data(tb
[NL80211_ATTR_MAC
]), ETH_ALEN
);
2666 reason
= nla_get_u32(tb
[NL80211_ATTR_CONN_FAILED_REASON
]);
2668 case NL80211_CONN_FAIL_MAX_CLIENTS
:
2669 wpa_printf(MSG_DEBUG
, "nl80211: Max client reached");
2670 data
.connect_failed_reason
.code
= MAX_CLIENT_REACHED
;
2672 case NL80211_CONN_FAIL_BLOCKED_CLIENT
:
2673 wpa_printf(MSG_DEBUG
, "nl80211: Blocked client " MACSTR
2674 " tried to connect",
2675 MAC2STR(data
.connect_failed_reason
.addr
));
2676 data
.connect_failed_reason
.code
= BLOCKED_CLIENT
;
2679 wpa_printf(MSG_DEBUG
, "nl8021l: Unknown connect failed reason "
2684 wpa_supplicant_event(drv
->ctx
, EVENT_CONNECT_FAILED_REASON
, &data
);
2688 static void nl80211_radar_event(struct wpa_driver_nl80211_data
*drv
,
2691 union wpa_event_data data
;
2692 enum nl80211_radar_event event_type
;
2694 if (!tb
[NL80211_ATTR_WIPHY_FREQ
] || !tb
[NL80211_ATTR_RADAR_EVENT
])
2697 os_memset(&data
, 0, sizeof(data
));
2698 data
.dfs_event
.freq
= nla_get_u32(tb
[NL80211_ATTR_WIPHY_FREQ
]);
2699 event_type
= nla_get_u32(tb
[NL80211_ATTR_RADAR_EVENT
]);
2701 /* Check HT params */
2702 if (tb
[NL80211_ATTR_WIPHY_CHANNEL_TYPE
]) {
2703 data
.dfs_event
.ht_enabled
= 1;
2704 data
.dfs_event
.chan_offset
= 0;
2706 switch (nla_get_u32(tb
[NL80211_ATTR_WIPHY_CHANNEL_TYPE
])) {
2707 case NL80211_CHAN_NO_HT
:
2708 data
.dfs_event
.ht_enabled
= 0;
2710 case NL80211_CHAN_HT20
:
2712 case NL80211_CHAN_HT40PLUS
:
2713 data
.dfs_event
.chan_offset
= 1;
2715 case NL80211_CHAN_HT40MINUS
:
2716 data
.dfs_event
.chan_offset
= -1;
2721 /* Get VHT params */
2722 if (tb
[NL80211_ATTR_CHANNEL_WIDTH
])
2723 data
.dfs_event
.chan_width
=
2724 convert2width(nla_get_u32(
2725 tb
[NL80211_ATTR_CHANNEL_WIDTH
]));
2726 if (tb
[NL80211_ATTR_CENTER_FREQ1
])
2727 data
.dfs_event
.cf1
= nla_get_u32(tb
[NL80211_ATTR_CENTER_FREQ1
]);
2728 if (tb
[NL80211_ATTR_CENTER_FREQ2
])
2729 data
.dfs_event
.cf2
= nla_get_u32(tb
[NL80211_ATTR_CENTER_FREQ2
]);
2731 wpa_printf(MSG_DEBUG
, "nl80211: DFS event on freq %d MHz, ht: %d, offset: %d, width: %d, cf1: %dMHz, cf2: %dMHz",
2732 data
.dfs_event
.freq
, data
.dfs_event
.ht_enabled
,
2733 data
.dfs_event
.chan_offset
, data
.dfs_event
.chan_width
,
2734 data
.dfs_event
.cf1
, data
.dfs_event
.cf2
);
2736 switch (event_type
) {
2737 case NL80211_RADAR_DETECTED
:
2738 wpa_supplicant_event(drv
->ctx
, EVENT_DFS_RADAR_DETECTED
, &data
);
2740 case NL80211_RADAR_CAC_FINISHED
:
2741 wpa_supplicant_event(drv
->ctx
, EVENT_DFS_CAC_FINISHED
, &data
);
2743 case NL80211_RADAR_CAC_ABORTED
:
2744 wpa_supplicant_event(drv
->ctx
, EVENT_DFS_CAC_ABORTED
, &data
);
2746 case NL80211_RADAR_NOP_FINISHED
:
2747 wpa_supplicant_event(drv
->ctx
, EVENT_DFS_NOP_FINISHED
, &data
);
2750 wpa_printf(MSG_DEBUG
, "nl80211: Unknown radar event %d "
2751 "received", event_type
);
2757 static void nl80211_spurious_frame(struct i802_bss
*bss
, struct nlattr
**tb
,
2760 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
2761 union wpa_event_data event
;
2763 if (!tb
[NL80211_ATTR_MAC
])
2766 os_memset(&event
, 0, sizeof(event
));
2767 event
.rx_from_unknown
.bssid
= bss
->addr
;
2768 event
.rx_from_unknown
.addr
= nla_data(tb
[NL80211_ATTR_MAC
]);
2769 event
.rx_from_unknown
.wds
= wds
;
2771 wpa_supplicant_event(drv
->ctx
, EVENT_RX_FROM_UNKNOWN
, &event
);
2775 static void qca_nl80211_avoid_freq(struct wpa_driver_nl80211_data
*drv
,
2776 const u8
*data
, size_t len
)
2779 union wpa_event_data event
;
2780 struct wpa_freq_range
*range
= NULL
;
2781 const struct qca_avoid_freq_list
*freq_range
;
2783 freq_range
= (const struct qca_avoid_freq_list
*) data
;
2784 if (len
< sizeof(freq_range
->count
))
2787 count
= freq_range
->count
;
2788 if (len
< sizeof(freq_range
->count
) +
2789 count
* sizeof(struct qca_avoid_freq_range
)) {
2790 wpa_printf(MSG_DEBUG
, "nl80211: Ignored too short avoid frequency list (len=%u)",
2791 (unsigned int) len
);
2796 range
= os_calloc(count
, sizeof(struct wpa_freq_range
));
2801 os_memset(&event
, 0, sizeof(event
));
2802 for (i
= 0; i
< count
; i
++) {
2803 unsigned int idx
= event
.freq_range
.num
;
2804 range
[idx
].min
= freq_range
->range
[i
].start_freq
;
2805 range
[idx
].max
= freq_range
->range
[i
].end_freq
;
2806 wpa_printf(MSG_DEBUG
, "nl80211: Avoid frequency range: %u-%u",
2807 range
[idx
].min
, range
[idx
].max
);
2808 if (range
[idx
].min
> range
[idx
].max
) {
2809 wpa_printf(MSG_DEBUG
, "nl80211: Ignore invalid frequency range");
2812 event
.freq_range
.num
++;
2814 event
.freq_range
.range
= range
;
2816 wpa_supplicant_event(drv
->ctx
, EVENT_AVOID_FREQUENCIES
, &event
);
2822 static void nl80211_vendor_event_qca(struct wpa_driver_nl80211_data
*drv
,
2823 u32 subcmd
, u8
*data
, size_t len
)
2826 case QCA_NL80211_VENDOR_SUBCMD_AVOID_FREQUENCY
:
2827 qca_nl80211_avoid_freq(drv
, data
, len
);
2830 wpa_printf(MSG_DEBUG
,
2831 "nl80211: Ignore unsupported QCA vendor event %u",
2838 static void nl80211_vendor_event(struct wpa_driver_nl80211_data
*drv
,
2841 u32 vendor_id
, subcmd
, wiphy
= 0;
2846 if (!tb
[NL80211_ATTR_VENDOR_ID
] ||
2847 !tb
[NL80211_ATTR_VENDOR_SUBCMD
])
2850 vendor_id
= nla_get_u32(tb
[NL80211_ATTR_VENDOR_ID
]);
2851 subcmd
= nla_get_u32(tb
[NL80211_ATTR_VENDOR_SUBCMD
]);
2853 if (tb
[NL80211_ATTR_WIPHY
])
2854 wiphy
= nla_get_u32(tb
[NL80211_ATTR_WIPHY
]);
2856 wpa_printf(MSG_DEBUG
, "nl80211: Vendor event: wiphy=%u vendor_id=0x%x subcmd=%u",
2857 wiphy
, vendor_id
, subcmd
);
2859 if (tb
[NL80211_ATTR_VENDOR_DATA
]) {
2860 data
= nla_data(tb
[NL80211_ATTR_VENDOR_DATA
]);
2861 len
= nla_len(tb
[NL80211_ATTR_VENDOR_DATA
]);
2862 wpa_hexdump(MSG_MSGDUMP
, "nl80211: Vendor data", data
, len
);
2865 wiphy_idx
= nl80211_get_wiphy_index(drv
->first_bss
);
2866 if (wiphy_idx
>= 0 && wiphy_idx
!= (int) wiphy
) {
2867 wpa_printf(MSG_DEBUG
, "nl80211: Ignore vendor event for foreign wiphy %u (own: %d)",
2872 switch (vendor_id
) {
2874 nl80211_vendor_event_qca(drv
, subcmd
, data
, len
);
2877 wpa_printf(MSG_DEBUG
, "nl80211: Ignore unsupported vendor event");
2883 static void do_process_drv_event(struct i802_bss
*bss
, int cmd
,
2886 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
2887 union wpa_event_data data
;
2889 wpa_printf(MSG_DEBUG
, "nl80211: Drv Event %d (%s) received for %s",
2890 cmd
, nl80211_command_to_string(cmd
), bss
->ifname
);
2892 if (drv
->ap_scan_as_station
!= NL80211_IFTYPE_UNSPECIFIED
&&
2893 (cmd
== NL80211_CMD_NEW_SCAN_RESULTS
||
2894 cmd
== NL80211_CMD_SCAN_ABORTED
)) {
2895 wpa_driver_nl80211_set_mode(drv
->first_bss
,
2896 drv
->ap_scan_as_station
);
2897 drv
->ap_scan_as_station
= NL80211_IFTYPE_UNSPECIFIED
;
2901 case NL80211_CMD_TRIGGER_SCAN
:
2902 wpa_dbg(drv
->ctx
, MSG_DEBUG
, "nl80211: Scan trigger");
2903 drv
->scan_state
= SCAN_STARTED
;
2904 if (drv
->scan_for_auth
) {
2906 * Cannot indicate EVENT_SCAN_STARTED here since we skip
2907 * EVENT_SCAN_RESULTS in scan_for_auth case and the
2908 * upper layer implementation could get confused about
2911 wpa_printf(MSG_DEBUG
, "nl80211: Do not indicate scan-start event due to internal scan_for_auth");
2914 wpa_supplicant_event(drv
->ctx
, EVENT_SCAN_STARTED
, NULL
);
2916 case NL80211_CMD_START_SCHED_SCAN
:
2917 wpa_dbg(drv
->ctx
, MSG_DEBUG
, "nl80211: Sched scan started");
2918 drv
->scan_state
= SCHED_SCAN_STARTED
;
2920 case NL80211_CMD_SCHED_SCAN_STOPPED
:
2921 wpa_dbg(drv
->ctx
, MSG_DEBUG
, "nl80211: Sched scan stopped");
2922 drv
->scan_state
= SCHED_SCAN_STOPPED
;
2923 wpa_supplicant_event(drv
->ctx
, EVENT_SCHED_SCAN_STOPPED
, NULL
);
2925 case NL80211_CMD_NEW_SCAN_RESULTS
:
2926 wpa_dbg(drv
->ctx
, MSG_DEBUG
,
2927 "nl80211: New scan results available");
2928 drv
->scan_state
= SCAN_COMPLETED
;
2929 drv
->scan_complete_events
= 1;
2930 eloop_cancel_timeout(wpa_driver_nl80211_scan_timeout
, drv
,
2932 send_scan_event(drv
, 0, tb
);
2934 case NL80211_CMD_SCHED_SCAN_RESULTS
:
2935 wpa_dbg(drv
->ctx
, MSG_DEBUG
,
2936 "nl80211: New sched scan results available");
2937 drv
->scan_state
= SCHED_SCAN_RESULTS
;
2938 send_scan_event(drv
, 0, tb
);
2940 case NL80211_CMD_SCAN_ABORTED
:
2941 wpa_dbg(drv
->ctx
, MSG_DEBUG
, "nl80211: Scan aborted");
2942 drv
->scan_state
= SCAN_ABORTED
;
2944 * Need to indicate that scan results are available in order
2945 * not to make wpa_supplicant stop its scanning.
2947 eloop_cancel_timeout(wpa_driver_nl80211_scan_timeout
, drv
,
2949 send_scan_event(drv
, 1, tb
);
2951 case NL80211_CMD_AUTHENTICATE
:
2952 case NL80211_CMD_ASSOCIATE
:
2953 case NL80211_CMD_DEAUTHENTICATE
:
2954 case NL80211_CMD_DISASSOCIATE
:
2955 case NL80211_CMD_FRAME_TX_STATUS
:
2956 case NL80211_CMD_UNPROT_DEAUTHENTICATE
:
2957 case NL80211_CMD_UNPROT_DISASSOCIATE
:
2958 mlme_event(bss
, cmd
, tb
[NL80211_ATTR_FRAME
],
2959 tb
[NL80211_ATTR_MAC
], tb
[NL80211_ATTR_TIMED_OUT
],
2960 tb
[NL80211_ATTR_WIPHY_FREQ
], tb
[NL80211_ATTR_ACK
],
2961 tb
[NL80211_ATTR_COOKIE
],
2962 tb
[NL80211_ATTR_RX_SIGNAL_DBM
]);
2964 case NL80211_CMD_CONNECT
:
2965 case NL80211_CMD_ROAM
:
2966 mlme_event_connect(drv
, cmd
,
2967 tb
[NL80211_ATTR_STATUS_CODE
],
2968 tb
[NL80211_ATTR_MAC
],
2969 tb
[NL80211_ATTR_REQ_IE
],
2970 tb
[NL80211_ATTR_RESP_IE
]);
2972 case NL80211_CMD_CH_SWITCH_NOTIFY
:
2973 mlme_event_ch_switch(drv
,
2974 tb
[NL80211_ATTR_IFINDEX
],
2975 tb
[NL80211_ATTR_WIPHY_FREQ
],
2976 tb
[NL80211_ATTR_WIPHY_CHANNEL_TYPE
],
2977 tb
[NL80211_ATTR_CHANNEL_WIDTH
],
2978 tb
[NL80211_ATTR_CENTER_FREQ1
],
2979 tb
[NL80211_ATTR_CENTER_FREQ2
]);
2981 case NL80211_CMD_DISCONNECT
:
2982 mlme_event_disconnect(drv
, tb
[NL80211_ATTR_REASON_CODE
],
2983 tb
[NL80211_ATTR_MAC
],
2984 tb
[NL80211_ATTR_DISCONNECTED_BY_AP
]);
2986 case NL80211_CMD_MICHAEL_MIC_FAILURE
:
2987 mlme_event_michael_mic_failure(bss
, tb
);
2989 case NL80211_CMD_JOIN_IBSS
:
2990 mlme_event_join_ibss(drv
, tb
);
2992 case NL80211_CMD_REMAIN_ON_CHANNEL
:
2993 mlme_event_remain_on_channel(drv
, 0, tb
);
2995 case NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL
:
2996 mlme_event_remain_on_channel(drv
, 1, tb
);
2998 case NL80211_CMD_NOTIFY_CQM
:
2999 nl80211_cqm_event(drv
, tb
);
3001 case NL80211_CMD_REG_CHANGE
:
3002 wpa_printf(MSG_DEBUG
, "nl80211: Regulatory domain change");
3003 if (tb
[NL80211_ATTR_REG_INITIATOR
] == NULL
)
3005 os_memset(&data
, 0, sizeof(data
));
3006 switch (nla_get_u8(tb
[NL80211_ATTR_REG_INITIATOR
])) {
3007 case NL80211_REGDOM_SET_BY_CORE
:
3008 data
.channel_list_changed
.initiator
=
3011 case NL80211_REGDOM_SET_BY_USER
:
3012 data
.channel_list_changed
.initiator
=
3015 case NL80211_REGDOM_SET_BY_DRIVER
:
3016 data
.channel_list_changed
.initiator
=
3017 REGDOM_SET_BY_DRIVER
;
3019 case NL80211_REGDOM_SET_BY_COUNTRY_IE
:
3020 data
.channel_list_changed
.initiator
=
3021 REGDOM_SET_BY_COUNTRY_IE
;
3024 wpa_printf(MSG_DEBUG
, "nl80211: Unknown reg change initiator %d received",
3025 nla_get_u8(tb
[NL80211_ATTR_REG_INITIATOR
]));
3028 wpa_supplicant_event(drv
->ctx
, EVENT_CHANNEL_LIST_CHANGED
,
3031 case NL80211_CMD_REG_BEACON_HINT
:
3032 wpa_printf(MSG_DEBUG
, "nl80211: Regulatory beacon hint");
3033 os_memset(&data
, 0, sizeof(data
));
3034 data
.channel_list_changed
.initiator
= REGDOM_BEACON_HINT
;
3035 wpa_supplicant_event(drv
->ctx
, EVENT_CHANNEL_LIST_CHANGED
,
3038 case NL80211_CMD_NEW_STATION
:
3039 nl80211_new_station_event(drv
, tb
);
3041 case NL80211_CMD_DEL_STATION
:
3042 nl80211_del_station_event(drv
, tb
);
3044 case NL80211_CMD_SET_REKEY_OFFLOAD
:
3045 nl80211_rekey_offload_event(drv
, tb
);
3047 case NL80211_CMD_PMKSA_CANDIDATE
:
3048 nl80211_pmksa_candidate_event(drv
, tb
);
3050 case NL80211_CMD_PROBE_CLIENT
:
3051 nl80211_client_probe_event(drv
, tb
);
3053 case NL80211_CMD_TDLS_OPER
:
3054 nl80211_tdls_oper_event(drv
, tb
);
3056 case NL80211_CMD_CONN_FAILED
:
3057 nl80211_connect_failed_event(drv
, tb
);
3059 case NL80211_CMD_FT_EVENT
:
3060 mlme_event_ft_event(drv
, tb
);
3062 case NL80211_CMD_RADAR_DETECT
:
3063 nl80211_radar_event(drv
, tb
);
3065 case NL80211_CMD_STOP_AP
:
3066 nl80211_stop_ap(drv
, tb
);
3068 case NL80211_CMD_VENDOR
:
3069 nl80211_vendor_event(drv
, tb
);
3072 wpa_dbg(drv
->ctx
, MSG_DEBUG
, "nl80211: Ignored unknown event "
3079 static int process_drv_event(struct nl_msg
*msg
, void *arg
)
3081 struct wpa_driver_nl80211_data
*drv
= arg
;
3082 struct genlmsghdr
*gnlh
= nlmsg_data(nlmsg_hdr(msg
));
3083 struct nlattr
*tb
[NL80211_ATTR_MAX
+ 1];
3084 struct i802_bss
*bss
;
3087 nla_parse(tb
, NL80211_ATTR_MAX
, genlmsg_attrdata(gnlh
, 0),
3088 genlmsg_attrlen(gnlh
, 0), NULL
);
3090 if (tb
[NL80211_ATTR_IFINDEX
]) {
3091 ifidx
= nla_get_u32(tb
[NL80211_ATTR_IFINDEX
]);
3093 for (bss
= drv
->first_bss
; bss
; bss
= bss
->next
)
3094 if (ifidx
== -1 || ifidx
== bss
->ifindex
) {
3095 do_process_drv_event(bss
, gnlh
->cmd
, tb
);
3098 wpa_printf(MSG_DEBUG
,
3099 "nl80211: Ignored event (cmd=%d) for foreign interface (ifindex %d)",
3101 } else if (tb
[NL80211_ATTR_WDEV
]) {
3102 u64 wdev_id
= nla_get_u64(tb
[NL80211_ATTR_WDEV
]);
3103 wpa_printf(MSG_DEBUG
, "nl80211: Process event on P2P device");
3104 for (bss
= drv
->first_bss
; bss
; bss
= bss
->next
) {
3105 if (bss
->wdev_id_set
&& wdev_id
== bss
->wdev_id
) {
3106 do_process_drv_event(bss
, gnlh
->cmd
, tb
);
3110 wpa_printf(MSG_DEBUG
,
3111 "nl80211: Ignored event (cmd=%d) for foreign interface (wdev 0x%llx)",
3112 gnlh
->cmd
, (long long unsigned int) wdev_id
);
3119 static int process_global_event(struct nl_msg
*msg
, void *arg
)
3121 struct nl80211_global
*global
= arg
;
3122 struct genlmsghdr
*gnlh
= nlmsg_data(nlmsg_hdr(msg
));
3123 struct nlattr
*tb
[NL80211_ATTR_MAX
+ 1];
3124 struct wpa_driver_nl80211_data
*drv
, *tmp
;
3126 struct i802_bss
*bss
;
3128 int wdev_id_set
= 0;
3130 nla_parse(tb
, NL80211_ATTR_MAX
, genlmsg_attrdata(gnlh
, 0),
3131 genlmsg_attrlen(gnlh
, 0), NULL
);
3133 if (tb
[NL80211_ATTR_IFINDEX
])
3134 ifidx
= nla_get_u32(tb
[NL80211_ATTR_IFINDEX
]);
3135 else if (tb
[NL80211_ATTR_WDEV
]) {
3136 wdev_id
= nla_get_u64(tb
[NL80211_ATTR_WDEV
]);
3140 dl_list_for_each_safe(drv
, tmp
, &global
->interfaces
,
3141 struct wpa_driver_nl80211_data
, list
) {
3142 for (bss
= drv
->first_bss
; bss
; bss
= bss
->next
) {
3143 if ((ifidx
== -1 && !wdev_id_set
) ||
3144 ifidx
== bss
->ifindex
||
3145 (wdev_id_set
&& bss
->wdev_id_set
&&
3146 wdev_id
== bss
->wdev_id
)) {
3147 do_process_drv_event(bss
, gnlh
->cmd
, tb
);
3157 static int process_bss_event(struct nl_msg
*msg
, void *arg
)
3159 struct i802_bss
*bss
= arg
;
3160 struct genlmsghdr
*gnlh
= nlmsg_data(nlmsg_hdr(msg
));
3161 struct nlattr
*tb
[NL80211_ATTR_MAX
+ 1];
3163 nla_parse(tb
, NL80211_ATTR_MAX
, genlmsg_attrdata(gnlh
, 0),
3164 genlmsg_attrlen(gnlh
, 0), NULL
);
3166 wpa_printf(MSG_DEBUG
, "nl80211: BSS Event %d (%s) received for %s",
3167 gnlh
->cmd
, nl80211_command_to_string(gnlh
->cmd
),
3170 switch (gnlh
->cmd
) {
3171 case NL80211_CMD_FRAME
:
3172 case NL80211_CMD_FRAME_TX_STATUS
:
3173 mlme_event(bss
, gnlh
->cmd
, tb
[NL80211_ATTR_FRAME
],
3174 tb
[NL80211_ATTR_MAC
], tb
[NL80211_ATTR_TIMED_OUT
],
3175 tb
[NL80211_ATTR_WIPHY_FREQ
], tb
[NL80211_ATTR_ACK
],
3176 tb
[NL80211_ATTR_COOKIE
],
3177 tb
[NL80211_ATTR_RX_SIGNAL_DBM
]);
3179 case NL80211_CMD_UNEXPECTED_FRAME
:
3180 nl80211_spurious_frame(bss
, tb
, 0);
3182 case NL80211_CMD_UNEXPECTED_4ADDR_FRAME
:
3183 nl80211_spurious_frame(bss
, tb
, 1);
3186 wpa_printf(MSG_DEBUG
, "nl80211: Ignored unknown event "
3187 "(cmd=%d)", gnlh
->cmd
);
3195 static void wpa_driver_nl80211_event_receive(int sock
, void *eloop_ctx
,
3198 struct nl_cb
*cb
= eloop_ctx
;
3201 wpa_printf(MSG_MSGDUMP
, "nl80211: Event message available");
3203 res
= nl_recvmsgs(handle
, cb
);
3205 wpa_printf(MSG_INFO
, "nl80211: %s->nl_recvmsgs failed: %d",
3212 * wpa_driver_nl80211_set_country - ask nl80211 to set the regulatory domain
3213 * @priv: driver_nl80211 private data
3214 * @alpha2_arg: country to which to switch to
3215 * Returns: 0 on success, -1 on failure
3217 * This asks nl80211 to set the regulatory domain for given
3218 * country ISO / IEC alpha2.
3220 static int wpa_driver_nl80211_set_country(void *priv
, const char *alpha2_arg
)
3222 struct i802_bss
*bss
= priv
;
3223 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
3227 msg
= nlmsg_alloc();
3231 alpha2
[0] = alpha2_arg
[0];
3232 alpha2
[1] = alpha2_arg
[1];
3235 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_REQ_SET_REG
);
3237 NLA_PUT_STRING(msg
, NL80211_ATTR_REG_ALPHA2
, alpha2
);
3238 if (send_and_recv_msgs(drv
, msg
, NULL
, NULL
))
3247 static int nl80211_get_country(struct nl_msg
*msg
, void *arg
)
3250 struct nlattr
*tb_msg
[NL80211_ATTR_MAX
+ 1];
3251 struct genlmsghdr
*gnlh
= nlmsg_data(nlmsg_hdr(msg
));
3253 nla_parse(tb_msg
, NL80211_ATTR_MAX
, genlmsg_attrdata(gnlh
, 0),
3254 genlmsg_attrlen(gnlh
, 0), NULL
);
3255 if (!tb_msg
[NL80211_ATTR_REG_ALPHA2
]) {
3256 wpa_printf(MSG_DEBUG
, "nl80211: No country information available");
3259 os_strlcpy(alpha2
, nla_data(tb_msg
[NL80211_ATTR_REG_ALPHA2
]), 3);
3264 static int wpa_driver_nl80211_get_country(void *priv
, char *alpha2
)
3266 struct i802_bss
*bss
= priv
;
3267 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
3271 msg
= nlmsg_alloc();
3275 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_GET_REG
);
3277 ret
= send_and_recv_msgs(drv
, msg
, nl80211_get_country
, alpha2
);
3285 static int protocol_feature_handler(struct nl_msg
*msg
, void *arg
)
3288 struct nlattr
*tb_msg
[NL80211_ATTR_MAX
+ 1];
3289 struct genlmsghdr
*gnlh
= nlmsg_data(nlmsg_hdr(msg
));
3291 nla_parse(tb_msg
, NL80211_ATTR_MAX
, genlmsg_attrdata(gnlh
, 0),
3292 genlmsg_attrlen(gnlh
, 0), NULL
);
3294 if (tb_msg
[NL80211_ATTR_PROTOCOL_FEATURES
])
3295 *feat
= nla_get_u32(tb_msg
[NL80211_ATTR_PROTOCOL_FEATURES
]);
3301 static u32
get_nl80211_protocol_features(struct wpa_driver_nl80211_data
*drv
)
3306 msg
= nlmsg_alloc();
3308 goto nla_put_failure
;
3310 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_GET_PROTOCOL_FEATURES
);
3311 if (send_and_recv_msgs(drv
, msg
, protocol_feature_handler
, &feat
) == 0)
3321 struct wiphy_info_data
{
3322 struct wpa_driver_nl80211_data
*drv
;
3323 struct wpa_driver_capa
*capa
;
3325 unsigned int num_multichan_concurrent
;
3327 unsigned int error
:1;
3328 unsigned int device_ap_sme
:1;
3329 unsigned int poll_command_supported
:1;
3330 unsigned int data_tx_status
:1;
3331 unsigned int monitor_supported
:1;
3332 unsigned int auth_supported
:1;
3333 unsigned int connect_supported
:1;
3334 unsigned int p2p_go_supported
:1;
3335 unsigned int p2p_client_supported
:1;
3336 unsigned int p2p_concurrent
:1;
3337 unsigned int channel_switch_supported
:1;
3338 unsigned int set_qos_map_supported
:1;
3342 static unsigned int probe_resp_offload_support(int supp_protocols
)
3344 unsigned int prot
= 0;
3346 if (supp_protocols
& NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS
)
3347 prot
|= WPA_DRIVER_PROBE_RESP_OFFLOAD_WPS
;
3348 if (supp_protocols
& NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2
)
3349 prot
|= WPA_DRIVER_PROBE_RESP_OFFLOAD_WPS2
;
3350 if (supp_protocols
& NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P
)
3351 prot
|= WPA_DRIVER_PROBE_RESP_OFFLOAD_P2P
;
3352 if (supp_protocols
& NL80211_PROBE_RESP_OFFLOAD_SUPPORT_80211U
)
3353 prot
|= WPA_DRIVER_PROBE_RESP_OFFLOAD_INTERWORKING
;
3359 static void wiphy_info_supported_iftypes(struct wiphy_info_data
*info
,
3362 struct nlattr
*nl_mode
;
3368 nla_for_each_nested(nl_mode
, tb
, i
) {
3369 switch (nla_type(nl_mode
)) {
3370 case NL80211_IFTYPE_AP
:
3371 info
->capa
->flags
|= WPA_DRIVER_FLAGS_AP
;
3373 case NL80211_IFTYPE_ADHOC
:
3374 info
->capa
->flags
|= WPA_DRIVER_FLAGS_IBSS
;
3376 case NL80211_IFTYPE_P2P_DEVICE
:
3377 info
->capa
->flags
|=
3378 WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE
;
3380 case NL80211_IFTYPE_P2P_GO
:
3381 info
->p2p_go_supported
= 1;
3383 case NL80211_IFTYPE_P2P_CLIENT
:
3384 info
->p2p_client_supported
= 1;
3386 case NL80211_IFTYPE_MONITOR
:
3387 info
->monitor_supported
= 1;
3394 static int wiphy_info_iface_comb_process(struct wiphy_info_data
*info
,
3395 struct nlattr
*nl_combi
)
3397 struct nlattr
*tb_comb
[NUM_NL80211_IFACE_COMB
];
3398 struct nlattr
*tb_limit
[NUM_NL80211_IFACE_LIMIT
];
3399 struct nlattr
*nl_limit
, *nl_mode
;
3400 int err
, rem_limit
, rem_mode
;
3401 int combination_has_p2p
= 0, combination_has_mgd
= 0;
3402 static struct nla_policy
3403 iface_combination_policy
[NUM_NL80211_IFACE_COMB
] = {
3404 [NL80211_IFACE_COMB_LIMITS
] = { .type
= NLA_NESTED
},
3405 [NL80211_IFACE_COMB_MAXNUM
] = { .type
= NLA_U32
},
3406 [NL80211_IFACE_COMB_STA_AP_BI_MATCH
] = { .type
= NLA_FLAG
},
3407 [NL80211_IFACE_COMB_NUM_CHANNELS
] = { .type
= NLA_U32
},
3408 [NL80211_IFACE_COMB_RADAR_DETECT_WIDTHS
] = { .type
= NLA_U32
},
3410 iface_limit_policy
[NUM_NL80211_IFACE_LIMIT
] = {
3411 [NL80211_IFACE_LIMIT_TYPES
] = { .type
= NLA_NESTED
},
3412 [NL80211_IFACE_LIMIT_MAX
] = { .type
= NLA_U32
},
3415 err
= nla_parse_nested(tb_comb
, MAX_NL80211_IFACE_COMB
,
3416 nl_combi
, iface_combination_policy
);
3417 if (err
|| !tb_comb
[NL80211_IFACE_COMB_LIMITS
] ||
3418 !tb_comb
[NL80211_IFACE_COMB_MAXNUM
] ||
3419 !tb_comb
[NL80211_IFACE_COMB_NUM_CHANNELS
])
3420 return 0; /* broken combination */
3422 if (tb_comb
[NL80211_IFACE_COMB_RADAR_DETECT_WIDTHS
])
3423 info
->capa
->flags
|= WPA_DRIVER_FLAGS_RADAR
;
3425 nla_for_each_nested(nl_limit
, tb_comb
[NL80211_IFACE_COMB_LIMITS
],
3427 err
= nla_parse_nested(tb_limit
, MAX_NL80211_IFACE_LIMIT
,
3428 nl_limit
, iface_limit_policy
);
3429 if (err
|| !tb_limit
[NL80211_IFACE_LIMIT_TYPES
])
3430 return 0; /* broken combination */
3432 nla_for_each_nested(nl_mode
,
3433 tb_limit
[NL80211_IFACE_LIMIT_TYPES
],
3435 int ift
= nla_type(nl_mode
);
3436 if (ift
== NL80211_IFTYPE_P2P_GO
||
3437 ift
== NL80211_IFTYPE_P2P_CLIENT
)
3438 combination_has_p2p
= 1;
3439 if (ift
== NL80211_IFTYPE_STATION
)
3440 combination_has_mgd
= 1;
3442 if (combination_has_p2p
&& combination_has_mgd
)
3446 if (combination_has_p2p
&& combination_has_mgd
) {
3447 info
->p2p_concurrent
= 1;
3448 info
->num_multichan_concurrent
=
3449 nla_get_u32(tb_comb
[NL80211_IFACE_COMB_NUM_CHANNELS
]);
3457 static void wiphy_info_iface_comb(struct wiphy_info_data
*info
,
3460 struct nlattr
*nl_combi
;
3466 nla_for_each_nested(nl_combi
, tb
, rem_combi
) {
3467 if (wiphy_info_iface_comb_process(info
, nl_combi
) > 0)
3473 static void wiphy_info_supp_cmds(struct wiphy_info_data
*info
,
3476 struct nlattr
*nl_cmd
;
3482 nla_for_each_nested(nl_cmd
, tb
, i
) {
3483 switch (nla_get_u32(nl_cmd
)) {
3484 case NL80211_CMD_AUTHENTICATE
:
3485 info
->auth_supported
= 1;
3487 case NL80211_CMD_CONNECT
:
3488 info
->connect_supported
= 1;
3490 case NL80211_CMD_START_SCHED_SCAN
:
3491 info
->capa
->sched_scan_supported
= 1;
3493 case NL80211_CMD_PROBE_CLIENT
:
3494 info
->poll_command_supported
= 1;
3496 case NL80211_CMD_CHANNEL_SWITCH
:
3497 info
->channel_switch_supported
= 1;
3499 case NL80211_CMD_SET_QOS_MAP
:
3500 info
->set_qos_map_supported
= 1;
3507 static void wiphy_info_cipher_suites(struct wiphy_info_data
*info
,
3516 num
= nla_len(tb
) / sizeof(u32
);
3517 ciphers
= nla_data(tb
);
3518 for (i
= 0; i
< num
; i
++) {
3521 wpa_printf(MSG_DEBUG
, "nl80211: Supported cipher %02x-%02x-%02x:%d",
3522 c
>> 24, (c
>> 16) & 0xff,
3523 (c
>> 8) & 0xff, c
& 0xff);
3525 case WLAN_CIPHER_SUITE_CCMP_256
:
3526 info
->capa
->enc
|= WPA_DRIVER_CAPA_ENC_CCMP_256
;
3528 case WLAN_CIPHER_SUITE_GCMP_256
:
3529 info
->capa
->enc
|= WPA_DRIVER_CAPA_ENC_GCMP_256
;
3531 case WLAN_CIPHER_SUITE_CCMP
:
3532 info
->capa
->enc
|= WPA_DRIVER_CAPA_ENC_CCMP
;
3534 case WLAN_CIPHER_SUITE_GCMP
:
3535 info
->capa
->enc
|= WPA_DRIVER_CAPA_ENC_GCMP
;
3537 case WLAN_CIPHER_SUITE_TKIP
:
3538 info
->capa
->enc
|= WPA_DRIVER_CAPA_ENC_TKIP
;
3540 case WLAN_CIPHER_SUITE_WEP104
:
3541 info
->capa
->enc
|= WPA_DRIVER_CAPA_ENC_WEP104
;
3543 case WLAN_CIPHER_SUITE_WEP40
:
3544 info
->capa
->enc
|= WPA_DRIVER_CAPA_ENC_WEP40
;
3546 case WLAN_CIPHER_SUITE_AES_CMAC
:
3547 info
->capa
->enc
|= WPA_DRIVER_CAPA_ENC_BIP
;
3549 case WLAN_CIPHER_SUITE_BIP_GMAC_128
:
3550 info
->capa
->enc
|= WPA_DRIVER_CAPA_ENC_BIP_GMAC_128
;
3552 case WLAN_CIPHER_SUITE_BIP_GMAC_256
:
3553 info
->capa
->enc
|= WPA_DRIVER_CAPA_ENC_BIP_GMAC_256
;
3555 case WLAN_CIPHER_SUITE_BIP_CMAC_256
:
3556 info
->capa
->enc
|= WPA_DRIVER_CAPA_ENC_BIP_CMAC_256
;
3558 case WLAN_CIPHER_SUITE_NO_GROUP_ADDR
:
3559 info
->capa
->enc
|= WPA_DRIVER_CAPA_ENC_GTK_NOT_USED
;
3566 static void wiphy_info_max_roc(struct wpa_driver_capa
*capa
,
3570 capa
->max_remain_on_chan
= nla_get_u32(tb
);
3574 static void wiphy_info_tdls(struct wpa_driver_capa
*capa
, struct nlattr
*tdls
,
3575 struct nlattr
*ext_setup
)
3580 wpa_printf(MSG_DEBUG
, "nl80211: TDLS supported");
3581 capa
->flags
|= WPA_DRIVER_FLAGS_TDLS_SUPPORT
;
3584 wpa_printf(MSG_DEBUG
, "nl80211: TDLS external setup");
3585 capa
->flags
|= WPA_DRIVER_FLAGS_TDLS_EXTERNAL_SETUP
;
3590 static void wiphy_info_feature_flags(struct wiphy_info_data
*info
,
3594 struct wpa_driver_capa
*capa
= info
->capa
;
3599 flags
= nla_get_u32(tb
);
3601 if (flags
& NL80211_FEATURE_SK_TX_STATUS
)
3602 info
->data_tx_status
= 1;
3604 if (flags
& NL80211_FEATURE_INACTIVITY_TIMER
)
3605 capa
->flags
|= WPA_DRIVER_FLAGS_INACTIVITY_TIMER
;
3607 if (flags
& NL80211_FEATURE_SAE
)
3608 capa
->flags
|= WPA_DRIVER_FLAGS_SAE
;
3610 if (flags
& NL80211_FEATURE_NEED_OBSS_SCAN
)
3611 capa
->flags
|= WPA_DRIVER_FLAGS_OBSS_SCAN
;
3615 static void wiphy_info_probe_resp_offload(struct wpa_driver_capa
*capa
,
3623 protocols
= nla_get_u32(tb
);
3624 wpa_printf(MSG_DEBUG
, "nl80211: Supports Probe Response offload in AP "
3626 capa
->flags
|= WPA_DRIVER_FLAGS_PROBE_RESP_OFFLOAD
;
3627 capa
->probe_resp_offloads
= probe_resp_offload_support(protocols
);
3631 static int wiphy_info_handler(struct nl_msg
*msg
, void *arg
)
3633 struct nlattr
*tb
[NL80211_ATTR_MAX
+ 1];
3634 struct genlmsghdr
*gnlh
= nlmsg_data(nlmsg_hdr(msg
));
3635 struct wiphy_info_data
*info
= arg
;
3636 struct wpa_driver_capa
*capa
= info
->capa
;
3637 struct wpa_driver_nl80211_data
*drv
= info
->drv
;
3639 nla_parse(tb
, NL80211_ATTR_MAX
, genlmsg_attrdata(gnlh
, 0),
3640 genlmsg_attrlen(gnlh
, 0), NULL
);
3642 if (tb
[NL80211_ATTR_WIPHY_NAME
])
3643 os_strlcpy(drv
->phyname
,
3644 nla_get_string(tb
[NL80211_ATTR_WIPHY_NAME
]),
3645 sizeof(drv
->phyname
));
3646 if (tb
[NL80211_ATTR_MAX_NUM_SCAN_SSIDS
])
3647 capa
->max_scan_ssids
=
3648 nla_get_u8(tb
[NL80211_ATTR_MAX_NUM_SCAN_SSIDS
]);
3650 if (tb
[NL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDS
])
3651 capa
->max_sched_scan_ssids
=
3652 nla_get_u8(tb
[NL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDS
]);
3654 if (tb
[NL80211_ATTR_MAX_MATCH_SETS
])
3655 capa
->max_match_sets
=
3656 nla_get_u8(tb
[NL80211_ATTR_MAX_MATCH_SETS
]);
3658 if (tb
[NL80211_ATTR_MAC_ACL_MAX
])
3659 capa
->max_acl_mac_addrs
=
3660 nla_get_u8(tb
[NL80211_ATTR_MAC_ACL_MAX
]);
3662 wiphy_info_supported_iftypes(info
, tb
[NL80211_ATTR_SUPPORTED_IFTYPES
]);
3663 wiphy_info_iface_comb(info
, tb
[NL80211_ATTR_INTERFACE_COMBINATIONS
]);
3664 wiphy_info_supp_cmds(info
, tb
[NL80211_ATTR_SUPPORTED_COMMANDS
]);
3665 wiphy_info_cipher_suites(info
, tb
[NL80211_ATTR_CIPHER_SUITES
]);
3667 if (tb
[NL80211_ATTR_OFFCHANNEL_TX_OK
]) {
3668 wpa_printf(MSG_DEBUG
, "nl80211: Using driver-based "
3670 capa
->flags
|= WPA_DRIVER_FLAGS_OFFCHANNEL_TX
;
3673 if (tb
[NL80211_ATTR_ROAM_SUPPORT
]) {
3674 wpa_printf(MSG_DEBUG
, "nl80211: Using driver-based roaming");
3675 capa
->flags
|= WPA_DRIVER_FLAGS_BSS_SELECTION
;
3678 wiphy_info_max_roc(capa
,
3679 tb
[NL80211_ATTR_MAX_REMAIN_ON_CHANNEL_DURATION
]);
3681 if (tb
[NL80211_ATTR_SUPPORT_AP_UAPSD
])
3682 capa
->flags
|= WPA_DRIVER_FLAGS_AP_UAPSD
;
3684 wiphy_info_tdls(capa
, tb
[NL80211_ATTR_TDLS_SUPPORT
],
3685 tb
[NL80211_ATTR_TDLS_EXTERNAL_SETUP
]);
3687 if (tb
[NL80211_ATTR_DEVICE_AP_SME
])
3688 info
->device_ap_sme
= 1;
3690 wiphy_info_feature_flags(info
, tb
[NL80211_ATTR_FEATURE_FLAGS
]);
3691 wiphy_info_probe_resp_offload(capa
,
3692 tb
[NL80211_ATTR_PROBE_RESP_OFFLOAD
]);
3694 if (tb
[NL80211_ATTR_EXT_CAPA
] && tb
[NL80211_ATTR_EXT_CAPA_MASK
] &&
3695 drv
->extended_capa
== NULL
) {
3696 drv
->extended_capa
=
3697 os_malloc(nla_len(tb
[NL80211_ATTR_EXT_CAPA
]));
3698 if (drv
->extended_capa
) {
3699 os_memcpy(drv
->extended_capa
,
3700 nla_data(tb
[NL80211_ATTR_EXT_CAPA
]),
3701 nla_len(tb
[NL80211_ATTR_EXT_CAPA
]));
3702 drv
->extended_capa_len
=
3703 nla_len(tb
[NL80211_ATTR_EXT_CAPA
]);
3705 drv
->extended_capa_mask
=
3706 os_malloc(nla_len(tb
[NL80211_ATTR_EXT_CAPA
]));
3707 if (drv
->extended_capa_mask
) {
3708 os_memcpy(drv
->extended_capa_mask
,
3709 nla_data(tb
[NL80211_ATTR_EXT_CAPA
]),
3710 nla_len(tb
[NL80211_ATTR_EXT_CAPA
]));
3712 os_free(drv
->extended_capa
);
3713 drv
->extended_capa
= NULL
;
3714 drv
->extended_capa_len
= 0;
3718 if (tb
[NL80211_ATTR_VENDOR_DATA
]) {
3722 nla_for_each_nested(nl
, tb
[NL80211_ATTR_VENDOR_DATA
], rem
) {
3723 struct nl80211_vendor_cmd_info
*vinfo
;
3724 if (nla_len(nl
) != sizeof(*vinfo
)) {
3725 wpa_printf(MSG_DEBUG
, "nl80211: Unexpected vendor data info");
3728 vinfo
= nla_data(nl
);
3729 if (vinfo
->subcmd
==
3730 QCA_NL80211_VENDOR_SUBCMD_DFS_CAPABILITY
)
3731 drv
->dfs_vendor_cmd_avail
= 1;
3733 wpa_printf(MSG_DEBUG
, "nl80211: Supported vendor command: vendor_id=0x%x subcmd=%u",
3734 vinfo
->vendor_id
, vinfo
->subcmd
);
3738 if (tb
[NL80211_ATTR_VENDOR_EVENTS
]) {
3742 nla_for_each_nested(nl
, tb
[NL80211_ATTR_VENDOR_EVENTS
], rem
) {
3743 struct nl80211_vendor_cmd_info
*vinfo
;
3744 if (nla_len(nl
) != sizeof(*vinfo
)) {
3745 wpa_printf(MSG_DEBUG
, "nl80211: Unexpected vendor data info");
3748 vinfo
= nla_data(nl
);
3749 wpa_printf(MSG_DEBUG
, "nl80211: Supported vendor event: vendor_id=0x%x subcmd=%u",
3750 vinfo
->vendor_id
, vinfo
->subcmd
);
3758 static int wpa_driver_nl80211_get_info(struct wpa_driver_nl80211_data
*drv
,
3759 struct wiphy_info_data
*info
)
3764 os_memset(info
, 0, sizeof(*info
));
3765 info
->capa
= &drv
->capa
;
3768 msg
= nlmsg_alloc();
3772 feat
= get_nl80211_protocol_features(drv
);
3773 if (feat
& NL80211_PROTOCOL_FEATURE_SPLIT_WIPHY_DUMP
)
3774 nl80211_cmd(drv
, msg
, NLM_F_DUMP
, NL80211_CMD_GET_WIPHY
);
3776 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_GET_WIPHY
);
3778 NLA_PUT_FLAG(msg
, NL80211_ATTR_SPLIT_WIPHY_DUMP
);
3779 if (nl80211_set_iface_id(msg
, drv
->first_bss
) < 0)
3780 goto nla_put_failure
;
3782 if (send_and_recv_msgs(drv
, msg
, wiphy_info_handler
, info
))
3785 if (info
->auth_supported
)
3786 drv
->capa
.flags
|= WPA_DRIVER_FLAGS_SME
;
3787 else if (!info
->connect_supported
) {
3788 wpa_printf(MSG_INFO
, "nl80211: Driver does not support "
3789 "authentication/association or connect commands");
3793 if (info
->p2p_go_supported
&& info
->p2p_client_supported
)
3794 drv
->capa
.flags
|= WPA_DRIVER_FLAGS_P2P_CAPABLE
;
3795 if (info
->p2p_concurrent
) {
3796 wpa_printf(MSG_DEBUG
, "nl80211: Use separate P2P group "
3797 "interface (driver advertised support)");
3798 drv
->capa
.flags
|= WPA_DRIVER_FLAGS_P2P_CONCURRENT
;
3799 drv
->capa
.flags
|= WPA_DRIVER_FLAGS_P2P_MGMT_AND_NON_P2P
;
3801 if (info
->num_multichan_concurrent
> 1) {
3802 wpa_printf(MSG_DEBUG
, "nl80211: Enable multi-channel "
3803 "concurrent (driver advertised support)");
3804 drv
->capa
.num_multichan_concurrent
=
3805 info
->num_multichan_concurrent
;
3808 /* default to 5000 since early versions of mac80211 don't set it */
3809 if (!drv
->capa
.max_remain_on_chan
)
3810 drv
->capa
.max_remain_on_chan
= 5000;
3812 if (info
->channel_switch_supported
)
3813 drv
->capa
.flags
|= WPA_DRIVER_FLAGS_AP_CSA
;
3822 static int wpa_driver_nl80211_capa(struct wpa_driver_nl80211_data
*drv
)
3824 struct wiphy_info_data info
;
3825 if (wpa_driver_nl80211_get_info(drv
, &info
))
3831 drv
->has_capability
= 1;
3832 drv
->capa
.key_mgmt
= WPA_DRIVER_CAPA_KEY_MGMT_WPA
|
3833 WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK
|
3834 WPA_DRIVER_CAPA_KEY_MGMT_WPA2
|
3835 WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK
;
3836 drv
->capa
.auth
= WPA_DRIVER_AUTH_OPEN
|
3837 WPA_DRIVER_AUTH_SHARED
|
3838 WPA_DRIVER_AUTH_LEAP
;
3840 drv
->capa
.flags
|= WPA_DRIVER_FLAGS_SANE_ERROR_CODES
;
3841 drv
->capa
.flags
|= WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC_DONE
;
3842 drv
->capa
.flags
|= WPA_DRIVER_FLAGS_EAPOL_TX_STATUS
;
3845 * As all cfg80211 drivers must support cases where the AP interface is
3846 * removed without the knowledge of wpa_supplicant/hostapd, e.g., in
3847 * case that the user space daemon has crashed, they must be able to
3848 * cleanup all stations and key entries in the AP tear down flow. Thus,
3849 * this flag can/should always be set for cfg80211 drivers.
3851 drv
->capa
.flags
|= WPA_DRIVER_FLAGS_AP_TEARDOWN_SUPPORT
;
3853 if (!info
.device_ap_sme
) {
3854 drv
->capa
.flags
|= WPA_DRIVER_FLAGS_DEAUTH_TX_STATUS
;
3857 * No AP SME is currently assumed to also indicate no AP MLME
3858 * in the driver/firmware.
3860 drv
->capa
.flags
|= WPA_DRIVER_FLAGS_AP_MLME
;
3863 drv
->device_ap_sme
= info
.device_ap_sme
;
3864 drv
->poll_command_supported
= info
.poll_command_supported
;
3865 drv
->data_tx_status
= info
.data_tx_status
;
3866 if (info
.set_qos_map_supported
)
3867 drv
->capa
.flags
|= WPA_DRIVER_FLAGS_QOS_MAPPING
;
3870 * If poll command and tx status are supported, mac80211 is new enough
3871 * to have everything we need to not need monitor interfaces.
3873 drv
->use_monitor
= !info
.poll_command_supported
|| !info
.data_tx_status
;
3875 if (drv
->device_ap_sme
&& drv
->use_monitor
) {
3877 * Non-mac80211 drivers may not support monitor interface.
3878 * Make sure we do not get stuck with incorrect capability here
3879 * by explicitly testing this.
3881 if (!info
.monitor_supported
) {
3882 wpa_printf(MSG_DEBUG
, "nl80211: Disable use_monitor "
3883 "with device_ap_sme since no monitor mode "
3884 "support detected");
3885 drv
->use_monitor
= 0;
3890 * If we aren't going to use monitor interfaces, but the
3891 * driver doesn't support data TX status, we won't get TX
3892 * status for EAPOL frames.
3894 if (!drv
->use_monitor
&& !info
.data_tx_status
)
3895 drv
->capa
.flags
&= ~WPA_DRIVER_FLAGS_EAPOL_TX_STATUS
;
3902 static int android_genl_ctrl_resolve(struct nl_handle
*handle
,
3906 * Android ICS has very minimal genl_ctrl_resolve() implementation, so
3907 * need to work around that.
3909 struct nl_cache
*cache
= NULL
;
3910 struct genl_family
*nl80211
= NULL
;
3913 if (genl_ctrl_alloc_cache(handle
, &cache
) < 0) {
3914 wpa_printf(MSG_ERROR
, "nl80211: Failed to allocate generic "
3919 nl80211
= genl_ctrl_search_by_name(cache
, name
);
3920 if (nl80211
== NULL
)
3923 id
= genl_family_get_id(nl80211
);
3927 genl_family_put(nl80211
);
3929 nl_cache_free(cache
);
3933 #define genl_ctrl_resolve android_genl_ctrl_resolve
3934 #endif /* ANDROID */
3937 static int wpa_driver_nl80211_init_nl_global(struct nl80211_global
*global
)
3941 global
->nl_cb
= nl_cb_alloc(NL_CB_DEFAULT
);
3942 if (global
->nl_cb
== NULL
) {
3943 wpa_printf(MSG_ERROR
, "nl80211: Failed to allocate netlink "
3948 global
->nl
= nl_create_handle(global
->nl_cb
, "nl");
3949 if (global
->nl
== NULL
)
3952 global
->nl80211_id
= genl_ctrl_resolve(global
->nl
, "nl80211");
3953 if (global
->nl80211_id
< 0) {
3954 wpa_printf(MSG_ERROR
, "nl80211: 'nl80211' generic netlink not "
3959 global
->nl_event
= nl_create_handle(global
->nl_cb
, "event");
3960 if (global
->nl_event
== NULL
)
3963 ret
= nl_get_multicast_id(global
, "nl80211", "scan");
3965 ret
= nl_socket_add_membership(global
->nl_event
, ret
);
3967 wpa_printf(MSG_ERROR
, "nl80211: Could not add multicast "
3968 "membership for scan events: %d (%s)",
3969 ret
, strerror(-ret
));
3973 ret
= nl_get_multicast_id(global
, "nl80211", "mlme");
3975 ret
= nl_socket_add_membership(global
->nl_event
, ret
);
3977 wpa_printf(MSG_ERROR
, "nl80211: Could not add multicast "
3978 "membership for mlme events: %d (%s)",
3979 ret
, strerror(-ret
));
3983 ret
= nl_get_multicast_id(global
, "nl80211", "regulatory");
3985 ret
= nl_socket_add_membership(global
->nl_event
, ret
);
3987 wpa_printf(MSG_DEBUG
, "nl80211: Could not add multicast "
3988 "membership for regulatory events: %d (%s)",
3989 ret
, strerror(-ret
));
3990 /* Continue without regulatory events */
3993 ret
= nl_get_multicast_id(global
, "nl80211", "vendor");
3995 ret
= nl_socket_add_membership(global
->nl_event
, ret
);
3997 wpa_printf(MSG_DEBUG
, "nl80211: Could not add multicast "
3998 "membership for vendor events: %d (%s)",
3999 ret
, strerror(-ret
));
4000 /* Continue without vendor events */
4003 nl_cb_set(global
->nl_cb
, NL_CB_SEQ_CHECK
, NL_CB_CUSTOM
,
4004 no_seq_check
, NULL
);
4005 nl_cb_set(global
->nl_cb
, NL_CB_VALID
, NL_CB_CUSTOM
,
4006 process_global_event
, global
);
4008 nl80211_register_eloop_read(&global
->nl_event
,
4009 wpa_driver_nl80211_event_receive
,
4015 nl_destroy_handles(&global
->nl_event
);
4016 nl_destroy_handles(&global
->nl
);
4017 nl_cb_put(global
->nl_cb
);
4018 global
->nl_cb
= NULL
;
4023 static int wpa_driver_nl80211_init_nl(struct wpa_driver_nl80211_data
*drv
)
4025 drv
->nl_cb
= nl_cb_alloc(NL_CB_DEFAULT
);
4027 wpa_printf(MSG_ERROR
, "nl80211: Failed to alloc cb struct");
4031 nl_cb_set(drv
->nl_cb
, NL_CB_SEQ_CHECK
, NL_CB_CUSTOM
,
4032 no_seq_check
, NULL
);
4033 nl_cb_set(drv
->nl_cb
, NL_CB_VALID
, NL_CB_CUSTOM
,
4034 process_drv_event
, drv
);
4040 static void wpa_driver_nl80211_rfkill_blocked(void *ctx
)
4042 wpa_printf(MSG_DEBUG
, "nl80211: RFKILL blocked");
4044 * This may be for any interface; use ifdown event to disable
4050 static void wpa_driver_nl80211_rfkill_unblocked(void *ctx
)
4052 struct wpa_driver_nl80211_data
*drv
= ctx
;
4053 wpa_printf(MSG_DEBUG
, "nl80211: RFKILL unblocked");
4054 if (i802_set_iface_flags(drv
->first_bss
, 1)) {
4055 wpa_printf(MSG_DEBUG
, "nl80211: Could not set interface UP "
4056 "after rfkill unblock");
4059 /* rtnetlink ifup handler will report interface as enabled */
4063 static void wpa_driver_nl80211_handle_eapol_tx_status(int sock
,
4067 struct wpa_driver_nl80211_data
*drv
= eloop_ctx
;
4072 struct cmsghdr
*cmsg
;
4073 int res
, found_ee
= 0, found_wifi
= 0, acked
= 0;
4074 union wpa_event_data event
;
4076 memset(&msg
, 0, sizeof(msg
));
4077 msg
.msg_iov
= &entry
;
4079 entry
.iov_base
= data
;
4080 entry
.iov_len
= sizeof(data
);
4081 msg
.msg_control
= &control
;
4082 msg
.msg_controllen
= sizeof(control
);
4084 res
= recvmsg(sock
, &msg
, MSG_ERRQUEUE
);
4085 /* if error or not fitting 802.3 header, return */
4089 for (cmsg
= CMSG_FIRSTHDR(&msg
); cmsg
; cmsg
= CMSG_NXTHDR(&msg
, cmsg
))
4091 if (cmsg
->cmsg_level
== SOL_SOCKET
&&
4092 cmsg
->cmsg_type
== SCM_WIFI_STATUS
) {
4096 ack
= (void *)CMSG_DATA(cmsg
);
4100 if (cmsg
->cmsg_level
== SOL_PACKET
&&
4101 cmsg
->cmsg_type
== PACKET_TX_TIMESTAMP
) {
4102 struct sock_extended_err
*err
=
4103 (struct sock_extended_err
*)CMSG_DATA(cmsg
);
4105 if (err
->ee_origin
== SO_EE_ORIGIN_TXSTATUS
)
4110 if (!found_ee
|| !found_wifi
)
4113 memset(&event
, 0, sizeof(event
));
4114 event
.eapol_tx_status
.dst
= data
;
4115 event
.eapol_tx_status
.data
= data
+ 14;
4116 event
.eapol_tx_status
.data_len
= res
- 14;
4117 event
.eapol_tx_status
.ack
= acked
;
4118 wpa_supplicant_event(drv
->ctx
, EVENT_EAPOL_TX_STATUS
, &event
);
4122 static int nl80211_init_bss(struct i802_bss
*bss
)
4124 bss
->nl_cb
= nl_cb_alloc(NL_CB_DEFAULT
);
4128 nl_cb_set(bss
->nl_cb
, NL_CB_SEQ_CHECK
, NL_CB_CUSTOM
,
4129 no_seq_check
, NULL
);
4130 nl_cb_set(bss
->nl_cb
, NL_CB_VALID
, NL_CB_CUSTOM
,
4131 process_bss_event
, bss
);
4137 static void nl80211_destroy_bss(struct i802_bss
*bss
)
4139 nl_cb_put(bss
->nl_cb
);
4144 static void * wpa_driver_nl80211_drv_init(void *ctx
, const char *ifname
,
4145 void *global_priv
, int hostapd
,
4148 struct wpa_driver_nl80211_data
*drv
;
4149 struct rfkill_config
*rcfg
;
4150 struct i802_bss
*bss
;
4152 if (global_priv
== NULL
)
4154 drv
= os_zalloc(sizeof(*drv
));
4157 drv
->global
= global_priv
;
4159 drv
->hostapd
= !!hostapd
;
4160 drv
->eapol_sock
= -1;
4161 drv
->num_if_indices
= sizeof(drv
->default_if_indices
) / sizeof(int);
4162 drv
->if_indices
= drv
->default_if_indices
;
4164 drv
->first_bss
= os_zalloc(sizeof(*drv
->first_bss
));
4165 if (!drv
->first_bss
) {
4169 bss
= drv
->first_bss
;
4173 os_strlcpy(bss
->ifname
, ifname
, sizeof(bss
->ifname
));
4174 drv
->monitor_ifidx
= -1;
4175 drv
->monitor_sock
= -1;
4176 drv
->eapol_tx_sock
= -1;
4177 drv
->ap_scan_as_station
= NL80211_IFTYPE_UNSPECIFIED
;
4179 if (wpa_driver_nl80211_init_nl(drv
)) {
4184 if (nl80211_init_bss(bss
))
4187 rcfg
= os_zalloc(sizeof(*rcfg
));
4191 os_strlcpy(rcfg
->ifname
, ifname
, sizeof(rcfg
->ifname
));
4192 rcfg
->blocked_cb
= wpa_driver_nl80211_rfkill_blocked
;
4193 rcfg
->unblocked_cb
= wpa_driver_nl80211_rfkill_unblocked
;
4194 drv
->rfkill
= rfkill_init(rcfg
);
4195 if (drv
->rfkill
== NULL
) {
4196 wpa_printf(MSG_DEBUG
, "nl80211: RFKILL status not available");
4200 if (linux_iface_up(drv
->global
->ioctl_sock
, ifname
) > 0)
4201 drv
->start_iface_up
= 1;
4203 if (wpa_driver_nl80211_finish_drv_init(drv
, set_addr
, 1))
4206 drv
->eapol_tx_sock
= socket(PF_PACKET
, SOCK_DGRAM
, 0);
4207 if (drv
->eapol_tx_sock
< 0)
4210 if (drv
->data_tx_status
) {
4213 if (setsockopt(drv
->eapol_tx_sock
, SOL_SOCKET
, SO_WIFI_STATUS
,
4214 &enabled
, sizeof(enabled
)) < 0) {
4215 wpa_printf(MSG_DEBUG
,
4216 "nl80211: wifi status sockopt failed\n");
4217 drv
->data_tx_status
= 0;
4218 if (!drv
->use_monitor
)
4220 ~WPA_DRIVER_FLAGS_EAPOL_TX_STATUS
;
4222 eloop_register_read_sock(drv
->eapol_tx_sock
,
4223 wpa_driver_nl80211_handle_eapol_tx_status
,
4229 dl_list_add(&drv
->global
->interfaces
, &drv
->list
);
4230 drv
->in_interface_list
= 1;
4236 wpa_driver_nl80211_deinit(bss
);
4242 * wpa_driver_nl80211_init - Initialize nl80211 driver interface
4243 * @ctx: context to be used when calling wpa_supplicant functions,
4244 * e.g., wpa_supplicant_event()
4245 * @ifname: interface name, e.g., wlan0
4246 * @global_priv: private driver global data from global_init()
4247 * Returns: Pointer to private data, %NULL on failure
4249 static void * wpa_driver_nl80211_init(void *ctx
, const char *ifname
,
4252 return wpa_driver_nl80211_drv_init(ctx
, ifname
, global_priv
, 0, NULL
);
4256 static int nl80211_register_frame(struct i802_bss
*bss
,
4257 struct nl_handle
*nl_handle
,
4258 u16 type
, const u8
*match
, size_t match_len
)
4260 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
4265 msg
= nlmsg_alloc();
4270 wpa_snprintf_hex(buf
, sizeof(buf
), match
, match_len
);
4271 wpa_printf(MSG_DEBUG
, "nl80211: Register frame type=0x%x nl_handle=%p match=%s",
4272 type
, nl_handle
, buf
);
4274 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_REGISTER_ACTION
);
4276 if (nl80211_set_iface_id(msg
, bss
) < 0)
4277 goto nla_put_failure
;
4279 NLA_PUT_U16(msg
, NL80211_ATTR_FRAME_TYPE
, type
);
4280 NLA_PUT(msg
, NL80211_ATTR_FRAME_MATCH
, match_len
, match
);
4282 ret
= send_and_recv(drv
->global
, nl_handle
, msg
, NULL
, NULL
);
4285 wpa_printf(MSG_DEBUG
, "nl80211: Register frame command "
4286 "failed (type=%u): ret=%d (%s)",
4287 type
, ret
, strerror(-ret
));
4288 wpa_hexdump(MSG_DEBUG
, "nl80211: Register frame match",
4290 goto nla_put_failure
;
4299 static int nl80211_alloc_mgmt_handle(struct i802_bss
*bss
)
4301 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
4304 wpa_printf(MSG_DEBUG
, "nl80211: Mgmt reporting "
4305 "already on! (nl_mgmt=%p)", bss
->nl_mgmt
);
4309 bss
->nl_mgmt
= nl_create_handle(drv
->nl_cb
, "mgmt");
4310 if (bss
->nl_mgmt
== NULL
)
4317 static void nl80211_mgmt_handle_register_eloop(struct i802_bss
*bss
)
4319 nl80211_register_eloop_read(&bss
->nl_mgmt
,
4320 wpa_driver_nl80211_event_receive
,
4325 static int nl80211_register_action_frame(struct i802_bss
*bss
,
4326 const u8
*match
, size_t match_len
)
4328 u16 type
= (WLAN_FC_TYPE_MGMT
<< 2) | (WLAN_FC_STYPE_ACTION
<< 4);
4329 return nl80211_register_frame(bss
, bss
->nl_mgmt
,
4330 type
, match
, match_len
);
4334 static int nl80211_mgmt_subscribe_non_ap(struct i802_bss
*bss
)
4336 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
4339 if (nl80211_alloc_mgmt_handle(bss
))
4341 wpa_printf(MSG_DEBUG
, "nl80211: Subscribe to mgmt frames with non-AP "
4342 "handle %p", bss
->nl_mgmt
);
4344 if (drv
->nlmode
== NL80211_IFTYPE_ADHOC
) {
4345 u16 type
= (WLAN_FC_TYPE_MGMT
<< 2) | (WLAN_FC_STYPE_AUTH
<< 4);
4347 /* register for any AUTH message */
4348 nl80211_register_frame(bss
, bss
->nl_mgmt
, type
, NULL
, 0);
4351 #ifdef CONFIG_INTERWORKING
4352 /* QoS Map Configure */
4353 if (nl80211_register_action_frame(bss
, (u8
*) "\x01\x04", 2) < 0)
4355 #endif /* CONFIG_INTERWORKING */
4356 #if defined(CONFIG_P2P) || defined(CONFIG_INTERWORKING)
4357 /* GAS Initial Request */
4358 if (nl80211_register_action_frame(bss
, (u8
*) "\x04\x0a", 2) < 0)
4360 /* GAS Initial Response */
4361 if (nl80211_register_action_frame(bss
, (u8
*) "\x04\x0b", 2) < 0)
4363 /* GAS Comeback Request */
4364 if (nl80211_register_action_frame(bss
, (u8
*) "\x04\x0c", 2) < 0)
4366 /* GAS Comeback Response */
4367 if (nl80211_register_action_frame(bss
, (u8
*) "\x04\x0d", 2) < 0)
4369 /* Protected GAS Initial Request */
4370 if (nl80211_register_action_frame(bss
, (u8
*) "\x09\x0a", 2) < 0)
4372 /* Protected GAS Initial Response */
4373 if (nl80211_register_action_frame(bss
, (u8
*) "\x09\x0b", 2) < 0)
4375 /* Protected GAS Comeback Request */
4376 if (nl80211_register_action_frame(bss
, (u8
*) "\x09\x0c", 2) < 0)
4378 /* Protected GAS Comeback Response */
4379 if (nl80211_register_action_frame(bss
, (u8
*) "\x09\x0d", 2) < 0)
4381 #endif /* CONFIG_P2P || CONFIG_INTERWORKING */
4383 /* P2P Public Action */
4384 if (nl80211_register_action_frame(bss
,
4385 (u8
*) "\x04\x09\x50\x6f\x9a\x09",
4389 if (nl80211_register_action_frame(bss
,
4390 (u8
*) "\x7f\x50\x6f\x9a\x09",
4393 #endif /* CONFIG_P2P */
4394 #ifdef CONFIG_IEEE80211W
4395 /* SA Query Response */
4396 if (nl80211_register_action_frame(bss
, (u8
*) "\x08\x01", 2) < 0)
4398 #endif /* CONFIG_IEEE80211W */
4400 if ((drv
->capa
.flags
& WPA_DRIVER_FLAGS_TDLS_SUPPORT
)) {
4401 /* TDLS Discovery Response */
4402 if (nl80211_register_action_frame(bss
, (u8
*) "\x04\x0e", 2) <
4406 #endif /* CONFIG_TDLS */
4408 /* FT Action frames */
4409 if (nl80211_register_action_frame(bss
, (u8
*) "\x06", 1) < 0)
4412 drv
->capa
.key_mgmt
|= WPA_DRIVER_CAPA_KEY_MGMT_FT
|
4413 WPA_DRIVER_CAPA_KEY_MGMT_FT_PSK
;
4415 /* WNM - BSS Transition Management Request */
4416 if (nl80211_register_action_frame(bss
, (u8
*) "\x0a\x07", 2) < 0)
4418 /* WNM-Sleep Mode Response */
4419 if (nl80211_register_action_frame(bss
, (u8
*) "\x0a\x11", 2) < 0)
4423 /* WNM-Notification */
4424 if (nl80211_register_action_frame(bss
, (u8
*) "\x0a\x1a", 2) < 0)
4426 #endif /* CONFIG_HS20 */
4428 nl80211_mgmt_handle_register_eloop(bss
);
4434 static int nl80211_register_spurious_class3(struct i802_bss
*bss
)
4436 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
4440 msg
= nlmsg_alloc();
4444 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_UNEXPECTED_FRAME
);
4446 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, bss
->ifindex
);
4448 ret
= send_and_recv(drv
->global
, bss
->nl_mgmt
, msg
, NULL
, NULL
);
4451 wpa_printf(MSG_DEBUG
, "nl80211: Register spurious class3 "
4452 "failed: ret=%d (%s)",
4453 ret
, strerror(-ret
));
4454 goto nla_put_failure
;
4463 static int nl80211_mgmt_subscribe_ap(struct i802_bss
*bss
)
4465 static const int stypes
[] = {
4467 WLAN_FC_STYPE_ASSOC_REQ
,
4468 WLAN_FC_STYPE_REASSOC_REQ
,
4469 WLAN_FC_STYPE_DISASSOC
,
4470 WLAN_FC_STYPE_DEAUTH
,
4471 WLAN_FC_STYPE_ACTION
,
4472 WLAN_FC_STYPE_PROBE_REQ
,
4473 /* Beacon doesn't work as mac80211 doesn't currently allow
4474 * it, but it wouldn't really be the right thing anyway as
4475 * it isn't per interface ... maybe just dump the scan
4476 * results periodically for OLBC?
4478 // WLAN_FC_STYPE_BEACON,
4482 if (nl80211_alloc_mgmt_handle(bss
))
4484 wpa_printf(MSG_DEBUG
, "nl80211: Subscribe to mgmt frames with AP "
4485 "handle %p", bss
->nl_mgmt
);
4487 for (i
= 0; i
< ARRAY_SIZE(stypes
); i
++) {
4488 if (nl80211_register_frame(bss
, bss
->nl_mgmt
,
4489 (WLAN_FC_TYPE_MGMT
<< 2) |
4496 if (nl80211_register_spurious_class3(bss
))
4499 if (nl80211_get_wiphy_data_ap(bss
) == NULL
)
4502 nl80211_mgmt_handle_register_eloop(bss
);
4506 nl_destroy_handles(&bss
->nl_mgmt
);
4511 static int nl80211_mgmt_subscribe_ap_dev_sme(struct i802_bss
*bss
)
4513 if (nl80211_alloc_mgmt_handle(bss
))
4515 wpa_printf(MSG_DEBUG
, "nl80211: Subscribe to mgmt frames with AP "
4516 "handle %p (device SME)", bss
->nl_mgmt
);
4518 if (nl80211_register_frame(bss
, bss
->nl_mgmt
,
4519 (WLAN_FC_TYPE_MGMT
<< 2) |
4520 (WLAN_FC_STYPE_ACTION
<< 4),
4524 nl80211_mgmt_handle_register_eloop(bss
);
4528 nl_destroy_handles(&bss
->nl_mgmt
);
4533 static void nl80211_mgmt_unsubscribe(struct i802_bss
*bss
, const char *reason
)
4535 if (bss
->nl_mgmt
== NULL
)
4537 wpa_printf(MSG_DEBUG
, "nl80211: Unsubscribe mgmt frames handle %p "
4538 "(%s)", bss
->nl_mgmt
, reason
);
4539 nl80211_destroy_eloop_handle(&bss
->nl_mgmt
);
4541 nl80211_put_wiphy_data_ap(bss
);
4545 static void wpa_driver_nl80211_send_rfkill(void *eloop_ctx
, void *timeout_ctx
)
4547 wpa_supplicant_event(timeout_ctx
, EVENT_INTERFACE_DISABLED
, NULL
);
4551 static void nl80211_del_p2pdev(struct i802_bss
*bss
)
4553 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
4557 msg
= nlmsg_alloc();
4561 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_DEL_INTERFACE
);
4562 NLA_PUT_U64(msg
, NL80211_ATTR_WDEV
, bss
->wdev_id
);
4564 ret
= send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
4567 wpa_printf(MSG_DEBUG
, "nl80211: Delete P2P Device %s (0x%llx): %s",
4568 bss
->ifname
, (long long unsigned int) bss
->wdev_id
,
4576 static int nl80211_set_p2pdev(struct i802_bss
*bss
, int start
)
4578 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
4582 msg
= nlmsg_alloc();
4587 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_START_P2P_DEVICE
);
4589 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_STOP_P2P_DEVICE
);
4591 NLA_PUT_U64(msg
, NL80211_ATTR_WDEV
, bss
->wdev_id
);
4593 ret
= send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
4596 wpa_printf(MSG_DEBUG
, "nl80211: %s P2P Device %s (0x%llx): %s",
4597 start
? "Start" : "Stop",
4598 bss
->ifname
, (long long unsigned int) bss
->wdev_id
,
4607 static int i802_set_iface_flags(struct i802_bss
*bss
, int up
)
4609 enum nl80211_iftype nlmode
;
4611 nlmode
= nl80211_get_ifmode(bss
);
4612 if (nlmode
!= NL80211_IFTYPE_P2P_DEVICE
) {
4613 return linux_set_iface_flags(bss
->drv
->global
->ioctl_sock
,
4617 /* P2P Device has start/stop which is equivalent */
4618 return nl80211_set_p2pdev(bss
, up
);
4623 wpa_driver_nl80211_finish_drv_init(struct wpa_driver_nl80211_data
*drv
,
4624 const u8
*set_addr
, int first
)
4626 struct i802_bss
*bss
= drv
->first_bss
;
4627 int send_rfkill_event
= 0;
4628 enum nl80211_iftype nlmode
;
4630 drv
->ifindex
= if_nametoindex(bss
->ifname
);
4631 bss
->ifindex
= drv
->ifindex
;
4632 bss
->wdev_id
= drv
->global
->if_add_wdevid
;
4633 bss
->wdev_id_set
= drv
->global
->if_add_wdevid_set
;
4635 bss
->if_dynamic
= drv
->ifindex
== drv
->global
->if_add_ifindex
;
4636 bss
->if_dynamic
= bss
->if_dynamic
|| drv
->global
->if_add_wdevid_set
;
4637 drv
->global
->if_add_wdevid_set
= 0;
4639 if (wpa_driver_nl80211_capa(drv
))
4642 wpa_printf(MSG_DEBUG
, "nl80211: interface %s in phy %s",
4643 bss
->ifname
, drv
->phyname
);
4646 (linux_set_iface_flags(drv
->global
->ioctl_sock
, bss
->ifname
, 0) ||
4647 linux_set_ifhwaddr(drv
->global
->ioctl_sock
, bss
->ifname
,
4651 if (first
&& nl80211_get_ifmode(bss
) == NL80211_IFTYPE_AP
)
4652 drv
->start_mode_ap
= 1;
4655 nlmode
= NL80211_IFTYPE_AP
;
4656 else if (bss
->if_dynamic
)
4657 nlmode
= nl80211_get_ifmode(bss
);
4659 nlmode
= NL80211_IFTYPE_STATION
;
4661 if (wpa_driver_nl80211_set_mode(bss
, nlmode
) < 0) {
4662 wpa_printf(MSG_ERROR
, "nl80211: Could not configure driver mode");
4666 if (nlmode
== NL80211_IFTYPE_P2P_DEVICE
)
4667 nl80211_get_macaddr(bss
);
4669 if (!rfkill_is_blocked(drv
->rfkill
)) {
4670 int ret
= i802_set_iface_flags(bss
, 1);
4672 wpa_printf(MSG_ERROR
, "nl80211: Could not set "
4673 "interface '%s' UP", bss
->ifname
);
4676 if (nlmode
== NL80211_IFTYPE_P2P_DEVICE
)
4679 wpa_printf(MSG_DEBUG
, "nl80211: Could not yet enable "
4680 "interface '%s' due to rfkill", bss
->ifname
);
4681 if (nlmode
== NL80211_IFTYPE_P2P_DEVICE
)
4683 drv
->if_disabled
= 1;
4684 send_rfkill_event
= 1;
4688 netlink_send_oper_ifla(drv
->global
->netlink
, drv
->ifindex
,
4689 1, IF_OPER_DORMANT
);
4691 if (linux_get_ifhwaddr(drv
->global
->ioctl_sock
, bss
->ifname
,
4695 if (send_rfkill_event
) {
4696 eloop_register_timeout(0, 0, wpa_driver_nl80211_send_rfkill
,
4704 static int wpa_driver_nl80211_del_beacon(struct wpa_driver_nl80211_data
*drv
)
4708 msg
= nlmsg_alloc();
4712 wpa_printf(MSG_DEBUG
, "nl80211: Remove beacon (ifindex=%d)",
4714 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_DEL_BEACON
);
4715 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, drv
->ifindex
);
4717 return send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
4725 * wpa_driver_nl80211_deinit - Deinitialize nl80211 driver interface
4726 * @bss: Pointer to private nl80211 data from wpa_driver_nl80211_init()
4728 * Shut down driver interface and processing of driver events. Free
4729 * private data buffer if one was allocated in wpa_driver_nl80211_init().
4731 static void wpa_driver_nl80211_deinit(struct i802_bss
*bss
)
4733 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
4736 if (drv
->data_tx_status
)
4737 eloop_unregister_read_sock(drv
->eapol_tx_sock
);
4738 if (drv
->eapol_tx_sock
>= 0)
4739 close(drv
->eapol_tx_sock
);
4742 wpa_driver_nl80211_probe_req_report(bss
, 0);
4743 if (bss
->added_if_into_bridge
) {
4744 if (linux_br_del_if(drv
->global
->ioctl_sock
, bss
->brname
,
4746 wpa_printf(MSG_INFO
, "nl80211: Failed to remove "
4747 "interface %s from bridge %s: %s",
4748 bss
->ifname
, bss
->brname
, strerror(errno
));
4750 if (bss
->added_bridge
) {
4751 if (linux_br_del(drv
->global
->ioctl_sock
, bss
->brname
) < 0)
4752 wpa_printf(MSG_INFO
, "nl80211: Failed to remove "
4754 bss
->brname
, strerror(errno
));
4757 nl80211_remove_monitor_interface(drv
);
4759 if (is_ap_interface(drv
->nlmode
))
4760 wpa_driver_nl80211_del_beacon(drv
);
4762 if (drv
->eapol_sock
>= 0) {
4763 eloop_unregister_read_sock(drv
->eapol_sock
);
4764 close(drv
->eapol_sock
);
4767 if (drv
->if_indices
!= drv
->default_if_indices
)
4768 os_free(drv
->if_indices
);
4770 if (drv
->disabled_11b_rates
)
4771 nl80211_disable_11b_rates(drv
, drv
->ifindex
, 0);
4773 netlink_send_oper_ifla(drv
->global
->netlink
, drv
->ifindex
, 0,
4775 rfkill_deinit(drv
->rfkill
);
4777 eloop_cancel_timeout(wpa_driver_nl80211_scan_timeout
, drv
, drv
->ctx
);
4779 if (!drv
->start_iface_up
)
4780 (void) i802_set_iface_flags(bss
, 0);
4781 if (drv
->nlmode
!= NL80211_IFTYPE_P2P_DEVICE
) {
4782 if (!drv
->hostapd
|| !drv
->start_mode_ap
)
4783 wpa_driver_nl80211_set_mode(bss
,
4784 NL80211_IFTYPE_STATION
);
4785 nl80211_mgmt_unsubscribe(bss
, "deinit");
4787 nl80211_mgmt_unsubscribe(bss
, "deinit");
4788 nl80211_del_p2pdev(bss
);
4790 nl_cb_put(drv
->nl_cb
);
4792 nl80211_destroy_bss(drv
->first_bss
);
4794 os_free(drv
->filter_ssids
);
4796 os_free(drv
->auth_ie
);
4798 if (drv
->in_interface_list
)
4799 dl_list_del(&drv
->list
);
4801 os_free(drv
->extended_capa
);
4802 os_free(drv
->extended_capa_mask
);
4803 os_free(drv
->first_bss
);
4809 * wpa_driver_nl80211_scan_timeout - Scan timeout to report scan completion
4810 * @eloop_ctx: Driver private data
4811 * @timeout_ctx: ctx argument given to wpa_driver_nl80211_init()
4813 * This function can be used as registered timeout when starting a scan to
4814 * generate a scan completed event if the driver does not report this.
4816 static void wpa_driver_nl80211_scan_timeout(void *eloop_ctx
, void *timeout_ctx
)
4818 struct wpa_driver_nl80211_data
*drv
= eloop_ctx
;
4819 if (drv
->ap_scan_as_station
!= NL80211_IFTYPE_UNSPECIFIED
) {
4820 wpa_driver_nl80211_set_mode(drv
->first_bss
,
4821 drv
->ap_scan_as_station
);
4822 drv
->ap_scan_as_station
= NL80211_IFTYPE_UNSPECIFIED
;
4824 wpa_printf(MSG_DEBUG
, "Scan timeout - try to get results");
4825 wpa_supplicant_event(timeout_ctx
, EVENT_SCAN_RESULTS
, NULL
);
4829 static struct nl_msg
*
4830 nl80211_scan_common(struct wpa_driver_nl80211_data
*drv
, u8 cmd
,
4831 struct wpa_driver_scan_params
*params
, u64
*wdev_id
)
4836 msg
= nlmsg_alloc();
4840 nl80211_cmd(drv
, msg
, 0, cmd
);
4843 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, drv
->ifindex
);
4845 NLA_PUT_U64(msg
, NL80211_ATTR_WDEV
, *wdev_id
);
4847 if (params
->num_ssids
) {
4848 struct nlattr
*ssids
;
4850 ssids
= nla_nest_start(msg
, NL80211_ATTR_SCAN_SSIDS
);
4853 for (i
= 0; i
< params
->num_ssids
; i
++) {
4854 wpa_hexdump_ascii(MSG_MSGDUMP
, "nl80211: Scan SSID",
4855 params
->ssids
[i
].ssid
,
4856 params
->ssids
[i
].ssid_len
);
4857 if (nla_put(msg
, i
+ 1, params
->ssids
[i
].ssid_len
,
4858 params
->ssids
[i
].ssid
) < 0)
4861 nla_nest_end(msg
, ssids
);
4864 if (params
->extra_ies
) {
4865 wpa_hexdump(MSG_MSGDUMP
, "nl80211: Scan extra IEs",
4866 params
->extra_ies
, params
->extra_ies_len
);
4867 if (nla_put(msg
, NL80211_ATTR_IE
, params
->extra_ies_len
,
4868 params
->extra_ies
) < 0)
4872 if (params
->freqs
) {
4873 struct nlattr
*freqs
;
4874 freqs
= nla_nest_start(msg
, NL80211_ATTR_SCAN_FREQUENCIES
);
4877 for (i
= 0; params
->freqs
[i
]; i
++) {
4878 wpa_printf(MSG_MSGDUMP
, "nl80211: Scan frequency %u "
4879 "MHz", params
->freqs
[i
]);
4880 if (nla_put_u32(msg
, i
+ 1, params
->freqs
[i
]) < 0)
4883 nla_nest_end(msg
, freqs
);
4886 os_free(drv
->filter_ssids
);
4887 drv
->filter_ssids
= params
->filter_ssids
;
4888 params
->filter_ssids
= NULL
;
4889 drv
->num_filter_ssids
= params
->num_filter_ssids
;
4891 if (params
->only_new_results
) {
4892 wpa_printf(MSG_DEBUG
, "nl80211: Add NL80211_SCAN_FLAG_FLUSH");
4893 NLA_PUT_U32(msg
, NL80211_ATTR_SCAN_FLAGS
,
4894 NL80211_SCAN_FLAG_FLUSH
);
4907 * wpa_driver_nl80211_scan - Request the driver to initiate scan
4908 * @bss: Pointer to private driver data from wpa_driver_nl80211_init()
4909 * @params: Scan parameters
4910 * Returns: 0 on success, -1 on failure
4912 static int wpa_driver_nl80211_scan(struct i802_bss
*bss
,
4913 struct wpa_driver_scan_params
*params
)
4915 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
4916 int ret
= -1, timeout
;
4917 struct nl_msg
*msg
= NULL
;
4919 wpa_dbg(drv
->ctx
, MSG_DEBUG
, "nl80211: scan request");
4920 drv
->scan_for_auth
= 0;
4922 msg
= nl80211_scan_common(drv
, NL80211_CMD_TRIGGER_SCAN
, params
,
4923 bss
->wdev_id_set
? &bss
->wdev_id
: NULL
);
4927 if (params
->p2p_probe
) {
4928 struct nlattr
*rates
;
4930 wpa_printf(MSG_DEBUG
, "nl80211: P2P probe - mask SuppRates");
4932 rates
= nla_nest_start(msg
, NL80211_ATTR_SCAN_SUPP_RATES
);
4934 goto nla_put_failure
;
4937 * Remove 2.4 GHz rates 1, 2, 5.5, 11 Mbps from supported rates
4938 * by masking out everything else apart from the OFDM rates 6,
4939 * 9, 12, 18, 24, 36, 48, 54 Mbps from non-MCS rates. All 5 GHz
4940 * rates are left enabled.
4942 NLA_PUT(msg
, NL80211_BAND_2GHZ
, 8,
4943 "\x0c\x12\x18\x24\x30\x48\x60\x6c");
4944 nla_nest_end(msg
, rates
);
4946 NLA_PUT_FLAG(msg
, NL80211_ATTR_TX_NO_CCK_RATE
);
4949 ret
= send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
4952 wpa_printf(MSG_DEBUG
, "nl80211: Scan trigger failed: ret=%d "
4953 "(%s)", ret
, strerror(-ret
));
4954 if (drv
->hostapd
&& is_ap_interface(drv
->nlmode
)) {
4955 enum nl80211_iftype old_mode
= drv
->nlmode
;
4958 * mac80211 does not allow scan requests in AP mode, so
4959 * try to do this in station mode.
4961 if (wpa_driver_nl80211_set_mode(
4962 bss
, NL80211_IFTYPE_STATION
))
4963 goto nla_put_failure
;
4965 if (wpa_driver_nl80211_scan(bss
, params
)) {
4966 wpa_driver_nl80211_set_mode(bss
, drv
->nlmode
);
4967 goto nla_put_failure
;
4970 /* Restore AP mode when processing scan results */
4971 drv
->ap_scan_as_station
= old_mode
;
4974 goto nla_put_failure
;
4977 drv
->scan_state
= SCAN_REQUESTED
;
4978 /* Not all drivers generate "scan completed" wireless event, so try to
4979 * read results after a timeout. */
4981 if (drv
->scan_complete_events
) {
4983 * The driver seems to deliver events to notify when scan is
4984 * complete, so use longer timeout to avoid race conditions
4985 * with scanning and following association request.
4989 wpa_printf(MSG_DEBUG
, "Scan requested (ret=%d) - scan timeout %d "
4990 "seconds", ret
, timeout
);
4991 eloop_cancel_timeout(wpa_driver_nl80211_scan_timeout
, drv
, drv
->ctx
);
4992 eloop_register_timeout(timeout
, 0, wpa_driver_nl80211_scan_timeout
,
5002 * wpa_driver_nl80211_sched_scan - Initiate a scheduled scan
5003 * @priv: Pointer to private driver data from wpa_driver_nl80211_init()
5004 * @params: Scan parameters
5005 * @interval: Interval between scan cycles in milliseconds
5006 * Returns: 0 on success, -1 on failure or if not supported
5008 static int wpa_driver_nl80211_sched_scan(void *priv
,
5009 struct wpa_driver_scan_params
*params
,
5012 struct i802_bss
*bss
= priv
;
5013 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
5018 wpa_dbg(drv
->ctx
, MSG_DEBUG
, "nl80211: sched_scan request");
5021 if (!drv
->capa
.sched_scan_supported
)
5022 return android_pno_start(bss
, params
);
5023 #endif /* ANDROID */
5025 msg
= nl80211_scan_common(drv
, NL80211_CMD_START_SCHED_SCAN
, params
,
5026 bss
->wdev_id_set
? &bss
->wdev_id
: NULL
);
5028 goto nla_put_failure
;
5030 NLA_PUT_U32(msg
, NL80211_ATTR_SCHED_SCAN_INTERVAL
, interval
);
5032 if ((drv
->num_filter_ssids
&&
5033 (int) drv
->num_filter_ssids
<= drv
->capa
.max_match_sets
) ||
5034 params
->filter_rssi
) {
5035 struct nlattr
*match_sets
;
5036 match_sets
= nla_nest_start(msg
, NL80211_ATTR_SCHED_SCAN_MATCH
);
5037 if (match_sets
== NULL
)
5038 goto nla_put_failure
;
5040 for (i
= 0; i
< drv
->num_filter_ssids
; i
++) {
5041 struct nlattr
*match_set_ssid
;
5042 wpa_hexdump_ascii(MSG_MSGDUMP
,
5043 "nl80211: Sched scan filter SSID",
5044 drv
->filter_ssids
[i
].ssid
,
5045 drv
->filter_ssids
[i
].ssid_len
);
5047 match_set_ssid
= nla_nest_start(msg
, i
+ 1);
5048 if (match_set_ssid
== NULL
)
5049 goto nla_put_failure
;
5050 NLA_PUT(msg
, NL80211_ATTR_SCHED_SCAN_MATCH_SSID
,
5051 drv
->filter_ssids
[i
].ssid_len
,
5052 drv
->filter_ssids
[i
].ssid
);
5053 if (params
->filter_rssi
)
5055 NL80211_SCHED_SCAN_MATCH_ATTR_RSSI
,
5056 params
->filter_rssi
);
5058 nla_nest_end(msg
, match_set_ssid
);
5062 * Due to backward compatibility code, newer kernels treat this
5063 * matchset (with only an RSSI filter) as the default for all
5064 * other matchsets, unless it's the only one, in which case the
5065 * matchset will actually allow all SSIDs above the RSSI.
5067 if (params
->filter_rssi
) {
5068 struct nlattr
*match_set_rssi
;
5069 match_set_rssi
= nla_nest_start(msg
, 0);
5070 if (match_set_rssi
== NULL
)
5071 goto nla_put_failure
;
5072 NLA_PUT_U32(msg
, NL80211_SCHED_SCAN_MATCH_ATTR_RSSI
,
5073 params
->filter_rssi
);
5074 wpa_printf(MSG_MSGDUMP
,
5075 "nl80211: Sched scan RSSI filter %d dBm",
5076 params
->filter_rssi
);
5077 nla_nest_end(msg
, match_set_rssi
);
5080 nla_nest_end(msg
, match_sets
);
5083 ret
= send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
5085 /* TODO: if we get an error here, we should fall back to normal scan */
5089 wpa_printf(MSG_DEBUG
, "nl80211: Sched scan start failed: "
5090 "ret=%d (%s)", ret
, strerror(-ret
));
5091 goto nla_put_failure
;
5094 wpa_printf(MSG_DEBUG
, "nl80211: Sched scan requested (ret=%d) - "
5095 "scan interval %d msec", ret
, interval
);
5104 * wpa_driver_nl80211_stop_sched_scan - Stop a scheduled scan
5105 * @priv: Pointer to private driver data from wpa_driver_nl80211_init()
5106 * Returns: 0 on success, -1 on failure or if not supported
5108 static int wpa_driver_nl80211_stop_sched_scan(void *priv
)
5110 struct i802_bss
*bss
= priv
;
5111 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
5116 if (!drv
->capa
.sched_scan_supported
)
5117 return android_pno_stop(bss
);
5118 #endif /* ANDROID */
5120 msg
= nlmsg_alloc();
5124 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_STOP_SCHED_SCAN
);
5126 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, drv
->ifindex
);
5128 ret
= send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
5131 wpa_printf(MSG_DEBUG
, "nl80211: Sched scan stop failed: "
5132 "ret=%d (%s)", ret
, strerror(-ret
));
5133 goto nla_put_failure
;
5136 wpa_printf(MSG_DEBUG
, "nl80211: Sched scan stop sent (ret=%d)", ret
);
5144 static const u8
* nl80211_get_ie(const u8
*ies
, size_t ies_len
, u8 ie
)
5146 const u8
*end
, *pos
;
5152 end
= ies
+ ies_len
;
5154 while (pos
+ 1 < end
) {
5155 if (pos
+ 2 + pos
[1] > end
)
5166 static int nl80211_scan_filtered(struct wpa_driver_nl80211_data
*drv
,
5167 const u8
*ie
, size_t ie_len
)
5172 if (drv
->filter_ssids
== NULL
)
5175 ssid
= nl80211_get_ie(ie
, ie_len
, WLAN_EID_SSID
);
5179 for (i
= 0; i
< drv
->num_filter_ssids
; i
++) {
5180 if (ssid
[1] == drv
->filter_ssids
[i
].ssid_len
&&
5181 os_memcmp(ssid
+ 2, drv
->filter_ssids
[i
].ssid
, ssid
[1]) ==
5190 static int bss_info_handler(struct nl_msg
*msg
, void *arg
)
5192 struct nlattr
*tb
[NL80211_ATTR_MAX
+ 1];
5193 struct genlmsghdr
*gnlh
= nlmsg_data(nlmsg_hdr(msg
));
5194 struct nlattr
*bss
[NL80211_BSS_MAX
+ 1];
5195 static struct nla_policy bss_policy
[NL80211_BSS_MAX
+ 1] = {
5196 [NL80211_BSS_BSSID
] = { .type
= NLA_UNSPEC
},
5197 [NL80211_BSS_FREQUENCY
] = { .type
= NLA_U32
},
5198 [NL80211_BSS_TSF
] = { .type
= NLA_U64
},
5199 [NL80211_BSS_BEACON_INTERVAL
] = { .type
= NLA_U16
},
5200 [NL80211_BSS_CAPABILITY
] = { .type
= NLA_U16
},
5201 [NL80211_BSS_INFORMATION_ELEMENTS
] = { .type
= NLA_UNSPEC
},
5202 [NL80211_BSS_SIGNAL_MBM
] = { .type
= NLA_U32
},
5203 [NL80211_BSS_SIGNAL_UNSPEC
] = { .type
= NLA_U8
},
5204 [NL80211_BSS_STATUS
] = { .type
= NLA_U32
},
5205 [NL80211_BSS_SEEN_MS_AGO
] = { .type
= NLA_U32
},
5206 [NL80211_BSS_BEACON_IES
] = { .type
= NLA_UNSPEC
},
5208 struct nl80211_bss_info_arg
*_arg
= arg
;
5209 struct wpa_scan_results
*res
= _arg
->res
;
5210 struct wpa_scan_res
**tmp
;
5211 struct wpa_scan_res
*r
;
5212 const u8
*ie
, *beacon_ie
;
5213 size_t ie_len
, beacon_ie_len
;
5217 nla_parse(tb
, NL80211_ATTR_MAX
, genlmsg_attrdata(gnlh
, 0),
5218 genlmsg_attrlen(gnlh
, 0), NULL
);
5219 if (!tb
[NL80211_ATTR_BSS
])
5221 if (nla_parse_nested(bss
, NL80211_BSS_MAX
, tb
[NL80211_ATTR_BSS
],
5224 if (bss
[NL80211_BSS_STATUS
]) {
5225 enum nl80211_bss_status status
;
5226 status
= nla_get_u32(bss
[NL80211_BSS_STATUS
]);
5227 if (status
== NL80211_BSS_STATUS_ASSOCIATED
&&
5228 bss
[NL80211_BSS_FREQUENCY
]) {
5230 nla_get_u32(bss
[NL80211_BSS_FREQUENCY
]);
5231 wpa_printf(MSG_DEBUG
, "nl80211: Associated on %u MHz",
5234 if (status
== NL80211_BSS_STATUS_ASSOCIATED
&&
5235 bss
[NL80211_BSS_BSSID
]) {
5236 os_memcpy(_arg
->assoc_bssid
,
5237 nla_data(bss
[NL80211_BSS_BSSID
]), ETH_ALEN
);
5238 wpa_printf(MSG_DEBUG
, "nl80211: Associated with "
5239 MACSTR
, MAC2STR(_arg
->assoc_bssid
));
5244 if (bss
[NL80211_BSS_INFORMATION_ELEMENTS
]) {
5245 ie
= nla_data(bss
[NL80211_BSS_INFORMATION_ELEMENTS
]);
5246 ie_len
= nla_len(bss
[NL80211_BSS_INFORMATION_ELEMENTS
]);
5251 if (bss
[NL80211_BSS_BEACON_IES
]) {
5252 beacon_ie
= nla_data(bss
[NL80211_BSS_BEACON_IES
]);
5253 beacon_ie_len
= nla_len(bss
[NL80211_BSS_BEACON_IES
]);
5259 if (nl80211_scan_filtered(_arg
->drv
, ie
? ie
: beacon_ie
,
5260 ie
? ie_len
: beacon_ie_len
))
5263 r
= os_zalloc(sizeof(*r
) + ie_len
+ beacon_ie_len
);
5266 if (bss
[NL80211_BSS_BSSID
])
5267 os_memcpy(r
->bssid
, nla_data(bss
[NL80211_BSS_BSSID
]),
5269 if (bss
[NL80211_BSS_FREQUENCY
])
5270 r
->freq
= nla_get_u32(bss
[NL80211_BSS_FREQUENCY
]);
5271 if (bss
[NL80211_BSS_BEACON_INTERVAL
])
5272 r
->beacon_int
= nla_get_u16(bss
[NL80211_BSS_BEACON_INTERVAL
]);
5273 if (bss
[NL80211_BSS_CAPABILITY
])
5274 r
->caps
= nla_get_u16(bss
[NL80211_BSS_CAPABILITY
]);
5275 r
->flags
|= WPA_SCAN_NOISE_INVALID
;
5276 if (bss
[NL80211_BSS_SIGNAL_MBM
]) {
5277 r
->level
= nla_get_u32(bss
[NL80211_BSS_SIGNAL_MBM
]);
5278 r
->level
/= 100; /* mBm to dBm */
5279 r
->flags
|= WPA_SCAN_LEVEL_DBM
| WPA_SCAN_QUAL_INVALID
;
5280 } else if (bss
[NL80211_BSS_SIGNAL_UNSPEC
]) {
5281 r
->level
= nla_get_u8(bss
[NL80211_BSS_SIGNAL_UNSPEC
]);
5282 r
->flags
|= WPA_SCAN_QUAL_INVALID
;
5284 r
->flags
|= WPA_SCAN_LEVEL_INVALID
| WPA_SCAN_QUAL_INVALID
;
5285 if (bss
[NL80211_BSS_TSF
])
5286 r
->tsf
= nla_get_u64(bss
[NL80211_BSS_TSF
]);
5287 if (bss
[NL80211_BSS_SEEN_MS_AGO
])
5288 r
->age
= nla_get_u32(bss
[NL80211_BSS_SEEN_MS_AGO
]);
5290 pos
= (u8
*) (r
+ 1);
5292 os_memcpy(pos
, ie
, ie_len
);
5295 r
->beacon_ie_len
= beacon_ie_len
;
5297 os_memcpy(pos
, beacon_ie
, beacon_ie_len
);
5299 if (bss
[NL80211_BSS_STATUS
]) {
5300 enum nl80211_bss_status status
;
5301 status
= nla_get_u32(bss
[NL80211_BSS_STATUS
]);
5303 case NL80211_BSS_STATUS_AUTHENTICATED
:
5304 r
->flags
|= WPA_SCAN_AUTHENTICATED
;
5306 case NL80211_BSS_STATUS_ASSOCIATED
:
5307 r
->flags
|= WPA_SCAN_ASSOCIATED
;
5315 * cfg80211 maintains separate BSS table entries for APs if the same
5316 * BSSID,SSID pair is seen on multiple channels. wpa_supplicant does
5317 * not use frequency as a separate key in the BSS table, so filter out
5318 * duplicated entries. Prefer associated BSS entry in such a case in
5319 * order to get the correct frequency into the BSS table. Similarly,
5320 * prefer newer entries over older.
5322 for (i
= 0; i
< res
->num
; i
++) {
5324 if (os_memcmp(res
->res
[i
]->bssid
, r
->bssid
, ETH_ALEN
) != 0)
5327 s1
= nl80211_get_ie((u8
*) (res
->res
[i
] + 1),
5328 res
->res
[i
]->ie_len
, WLAN_EID_SSID
);
5329 s2
= nl80211_get_ie((u8
*) (r
+ 1), r
->ie_len
, WLAN_EID_SSID
);
5330 if (s1
== NULL
|| s2
== NULL
|| s1
[1] != s2
[1] ||
5331 os_memcmp(s1
, s2
, 2 + s1
[1]) != 0)
5334 /* Same BSSID,SSID was already included in scan results */
5335 wpa_printf(MSG_DEBUG
, "nl80211: Remove duplicated scan result "
5336 "for " MACSTR
, MAC2STR(r
->bssid
));
5338 if (((r
->flags
& WPA_SCAN_ASSOCIATED
) &&
5339 !(res
->res
[i
]->flags
& WPA_SCAN_ASSOCIATED
)) ||
5340 r
->age
< res
->res
[i
]->age
) {
5341 os_free(res
->res
[i
]);
5348 tmp
= os_realloc_array(res
->res
, res
->num
+ 1,
5349 sizeof(struct wpa_scan_res
*));
5354 tmp
[res
->num
++] = r
;
5361 static void clear_state_mismatch(struct wpa_driver_nl80211_data
*drv
,
5364 if (drv
->capa
.flags
& WPA_DRIVER_FLAGS_SME
) {
5365 wpa_printf(MSG_DEBUG
, "nl80211: Clear possible state "
5366 "mismatch (" MACSTR
")", MAC2STR(addr
));
5367 wpa_driver_nl80211_mlme(drv
, addr
,
5368 NL80211_CMD_DEAUTHENTICATE
,
5369 WLAN_REASON_PREV_AUTH_NOT_VALID
, 1);
5374 static void wpa_driver_nl80211_check_bss_status(
5375 struct wpa_driver_nl80211_data
*drv
, struct wpa_scan_results
*res
)
5379 for (i
= 0; i
< res
->num
; i
++) {
5380 struct wpa_scan_res
*r
= res
->res
[i
];
5381 if (r
->flags
& WPA_SCAN_AUTHENTICATED
) {
5382 wpa_printf(MSG_DEBUG
, "nl80211: Scan results "
5383 "indicates BSS status with " MACSTR
5384 " as authenticated",
5386 if (is_sta_interface(drv
->nlmode
) &&
5387 os_memcmp(r
->bssid
, drv
->bssid
, ETH_ALEN
) != 0 &&
5388 os_memcmp(r
->bssid
, drv
->auth_bssid
, ETH_ALEN
) !=
5390 wpa_printf(MSG_DEBUG
, "nl80211: Unknown BSSID"
5391 " in local state (auth=" MACSTR
5392 " assoc=" MACSTR
")",
5393 MAC2STR(drv
->auth_bssid
),
5394 MAC2STR(drv
->bssid
));
5395 clear_state_mismatch(drv
, r
->bssid
);
5399 if (r
->flags
& WPA_SCAN_ASSOCIATED
) {
5400 wpa_printf(MSG_DEBUG
, "nl80211: Scan results "
5401 "indicate BSS status with " MACSTR
5404 if (is_sta_interface(drv
->nlmode
) &&
5406 wpa_printf(MSG_DEBUG
, "nl80211: Local state "
5407 "(not associated) does not match "
5409 clear_state_mismatch(drv
, r
->bssid
);
5410 } else if (is_sta_interface(drv
->nlmode
) &&
5411 os_memcmp(drv
->bssid
, r
->bssid
, ETH_ALEN
) !=
5413 wpa_printf(MSG_DEBUG
, "nl80211: Local state "
5414 "(associated with " MACSTR
") does "
5415 "not match with BSS state",
5416 MAC2STR(drv
->bssid
));
5417 clear_state_mismatch(drv
, r
->bssid
);
5418 clear_state_mismatch(drv
, drv
->bssid
);
5425 static struct wpa_scan_results
*
5426 nl80211_get_scan_results(struct wpa_driver_nl80211_data
*drv
)
5429 struct wpa_scan_results
*res
;
5431 struct nl80211_bss_info_arg arg
;
5433 res
= os_zalloc(sizeof(*res
));
5436 msg
= nlmsg_alloc();
5438 goto nla_put_failure
;
5440 nl80211_cmd(drv
, msg
, NLM_F_DUMP
, NL80211_CMD_GET_SCAN
);
5441 if (nl80211_set_iface_id(msg
, drv
->first_bss
) < 0)
5442 goto nla_put_failure
;
5446 ret
= send_and_recv_msgs(drv
, msg
, bss_info_handler
, &arg
);
5449 wpa_printf(MSG_DEBUG
, "nl80211: Received scan results (%lu "
5450 "BSSes)", (unsigned long) res
->num
);
5451 nl80211_get_noise_for_scan_results(drv
, res
);
5454 wpa_printf(MSG_DEBUG
, "nl80211: Scan result fetch failed: ret=%d "
5455 "(%s)", ret
, strerror(-ret
));
5458 wpa_scan_results_free(res
);
5464 * wpa_driver_nl80211_get_scan_results - Fetch the latest scan results
5465 * @priv: Pointer to private wext data from wpa_driver_nl80211_init()
5466 * Returns: Scan results on success, -1 on failure
5468 static struct wpa_scan_results
*
5469 wpa_driver_nl80211_get_scan_results(void *priv
)
5471 struct i802_bss
*bss
= priv
;
5472 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
5473 struct wpa_scan_results
*res
;
5475 res
= nl80211_get_scan_results(drv
);
5477 wpa_driver_nl80211_check_bss_status(drv
, res
);
5482 static void nl80211_dump_scan(struct wpa_driver_nl80211_data
*drv
)
5484 struct wpa_scan_results
*res
;
5487 res
= nl80211_get_scan_results(drv
);
5489 wpa_printf(MSG_DEBUG
, "nl80211: Failed to get scan results");
5493 wpa_printf(MSG_DEBUG
, "nl80211: Scan result dump");
5494 for (i
= 0; i
< res
->num
; i
++) {
5495 struct wpa_scan_res
*r
= res
->res
[i
];
5496 wpa_printf(MSG_DEBUG
, "nl80211: %d/%d " MACSTR
"%s%s",
5497 (int) i
, (int) res
->num
, MAC2STR(r
->bssid
),
5498 r
->flags
& WPA_SCAN_AUTHENTICATED
? " [auth]" : "",
5499 r
->flags
& WPA_SCAN_ASSOCIATED
? " [assoc]" : "");
5502 wpa_scan_results_free(res
);
5506 static u32
wpa_alg_to_cipher_suite(enum wpa_alg alg
, size_t key_len
)
5511 return WLAN_CIPHER_SUITE_WEP40
;
5512 return WLAN_CIPHER_SUITE_WEP104
;
5514 return WLAN_CIPHER_SUITE_TKIP
;
5516 return WLAN_CIPHER_SUITE_CCMP
;
5518 return WLAN_CIPHER_SUITE_GCMP
;
5519 case WPA_ALG_CCMP_256
:
5520 return WLAN_CIPHER_SUITE_CCMP_256
;
5521 case WPA_ALG_GCMP_256
:
5522 return WLAN_CIPHER_SUITE_GCMP_256
;
5524 return WLAN_CIPHER_SUITE_AES_CMAC
;
5525 case WPA_ALG_BIP_GMAC_128
:
5526 return WLAN_CIPHER_SUITE_BIP_GMAC_128
;
5527 case WPA_ALG_BIP_GMAC_256
:
5528 return WLAN_CIPHER_SUITE_BIP_GMAC_256
;
5529 case WPA_ALG_BIP_CMAC_256
:
5530 return WLAN_CIPHER_SUITE_BIP_CMAC_256
;
5532 return WLAN_CIPHER_SUITE_SMS4
;
5534 return WLAN_CIPHER_SUITE_KRK
;
5537 wpa_printf(MSG_ERROR
, "nl80211: Unexpected encryption algorithm %d",
5542 wpa_printf(MSG_ERROR
, "nl80211: Unsupported encryption algorithm %d",
5548 static u32
wpa_cipher_to_cipher_suite(unsigned int cipher
)
5551 case WPA_CIPHER_CCMP_256
:
5552 return WLAN_CIPHER_SUITE_CCMP_256
;
5553 case WPA_CIPHER_GCMP_256
:
5554 return WLAN_CIPHER_SUITE_GCMP_256
;
5555 case WPA_CIPHER_CCMP
:
5556 return WLAN_CIPHER_SUITE_CCMP
;
5557 case WPA_CIPHER_GCMP
:
5558 return WLAN_CIPHER_SUITE_GCMP
;
5559 case WPA_CIPHER_TKIP
:
5560 return WLAN_CIPHER_SUITE_TKIP
;
5561 case WPA_CIPHER_WEP104
:
5562 return WLAN_CIPHER_SUITE_WEP104
;
5563 case WPA_CIPHER_WEP40
:
5564 return WLAN_CIPHER_SUITE_WEP40
;
5565 case WPA_CIPHER_GTK_NOT_USED
:
5566 return WLAN_CIPHER_SUITE_NO_GROUP_ADDR
;
5573 static int wpa_cipher_to_cipher_suites(unsigned int ciphers
, u32 suites
[],
5578 if (num_suites
< max_suites
&& ciphers
& WPA_CIPHER_CCMP_256
)
5579 suites
[num_suites
++] = WLAN_CIPHER_SUITE_CCMP_256
;
5580 if (num_suites
< max_suites
&& ciphers
& WPA_CIPHER_GCMP_256
)
5581 suites
[num_suites
++] = WLAN_CIPHER_SUITE_GCMP_256
;
5582 if (num_suites
< max_suites
&& ciphers
& WPA_CIPHER_CCMP
)
5583 suites
[num_suites
++] = WLAN_CIPHER_SUITE_CCMP
;
5584 if (num_suites
< max_suites
&& ciphers
& WPA_CIPHER_GCMP
)
5585 suites
[num_suites
++] = WLAN_CIPHER_SUITE_GCMP
;
5586 if (num_suites
< max_suites
&& ciphers
& WPA_CIPHER_TKIP
)
5587 suites
[num_suites
++] = WLAN_CIPHER_SUITE_TKIP
;
5588 if (num_suites
< max_suites
&& ciphers
& WPA_CIPHER_WEP104
)
5589 suites
[num_suites
++] = WLAN_CIPHER_SUITE_WEP104
;
5590 if (num_suites
< max_suites
&& ciphers
& WPA_CIPHER_WEP40
)
5591 suites
[num_suites
++] = WLAN_CIPHER_SUITE_WEP40
;
5597 static int wpa_driver_nl80211_set_key(const char *ifname
, struct i802_bss
*bss
,
5598 enum wpa_alg alg
, const u8
*addr
,
5599 int key_idx
, int set_tx
,
5600 const u8
*seq
, size_t seq_len
,
5601 const u8
*key
, size_t key_len
)
5603 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
5609 /* Ignore for P2P Device */
5610 if (drv
->nlmode
== NL80211_IFTYPE_P2P_DEVICE
)
5613 ifindex
= if_nametoindex(ifname
);
5614 wpa_printf(MSG_DEBUG
, "%s: ifindex=%d (%s) alg=%d addr=%p key_idx=%d "
5615 "set_tx=%d seq_len=%lu key_len=%lu",
5616 __func__
, ifindex
, ifname
, alg
, addr
, key_idx
, set_tx
,
5617 (unsigned long) seq_len
, (unsigned long) key_len
);
5619 if (key_idx
== -1) {
5623 #endif /* CONFIG_TDLS */
5625 msg
= nlmsg_alloc();
5629 if (alg
== WPA_ALG_NONE
) {
5630 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_DEL_KEY
);
5632 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_NEW_KEY
);
5633 NLA_PUT(msg
, NL80211_ATTR_KEY_DATA
, key_len
, key
);
5634 wpa_hexdump_key(MSG_DEBUG
, "nl80211: KEY_DATA", key
, key_len
);
5635 NLA_PUT_U32(msg
, NL80211_ATTR_KEY_CIPHER
,
5636 wpa_alg_to_cipher_suite(alg
, key_len
));
5639 if (seq
&& seq_len
) {
5640 NLA_PUT(msg
, NL80211_ATTR_KEY_SEQ
, seq_len
, seq
);
5641 wpa_hexdump(MSG_DEBUG
, "nl80211: KEY_SEQ", seq
, seq_len
);
5644 if (addr
&& !is_broadcast_ether_addr(addr
)) {
5645 wpa_printf(MSG_DEBUG
, " addr=" MACSTR
, MAC2STR(addr
));
5646 NLA_PUT(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, addr
);
5648 if (alg
!= WPA_ALG_WEP
&& key_idx
&& !set_tx
) {
5649 wpa_printf(MSG_DEBUG
, " RSN IBSS RX GTK");
5650 NLA_PUT_U32(msg
, NL80211_ATTR_KEY_TYPE
,
5651 NL80211_KEYTYPE_GROUP
);
5653 } else if (addr
&& is_broadcast_ether_addr(addr
)) {
5654 struct nlattr
*types
;
5656 wpa_printf(MSG_DEBUG
, " broadcast key");
5658 types
= nla_nest_start(msg
, NL80211_ATTR_KEY_DEFAULT_TYPES
);
5660 goto nla_put_failure
;
5661 NLA_PUT_FLAG(msg
, NL80211_KEY_DEFAULT_TYPE_MULTICAST
);
5662 nla_nest_end(msg
, types
);
5664 NLA_PUT_U8(msg
, NL80211_ATTR_KEY_IDX
, key_idx
);
5665 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, ifindex
);
5667 ret
= send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
5668 if ((ret
== -ENOENT
|| ret
== -ENOLINK
) && alg
== WPA_ALG_NONE
)
5671 wpa_printf(MSG_DEBUG
, "nl80211: set_key failed; err=%d %s)",
5672 ret
, strerror(-ret
));
5675 * If we failed or don't need to set the default TX key (below),
5678 if (ret
|| !set_tx
|| alg
== WPA_ALG_NONE
|| tdls
)
5680 if (is_ap_interface(drv
->nlmode
) && addr
&&
5681 !is_broadcast_ether_addr(addr
))
5684 msg
= nlmsg_alloc();
5688 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_SET_KEY
);
5689 NLA_PUT_U8(msg
, NL80211_ATTR_KEY_IDX
, key_idx
);
5690 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, ifindex
);
5691 if (alg
== WPA_ALG_IGTK
)
5692 NLA_PUT_FLAG(msg
, NL80211_ATTR_KEY_DEFAULT_MGMT
);
5694 NLA_PUT_FLAG(msg
, NL80211_ATTR_KEY_DEFAULT
);
5695 if (addr
&& is_broadcast_ether_addr(addr
)) {
5696 struct nlattr
*types
;
5698 types
= nla_nest_start(msg
, NL80211_ATTR_KEY_DEFAULT_TYPES
);
5700 goto nla_put_failure
;
5701 NLA_PUT_FLAG(msg
, NL80211_KEY_DEFAULT_TYPE_MULTICAST
);
5702 nla_nest_end(msg
, types
);
5704 struct nlattr
*types
;
5706 types
= nla_nest_start(msg
, NL80211_ATTR_KEY_DEFAULT_TYPES
);
5708 goto nla_put_failure
;
5709 NLA_PUT_FLAG(msg
, NL80211_KEY_DEFAULT_TYPE_UNICAST
);
5710 nla_nest_end(msg
, types
);
5713 ret
= send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
5717 wpa_printf(MSG_DEBUG
, "nl80211: set_key default failed; "
5718 "err=%d %s)", ret
, strerror(-ret
));
5727 static int nl_add_key(struct nl_msg
*msg
, enum wpa_alg alg
,
5728 int key_idx
, int defkey
,
5729 const u8
*seq
, size_t seq_len
,
5730 const u8
*key
, size_t key_len
)
5732 struct nlattr
*key_attr
= nla_nest_start(msg
, NL80211_ATTR_KEY
);
5736 if (defkey
&& alg
== WPA_ALG_IGTK
)
5737 NLA_PUT_FLAG(msg
, NL80211_KEY_DEFAULT_MGMT
);
5739 NLA_PUT_FLAG(msg
, NL80211_KEY_DEFAULT
);
5741 NLA_PUT_U8(msg
, NL80211_KEY_IDX
, key_idx
);
5743 NLA_PUT_U32(msg
, NL80211_KEY_CIPHER
,
5744 wpa_alg_to_cipher_suite(alg
, key_len
));
5747 NLA_PUT(msg
, NL80211_KEY_SEQ
, seq_len
, seq
);
5749 NLA_PUT(msg
, NL80211_KEY_DATA
, key_len
, key
);
5751 nla_nest_end(msg
, key_attr
);
5759 static int nl80211_set_conn_keys(struct wpa_driver_associate_params
*params
,
5763 struct nlattr
*nl_keys
, *nl_key
;
5765 for (i
= 0; i
< 4; i
++) {
5766 if (!params
->wep_key
[i
])
5771 if (params
->wps
== WPS_MODE_PRIVACY
)
5773 if (params
->pairwise_suite
&&
5774 params
->pairwise_suite
!= WPA_CIPHER_NONE
)
5780 NLA_PUT_FLAG(msg
, NL80211_ATTR_PRIVACY
);
5782 nl_keys
= nla_nest_start(msg
, NL80211_ATTR_KEYS
);
5784 goto nla_put_failure
;
5786 for (i
= 0; i
< 4; i
++) {
5787 if (!params
->wep_key
[i
])
5790 nl_key
= nla_nest_start(msg
, i
);
5792 goto nla_put_failure
;
5794 NLA_PUT(msg
, NL80211_KEY_DATA
, params
->wep_key_len
[i
],
5795 params
->wep_key
[i
]);
5796 if (params
->wep_key_len
[i
] == 5)
5797 NLA_PUT_U32(msg
, NL80211_KEY_CIPHER
,
5798 WLAN_CIPHER_SUITE_WEP40
);
5800 NLA_PUT_U32(msg
, NL80211_KEY_CIPHER
,
5801 WLAN_CIPHER_SUITE_WEP104
);
5803 NLA_PUT_U8(msg
, NL80211_KEY_IDX
, i
);
5805 if (i
== params
->wep_tx_keyidx
)
5806 NLA_PUT_FLAG(msg
, NL80211_KEY_DEFAULT
);
5808 nla_nest_end(msg
, nl_key
);
5810 nla_nest_end(msg
, nl_keys
);
5819 static int wpa_driver_nl80211_mlme(struct wpa_driver_nl80211_data
*drv
,
5820 const u8
*addr
, int cmd
, u16 reason_code
,
5821 int local_state_change
)
5826 msg
= nlmsg_alloc();
5830 nl80211_cmd(drv
, msg
, 0, cmd
);
5832 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, drv
->ifindex
);
5833 NLA_PUT_U16(msg
, NL80211_ATTR_REASON_CODE
, reason_code
);
5835 NLA_PUT(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, addr
);
5836 if (local_state_change
)
5837 NLA_PUT_FLAG(msg
, NL80211_ATTR_LOCAL_STATE_CHANGE
);
5839 ret
= send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
5842 wpa_dbg(drv
->ctx
, MSG_DEBUG
,
5843 "nl80211: MLME command failed: reason=%u ret=%d (%s)",
5844 reason_code
, ret
, strerror(-ret
));
5845 goto nla_put_failure
;
5855 static int wpa_driver_nl80211_disconnect(struct wpa_driver_nl80211_data
*drv
,
5860 wpa_printf(MSG_DEBUG
, "%s(reason_code=%d)", __func__
, reason_code
);
5861 nl80211_mark_disconnected(drv
);
5862 /* Disconnect command doesn't need BSSID - it uses cached value */
5863 ret
= wpa_driver_nl80211_mlme(drv
, NULL
, NL80211_CMD_DISCONNECT
,
5866 * For locally generated disconnect, supplicant already generates a
5867 * DEAUTH event, so ignore the event from NL80211.
5869 drv
->ignore_next_local_disconnect
= ret
== 0;
5875 static int wpa_driver_nl80211_deauthenticate(struct i802_bss
*bss
,
5876 const u8
*addr
, int reason_code
)
5878 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
5879 if (!(drv
->capa
.flags
& WPA_DRIVER_FLAGS_SME
))
5880 return wpa_driver_nl80211_disconnect(drv
, reason_code
);
5881 wpa_printf(MSG_DEBUG
, "%s(addr=" MACSTR
" reason_code=%d)",
5882 __func__
, MAC2STR(addr
), reason_code
);
5883 nl80211_mark_disconnected(drv
);
5884 if (drv
->nlmode
== NL80211_IFTYPE_ADHOC
)
5885 return nl80211_leave_ibss(drv
);
5886 return wpa_driver_nl80211_mlme(drv
, addr
, NL80211_CMD_DEAUTHENTICATE
,
5891 static void nl80211_copy_auth_params(struct wpa_driver_nl80211_data
*drv
,
5892 struct wpa_driver_auth_params
*params
)
5896 drv
->auth_freq
= params
->freq
;
5897 drv
->auth_alg
= params
->auth_alg
;
5898 drv
->auth_wep_tx_keyidx
= params
->wep_tx_keyidx
;
5899 drv
->auth_local_state_change
= params
->local_state_change
;
5900 drv
->auth_p2p
= params
->p2p
;
5903 os_memcpy(drv
->auth_bssid_
, params
->bssid
, ETH_ALEN
);
5905 os_memset(drv
->auth_bssid_
, 0, ETH_ALEN
);
5908 os_memcpy(drv
->auth_ssid
, params
->ssid
, params
->ssid_len
);
5909 drv
->auth_ssid_len
= params
->ssid_len
;
5911 drv
->auth_ssid_len
= 0;
5914 os_free(drv
->auth_ie
);
5915 drv
->auth_ie
= NULL
;
5916 drv
->auth_ie_len
= 0;
5918 drv
->auth_ie
= os_malloc(params
->ie_len
);
5920 os_memcpy(drv
->auth_ie
, params
->ie
, params
->ie_len
);
5921 drv
->auth_ie_len
= params
->ie_len
;
5925 for (i
= 0; i
< 4; i
++) {
5926 if (params
->wep_key
[i
] && params
->wep_key_len
[i
] &&
5927 params
->wep_key_len
[i
] <= 16) {
5928 os_memcpy(drv
->auth_wep_key
[i
], params
->wep_key
[i
],
5929 params
->wep_key_len
[i
]);
5930 drv
->auth_wep_key_len
[i
] = params
->wep_key_len
[i
];
5932 drv
->auth_wep_key_len
[i
] = 0;
5937 static int wpa_driver_nl80211_authenticate(
5938 struct i802_bss
*bss
, struct wpa_driver_auth_params
*params
)
5940 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
5943 enum nl80211_auth_type type
;
5944 enum nl80211_iftype nlmode
;
5948 is_retry
= drv
->retry_auth
;
5949 drv
->retry_auth
= 0;
5950 drv
->ignore_deauth_event
= 0;
5952 nl80211_mark_disconnected(drv
);
5953 os_memset(drv
->auth_bssid
, 0, ETH_ALEN
);
5955 os_memcpy(drv
->auth_attempt_bssid
, params
->bssid
, ETH_ALEN
);
5957 os_memset(drv
->auth_attempt_bssid
, 0, ETH_ALEN
);
5958 /* FIX: IBSS mode */
5959 nlmode
= params
->p2p
?
5960 NL80211_IFTYPE_P2P_CLIENT
: NL80211_IFTYPE_STATION
;
5961 if (drv
->nlmode
!= nlmode
&&
5962 wpa_driver_nl80211_set_mode(bss
, nlmode
) < 0)
5966 msg
= nlmsg_alloc();
5970 wpa_printf(MSG_DEBUG
, "nl80211: Authenticate (ifindex=%d)",
5973 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_AUTHENTICATE
);
5975 for (i
= 0; i
< 4; i
++) {
5976 if (!params
->wep_key
[i
])
5978 wpa_driver_nl80211_set_key(bss
->ifname
, bss
, WPA_ALG_WEP
,
5980 i
== params
->wep_tx_keyidx
, NULL
, 0,
5982 params
->wep_key_len
[i
]);
5983 if (params
->wep_tx_keyidx
!= i
)
5985 if (nl_add_key(msg
, WPA_ALG_WEP
, i
, 1, NULL
, 0,
5986 params
->wep_key
[i
], params
->wep_key_len
[i
])) {
5992 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, drv
->ifindex
);
5993 if (params
->bssid
) {
5994 wpa_printf(MSG_DEBUG
, " * bssid=" MACSTR
,
5995 MAC2STR(params
->bssid
));
5996 NLA_PUT(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, params
->bssid
);
5999 wpa_printf(MSG_DEBUG
, " * freq=%d", params
->freq
);
6000 NLA_PUT_U32(msg
, NL80211_ATTR_WIPHY_FREQ
, params
->freq
);
6003 wpa_hexdump_ascii(MSG_DEBUG
, " * SSID",
6004 params
->ssid
, params
->ssid_len
);
6005 NLA_PUT(msg
, NL80211_ATTR_SSID
, params
->ssid_len
,
6008 wpa_hexdump(MSG_DEBUG
, " * IEs", params
->ie
, params
->ie_len
);
6010 NLA_PUT(msg
, NL80211_ATTR_IE
, params
->ie_len
, params
->ie
);
6011 if (params
->sae_data
) {
6012 wpa_hexdump(MSG_DEBUG
, " * SAE data", params
->sae_data
,
6013 params
->sae_data_len
);
6014 NLA_PUT(msg
, NL80211_ATTR_SAE_DATA
, params
->sae_data_len
,
6017 if (params
->auth_alg
& WPA_AUTH_ALG_OPEN
)
6018 type
= NL80211_AUTHTYPE_OPEN_SYSTEM
;
6019 else if (params
->auth_alg
& WPA_AUTH_ALG_SHARED
)
6020 type
= NL80211_AUTHTYPE_SHARED_KEY
;
6021 else if (params
->auth_alg
& WPA_AUTH_ALG_LEAP
)
6022 type
= NL80211_AUTHTYPE_NETWORK_EAP
;
6023 else if (params
->auth_alg
& WPA_AUTH_ALG_FT
)
6024 type
= NL80211_AUTHTYPE_FT
;
6025 else if (params
->auth_alg
& WPA_AUTH_ALG_SAE
)
6026 type
= NL80211_AUTHTYPE_SAE
;
6028 goto nla_put_failure
;
6029 wpa_printf(MSG_DEBUG
, " * Auth Type %d", type
);
6030 NLA_PUT_U32(msg
, NL80211_ATTR_AUTH_TYPE
, type
);
6031 if (params
->local_state_change
) {
6032 wpa_printf(MSG_DEBUG
, " * Local state change only");
6033 NLA_PUT_FLAG(msg
, NL80211_ATTR_LOCAL_STATE_CHANGE
);
6036 ret
= send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
6039 wpa_dbg(drv
->ctx
, MSG_DEBUG
,
6040 "nl80211: MLME command failed (auth): ret=%d (%s)",
6041 ret
, strerror(-ret
));
6043 if (ret
== -EALREADY
&& count
== 1 && params
->bssid
&&
6044 !params
->local_state_change
) {
6046 * mac80211 does not currently accept new
6047 * authentication if we are already authenticated. As a
6048 * workaround, force deauthentication and try again.
6050 wpa_printf(MSG_DEBUG
, "nl80211: Retry authentication "
6051 "after forced deauthentication");
6052 drv
->ignore_deauth_event
= 1;
6053 wpa_driver_nl80211_deauthenticate(
6055 WLAN_REASON_PREV_AUTH_NOT_VALID
);
6060 if (ret
== -ENOENT
&& params
->freq
&& !is_retry
) {
6062 * cfg80211 has likely expired the BSS entry even
6063 * though it was previously available in our internal
6064 * BSS table. To recover quickly, start a single
6065 * channel scan on the specified channel.
6067 struct wpa_driver_scan_params scan
;
6070 os_memset(&scan
, 0, sizeof(scan
));
6073 scan
.ssids
[0].ssid
= params
->ssid
;
6074 scan
.ssids
[0].ssid_len
= params
->ssid_len
;
6076 freqs
[0] = params
->freq
;
6079 wpa_printf(MSG_DEBUG
, "nl80211: Trigger single "
6080 "channel scan to refresh cfg80211 BSS "
6082 ret
= wpa_driver_nl80211_scan(bss
, &scan
);
6084 nl80211_copy_auth_params(drv
, params
);
6085 drv
->scan_for_auth
= 1;
6087 } else if (is_retry
) {
6089 * Need to indicate this with an event since the return
6090 * value from the retry is not delivered to core code.
6092 union wpa_event_data event
;
6093 wpa_printf(MSG_DEBUG
, "nl80211: Authentication retry "
6095 os_memset(&event
, 0, sizeof(event
));
6096 os_memcpy(event
.timeout_event
.addr
, drv
->auth_bssid_
,
6098 wpa_supplicant_event(drv
->ctx
, EVENT_AUTH_TIMED_OUT
,
6102 goto nla_put_failure
;
6105 wpa_printf(MSG_DEBUG
, "nl80211: Authentication request send "
6114 static int wpa_driver_nl80211_authenticate_retry(
6115 struct wpa_driver_nl80211_data
*drv
)
6117 struct wpa_driver_auth_params params
;
6118 struct i802_bss
*bss
= drv
->first_bss
;
6121 wpa_printf(MSG_DEBUG
, "nl80211: Try to authenticate again");
6123 os_memset(¶ms
, 0, sizeof(params
));
6124 params
.freq
= drv
->auth_freq
;
6125 params
.auth_alg
= drv
->auth_alg
;
6126 params
.wep_tx_keyidx
= drv
->auth_wep_tx_keyidx
;
6127 params
.local_state_change
= drv
->auth_local_state_change
;
6128 params
.p2p
= drv
->auth_p2p
;
6130 if (!is_zero_ether_addr(drv
->auth_bssid_
))
6131 params
.bssid
= drv
->auth_bssid_
;
6133 if (drv
->auth_ssid_len
) {
6134 params
.ssid
= drv
->auth_ssid
;
6135 params
.ssid_len
= drv
->auth_ssid_len
;
6138 params
.ie
= drv
->auth_ie
;
6139 params
.ie_len
= drv
->auth_ie_len
;
6141 for (i
= 0; i
< 4; i
++) {
6142 if (drv
->auth_wep_key_len
[i
]) {
6143 params
.wep_key
[i
] = drv
->auth_wep_key
[i
];
6144 params
.wep_key_len
[i
] = drv
->auth_wep_key_len
[i
];
6148 drv
->retry_auth
= 1;
6149 return wpa_driver_nl80211_authenticate(bss
, ¶ms
);
6153 struct phy_info_arg
{
6155 struct hostapd_hw_modes
*modes
;
6156 int last_mode
, last_chan_idx
;
6159 static void phy_info_ht_capa(struct hostapd_hw_modes
*mode
, struct nlattr
*capa
,
6160 struct nlattr
*ampdu_factor
,
6161 struct nlattr
*ampdu_density
,
6162 struct nlattr
*mcs_set
)
6165 mode
->ht_capab
= nla_get_u16(capa
);
6168 mode
->a_mpdu_params
|= nla_get_u8(ampdu_factor
) & 0x03;
6171 mode
->a_mpdu_params
|= nla_get_u8(ampdu_density
) << 2;
6173 if (mcs_set
&& nla_len(mcs_set
) >= 16) {
6175 mcs
= nla_data(mcs_set
);
6176 os_memcpy(mode
->mcs_set
, mcs
, 16);
6181 static void phy_info_vht_capa(struct hostapd_hw_modes
*mode
,
6182 struct nlattr
*capa
,
6183 struct nlattr
*mcs_set
)
6186 mode
->vht_capab
= nla_get_u32(capa
);
6188 if (mcs_set
&& nla_len(mcs_set
) >= 8) {
6190 mcs
= nla_data(mcs_set
);
6191 os_memcpy(mode
->vht_mcs_set
, mcs
, 8);
6196 static void phy_info_freq(struct hostapd_hw_modes
*mode
,
6197 struct hostapd_channel_data
*chan
,
6198 struct nlattr
*tb_freq
[])
6201 chan
->freq
= nla_get_u32(tb_freq
[NL80211_FREQUENCY_ATTR_FREQ
]);
6203 if (ieee80211_freq_to_chan(chan
->freq
, &channel
) != NUM_HOSTAPD_MODES
)
6204 chan
->chan
= channel
;
6206 if (tb_freq
[NL80211_FREQUENCY_ATTR_DISABLED
])
6207 chan
->flag
|= HOSTAPD_CHAN_DISABLED
;
6208 if (tb_freq
[NL80211_FREQUENCY_ATTR_NO_IR
])
6209 chan
->flag
|= HOSTAPD_CHAN_PASSIVE_SCAN
| HOSTAPD_CHAN_NO_IBSS
;
6210 if (tb_freq
[NL80211_FREQUENCY_ATTR_RADAR
])
6211 chan
->flag
|= HOSTAPD_CHAN_RADAR
;
6213 if (tb_freq
[NL80211_FREQUENCY_ATTR_DFS_STATE
]) {
6214 enum nl80211_dfs_state state
=
6215 nla_get_u32(tb_freq
[NL80211_FREQUENCY_ATTR_DFS_STATE
]);
6218 case NL80211_DFS_USABLE
:
6219 chan
->flag
|= HOSTAPD_CHAN_DFS_USABLE
;
6221 case NL80211_DFS_AVAILABLE
:
6222 chan
->flag
|= HOSTAPD_CHAN_DFS_AVAILABLE
;
6224 case NL80211_DFS_UNAVAILABLE
:
6225 chan
->flag
|= HOSTAPD_CHAN_DFS_UNAVAILABLE
;
6232 static int phy_info_freqs(struct phy_info_arg
*phy_info
,
6233 struct hostapd_hw_modes
*mode
, struct nlattr
*tb
)
6235 static struct nla_policy freq_policy
[NL80211_FREQUENCY_ATTR_MAX
+ 1] = {
6236 [NL80211_FREQUENCY_ATTR_FREQ
] = { .type
= NLA_U32
},
6237 [NL80211_FREQUENCY_ATTR_DISABLED
] = { .type
= NLA_FLAG
},
6238 [NL80211_FREQUENCY_ATTR_NO_IR
] = { .type
= NLA_FLAG
},
6239 [NL80211_FREQUENCY_ATTR_RADAR
] = { .type
= NLA_FLAG
},
6240 [NL80211_FREQUENCY_ATTR_MAX_TX_POWER
] = { .type
= NLA_U32
},
6241 [NL80211_FREQUENCY_ATTR_DFS_STATE
] = { .type
= NLA_U32
},
6243 int new_channels
= 0;
6244 struct hostapd_channel_data
*channel
;
6245 struct nlattr
*tb_freq
[NL80211_FREQUENCY_ATTR_MAX
+ 1];
6246 struct nlattr
*nl_freq
;
6252 nla_for_each_nested(nl_freq
, tb
, rem_freq
) {
6253 nla_parse(tb_freq
, NL80211_FREQUENCY_ATTR_MAX
,
6254 nla_data(nl_freq
), nla_len(nl_freq
), freq_policy
);
6255 if (!tb_freq
[NL80211_FREQUENCY_ATTR_FREQ
])
6260 channel
= os_realloc_array(mode
->channels
,
6261 mode
->num_channels
+ new_channels
,
6262 sizeof(struct hostapd_channel_data
));
6266 mode
->channels
= channel
;
6267 mode
->num_channels
+= new_channels
;
6269 idx
= phy_info
->last_chan_idx
;
6271 nla_for_each_nested(nl_freq
, tb
, rem_freq
) {
6272 nla_parse(tb_freq
, NL80211_FREQUENCY_ATTR_MAX
,
6273 nla_data(nl_freq
), nla_len(nl_freq
), freq_policy
);
6274 if (!tb_freq
[NL80211_FREQUENCY_ATTR_FREQ
])
6276 phy_info_freq(mode
, &mode
->channels
[idx
], tb_freq
);
6279 phy_info
->last_chan_idx
= idx
;
6285 static int phy_info_rates(struct hostapd_hw_modes
*mode
, struct nlattr
*tb
)
6287 static struct nla_policy rate_policy
[NL80211_BITRATE_ATTR_MAX
+ 1] = {
6288 [NL80211_BITRATE_ATTR_RATE
] = { .type
= NLA_U32
},
6289 [NL80211_BITRATE_ATTR_2GHZ_SHORTPREAMBLE
] =
6290 { .type
= NLA_FLAG
},
6292 struct nlattr
*tb_rate
[NL80211_BITRATE_ATTR_MAX
+ 1];
6293 struct nlattr
*nl_rate
;
6299 nla_for_each_nested(nl_rate
, tb
, rem_rate
) {
6300 nla_parse(tb_rate
, NL80211_BITRATE_ATTR_MAX
,
6301 nla_data(nl_rate
), nla_len(nl_rate
),
6303 if (!tb_rate
[NL80211_BITRATE_ATTR_RATE
])
6308 mode
->rates
= os_calloc(mode
->num_rates
, sizeof(int));
6314 nla_for_each_nested(nl_rate
, tb
, rem_rate
) {
6315 nla_parse(tb_rate
, NL80211_BITRATE_ATTR_MAX
,
6316 nla_data(nl_rate
), nla_len(nl_rate
),
6318 if (!tb_rate
[NL80211_BITRATE_ATTR_RATE
])
6320 mode
->rates
[idx
] = nla_get_u32(
6321 tb_rate
[NL80211_BITRATE_ATTR_RATE
]);
6329 static int phy_info_band(struct phy_info_arg
*phy_info
, struct nlattr
*nl_band
)
6331 struct nlattr
*tb_band
[NL80211_BAND_ATTR_MAX
+ 1];
6332 struct hostapd_hw_modes
*mode
;
6335 if (phy_info
->last_mode
!= nl_band
->nla_type
) {
6336 mode
= os_realloc_array(phy_info
->modes
,
6337 *phy_info
->num_modes
+ 1,
6341 phy_info
->modes
= mode
;
6343 mode
= &phy_info
->modes
[*(phy_info
->num_modes
)];
6344 os_memset(mode
, 0, sizeof(*mode
));
6345 mode
->mode
= NUM_HOSTAPD_MODES
;
6346 mode
->flags
= HOSTAPD_MODE_FLAG_HT_INFO_KNOWN
|
6347 HOSTAPD_MODE_FLAG_VHT_INFO_KNOWN
;
6350 * Unsupported VHT MCS stream is defined as value 3, so the VHT
6351 * MCS RX/TX map must be initialized with 0xffff to mark all 8
6352 * possible streams as unsupported. This will be overridden if
6353 * driver advertises VHT support.
6355 mode
->vht_mcs_set
[0] = 0xff;
6356 mode
->vht_mcs_set
[1] = 0xff;
6357 mode
->vht_mcs_set
[4] = 0xff;
6358 mode
->vht_mcs_set
[5] = 0xff;
6360 *(phy_info
->num_modes
) += 1;
6361 phy_info
->last_mode
= nl_band
->nla_type
;
6362 phy_info
->last_chan_idx
= 0;
6364 mode
= &phy_info
->modes
[*(phy_info
->num_modes
) - 1];
6366 nla_parse(tb_band
, NL80211_BAND_ATTR_MAX
, nla_data(nl_band
),
6367 nla_len(nl_band
), NULL
);
6369 phy_info_ht_capa(mode
, tb_band
[NL80211_BAND_ATTR_HT_CAPA
],
6370 tb_band
[NL80211_BAND_ATTR_HT_AMPDU_FACTOR
],
6371 tb_band
[NL80211_BAND_ATTR_HT_AMPDU_DENSITY
],
6372 tb_band
[NL80211_BAND_ATTR_HT_MCS_SET
]);
6373 phy_info_vht_capa(mode
, tb_band
[NL80211_BAND_ATTR_VHT_CAPA
],
6374 tb_band
[NL80211_BAND_ATTR_VHT_MCS_SET
]);
6375 ret
= phy_info_freqs(phy_info
, mode
, tb_band
[NL80211_BAND_ATTR_FREQS
]);
6378 ret
= phy_info_rates(mode
, tb_band
[NL80211_BAND_ATTR_RATES
]);
6386 static int phy_info_handler(struct nl_msg
*msg
, void *arg
)
6388 struct nlattr
*tb_msg
[NL80211_ATTR_MAX
+ 1];
6389 struct genlmsghdr
*gnlh
= nlmsg_data(nlmsg_hdr(msg
));
6390 struct phy_info_arg
*phy_info
= arg
;
6391 struct nlattr
*nl_band
;
6394 nla_parse(tb_msg
, NL80211_ATTR_MAX
, genlmsg_attrdata(gnlh
, 0),
6395 genlmsg_attrlen(gnlh
, 0), NULL
);
6397 if (!tb_msg
[NL80211_ATTR_WIPHY_BANDS
])
6400 nla_for_each_nested(nl_band
, tb_msg
[NL80211_ATTR_WIPHY_BANDS
], rem_band
)
6402 int res
= phy_info_band(phy_info
, nl_band
);
6411 static struct hostapd_hw_modes
*
6412 wpa_driver_nl80211_postprocess_modes(struct hostapd_hw_modes
*modes
,
6416 struct hostapd_hw_modes
*mode11g
= NULL
, *nmodes
, *mode
;
6417 int i
, mode11g_idx
= -1;
6419 /* heuristic to set up modes */
6420 for (m
= 0; m
< *num_modes
; m
++) {
6421 if (!modes
[m
].num_channels
)
6423 if (modes
[m
].channels
[0].freq
< 4000) {
6424 modes
[m
].mode
= HOSTAPD_MODE_IEEE80211B
;
6425 for (i
= 0; i
< modes
[m
].num_rates
; i
++) {
6426 if (modes
[m
].rates
[i
] > 200) {
6427 modes
[m
].mode
= HOSTAPD_MODE_IEEE80211G
;
6431 } else if (modes
[m
].channels
[0].freq
> 50000)
6432 modes
[m
].mode
= HOSTAPD_MODE_IEEE80211AD
;
6434 modes
[m
].mode
= HOSTAPD_MODE_IEEE80211A
;
6437 /* If only 802.11g mode is included, use it to construct matching
6438 * 802.11b mode data. */
6440 for (m
= 0; m
< *num_modes
; m
++) {
6441 if (modes
[m
].mode
== HOSTAPD_MODE_IEEE80211B
)
6442 return modes
; /* 802.11b already included */
6443 if (modes
[m
].mode
== HOSTAPD_MODE_IEEE80211G
)
6447 if (mode11g_idx
< 0)
6448 return modes
; /* 2.4 GHz band not supported at all */
6450 nmodes
= os_realloc_array(modes
, *num_modes
+ 1, sizeof(*nmodes
));
6452 return modes
; /* Could not add 802.11b mode */
6454 mode
= &nmodes
[*num_modes
];
6455 os_memset(mode
, 0, sizeof(*mode
));
6459 mode
->mode
= HOSTAPD_MODE_IEEE80211B
;
6461 mode11g
= &modes
[mode11g_idx
];
6462 mode
->num_channels
= mode11g
->num_channels
;
6463 mode
->channels
= os_malloc(mode11g
->num_channels
*
6464 sizeof(struct hostapd_channel_data
));
6465 if (mode
->channels
== NULL
) {
6467 return modes
; /* Could not add 802.11b mode */
6469 os_memcpy(mode
->channels
, mode11g
->channels
,
6470 mode11g
->num_channels
* sizeof(struct hostapd_channel_data
));
6472 mode
->num_rates
= 0;
6473 mode
->rates
= os_malloc(4 * sizeof(int));
6474 if (mode
->rates
== NULL
) {
6475 os_free(mode
->channels
);
6477 return modes
; /* Could not add 802.11b mode */
6480 for (i
= 0; i
< mode11g
->num_rates
; i
++) {
6481 if (mode11g
->rates
[i
] != 10 && mode11g
->rates
[i
] != 20 &&
6482 mode11g
->rates
[i
] != 55 && mode11g
->rates
[i
] != 110)
6484 mode
->rates
[mode
->num_rates
] = mode11g
->rates
[i
];
6486 if (mode
->num_rates
== 4)
6490 if (mode
->num_rates
== 0) {
6491 os_free(mode
->channels
);
6492 os_free(mode
->rates
);
6494 return modes
; /* No 802.11b rates */
6497 wpa_printf(MSG_DEBUG
, "nl80211: Added 802.11b mode based on 802.11g "
6504 static void nl80211_set_ht40_mode(struct hostapd_hw_modes
*mode
, int start
,
6509 for (c
= 0; c
< mode
->num_channels
; c
++) {
6510 struct hostapd_channel_data
*chan
= &mode
->channels
[c
];
6511 if (chan
->freq
- 10 >= start
&& chan
->freq
+ 10 <= end
)
6512 chan
->flag
|= HOSTAPD_CHAN_HT40
;
6517 static void nl80211_set_ht40_mode_sec(struct hostapd_hw_modes
*mode
, int start
,
6522 for (c
= 0; c
< mode
->num_channels
; c
++) {
6523 struct hostapd_channel_data
*chan
= &mode
->channels
[c
];
6524 if (!(chan
->flag
& HOSTAPD_CHAN_HT40
))
6526 if (chan
->freq
- 30 >= start
&& chan
->freq
- 10 <= end
)
6527 chan
->flag
|= HOSTAPD_CHAN_HT40MINUS
;
6528 if (chan
->freq
+ 10 >= start
&& chan
->freq
+ 30 <= end
)
6529 chan
->flag
|= HOSTAPD_CHAN_HT40PLUS
;
6534 static void nl80211_reg_rule_max_eirp(u32 start
, u32 end
, u32 max_eirp
,
6535 struct phy_info_arg
*results
)
6539 for (m
= 0; m
< *results
->num_modes
; m
++) {
6541 struct hostapd_hw_modes
*mode
= &results
->modes
[m
];
6543 for (c
= 0; c
< mode
->num_channels
; c
++) {
6544 struct hostapd_channel_data
*chan
= &mode
->channels
[c
];
6545 if ((u32
) chan
->freq
- 10 >= start
&&
6546 (u32
) chan
->freq
+ 10 <= end
)
6547 chan
->max_tx_power
= max_eirp
;
6553 static void nl80211_reg_rule_ht40(u32 start
, u32 end
,
6554 struct phy_info_arg
*results
)
6558 for (m
= 0; m
< *results
->num_modes
; m
++) {
6559 if (!(results
->modes
[m
].ht_capab
&
6560 HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET
))
6562 nl80211_set_ht40_mode(&results
->modes
[m
], start
, end
);
6567 static void nl80211_reg_rule_sec(struct nlattr
*tb
[],
6568 struct phy_info_arg
*results
)
6570 u32 start
, end
, max_bw
;
6573 if (tb
[NL80211_ATTR_FREQ_RANGE_START
] == NULL
||
6574 tb
[NL80211_ATTR_FREQ_RANGE_END
] == NULL
||
6575 tb
[NL80211_ATTR_FREQ_RANGE_MAX_BW
] == NULL
)
6578 start
= nla_get_u32(tb
[NL80211_ATTR_FREQ_RANGE_START
]) / 1000;
6579 end
= nla_get_u32(tb
[NL80211_ATTR_FREQ_RANGE_END
]) / 1000;
6580 max_bw
= nla_get_u32(tb
[NL80211_ATTR_FREQ_RANGE_MAX_BW
]) / 1000;
6585 for (m
= 0; m
< *results
->num_modes
; m
++) {
6586 if (!(results
->modes
[m
].ht_capab
&
6587 HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET
))
6589 nl80211_set_ht40_mode_sec(&results
->modes
[m
], start
, end
);
6594 static void nl80211_set_vht_mode(struct hostapd_hw_modes
*mode
, int start
,
6599 for (c
= 0; c
< mode
->num_channels
; c
++) {
6600 struct hostapd_channel_data
*chan
= &mode
->channels
[c
];
6601 if (chan
->freq
- 10 >= start
&& chan
->freq
+ 70 <= end
)
6602 chan
->flag
|= HOSTAPD_CHAN_VHT_10_70
;
6604 if (chan
->freq
- 30 >= start
&& chan
->freq
+ 50 <= end
)
6605 chan
->flag
|= HOSTAPD_CHAN_VHT_30_50
;
6607 if (chan
->freq
- 50 >= start
&& chan
->freq
+ 30 <= end
)
6608 chan
->flag
|= HOSTAPD_CHAN_VHT_50_30
;
6610 if (chan
->freq
- 70 >= start
&& chan
->freq
+ 10 <= end
)
6611 chan
->flag
|= HOSTAPD_CHAN_VHT_70_10
;
6616 static void nl80211_reg_rule_vht(struct nlattr
*tb
[],
6617 struct phy_info_arg
*results
)
6619 u32 start
, end
, max_bw
;
6622 if (tb
[NL80211_ATTR_FREQ_RANGE_START
] == NULL
||
6623 tb
[NL80211_ATTR_FREQ_RANGE_END
] == NULL
||
6624 tb
[NL80211_ATTR_FREQ_RANGE_MAX_BW
] == NULL
)
6627 start
= nla_get_u32(tb
[NL80211_ATTR_FREQ_RANGE_START
]) / 1000;
6628 end
= nla_get_u32(tb
[NL80211_ATTR_FREQ_RANGE_END
]) / 1000;
6629 max_bw
= nla_get_u32(tb
[NL80211_ATTR_FREQ_RANGE_MAX_BW
]) / 1000;
6634 for (m
= 0; m
< *results
->num_modes
; m
++) {
6635 if (!(results
->modes
[m
].ht_capab
&
6636 HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET
))
6638 /* TODO: use a real VHT support indication */
6639 if (!results
->modes
[m
].vht_capab
)
6642 nl80211_set_vht_mode(&results
->modes
[m
], start
, end
);
6647 static const char * dfs_domain_name(enum nl80211_dfs_regions region
)
6650 case NL80211_DFS_UNSET
:
6652 case NL80211_DFS_FCC
:
6654 case NL80211_DFS_ETSI
:
6656 case NL80211_DFS_JP
:
6659 return "DFS-invalid";
6664 static int nl80211_get_reg(struct nl_msg
*msg
, void *arg
)
6666 struct phy_info_arg
*results
= arg
;
6667 struct nlattr
*tb_msg
[NL80211_ATTR_MAX
+ 1];
6668 struct genlmsghdr
*gnlh
= nlmsg_data(nlmsg_hdr(msg
));
6669 struct nlattr
*nl_rule
;
6670 struct nlattr
*tb_rule
[NL80211_FREQUENCY_ATTR_MAX
+ 1];
6672 static struct nla_policy reg_policy
[NL80211_FREQUENCY_ATTR_MAX
+ 1] = {
6673 [NL80211_ATTR_REG_RULE_FLAGS
] = { .type
= NLA_U32
},
6674 [NL80211_ATTR_FREQ_RANGE_START
] = { .type
= NLA_U32
},
6675 [NL80211_ATTR_FREQ_RANGE_END
] = { .type
= NLA_U32
},
6676 [NL80211_ATTR_FREQ_RANGE_MAX_BW
] = { .type
= NLA_U32
},
6677 [NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN
] = { .type
= NLA_U32
},
6678 [NL80211_ATTR_POWER_RULE_MAX_EIRP
] = { .type
= NLA_U32
},
6681 nla_parse(tb_msg
, NL80211_ATTR_MAX
, genlmsg_attrdata(gnlh
, 0),
6682 genlmsg_attrlen(gnlh
, 0), NULL
);
6683 if (!tb_msg
[NL80211_ATTR_REG_ALPHA2
] ||
6684 !tb_msg
[NL80211_ATTR_REG_RULES
]) {
6685 wpa_printf(MSG_DEBUG
, "nl80211: No regulatory information "
6690 if (tb_msg
[NL80211_ATTR_DFS_REGION
]) {
6691 enum nl80211_dfs_regions dfs_domain
;
6692 dfs_domain
= nla_get_u8(tb_msg
[NL80211_ATTR_DFS_REGION
]);
6693 wpa_printf(MSG_DEBUG
, "nl80211: Regulatory information - country=%s (%s)",
6694 (char *) nla_data(tb_msg
[NL80211_ATTR_REG_ALPHA2
]),
6695 dfs_domain_name(dfs_domain
));
6697 wpa_printf(MSG_DEBUG
, "nl80211: Regulatory information - country=%s",
6698 (char *) nla_data(tb_msg
[NL80211_ATTR_REG_ALPHA2
]));
6701 nla_for_each_nested(nl_rule
, tb_msg
[NL80211_ATTR_REG_RULES
], rem_rule
)
6703 u32 start
, end
, max_eirp
= 0, max_bw
= 0, flags
= 0;
6704 nla_parse(tb_rule
, NL80211_FREQUENCY_ATTR_MAX
,
6705 nla_data(nl_rule
), nla_len(nl_rule
), reg_policy
);
6706 if (tb_rule
[NL80211_ATTR_FREQ_RANGE_START
] == NULL
||
6707 tb_rule
[NL80211_ATTR_FREQ_RANGE_END
] == NULL
)
6709 start
= nla_get_u32(tb_rule
[NL80211_ATTR_FREQ_RANGE_START
]) / 1000;
6710 end
= nla_get_u32(tb_rule
[NL80211_ATTR_FREQ_RANGE_END
]) / 1000;
6711 if (tb_rule
[NL80211_ATTR_POWER_RULE_MAX_EIRP
])
6712 max_eirp
= nla_get_u32(tb_rule
[NL80211_ATTR_POWER_RULE_MAX_EIRP
]) / 100;
6713 if (tb_rule
[NL80211_ATTR_FREQ_RANGE_MAX_BW
])
6714 max_bw
= nla_get_u32(tb_rule
[NL80211_ATTR_FREQ_RANGE_MAX_BW
]) / 1000;
6715 if (tb_rule
[NL80211_ATTR_REG_RULE_FLAGS
])
6716 flags
= nla_get_u32(tb_rule
[NL80211_ATTR_REG_RULE_FLAGS
]);
6718 wpa_printf(MSG_DEBUG
, "nl80211: %u-%u @ %u MHz %u mBm%s%s%s%s%s%s%s%s",
6719 start
, end
, max_bw
, max_eirp
,
6720 flags
& NL80211_RRF_NO_OFDM
? " (no OFDM)" : "",
6721 flags
& NL80211_RRF_NO_CCK
? " (no CCK)" : "",
6722 flags
& NL80211_RRF_NO_INDOOR
? " (no indoor)" : "",
6723 flags
& NL80211_RRF_NO_OUTDOOR
? " (no outdoor)" :
6725 flags
& NL80211_RRF_DFS
? " (DFS)" : "",
6726 flags
& NL80211_RRF_PTP_ONLY
? " (PTP only)" : "",
6727 flags
& NL80211_RRF_PTMP_ONLY
? " (PTMP only)" : "",
6728 flags
& NL80211_RRF_NO_IR
? " (no IR)" : "");
6730 nl80211_reg_rule_ht40(start
, end
, results
);
6731 if (tb_rule
[NL80211_ATTR_POWER_RULE_MAX_EIRP
])
6732 nl80211_reg_rule_max_eirp(start
, end
, max_eirp
,
6736 nla_for_each_nested(nl_rule
, tb_msg
[NL80211_ATTR_REG_RULES
], rem_rule
)
6738 nla_parse(tb_rule
, NL80211_FREQUENCY_ATTR_MAX
,
6739 nla_data(nl_rule
), nla_len(nl_rule
), reg_policy
);
6740 nl80211_reg_rule_sec(tb_rule
, results
);
6743 nla_for_each_nested(nl_rule
, tb_msg
[NL80211_ATTR_REG_RULES
], rem_rule
)
6745 nla_parse(tb_rule
, NL80211_FREQUENCY_ATTR_MAX
,
6746 nla_data(nl_rule
), nla_len(nl_rule
), reg_policy
);
6747 nl80211_reg_rule_vht(tb_rule
, results
);
6754 static int nl80211_set_regulatory_flags(struct wpa_driver_nl80211_data
*drv
,
6755 struct phy_info_arg
*results
)
6759 msg
= nlmsg_alloc();
6763 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_GET_REG
);
6764 return send_and_recv_msgs(drv
, msg
, nl80211_get_reg
, results
);
6768 static struct hostapd_hw_modes
*
6769 wpa_driver_nl80211_get_hw_feature_data(void *priv
, u16
*num_modes
, u16
*flags
)
6772 struct i802_bss
*bss
= priv
;
6773 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
6775 struct phy_info_arg result
= {
6776 .num_modes
= num_modes
,
6784 msg
= nlmsg_alloc();
6788 feat
= get_nl80211_protocol_features(drv
);
6789 if (feat
& NL80211_PROTOCOL_FEATURE_SPLIT_WIPHY_DUMP
)
6790 nl80211_cmd(drv
, msg
, NLM_F_DUMP
, NL80211_CMD_GET_WIPHY
);
6792 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_GET_WIPHY
);
6794 NLA_PUT_FLAG(msg
, NL80211_ATTR_SPLIT_WIPHY_DUMP
);
6795 if (nl80211_set_iface_id(msg
, bss
) < 0)
6796 goto nla_put_failure
;
6798 if (send_and_recv_msgs(drv
, msg
, phy_info_handler
, &result
) == 0) {
6799 nl80211_set_regulatory_flags(drv
, &result
);
6800 return wpa_driver_nl80211_postprocess_modes(result
.modes
,
6810 static int wpa_driver_nl80211_send_mntr(struct wpa_driver_nl80211_data
*drv
,
6811 const void *data
, size_t len
,
6812 int encrypt
, int noack
)
6815 0x00, 0x00, /* radiotap version */
6816 0x0e, 0x00, /* radiotap length */
6817 0x02, 0xc0, 0x00, 0x00, /* bmap: flags, tx and rx flags */
6818 IEEE80211_RADIOTAP_F_FRAG
, /* F_FRAG (fragment if required) */
6820 0x00, 0x00, /* RX and TX flags to indicate that */
6821 0x00, 0x00, /* this is the injected frame directly */
6823 struct iovec iov
[2] = {
6825 .iov_base
= &rtap_hdr
,
6826 .iov_len
= sizeof(rtap_hdr
),
6829 .iov_base
= (void *) data
,
6833 struct msghdr msg
= {
6838 .msg_control
= NULL
,
6839 .msg_controllen
= 0,
6846 rtap_hdr
[8] |= IEEE80211_RADIOTAP_F_WEP
;
6848 if (drv
->monitor_sock
< 0) {
6849 wpa_printf(MSG_DEBUG
, "nl80211: No monitor socket available "
6850 "for %s", __func__
);
6855 txflags
|= IEEE80211_RADIOTAP_F_TX_NOACK
;
6856 WPA_PUT_LE16(&rtap_hdr
[12], txflags
);
6858 res
= sendmsg(drv
->monitor_sock
, &msg
, 0);
6860 wpa_printf(MSG_INFO
, "nl80211: sendmsg: %s", strerror(errno
));
6867 static int wpa_driver_nl80211_send_frame(struct i802_bss
*bss
,
6868 const void *data
, size_t len
,
6869 int encrypt
, int noack
,
6870 unsigned int freq
, int no_cck
,
6871 int offchanok
, unsigned int wait_time
)
6873 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
6878 wpa_printf(MSG_DEBUG
, "nl80211: send_frame - Use bss->freq=%u",
6883 if (drv
->use_monitor
) {
6884 wpa_printf(MSG_DEBUG
, "nl80211: send_frame(freq=%u bss->freq=%u) -> send_mntr",
6886 return wpa_driver_nl80211_send_mntr(drv
, data
, len
,
6890 wpa_printf(MSG_DEBUG
, "nl80211: send_frame -> send_frame_cmd");
6891 res
= nl80211_send_frame_cmd(bss
, freq
, wait_time
, data
, len
,
6892 &cookie
, no_cck
, noack
, offchanok
);
6893 if (res
== 0 && !noack
) {
6894 const struct ieee80211_mgmt
*mgmt
;
6897 mgmt
= (const struct ieee80211_mgmt
*) data
;
6898 fc
= le_to_host16(mgmt
->frame_control
);
6899 if (WLAN_FC_GET_TYPE(fc
) == WLAN_FC_TYPE_MGMT
&&
6900 WLAN_FC_GET_STYPE(fc
) == WLAN_FC_STYPE_ACTION
) {
6901 wpa_printf(MSG_MSGDUMP
,
6902 "nl80211: Update send_action_cookie from 0x%llx to 0x%llx",
6903 (long long unsigned int)
6904 drv
->send_action_cookie
,
6905 (long long unsigned int) cookie
);
6906 drv
->send_action_cookie
= cookie
;
6914 static int wpa_driver_nl80211_send_mlme(struct i802_bss
*bss
, const u8
*data
,
6915 size_t data_len
, int noack
,
6916 unsigned int freq
, int no_cck
,
6918 unsigned int wait_time
)
6920 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
6921 struct ieee80211_mgmt
*mgmt
;
6925 mgmt
= (struct ieee80211_mgmt
*) data
;
6926 fc
= le_to_host16(mgmt
->frame_control
);
6927 wpa_printf(MSG_DEBUG
, "nl80211: send_mlme - noack=%d freq=%u no_cck=%d offchanok=%d wait_time=%u fc=0x%x nlmode=%d",
6928 noack
, freq
, no_cck
, offchanok
, wait_time
, fc
, drv
->nlmode
);
6930 if ((is_sta_interface(drv
->nlmode
) ||
6931 drv
->nlmode
== NL80211_IFTYPE_P2P_DEVICE
) &&
6932 WLAN_FC_GET_TYPE(fc
) == WLAN_FC_TYPE_MGMT
&&
6933 WLAN_FC_GET_STYPE(fc
) == WLAN_FC_STYPE_PROBE_RESP
) {
6935 * The use of last_mgmt_freq is a bit of a hack,
6936 * but it works due to the single-threaded nature
6937 * of wpa_supplicant.
6940 wpa_printf(MSG_DEBUG
, "nl80211: Use last_mgmt_freq=%d",
6941 drv
->last_mgmt_freq
);
6942 freq
= drv
->last_mgmt_freq
;
6944 return nl80211_send_frame_cmd(bss
, freq
, 0,
6945 data
, data_len
, NULL
, 1, noack
,
6949 if (drv
->device_ap_sme
&& is_ap_interface(drv
->nlmode
)) {
6951 wpa_printf(MSG_DEBUG
, "nl80211: Use bss->freq=%d",
6955 return nl80211_send_frame_cmd(bss
, freq
,
6956 (int) freq
== bss
->freq
? 0 :
6959 &drv
->send_action_cookie
,
6960 no_cck
, noack
, offchanok
);
6963 if (WLAN_FC_GET_TYPE(fc
) == WLAN_FC_TYPE_MGMT
&&
6964 WLAN_FC_GET_STYPE(fc
) == WLAN_FC_STYPE_AUTH
) {
6966 * Only one of the authentication frame types is encrypted.
6967 * In order for static WEP encryption to work properly (i.e.,
6968 * to not encrypt the frame), we need to tell mac80211 about
6969 * the frames that must not be encrypted.
6971 u16 auth_alg
= le_to_host16(mgmt
->u
.auth
.auth_alg
);
6972 u16 auth_trans
= le_to_host16(mgmt
->u
.auth
.auth_transaction
);
6973 if (auth_alg
!= WLAN_AUTH_SHARED_KEY
|| auth_trans
!= 3)
6977 wpa_printf(MSG_DEBUG
, "nl80211: send_mlme -> send_frame");
6978 return wpa_driver_nl80211_send_frame(bss
, data
, data_len
, encrypt
,
6979 noack
, freq
, no_cck
, offchanok
,
6984 static int nl80211_set_bss(struct i802_bss
*bss
, int cts
, int preamble
,
6985 int slot
, int ht_opmode
, int ap_isolate
,
6988 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
6991 msg
= nlmsg_alloc();
6995 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_SET_BSS
);
6998 NLA_PUT_U8(msg
, NL80211_ATTR_BSS_CTS_PROT
, cts
);
7000 NLA_PUT_U8(msg
, NL80211_ATTR_BSS_SHORT_PREAMBLE
, preamble
);
7002 NLA_PUT_U8(msg
, NL80211_ATTR_BSS_SHORT_SLOT_TIME
, slot
);
7004 NLA_PUT_U16(msg
, NL80211_ATTR_BSS_HT_OPMODE
, ht_opmode
);
7005 if (ap_isolate
>= 0)
7006 NLA_PUT_U8(msg
, NL80211_ATTR_AP_ISOLATE
, ap_isolate
);
7009 u8 rates
[NL80211_MAX_SUPP_RATES
];
7013 for (i
= 0; i
< NL80211_MAX_SUPP_RATES
&& basic_rates
[i
] >= 0;
7015 rates
[rates_len
++] = basic_rates
[i
] / 5;
7017 NLA_PUT(msg
, NL80211_ATTR_BSS_BASIC_RATES
, rates_len
, rates
);
7020 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, if_nametoindex(bss
->ifname
));
7022 return send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
7029 static int wpa_driver_nl80211_set_acl(void *priv
,
7030 struct hostapd_acl_params
*params
)
7032 struct i802_bss
*bss
= priv
;
7033 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
7039 if (!(drv
->capa
.max_acl_mac_addrs
))
7042 if (params
->num_mac_acl
> drv
->capa
.max_acl_mac_addrs
)
7045 msg
= nlmsg_alloc();
7049 wpa_printf(MSG_DEBUG
, "nl80211: Set %s ACL (num_mac_acl=%u)",
7050 params
->acl_policy
? "Accept" : "Deny", params
->num_mac_acl
);
7052 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_SET_MAC_ACL
);
7054 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, drv
->ifindex
);
7056 NLA_PUT_U32(msg
, NL80211_ATTR_ACL_POLICY
, params
->acl_policy
?
7057 NL80211_ACL_POLICY_DENY_UNLESS_LISTED
:
7058 NL80211_ACL_POLICY_ACCEPT_UNLESS_LISTED
);
7060 acl
= nla_nest_start(msg
, NL80211_ATTR_MAC_ADDRS
);
7062 goto nla_put_failure
;
7064 for (i
= 0; i
< params
->num_mac_acl
; i
++)
7065 NLA_PUT(msg
, i
+ 1, ETH_ALEN
, params
->mac_acl
[i
].addr
);
7067 nla_nest_end(msg
, acl
);
7069 ret
= send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
7072 wpa_printf(MSG_DEBUG
, "nl80211: Failed to set MAC ACL: %d (%s)",
7073 ret
, strerror(-ret
));
7083 static int wpa_driver_nl80211_set_ap(void *priv
,
7084 struct wpa_driver_ap_params
*params
)
7086 struct i802_bss
*bss
= priv
;
7087 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
7089 u8 cmd
= NL80211_CMD_NEW_BEACON
;
7092 int ifindex
= if_nametoindex(bss
->ifname
);
7094 u32 suites
[10], suite
;
7097 beacon_set
= bss
->beacon_set
;
7099 msg
= nlmsg_alloc();
7103 wpa_printf(MSG_DEBUG
, "nl80211: Set beacon (beacon_set=%d)",
7106 cmd
= NL80211_CMD_SET_BEACON
;
7108 nl80211_cmd(drv
, msg
, 0, cmd
);
7109 wpa_hexdump(MSG_DEBUG
, "nl80211: Beacon head",
7110 params
->head
, params
->head_len
);
7111 NLA_PUT(msg
, NL80211_ATTR_BEACON_HEAD
, params
->head_len
, params
->head
);
7112 wpa_hexdump(MSG_DEBUG
, "nl80211: Beacon tail",
7113 params
->tail
, params
->tail_len
);
7114 NLA_PUT(msg
, NL80211_ATTR_BEACON_TAIL
, params
->tail_len
, params
->tail
);
7115 wpa_printf(MSG_DEBUG
, "nl80211: ifindex=%d", ifindex
);
7116 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, ifindex
);
7117 wpa_printf(MSG_DEBUG
, "nl80211: beacon_int=%d", params
->beacon_int
);
7118 NLA_PUT_U32(msg
, NL80211_ATTR_BEACON_INTERVAL
, params
->beacon_int
);
7119 wpa_printf(MSG_DEBUG
, "nl80211: dtim_period=%d", params
->dtim_period
);
7120 NLA_PUT_U32(msg
, NL80211_ATTR_DTIM_PERIOD
, params
->dtim_period
);
7121 wpa_hexdump_ascii(MSG_DEBUG
, "nl80211: ssid",
7122 params
->ssid
, params
->ssid_len
);
7123 NLA_PUT(msg
, NL80211_ATTR_SSID
, params
->ssid_len
,
7125 if (params
->proberesp
&& params
->proberesp_len
) {
7126 wpa_hexdump(MSG_DEBUG
, "nl80211: proberesp (offload)",
7127 params
->proberesp
, params
->proberesp_len
);
7128 NLA_PUT(msg
, NL80211_ATTR_PROBE_RESP
, params
->proberesp_len
,
7131 switch (params
->hide_ssid
) {
7132 case NO_SSID_HIDING
:
7133 wpa_printf(MSG_DEBUG
, "nl80211: hidden SSID not in use");
7134 NLA_PUT_U32(msg
, NL80211_ATTR_HIDDEN_SSID
,
7135 NL80211_HIDDEN_SSID_NOT_IN_USE
);
7137 case HIDDEN_SSID_ZERO_LEN
:
7138 wpa_printf(MSG_DEBUG
, "nl80211: hidden SSID zero len");
7139 NLA_PUT_U32(msg
, NL80211_ATTR_HIDDEN_SSID
,
7140 NL80211_HIDDEN_SSID_ZERO_LEN
);
7142 case HIDDEN_SSID_ZERO_CONTENTS
:
7143 wpa_printf(MSG_DEBUG
, "nl80211: hidden SSID zero contents");
7144 NLA_PUT_U32(msg
, NL80211_ATTR_HIDDEN_SSID
,
7145 NL80211_HIDDEN_SSID_ZERO_CONTENTS
);
7148 wpa_printf(MSG_DEBUG
, "nl80211: privacy=%d", params
->privacy
);
7149 if (params
->privacy
)
7150 NLA_PUT_FLAG(msg
, NL80211_ATTR_PRIVACY
);
7151 wpa_printf(MSG_DEBUG
, "nl80211: auth_algs=0x%x", params
->auth_algs
);
7152 if ((params
->auth_algs
& (WPA_AUTH_ALG_OPEN
| WPA_AUTH_ALG_SHARED
)) ==
7153 (WPA_AUTH_ALG_OPEN
| WPA_AUTH_ALG_SHARED
)) {
7154 /* Leave out the attribute */
7155 } else if (params
->auth_algs
& WPA_AUTH_ALG_SHARED
)
7156 NLA_PUT_U32(msg
, NL80211_ATTR_AUTH_TYPE
,
7157 NL80211_AUTHTYPE_SHARED_KEY
);
7159 NLA_PUT_U32(msg
, NL80211_ATTR_AUTH_TYPE
,
7160 NL80211_AUTHTYPE_OPEN_SYSTEM
);
7162 wpa_printf(MSG_DEBUG
, "nl80211: wpa_version=0x%x", params
->wpa_version
);
7164 if (params
->wpa_version
& WPA_PROTO_WPA
)
7165 ver
|= NL80211_WPA_VERSION_1
;
7166 if (params
->wpa_version
& WPA_PROTO_RSN
)
7167 ver
|= NL80211_WPA_VERSION_2
;
7169 NLA_PUT_U32(msg
, NL80211_ATTR_WPA_VERSIONS
, ver
);
7171 wpa_printf(MSG_DEBUG
, "nl80211: key_mgmt_suites=0x%x",
7172 params
->key_mgmt_suites
);
7174 if (params
->key_mgmt_suites
& WPA_KEY_MGMT_IEEE8021X
)
7175 suites
[num_suites
++] = WLAN_AKM_SUITE_8021X
;
7176 if (params
->key_mgmt_suites
& WPA_KEY_MGMT_PSK
)
7177 suites
[num_suites
++] = WLAN_AKM_SUITE_PSK
;
7179 NLA_PUT(msg
, NL80211_ATTR_AKM_SUITES
,
7180 num_suites
* sizeof(u32
), suites
);
7183 if (params
->key_mgmt_suites
& WPA_KEY_MGMT_IEEE8021X
&&
7184 params
->pairwise_ciphers
& (WPA_CIPHER_WEP104
| WPA_CIPHER_WEP40
))
7185 NLA_PUT_FLAG(msg
, NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT
);
7187 wpa_printf(MSG_DEBUG
, "nl80211: pairwise_ciphers=0x%x",
7188 params
->pairwise_ciphers
);
7189 num_suites
= wpa_cipher_to_cipher_suites(params
->pairwise_ciphers
,
7190 suites
, ARRAY_SIZE(suites
));
7192 NLA_PUT(msg
, NL80211_ATTR_CIPHER_SUITES_PAIRWISE
,
7193 num_suites
* sizeof(u32
), suites
);
7196 wpa_printf(MSG_DEBUG
, "nl80211: group_cipher=0x%x",
7197 params
->group_cipher
);
7198 suite
= wpa_cipher_to_cipher_suite(params
->group_cipher
);
7200 NLA_PUT_U32(msg
, NL80211_ATTR_CIPHER_SUITE_GROUP
, suite
);
7202 if (params
->beacon_ies
) {
7203 wpa_hexdump_buf(MSG_DEBUG
, "nl80211: beacon_ies",
7204 params
->beacon_ies
);
7205 NLA_PUT(msg
, NL80211_ATTR_IE
, wpabuf_len(params
->beacon_ies
),
7206 wpabuf_head(params
->beacon_ies
));
7208 if (params
->proberesp_ies
) {
7209 wpa_hexdump_buf(MSG_DEBUG
, "nl80211: proberesp_ies",
7210 params
->proberesp_ies
);
7211 NLA_PUT(msg
, NL80211_ATTR_IE_PROBE_RESP
,
7212 wpabuf_len(params
->proberesp_ies
),
7213 wpabuf_head(params
->proberesp_ies
));
7215 if (params
->assocresp_ies
) {
7216 wpa_hexdump_buf(MSG_DEBUG
, "nl80211: assocresp_ies",
7217 params
->assocresp_ies
);
7218 NLA_PUT(msg
, NL80211_ATTR_IE_ASSOC_RESP
,
7219 wpabuf_len(params
->assocresp_ies
),
7220 wpabuf_head(params
->assocresp_ies
));
7223 if (drv
->capa
.flags
& WPA_DRIVER_FLAGS_INACTIVITY_TIMER
) {
7224 wpa_printf(MSG_DEBUG
, "nl80211: ap_max_inactivity=%d",
7225 params
->ap_max_inactivity
);
7226 NLA_PUT_U16(msg
, NL80211_ATTR_INACTIVITY_TIMEOUT
,
7227 params
->ap_max_inactivity
);
7230 ret
= send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
7232 wpa_printf(MSG_DEBUG
, "nl80211: Beacon set failed: %d (%s)",
7233 ret
, strerror(-ret
));
7235 bss
->beacon_set
= 1;
7236 nl80211_set_bss(bss
, params
->cts_protect
, params
->preamble
,
7237 params
->short_slot_time
, params
->ht_opmode
,
7238 params
->isolate
, params
->basic_rates
);
7247 static int nl80211_put_freq_params(struct nl_msg
*msg
,
7248 struct hostapd_freq_params
*freq
)
7250 NLA_PUT_U32(msg
, NL80211_ATTR_WIPHY_FREQ
, freq
->freq
);
7251 if (freq
->vht_enabled
) {
7252 switch (freq
->bandwidth
) {
7254 NLA_PUT_U32(msg
, NL80211_ATTR_CHANNEL_WIDTH
,
7255 NL80211_CHAN_WIDTH_20
);
7258 NLA_PUT_U32(msg
, NL80211_ATTR_CHANNEL_WIDTH
,
7259 NL80211_CHAN_WIDTH_40
);
7262 if (freq
->center_freq2
)
7263 NLA_PUT_U32(msg
, NL80211_ATTR_CHANNEL_WIDTH
,
7264 NL80211_CHAN_WIDTH_80P80
);
7266 NLA_PUT_U32(msg
, NL80211_ATTR_CHANNEL_WIDTH
,
7267 NL80211_CHAN_WIDTH_80
);
7270 NLA_PUT_U32(msg
, NL80211_ATTR_CHANNEL_WIDTH
,
7271 NL80211_CHAN_WIDTH_160
);
7276 NLA_PUT_U32(msg
, NL80211_ATTR_CENTER_FREQ1
, freq
->center_freq1
);
7277 if (freq
->center_freq2
)
7278 NLA_PUT_U32(msg
, NL80211_ATTR_CENTER_FREQ2
,
7279 freq
->center_freq2
);
7280 } else if (freq
->ht_enabled
) {
7281 switch (freq
->sec_channel_offset
) {
7283 NLA_PUT_U32(msg
, NL80211_ATTR_WIPHY_CHANNEL_TYPE
,
7284 NL80211_CHAN_HT40MINUS
);
7287 NLA_PUT_U32(msg
, NL80211_ATTR_WIPHY_CHANNEL_TYPE
,
7288 NL80211_CHAN_HT40PLUS
);
7291 NLA_PUT_U32(msg
, NL80211_ATTR_WIPHY_CHANNEL_TYPE
,
7303 static int wpa_driver_nl80211_set_freq(struct i802_bss
*bss
,
7304 struct hostapd_freq_params
*freq
)
7306 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
7310 wpa_printf(MSG_DEBUG
,
7311 "nl80211: Set freq %d (ht_enabled=%d, vht_enabled=%d, bandwidth=%d MHz, cf1=%d MHz, cf2=%d MHz)",
7312 freq
->freq
, freq
->ht_enabled
, freq
->vht_enabled
,
7313 freq
->bandwidth
, freq
->center_freq1
, freq
->center_freq2
);
7314 msg
= nlmsg_alloc();
7318 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_SET_WIPHY
);
7320 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, drv
->ifindex
);
7321 if (nl80211_put_freq_params(msg
, freq
) < 0)
7322 goto nla_put_failure
;
7324 ret
= send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
7327 bss
->freq
= freq
->freq
;
7330 wpa_printf(MSG_DEBUG
, "nl80211: Failed to set channel (freq=%d): "
7331 "%d (%s)", freq
->freq
, ret
, strerror(-ret
));
7338 static u32
sta_flags_nl80211(int flags
)
7342 if (flags
& WPA_STA_AUTHORIZED
)
7343 f
|= BIT(NL80211_STA_FLAG_AUTHORIZED
);
7344 if (flags
& WPA_STA_WMM
)
7345 f
|= BIT(NL80211_STA_FLAG_WME
);
7346 if (flags
& WPA_STA_SHORT_PREAMBLE
)
7347 f
|= BIT(NL80211_STA_FLAG_SHORT_PREAMBLE
);
7348 if (flags
& WPA_STA_MFP
)
7349 f
|= BIT(NL80211_STA_FLAG_MFP
);
7350 if (flags
& WPA_STA_TDLS_PEER
)
7351 f
|= BIT(NL80211_STA_FLAG_TDLS_PEER
);
7357 static int wpa_driver_nl80211_sta_add(void *priv
,
7358 struct hostapd_sta_add_params
*params
)
7360 struct i802_bss
*bss
= priv
;
7361 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
7363 struct nl80211_sta_flag_update upd
;
7366 if ((params
->flags
& WPA_STA_TDLS_PEER
) &&
7367 !(drv
->capa
.flags
& WPA_DRIVER_FLAGS_TDLS_SUPPORT
))
7370 msg
= nlmsg_alloc();
7374 wpa_printf(MSG_DEBUG
, "nl80211: %s STA " MACSTR
,
7375 params
->set
? "Set" : "Add", MAC2STR(params
->addr
));
7376 nl80211_cmd(drv
, msg
, 0, params
->set
? NL80211_CMD_SET_STATION
:
7377 NL80211_CMD_NEW_STATION
);
7379 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, if_nametoindex(bss
->ifname
));
7380 NLA_PUT(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, params
->addr
);
7381 NLA_PUT(msg
, NL80211_ATTR_STA_SUPPORTED_RATES
, params
->supp_rates_len
,
7382 params
->supp_rates
);
7383 wpa_hexdump(MSG_DEBUG
, " * supported rates", params
->supp_rates
,
7384 params
->supp_rates_len
);
7387 wpa_printf(MSG_DEBUG
, " * aid=%u", params
->aid
);
7388 NLA_PUT_U16(msg
, NL80211_ATTR_STA_AID
, params
->aid
);
7391 * cfg80211 validates that AID is non-zero, so we have
7392 * to make this a non-zero value for the TDLS case where
7393 * a dummy STA entry is used for now.
7395 wpa_printf(MSG_DEBUG
, " * aid=1 (TDLS workaround)");
7396 NLA_PUT_U16(msg
, NL80211_ATTR_STA_AID
, 1);
7398 wpa_printf(MSG_DEBUG
, " * listen_interval=%u",
7399 params
->listen_interval
);
7400 NLA_PUT_U16(msg
, NL80211_ATTR_STA_LISTEN_INTERVAL
,
7401 params
->listen_interval
);
7402 } else if (params
->aid
&& (params
->flags
& WPA_STA_TDLS_PEER
)) {
7403 wpa_printf(MSG_DEBUG
, " * peer_aid=%u", params
->aid
);
7404 NLA_PUT_U16(msg
, NL80211_ATTR_PEER_AID
, params
->aid
);
7406 if (params
->ht_capabilities
) {
7407 wpa_hexdump(MSG_DEBUG
, " * ht_capabilities",
7408 (u8
*) params
->ht_capabilities
,
7409 sizeof(*params
->ht_capabilities
));
7410 NLA_PUT(msg
, NL80211_ATTR_HT_CAPABILITY
,
7411 sizeof(*params
->ht_capabilities
),
7412 params
->ht_capabilities
);
7415 if (params
->vht_capabilities
) {
7416 wpa_hexdump(MSG_DEBUG
, " * vht_capabilities",
7417 (u8
*) params
->vht_capabilities
,
7418 sizeof(*params
->vht_capabilities
));
7419 NLA_PUT(msg
, NL80211_ATTR_VHT_CAPABILITY
,
7420 sizeof(*params
->vht_capabilities
),
7421 params
->vht_capabilities
);
7424 if (params
->vht_opmode_enabled
) {
7425 wpa_printf(MSG_DEBUG
, " * opmode=%u", params
->vht_opmode
);
7426 NLA_PUT_U8(msg
, NL80211_ATTR_OPMODE_NOTIF
,
7427 params
->vht_opmode
);
7430 wpa_printf(MSG_DEBUG
, " * capability=0x%x", params
->capability
);
7431 NLA_PUT_U16(msg
, NL80211_ATTR_STA_CAPABILITY
, params
->capability
);
7433 if (params
->ext_capab
) {
7434 wpa_hexdump(MSG_DEBUG
, " * ext_capab",
7435 params
->ext_capab
, params
->ext_capab_len
);
7436 NLA_PUT(msg
, NL80211_ATTR_STA_EXT_CAPABILITY
,
7437 params
->ext_capab_len
, params
->ext_capab
);
7440 if (params
->supp_channels
) {
7441 wpa_hexdump(MSG_DEBUG
, " * supported channels",
7442 params
->supp_channels
, params
->supp_channels_len
);
7443 NLA_PUT(msg
, NL80211_ATTR_STA_SUPPORTED_CHANNELS
,
7444 params
->supp_channels_len
, params
->supp_channels
);
7447 if (params
->supp_oper_classes
) {
7448 wpa_hexdump(MSG_DEBUG
, " * supported operating classes",
7449 params
->supp_oper_classes
,
7450 params
->supp_oper_classes_len
);
7451 NLA_PUT(msg
, NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES
,
7452 params
->supp_oper_classes_len
,
7453 params
->supp_oper_classes
);
7456 os_memset(&upd
, 0, sizeof(upd
));
7457 upd
.mask
= sta_flags_nl80211(params
->flags
);
7459 wpa_printf(MSG_DEBUG
, " * flags set=0x%x mask=0x%x",
7461 NLA_PUT(msg
, NL80211_ATTR_STA_FLAGS2
, sizeof(upd
), &upd
);
7463 if (params
->flags
& WPA_STA_WMM
) {
7464 struct nlattr
*wme
= nla_nest_start(msg
, NL80211_ATTR_STA_WME
);
7467 goto nla_put_failure
;
7469 wpa_printf(MSG_DEBUG
, " * qosinfo=0x%x", params
->qosinfo
);
7470 NLA_PUT_U8(msg
, NL80211_STA_WME_UAPSD_QUEUES
,
7471 params
->qosinfo
& WMM_QOSINFO_STA_AC_MASK
);
7472 NLA_PUT_U8(msg
, NL80211_STA_WME_MAX_SP
,
7473 (params
->qosinfo
>> WMM_QOSINFO_STA_SP_SHIFT
) &
7474 WMM_QOSINFO_STA_SP_MASK
);
7475 nla_nest_end(msg
, wme
);
7478 ret
= send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
7481 wpa_printf(MSG_DEBUG
, "nl80211: NL80211_CMD_%s_STATION "
7482 "result: %d (%s)", params
->set
? "SET" : "NEW", ret
,
7492 static int wpa_driver_nl80211_sta_remove(struct i802_bss
*bss
, const u8
*addr
)
7494 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
7498 msg
= nlmsg_alloc();
7502 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_DEL_STATION
);
7504 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
,
7505 if_nametoindex(bss
->ifname
));
7506 NLA_PUT(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, addr
);
7508 ret
= send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
7509 wpa_printf(MSG_DEBUG
, "nl80211: sta_remove -> DEL_STATION %s " MACSTR
7511 bss
->ifname
, MAC2STR(addr
), ret
, strerror(-ret
));
7521 static void nl80211_remove_iface(struct wpa_driver_nl80211_data
*drv
,
7526 wpa_printf(MSG_DEBUG
, "nl80211: Remove interface ifindex=%d", ifidx
);
7528 /* stop listening for EAPOL on this interface */
7529 del_ifidx(drv
, ifidx
);
7531 msg
= nlmsg_alloc();
7533 goto nla_put_failure
;
7535 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_DEL_INTERFACE
);
7536 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, ifidx
);
7538 if (send_and_recv_msgs(drv
, msg
, NULL
, NULL
) == 0)
7543 wpa_printf(MSG_ERROR
, "Failed to remove interface (ifidx=%d)", ifidx
);
7547 static const char * nl80211_iftype_str(enum nl80211_iftype mode
)
7550 case NL80211_IFTYPE_ADHOC
:
7552 case NL80211_IFTYPE_STATION
:
7554 case NL80211_IFTYPE_AP
:
7556 case NL80211_IFTYPE_AP_VLAN
:
7558 case NL80211_IFTYPE_WDS
:
7560 case NL80211_IFTYPE_MONITOR
:
7562 case NL80211_IFTYPE_MESH_POINT
:
7563 return "MESH_POINT";
7564 case NL80211_IFTYPE_P2P_CLIENT
:
7565 return "P2P_CLIENT";
7566 case NL80211_IFTYPE_P2P_GO
:
7568 case NL80211_IFTYPE_P2P_DEVICE
:
7569 return "P2P_DEVICE";
7576 static int nl80211_create_iface_once(struct wpa_driver_nl80211_data
*drv
,
7578 enum nl80211_iftype iftype
,
7579 const u8
*addr
, int wds
,
7580 int (*handler
)(struct nl_msg
*, void *),
7587 wpa_printf(MSG_DEBUG
, "nl80211: Create interface iftype %d (%s)",
7588 iftype
, nl80211_iftype_str(iftype
));
7590 msg
= nlmsg_alloc();
7594 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_NEW_INTERFACE
);
7595 if (nl80211_set_iface_id(msg
, drv
->first_bss
) < 0)
7596 goto nla_put_failure
;
7597 NLA_PUT_STRING(msg
, NL80211_ATTR_IFNAME
, ifname
);
7598 NLA_PUT_U32(msg
, NL80211_ATTR_IFTYPE
, iftype
);
7600 if (iftype
== NL80211_IFTYPE_MONITOR
) {
7601 struct nlattr
*flags
;
7603 flags
= nla_nest_start(msg
, NL80211_ATTR_MNTR_FLAGS
);
7605 goto nla_put_failure
;
7607 NLA_PUT_FLAG(msg
, NL80211_MNTR_FLAG_COOK_FRAMES
);
7609 nla_nest_end(msg
, flags
);
7611 NLA_PUT_U8(msg
, NL80211_ATTR_4ADDR
, wds
);
7614 ret
= send_and_recv_msgs(drv
, msg
, handler
, arg
);
7619 wpa_printf(MSG_ERROR
, "Failed to create interface %s: %d (%s)",
7620 ifname
, ret
, strerror(-ret
));
7624 if (iftype
== NL80211_IFTYPE_P2P_DEVICE
)
7627 ifidx
= if_nametoindex(ifname
);
7628 wpa_printf(MSG_DEBUG
, "nl80211: New interface %s created: ifindex=%d",
7634 /* start listening for EAPOL on this interface */
7635 add_ifidx(drv
, ifidx
);
7637 if (addr
&& iftype
!= NL80211_IFTYPE_MONITOR
&&
7638 linux_set_ifhwaddr(drv
->global
->ioctl_sock
, ifname
, addr
)) {
7639 nl80211_remove_iface(drv
, ifidx
);
7647 static int nl80211_create_iface(struct wpa_driver_nl80211_data
*drv
,
7648 const char *ifname
, enum nl80211_iftype iftype
,
7649 const u8
*addr
, int wds
,
7650 int (*handler
)(struct nl_msg
*, void *),
7651 void *arg
, int use_existing
)
7655 ret
= nl80211_create_iface_once(drv
, ifname
, iftype
, addr
, wds
, handler
,
7658 /* if error occurred and interface exists already */
7659 if (ret
== -ENFILE
&& if_nametoindex(ifname
)) {
7661 wpa_printf(MSG_DEBUG
, "nl80211: Continue using existing interface %s",
7663 if (addr
&& iftype
!= NL80211_IFTYPE_MONITOR
&&
7664 linux_set_ifhwaddr(drv
->global
->ioctl_sock
, ifname
,
7666 (linux_set_iface_flags(drv
->global
->ioctl_sock
,
7668 linux_set_ifhwaddr(drv
->global
->ioctl_sock
, ifname
,
7670 linux_set_iface_flags(drv
->global
->ioctl_sock
,
7675 wpa_printf(MSG_INFO
, "Try to remove and re-create %s", ifname
);
7677 /* Try to remove the interface that was already there. */
7678 nl80211_remove_iface(drv
, if_nametoindex(ifname
));
7680 /* Try to create the interface again */
7681 ret
= nl80211_create_iface_once(drv
, ifname
, iftype
, addr
,
7685 if (ret
>= 0 && is_p2p_net_interface(iftype
))
7686 nl80211_disable_11b_rates(drv
, ret
, 1);
7692 static void handle_tx_callback(void *ctx
, u8
*buf
, size_t len
, int ok
)
7694 struct ieee80211_hdr
*hdr
;
7696 union wpa_event_data event
;
7698 hdr
= (struct ieee80211_hdr
*) buf
;
7699 fc
= le_to_host16(hdr
->frame_control
);
7701 os_memset(&event
, 0, sizeof(event
));
7702 event
.tx_status
.type
= WLAN_FC_GET_TYPE(fc
);
7703 event
.tx_status
.stype
= WLAN_FC_GET_STYPE(fc
);
7704 event
.tx_status
.dst
= hdr
->addr1
;
7705 event
.tx_status
.data
= buf
;
7706 event
.tx_status
.data_len
= len
;
7707 event
.tx_status
.ack
= ok
;
7708 wpa_supplicant_event(ctx
, EVENT_TX_STATUS
, &event
);
7712 static void from_unknown_sta(struct wpa_driver_nl80211_data
*drv
,
7713 u8
*buf
, size_t len
)
7715 struct ieee80211_hdr
*hdr
= (void *)buf
;
7717 union wpa_event_data event
;
7719 if (len
< sizeof(*hdr
))
7722 fc
= le_to_host16(hdr
->frame_control
);
7724 os_memset(&event
, 0, sizeof(event
));
7725 event
.rx_from_unknown
.bssid
= get_hdr_bssid(hdr
, len
);
7726 event
.rx_from_unknown
.addr
= hdr
->addr2
;
7727 event
.rx_from_unknown
.wds
= (fc
& (WLAN_FC_FROMDS
| WLAN_FC_TODS
)) ==
7728 (WLAN_FC_FROMDS
| WLAN_FC_TODS
);
7729 wpa_supplicant_event(drv
->ctx
, EVENT_RX_FROM_UNKNOWN
, &event
);
7733 static void handle_frame(struct wpa_driver_nl80211_data
*drv
,
7734 u8
*buf
, size_t len
, int datarate
, int ssi_signal
)
7736 struct ieee80211_hdr
*hdr
;
7738 union wpa_event_data event
;
7740 hdr
= (struct ieee80211_hdr
*) buf
;
7741 fc
= le_to_host16(hdr
->frame_control
);
7743 switch (WLAN_FC_GET_TYPE(fc
)) {
7744 case WLAN_FC_TYPE_MGMT
:
7745 os_memset(&event
, 0, sizeof(event
));
7746 event
.rx_mgmt
.frame
= buf
;
7747 event
.rx_mgmt
.frame_len
= len
;
7748 event
.rx_mgmt
.datarate
= datarate
;
7749 event
.rx_mgmt
.ssi_signal
= ssi_signal
;
7750 wpa_supplicant_event(drv
->ctx
, EVENT_RX_MGMT
, &event
);
7752 case WLAN_FC_TYPE_CTRL
:
7753 /* can only get here with PS-Poll frames */
7754 wpa_printf(MSG_DEBUG
, "CTRL");
7755 from_unknown_sta(drv
, buf
, len
);
7757 case WLAN_FC_TYPE_DATA
:
7758 from_unknown_sta(drv
, buf
, len
);
7764 static void handle_monitor_read(int sock
, void *eloop_ctx
, void *sock_ctx
)
7766 struct wpa_driver_nl80211_data
*drv
= eloop_ctx
;
7768 unsigned char buf
[3000];
7769 struct ieee80211_radiotap_iterator iter
;
7771 int datarate
= 0, ssi_signal
= 0;
7772 int injected
= 0, failed
= 0, rxflags
= 0;
7774 len
= recv(sock
, buf
, sizeof(buf
), 0);
7776 wpa_printf(MSG_ERROR
, "nl80211: Monitor socket recv failed: %s",
7781 if (ieee80211_radiotap_iterator_init(&iter
, (void*)buf
, len
)) {
7782 wpa_printf(MSG_INFO
, "nl80211: received invalid radiotap frame");
7787 ret
= ieee80211_radiotap_iterator_next(&iter
);
7791 wpa_printf(MSG_INFO
, "nl80211: received invalid radiotap frame (%d)",
7795 switch (iter
.this_arg_index
) {
7796 case IEEE80211_RADIOTAP_FLAGS
:
7797 if (*iter
.this_arg
& IEEE80211_RADIOTAP_F_FCS
)
7800 case IEEE80211_RADIOTAP_RX_FLAGS
:
7803 case IEEE80211_RADIOTAP_TX_FLAGS
:
7805 failed
= le_to_host16((*(uint16_t *) iter
.this_arg
)) &
7806 IEEE80211_RADIOTAP_F_TX_FAIL
;
7808 case IEEE80211_RADIOTAP_DATA_RETRIES
:
7810 case IEEE80211_RADIOTAP_CHANNEL
:
7811 /* TODO: convert from freq/flags to channel number */
7813 case IEEE80211_RADIOTAP_RATE
:
7814 datarate
= *iter
.this_arg
* 5;
7816 case IEEE80211_RADIOTAP_DBM_ANTSIGNAL
:
7817 ssi_signal
= (s8
) *iter
.this_arg
;
7822 if (rxflags
&& injected
)
7826 handle_frame(drv
, buf
+ iter
.max_length
,
7827 len
- iter
.max_length
, datarate
, ssi_signal
);
7829 handle_tx_callback(drv
->ctx
, buf
+ iter
.max_length
,
7830 len
- iter
.max_length
, !failed
);
7835 * we post-process the filter code later and rewrite
7836 * this to the offset to the last instruction
7841 static struct sock_filter msock_filter_insns
[] = {
7843 * do a little-endian load of the radiotap length field
7845 /* load lower byte into A */
7846 BPF_STMT(BPF_LD
| BPF_B
| BPF_ABS
, 2),
7847 /* put it into X (== index register) */
7848 BPF_STMT(BPF_MISC
| BPF_TAX
, 0),
7849 /* load upper byte into A */
7850 BPF_STMT(BPF_LD
| BPF_B
| BPF_ABS
, 3),
7851 /* left-shift it by 8 */
7852 BPF_STMT(BPF_ALU
| BPF_LSH
| BPF_K
, 8),
7854 BPF_STMT(BPF_ALU
| BPF_OR
| BPF_X
, 0),
7855 /* put result into X */
7856 BPF_STMT(BPF_MISC
| BPF_TAX
, 0),
7859 * Allow management frames through, this also gives us those
7860 * management frames that we sent ourselves with status
7862 /* load the lower byte of the IEEE 802.11 frame control field */
7863 BPF_STMT(BPF_LD
| BPF_B
| BPF_IND
, 0),
7864 /* mask off frame type and version */
7865 BPF_STMT(BPF_ALU
| BPF_AND
| BPF_K
, 0xF),
7866 /* accept frame if it's both 0, fall through otherwise */
7867 BPF_JUMP(BPF_JMP
| BPF_JEQ
| BPF_K
, 0, PASS
, 0),
7870 * TODO: add a bit to radiotap RX flags that indicates
7871 * that the sending station is not associated, then
7872 * add a filter here that filters on our DA and that flag
7873 * to allow us to deauth frames to that bad station.
7875 * For now allow all To DS data frames through.
7877 /* load the IEEE 802.11 frame control field */
7878 BPF_STMT(BPF_LD
| BPF_H
| BPF_IND
, 0),
7879 /* mask off frame type, version and DS status */
7880 BPF_STMT(BPF_ALU
| BPF_AND
| BPF_K
, 0x0F03),
7881 /* accept frame if version 0, type 2 and To DS, fall through otherwise
7883 BPF_JUMP(BPF_JMP
| BPF_JEQ
| BPF_K
, 0x0801, PASS
, 0),
7887 * drop non-data frames
7889 /* load the lower byte of the frame control field */
7890 BPF_STMT(BPF_LD
| BPF_B
| BPF_IND
, 0),
7891 /* mask off QoS bit */
7892 BPF_STMT(BPF_ALU
| BPF_AND
| BPF_K
, 0x0c),
7893 /* drop non-data frames */
7894 BPF_JUMP(BPF_JMP
| BPF_JEQ
| BPF_K
, 8, 0, FAIL
),
7896 /* load the upper byte of the frame control field */
7897 BPF_STMT(BPF_LD
| BPF_B
| BPF_IND
, 1),
7898 /* mask off toDS/fromDS */
7899 BPF_STMT(BPF_ALU
| BPF_AND
| BPF_K
, 0x03),
7900 /* accept WDS frames */
7901 BPF_JUMP(BPF_JMP
| BPF_JEQ
| BPF_K
, 3, PASS
, 0),
7904 * add header length to index
7906 /* load the lower byte of the frame control field */
7907 BPF_STMT(BPF_LD
| BPF_B
| BPF_IND
, 0),
7908 /* mask off QoS bit */
7909 BPF_STMT(BPF_ALU
| BPF_AND
| BPF_K
, 0x80),
7910 /* right shift it by 6 to give 0 or 2 */
7911 BPF_STMT(BPF_ALU
| BPF_RSH
| BPF_K
, 6),
7912 /* add data frame header length */
7913 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_K
, 24),
7914 /* add index, was start of 802.11 header */
7915 BPF_STMT(BPF_ALU
| BPF_ADD
| BPF_X
, 0),
7916 /* move to index, now start of LL header */
7917 BPF_STMT(BPF_MISC
| BPF_TAX
, 0),
7920 * Accept empty data frames, we use those for
7923 BPF_STMT(BPF_LD
| BPF_W
| BPF_LEN
, 0),
7924 BPF_JUMP(BPF_JMP
| BPF_JEQ
| BPF_X
, 0, PASS
, 0),
7927 * Accept EAPOL frames
7929 BPF_STMT(BPF_LD
| BPF_W
| BPF_IND
, 0),
7930 BPF_JUMP(BPF_JMP
| BPF_JEQ
| BPF_K
, 0xAAAA0300, 0, FAIL
),
7931 BPF_STMT(BPF_LD
| BPF_W
| BPF_IND
, 4),
7932 BPF_JUMP(BPF_JMP
| BPF_JEQ
| BPF_K
, 0x0000888E, PASS
, FAIL
),
7934 /* keep these last two statements or change the code below */
7935 /* return 0 == "DROP" */
7936 BPF_STMT(BPF_RET
| BPF_K
, 0),
7937 /* return ~0 == "keep all" */
7938 BPF_STMT(BPF_RET
| BPF_K
, ~0),
7941 static struct sock_fprog msock_filter
= {
7942 .len
= ARRAY_SIZE(msock_filter_insns
),
7943 .filter
= msock_filter_insns
,
7947 static int add_monitor_filter(int s
)
7951 /* rewrite all PASS/FAIL jump offsets */
7952 for (idx
= 0; idx
< msock_filter
.len
; idx
++) {
7953 struct sock_filter
*insn
= &msock_filter_insns
[idx
];
7955 if (BPF_CLASS(insn
->code
) == BPF_JMP
) {
7956 if (insn
->code
== (BPF_JMP
|BPF_JA
)) {
7957 if (insn
->k
== PASS
)
7958 insn
->k
= msock_filter
.len
- idx
- 2;
7959 else if (insn
->k
== FAIL
)
7960 insn
->k
= msock_filter
.len
- idx
- 3;
7963 if (insn
->jt
== PASS
)
7964 insn
->jt
= msock_filter
.len
- idx
- 2;
7965 else if (insn
->jt
== FAIL
)
7966 insn
->jt
= msock_filter
.len
- idx
- 3;
7968 if (insn
->jf
== PASS
)
7969 insn
->jf
= msock_filter
.len
- idx
- 2;
7970 else if (insn
->jf
== FAIL
)
7971 insn
->jf
= msock_filter
.len
- idx
- 3;
7975 if (setsockopt(s
, SOL_SOCKET
, SO_ATTACH_FILTER
,
7976 &msock_filter
, sizeof(msock_filter
))) {
7977 wpa_printf(MSG_ERROR
, "nl80211: setsockopt(SO_ATTACH_FILTER) failed: %s",
7986 static void nl80211_remove_monitor_interface(
7987 struct wpa_driver_nl80211_data
*drv
)
7989 if (drv
->monitor_refcount
> 0)
7990 drv
->monitor_refcount
--;
7991 wpa_printf(MSG_DEBUG
, "nl80211: Remove monitor interface: refcount=%d",
7992 drv
->monitor_refcount
);
7993 if (drv
->monitor_refcount
> 0)
7996 if (drv
->monitor_ifidx
>= 0) {
7997 nl80211_remove_iface(drv
, drv
->monitor_ifidx
);
7998 drv
->monitor_ifidx
= -1;
8000 if (drv
->monitor_sock
>= 0) {
8001 eloop_unregister_read_sock(drv
->monitor_sock
);
8002 close(drv
->monitor_sock
);
8003 drv
->monitor_sock
= -1;
8009 nl80211_create_monitor_interface(struct wpa_driver_nl80211_data
*drv
)
8012 struct sockaddr_ll ll
;
8016 if (drv
->monitor_ifidx
>= 0) {
8017 drv
->monitor_refcount
++;
8018 wpa_printf(MSG_DEBUG
, "nl80211: Re-use existing monitor interface: refcount=%d",
8019 drv
->monitor_refcount
);
8023 if (os_strncmp(drv
->first_bss
->ifname
, "p2p-", 4) == 0) {
8025 * P2P interface name is of the format p2p-%s-%d. For monitor
8026 * interface name corresponding to P2P GO, replace "p2p-" with
8027 * "mon-" to retain the same interface name length and to
8028 * indicate that it is a monitor interface.
8030 snprintf(buf
, IFNAMSIZ
, "mon-%s", drv
->first_bss
->ifname
+ 4);
8032 /* Non-P2P interface with AP functionality. */
8033 snprintf(buf
, IFNAMSIZ
, "mon.%s", drv
->first_bss
->ifname
);
8036 buf
[IFNAMSIZ
- 1] = '\0';
8038 drv
->monitor_ifidx
=
8039 nl80211_create_iface(drv
, buf
, NL80211_IFTYPE_MONITOR
, NULL
,
8042 if (drv
->monitor_ifidx
== -EOPNOTSUPP
) {
8044 * This is backward compatibility for a few versions of
8045 * the kernel only that didn't advertise the right
8046 * attributes for the only driver that then supported
8047 * AP mode w/o monitor -- ath6kl.
8049 wpa_printf(MSG_DEBUG
, "nl80211: Driver does not support "
8050 "monitor interface type - try to run without it");
8051 drv
->device_ap_sme
= 1;
8054 if (drv
->monitor_ifidx
< 0)
8057 if (linux_set_iface_flags(drv
->global
->ioctl_sock
, buf
, 1))
8060 memset(&ll
, 0, sizeof(ll
));
8061 ll
.sll_family
= AF_PACKET
;
8062 ll
.sll_ifindex
= drv
->monitor_ifidx
;
8063 drv
->monitor_sock
= socket(PF_PACKET
, SOCK_RAW
, htons(ETH_P_ALL
));
8064 if (drv
->monitor_sock
< 0) {
8065 wpa_printf(MSG_ERROR
, "nl80211: socket[PF_PACKET,SOCK_RAW] failed: %s",
8070 if (add_monitor_filter(drv
->monitor_sock
)) {
8071 wpa_printf(MSG_INFO
, "Failed to set socket filter for monitor "
8072 "interface; do filtering in user space");
8073 /* This works, but will cost in performance. */
8076 if (bind(drv
->monitor_sock
, (struct sockaddr
*) &ll
, sizeof(ll
)) < 0) {
8077 wpa_printf(MSG_ERROR
, "nl80211: monitor socket bind failed: %s",
8082 optlen
= sizeof(optval
);
8085 (drv
->monitor_sock
, SOL_SOCKET
, SO_PRIORITY
, &optval
, optlen
)) {
8086 wpa_printf(MSG_ERROR
, "nl80211: Failed to set socket priority: %s",
8091 if (eloop_register_read_sock(drv
->monitor_sock
, handle_monitor_read
,
8093 wpa_printf(MSG_INFO
, "nl80211: Could not register monitor read socket");
8097 drv
->monitor_refcount
++;
8100 nl80211_remove_monitor_interface(drv
);
8105 static int nl80211_setup_ap(struct i802_bss
*bss
)
8107 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
8109 wpa_printf(MSG_DEBUG
, "nl80211: Setup AP(%s) - device_ap_sme=%d use_monitor=%d",
8110 bss
->ifname
, drv
->device_ap_sme
, drv
->use_monitor
);
8113 * Disable Probe Request reporting unless we need it in this way for
8114 * devices that include the AP SME, in the other case (unless using
8115 * monitor iface) we'll get it through the nl_mgmt socket instead.
8117 if (!drv
->device_ap_sme
)
8118 wpa_driver_nl80211_probe_req_report(bss
, 0);
8120 if (!drv
->device_ap_sme
&& !drv
->use_monitor
)
8121 if (nl80211_mgmt_subscribe_ap(bss
))
8124 if (drv
->device_ap_sme
&& !drv
->use_monitor
)
8125 if (nl80211_mgmt_subscribe_ap_dev_sme(bss
))
8128 if (!drv
->device_ap_sme
&& drv
->use_monitor
&&
8129 nl80211_create_monitor_interface(drv
) &&
8130 !drv
->device_ap_sme
)
8133 if (drv
->device_ap_sme
&&
8134 wpa_driver_nl80211_probe_req_report(bss
, 1) < 0) {
8135 wpa_printf(MSG_DEBUG
, "nl80211: Failed to enable "
8136 "Probe Request frame reporting in AP mode");
8137 /* Try to survive without this */
8144 static void nl80211_teardown_ap(struct i802_bss
*bss
)
8146 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
8148 wpa_printf(MSG_DEBUG
, "nl80211: Teardown AP(%s) - device_ap_sme=%d use_monitor=%d",
8149 bss
->ifname
, drv
->device_ap_sme
, drv
->use_monitor
);
8150 if (drv
->device_ap_sme
) {
8151 wpa_driver_nl80211_probe_req_report(bss
, 0);
8152 if (!drv
->use_monitor
)
8153 nl80211_mgmt_unsubscribe(bss
, "AP teardown (dev SME)");
8154 } else if (drv
->use_monitor
)
8155 nl80211_remove_monitor_interface(drv
);
8157 nl80211_mgmt_unsubscribe(bss
, "AP teardown");
8159 bss
->beacon_set
= 0;
8163 static int nl80211_send_eapol_data(struct i802_bss
*bss
,
8164 const u8
*addr
, const u8
*data
,
8167 struct sockaddr_ll ll
;
8170 if (bss
->drv
->eapol_tx_sock
< 0) {
8171 wpa_printf(MSG_DEBUG
, "nl80211: No socket to send EAPOL");
8175 os_memset(&ll
, 0, sizeof(ll
));
8176 ll
.sll_family
= AF_PACKET
;
8177 ll
.sll_ifindex
= bss
->ifindex
;
8178 ll
.sll_protocol
= htons(ETH_P_PAE
);
8179 ll
.sll_halen
= ETH_ALEN
;
8180 os_memcpy(ll
.sll_addr
, addr
, ETH_ALEN
);
8181 ret
= sendto(bss
->drv
->eapol_tx_sock
, data
, data_len
, 0,
8182 (struct sockaddr
*) &ll
, sizeof(ll
));
8184 wpa_printf(MSG_ERROR
, "nl80211: EAPOL TX: %s",
8191 static const u8 rfc1042_header
[6] = { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00 };
8193 static int wpa_driver_nl80211_hapd_send_eapol(
8194 void *priv
, const u8
*addr
, const u8
*data
,
8195 size_t data_len
, int encrypt
, const u8
*own_addr
, u32 flags
)
8197 struct i802_bss
*bss
= priv
;
8198 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
8199 struct ieee80211_hdr
*hdr
;
8203 int qos
= flags
& WPA_STA_WMM
;
8205 if (drv
->device_ap_sme
|| !drv
->use_monitor
)
8206 return nl80211_send_eapol_data(bss
, addr
, data
, data_len
);
8208 len
= sizeof(*hdr
) + (qos
? 2 : 0) + sizeof(rfc1042_header
) + 2 +
8210 hdr
= os_zalloc(len
);
8212 wpa_printf(MSG_INFO
, "nl80211: Failed to allocate EAPOL buffer(len=%lu)",
8213 (unsigned long) len
);
8217 hdr
->frame_control
=
8218 IEEE80211_FC(WLAN_FC_TYPE_DATA
, WLAN_FC_STYPE_DATA
);
8219 hdr
->frame_control
|= host_to_le16(WLAN_FC_FROMDS
);
8221 hdr
->frame_control
|= host_to_le16(WLAN_FC_ISWEP
);
8223 hdr
->frame_control
|=
8224 host_to_le16(WLAN_FC_STYPE_QOS_DATA
<< 4);
8227 memcpy(hdr
->IEEE80211_DA_FROMDS
, addr
, ETH_ALEN
);
8228 memcpy(hdr
->IEEE80211_BSSID_FROMDS
, own_addr
, ETH_ALEN
);
8229 memcpy(hdr
->IEEE80211_SA_FROMDS
, own_addr
, ETH_ALEN
);
8230 pos
= (u8
*) (hdr
+ 1);
8233 /* Set highest priority in QoS header */
8239 memcpy(pos
, rfc1042_header
, sizeof(rfc1042_header
));
8240 pos
+= sizeof(rfc1042_header
);
8241 WPA_PUT_BE16(pos
, ETH_P_PAE
);
8243 memcpy(pos
, data
, data_len
);
8245 res
= wpa_driver_nl80211_send_frame(bss
, (u8
*) hdr
, len
, encrypt
, 0,
8248 wpa_printf(MSG_ERROR
, "i802_send_eapol - packet len: %lu - "
8250 (unsigned long) len
, errno
, strerror(errno
));
8258 static int wpa_driver_nl80211_sta_set_flags(void *priv
, const u8
*addr
,
8260 int flags_or
, int flags_and
)
8262 struct i802_bss
*bss
= priv
;
8263 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
8265 struct nlattr
*flags
;
8266 struct nl80211_sta_flag_update upd
;
8268 msg
= nlmsg_alloc();
8272 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_SET_STATION
);
8274 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
,
8275 if_nametoindex(bss
->ifname
));
8276 NLA_PUT(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, addr
);
8279 * Backwards compatibility version using NL80211_ATTR_STA_FLAGS. This
8280 * can be removed eventually.
8282 flags
= nla_nest_start(msg
, NL80211_ATTR_STA_FLAGS
);
8284 goto nla_put_failure
;
8285 if (total_flags
& WPA_STA_AUTHORIZED
)
8286 NLA_PUT_FLAG(msg
, NL80211_STA_FLAG_AUTHORIZED
);
8288 if (total_flags
& WPA_STA_WMM
)
8289 NLA_PUT_FLAG(msg
, NL80211_STA_FLAG_WME
);
8291 if (total_flags
& WPA_STA_SHORT_PREAMBLE
)
8292 NLA_PUT_FLAG(msg
, NL80211_STA_FLAG_SHORT_PREAMBLE
);
8294 if (total_flags
& WPA_STA_MFP
)
8295 NLA_PUT_FLAG(msg
, NL80211_STA_FLAG_MFP
);
8297 if (total_flags
& WPA_STA_TDLS_PEER
)
8298 NLA_PUT_FLAG(msg
, NL80211_STA_FLAG_TDLS_PEER
);
8300 nla_nest_end(msg
, flags
);
8302 os_memset(&upd
, 0, sizeof(upd
));
8303 upd
.mask
= sta_flags_nl80211(flags_or
| ~flags_and
);
8304 upd
.set
= sta_flags_nl80211(flags_or
);
8305 NLA_PUT(msg
, NL80211_ATTR_STA_FLAGS2
, sizeof(upd
), &upd
);
8307 return send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
8314 static int wpa_driver_nl80211_ap(struct wpa_driver_nl80211_data
*drv
,
8315 struct wpa_driver_associate_params
*params
)
8317 enum nl80211_iftype nlmode
, old_mode
;
8318 struct hostapd_freq_params freq
= {
8319 .freq
= params
->freq
,
8323 wpa_printf(MSG_DEBUG
, "nl80211: Setup AP operations for P2P "
8325 nlmode
= NL80211_IFTYPE_P2P_GO
;
8327 nlmode
= NL80211_IFTYPE_AP
;
8329 old_mode
= drv
->nlmode
;
8330 if (wpa_driver_nl80211_set_mode(drv
->first_bss
, nlmode
)) {
8331 nl80211_remove_monitor_interface(drv
);
8335 if (wpa_driver_nl80211_set_freq(drv
->first_bss
, &freq
)) {
8336 if (old_mode
!= nlmode
)
8337 wpa_driver_nl80211_set_mode(drv
->first_bss
, old_mode
);
8338 nl80211_remove_monitor_interface(drv
);
8346 static int nl80211_leave_ibss(struct wpa_driver_nl80211_data
*drv
)
8351 msg
= nlmsg_alloc();
8355 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_LEAVE_IBSS
);
8356 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, drv
->ifindex
);
8357 ret
= send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
8360 wpa_printf(MSG_DEBUG
, "nl80211: Leave IBSS failed: ret=%d "
8361 "(%s)", ret
, strerror(-ret
));
8362 goto nla_put_failure
;
8366 wpa_printf(MSG_DEBUG
, "nl80211: Leave IBSS request sent successfully");
8369 if (wpa_driver_nl80211_set_mode(drv
->first_bss
,
8370 NL80211_IFTYPE_STATION
)) {
8371 wpa_printf(MSG_INFO
, "nl80211: Failed to set interface into "
8380 static int wpa_driver_nl80211_ibss(struct wpa_driver_nl80211_data
*drv
,
8381 struct wpa_driver_associate_params
*params
)
8387 wpa_printf(MSG_DEBUG
, "nl80211: Join IBSS (ifindex=%d)", drv
->ifindex
);
8389 if (wpa_driver_nl80211_set_mode(drv
->first_bss
,
8390 NL80211_IFTYPE_ADHOC
)) {
8391 wpa_printf(MSG_INFO
, "nl80211: Failed to set interface into "
8397 msg
= nlmsg_alloc();
8401 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_JOIN_IBSS
);
8402 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, drv
->ifindex
);
8404 if (params
->ssid
== NULL
|| params
->ssid_len
> sizeof(drv
->ssid
))
8405 goto nla_put_failure
;
8407 wpa_hexdump_ascii(MSG_DEBUG
, " * SSID",
8408 params
->ssid
, params
->ssid_len
);
8409 NLA_PUT(msg
, NL80211_ATTR_SSID
, params
->ssid_len
,
8411 os_memcpy(drv
->ssid
, params
->ssid
, params
->ssid_len
);
8412 drv
->ssid_len
= params
->ssid_len
;
8414 wpa_printf(MSG_DEBUG
, " * freq=%d", params
->freq
);
8415 NLA_PUT_U32(msg
, NL80211_ATTR_WIPHY_FREQ
, params
->freq
);
8417 if (params
->beacon_int
> 0) {
8418 wpa_printf(MSG_DEBUG
, " * beacon_int=%d", params
->beacon_int
);
8419 NLA_PUT_U32(msg
, NL80211_ATTR_BEACON_INTERVAL
,
8420 params
->beacon_int
);
8423 ret
= nl80211_set_conn_keys(params
, msg
);
8425 goto nla_put_failure
;
8427 if (params
->bssid
&& params
->fixed_bssid
) {
8428 wpa_printf(MSG_DEBUG
, " * BSSID=" MACSTR
,
8429 MAC2STR(params
->bssid
));
8430 NLA_PUT(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, params
->bssid
);
8433 if (params
->key_mgmt_suite
== WPA_KEY_MGMT_IEEE8021X
||
8434 params
->key_mgmt_suite
== WPA_KEY_MGMT_PSK
||
8435 params
->key_mgmt_suite
== WPA_KEY_MGMT_IEEE8021X_SHA256
||
8436 params
->key_mgmt_suite
== WPA_KEY_MGMT_PSK_SHA256
) {
8437 wpa_printf(MSG_DEBUG
, " * control port");
8438 NLA_PUT_FLAG(msg
, NL80211_ATTR_CONTROL_PORT
);
8441 if (params
->wpa_ie
) {
8442 wpa_hexdump(MSG_DEBUG
,
8443 " * Extra IEs for Beacon/Probe Response frames",
8444 params
->wpa_ie
, params
->wpa_ie_len
);
8445 NLA_PUT(msg
, NL80211_ATTR_IE
, params
->wpa_ie_len
,
8449 ret
= send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
8452 wpa_printf(MSG_DEBUG
, "nl80211: Join IBSS failed: ret=%d (%s)",
8453 ret
, strerror(-ret
));
8455 if (ret
== -EALREADY
&& count
== 1) {
8456 wpa_printf(MSG_DEBUG
, "nl80211: Retry IBSS join after "
8458 nl80211_leave_ibss(drv
);
8463 goto nla_put_failure
;
8466 wpa_printf(MSG_DEBUG
, "nl80211: Join IBSS request sent successfully");
8474 static int nl80211_connect_common(struct wpa_driver_nl80211_data
*drv
,
8475 struct wpa_driver_associate_params
*params
,
8478 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, drv
->ifindex
);
8480 if (params
->bssid
) {
8481 wpa_printf(MSG_DEBUG
, " * bssid=" MACSTR
,
8482 MAC2STR(params
->bssid
));
8483 NLA_PUT(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, params
->bssid
);
8486 if (params
->bssid_hint
) {
8487 wpa_printf(MSG_DEBUG
, " * bssid_hint=" MACSTR
,
8488 MAC2STR(params
->bssid_hint
));
8489 NLA_PUT(msg
, NL80211_ATTR_MAC_HINT
, ETH_ALEN
,
8490 params
->bssid_hint
);
8494 wpa_printf(MSG_DEBUG
, " * freq=%d", params
->freq
);
8495 NLA_PUT_U32(msg
, NL80211_ATTR_WIPHY_FREQ
, params
->freq
);
8496 drv
->assoc_freq
= params
->freq
;
8498 drv
->assoc_freq
= 0;
8500 if (params
->freq_hint
) {
8501 wpa_printf(MSG_DEBUG
, " * freq_hint=%d", params
->freq_hint
);
8502 NLA_PUT_U32(msg
, NL80211_ATTR_WIPHY_FREQ_HINT
,
8506 if (params
->bg_scan_period
>= 0) {
8507 wpa_printf(MSG_DEBUG
, " * bg scan period=%d",
8508 params
->bg_scan_period
);
8509 NLA_PUT_U16(msg
, NL80211_ATTR_BG_SCAN_PERIOD
,
8510 params
->bg_scan_period
);
8514 wpa_hexdump_ascii(MSG_DEBUG
, " * SSID",
8515 params
->ssid
, params
->ssid_len
);
8516 NLA_PUT(msg
, NL80211_ATTR_SSID
, params
->ssid_len
,
8518 if (params
->ssid_len
> sizeof(drv
->ssid
))
8519 goto nla_put_failure
;
8520 os_memcpy(drv
->ssid
, params
->ssid
, params
->ssid_len
);
8521 drv
->ssid_len
= params
->ssid_len
;
8524 wpa_hexdump(MSG_DEBUG
, " * IEs", params
->wpa_ie
, params
->wpa_ie_len
);
8526 NLA_PUT(msg
, NL80211_ATTR_IE
, params
->wpa_ie_len
,
8529 if (params
->wpa_proto
) {
8530 enum nl80211_wpa_versions ver
= 0;
8532 if (params
->wpa_proto
& WPA_PROTO_WPA
)
8533 ver
|= NL80211_WPA_VERSION_1
;
8534 if (params
->wpa_proto
& WPA_PROTO_RSN
)
8535 ver
|= NL80211_WPA_VERSION_2
;
8537 wpa_printf(MSG_DEBUG
, " * WPA Versions 0x%x", ver
);
8538 NLA_PUT_U32(msg
, NL80211_ATTR_WPA_VERSIONS
, ver
);
8541 if (params
->pairwise_suite
!= WPA_CIPHER_NONE
) {
8542 u32 cipher
= wpa_cipher_to_cipher_suite(params
->pairwise_suite
);
8543 wpa_printf(MSG_DEBUG
, " * pairwise=0x%x", cipher
);
8544 NLA_PUT_U32(msg
, NL80211_ATTR_CIPHER_SUITES_PAIRWISE
, cipher
);
8547 if (params
->group_suite
== WPA_CIPHER_GTK_NOT_USED
&&
8548 !(drv
->capa
.enc
& WPA_DRIVER_CAPA_ENC_GTK_NOT_USED
)) {
8550 * This is likely to work even though many drivers do not
8551 * advertise support for operations without GTK.
8553 wpa_printf(MSG_DEBUG
, " * skip group cipher configuration for GTK_NOT_USED due to missing driver support advertisement");
8554 } else if (params
->group_suite
!= WPA_CIPHER_NONE
) {
8555 u32 cipher
= wpa_cipher_to_cipher_suite(params
->group_suite
);
8556 wpa_printf(MSG_DEBUG
, " * group=0x%x", cipher
);
8557 NLA_PUT_U32(msg
, NL80211_ATTR_CIPHER_SUITE_GROUP
, cipher
);
8560 if (params
->key_mgmt_suite
== WPA_KEY_MGMT_IEEE8021X
||
8561 params
->key_mgmt_suite
== WPA_KEY_MGMT_PSK
||
8562 params
->key_mgmt_suite
== WPA_KEY_MGMT_FT_IEEE8021X
||
8563 params
->key_mgmt_suite
== WPA_KEY_MGMT_FT_PSK
||
8564 params
->key_mgmt_suite
== WPA_KEY_MGMT_CCKM
||
8565 params
->key_mgmt_suite
== WPA_KEY_MGMT_OSEN
) {
8566 int mgmt
= WLAN_AKM_SUITE_PSK
;
8568 switch (params
->key_mgmt_suite
) {
8569 case WPA_KEY_MGMT_CCKM
:
8570 mgmt
= WLAN_AKM_SUITE_CCKM
;
8572 case WPA_KEY_MGMT_IEEE8021X
:
8573 mgmt
= WLAN_AKM_SUITE_8021X
;
8575 case WPA_KEY_MGMT_FT_IEEE8021X
:
8576 mgmt
= WLAN_AKM_SUITE_FT_8021X
;
8578 case WPA_KEY_MGMT_FT_PSK
:
8579 mgmt
= WLAN_AKM_SUITE_FT_PSK
;
8581 case WPA_KEY_MGMT_OSEN
:
8582 mgmt
= WLAN_AKM_SUITE_OSEN
;
8584 case WPA_KEY_MGMT_PSK
:
8586 mgmt
= WLAN_AKM_SUITE_PSK
;
8589 wpa_printf(MSG_DEBUG
, " * akm=0x%x", mgmt
);
8590 NLA_PUT_U32(msg
, NL80211_ATTR_AKM_SUITES
, mgmt
);
8593 NLA_PUT_FLAG(msg
, NL80211_ATTR_CONTROL_PORT
);
8595 if (params
->mgmt_frame_protection
== MGMT_FRAME_PROTECTION_REQUIRED
)
8596 NLA_PUT_U32(msg
, NL80211_ATTR_USE_MFP
, NL80211_MFP_REQUIRED
);
8598 if (params
->disable_ht
)
8599 NLA_PUT_FLAG(msg
, NL80211_ATTR_DISABLE_HT
);
8601 if (params
->htcaps
&& params
->htcaps_mask
) {
8602 int sz
= sizeof(struct ieee80211_ht_capabilities
);
8603 NLA_PUT(msg
, NL80211_ATTR_HT_CAPABILITY
, sz
, params
->htcaps
);
8604 NLA_PUT(msg
, NL80211_ATTR_HT_CAPABILITY_MASK
, sz
,
8605 params
->htcaps_mask
);
8608 #ifdef CONFIG_VHT_OVERRIDES
8609 if (params
->disable_vht
) {
8610 wpa_printf(MSG_DEBUG
, " * VHT disabled");
8611 NLA_PUT_FLAG(msg
, NL80211_ATTR_DISABLE_VHT
);
8614 if (params
->vhtcaps
&& params
->vhtcaps_mask
) {
8615 int sz
= sizeof(struct ieee80211_vht_capabilities
);
8616 NLA_PUT(msg
, NL80211_ATTR_VHT_CAPABILITY
, sz
, params
->vhtcaps
);
8617 NLA_PUT(msg
, NL80211_ATTR_VHT_CAPABILITY_MASK
, sz
,
8618 params
->vhtcaps_mask
);
8620 #endif /* CONFIG_VHT_OVERRIDES */
8623 wpa_printf(MSG_DEBUG
, " * P2P group");
8631 static int wpa_driver_nl80211_try_connect(
8632 struct wpa_driver_nl80211_data
*drv
,
8633 struct wpa_driver_associate_params
*params
)
8636 enum nl80211_auth_type type
;
8640 msg
= nlmsg_alloc();
8644 wpa_printf(MSG_DEBUG
, "nl80211: Connect (ifindex=%d)", drv
->ifindex
);
8645 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_CONNECT
);
8647 ret
= nl80211_connect_common(drv
, params
, msg
);
8649 goto nla_put_failure
;
8652 if (params
->auth_alg
& WPA_AUTH_ALG_OPEN
)
8654 if (params
->auth_alg
& WPA_AUTH_ALG_SHARED
)
8656 if (params
->auth_alg
& WPA_AUTH_ALG_LEAP
)
8659 wpa_printf(MSG_DEBUG
, " * Leave out Auth Type for automatic "
8661 goto skip_auth_type
;
8664 if (params
->auth_alg
& WPA_AUTH_ALG_OPEN
)
8665 type
= NL80211_AUTHTYPE_OPEN_SYSTEM
;
8666 else if (params
->auth_alg
& WPA_AUTH_ALG_SHARED
)
8667 type
= NL80211_AUTHTYPE_SHARED_KEY
;
8668 else if (params
->auth_alg
& WPA_AUTH_ALG_LEAP
)
8669 type
= NL80211_AUTHTYPE_NETWORK_EAP
;
8670 else if (params
->auth_alg
& WPA_AUTH_ALG_FT
)
8671 type
= NL80211_AUTHTYPE_FT
;
8673 goto nla_put_failure
;
8675 wpa_printf(MSG_DEBUG
, " * Auth Type %d", type
);
8676 NLA_PUT_U32(msg
, NL80211_ATTR_AUTH_TYPE
, type
);
8679 ret
= nl80211_set_conn_keys(params
, msg
);
8681 goto nla_put_failure
;
8683 ret
= send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
8686 wpa_printf(MSG_DEBUG
, "nl80211: MLME connect failed: ret=%d "
8687 "(%s)", ret
, strerror(-ret
));
8688 goto nla_put_failure
;
8691 wpa_printf(MSG_DEBUG
, "nl80211: Connect request send successfully");
8700 static int wpa_driver_nl80211_connect(
8701 struct wpa_driver_nl80211_data
*drv
,
8702 struct wpa_driver_associate_params
*params
)
8704 int ret
= wpa_driver_nl80211_try_connect(drv
, params
);
8705 if (ret
== -EALREADY
) {
8707 * cfg80211 does not currently accept new connections if
8708 * we are already connected. As a workaround, force
8709 * disconnection and try again.
8711 wpa_printf(MSG_DEBUG
, "nl80211: Explicitly "
8712 "disconnecting before reassociation "
8714 if (wpa_driver_nl80211_disconnect(
8715 drv
, WLAN_REASON_PREV_AUTH_NOT_VALID
))
8717 ret
= wpa_driver_nl80211_try_connect(drv
, params
);
8723 static int wpa_driver_nl80211_associate(
8724 void *priv
, struct wpa_driver_associate_params
*params
)
8726 struct i802_bss
*bss
= priv
;
8727 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
8731 if (params
->mode
== IEEE80211_MODE_AP
)
8732 return wpa_driver_nl80211_ap(drv
, params
);
8734 if (params
->mode
== IEEE80211_MODE_IBSS
)
8735 return wpa_driver_nl80211_ibss(drv
, params
);
8737 if (!(drv
->capa
.flags
& WPA_DRIVER_FLAGS_SME
)) {
8738 enum nl80211_iftype nlmode
= params
->p2p
?
8739 NL80211_IFTYPE_P2P_CLIENT
: NL80211_IFTYPE_STATION
;
8741 if (wpa_driver_nl80211_set_mode(priv
, nlmode
) < 0)
8743 return wpa_driver_nl80211_connect(drv
, params
);
8746 nl80211_mark_disconnected(drv
);
8748 msg
= nlmsg_alloc();
8752 wpa_printf(MSG_DEBUG
, "nl80211: Associate (ifindex=%d)",
8754 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_ASSOCIATE
);
8756 ret
= nl80211_connect_common(drv
, params
, msg
);
8758 goto nla_put_failure
;
8760 if (params
->prev_bssid
) {
8761 wpa_printf(MSG_DEBUG
, " * prev_bssid=" MACSTR
,
8762 MAC2STR(params
->prev_bssid
));
8763 NLA_PUT(msg
, NL80211_ATTR_PREV_BSSID
, ETH_ALEN
,
8764 params
->prev_bssid
);
8767 ret
= send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
8770 wpa_dbg(drv
->ctx
, MSG_DEBUG
,
8771 "nl80211: MLME command failed (assoc): ret=%d (%s)",
8772 ret
, strerror(-ret
));
8773 nl80211_dump_scan(drv
);
8774 goto nla_put_failure
;
8777 wpa_printf(MSG_DEBUG
, "nl80211: Association request send "
8786 static int nl80211_set_mode(struct wpa_driver_nl80211_data
*drv
,
8787 int ifindex
, enum nl80211_iftype mode
)
8792 wpa_printf(MSG_DEBUG
, "nl80211: Set mode ifindex %d iftype %d (%s)",
8793 ifindex
, mode
, nl80211_iftype_str(mode
));
8795 msg
= nlmsg_alloc();
8799 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_SET_INTERFACE
);
8800 if (nl80211_set_iface_id(msg
, drv
->first_bss
) < 0)
8801 goto nla_put_failure
;
8802 NLA_PUT_U32(msg
, NL80211_ATTR_IFTYPE
, mode
);
8804 ret
= send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
8810 wpa_printf(MSG_DEBUG
, "nl80211: Failed to set interface %d to mode %d:"
8811 " %d (%s)", ifindex
, mode
, ret
, strerror(-ret
));
8816 static int wpa_driver_nl80211_set_mode(struct i802_bss
*bss
,
8817 enum nl80211_iftype nlmode
)
8819 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
8822 int was_ap
= is_ap_interface(drv
->nlmode
);
8825 res
= nl80211_set_mode(drv
, drv
->ifindex
, nlmode
);
8826 if (res
&& nlmode
== nl80211_get_ifmode(bss
))
8830 drv
->nlmode
= nlmode
;
8838 if (nlmode
== drv
->nlmode
) {
8839 wpa_printf(MSG_DEBUG
, "nl80211: Interface already in "
8840 "requested mode - ignore error");
8842 goto done
; /* Already in the requested mode */
8845 /* mac80211 doesn't allow mode changes while the device is up, so
8846 * take the device down, try to set the mode again, and bring the
8849 wpa_printf(MSG_DEBUG
, "nl80211: Try mode change after setting "
8851 for (i
= 0; i
< 10; i
++) {
8852 res
= i802_set_iface_flags(bss
, 0);
8853 if (res
== -EACCES
|| res
== -ENODEV
)
8856 /* Try to set the mode again while the interface is
8858 ret
= nl80211_set_mode(drv
, drv
->ifindex
, nlmode
);
8861 res
= i802_set_iface_flags(bss
, 1);
8864 else if (ret
!= -EBUSY
)
8867 wpa_printf(MSG_DEBUG
, "nl80211: Failed to set "
8869 os_sleep(0, 100000);
8873 wpa_printf(MSG_DEBUG
, "nl80211: Mode change succeeded while "
8874 "interface is down");
8875 drv
->nlmode
= nlmode
;
8876 drv
->ignore_if_down_event
= 1;
8881 wpa_printf(MSG_DEBUG
, "nl80211: Interface mode change to %d "
8882 "from %d failed", nlmode
, drv
->nlmode
);
8886 if (is_p2p_net_interface(nlmode
))
8887 nl80211_disable_11b_rates(drv
, drv
->ifindex
, 1);
8888 else if (drv
->disabled_11b_rates
)
8889 nl80211_disable_11b_rates(drv
, drv
->ifindex
, 0);
8891 if (is_ap_interface(nlmode
)) {
8892 nl80211_mgmt_unsubscribe(bss
, "start AP");
8893 /* Setup additional AP mode functionality if needed */
8894 if (nl80211_setup_ap(bss
))
8896 } else if (was_ap
) {
8897 /* Remove additional AP mode functionality */
8898 nl80211_teardown_ap(bss
);
8900 nl80211_mgmt_unsubscribe(bss
, "mode change");
8903 if (!bss
->in_deinit
&& !is_ap_interface(nlmode
) &&
8904 nl80211_mgmt_subscribe_non_ap(bss
) < 0)
8905 wpa_printf(MSG_DEBUG
, "nl80211: Failed to register Action "
8906 "frame processing - ignore for now");
8912 static int dfs_info_handler(struct nl_msg
*msg
, void *arg
)
8914 struct nlattr
*tb
[NL80211_ATTR_MAX
+ 1];
8915 struct genlmsghdr
*gnlh
= nlmsg_data(nlmsg_hdr(msg
));
8916 int *dfs_capability_ptr
= arg
;
8918 nla_parse(tb
, NL80211_ATTR_MAX
, genlmsg_attrdata(gnlh
, 0),
8919 genlmsg_attrlen(gnlh
, 0), NULL
);
8921 if (tb
[NL80211_ATTR_VENDOR_DATA
]) {
8922 struct nlattr
*nl_vend
= tb
[NL80211_ATTR_VENDOR_DATA
];
8923 struct nlattr
*tb_vendor
[QCA_WLAN_VENDOR_ATTR_MAX
+ 1];
8925 nla_parse(tb_vendor
, QCA_WLAN_VENDOR_ATTR_MAX
,
8926 nla_data(nl_vend
), nla_len(nl_vend
), NULL
);
8928 if (tb_vendor
[QCA_WLAN_VENDOR_ATTR_DFS
]) {
8930 val
= nla_get_u32(tb_vendor
[QCA_WLAN_VENDOR_ATTR_DFS
]);
8931 wpa_printf(MSG_DEBUG
, "nl80211: DFS offload capability: %u",
8933 *dfs_capability_ptr
= val
;
8941 static int wpa_driver_nl80211_get_capa(void *priv
,
8942 struct wpa_driver_capa
*capa
)
8944 struct i802_bss
*bss
= priv
;
8945 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
8947 int dfs_capability
= 0;
8950 if (!drv
->has_capability
)
8952 os_memcpy(capa
, &drv
->capa
, sizeof(*capa
));
8953 if (drv
->extended_capa
&& drv
->extended_capa_mask
) {
8954 capa
->extended_capa
= drv
->extended_capa
;
8955 capa
->extended_capa_mask
= drv
->extended_capa_mask
;
8956 capa
->extended_capa_len
= drv
->extended_capa_len
;
8959 if ((capa
->flags
& WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE
) &&
8960 !drv
->allow_p2p_device
) {
8961 wpa_printf(MSG_DEBUG
, "nl80211: Do not indicate P2P_DEVICE support (p2p_device=1 driver param not specified)");
8962 capa
->flags
&= ~WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE
;
8965 if (drv
->dfs_vendor_cmd_avail
== 1) {
8966 msg
= nlmsg_alloc();
8970 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_VENDOR
);
8972 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, drv
->ifindex
);
8973 NLA_PUT_U32(msg
, NL80211_ATTR_VENDOR_ID
, OUI_QCA
);
8974 NLA_PUT_U32(msg
, NL80211_ATTR_VENDOR_SUBCMD
,
8975 QCA_NL80211_VENDOR_SUBCMD_DFS_CAPABILITY
);
8977 ret
= send_and_recv_msgs(drv
, msg
, dfs_info_handler
,
8981 capa
->flags
|= WPA_DRIVER_FLAGS_DFS_OFFLOAD
;
8993 static int wpa_driver_nl80211_set_operstate(void *priv
, int state
)
8995 struct i802_bss
*bss
= priv
;
8996 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
8998 wpa_printf(MSG_DEBUG
, "nl80211: Set %s operstate %d->%d (%s)",
8999 bss
->ifname
, drv
->operstate
, state
,
9000 state
? "UP" : "DORMANT");
9001 drv
->operstate
= state
;
9002 return netlink_send_oper_ifla(drv
->global
->netlink
, drv
->ifindex
, -1,
9003 state
? IF_OPER_UP
: IF_OPER_DORMANT
);
9007 static int wpa_driver_nl80211_set_supp_port(void *priv
, int authorized
)
9009 struct i802_bss
*bss
= priv
;
9010 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
9012 struct nl80211_sta_flag_update upd
;
9015 if (!drv
->associated
&& is_zero_ether_addr(drv
->bssid
) && !authorized
) {
9016 wpa_printf(MSG_DEBUG
, "nl80211: Skip set_supp_port(unauthorized) while not associated");
9020 wpa_printf(MSG_DEBUG
, "nl80211: Set supplicant port %sauthorized for "
9021 MACSTR
, authorized
? "" : "un", MAC2STR(drv
->bssid
));
9023 msg
= nlmsg_alloc();
9027 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_SET_STATION
);
9029 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
,
9030 if_nametoindex(bss
->ifname
));
9031 NLA_PUT(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, drv
->bssid
);
9033 os_memset(&upd
, 0, sizeof(upd
));
9034 upd
.mask
= BIT(NL80211_STA_FLAG_AUTHORIZED
);
9036 upd
.set
= BIT(NL80211_STA_FLAG_AUTHORIZED
);
9037 NLA_PUT(msg
, NL80211_ATTR_STA_FLAGS2
, sizeof(upd
), &upd
);
9039 ret
= send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
9045 wpa_printf(MSG_DEBUG
, "nl80211: Failed to set STA flag: %d (%s)",
9046 ret
, strerror(-ret
));
9051 /* Set kernel driver on given frequency (MHz) */
9052 static int i802_set_freq(void *priv
, struct hostapd_freq_params
*freq
)
9054 struct i802_bss
*bss
= priv
;
9055 return wpa_driver_nl80211_set_freq(bss
, freq
);
9059 static inline int min_int(int a
, int b
)
9067 static int get_key_handler(struct nl_msg
*msg
, void *arg
)
9069 struct nlattr
*tb
[NL80211_ATTR_MAX
+ 1];
9070 struct genlmsghdr
*gnlh
= nlmsg_data(nlmsg_hdr(msg
));
9072 nla_parse(tb
, NL80211_ATTR_MAX
, genlmsg_attrdata(gnlh
, 0),
9073 genlmsg_attrlen(gnlh
, 0), NULL
);
9076 * TODO: validate the key index and mac address!
9077 * Otherwise, there's a race condition as soon as
9078 * the kernel starts sending key notifications.
9081 if (tb
[NL80211_ATTR_KEY_SEQ
])
9082 memcpy(arg
, nla_data(tb
[NL80211_ATTR_KEY_SEQ
]),
9083 min_int(nla_len(tb
[NL80211_ATTR_KEY_SEQ
]), 6));
9088 static int i802_get_seqnum(const char *iface
, void *priv
, const u8
*addr
,
9091 struct i802_bss
*bss
= priv
;
9092 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
9095 msg
= nlmsg_alloc();
9099 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_GET_KEY
);
9102 NLA_PUT(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, addr
);
9103 NLA_PUT_U8(msg
, NL80211_ATTR_KEY_IDX
, idx
);
9104 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, if_nametoindex(iface
));
9108 return send_and_recv_msgs(drv
, msg
, get_key_handler
, seq
);
9115 static int i802_set_rts(void *priv
, int rts
)
9117 struct i802_bss
*bss
= priv
;
9118 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
9123 msg
= nlmsg_alloc();
9132 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_SET_WIPHY
);
9133 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, drv
->ifindex
);
9134 NLA_PUT_U32(msg
, NL80211_ATTR_WIPHY_RTS_THRESHOLD
, val
);
9136 ret
= send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
9142 wpa_printf(MSG_DEBUG
, "nl80211: Failed to set RTS threshold %d: "
9143 "%d (%s)", rts
, ret
, strerror(-ret
));
9148 static int i802_set_frag(void *priv
, int frag
)
9150 struct i802_bss
*bss
= priv
;
9151 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
9156 msg
= nlmsg_alloc();
9165 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_SET_WIPHY
);
9166 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, drv
->ifindex
);
9167 NLA_PUT_U32(msg
, NL80211_ATTR_WIPHY_FRAG_THRESHOLD
, val
);
9169 ret
= send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
9175 wpa_printf(MSG_DEBUG
, "nl80211: Failed to set fragmentation threshold "
9176 "%d: %d (%s)", frag
, ret
, strerror(-ret
));
9181 static int i802_flush(void *priv
)
9183 struct i802_bss
*bss
= priv
;
9184 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
9188 msg
= nlmsg_alloc();
9192 wpa_printf(MSG_DEBUG
, "nl80211: flush -> DEL_STATION %s (all)",
9194 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_DEL_STATION
);
9197 * XXX: FIX! this needs to flush all VLANs too
9199 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
,
9200 if_nametoindex(bss
->ifname
));
9202 res
= send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
9204 wpa_printf(MSG_DEBUG
, "nl80211: Station flush failed: ret=%d "
9205 "(%s)", res
, strerror(-res
));
9214 static int get_sta_handler(struct nl_msg
*msg
, void *arg
)
9216 struct nlattr
*tb
[NL80211_ATTR_MAX
+ 1];
9217 struct genlmsghdr
*gnlh
= nlmsg_data(nlmsg_hdr(msg
));
9218 struct hostap_sta_driver_data
*data
= arg
;
9219 struct nlattr
*stats
[NL80211_STA_INFO_MAX
+ 1];
9220 static struct nla_policy stats_policy
[NL80211_STA_INFO_MAX
+ 1] = {
9221 [NL80211_STA_INFO_INACTIVE_TIME
] = { .type
= NLA_U32
},
9222 [NL80211_STA_INFO_RX_BYTES
] = { .type
= NLA_U32
},
9223 [NL80211_STA_INFO_TX_BYTES
] = { .type
= NLA_U32
},
9224 [NL80211_STA_INFO_RX_PACKETS
] = { .type
= NLA_U32
},
9225 [NL80211_STA_INFO_TX_PACKETS
] = { .type
= NLA_U32
},
9226 [NL80211_STA_INFO_TX_FAILED
] = { .type
= NLA_U32
},
9229 nla_parse(tb
, NL80211_ATTR_MAX
, genlmsg_attrdata(gnlh
, 0),
9230 genlmsg_attrlen(gnlh
, 0), NULL
);
9233 * TODO: validate the interface and mac address!
9234 * Otherwise, there's a race condition as soon as
9235 * the kernel starts sending station notifications.
9238 if (!tb
[NL80211_ATTR_STA_INFO
]) {
9239 wpa_printf(MSG_DEBUG
, "sta stats missing!");
9242 if (nla_parse_nested(stats
, NL80211_STA_INFO_MAX
,
9243 tb
[NL80211_ATTR_STA_INFO
],
9245 wpa_printf(MSG_DEBUG
, "failed to parse nested attributes!");
9249 if (stats
[NL80211_STA_INFO_INACTIVE_TIME
])
9250 data
->inactive_msec
=
9251 nla_get_u32(stats
[NL80211_STA_INFO_INACTIVE_TIME
]);
9252 if (stats
[NL80211_STA_INFO_RX_BYTES
])
9253 data
->rx_bytes
= nla_get_u32(stats
[NL80211_STA_INFO_RX_BYTES
]);
9254 if (stats
[NL80211_STA_INFO_TX_BYTES
])
9255 data
->tx_bytes
= nla_get_u32(stats
[NL80211_STA_INFO_TX_BYTES
]);
9256 if (stats
[NL80211_STA_INFO_RX_PACKETS
])
9258 nla_get_u32(stats
[NL80211_STA_INFO_RX_PACKETS
]);
9259 if (stats
[NL80211_STA_INFO_TX_PACKETS
])
9261 nla_get_u32(stats
[NL80211_STA_INFO_TX_PACKETS
]);
9262 if (stats
[NL80211_STA_INFO_TX_FAILED
])
9263 data
->tx_retry_failed
=
9264 nla_get_u32(stats
[NL80211_STA_INFO_TX_FAILED
]);
9269 static int i802_read_sta_data(struct i802_bss
*bss
,
9270 struct hostap_sta_driver_data
*data
,
9273 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
9276 os_memset(data
, 0, sizeof(*data
));
9277 msg
= nlmsg_alloc();
9281 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_GET_STATION
);
9283 NLA_PUT(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, addr
);
9284 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, if_nametoindex(bss
->ifname
));
9286 return send_and_recv_msgs(drv
, msg
, get_sta_handler
, data
);
9293 static int i802_set_tx_queue_params(void *priv
, int queue
, int aifs
,
9294 int cw_min
, int cw_max
, int burst_time
)
9296 struct i802_bss
*bss
= priv
;
9297 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
9299 struct nlattr
*txq
, *params
;
9301 msg
= nlmsg_alloc();
9305 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_SET_WIPHY
);
9307 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, if_nametoindex(bss
->ifname
));
9309 txq
= nla_nest_start(msg
, NL80211_ATTR_WIPHY_TXQ_PARAMS
);
9311 goto nla_put_failure
;
9313 /* We are only sending parameters for a single TXQ at a time */
9314 params
= nla_nest_start(msg
, 1);
9316 goto nla_put_failure
;
9320 NLA_PUT_U8(msg
, NL80211_TXQ_ATTR_QUEUE
, NL80211_TXQ_Q_VO
);
9323 NLA_PUT_U8(msg
, NL80211_TXQ_ATTR_QUEUE
, NL80211_TXQ_Q_VI
);
9326 NLA_PUT_U8(msg
, NL80211_TXQ_ATTR_QUEUE
, NL80211_TXQ_Q_BE
);
9329 NLA_PUT_U8(msg
, NL80211_TXQ_ATTR_QUEUE
, NL80211_TXQ_Q_BK
);
9332 /* Burst time is configured in units of 0.1 msec and TXOP parameter in
9333 * 32 usec, so need to convert the value here. */
9334 NLA_PUT_U16(msg
, NL80211_TXQ_ATTR_TXOP
, (burst_time
* 100 + 16) / 32);
9335 NLA_PUT_U16(msg
, NL80211_TXQ_ATTR_CWMIN
, cw_min
);
9336 NLA_PUT_U16(msg
, NL80211_TXQ_ATTR_CWMAX
, cw_max
);
9337 NLA_PUT_U8(msg
, NL80211_TXQ_ATTR_AIFS
, aifs
);
9339 nla_nest_end(msg
, params
);
9341 nla_nest_end(msg
, txq
);
9343 if (send_and_recv_msgs(drv
, msg
, NULL
, NULL
) == 0)
9352 static int i802_set_sta_vlan(struct i802_bss
*bss
, const u8
*addr
,
9353 const char *ifname
, int vlan_id
)
9355 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
9359 msg
= nlmsg_alloc();
9363 wpa_printf(MSG_DEBUG
, "nl80211: %s[%d]: set_sta_vlan(" MACSTR
9364 ", ifname=%s[%d], vlan_id=%d)",
9365 bss
->ifname
, if_nametoindex(bss
->ifname
),
9366 MAC2STR(addr
), ifname
, if_nametoindex(ifname
), vlan_id
);
9367 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_SET_STATION
);
9369 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
,
9370 if_nametoindex(bss
->ifname
));
9371 NLA_PUT(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, addr
);
9372 NLA_PUT_U32(msg
, NL80211_ATTR_STA_VLAN
,
9373 if_nametoindex(ifname
));
9375 ret
= send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
9378 wpa_printf(MSG_ERROR
, "nl80211: NL80211_ATTR_STA_VLAN (addr="
9379 MACSTR
" ifname=%s vlan_id=%d) failed: %d (%s)",
9380 MAC2STR(addr
), ifname
, vlan_id
, ret
,
9389 static int i802_get_inact_sec(void *priv
, const u8
*addr
)
9391 struct hostap_sta_driver_data data
;
9394 data
.inactive_msec
= (unsigned long) -1;
9395 ret
= i802_read_sta_data(priv
, &data
, addr
);
9396 if (ret
|| data
.inactive_msec
== (unsigned long) -1)
9398 return data
.inactive_msec
/ 1000;
9402 static int i802_sta_clear_stats(void *priv
, const u8
*addr
)
9411 static int i802_sta_deauth(void *priv
, const u8
*own_addr
, const u8
*addr
,
9414 struct i802_bss
*bss
= priv
;
9415 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
9416 struct ieee80211_mgmt mgmt
;
9418 if (drv
->device_ap_sme
)
9419 return wpa_driver_nl80211_sta_remove(bss
, addr
);
9421 memset(&mgmt
, 0, sizeof(mgmt
));
9422 mgmt
.frame_control
= IEEE80211_FC(WLAN_FC_TYPE_MGMT
,
9423 WLAN_FC_STYPE_DEAUTH
);
9424 memcpy(mgmt
.da
, addr
, ETH_ALEN
);
9425 memcpy(mgmt
.sa
, own_addr
, ETH_ALEN
);
9426 memcpy(mgmt
.bssid
, own_addr
, ETH_ALEN
);
9427 mgmt
.u
.deauth
.reason_code
= host_to_le16(reason
);
9428 return wpa_driver_nl80211_send_mlme(bss
, (u8
*) &mgmt
,
9430 sizeof(mgmt
.u
.deauth
), 0, 0, 0, 0,
9435 static int i802_sta_disassoc(void *priv
, const u8
*own_addr
, const u8
*addr
,
9438 struct i802_bss
*bss
= priv
;
9439 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
9440 struct ieee80211_mgmt mgmt
;
9442 if (drv
->device_ap_sme
)
9443 return wpa_driver_nl80211_sta_remove(bss
, addr
);
9445 memset(&mgmt
, 0, sizeof(mgmt
));
9446 mgmt
.frame_control
= IEEE80211_FC(WLAN_FC_TYPE_MGMT
,
9447 WLAN_FC_STYPE_DISASSOC
);
9448 memcpy(mgmt
.da
, addr
, ETH_ALEN
);
9449 memcpy(mgmt
.sa
, own_addr
, ETH_ALEN
);
9450 memcpy(mgmt
.bssid
, own_addr
, ETH_ALEN
);
9451 mgmt
.u
.disassoc
.reason_code
= host_to_le16(reason
);
9452 return wpa_driver_nl80211_send_mlme(bss
, (u8
*) &mgmt
,
9454 sizeof(mgmt
.u
.disassoc
), 0, 0, 0, 0,
9459 static void dump_ifidx(struct wpa_driver_nl80211_data
*drv
)
9461 char buf
[200], *pos
, *end
;
9465 end
= pos
+ sizeof(buf
);
9467 for (i
= 0; i
< drv
->num_if_indices
; i
++) {
9468 if (!drv
->if_indices
[i
])
9470 res
= os_snprintf(pos
, end
- pos
, " %d", drv
->if_indices
[i
]);
9471 if (res
< 0 || res
>= end
- pos
)
9477 wpa_printf(MSG_DEBUG
, "nl80211: if_indices[%d]:%s",
9478 drv
->num_if_indices
, buf
);
9482 static void add_ifidx(struct wpa_driver_nl80211_data
*drv
, int ifidx
)
9487 wpa_printf(MSG_DEBUG
, "nl80211: Add own interface ifindex %d",
9489 if (have_ifidx(drv
, ifidx
)) {
9490 wpa_printf(MSG_DEBUG
, "nl80211: ifindex %d already in the list",
9494 for (i
= 0; i
< drv
->num_if_indices
; i
++) {
9495 if (drv
->if_indices
[i
] == 0) {
9496 drv
->if_indices
[i
] = ifidx
;
9502 if (drv
->if_indices
!= drv
->default_if_indices
)
9503 old
= drv
->if_indices
;
9507 drv
->if_indices
= os_realloc_array(old
, drv
->num_if_indices
+ 1,
9509 if (!drv
->if_indices
) {
9511 drv
->if_indices
= drv
->default_if_indices
;
9513 drv
->if_indices
= old
;
9514 wpa_printf(MSG_ERROR
, "Failed to reallocate memory for "
9516 wpa_printf(MSG_ERROR
, "Ignoring EAPOL on interface %d", ifidx
);
9519 os_memcpy(drv
->if_indices
, drv
->default_if_indices
,
9520 sizeof(drv
->default_if_indices
));
9521 drv
->if_indices
[drv
->num_if_indices
] = ifidx
;
9522 drv
->num_if_indices
++;
9527 static void del_ifidx(struct wpa_driver_nl80211_data
*drv
, int ifidx
)
9531 for (i
= 0; i
< drv
->num_if_indices
; i
++) {
9532 if (drv
->if_indices
[i
] == ifidx
) {
9533 drv
->if_indices
[i
] = 0;
9541 static int have_ifidx(struct wpa_driver_nl80211_data
*drv
, int ifidx
)
9545 for (i
= 0; i
< drv
->num_if_indices
; i
++)
9546 if (drv
->if_indices
[i
] == ifidx
)
9553 static int i802_set_wds_sta(void *priv
, const u8
*addr
, int aid
, int val
,
9554 const char *bridge_ifname
, char *ifname_wds
)
9556 struct i802_bss
*bss
= priv
;
9557 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
9558 char name
[IFNAMSIZ
+ 1];
9560 os_snprintf(name
, sizeof(name
), "%s.sta%d", bss
->ifname
, aid
);
9562 os_strlcpy(ifname_wds
, name
, IFNAMSIZ
+ 1);
9564 wpa_printf(MSG_DEBUG
, "nl80211: Set WDS STA addr=" MACSTR
9565 " aid=%d val=%d name=%s", MAC2STR(addr
), aid
, val
, name
);
9567 if (!if_nametoindex(name
)) {
9568 if (nl80211_create_iface(drv
, name
,
9569 NL80211_IFTYPE_AP_VLAN
,
9570 bss
->addr
, 1, NULL
, NULL
, 0) <
9573 if (bridge_ifname
&&
9574 linux_br_add_if(drv
->global
->ioctl_sock
,
9575 bridge_ifname
, name
) < 0)
9578 if (linux_set_iface_flags(drv
->global
->ioctl_sock
, name
, 1)) {
9579 wpa_printf(MSG_ERROR
, "nl80211: Failed to set WDS STA "
9580 "interface %s up", name
);
9582 return i802_set_sta_vlan(priv
, addr
, name
, 0);
9585 linux_br_del_if(drv
->global
->ioctl_sock
, bridge_ifname
,
9588 i802_set_sta_vlan(priv
, addr
, bss
->ifname
, 0);
9589 nl80211_remove_iface(drv
, if_nametoindex(name
));
9595 static void handle_eapol(int sock
, void *eloop_ctx
, void *sock_ctx
)
9597 struct wpa_driver_nl80211_data
*drv
= eloop_ctx
;
9598 struct sockaddr_ll lladdr
;
9599 unsigned char buf
[3000];
9601 socklen_t fromlen
= sizeof(lladdr
);
9603 len
= recvfrom(sock
, buf
, sizeof(buf
), 0,
9604 (struct sockaddr
*)&lladdr
, &fromlen
);
9606 wpa_printf(MSG_ERROR
, "nl80211: EAPOL recv failed: %s",
9611 if (have_ifidx(drv
, lladdr
.sll_ifindex
))
9612 drv_event_eapol_rx(drv
->ctx
, lladdr
.sll_addr
, buf
, len
);
9616 static int i802_check_bridge(struct wpa_driver_nl80211_data
*drv
,
9617 struct i802_bss
*bss
,
9618 const char *brname
, const char *ifname
)
9621 char in_br
[IFNAMSIZ
];
9623 os_strlcpy(bss
->brname
, brname
, IFNAMSIZ
);
9624 ifindex
= if_nametoindex(brname
);
9627 * Bridge was configured, but the bridge device does
9628 * not exist. Try to add it now.
9630 if (linux_br_add(drv
->global
->ioctl_sock
, brname
) < 0) {
9631 wpa_printf(MSG_ERROR
, "nl80211: Failed to add the "
9632 "bridge interface %s: %s",
9633 brname
, strerror(errno
));
9636 bss
->added_bridge
= 1;
9637 add_ifidx(drv
, if_nametoindex(brname
));
9640 if (linux_br_get(in_br
, ifname
) == 0) {
9641 if (os_strcmp(in_br
, brname
) == 0)
9642 return 0; /* already in the bridge */
9644 wpa_printf(MSG_DEBUG
, "nl80211: Removing interface %s from "
9645 "bridge %s", ifname
, in_br
);
9646 if (linux_br_del_if(drv
->global
->ioctl_sock
, in_br
, ifname
) <
9648 wpa_printf(MSG_ERROR
, "nl80211: Failed to "
9649 "remove interface %s from bridge "
9651 ifname
, brname
, strerror(errno
));
9656 wpa_printf(MSG_DEBUG
, "nl80211: Adding interface %s into bridge %s",
9658 if (linux_br_add_if(drv
->global
->ioctl_sock
, brname
, ifname
) < 0) {
9659 wpa_printf(MSG_ERROR
, "nl80211: Failed to add interface %s "
9660 "into bridge %s: %s",
9661 ifname
, brname
, strerror(errno
));
9664 bss
->added_if_into_bridge
= 1;
9670 static void *i802_init(struct hostapd_data
*hapd
,
9671 struct wpa_init_params
*params
)
9673 struct wpa_driver_nl80211_data
*drv
;
9674 struct i802_bss
*bss
;
9676 char brname
[IFNAMSIZ
];
9677 int ifindex
, br_ifindex
;
9680 bss
= wpa_driver_nl80211_drv_init(hapd
, params
->ifname
,
9681 params
->global_priv
, 1,
9688 if (linux_br_get(brname
, params
->ifname
) == 0) {
9689 wpa_printf(MSG_DEBUG
, "nl80211: Interface %s is in bridge %s",
9690 params
->ifname
, brname
);
9691 br_ifindex
= if_nametoindex(brname
);
9697 for (i
= 0; i
< params
->num_bridge
; i
++) {
9698 if (params
->bridge
[i
]) {
9699 ifindex
= if_nametoindex(params
->bridge
[i
]);
9701 add_ifidx(drv
, ifindex
);
9702 if (ifindex
== br_ifindex
)
9706 if (!br_added
&& br_ifindex
&&
9707 (params
->num_bridge
== 0 || !params
->bridge
[0]))
9708 add_ifidx(drv
, br_ifindex
);
9710 /* start listening for EAPOL on the default AP interface */
9711 add_ifidx(drv
, drv
->ifindex
);
9713 if (params
->num_bridge
&& params
->bridge
[0] &&
9714 i802_check_bridge(drv
, bss
, params
->bridge
[0], params
->ifname
) < 0)
9717 drv
->eapol_sock
= socket(PF_PACKET
, SOCK_DGRAM
, htons(ETH_P_PAE
));
9718 if (drv
->eapol_sock
< 0) {
9719 wpa_printf(MSG_ERROR
, "nl80211: socket(PF_PACKET, SOCK_DGRAM, ETH_P_PAE) failed: %s",
9724 if (eloop_register_read_sock(drv
->eapol_sock
, handle_eapol
, drv
, NULL
))
9726 wpa_printf(MSG_INFO
, "nl80211: Could not register read socket for eapol");
9730 if (linux_get_ifhwaddr(drv
->global
->ioctl_sock
, bss
->ifname
,
9734 memcpy(bss
->addr
, params
->own_addr
, ETH_ALEN
);
9739 wpa_driver_nl80211_deinit(bss
);
9744 static void i802_deinit(void *priv
)
9746 struct i802_bss
*bss
= priv
;
9747 wpa_driver_nl80211_deinit(bss
);
9751 static enum nl80211_iftype
wpa_driver_nl80211_if_type(
9752 enum wpa_driver_if_type type
)
9755 case WPA_IF_STATION
:
9756 return NL80211_IFTYPE_STATION
;
9757 case WPA_IF_P2P_CLIENT
:
9758 case WPA_IF_P2P_GROUP
:
9759 return NL80211_IFTYPE_P2P_CLIENT
;
9760 case WPA_IF_AP_VLAN
:
9761 return NL80211_IFTYPE_AP_VLAN
;
9763 return NL80211_IFTYPE_AP
;
9765 return NL80211_IFTYPE_P2P_GO
;
9766 case WPA_IF_P2P_DEVICE
:
9767 return NL80211_IFTYPE_P2P_DEVICE
;
9775 static int nl80211_addr_in_use(struct nl80211_global
*global
, const u8
*addr
)
9777 struct wpa_driver_nl80211_data
*drv
;
9778 dl_list_for_each(drv
, &global
->interfaces
,
9779 struct wpa_driver_nl80211_data
, list
) {
9780 if (os_memcmp(addr
, drv
->first_bss
->addr
, ETH_ALEN
) == 0)
9787 static int nl80211_p2p_interface_addr(struct wpa_driver_nl80211_data
*drv
,
9795 os_memcpy(new_addr
, drv
->first_bss
->addr
, ETH_ALEN
);
9796 for (idx
= 0; idx
< 64; idx
++) {
9797 new_addr
[0] = drv
->first_bss
->addr
[0] | 0x02;
9798 new_addr
[0] ^= idx
<< 2;
9799 if (!nl80211_addr_in_use(drv
->global
, new_addr
))
9805 wpa_printf(MSG_DEBUG
, "nl80211: Assigned new P2P Interface Address "
9806 MACSTR
, MAC2STR(new_addr
));
9811 #endif /* CONFIG_P2P */
9817 u8 macaddr
[ETH_ALEN
];
9820 static int nl80211_wdev_handler(struct nl_msg
*msg
, void *arg
)
9822 struct genlmsghdr
*gnlh
= nlmsg_data(nlmsg_hdr(msg
));
9823 struct nlattr
*tb
[NL80211_ATTR_MAX
+ 1];
9824 struct wdev_info
*wi
= arg
;
9826 nla_parse(tb
, NL80211_ATTR_MAX
, genlmsg_attrdata(gnlh
, 0),
9827 genlmsg_attrlen(gnlh
, 0), NULL
);
9828 if (tb
[NL80211_ATTR_WDEV
]) {
9829 wi
->wdev_id
= nla_get_u64(tb
[NL80211_ATTR_WDEV
]);
9830 wi
->wdev_id_set
= 1;
9833 if (tb
[NL80211_ATTR_MAC
])
9834 os_memcpy(wi
->macaddr
, nla_data(tb
[NL80211_ATTR_MAC
]),
9841 static int wpa_driver_nl80211_if_add(void *priv
, enum wpa_driver_if_type type
,
9842 const char *ifname
, const u8
*addr
,
9843 void *bss_ctx
, void **drv_priv
,
9844 char *force_ifname
, u8
*if_addr
,
9845 const char *bridge
, int use_existing
)
9847 enum nl80211_iftype nlmode
;
9848 struct i802_bss
*bss
= priv
;
9849 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
9854 os_memcpy(if_addr
, addr
, ETH_ALEN
);
9855 nlmode
= wpa_driver_nl80211_if_type(type
);
9856 if (nlmode
== NL80211_IFTYPE_P2P_DEVICE
) {
9857 struct wdev_info p2pdev_info
;
9859 os_memset(&p2pdev_info
, 0, sizeof(p2pdev_info
));
9860 ifidx
= nl80211_create_iface(drv
, ifname
, nlmode
, addr
,
9861 0, nl80211_wdev_handler
,
9862 &p2pdev_info
, use_existing
);
9863 if (!p2pdev_info
.wdev_id_set
|| ifidx
!= 0) {
9864 wpa_printf(MSG_ERROR
, "nl80211: Failed to create a P2P Device interface %s",
9869 drv
->global
->if_add_wdevid
= p2pdev_info
.wdev_id
;
9870 drv
->global
->if_add_wdevid_set
= p2pdev_info
.wdev_id_set
;
9871 if (!is_zero_ether_addr(p2pdev_info
.macaddr
))
9872 os_memcpy(if_addr
, p2pdev_info
.macaddr
, ETH_ALEN
);
9873 wpa_printf(MSG_DEBUG
, "nl80211: New P2P Device interface %s (0x%llx) created",
9875 (long long unsigned int) p2pdev_info
.wdev_id
);
9877 ifidx
= nl80211_create_iface(drv
, ifname
, nlmode
, addr
,
9878 0, NULL
, NULL
, use_existing
);
9879 if (use_existing
&& ifidx
== -ENFILE
) {
9881 ifidx
= if_nametoindex(ifname
);
9882 } else if (ifidx
< 0) {
9888 if (drv
->nlmode
== NL80211_IFTYPE_P2P_DEVICE
)
9889 os_memcpy(if_addr
, bss
->addr
, ETH_ALEN
);
9890 else if (linux_get_ifhwaddr(drv
->global
->ioctl_sock
,
9891 bss
->ifname
, if_addr
) < 0) {
9893 nl80211_remove_iface(drv
, ifidx
);
9900 (type
== WPA_IF_P2P_CLIENT
|| type
== WPA_IF_P2P_GROUP
||
9901 type
== WPA_IF_P2P_GO
)) {
9902 /* Enforce unique P2P Interface Address */
9903 u8 new_addr
[ETH_ALEN
];
9905 if (linux_get_ifhwaddr(drv
->global
->ioctl_sock
, ifname
,
9907 nl80211_remove_iface(drv
, ifidx
);
9910 if (nl80211_addr_in_use(drv
->global
, new_addr
)) {
9911 wpa_printf(MSG_DEBUG
, "nl80211: Allocate new address "
9912 "for P2P group interface");
9913 if (nl80211_p2p_interface_addr(drv
, new_addr
) < 0) {
9914 nl80211_remove_iface(drv
, ifidx
);
9917 if (linux_set_ifhwaddr(drv
->global
->ioctl_sock
, ifname
,
9919 nl80211_remove_iface(drv
, ifidx
);
9923 os_memcpy(if_addr
, new_addr
, ETH_ALEN
);
9925 #endif /* CONFIG_P2P */
9927 if (type
== WPA_IF_AP_BSS
) {
9928 struct i802_bss
*new_bss
= os_zalloc(sizeof(*new_bss
));
9929 if (new_bss
== NULL
) {
9931 nl80211_remove_iface(drv
, ifidx
);
9936 i802_check_bridge(drv
, new_bss
, bridge
, ifname
) < 0) {
9937 wpa_printf(MSG_ERROR
, "nl80211: Failed to add the new "
9938 "interface %s to a bridge %s",
9941 nl80211_remove_iface(drv
, ifidx
);
9946 if (linux_set_iface_flags(drv
->global
->ioctl_sock
, ifname
, 1))
9948 nl80211_remove_iface(drv
, ifidx
);
9952 os_strlcpy(new_bss
->ifname
, ifname
, IFNAMSIZ
);
9953 os_memcpy(new_bss
->addr
, if_addr
, ETH_ALEN
);
9954 new_bss
->ifindex
= ifidx
;
9956 new_bss
->next
= drv
->first_bss
->next
;
9957 new_bss
->freq
= drv
->first_bss
->freq
;
9958 new_bss
->ctx
= bss_ctx
;
9959 new_bss
->added_if
= added
;
9960 drv
->first_bss
->next
= new_bss
;
9962 *drv_priv
= new_bss
;
9963 nl80211_init_bss(new_bss
);
9965 /* Subscribe management frames for this WPA_IF_AP_BSS */
9966 if (nl80211_setup_ap(new_bss
))
9971 drv
->global
->if_add_ifindex
= ifidx
;
9974 add_ifidx(drv
, ifidx
);
9980 static int wpa_driver_nl80211_if_remove(struct i802_bss
*bss
,
9981 enum wpa_driver_if_type type
,
9984 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
9985 int ifindex
= if_nametoindex(ifname
);
9987 wpa_printf(MSG_DEBUG
, "nl80211: %s(type=%d ifname=%s) ifindex=%d added_if=%d",
9988 __func__
, type
, ifname
, ifindex
, bss
->added_if
);
9989 if (ifindex
> 0 && (bss
->added_if
|| bss
->ifindex
!= ifindex
))
9990 nl80211_remove_iface(drv
, ifindex
);
9991 else if (ifindex
> 0 && !bss
->added_if
)
9992 del_ifidx(drv
, ifindex
);
9994 if (type
!= WPA_IF_AP_BSS
)
9997 if (bss
->added_if_into_bridge
) {
9998 if (linux_br_del_if(drv
->global
->ioctl_sock
, bss
->brname
,
10000 wpa_printf(MSG_INFO
, "nl80211: Failed to remove "
10001 "interface %s from bridge %s: %s",
10002 bss
->ifname
, bss
->brname
, strerror(errno
));
10004 if (bss
->added_bridge
) {
10005 if (linux_br_del(drv
->global
->ioctl_sock
, bss
->brname
) < 0)
10006 wpa_printf(MSG_INFO
, "nl80211: Failed to remove "
10008 bss
->brname
, strerror(errno
));
10011 if (bss
!= drv
->first_bss
) {
10012 struct i802_bss
*tbss
;
10014 wpa_printf(MSG_DEBUG
, "nl80211: Not the first BSS - remove it");
10015 for (tbss
= drv
->first_bss
; tbss
; tbss
= tbss
->next
) {
10016 if (tbss
->next
== bss
) {
10017 tbss
->next
= bss
->next
;
10018 /* Unsubscribe management frames */
10019 nl80211_teardown_ap(bss
);
10020 nl80211_destroy_bss(bss
);
10027 wpa_printf(MSG_INFO
, "nl80211: %s - could not find "
10028 "BSS %p in the list", __func__
, bss
);
10030 wpa_printf(MSG_DEBUG
, "nl80211: First BSS - reassign context");
10031 nl80211_teardown_ap(bss
);
10032 if (!bss
->added_if
&& !drv
->first_bss
->next
)
10033 wpa_driver_nl80211_del_beacon(drv
);
10034 nl80211_destroy_bss(bss
);
10035 if (!bss
->added_if
)
10036 i802_set_iface_flags(bss
, 0);
10037 if (drv
->first_bss
->next
) {
10038 drv
->first_bss
= drv
->first_bss
->next
;
10039 drv
->ctx
= drv
->first_bss
->ctx
;
10042 wpa_printf(MSG_DEBUG
, "nl80211: No second BSS to reassign context to");
10050 static int cookie_handler(struct nl_msg
*msg
, void *arg
)
10052 struct nlattr
*tb
[NL80211_ATTR_MAX
+ 1];
10053 struct genlmsghdr
*gnlh
= nlmsg_data(nlmsg_hdr(msg
));
10055 nla_parse(tb
, NL80211_ATTR_MAX
, genlmsg_attrdata(gnlh
, 0),
10056 genlmsg_attrlen(gnlh
, 0), NULL
);
10057 if (tb
[NL80211_ATTR_COOKIE
])
10058 *cookie
= nla_get_u64(tb
[NL80211_ATTR_COOKIE
]);
10063 static int nl80211_send_frame_cmd(struct i802_bss
*bss
,
10064 unsigned int freq
, unsigned int wait
,
10065 const u8
*buf
, size_t buf_len
,
10066 u64
*cookie_out
, int no_cck
, int no_ack
,
10069 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
10070 struct nl_msg
*msg
;
10074 msg
= nlmsg_alloc();
10078 wpa_printf(MSG_MSGDUMP
, "nl80211: CMD_FRAME freq=%u wait=%u no_cck=%d "
10079 "no_ack=%d offchanok=%d",
10080 freq
, wait
, no_cck
, no_ack
, offchanok
);
10081 wpa_hexdump(MSG_MSGDUMP
, "CMD_FRAME", buf
, buf_len
);
10082 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_FRAME
);
10084 if (nl80211_set_iface_id(msg
, bss
) < 0)
10085 goto nla_put_failure
;
10087 NLA_PUT_U32(msg
, NL80211_ATTR_WIPHY_FREQ
, freq
);
10089 NLA_PUT_U32(msg
, NL80211_ATTR_DURATION
, wait
);
10090 if (offchanok
&& ((drv
->capa
.flags
& WPA_DRIVER_FLAGS_OFFCHANNEL_TX
) ||
10091 drv
->test_use_roc_tx
))
10092 NLA_PUT_FLAG(msg
, NL80211_ATTR_OFFCHANNEL_TX_OK
);
10094 NLA_PUT_FLAG(msg
, NL80211_ATTR_TX_NO_CCK_RATE
);
10096 NLA_PUT_FLAG(msg
, NL80211_ATTR_DONT_WAIT_FOR_ACK
);
10098 NLA_PUT(msg
, NL80211_ATTR_FRAME
, buf_len
, buf
);
10101 ret
= send_and_recv_msgs(drv
, msg
, cookie_handler
, &cookie
);
10104 wpa_printf(MSG_DEBUG
, "nl80211: Frame command failed: ret=%d "
10105 "(%s) (freq=%u wait=%u)", ret
, strerror(-ret
),
10107 goto nla_put_failure
;
10109 wpa_printf(MSG_MSGDUMP
, "nl80211: Frame TX command accepted%s; "
10110 "cookie 0x%llx", no_ack
? " (no ACK)" : "",
10111 (long long unsigned int) cookie
);
10114 *cookie_out
= no_ack
? (u64
) -1 : cookie
;
10122 static int wpa_driver_nl80211_send_action(struct i802_bss
*bss
,
10124 unsigned int wait_time
,
10125 const u8
*dst
, const u8
*src
,
10127 const u8
*data
, size_t data_len
,
10130 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
10133 struct ieee80211_hdr
*hdr
;
10135 wpa_printf(MSG_DEBUG
, "nl80211: Send Action frame (ifindex=%d, "
10136 "freq=%u MHz wait=%d ms no_cck=%d)",
10137 drv
->ifindex
, freq
, wait_time
, no_cck
);
10139 buf
= os_zalloc(24 + data_len
);
10142 os_memcpy(buf
+ 24, data
, data_len
);
10143 hdr
= (struct ieee80211_hdr
*) buf
;
10144 hdr
->frame_control
=
10145 IEEE80211_FC(WLAN_FC_TYPE_MGMT
, WLAN_FC_STYPE_ACTION
);
10146 os_memcpy(hdr
->addr1
, dst
, ETH_ALEN
);
10147 os_memcpy(hdr
->addr2
, src
, ETH_ALEN
);
10148 os_memcpy(hdr
->addr3
, bssid
, ETH_ALEN
);
10150 if (is_ap_interface(drv
->nlmode
) &&
10151 (!(drv
->capa
.flags
& WPA_DRIVER_FLAGS_OFFCHANNEL_TX
) ||
10152 (int) freq
== bss
->freq
|| drv
->device_ap_sme
||
10153 !drv
->use_monitor
))
10154 ret
= wpa_driver_nl80211_send_mlme(bss
, buf
, 24 + data_len
,
10155 0, freq
, no_cck
, 1,
10158 ret
= nl80211_send_frame_cmd(bss
, freq
, wait_time
, buf
,
10160 &drv
->send_action_cookie
,
10168 static void wpa_driver_nl80211_send_action_cancel_wait(void *priv
)
10170 struct i802_bss
*bss
= priv
;
10171 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
10172 struct nl_msg
*msg
;
10175 msg
= nlmsg_alloc();
10179 wpa_printf(MSG_DEBUG
, "nl80211: Cancel TX frame wait: cookie=0x%llx",
10180 (long long unsigned int) drv
->send_action_cookie
);
10181 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_FRAME_WAIT_CANCEL
);
10183 if (nl80211_set_iface_id(msg
, bss
) < 0)
10184 goto nla_put_failure
;
10185 NLA_PUT_U64(msg
, NL80211_ATTR_COOKIE
, drv
->send_action_cookie
);
10187 ret
= send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
10190 wpa_printf(MSG_DEBUG
, "nl80211: wait cancel failed: ret=%d "
10191 "(%s)", ret
, strerror(-ret
));
10198 static int wpa_driver_nl80211_remain_on_channel(void *priv
, unsigned int freq
,
10199 unsigned int duration
)
10201 struct i802_bss
*bss
= priv
;
10202 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
10203 struct nl_msg
*msg
;
10207 msg
= nlmsg_alloc();
10211 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_REMAIN_ON_CHANNEL
);
10213 if (nl80211_set_iface_id(msg
, bss
) < 0)
10214 goto nla_put_failure
;
10216 NLA_PUT_U32(msg
, NL80211_ATTR_WIPHY_FREQ
, freq
);
10217 NLA_PUT_U32(msg
, NL80211_ATTR_DURATION
, duration
);
10220 ret
= send_and_recv_msgs(drv
, msg
, cookie_handler
, &cookie
);
10223 wpa_printf(MSG_DEBUG
, "nl80211: Remain-on-channel cookie "
10224 "0x%llx for freq=%u MHz duration=%u",
10225 (long long unsigned int) cookie
, freq
, duration
);
10226 drv
->remain_on_chan_cookie
= cookie
;
10227 drv
->pending_remain_on_chan
= 1;
10230 wpa_printf(MSG_DEBUG
, "nl80211: Failed to request remain-on-channel "
10231 "(freq=%d duration=%u): %d (%s)",
10232 freq
, duration
, ret
, strerror(-ret
));
10239 static int wpa_driver_nl80211_cancel_remain_on_channel(void *priv
)
10241 struct i802_bss
*bss
= priv
;
10242 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
10243 struct nl_msg
*msg
;
10246 if (!drv
->pending_remain_on_chan
) {
10247 wpa_printf(MSG_DEBUG
, "nl80211: No pending remain-on-channel "
10252 wpa_printf(MSG_DEBUG
, "nl80211: Cancel remain-on-channel with cookie "
10254 (long long unsigned int) drv
->remain_on_chan_cookie
);
10256 msg
= nlmsg_alloc();
10260 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL
);
10262 if (nl80211_set_iface_id(msg
, bss
) < 0)
10263 goto nla_put_failure
;
10265 NLA_PUT_U64(msg
, NL80211_ATTR_COOKIE
, drv
->remain_on_chan_cookie
);
10267 ret
= send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
10271 wpa_printf(MSG_DEBUG
, "nl80211: Failed to cancel remain-on-channel: "
10272 "%d (%s)", ret
, strerror(-ret
));
10279 static int wpa_driver_nl80211_probe_req_report(struct i802_bss
*bss
, int report
)
10281 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
10284 if (bss
->nl_preq
&& drv
->device_ap_sme
&&
10285 is_ap_interface(drv
->nlmode
)) {
10287 * Do not disable Probe Request reporting that was
10288 * enabled in nl80211_setup_ap().
10290 wpa_printf(MSG_DEBUG
, "nl80211: Skip disabling of "
10291 "Probe Request reporting nl_preq=%p while "
10292 "in AP mode", bss
->nl_preq
);
10293 } else if (bss
->nl_preq
) {
10294 wpa_printf(MSG_DEBUG
, "nl80211: Disable Probe Request "
10295 "reporting nl_preq=%p", bss
->nl_preq
);
10296 nl80211_destroy_eloop_handle(&bss
->nl_preq
);
10301 if (bss
->nl_preq
) {
10302 wpa_printf(MSG_DEBUG
, "nl80211: Probe Request reporting "
10303 "already on! nl_preq=%p", bss
->nl_preq
);
10307 bss
->nl_preq
= nl_create_handle(drv
->global
->nl_cb
, "preq");
10308 if (bss
->nl_preq
== NULL
)
10310 wpa_printf(MSG_DEBUG
, "nl80211: Enable Probe Request "
10311 "reporting nl_preq=%p", bss
->nl_preq
);
10313 if (nl80211_register_frame(bss
, bss
->nl_preq
,
10314 (WLAN_FC_TYPE_MGMT
<< 2) |
10315 (WLAN_FC_STYPE_PROBE_REQ
<< 4),
10319 nl80211_register_eloop_read(&bss
->nl_preq
,
10320 wpa_driver_nl80211_event_receive
,
10326 nl_destroy_handles(&bss
->nl_preq
);
10331 static int nl80211_disable_11b_rates(struct wpa_driver_nl80211_data
*drv
,
10332 int ifindex
, int disabled
)
10334 struct nl_msg
*msg
;
10335 struct nlattr
*bands
, *band
;
10338 msg
= nlmsg_alloc();
10342 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_SET_TX_BITRATE_MASK
);
10343 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, ifindex
);
10345 bands
= nla_nest_start(msg
, NL80211_ATTR_TX_RATES
);
10347 goto nla_put_failure
;
10350 * Disable 2 GHz rates 1, 2, 5.5, 11 Mbps by masking out everything
10351 * else apart from 6, 9, 12, 18, 24, 36, 48, 54 Mbps from non-MCS
10352 * rates. All 5 GHz rates are left enabled.
10354 band
= nla_nest_start(msg
, NL80211_BAND_2GHZ
);
10356 goto nla_put_failure
;
10358 NLA_PUT(msg
, NL80211_TXRATE_LEGACY
, 8,
10359 "\x0c\x12\x18\x24\x30\x48\x60\x6c");
10361 nla_nest_end(msg
, band
);
10363 nla_nest_end(msg
, bands
);
10365 ret
= send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
10368 wpa_printf(MSG_DEBUG
, "nl80211: Set TX rates failed: ret=%d "
10369 "(%s)", ret
, strerror(-ret
));
10371 drv
->disabled_11b_rates
= disabled
;
10381 static int wpa_driver_nl80211_deinit_ap(void *priv
)
10383 struct i802_bss
*bss
= priv
;
10384 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
10385 if (!is_ap_interface(drv
->nlmode
))
10387 wpa_driver_nl80211_del_beacon(drv
);
10390 * If the P2P GO interface was dynamically added, then it is
10391 * possible that the interface change to station is not possible.
10393 if (drv
->nlmode
== NL80211_IFTYPE_P2P_GO
&& bss
->if_dynamic
)
10396 return wpa_driver_nl80211_set_mode(priv
, NL80211_IFTYPE_STATION
);
10400 static int wpa_driver_nl80211_stop_ap(void *priv
)
10402 struct i802_bss
*bss
= priv
;
10403 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
10404 if (!is_ap_interface(drv
->nlmode
))
10406 wpa_driver_nl80211_del_beacon(drv
);
10407 bss
->beacon_set
= 0;
10412 static int wpa_driver_nl80211_deinit_p2p_cli(void *priv
)
10414 struct i802_bss
*bss
= priv
;
10415 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
10416 if (drv
->nlmode
!= NL80211_IFTYPE_P2P_CLIENT
)
10420 * If the P2P Client interface was dynamically added, then it is
10421 * possible that the interface change to station is not possible.
10423 if (bss
->if_dynamic
)
10426 return wpa_driver_nl80211_set_mode(priv
, NL80211_IFTYPE_STATION
);
10430 static void wpa_driver_nl80211_resume(void *priv
)
10432 struct i802_bss
*bss
= priv
;
10434 if (i802_set_iface_flags(bss
, 1))
10435 wpa_printf(MSG_DEBUG
, "nl80211: Failed to set interface up on resume event");
10439 static int nl80211_send_ft_action(void *priv
, u8 action
, const u8
*target_ap
,
10440 const u8
*ies
, size_t ies_len
)
10442 struct i802_bss
*bss
= priv
;
10443 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
10447 const u8
*own_addr
= bss
->addr
;
10450 wpa_printf(MSG_ERROR
, "nl80211: Unsupported send_ft_action "
10451 "action %d", action
);
10456 * Action frame payload:
10457 * Category[1] = 6 (Fast BSS Transition)
10458 * Action[1] = 1 (Fast BSS Transition Request)
10460 * Target AP Address
10464 data_len
= 2 + 2 * ETH_ALEN
+ ies_len
;
10465 data
= os_malloc(data_len
);
10469 *pos
++ = 0x06; /* FT Action category */
10471 os_memcpy(pos
, own_addr
, ETH_ALEN
);
10473 os_memcpy(pos
, target_ap
, ETH_ALEN
);
10475 os_memcpy(pos
, ies
, ies_len
);
10477 ret
= wpa_driver_nl80211_send_action(bss
, drv
->assoc_freq
, 0,
10478 drv
->bssid
, own_addr
, drv
->bssid
,
10479 data
, data_len
, 0);
10486 static int nl80211_signal_monitor(void *priv
, int threshold
, int hysteresis
)
10488 struct i802_bss
*bss
= priv
;
10489 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
10490 struct nl_msg
*msg
;
10491 struct nlattr
*cqm
;
10494 wpa_printf(MSG_DEBUG
, "nl80211: Signal monitor threshold=%d "
10495 "hysteresis=%d", threshold
, hysteresis
);
10497 msg
= nlmsg_alloc();
10501 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_SET_CQM
);
10503 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, bss
->ifindex
);
10505 cqm
= nla_nest_start(msg
, NL80211_ATTR_CQM
);
10507 goto nla_put_failure
;
10509 NLA_PUT_U32(msg
, NL80211_ATTR_CQM_RSSI_THOLD
, threshold
);
10510 NLA_PUT_U32(msg
, NL80211_ATTR_CQM_RSSI_HYST
, hysteresis
);
10511 nla_nest_end(msg
, cqm
);
10513 ret
= send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
10522 static int get_channel_width(struct nl_msg
*msg
, void *arg
)
10524 struct nlattr
*tb
[NL80211_ATTR_MAX
+ 1];
10525 struct genlmsghdr
*gnlh
= nlmsg_data(nlmsg_hdr(msg
));
10526 struct wpa_signal_info
*sig_change
= arg
;
10528 nla_parse(tb
, NL80211_ATTR_MAX
, genlmsg_attrdata(gnlh
, 0),
10529 genlmsg_attrlen(gnlh
, 0), NULL
);
10531 sig_change
->center_frq1
= -1;
10532 sig_change
->center_frq2
= -1;
10533 sig_change
->chanwidth
= CHAN_WIDTH_UNKNOWN
;
10535 if (tb
[NL80211_ATTR_CHANNEL_WIDTH
]) {
10536 sig_change
->chanwidth
= convert2width(
10537 nla_get_u32(tb
[NL80211_ATTR_CHANNEL_WIDTH
]));
10538 if (tb
[NL80211_ATTR_CENTER_FREQ1
])
10539 sig_change
->center_frq1
=
10540 nla_get_u32(tb
[NL80211_ATTR_CENTER_FREQ1
]);
10541 if (tb
[NL80211_ATTR_CENTER_FREQ2
])
10542 sig_change
->center_frq2
=
10543 nla_get_u32(tb
[NL80211_ATTR_CENTER_FREQ2
]);
10550 static int nl80211_get_channel_width(struct wpa_driver_nl80211_data
*drv
,
10551 struct wpa_signal_info
*sig
)
10553 struct nl_msg
*msg
;
10555 msg
= nlmsg_alloc();
10559 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_GET_INTERFACE
);
10560 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, drv
->ifindex
);
10562 return send_and_recv_msgs(drv
, msg
, get_channel_width
, sig
);
10570 static int nl80211_signal_poll(void *priv
, struct wpa_signal_info
*si
)
10572 struct i802_bss
*bss
= priv
;
10573 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
10576 os_memset(si
, 0, sizeof(*si
));
10577 res
= nl80211_get_link_signal(drv
, si
);
10581 res
= nl80211_get_channel_width(drv
, si
);
10585 return nl80211_get_link_noise(drv
, si
);
10589 static int wpa_driver_nl80211_shared_freq(void *priv
)
10591 struct i802_bss
*bss
= priv
;
10592 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
10593 struct wpa_driver_nl80211_data
*driver
;
10597 * If the same PHY is in connected state with some other interface,
10598 * then retrieve the assoc freq.
10600 wpa_printf(MSG_DEBUG
, "nl80211: Get shared freq for PHY %s",
10603 dl_list_for_each(driver
, &drv
->global
->interfaces
,
10604 struct wpa_driver_nl80211_data
, list
) {
10605 if (drv
== driver
||
10606 os_strcmp(drv
->phyname
, driver
->phyname
) != 0 ||
10607 !driver
->associated
)
10610 wpa_printf(MSG_DEBUG
, "nl80211: Found a match for PHY %s - %s "
10612 driver
->phyname
, driver
->first_bss
->ifname
,
10613 MAC2STR(driver
->first_bss
->addr
));
10614 if (is_ap_interface(driver
->nlmode
))
10615 freq
= driver
->first_bss
->freq
;
10617 freq
= nl80211_get_assoc_freq(driver
);
10618 wpa_printf(MSG_DEBUG
, "nl80211: Shared freq for PHY %s: %d",
10619 drv
->phyname
, freq
);
10623 wpa_printf(MSG_DEBUG
, "nl80211: No shared interface for "
10624 "PHY (%s) in associated state", drv
->phyname
);
10630 static int nl80211_send_frame(void *priv
, const u8
*data
, size_t data_len
,
10633 struct i802_bss
*bss
= priv
;
10634 return wpa_driver_nl80211_send_frame(bss
, data
, data_len
, encrypt
, 0,
10639 static int nl80211_set_param(void *priv
, const char *param
)
10641 wpa_printf(MSG_DEBUG
, "nl80211: driver param='%s'", param
);
10646 if (os_strstr(param
, "use_p2p_group_interface=1")) {
10647 struct i802_bss
*bss
= priv
;
10648 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
10650 wpa_printf(MSG_DEBUG
, "nl80211: Use separate P2P group "
10652 drv
->capa
.flags
|= WPA_DRIVER_FLAGS_P2P_CONCURRENT
;
10653 drv
->capa
.flags
|= WPA_DRIVER_FLAGS_P2P_MGMT_AND_NON_P2P
;
10656 if (os_strstr(param
, "p2p_device=1")) {
10657 struct i802_bss
*bss
= priv
;
10658 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
10659 drv
->allow_p2p_device
= 1;
10661 #endif /* CONFIG_P2P */
10663 if (os_strstr(param
, "use_monitor=1")) {
10664 struct i802_bss
*bss
= priv
;
10665 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
10666 drv
->use_monitor
= 1;
10669 if (os_strstr(param
, "force_connect_cmd=1")) {
10670 struct i802_bss
*bss
= priv
;
10671 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
10672 drv
->capa
.flags
&= ~WPA_DRIVER_FLAGS_SME
;
10675 if (os_strstr(param
, "no_offchannel_tx=1")) {
10676 struct i802_bss
*bss
= priv
;
10677 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
10678 drv
->capa
.flags
&= ~WPA_DRIVER_FLAGS_OFFCHANNEL_TX
;
10679 drv
->test_use_roc_tx
= 1;
10686 static void * nl80211_global_init(void)
10688 struct nl80211_global
*global
;
10689 struct netlink_config
*cfg
;
10691 global
= os_zalloc(sizeof(*global
));
10692 if (global
== NULL
)
10694 global
->ioctl_sock
= -1;
10695 dl_list_init(&global
->interfaces
);
10696 global
->if_add_ifindex
= -1;
10698 cfg
= os_zalloc(sizeof(*cfg
));
10703 cfg
->newlink_cb
= wpa_driver_nl80211_event_rtm_newlink
;
10704 cfg
->dellink_cb
= wpa_driver_nl80211_event_rtm_dellink
;
10705 global
->netlink
= netlink_init(cfg
);
10706 if (global
->netlink
== NULL
) {
10711 if (wpa_driver_nl80211_init_nl_global(global
) < 0)
10714 global
->ioctl_sock
= socket(PF_INET
, SOCK_DGRAM
, 0);
10715 if (global
->ioctl_sock
< 0) {
10716 wpa_printf(MSG_ERROR
, "nl80211: socket(PF_INET,SOCK_DGRAM) failed: %s",
10724 nl80211_global_deinit(global
);
10729 static void nl80211_global_deinit(void *priv
)
10731 struct nl80211_global
*global
= priv
;
10732 if (global
== NULL
)
10734 if (!dl_list_empty(&global
->interfaces
)) {
10735 wpa_printf(MSG_ERROR
, "nl80211: %u interface(s) remain at "
10736 "nl80211_global_deinit",
10737 dl_list_len(&global
->interfaces
));
10740 if (global
->netlink
)
10741 netlink_deinit(global
->netlink
);
10743 nl_destroy_handles(&global
->nl
);
10745 if (global
->nl_event
)
10746 nl80211_destroy_eloop_handle(&global
->nl_event
);
10748 nl_cb_put(global
->nl_cb
);
10750 if (global
->ioctl_sock
>= 0)
10751 close(global
->ioctl_sock
);
10757 static const char * nl80211_get_radio_name(void *priv
)
10759 struct i802_bss
*bss
= priv
;
10760 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
10761 return drv
->phyname
;
10765 static int nl80211_pmkid(struct i802_bss
*bss
, int cmd
, const u8
*bssid
,
10768 struct nl_msg
*msg
;
10770 msg
= nlmsg_alloc();
10774 nl80211_cmd(bss
->drv
, msg
, 0, cmd
);
10776 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, if_nametoindex(bss
->ifname
));
10778 NLA_PUT(msg
, NL80211_ATTR_PMKID
, 16, pmkid
);
10780 NLA_PUT(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, bssid
);
10782 return send_and_recv_msgs(bss
->drv
, msg
, NULL
, NULL
);
10789 static int nl80211_add_pmkid(void *priv
, const u8
*bssid
, const u8
*pmkid
)
10791 struct i802_bss
*bss
= priv
;
10792 wpa_printf(MSG_DEBUG
, "nl80211: Add PMKID for " MACSTR
, MAC2STR(bssid
));
10793 return nl80211_pmkid(bss
, NL80211_CMD_SET_PMKSA
, bssid
, pmkid
);
10797 static int nl80211_remove_pmkid(void *priv
, const u8
*bssid
, const u8
*pmkid
)
10799 struct i802_bss
*bss
= priv
;
10800 wpa_printf(MSG_DEBUG
, "nl80211: Delete PMKID for " MACSTR
,
10802 return nl80211_pmkid(bss
, NL80211_CMD_DEL_PMKSA
, bssid
, pmkid
);
10806 static int nl80211_flush_pmkid(void *priv
)
10808 struct i802_bss
*bss
= priv
;
10809 wpa_printf(MSG_DEBUG
, "nl80211: Flush PMKIDs");
10810 return nl80211_pmkid(bss
, NL80211_CMD_FLUSH_PMKSA
, NULL
, NULL
);
10814 static void clean_survey_results(struct survey_results
*survey_results
)
10816 struct freq_survey
*survey
, *tmp
;
10818 if (dl_list_empty(&survey_results
->survey_list
))
10821 dl_list_for_each_safe(survey
, tmp
, &survey_results
->survey_list
,
10822 struct freq_survey
, list
) {
10823 dl_list_del(&survey
->list
);
10829 static void add_survey(struct nlattr
**sinfo
, u32 ifidx
,
10830 struct dl_list
*survey_list
)
10832 struct freq_survey
*survey
;
10834 survey
= os_zalloc(sizeof(struct freq_survey
));
10838 survey
->ifidx
= ifidx
;
10839 survey
->freq
= nla_get_u32(sinfo
[NL80211_SURVEY_INFO_FREQUENCY
]);
10840 survey
->filled
= 0;
10842 if (sinfo
[NL80211_SURVEY_INFO_NOISE
]) {
10843 survey
->nf
= (int8_t)
10844 nla_get_u8(sinfo
[NL80211_SURVEY_INFO_NOISE
]);
10845 survey
->filled
|= SURVEY_HAS_NF
;
10848 if (sinfo
[NL80211_SURVEY_INFO_CHANNEL_TIME
]) {
10849 survey
->channel_time
=
10850 nla_get_u64(sinfo
[NL80211_SURVEY_INFO_CHANNEL_TIME
]);
10851 survey
->filled
|= SURVEY_HAS_CHAN_TIME
;
10854 if (sinfo
[NL80211_SURVEY_INFO_CHANNEL_TIME_BUSY
]) {
10855 survey
->channel_time_busy
=
10856 nla_get_u64(sinfo
[NL80211_SURVEY_INFO_CHANNEL_TIME_BUSY
]);
10857 survey
->filled
|= SURVEY_HAS_CHAN_TIME_BUSY
;
10860 if (sinfo
[NL80211_SURVEY_INFO_CHANNEL_TIME_RX
]) {
10861 survey
->channel_time_rx
=
10862 nla_get_u64(sinfo
[NL80211_SURVEY_INFO_CHANNEL_TIME_RX
]);
10863 survey
->filled
|= SURVEY_HAS_CHAN_TIME_RX
;
10866 if (sinfo
[NL80211_SURVEY_INFO_CHANNEL_TIME_TX
]) {
10867 survey
->channel_time_tx
=
10868 nla_get_u64(sinfo
[NL80211_SURVEY_INFO_CHANNEL_TIME_TX
]);
10869 survey
->filled
|= SURVEY_HAS_CHAN_TIME_TX
;
10872 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)",
10875 (unsigned long int) survey
->channel_time
,
10876 (unsigned long int) survey
->channel_time_busy
,
10877 (unsigned long int) survey
->channel_time_tx
,
10878 (unsigned long int) survey
->channel_time_rx
,
10881 dl_list_add_tail(survey_list
, &survey
->list
);
10885 static int check_survey_ok(struct nlattr
**sinfo
, u32 surveyed_freq
,
10886 unsigned int freq_filter
)
10891 return freq_filter
== surveyed_freq
;
10895 static int survey_handler(struct nl_msg
*msg
, void *arg
)
10897 struct nlattr
*tb
[NL80211_ATTR_MAX
+ 1];
10898 struct genlmsghdr
*gnlh
= nlmsg_data(nlmsg_hdr(msg
));
10899 struct nlattr
*sinfo
[NL80211_SURVEY_INFO_MAX
+ 1];
10900 struct survey_results
*survey_results
;
10901 u32 surveyed_freq
= 0;
10904 static struct nla_policy survey_policy
[NL80211_SURVEY_INFO_MAX
+ 1] = {
10905 [NL80211_SURVEY_INFO_FREQUENCY
] = { .type
= NLA_U32
},
10906 [NL80211_SURVEY_INFO_NOISE
] = { .type
= NLA_U8
},
10909 survey_results
= (struct survey_results
*) arg
;
10911 nla_parse(tb
, NL80211_ATTR_MAX
, genlmsg_attrdata(gnlh
, 0),
10912 genlmsg_attrlen(gnlh
, 0), NULL
);
10914 if (!tb
[NL80211_ATTR_IFINDEX
])
10917 ifidx
= nla_get_u32(tb
[NL80211_ATTR_IFINDEX
]);
10919 if (!tb
[NL80211_ATTR_SURVEY_INFO
])
10922 if (nla_parse_nested(sinfo
, NL80211_SURVEY_INFO_MAX
,
10923 tb
[NL80211_ATTR_SURVEY_INFO
],
10927 if (!sinfo
[NL80211_SURVEY_INFO_FREQUENCY
]) {
10928 wpa_printf(MSG_ERROR
, "nl80211: Invalid survey data");
10932 surveyed_freq
= nla_get_u32(sinfo
[NL80211_SURVEY_INFO_FREQUENCY
]);
10934 if (!check_survey_ok(sinfo
, surveyed_freq
,
10935 survey_results
->freq_filter
))
10938 if (survey_results
->freq_filter
&&
10939 survey_results
->freq_filter
!= surveyed_freq
) {
10940 wpa_printf(MSG_EXCESSIVE
, "nl80211: Ignoring survey data for freq %d MHz",
10945 add_survey(sinfo
, ifidx
, &survey_results
->survey_list
);
10951 static int wpa_driver_nl80211_get_survey(void *priv
, unsigned int freq
)
10953 struct i802_bss
*bss
= priv
;
10954 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
10955 struct nl_msg
*msg
;
10956 int err
= -ENOBUFS
;
10957 union wpa_event_data data
;
10958 struct survey_results
*survey_results
;
10960 os_memset(&data
, 0, sizeof(data
));
10961 survey_results
= &data
.survey_results
;
10963 dl_list_init(&survey_results
->survey_list
);
10965 msg
= nlmsg_alloc();
10967 goto nla_put_failure
;
10969 nl80211_cmd(drv
, msg
, NLM_F_DUMP
, NL80211_CMD_GET_SURVEY
);
10971 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, drv
->ifindex
);
10974 data
.survey_results
.freq_filter
= freq
;
10977 wpa_printf(MSG_DEBUG
, "nl80211: Fetch survey data");
10978 err
= send_and_recv_msgs(drv
, msg
, survey_handler
,
10983 wpa_printf(MSG_ERROR
, "nl80211: Failed to process survey data");
10987 wpa_supplicant_event(drv
->ctx
, EVENT_SURVEY
, &data
);
10990 clean_survey_results(survey_results
);
10996 static void nl80211_set_rekey_info(void *priv
, const u8
*kek
, const u8
*kck
,
10997 const u8
*replay_ctr
)
10999 struct i802_bss
*bss
= priv
;
11000 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
11001 struct nlattr
*replay_nested
;
11002 struct nl_msg
*msg
;
11004 msg
= nlmsg_alloc();
11008 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_SET_REKEY_OFFLOAD
);
11010 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, bss
->ifindex
);
11012 replay_nested
= nla_nest_start(msg
, NL80211_ATTR_REKEY_DATA
);
11013 if (!replay_nested
)
11014 goto nla_put_failure
;
11016 NLA_PUT(msg
, NL80211_REKEY_DATA_KEK
, NL80211_KEK_LEN
, kek
);
11017 NLA_PUT(msg
, NL80211_REKEY_DATA_KCK
, NL80211_KCK_LEN
, kck
);
11018 NLA_PUT(msg
, NL80211_REKEY_DATA_REPLAY_CTR
, NL80211_REPLAY_CTR_LEN
,
11021 nla_nest_end(msg
, replay_nested
);
11023 send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
11030 static void nl80211_send_null_frame(struct i802_bss
*bss
, const u8
*own_addr
,
11031 const u8
*addr
, int qos
)
11033 /* send data frame to poll STA and check whether
11034 * this frame is ACKed */
11036 struct ieee80211_hdr hdr
;
11038 } STRUCT_PACKED nulldata
;
11041 /* Send data frame to poll STA and check whether this frame is ACKed */
11043 os_memset(&nulldata
, 0, sizeof(nulldata
));
11046 nulldata
.hdr
.frame_control
=
11047 IEEE80211_FC(WLAN_FC_TYPE_DATA
,
11048 WLAN_FC_STYPE_QOS_NULL
);
11049 size
= sizeof(nulldata
);
11051 nulldata
.hdr
.frame_control
=
11052 IEEE80211_FC(WLAN_FC_TYPE_DATA
,
11053 WLAN_FC_STYPE_NULLFUNC
);
11054 size
= sizeof(struct ieee80211_hdr
);
11057 nulldata
.hdr
.frame_control
|= host_to_le16(WLAN_FC_FROMDS
);
11058 os_memcpy(nulldata
.hdr
.IEEE80211_DA_FROMDS
, addr
, ETH_ALEN
);
11059 os_memcpy(nulldata
.hdr
.IEEE80211_BSSID_FROMDS
, own_addr
, ETH_ALEN
);
11060 os_memcpy(nulldata
.hdr
.IEEE80211_SA_FROMDS
, own_addr
, ETH_ALEN
);
11062 if (wpa_driver_nl80211_send_mlme(bss
, (u8
*) &nulldata
, size
, 0, 0, 0,
11064 wpa_printf(MSG_DEBUG
, "nl80211_send_null_frame: Failed to "
11065 "send poll frame");
11068 static void nl80211_poll_client(void *priv
, const u8
*own_addr
, const u8
*addr
,
11071 struct i802_bss
*bss
= priv
;
11072 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
11073 struct nl_msg
*msg
;
11075 if (!drv
->poll_command_supported
) {
11076 nl80211_send_null_frame(bss
, own_addr
, addr
, qos
);
11080 msg
= nlmsg_alloc();
11084 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_PROBE_CLIENT
);
11086 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, bss
->ifindex
);
11087 NLA_PUT(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, addr
);
11089 send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
11096 static int nl80211_set_power_save(struct i802_bss
*bss
, int enabled
)
11098 struct nl_msg
*msg
;
11100 msg
= nlmsg_alloc();
11104 nl80211_cmd(bss
->drv
, msg
, 0, NL80211_CMD_SET_POWER_SAVE
);
11105 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, bss
->ifindex
);
11106 NLA_PUT_U32(msg
, NL80211_ATTR_PS_STATE
,
11107 enabled
? NL80211_PS_ENABLED
: NL80211_PS_DISABLED
);
11108 return send_and_recv_msgs(bss
->drv
, msg
, NULL
, NULL
);
11115 static int nl80211_set_p2p_powersave(void *priv
, int legacy_ps
, int opp_ps
,
11118 struct i802_bss
*bss
= priv
;
11120 wpa_printf(MSG_DEBUG
, "nl80211: set_p2p_powersave (legacy_ps=%d "
11121 "opp_ps=%d ctwindow=%d)", legacy_ps
, opp_ps
, ctwindow
);
11123 if (opp_ps
!= -1 || ctwindow
!= -1) {
11125 wpa_driver_set_p2p_ps(priv
, legacy_ps
, opp_ps
, ctwindow
);
11126 #else /* ANDROID_P2P */
11127 return -1; /* Not yet supported */
11128 #endif /* ANDROID_P2P */
11131 if (legacy_ps
== -1)
11133 if (legacy_ps
!= 0 && legacy_ps
!= 1)
11134 return -1; /* Not yet supported */
11136 return nl80211_set_power_save(bss
, legacy_ps
);
11140 static int nl80211_start_radar_detection(void *priv
,
11141 struct hostapd_freq_params
*freq
)
11143 struct i802_bss
*bss
= priv
;
11144 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
11145 struct nl_msg
*msg
;
11148 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)",
11149 freq
->freq
, freq
->ht_enabled
, freq
->vht_enabled
,
11150 freq
->bandwidth
, freq
->center_freq1
, freq
->center_freq2
);
11152 if (!(drv
->capa
.flags
& WPA_DRIVER_FLAGS_RADAR
)) {
11153 wpa_printf(MSG_DEBUG
, "nl80211: Driver does not support radar "
11158 msg
= nlmsg_alloc();
11162 nl80211_cmd(bss
->drv
, msg
, 0, NL80211_CMD_RADAR_DETECT
);
11163 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, drv
->ifindex
);
11164 NLA_PUT_U32(msg
, NL80211_ATTR_WIPHY_FREQ
, freq
->freq
);
11166 if (freq
->vht_enabled
) {
11167 switch (freq
->bandwidth
) {
11169 NLA_PUT_U32(msg
, NL80211_ATTR_CHANNEL_WIDTH
,
11170 NL80211_CHAN_WIDTH_20
);
11173 NLA_PUT_U32(msg
, NL80211_ATTR_CHANNEL_WIDTH
,
11174 NL80211_CHAN_WIDTH_40
);
11177 if (freq
->center_freq2
)
11178 NLA_PUT_U32(msg
, NL80211_ATTR_CHANNEL_WIDTH
,
11179 NL80211_CHAN_WIDTH_80P80
);
11181 NLA_PUT_U32(msg
, NL80211_ATTR_CHANNEL_WIDTH
,
11182 NL80211_CHAN_WIDTH_80
);
11185 NLA_PUT_U32(msg
, NL80211_ATTR_CHANNEL_WIDTH
,
11186 NL80211_CHAN_WIDTH_160
);
11191 NLA_PUT_U32(msg
, NL80211_ATTR_CENTER_FREQ1
, freq
->center_freq1
);
11192 if (freq
->center_freq2
)
11193 NLA_PUT_U32(msg
, NL80211_ATTR_CENTER_FREQ2
,
11194 freq
->center_freq2
);
11195 } else if (freq
->ht_enabled
) {
11196 switch (freq
->sec_channel_offset
) {
11198 NLA_PUT_U32(msg
, NL80211_ATTR_WIPHY_CHANNEL_TYPE
,
11199 NL80211_CHAN_HT40MINUS
);
11202 NLA_PUT_U32(msg
, NL80211_ATTR_WIPHY_CHANNEL_TYPE
,
11203 NL80211_CHAN_HT40PLUS
);
11206 NLA_PUT_U32(msg
, NL80211_ATTR_WIPHY_CHANNEL_TYPE
,
11207 NL80211_CHAN_HT20
);
11212 ret
= send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
11215 wpa_printf(MSG_DEBUG
, "nl80211: Failed to start radar detection: "
11216 "%d (%s)", ret
, strerror(-ret
));
11223 static int nl80211_send_tdls_mgmt(void *priv
, const u8
*dst
, u8 action_code
,
11224 u8 dialog_token
, u16 status_code
,
11225 const u8
*buf
, size_t len
)
11227 struct i802_bss
*bss
= priv
;
11228 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
11229 struct nl_msg
*msg
;
11231 if (!(drv
->capa
.flags
& WPA_DRIVER_FLAGS_TDLS_SUPPORT
))
11232 return -EOPNOTSUPP
;
11237 msg
= nlmsg_alloc();
11241 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_TDLS_MGMT
);
11242 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, drv
->ifindex
);
11243 NLA_PUT(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, dst
);
11244 NLA_PUT_U8(msg
, NL80211_ATTR_TDLS_ACTION
, action_code
);
11245 NLA_PUT_U8(msg
, NL80211_ATTR_TDLS_DIALOG_TOKEN
, dialog_token
);
11246 NLA_PUT_U16(msg
, NL80211_ATTR_STATUS_CODE
, status_code
);
11247 NLA_PUT(msg
, NL80211_ATTR_IE
, len
, buf
);
11249 return send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
11257 static int nl80211_tdls_oper(void *priv
, enum tdls_oper oper
, const u8
*peer
)
11259 struct i802_bss
*bss
= priv
;
11260 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
11261 struct nl_msg
*msg
;
11262 enum nl80211_tdls_operation nl80211_oper
;
11264 if (!(drv
->capa
.flags
& WPA_DRIVER_FLAGS_TDLS_SUPPORT
))
11265 return -EOPNOTSUPP
;
11268 case TDLS_DISCOVERY_REQ
:
11269 nl80211_oper
= NL80211_TDLS_DISCOVERY_REQ
;
11272 nl80211_oper
= NL80211_TDLS_SETUP
;
11274 case TDLS_TEARDOWN
:
11275 nl80211_oper
= NL80211_TDLS_TEARDOWN
;
11277 case TDLS_ENABLE_LINK
:
11278 nl80211_oper
= NL80211_TDLS_ENABLE_LINK
;
11280 case TDLS_DISABLE_LINK
:
11281 nl80211_oper
= NL80211_TDLS_DISABLE_LINK
;
11291 msg
= nlmsg_alloc();
11295 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_TDLS_OPER
);
11296 NLA_PUT_U8(msg
, NL80211_ATTR_TDLS_OPERATION
, nl80211_oper
);
11297 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, drv
->ifindex
);
11298 NLA_PUT(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, peer
);
11300 return send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
11307 #endif /* CONFIG TDLS */
11312 typedef struct android_wifi_priv_cmd
{
11316 } android_wifi_priv_cmd
;
11318 static int drv_errors
= 0;
11320 static void wpa_driver_send_hang_msg(struct wpa_driver_nl80211_data
*drv
)
11323 if (drv_errors
> DRV_NUMBER_SEQUENTIAL_ERRORS
) {
11325 wpa_msg(drv
->ctx
, MSG_INFO
, WPA_EVENT_DRIVER_STATE
"HANGED");
11330 static int android_priv_cmd(struct i802_bss
*bss
, const char *cmd
)
11332 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
11334 android_wifi_priv_cmd priv_cmd
;
11335 char buf
[MAX_DRV_CMD_SIZE
];
11338 os_memset(&ifr
, 0, sizeof(ifr
));
11339 os_memset(&priv_cmd
, 0, sizeof(priv_cmd
));
11340 os_strlcpy(ifr
.ifr_name
, bss
->ifname
, IFNAMSIZ
);
11342 os_memset(buf
, 0, sizeof(buf
));
11343 os_strlcpy(buf
, cmd
, sizeof(buf
));
11345 priv_cmd
.buf
= buf
;
11346 priv_cmd
.used_len
= sizeof(buf
);
11347 priv_cmd
.total_len
= sizeof(buf
);
11348 ifr
.ifr_data
= &priv_cmd
;
11350 ret
= ioctl(drv
->global
->ioctl_sock
, SIOCDEVPRIVATE
+ 1, &ifr
);
11352 wpa_printf(MSG_ERROR
, "%s: failed to issue private commands",
11354 wpa_driver_send_hang_msg(drv
);
11363 static int android_pno_start(struct i802_bss
*bss
,
11364 struct wpa_driver_scan_params
*params
)
11366 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
11368 android_wifi_priv_cmd priv_cmd
;
11369 int ret
= 0, i
= 0, bp
;
11370 char buf
[WEXT_PNO_MAX_COMMAND_SIZE
];
11372 bp
= WEXT_PNOSETUP_HEADER_SIZE
;
11373 os_memcpy(buf
, WEXT_PNOSETUP_HEADER
, bp
);
11374 buf
[bp
++] = WEXT_PNO_TLV_PREFIX
;
11375 buf
[bp
++] = WEXT_PNO_TLV_VERSION
;
11376 buf
[bp
++] = WEXT_PNO_TLV_SUBVERSION
;
11377 buf
[bp
++] = WEXT_PNO_TLV_RESERVED
;
11379 while (i
< WEXT_PNO_AMOUNT
&& (size_t) i
< params
->num_ssids
) {
11380 /* Check that there is enough space needed for 1 more SSID, the
11381 * other sections and null termination */
11382 if ((bp
+ WEXT_PNO_SSID_HEADER_SIZE
+ MAX_SSID_LEN
+
11383 WEXT_PNO_NONSSID_SECTIONS_SIZE
+ 1) >= (int) sizeof(buf
))
11385 wpa_hexdump_ascii(MSG_DEBUG
, "For PNO Scan",
11386 params
->ssids
[i
].ssid
,
11387 params
->ssids
[i
].ssid_len
);
11388 buf
[bp
++] = WEXT_PNO_SSID_SECTION
;
11389 buf
[bp
++] = params
->ssids
[i
].ssid_len
;
11390 os_memcpy(&buf
[bp
], params
->ssids
[i
].ssid
,
11391 params
->ssids
[i
].ssid_len
);
11392 bp
+= params
->ssids
[i
].ssid_len
;
11396 buf
[bp
++] = WEXT_PNO_SCAN_INTERVAL_SECTION
;
11397 os_snprintf(&buf
[bp
], WEXT_PNO_SCAN_INTERVAL_LENGTH
+ 1, "%x",
11398 WEXT_PNO_SCAN_INTERVAL
);
11399 bp
+= WEXT_PNO_SCAN_INTERVAL_LENGTH
;
11401 buf
[bp
++] = WEXT_PNO_REPEAT_SECTION
;
11402 os_snprintf(&buf
[bp
], WEXT_PNO_REPEAT_LENGTH
+ 1, "%x",
11404 bp
+= WEXT_PNO_REPEAT_LENGTH
;
11406 buf
[bp
++] = WEXT_PNO_MAX_REPEAT_SECTION
;
11407 os_snprintf(&buf
[bp
], WEXT_PNO_MAX_REPEAT_LENGTH
+ 1, "%x",
11408 WEXT_PNO_MAX_REPEAT
);
11409 bp
+= WEXT_PNO_MAX_REPEAT_LENGTH
+ 1;
11411 memset(&ifr
, 0, sizeof(ifr
));
11412 memset(&priv_cmd
, 0, sizeof(priv_cmd
));
11413 os_strlcpy(ifr
.ifr_name
, bss
->ifname
, IFNAMSIZ
);
11415 priv_cmd
.buf
= buf
;
11416 priv_cmd
.used_len
= bp
;
11417 priv_cmd
.total_len
= bp
;
11418 ifr
.ifr_data
= &priv_cmd
;
11420 ret
= ioctl(drv
->global
->ioctl_sock
, SIOCDEVPRIVATE
+ 1, &ifr
);
11423 wpa_printf(MSG_ERROR
, "ioctl[SIOCSIWPRIV] (pnosetup): %d",
11425 wpa_driver_send_hang_msg(drv
);
11431 return android_priv_cmd(bss
, "PNOFORCE 1");
11435 static int android_pno_stop(struct i802_bss
*bss
)
11437 return android_priv_cmd(bss
, "PNOFORCE 0");
11440 #endif /* ANDROID */
11443 static int driver_nl80211_set_key(const char *ifname
, void *priv
,
11444 enum wpa_alg alg
, const u8
*addr
,
11445 int key_idx
, int set_tx
,
11446 const u8
*seq
, size_t seq_len
,
11447 const u8
*key
, size_t key_len
)
11449 struct i802_bss
*bss
= priv
;
11450 return wpa_driver_nl80211_set_key(ifname
, bss
, alg
, addr
, key_idx
,
11451 set_tx
, seq
, seq_len
, key
, key_len
);
11455 static int driver_nl80211_scan2(void *priv
,
11456 struct wpa_driver_scan_params
*params
)
11458 struct i802_bss
*bss
= priv
;
11459 return wpa_driver_nl80211_scan(bss
, params
);
11463 static int driver_nl80211_deauthenticate(void *priv
, const u8
*addr
,
11466 struct i802_bss
*bss
= priv
;
11467 return wpa_driver_nl80211_deauthenticate(bss
, addr
, reason_code
);
11471 static int driver_nl80211_authenticate(void *priv
,
11472 struct wpa_driver_auth_params
*params
)
11474 struct i802_bss
*bss
= priv
;
11475 return wpa_driver_nl80211_authenticate(bss
, params
);
11479 static void driver_nl80211_deinit(void *priv
)
11481 struct i802_bss
*bss
= priv
;
11482 wpa_driver_nl80211_deinit(bss
);
11486 static int driver_nl80211_if_remove(void *priv
, enum wpa_driver_if_type type
,
11487 const char *ifname
)
11489 struct i802_bss
*bss
= priv
;
11490 return wpa_driver_nl80211_if_remove(bss
, type
, ifname
);
11494 static int driver_nl80211_send_mlme(void *priv
, const u8
*data
,
11495 size_t data_len
, int noack
)
11497 struct i802_bss
*bss
= priv
;
11498 return wpa_driver_nl80211_send_mlme(bss
, data
, data_len
, noack
,
11503 static int driver_nl80211_sta_remove(void *priv
, const u8
*addr
)
11505 struct i802_bss
*bss
= priv
;
11506 return wpa_driver_nl80211_sta_remove(bss
, addr
);
11510 static int driver_nl80211_set_sta_vlan(void *priv
, const u8
*addr
,
11511 const char *ifname
, int vlan_id
)
11513 struct i802_bss
*bss
= priv
;
11514 return i802_set_sta_vlan(bss
, addr
, ifname
, vlan_id
);
11518 static int driver_nl80211_read_sta_data(void *priv
,
11519 struct hostap_sta_driver_data
*data
,
11522 struct i802_bss
*bss
= priv
;
11523 return i802_read_sta_data(bss
, data
, addr
);
11527 static int driver_nl80211_send_action(void *priv
, unsigned int freq
,
11528 unsigned int wait_time
,
11529 const u8
*dst
, const u8
*src
,
11531 const u8
*data
, size_t data_len
,
11534 struct i802_bss
*bss
= priv
;
11535 return wpa_driver_nl80211_send_action(bss
, freq
, wait_time
, dst
, src
,
11536 bssid
, data
, data_len
, no_cck
);
11540 static int driver_nl80211_probe_req_report(void *priv
, int report
)
11542 struct i802_bss
*bss
= priv
;
11543 return wpa_driver_nl80211_probe_req_report(bss
, report
);
11547 static int wpa_driver_nl80211_update_ft_ies(void *priv
, const u8
*md
,
11548 const u8
*ies
, size_t ies_len
)
11551 struct nl_msg
*msg
;
11552 struct i802_bss
*bss
= priv
;
11553 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
11554 u16 mdid
= WPA_GET_LE16(md
);
11556 msg
= nlmsg_alloc();
11560 wpa_printf(MSG_DEBUG
, "nl80211: Updating FT IEs");
11561 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_UPDATE_FT_IES
);
11562 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, drv
->ifindex
);
11563 NLA_PUT(msg
, NL80211_ATTR_IE
, ies_len
, ies
);
11564 NLA_PUT_U16(msg
, NL80211_ATTR_MDID
, mdid
);
11566 ret
= send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
11568 wpa_printf(MSG_DEBUG
, "nl80211: update_ft_ies failed "
11569 "err=%d (%s)", ret
, strerror(-ret
));
11580 const u8
* wpa_driver_nl80211_get_macaddr(void *priv
)
11582 struct i802_bss
*bss
= priv
;
11583 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
11585 if (drv
->nlmode
!= NL80211_IFTYPE_P2P_DEVICE
)
11592 static const char * scan_state_str(enum scan_states scan_state
)
11594 switch (scan_state
) {
11597 case SCAN_REQUESTED
:
11598 return "SCAN_REQUESTED";
11600 return "SCAN_STARTED";
11601 case SCAN_COMPLETED
:
11602 return "SCAN_COMPLETED";
11604 return "SCAN_ABORTED";
11605 case SCHED_SCAN_STARTED
:
11606 return "SCHED_SCAN_STARTED";
11607 case SCHED_SCAN_STOPPED
:
11608 return "SCHED_SCAN_STOPPED";
11609 case SCHED_SCAN_RESULTS
:
11610 return "SCHED_SCAN_RESULTS";
11617 static int wpa_driver_nl80211_status(void *priv
, char *buf
, size_t buflen
)
11619 struct i802_bss
*bss
= priv
;
11620 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
11625 end
= buf
+ buflen
;
11627 res
= os_snprintf(pos
, end
- pos
,
11631 "addr=" MACSTR
"\n"
11637 MAC2STR(bss
->addr
),
11639 bss
->beacon_set
? "beacon_set=1\n" : "",
11640 bss
->added_if_into_bridge
?
11641 "added_if_into_bridge=1\n" : "",
11642 bss
->added_bridge
? "added_bridge=1\n" : "",
11643 bss
->in_deinit
? "in_deinit=1\n" : "",
11644 bss
->if_dynamic
? "if_dynamic=1\n" : "");
11645 if (res
< 0 || res
>= end
- pos
)
11649 if (bss
->wdev_id_set
) {
11650 res
= os_snprintf(pos
, end
- pos
, "wdev_id=%llu\n",
11651 (unsigned long long) bss
->wdev_id
);
11652 if (res
< 0 || res
>= end
- pos
)
11657 res
= os_snprintf(pos
, end
- pos
,
11662 "auth_bssid=" MACSTR
"\n"
11663 "auth_attempt_bssid=" MACSTR
"\n"
11664 "bssid=" MACSTR
"\n"
11665 "prev_bssid=" MACSTR
"\n"
11668 "monitor_sock=%d\n"
11669 "monitor_ifidx=%d\n"
11670 "monitor_refcount=%d\n"
11671 "last_mgmt_freq=%u\n"
11672 "eapol_tx_sock=%d\n"
11673 "%s%s%s%s%s%s%s%s%s%s%s%s%s",
11677 scan_state_str(drv
->scan_state
),
11678 MAC2STR(drv
->auth_bssid
),
11679 MAC2STR(drv
->auth_attempt_bssid
),
11680 MAC2STR(drv
->bssid
),
11681 MAC2STR(drv
->prev_bssid
),
11685 drv
->monitor_ifidx
,
11686 drv
->monitor_refcount
,
11687 drv
->last_mgmt_freq
,
11688 drv
->eapol_tx_sock
,
11689 drv
->ignore_if_down_event
?
11690 "ignore_if_down_event=1\n" : "",
11691 drv
->scan_complete_events
?
11692 "scan_complete_events=1\n" : "",
11693 drv
->disabled_11b_rates
?
11694 "disabled_11b_rates=1\n" : "",
11695 drv
->pending_remain_on_chan
?
11696 "pending_remain_on_chan=1\n" : "",
11697 drv
->in_interface_list
? "in_interface_list=1\n" : "",
11698 drv
->device_ap_sme
? "device_ap_sme=1\n" : "",
11699 drv
->poll_command_supported
?
11700 "poll_command_supported=1\n" : "",
11701 drv
->data_tx_status
? "data_tx_status=1\n" : "",
11702 drv
->scan_for_auth
? "scan_for_auth=1\n" : "",
11703 drv
->retry_auth
? "retry_auth=1\n" : "",
11704 drv
->use_monitor
? "use_monitor=1\n" : "",
11705 drv
->ignore_next_local_disconnect
?
11706 "ignore_next_local_disconnect=1\n" : "",
11707 drv
->allow_p2p_device
? "allow_p2p_device=1\n" : "");
11708 if (res
< 0 || res
>= end
- pos
)
11712 if (drv
->has_capability
) {
11713 res
= os_snprintf(pos
, end
- pos
,
11714 "capa.key_mgmt=0x%x\n"
11717 "capa.flags=0x%x\n"
11718 "capa.max_scan_ssids=%d\n"
11719 "capa.max_sched_scan_ssids=%d\n"
11720 "capa.sched_scan_supported=%d\n"
11721 "capa.max_match_sets=%d\n"
11722 "capa.max_remain_on_chan=%u\n"
11723 "capa.max_stations=%u\n"
11724 "capa.probe_resp_offloads=0x%x\n"
11725 "capa.max_acl_mac_addrs=%u\n"
11726 "capa.num_multichan_concurrent=%u\n",
11727 drv
->capa
.key_mgmt
,
11731 drv
->capa
.max_scan_ssids
,
11732 drv
->capa
.max_sched_scan_ssids
,
11733 drv
->capa
.sched_scan_supported
,
11734 drv
->capa
.max_match_sets
,
11735 drv
->capa
.max_remain_on_chan
,
11736 drv
->capa
.max_stations
,
11737 drv
->capa
.probe_resp_offloads
,
11738 drv
->capa
.max_acl_mac_addrs
,
11739 drv
->capa
.num_multichan_concurrent
);
11740 if (res
< 0 || res
>= end
- pos
)
11749 static int set_beacon_data(struct nl_msg
*msg
, struct beacon_data
*settings
)
11751 if (settings
->head
)
11752 NLA_PUT(msg
, NL80211_ATTR_BEACON_HEAD
,
11753 settings
->head_len
, settings
->head
);
11755 if (settings
->tail
)
11756 NLA_PUT(msg
, NL80211_ATTR_BEACON_TAIL
,
11757 settings
->tail_len
, settings
->tail
);
11759 if (settings
->beacon_ies
)
11760 NLA_PUT(msg
, NL80211_ATTR_IE
,
11761 settings
->beacon_ies_len
, settings
->beacon_ies
);
11763 if (settings
->proberesp_ies
)
11764 NLA_PUT(msg
, NL80211_ATTR_IE_PROBE_RESP
,
11765 settings
->proberesp_ies_len
, settings
->proberesp_ies
);
11767 if (settings
->assocresp_ies
)
11769 NL80211_ATTR_IE_ASSOC_RESP
,
11770 settings
->assocresp_ies_len
, settings
->assocresp_ies
);
11772 if (settings
->probe_resp
)
11773 NLA_PUT(msg
, NL80211_ATTR_PROBE_RESP
,
11774 settings
->probe_resp_len
, settings
->probe_resp
);
11783 static int nl80211_switch_channel(void *priv
, struct csa_settings
*settings
)
11785 struct nl_msg
*msg
;
11786 struct i802_bss
*bss
= priv
;
11787 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
11788 struct nlattr
*beacon_csa
;
11789 int ret
= -ENOBUFS
;
11791 wpa_printf(MSG_DEBUG
, "nl80211: Channel switch request (cs_count=%u block_tx=%u freq=%d width=%d cf1=%d cf2=%d)",
11792 settings
->cs_count
, settings
->block_tx
,
11793 settings
->freq_params
.freq
, settings
->freq_params
.bandwidth
,
11794 settings
->freq_params
.center_freq1
,
11795 settings
->freq_params
.center_freq2
);
11797 if (!(drv
->capa
.flags
& WPA_DRIVER_FLAGS_AP_CSA
)) {
11798 wpa_printf(MSG_DEBUG
, "nl80211: Driver does not support channel switch command");
11799 return -EOPNOTSUPP
;
11802 if ((drv
->nlmode
!= NL80211_IFTYPE_AP
) &&
11803 (drv
->nlmode
!= NL80211_IFTYPE_P2P_GO
))
11804 return -EOPNOTSUPP
;
11806 /* check settings validity */
11807 if (!settings
->beacon_csa
.tail
||
11808 ((settings
->beacon_csa
.tail_len
<=
11809 settings
->counter_offset_beacon
) ||
11810 (settings
->beacon_csa
.tail
[settings
->counter_offset_beacon
] !=
11811 settings
->cs_count
)))
11814 if (settings
->beacon_csa
.probe_resp
&&
11815 ((settings
->beacon_csa
.probe_resp_len
<=
11816 settings
->counter_offset_presp
) ||
11817 (settings
->beacon_csa
.probe_resp
[settings
->counter_offset_presp
] !=
11818 settings
->cs_count
)))
11821 msg
= nlmsg_alloc();
11825 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_CHANNEL_SWITCH
);
11826 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, drv
->ifindex
);
11827 NLA_PUT_U32(msg
, NL80211_ATTR_CH_SWITCH_COUNT
, settings
->cs_count
);
11828 ret
= nl80211_put_freq_params(msg
, &settings
->freq_params
);
11832 if (settings
->block_tx
)
11833 NLA_PUT_FLAG(msg
, NL80211_ATTR_CH_SWITCH_BLOCK_TX
);
11835 /* beacon_after params */
11836 ret
= set_beacon_data(msg
, &settings
->beacon_after
);
11840 /* beacon_csa params */
11841 beacon_csa
= nla_nest_start(msg
, NL80211_ATTR_CSA_IES
);
11843 goto nla_put_failure
;
11845 ret
= set_beacon_data(msg
, &settings
->beacon_csa
);
11849 NLA_PUT_U16(msg
, NL80211_ATTR_CSA_C_OFF_BEACON
,
11850 settings
->counter_offset_beacon
);
11852 if (settings
->beacon_csa
.probe_resp
)
11853 NLA_PUT_U16(msg
, NL80211_ATTR_CSA_C_OFF_PRESP
,
11854 settings
->counter_offset_presp
);
11856 nla_nest_end(msg
, beacon_csa
);
11857 ret
= send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
11859 wpa_printf(MSG_DEBUG
, "nl80211: switch_channel failed err=%d (%s)",
11860 ret
, strerror(-ret
));
11868 wpa_printf(MSG_DEBUG
, "nl80211: Could not build channel switch request");
11873 #ifdef CONFIG_TESTING_OPTIONS
11874 static int cmd_reply_handler(struct nl_msg
*msg
, void *arg
)
11876 struct genlmsghdr
*gnlh
= nlmsg_data(nlmsg_hdr(msg
));
11877 struct wpabuf
*buf
= arg
;
11882 if ((size_t) genlmsg_attrlen(gnlh
, 0) > wpabuf_tailroom(buf
)) {
11883 wpa_printf(MSG_INFO
, "nl80211: insufficient buffer space for reply");
11887 wpabuf_put_data(buf
, genlmsg_attrdata(gnlh
, 0),
11888 genlmsg_attrlen(gnlh
, 0));
11892 #endif /* CONFIG_TESTING_OPTIONS */
11895 static int vendor_reply_handler(struct nl_msg
*msg
, void *arg
)
11897 struct nlattr
*tb
[NL80211_ATTR_MAX
+ 1];
11898 struct nlattr
*nl_vendor_reply
, *nl
;
11899 struct genlmsghdr
*gnlh
= nlmsg_data(nlmsg_hdr(msg
));
11900 struct wpabuf
*buf
= arg
;
11906 nla_parse(tb
, NL80211_ATTR_MAX
, genlmsg_attrdata(gnlh
, 0),
11907 genlmsg_attrlen(gnlh
, 0), NULL
);
11908 nl_vendor_reply
= tb
[NL80211_ATTR_VENDOR_DATA
];
11910 if (!nl_vendor_reply
)
11913 if ((size_t) nla_len(nl_vendor_reply
) > wpabuf_tailroom(buf
)) {
11914 wpa_printf(MSG_INFO
, "nl80211: Vendor command: insufficient buffer space for reply");
11918 nla_for_each_nested(nl
, nl_vendor_reply
, rem
) {
11919 wpabuf_put_data(buf
, nla_data(nl
), nla_len(nl
));
11926 static int nl80211_vendor_cmd(void *priv
, unsigned int vendor_id
,
11927 unsigned int subcmd
, const u8
*data
,
11928 size_t data_len
, struct wpabuf
*buf
)
11930 struct i802_bss
*bss
= priv
;
11931 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
11932 struct nl_msg
*msg
;
11935 msg
= nlmsg_alloc();
11939 #ifdef CONFIG_TESTING_OPTIONS
11940 if (vendor_id
== 0xffffffff) {
11941 nl80211_cmd(drv
, msg
, 0, subcmd
);
11942 if (nlmsg_append(msg
, (void *) data
, data_len
, NLMSG_ALIGNTO
) <
11944 goto nla_put_failure
;
11945 ret
= send_and_recv_msgs(drv
, msg
, cmd_reply_handler
, buf
);
11947 wpa_printf(MSG_DEBUG
, "nl80211: command failed err=%d",
11951 #endif /* CONFIG_TESTING_OPTIONS */
11953 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_VENDOR
);
11954 if (nl80211_set_iface_id(msg
, bss
) < 0)
11955 goto nla_put_failure
;
11956 NLA_PUT_U32(msg
, NL80211_ATTR_VENDOR_ID
, vendor_id
);
11957 NLA_PUT_U32(msg
, NL80211_ATTR_VENDOR_SUBCMD
, subcmd
);
11959 NLA_PUT(msg
, NL80211_ATTR_VENDOR_DATA
, data_len
, data
);
11961 ret
= send_and_recv_msgs(drv
, msg
, vendor_reply_handler
, buf
);
11963 wpa_printf(MSG_DEBUG
, "nl80211: vendor command failed err=%d",
11973 static int nl80211_set_qos_map(void *priv
, const u8
*qos_map_set
,
11974 u8 qos_map_set_len
)
11976 struct i802_bss
*bss
= priv
;
11977 struct wpa_driver_nl80211_data
*drv
= bss
->drv
;
11978 struct nl_msg
*msg
;
11981 msg
= nlmsg_alloc();
11985 wpa_hexdump(MSG_DEBUG
, "nl80211: Setting QoS Map",
11986 qos_map_set
, qos_map_set_len
);
11988 nl80211_cmd(drv
, msg
, 0, NL80211_CMD_SET_QOS_MAP
);
11989 NLA_PUT_U32(msg
, NL80211_ATTR_IFINDEX
, drv
->ifindex
);
11990 NLA_PUT(msg
, NL80211_ATTR_QOS_MAP
, qos_map_set_len
, qos_map_set
);
11992 ret
= send_and_recv_msgs(drv
, msg
, NULL
, NULL
);
11994 wpa_printf(MSG_DEBUG
, "nl80211: Setting QoS Map failed");
12004 const struct wpa_driver_ops wpa_driver_nl80211_ops
= {
12006 .desc
= "Linux nl80211/cfg80211",
12007 .get_bssid
= wpa_driver_nl80211_get_bssid
,
12008 .get_ssid
= wpa_driver_nl80211_get_ssid
,
12009 .set_key
= driver_nl80211_set_key
,
12010 .scan2
= driver_nl80211_scan2
,
12011 .sched_scan
= wpa_driver_nl80211_sched_scan
,
12012 .stop_sched_scan
= wpa_driver_nl80211_stop_sched_scan
,
12013 .get_scan_results2
= wpa_driver_nl80211_get_scan_results
,
12014 .deauthenticate
= driver_nl80211_deauthenticate
,
12015 .authenticate
= driver_nl80211_authenticate
,
12016 .associate
= wpa_driver_nl80211_associate
,
12017 .global_init
= nl80211_global_init
,
12018 .global_deinit
= nl80211_global_deinit
,
12019 .init2
= wpa_driver_nl80211_init
,
12020 .deinit
= driver_nl80211_deinit
,
12021 .get_capa
= wpa_driver_nl80211_get_capa
,
12022 .set_operstate
= wpa_driver_nl80211_set_operstate
,
12023 .set_supp_port
= wpa_driver_nl80211_set_supp_port
,
12024 .set_country
= wpa_driver_nl80211_set_country
,
12025 .get_country
= wpa_driver_nl80211_get_country
,
12026 .set_ap
= wpa_driver_nl80211_set_ap
,
12027 .set_acl
= wpa_driver_nl80211_set_acl
,
12028 .if_add
= wpa_driver_nl80211_if_add
,
12029 .if_remove
= driver_nl80211_if_remove
,
12030 .send_mlme
= driver_nl80211_send_mlme
,
12031 .get_hw_feature_data
= wpa_driver_nl80211_get_hw_feature_data
,
12032 .sta_add
= wpa_driver_nl80211_sta_add
,
12033 .sta_remove
= driver_nl80211_sta_remove
,
12034 .hapd_send_eapol
= wpa_driver_nl80211_hapd_send_eapol
,
12035 .sta_set_flags
= wpa_driver_nl80211_sta_set_flags
,
12036 .hapd_init
= i802_init
,
12037 .hapd_deinit
= i802_deinit
,
12038 .set_wds_sta
= i802_set_wds_sta
,
12039 .get_seqnum
= i802_get_seqnum
,
12040 .flush
= i802_flush
,
12041 .get_inact_sec
= i802_get_inact_sec
,
12042 .sta_clear_stats
= i802_sta_clear_stats
,
12043 .set_rts
= i802_set_rts
,
12044 .set_frag
= i802_set_frag
,
12045 .set_tx_queue_params
= i802_set_tx_queue_params
,
12046 .set_sta_vlan
= driver_nl80211_set_sta_vlan
,
12047 .sta_deauth
= i802_sta_deauth
,
12048 .sta_disassoc
= i802_sta_disassoc
,
12049 .read_sta_data
= driver_nl80211_read_sta_data
,
12050 .set_freq
= i802_set_freq
,
12051 .send_action
= driver_nl80211_send_action
,
12052 .send_action_cancel_wait
= wpa_driver_nl80211_send_action_cancel_wait
,
12053 .remain_on_channel
= wpa_driver_nl80211_remain_on_channel
,
12054 .cancel_remain_on_channel
=
12055 wpa_driver_nl80211_cancel_remain_on_channel
,
12056 .probe_req_report
= driver_nl80211_probe_req_report
,
12057 .deinit_ap
= wpa_driver_nl80211_deinit_ap
,
12058 .deinit_p2p_cli
= wpa_driver_nl80211_deinit_p2p_cli
,
12059 .resume
= wpa_driver_nl80211_resume
,
12060 .send_ft_action
= nl80211_send_ft_action
,
12061 .signal_monitor
= nl80211_signal_monitor
,
12062 .signal_poll
= nl80211_signal_poll
,
12063 .send_frame
= nl80211_send_frame
,
12064 .shared_freq
= wpa_driver_nl80211_shared_freq
,
12065 .set_param
= nl80211_set_param
,
12066 .get_radio_name
= nl80211_get_radio_name
,
12067 .add_pmkid
= nl80211_add_pmkid
,
12068 .remove_pmkid
= nl80211_remove_pmkid
,
12069 .flush_pmkid
= nl80211_flush_pmkid
,
12070 .set_rekey_info
= nl80211_set_rekey_info
,
12071 .poll_client
= nl80211_poll_client
,
12072 .set_p2p_powersave
= nl80211_set_p2p_powersave
,
12073 .start_dfs_cac
= nl80211_start_radar_detection
,
12074 .stop_ap
= wpa_driver_nl80211_stop_ap
,
12076 .send_tdls_mgmt
= nl80211_send_tdls_mgmt
,
12077 .tdls_oper
= nl80211_tdls_oper
,
12078 #endif /* CONFIG_TDLS */
12079 .update_ft_ies
= wpa_driver_nl80211_update_ft_ies
,
12080 .get_mac_addr
= wpa_driver_nl80211_get_macaddr
,
12081 .get_survey
= wpa_driver_nl80211_get_survey
,
12082 .status
= wpa_driver_nl80211_status
,
12083 .switch_channel
= nl80211_switch_channel
,
12085 .set_noa
= wpa_driver_set_p2p_noa
,
12086 .get_noa
= wpa_driver_get_p2p_noa
,
12087 .set_ap_wps_ie
= wpa_driver_set_ap_wps_p2p_ie
,
12088 #endif /* ANDROID_P2P */
12090 .driver_cmd
= wpa_driver_nl80211_driver_cmd
,
12091 #endif /* ANDROID */
12092 .vendor_cmd
= nl80211_vendor_cmd
,
12093 .set_qos_map
= nl80211_set_qos_map
,