]> git.ipfire.org Git - thirdparty/hostap.git/blob - src/drivers/driver_nl80211.c
projects / thirdparty / hostap.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
FILS: Define authentication algorithm for FILS SK auth with PFS
[thirdparty/hostap.git] / src / drivers / driver_nl80211.c
1 /*
2 * Driver interaction with Linux nl80211/cfg80211
3 * Copyright (c) 2002-2015, 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
8 *
9 * This software may be distributed under the terms of the BSD license.
10 * See README for more details.
11 */
12
13 #include "includes.h"
14 #include <sys/types.h>
15 #include <fcntl.h>
16 #include <net/if.h>
17 #include <netlink/genl/genl.h>
18 #include <netlink/genl/ctrl.h>
19 #ifdef CONFIG_LIBNL3_ROUTE
20 #include <netlink/route/neighbour.h>
21 #endif /* CONFIG_LIBNL3_ROUTE */
22 #include <linux/rtnetlink.h>
23 #include <netpacket/packet.h>
24 #include <linux/errqueue.h>
25
26 #include "common.h"
27 #include "eloop.h"
28 #include "common/qca-vendor.h"
29 #include "common/qca-vendor-attr.h"
30 #include "common/ieee802_11_defs.h"
31 #include "common/ieee802_11_common.h"
32 #include "common/wpa_common.h"
33 #include "l2_packet/l2_packet.h"
34 #include "netlink.h"
35 #include "linux_defines.h"
36 #include "linux_ioctl.h"
37 #include "radiotap.h"
38 #include "radiotap_iter.h"
39 #include "rfkill.h"
40 #include "driver_nl80211.h"
41
42
43 #ifndef CONFIG_LIBNL20
44 /*
45 * libnl 1.1 has a bug, it tries to allocate socket numbers densely
46 * but when you free a socket again it will mess up its bitmap and
47 * and use the wrong number the next time it needs a socket ID.
48 * Therefore, we wrap the handle alloc/destroy and add our own pid
49 * accounting.
50 */
51 static uint32_t port_bitmap[32] = { 0 };
52
53 static struct nl_handle *nl80211_handle_alloc(void *cb)
54 {
55 struct nl_handle *handle;
56 uint32_t pid = getpid() & 0x3FFFFF;
57 int i;
58
59 handle = nl_handle_alloc_cb(cb);
60
61 for (i = 0; i < 1024; i++) {
62 if (port_bitmap[i / 32] & (1 << (i % 32)))
63 continue;
64 port_bitmap[i / 32] |= 1 << (i % 32);
65 pid += i << 22;
66 break;
67 }
68
69 nl_socket_set_local_port(handle, pid);
70
71 return handle;
72 }
73
74 static void nl80211_handle_destroy(struct nl_handle *handle)
75 {
76 uint32_t port = nl_socket_get_local_port(handle);
77
78 port >>= 22;
79 port_bitmap[port / 32] &= ~(1 << (port % 32));
80
81 nl_handle_destroy(handle);
82 }
83 #endif /* CONFIG_LIBNL20 */
84
85
86 #ifdef ANDROID
87 /* system/core/libnl_2 does not include nl_socket_set_nonblocking() */
88 #undef nl_socket_set_nonblocking
89 #define nl_socket_set_nonblocking(h) android_nl_socket_set_nonblocking(h)
90
91 #endif /* ANDROID */
92
93
94 static struct nl_handle * nl_create_handle(struct nl_cb *cb, const char *dbg)
95 {
96 struct nl_handle *handle;
97
98 handle = nl80211_handle_alloc(cb);
99 if (handle == NULL) {
100 wpa_printf(MSG_ERROR, "nl80211: Failed to allocate netlink "
101 "callbacks (%s)", dbg);
102 return NULL;
103 }
104
105 if (genl_connect(handle)) {
106 wpa_printf(MSG_ERROR, "nl80211: Failed to connect to generic "
107 "netlink (%s)", dbg);
108 nl80211_handle_destroy(handle);
109 return NULL;
110 }
111
112 return handle;
113 }
114
115
116 static void nl_destroy_handles(struct nl_handle **handle)
117 {
118 if (*handle == NULL)
119 return;
120 nl80211_handle_destroy(*handle);
121 *handle = NULL;
122 }
123
124
125 #if __WORDSIZE == 64
126 #define ELOOP_SOCKET_INVALID (intptr_t) 0x8888888888888889ULL
127 #else
128 #define ELOOP_SOCKET_INVALID (intptr_t) 0x88888889ULL
129 #endif
130
131 static void nl80211_register_eloop_read(struct nl_handle **handle,
132 eloop_sock_handler handler,
133 void *eloop_data)
134 {
135 #ifdef CONFIG_LIBNL20
136 /*
137 * libnl uses a pretty small buffer (32 kB that gets converted to 64 kB)
138 * by default. It is possible to hit that limit in some cases where
139 * operations are blocked, e.g., with a burst of Deauthentication frames
140 * to hostapd and STA entry deletion. Try to increase the buffer to make
141 * this less likely to occur.
142 */
143 if (nl_socket_set_buffer_size(*handle, 262144, 0) < 0) {
144 wpa_printf(MSG_DEBUG,
145 "nl80211: Could not set nl_socket RX buffer size: %s",
146 strerror(errno));
147 /* continue anyway with the default (smaller) buffer */
148 }
149 #endif /* CONFIG_LIBNL20 */
150
151 nl_socket_set_nonblocking(*handle);
152 eloop_register_read_sock(nl_socket_get_fd(*handle), handler,
153 eloop_data, *handle);
154 *handle = (void *) (((intptr_t) *handle) ^ ELOOP_SOCKET_INVALID);
155 }
156
157
158 static void nl80211_destroy_eloop_handle(struct nl_handle **handle)
159 {
160 *handle = (void *) (((intptr_t) *handle) ^ ELOOP_SOCKET_INVALID);
161 eloop_unregister_read_sock(nl_socket_get_fd(*handle));
162 nl_destroy_handles(handle);
163 }
164
165
166 static void nl80211_global_deinit(void *priv);
167 static void nl80211_check_global(struct nl80211_global *global);
168
169 static void wpa_driver_nl80211_deinit(struct i802_bss *bss);
170 static int wpa_driver_nl80211_set_mode_ibss(struct i802_bss *bss,
171 struct hostapd_freq_params *freq);
172
173 static int
174 wpa_driver_nl80211_finish_drv_init(struct wpa_driver_nl80211_data *drv,
175 const u8 *set_addr, int first,
176 const char *driver_params);
177 static int nl80211_send_frame_cmd(struct i802_bss *bss,
178 unsigned int freq, unsigned int wait,
179 const u8 *buf, size_t buf_len, u64 *cookie,
180 int no_cck, int no_ack, int offchanok,
181 const u16 *csa_offs, size_t csa_offs_len);
182 static int wpa_driver_nl80211_probe_req_report(struct i802_bss *bss,
183 int report);
184
185 #define IFIDX_ANY -1
186
187 static void add_ifidx(struct wpa_driver_nl80211_data *drv, int ifidx,
188 int ifidx_reason);
189 static void del_ifidx(struct wpa_driver_nl80211_data *drv, int ifidx,
190 int ifidx_reason);
191 static int have_ifidx(struct wpa_driver_nl80211_data *drv, int ifidx,
192 int ifidx_reason);
193
194 static int nl80211_set_channel(struct i802_bss *bss,
195 struct hostapd_freq_params *freq, int set_chan);
196 static int nl80211_disable_11b_rates(struct wpa_driver_nl80211_data *drv,
197 int ifindex, int disabled);
198
199 static int nl80211_leave_ibss(struct wpa_driver_nl80211_data *drv,
200 int reset_mode);
201
202 static int i802_set_iface_flags(struct i802_bss *bss, int up);
203 static int nl80211_set_param(void *priv, const char *param);
204 #ifdef CONFIG_MESH
205 static int nl80211_put_mesh_config(struct nl_msg *msg,
206 struct wpa_driver_mesh_bss_params *params);
207 #endif /* CONFIG_MESH */
208 static int i802_sta_disassoc(void *priv, const u8 *own_addr, const u8 *addr,
209 int reason);
210
211
212 /* Converts nl80211_chan_width to a common format */
213 enum chan_width convert2width(int width)
214 {
215 switch (width) {
216 case NL80211_CHAN_WIDTH_20_NOHT:
217 return CHAN_WIDTH_20_NOHT;
218 case NL80211_CHAN_WIDTH_20:
219 return CHAN_WIDTH_20;
220 case NL80211_CHAN_WIDTH_40:
221 return CHAN_WIDTH_40;
222 case NL80211_CHAN_WIDTH_80:
223 return CHAN_WIDTH_80;
224 case NL80211_CHAN_WIDTH_80P80:
225 return CHAN_WIDTH_80P80;
226 case NL80211_CHAN_WIDTH_160:
227 return CHAN_WIDTH_160;
228 }
229 return CHAN_WIDTH_UNKNOWN;
230 }
231
232
233 int is_ap_interface(enum nl80211_iftype nlmode)
234 {
235 return nlmode == NL80211_IFTYPE_AP ||
236 nlmode == NL80211_IFTYPE_P2P_GO;
237 }
238
239
240 int is_sta_interface(enum nl80211_iftype nlmode)
241 {
242 return nlmode == NL80211_IFTYPE_STATION ||
243 nlmode == NL80211_IFTYPE_P2P_CLIENT;
244 }
245
246
247 static int is_p2p_net_interface(enum nl80211_iftype nlmode)
248 {
249 return nlmode == NL80211_IFTYPE_P2P_CLIENT ||
250 nlmode == NL80211_IFTYPE_P2P_GO;
251 }
252
253
254 struct i802_bss * get_bss_ifindex(struct wpa_driver_nl80211_data *drv,
255 int ifindex)
256 {
257 struct i802_bss *bss;
258
259 for (bss = drv->first_bss; bss; bss = bss->next) {
260 if (bss->ifindex == ifindex)
261 return bss;
262 }
263
264 return NULL;
265 }
266
267
268 static int is_mesh_interface(enum nl80211_iftype nlmode)
269 {
270 return nlmode == NL80211_IFTYPE_MESH_POINT;
271 }
272
273
274 void nl80211_mark_disconnected(struct wpa_driver_nl80211_data *drv)
275 {
276 if (drv->associated)
277 os_memcpy(drv->prev_bssid, drv->bssid, ETH_ALEN);
278 drv->associated = 0;
279 os_memset(drv->bssid, 0, ETH_ALEN);
280 }
281
282
283 /* nl80211 code */
284 static int ack_handler(struct nl_msg *msg, void *arg)
285 {
286 int *err = arg;
287 *err = 0;
288 return NL_STOP;
289 }
290
291 static int finish_handler(struct nl_msg *msg, void *arg)
292 {
293 int *ret = arg;
294 *ret = 0;
295 return NL_SKIP;
296 }
297
298 static int error_handler(struct sockaddr_nl *nla, struct nlmsgerr *err,
299 void *arg)
300 {
301 int *ret = arg;
302 *ret = err->error;
303 return NL_SKIP;
304 }
305
306
307 static int no_seq_check(struct nl_msg *msg, void *arg)
308 {
309 return NL_OK;
310 }
311
312
313 static void nl80211_nlmsg_clear(struct nl_msg *msg)
314 {
315 /*
316 * Clear nlmsg data, e.g., to make sure key material is not left in
317 * heap memory for unnecessarily long time.
318 */
319 if (msg) {
320 struct nlmsghdr *hdr = nlmsg_hdr(msg);
321 void *data = nlmsg_data(hdr);
322 /*
323 * This would use nlmsg_datalen() or the older nlmsg_len() if
324 * only libnl were to maintain a stable API.. Neither will work
325 * with all released versions, so just calculate the length
326 * here.
327 */
328 int len = hdr->nlmsg_len - NLMSG_HDRLEN;
329
330 os_memset(data, 0, len);
331 }
332 }
333
334
335 static int send_and_recv(struct nl80211_global *global,
336 struct nl_handle *nl_handle, struct nl_msg *msg,
337 int (*valid_handler)(struct nl_msg *, void *),
338 void *valid_data)
339 {
340 struct nl_cb *cb;
341 int err = -ENOMEM;
342
343 if (!msg)
344 return -ENOMEM;
345
346 cb = nl_cb_clone(global->nl_cb);
347 if (!cb)
348 goto out;
349
350 err = nl_send_auto_complete(nl_handle, msg);
351 if (err < 0)
352 goto out;
353
354 err = 1;
355
356 nl_cb_err(cb, NL_CB_CUSTOM, error_handler, &err);
357 nl_cb_set(cb, NL_CB_FINISH, NL_CB_CUSTOM, finish_handler, &err);
358 nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, ack_handler, &err);
359
360 if (valid_handler)
361 nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM,
362 valid_handler, valid_data);
363
364 while (err > 0) {
365 int res = nl_recvmsgs(nl_handle, cb);
366 if (res < 0) {
367 wpa_printf(MSG_INFO,
368 "nl80211: %s->nl_recvmsgs failed: %d",
369 __func__, res);
370 }
371 }
372 out:
373 nl_cb_put(cb);
374 if (!valid_handler && valid_data == (void *) -1)
375 nl80211_nlmsg_clear(msg);
376 nlmsg_free(msg);
377 return err;
378 }
379
380
381 int send_and_recv_msgs(struct wpa_driver_nl80211_data *drv,
382 struct nl_msg *msg,
383 int (*valid_handler)(struct nl_msg *, void *),
384 void *valid_data)
385 {
386 return send_and_recv(drv->global, drv->global->nl, msg,
387 valid_handler, valid_data);
388 }
389
390
391 struct family_data {
392 const char *group;
393 int id;
394 };
395
396
397 static int family_handler(struct nl_msg *msg, void *arg)
398 {
399 struct family_data *res = arg;
400 struct nlattr *tb[CTRL_ATTR_MAX + 1];
401 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
402 struct nlattr *mcgrp;
403 int i;
404
405 nla_parse(tb, CTRL_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
406 genlmsg_attrlen(gnlh, 0), NULL);
407 if (!tb[CTRL_ATTR_MCAST_GROUPS])
408 return NL_SKIP;
409
410 nla_for_each_nested(mcgrp, tb[CTRL_ATTR_MCAST_GROUPS], i) {
411 struct nlattr *tb2[CTRL_ATTR_MCAST_GRP_MAX + 1];
412 nla_parse(tb2, CTRL_ATTR_MCAST_GRP_MAX, nla_data(mcgrp),
413 nla_len(mcgrp), NULL);
414 if (!tb2[CTRL_ATTR_MCAST_GRP_NAME] ||
415 !tb2[CTRL_ATTR_MCAST_GRP_ID] ||
416 os_strncmp(nla_data(tb2[CTRL_ATTR_MCAST_GRP_NAME]),
417 res->group,
418 nla_len(tb2[CTRL_ATTR_MCAST_GRP_NAME])) != 0)
419 continue;
420 res->id = nla_get_u32(tb2[CTRL_ATTR_MCAST_GRP_ID]);
421 break;
422 };
423
424 return NL_SKIP;
425 }
426
427
428 static int nl_get_multicast_id(struct nl80211_global *global,
429 const char *family, const char *group)
430 {
431 struct nl_msg *msg;
432 int ret;
433 struct family_data res = { group, -ENOENT };
434
435 msg = nlmsg_alloc();
436 if (!msg)
437 return -ENOMEM;
438 if (!genlmsg_put(msg, 0, 0, genl_ctrl_resolve(global->nl, "nlctrl"),
439 0, 0, CTRL_CMD_GETFAMILY, 0) ||
440 nla_put_string(msg, CTRL_ATTR_FAMILY_NAME, family)) {
441 nlmsg_free(msg);
442 return -1;
443 }
444
445 ret = send_and_recv(global, global->nl, msg, family_handler, &res);
446 if (ret == 0)
447 ret = res.id;
448 return ret;
449 }
450
451
452 void * nl80211_cmd(struct wpa_driver_nl80211_data *drv,
453 struct nl_msg *msg, int flags, uint8_t cmd)
454 {
455 if (TEST_FAIL())
456 return NULL;
457 return genlmsg_put(msg, 0, 0, drv->global->nl80211_id,
458 0, flags, cmd, 0);
459 }
460
461
462 static int nl80211_set_iface_id(struct nl_msg *msg, struct i802_bss *bss)
463 {
464 if (bss->wdev_id_set)
465 return nla_put_u64(msg, NL80211_ATTR_WDEV, bss->wdev_id);
466 return nla_put_u32(msg, NL80211_ATTR_IFINDEX, bss->ifindex);
467 }
468
469
470 struct nl_msg * nl80211_cmd_msg(struct i802_bss *bss, int flags, uint8_t cmd)
471 {
472 struct nl_msg *msg;
473
474 msg = nlmsg_alloc();
475 if (!msg)
476 return NULL;
477
478 if (!nl80211_cmd(bss->drv, msg, flags, cmd) ||
479 nl80211_set_iface_id(msg, bss) < 0) {
480 nlmsg_free(msg);
481 return NULL;
482 }
483
484 return msg;
485 }
486
487
488 static struct nl_msg *
489 nl80211_ifindex_msg(struct wpa_driver_nl80211_data *drv, int ifindex,
490 int flags, uint8_t cmd)
491 {
492 struct nl_msg *msg;
493
494 msg = nlmsg_alloc();
495 if (!msg)
496 return NULL;
497
498 if (!nl80211_cmd(drv, msg, flags, cmd) ||
499 nla_put_u32(msg, NL80211_ATTR_IFINDEX, ifindex)) {
500 nlmsg_free(msg);
501 return NULL;
502 }
503
504 return msg;
505 }
506
507
508 struct nl_msg * nl80211_drv_msg(struct wpa_driver_nl80211_data *drv, int flags,
509 uint8_t cmd)
510 {
511 return nl80211_ifindex_msg(drv, drv->ifindex, flags, cmd);
512 }
513
514
515 struct nl_msg * nl80211_bss_msg(struct i802_bss *bss, int flags, uint8_t cmd)
516 {
517 return nl80211_ifindex_msg(bss->drv, bss->ifindex, flags, cmd);
518 }
519
520
521 struct wiphy_idx_data {
522 int wiphy_idx;
523 enum nl80211_iftype nlmode;
524 u8 *macaddr;
525 };
526
527
528 static int netdev_info_handler(struct nl_msg *msg, void *arg)
529 {
530 struct nlattr *tb[NL80211_ATTR_MAX + 1];
531 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
532 struct wiphy_idx_data *info = arg;
533
534 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
535 genlmsg_attrlen(gnlh, 0), NULL);
536
537 if (tb[NL80211_ATTR_WIPHY])
538 info->wiphy_idx = nla_get_u32(tb[NL80211_ATTR_WIPHY]);
539
540 if (tb[NL80211_ATTR_IFTYPE])
541 info->nlmode = nla_get_u32(tb[NL80211_ATTR_IFTYPE]);
542
543 if (tb[NL80211_ATTR_MAC] && info->macaddr)
544 os_memcpy(info->macaddr, nla_data(tb[NL80211_ATTR_MAC]),
545 ETH_ALEN);
546
547 return NL_SKIP;
548 }
549
550
551 int nl80211_get_wiphy_index(struct i802_bss *bss)
552 {
553 struct nl_msg *msg;
554 struct wiphy_idx_data data = {
555 .wiphy_idx = -1,
556 .macaddr = NULL,
557 };
558
559 if (!(msg = nl80211_cmd_msg(bss, 0, NL80211_CMD_GET_INTERFACE)))
560 return -1;
561
562 if (send_and_recv_msgs(bss->drv, msg, netdev_info_handler, &data) == 0)
563 return data.wiphy_idx;
564 return -1;
565 }
566
567
568 static enum nl80211_iftype nl80211_get_ifmode(struct i802_bss *bss)
569 {
570 struct nl_msg *msg;
571 struct wiphy_idx_data data = {
572 .nlmode = NL80211_IFTYPE_UNSPECIFIED,
573 .macaddr = NULL,
574 };
575
576 if (!(msg = nl80211_cmd_msg(bss, 0, NL80211_CMD_GET_INTERFACE)))
577 return NL80211_IFTYPE_UNSPECIFIED;
578
579 if (send_and_recv_msgs(bss->drv, msg, netdev_info_handler, &data) == 0)
580 return data.nlmode;
581 return NL80211_IFTYPE_UNSPECIFIED;
582 }
583
584
585 static int nl80211_get_macaddr(struct i802_bss *bss)
586 {
587 struct nl_msg *msg;
588 struct wiphy_idx_data data = {
589 .macaddr = bss->addr,
590 };
591
592 if (!(msg = nl80211_cmd_msg(bss, 0, NL80211_CMD_GET_INTERFACE)))
593 return -1;
594
595 return send_and_recv_msgs(bss->drv, msg, netdev_info_handler, &data);
596 }
597
598
599 static int nl80211_register_beacons(struct wpa_driver_nl80211_data *drv,
600 struct nl80211_wiphy_data *w)
601 {
602 struct nl_msg *msg;
603 int ret;
604
605 msg = nlmsg_alloc();
606 if (!msg)
607 return -1;
608
609 if (!nl80211_cmd(drv, msg, 0, NL80211_CMD_REGISTER_BEACONS) ||
610 nla_put_u32(msg, NL80211_ATTR_WIPHY, w->wiphy_idx)) {
611 nlmsg_free(msg);
612 return -1;
613 }
614
615 ret = send_and_recv(drv->global, w->nl_beacons, msg, NULL, NULL);
616 if (ret) {
617 wpa_printf(MSG_DEBUG, "nl80211: Register beacons command "
618 "failed: ret=%d (%s)",
619 ret, strerror(-ret));
620 }
621 return ret;
622 }
623
624
625 static void nl80211_recv_beacons(int sock, void *eloop_ctx, void *handle)
626 {
627 struct nl80211_wiphy_data *w = eloop_ctx;
628 int res;
629
630 wpa_printf(MSG_EXCESSIVE, "nl80211: Beacon event message available");
631
632 res = nl_recvmsgs(handle, w->nl_cb);
633 if (res < 0) {
634 wpa_printf(MSG_INFO, "nl80211: %s->nl_recvmsgs failed: %d",
635 __func__, res);
636 }
637 }
638
639
640 static int process_beacon_event(struct nl_msg *msg, void *arg)
641 {
642 struct nl80211_wiphy_data *w = arg;
643 struct wpa_driver_nl80211_data *drv;
644 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
645 struct nlattr *tb[NL80211_ATTR_MAX + 1];
646 union wpa_event_data event;
647
648 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
649 genlmsg_attrlen(gnlh, 0), NULL);
650
651 if (gnlh->cmd != NL80211_CMD_FRAME) {
652 wpa_printf(MSG_DEBUG, "nl80211: Unexpected beacon event? (%d)",
653 gnlh->cmd);
654 return NL_SKIP;
655 }
656
657 if (!tb[NL80211_ATTR_FRAME])
658 return NL_SKIP;
659
660 dl_list_for_each(drv, &w->drvs, struct wpa_driver_nl80211_data,
661 wiphy_list) {
662 os_memset(&event, 0, sizeof(event));
663 event.rx_mgmt.frame = nla_data(tb[NL80211_ATTR_FRAME]);
664 event.rx_mgmt.frame_len = nla_len(tb[NL80211_ATTR_FRAME]);
665 wpa_supplicant_event(drv->ctx, EVENT_RX_MGMT, &event);
666 }
667
668 return NL_SKIP;
669 }
670
671
672 static struct nl80211_wiphy_data *
673 nl80211_get_wiphy_data_ap(struct i802_bss *bss)
674 {
675 static DEFINE_DL_LIST(nl80211_wiphys);
676 struct nl80211_wiphy_data *w;
677 int wiphy_idx, found = 0;
678 struct i802_bss *tmp_bss;
679 u8 channel;
680
681 if (bss->wiphy_data != NULL)
682 return bss->wiphy_data;
683
684 wiphy_idx = nl80211_get_wiphy_index(bss);
685
686 dl_list_for_each(w, &nl80211_wiphys, struct nl80211_wiphy_data, list) {
687 if (w->wiphy_idx == wiphy_idx)
688 goto add;
689 }
690
691 /* alloc new one */
692 w = os_zalloc(sizeof(*w));
693 if (w == NULL)
694 return NULL;
695 w->wiphy_idx = wiphy_idx;
696 dl_list_init(&w->bsss);
697 dl_list_init(&w->drvs);
698
699 /* Beacon frames not supported in IEEE 802.11ad */
700 if (ieee80211_freq_to_chan(bss->freq, &channel) !=
701 HOSTAPD_MODE_IEEE80211AD) {
702 w->nl_cb = nl_cb_alloc(NL_CB_DEFAULT);
703 if (!w->nl_cb) {
704 os_free(w);
705 return NULL;
706 }
707 nl_cb_set(w->nl_cb, NL_CB_SEQ_CHECK, NL_CB_CUSTOM,
708 no_seq_check, NULL);
709 nl_cb_set(w->nl_cb, NL_CB_VALID, NL_CB_CUSTOM,
710 process_beacon_event, w);
711
712 w->nl_beacons = nl_create_handle(bss->drv->global->nl_cb,
713 "wiphy beacons");
714 if (w->nl_beacons == NULL) {
715 os_free(w);
716 return NULL;
717 }
718
719 if (nl80211_register_beacons(bss->drv, w)) {
720 nl_destroy_handles(&w->nl_beacons);
721 os_free(w);
722 return NULL;
723 }
724
725 nl80211_register_eloop_read(&w->nl_beacons,
726 nl80211_recv_beacons, w);
727 }
728
729 dl_list_add(&nl80211_wiphys, &w->list);
730
731 add:
732 /* drv entry for this bss already there? */
733 dl_list_for_each(tmp_bss, &w->bsss, struct i802_bss, wiphy_list) {
734 if (tmp_bss->drv == bss->drv) {
735 found = 1;
736 break;
737 }
738 }
739 /* if not add it */
740 if (!found)
741 dl_list_add(&w->drvs, &bss->drv->wiphy_list);
742
743 dl_list_add(&w->bsss, &bss->wiphy_list);
744 bss->wiphy_data = w;
745 return w;
746 }
747
748
749 static void nl80211_put_wiphy_data_ap(struct i802_bss *bss)
750 {
751 struct nl80211_wiphy_data *w = bss->wiphy_data;
752 struct i802_bss *tmp_bss;
753 int found = 0;
754
755 if (w == NULL)
756 return;
757 bss->wiphy_data = NULL;
758 dl_list_del(&bss->wiphy_list);
759
760 /* still any for this drv present? */
761 dl_list_for_each(tmp_bss, &w->bsss, struct i802_bss, wiphy_list) {
762 if (tmp_bss->drv == bss->drv) {
763 found = 1;
764 break;
765 }
766 }
767 /* if not remove it */
768 if (!found)
769 dl_list_del(&bss->drv->wiphy_list);
770
771 if (!dl_list_empty(&w->bsss))
772 return;
773
774 if (w->nl_beacons)
775 nl80211_destroy_eloop_handle(&w->nl_beacons);
776
777 nl_cb_put(w->nl_cb);
778 dl_list_del(&w->list);
779 os_free(w);
780 }
781
782
783 static unsigned int nl80211_get_ifindex(void *priv)
784 {
785 struct i802_bss *bss = priv;
786 struct wpa_driver_nl80211_data *drv = bss->drv;
787
788 return drv->ifindex;
789 }
790
791
792 static int wpa_driver_nl80211_get_bssid(void *priv, u8 *bssid)
793 {
794 struct i802_bss *bss = priv;
795 struct wpa_driver_nl80211_data *drv = bss->drv;
796 if (!drv->associated)
797 return -1;
798 os_memcpy(bssid, drv->bssid, ETH_ALEN);
799 return 0;
800 }
801
802
803 static int wpa_driver_nl80211_get_ssid(void *priv, u8 *ssid)
804 {
805 struct i802_bss *bss = priv;
806 struct wpa_driver_nl80211_data *drv = bss->drv;
807 if (!drv->associated)
808 return -1;
809 os_memcpy(ssid, drv->ssid, drv->ssid_len);
810 return drv->ssid_len;
811 }
812
813
814 static void wpa_driver_nl80211_event_newlink(
815 struct nl80211_global *global, struct wpa_driver_nl80211_data *drv,
816 int ifindex, const char *ifname)
817 {
818 union wpa_event_data event;
819
820 if (drv && os_strcmp(drv->first_bss->ifname, ifname) == 0) {
821 if (if_nametoindex(drv->first_bss->ifname) == 0) {
822 wpa_printf(MSG_DEBUG, "nl80211: Interface %s does not exist - ignore RTM_NEWLINK",
823 drv->first_bss->ifname);
824 return;
825 }
826 if (!drv->if_removed)
827 return;
828 wpa_printf(MSG_DEBUG, "nl80211: Mark if_removed=0 for %s based on RTM_NEWLINK event",
829 drv->first_bss->ifname);
830 drv->if_removed = 0;
831 }
832
833 os_memset(&event, 0, sizeof(event));
834 event.interface_status.ifindex = ifindex;
835 os_strlcpy(event.interface_status.ifname, ifname,
836 sizeof(event.interface_status.ifname));
837 event.interface_status.ievent = EVENT_INTERFACE_ADDED;
838 if (drv)
839 wpa_supplicant_event(drv->ctx, EVENT_INTERFACE_STATUS, &event);
840 else
841 wpa_supplicant_event_global(global->ctx, EVENT_INTERFACE_STATUS,
842 &event);
843 }
844
845
846 static void wpa_driver_nl80211_event_dellink(
847 struct nl80211_global *global, struct wpa_driver_nl80211_data *drv,
848 int ifindex, const char *ifname)
849 {
850 union wpa_event_data event;
851
852 if (drv && os_strcmp(drv->first_bss->ifname, ifname) == 0) {
853 if (drv->if_removed) {
854 wpa_printf(MSG_DEBUG, "nl80211: if_removed already set - ignore RTM_DELLINK event for %s",
855 ifname);
856 return;
857 }
858 wpa_printf(MSG_DEBUG, "RTM_DELLINK: Interface '%s' removed - mark if_removed=1",
859 ifname);
860 drv->if_removed = 1;
861 } else {
862 wpa_printf(MSG_DEBUG, "RTM_DELLINK: Interface '%s' removed",
863 ifname);
864 }
865
866 os_memset(&event, 0, sizeof(event));
867 event.interface_status.ifindex = ifindex;
868 os_strlcpy(event.interface_status.ifname, ifname,
869 sizeof(event.interface_status.ifname));
870 event.interface_status.ievent = EVENT_INTERFACE_REMOVED;
871 if (drv)
872 wpa_supplicant_event(drv->ctx, EVENT_INTERFACE_STATUS, &event);
873 else
874 wpa_supplicant_event_global(global->ctx, EVENT_INTERFACE_STATUS,
875 &event);
876 }
877
878
879 static int wpa_driver_nl80211_own_ifname(struct wpa_driver_nl80211_data *drv,
880 u8 *buf, size_t len)
881 {
882 int attrlen, rta_len;
883 struct rtattr *attr;
884
885 attrlen = len;
886 attr = (struct rtattr *) buf;
887
888 rta_len = RTA_ALIGN(sizeof(struct rtattr));
889 while (RTA_OK(attr, attrlen)) {
890 if (attr->rta_type == IFLA_IFNAME) {
891 if (os_strcmp(((char *) attr) + rta_len,
892 drv->first_bss->ifname) == 0)
893 return 1;
894 else
895 break;
896 }
897 attr = RTA_NEXT(attr, attrlen);
898 }
899
900 return 0;
901 }
902
903
904 static int wpa_driver_nl80211_own_ifindex(struct wpa_driver_nl80211_data *drv,
905 int ifindex, u8 *buf, size_t len)
906 {
907 if (drv->ifindex == ifindex)
908 return 1;
909
910 if (drv->if_removed && wpa_driver_nl80211_own_ifname(drv, buf, len)) {
911 nl80211_check_global(drv->global);
912 wpa_printf(MSG_DEBUG, "nl80211: Update ifindex for a removed "
913 "interface");
914 wpa_driver_nl80211_finish_drv_init(drv, NULL, 0, NULL);
915 return 1;
916 }
917
918 return 0;
919 }
920
921
922 static struct wpa_driver_nl80211_data *
923 nl80211_find_drv(struct nl80211_global *global, int idx, u8 *buf, size_t len)
924 {
925 struct wpa_driver_nl80211_data *drv;
926 dl_list_for_each(drv, &global->interfaces,
927 struct wpa_driver_nl80211_data, list) {
928 if (wpa_driver_nl80211_own_ifindex(drv, idx, buf, len) ||
929 have_ifidx(drv, idx, IFIDX_ANY))
930 return drv;
931 }
932 return NULL;
933 }
934
935
936 static void wpa_driver_nl80211_event_rtm_newlink(void *ctx,
937 struct ifinfomsg *ifi,
938 u8 *buf, size_t len)
939 {
940 struct nl80211_global *global = ctx;
941 struct wpa_driver_nl80211_data *drv;
942 int attrlen;
943 struct rtattr *attr;
944 u32 brid = 0;
945 char namebuf[IFNAMSIZ];
946 char ifname[IFNAMSIZ + 1];
947 char extra[100], *pos, *end;
948
949 extra[0] = '\0';
950 pos = extra;
951 end = pos + sizeof(extra);
952 ifname[0] = '\0';
953
954 attrlen = len;
955 attr = (struct rtattr *) buf;
956 while (RTA_OK(attr, attrlen)) {
957 switch (attr->rta_type) {
958 case IFLA_IFNAME:
959 if (RTA_PAYLOAD(attr) >= IFNAMSIZ)
960 break;
961 os_memcpy(ifname, RTA_DATA(attr), RTA_PAYLOAD(attr));
962 ifname[RTA_PAYLOAD(attr)] = '\0';
963 break;
964 case IFLA_MASTER:
965 brid = nla_get_u32((struct nlattr *) attr);
966 pos += os_snprintf(pos, end - pos, " master=%u", brid);
967 break;
968 case IFLA_WIRELESS:
969 pos += os_snprintf(pos, end - pos, " wext");
970 break;
971 case IFLA_OPERSTATE:
972 pos += os_snprintf(pos, end - pos, " operstate=%u",
973 nla_get_u32((struct nlattr *) attr));
974 break;
975 case IFLA_LINKMODE:
976 pos += os_snprintf(pos, end - pos, " linkmode=%u",
977 nla_get_u32((struct nlattr *) attr));
978 break;
979 }
980 attr = RTA_NEXT(attr, attrlen);
981 }
982 extra[sizeof(extra) - 1] = '\0';
983
984 wpa_printf(MSG_DEBUG, "RTM_NEWLINK: ifi_index=%d ifname=%s%s ifi_family=%d ifi_flags=0x%x (%s%s%s%s)",
985 ifi->ifi_index, ifname, extra, ifi->ifi_family,
986 ifi->ifi_flags,
987 (ifi->ifi_flags & IFF_UP) ? "[UP]" : "",
988 (ifi->ifi_flags & IFF_RUNNING) ? "[RUNNING]" : "",
989 (ifi->ifi_flags & IFF_LOWER_UP) ? "[LOWER_UP]" : "",
990 (ifi->ifi_flags & IFF_DORMANT) ? "[DORMANT]" : "");
991
992 drv = nl80211_find_drv(global, ifi->ifi_index, buf, len);
993 if (!drv)
994 goto event_newlink;
995
996 if (!drv->if_disabled && !(ifi->ifi_flags & IFF_UP)) {
997 namebuf[0] = '\0';
998 if (if_indextoname(ifi->ifi_index, namebuf) &&
999 linux_iface_up(drv->global->ioctl_sock, namebuf) > 0) {
1000 wpa_printf(MSG_DEBUG, "nl80211: Ignore interface down "
1001 "event since interface %s is up", namebuf);
1002 drv->ignore_if_down_event = 0;
1003 return;
1004 }
1005 wpa_printf(MSG_DEBUG, "nl80211: Interface down (%s/%s)",
1006 namebuf, ifname);
1007 if (os_strcmp(drv->first_bss->ifname, ifname) != 0) {
1008 wpa_printf(MSG_DEBUG,
1009 "nl80211: Not the main interface (%s) - do not indicate interface down",
1010 drv->first_bss->ifname);
1011 } else if (drv->ignore_if_down_event) {
1012 wpa_printf(MSG_DEBUG, "nl80211: Ignore interface down "
1013 "event generated by mode change");
1014 drv->ignore_if_down_event = 0;
1015 } else {
1016 drv->if_disabled = 1;
1017 wpa_supplicant_event(drv->ctx,
1018 EVENT_INTERFACE_DISABLED, NULL);
1019
1020 /*
1021 * Try to get drv again, since it may be removed as
1022 * part of the EVENT_INTERFACE_DISABLED handling for
1023 * dynamic interfaces
1024 */
1025 drv = nl80211_find_drv(global, ifi->ifi_index,
1026 buf, len);
1027 if (!drv)
1028 return;
1029 }
1030 }
1031
1032 if (drv->if_disabled && (ifi->ifi_flags & IFF_UP)) {
1033 if (if_indextoname(ifi->ifi_index, namebuf) &&
1034 linux_iface_up(drv->global->ioctl_sock, namebuf) == 0) {
1035 wpa_printf(MSG_DEBUG, "nl80211: Ignore interface up "
1036 "event since interface %s is down",
1037 namebuf);
1038 } else if (if_nametoindex(drv->first_bss->ifname) == 0) {
1039 wpa_printf(MSG_DEBUG, "nl80211: Ignore interface up "
1040 "event since interface %s does not exist",
1041 drv->first_bss->ifname);
1042 } else if (drv->if_removed) {
1043 wpa_printf(MSG_DEBUG, "nl80211: Ignore interface up "
1044 "event since interface %s is marked "
1045 "removed", drv->first_bss->ifname);
1046 } else {
1047 struct i802_bss *bss;
1048 u8 addr[ETH_ALEN];
1049
1050 /* Re-read MAC address as it may have changed */
1051 bss = get_bss_ifindex(drv, ifi->ifi_index);
1052 if (bss &&
1053 linux_get_ifhwaddr(drv->global->ioctl_sock,
1054 bss->ifname, addr) < 0) {
1055 wpa_printf(MSG_DEBUG,
1056 "nl80211: %s: failed to re-read MAC address",
1057 bss->ifname);
1058 } else if (bss &&
1059 os_memcmp(addr, bss->addr, ETH_ALEN) != 0) {
1060 wpa_printf(MSG_DEBUG,
1061 "nl80211: Own MAC address on ifindex %d (%s) changed from "
1062 MACSTR " to " MACSTR,
1063 ifi->ifi_index, bss->ifname,
1064 MAC2STR(bss->addr),
1065 MAC2STR(addr));
1066 os_memcpy(bss->addr, addr, ETH_ALEN);
1067 }
1068
1069 wpa_printf(MSG_DEBUG, "nl80211: Interface up");
1070 drv->if_disabled = 0;
1071 wpa_supplicant_event(drv->ctx, EVENT_INTERFACE_ENABLED,
1072 NULL);
1073 }
1074 }
1075
1076 /*
1077 * Some drivers send the association event before the operup event--in
1078 * this case, lifting operstate in wpa_driver_nl80211_set_operstate()
1079 * fails. This will hit us when wpa_supplicant does not need to do
1080 * IEEE 802.1X authentication
1081 */
1082 if (drv->operstate == 1 &&
1083 (ifi->ifi_flags & (IFF_LOWER_UP | IFF_DORMANT)) == IFF_LOWER_UP &&
1084 !(ifi->ifi_flags & IFF_RUNNING)) {
1085 wpa_printf(MSG_DEBUG, "nl80211: Set IF_OPER_UP again based on ifi_flags and expected operstate");
1086 netlink_send_oper_ifla(drv->global->netlink, drv->ifindex,
1087 -1, IF_OPER_UP);
1088 }
1089
1090 event_newlink:
1091 if (ifname[0])
1092 wpa_driver_nl80211_event_newlink(global, drv, ifi->ifi_index,
1093 ifname);
1094
1095 if (ifi->ifi_family == AF_BRIDGE && brid && drv) {
1096 struct i802_bss *bss;
1097
1098 /* device has been added to bridge */
1099 if (!if_indextoname(brid, namebuf)) {
1100 wpa_printf(MSG_DEBUG,
1101 "nl80211: Could not find bridge ifname for ifindex %u",
1102 brid);
1103 return;
1104 }
1105 wpa_printf(MSG_DEBUG, "nl80211: Add ifindex %u for bridge %s",
1106 brid, namebuf);
1107 add_ifidx(drv, brid, ifi->ifi_index);
1108
1109 for (bss = drv->first_bss; bss; bss = bss->next) {
1110 if (os_strcmp(ifname, bss->ifname) == 0) {
1111 os_strlcpy(bss->brname, namebuf, IFNAMSIZ);
1112 break;
1113 }
1114 }
1115 }
1116 }
1117
1118
1119 static void wpa_driver_nl80211_event_rtm_dellink(void *ctx,
1120 struct ifinfomsg *ifi,
1121 u8 *buf, size_t len)
1122 {
1123 struct nl80211_global *global = ctx;
1124 struct wpa_driver_nl80211_data *drv;
1125 int attrlen;
1126 struct rtattr *attr;
1127 u32 brid = 0;
1128 char ifname[IFNAMSIZ + 1];
1129 char extra[100], *pos, *end;
1130
1131 extra[0] = '\0';
1132 pos = extra;
1133 end = pos + sizeof(extra);
1134 ifname[0] = '\0';
1135
1136 attrlen = len;
1137 attr = (struct rtattr *) buf;
1138 while (RTA_OK(attr, attrlen)) {
1139 switch (attr->rta_type) {
1140 case IFLA_IFNAME:
1141 if (RTA_PAYLOAD(attr) >= IFNAMSIZ)
1142 break;
1143 os_memcpy(ifname, RTA_DATA(attr), RTA_PAYLOAD(attr));
1144 ifname[RTA_PAYLOAD(attr)] = '\0';
1145 break;
1146 case IFLA_MASTER:
1147 brid = nla_get_u32((struct nlattr *) attr);
1148 pos += os_snprintf(pos, end - pos, " master=%u", brid);
1149 break;
1150 case IFLA_OPERSTATE:
1151 pos += os_snprintf(pos, end - pos, " operstate=%u",
1152 nla_get_u32((struct nlattr *) attr));
1153 break;
1154 case IFLA_LINKMODE:
1155 pos += os_snprintf(pos, end - pos, " linkmode=%u",
1156 nla_get_u32((struct nlattr *) attr));
1157 break;
1158 }
1159 attr = RTA_NEXT(attr, attrlen);
1160 }
1161 extra[sizeof(extra) - 1] = '\0';
1162
1163 wpa_printf(MSG_DEBUG, "RTM_DELLINK: ifi_index=%d ifname=%s%s ifi_family=%d ifi_flags=0x%x (%s%s%s%s)",
1164 ifi->ifi_index, ifname, extra, ifi->ifi_family,
1165 ifi->ifi_flags,
1166 (ifi->ifi_flags & IFF_UP) ? "[UP]" : "",
1167 (ifi->ifi_flags & IFF_RUNNING) ? "[RUNNING]" : "",
1168 (ifi->ifi_flags & IFF_LOWER_UP) ? "[LOWER_UP]" : "",
1169 (ifi->ifi_flags & IFF_DORMANT) ? "[DORMANT]" : "");
1170
1171 drv = nl80211_find_drv(global, ifi->ifi_index, buf, len);
1172
1173 if (ifi->ifi_family == AF_BRIDGE && brid && drv) {
1174 /* device has been removed from bridge */
1175 char namebuf[IFNAMSIZ];
1176
1177 if (!if_indextoname(brid, namebuf)) {
1178 wpa_printf(MSG_DEBUG,
1179 "nl80211: Could not find bridge ifname for ifindex %u",
1180 brid);
1181 } else {
1182 wpa_printf(MSG_DEBUG,
1183 "nl80211: Remove ifindex %u for bridge %s",
1184 brid, namebuf);
1185 }
1186 del_ifidx(drv, brid, ifi->ifi_index);
1187 }
1188
1189 if (ifi->ifi_family != AF_BRIDGE || !brid)
1190 wpa_driver_nl80211_event_dellink(global, drv, ifi->ifi_index,
1191 ifname);
1192 }
1193
1194
1195 struct nl80211_get_assoc_freq_arg {
1196 struct wpa_driver_nl80211_data *drv;
1197 unsigned int assoc_freq;
1198 unsigned int ibss_freq;
1199 u8 assoc_bssid[ETH_ALEN];
1200 u8 assoc_ssid[SSID_MAX_LEN];
1201 u8 assoc_ssid_len;
1202 };
1203
1204 static int nl80211_get_assoc_freq_handler(struct nl_msg *msg, void *arg)
1205 {
1206 struct nlattr *tb[NL80211_ATTR_MAX + 1];
1207 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
1208 struct nlattr *bss[NL80211_BSS_MAX + 1];
1209 static struct nla_policy bss_policy[NL80211_BSS_MAX + 1] = {
1210 [NL80211_BSS_BSSID] = { .type = NLA_UNSPEC },
1211 [NL80211_BSS_FREQUENCY] = { .type = NLA_U32 },
1212 [NL80211_BSS_INFORMATION_ELEMENTS] = { .type = NLA_UNSPEC },
1213 [NL80211_BSS_STATUS] = { .type = NLA_U32 },
1214 };
1215 struct nl80211_get_assoc_freq_arg *ctx = arg;
1216 enum nl80211_bss_status status;
1217
1218 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
1219 genlmsg_attrlen(gnlh, 0), NULL);
1220 if (!tb[NL80211_ATTR_BSS] ||
1221 nla_parse_nested(bss, NL80211_BSS_MAX, tb[NL80211_ATTR_BSS],
1222 bss_policy) ||
1223 !bss[NL80211_BSS_STATUS])
1224 return NL_SKIP;
1225
1226 status = nla_get_u32(bss[NL80211_BSS_STATUS]);
1227 if (status == NL80211_BSS_STATUS_ASSOCIATED &&
1228 bss[NL80211_BSS_FREQUENCY]) {
1229 ctx->assoc_freq = nla_get_u32(bss[NL80211_BSS_FREQUENCY]);
1230 wpa_printf(MSG_DEBUG, "nl80211: Associated on %u MHz",
1231 ctx->assoc_freq);
1232 }
1233 if (status == NL80211_BSS_STATUS_IBSS_JOINED &&
1234 bss[NL80211_BSS_FREQUENCY]) {
1235 ctx->ibss_freq = nla_get_u32(bss[NL80211_BSS_FREQUENCY]);
1236 wpa_printf(MSG_DEBUG, "nl80211: IBSS-joined on %u MHz",
1237 ctx->ibss_freq);
1238 }
1239 if (status == NL80211_BSS_STATUS_ASSOCIATED &&
1240 bss[NL80211_BSS_BSSID]) {
1241 os_memcpy(ctx->assoc_bssid,
1242 nla_data(bss[NL80211_BSS_BSSID]), ETH_ALEN);
1243 wpa_printf(MSG_DEBUG, "nl80211: Associated with "
1244 MACSTR, MAC2STR(ctx->assoc_bssid));
1245 }
1246
1247 if (status == NL80211_BSS_STATUS_ASSOCIATED &&
1248 bss[NL80211_BSS_INFORMATION_ELEMENTS]) {
1249 const u8 *ie, *ssid;
1250 size_t ie_len;
1251
1252 ie = nla_data(bss[NL80211_BSS_INFORMATION_ELEMENTS]);
1253 ie_len = nla_len(bss[NL80211_BSS_INFORMATION_ELEMENTS]);
1254 ssid = get_ie(ie, ie_len, WLAN_EID_SSID);
1255 if (ssid && ssid[1] > 0 && ssid[1] <= SSID_MAX_LEN) {
1256 ctx->assoc_ssid_len = ssid[1];
1257 os_memcpy(ctx->assoc_ssid, ssid + 2, ssid[1]);
1258 }
1259 }
1260
1261 return NL_SKIP;
1262 }
1263
1264
1265 int nl80211_get_assoc_ssid(struct wpa_driver_nl80211_data *drv, u8 *ssid)
1266 {
1267 struct nl_msg *msg;
1268 int ret;
1269 struct nl80211_get_assoc_freq_arg arg;
1270
1271 msg = nl80211_drv_msg(drv, NLM_F_DUMP, NL80211_CMD_GET_SCAN);
1272 os_memset(&arg, 0, sizeof(arg));
1273 arg.drv = drv;
1274 ret = send_and_recv_msgs(drv, msg, nl80211_get_assoc_freq_handler,
1275 &arg);
1276 if (ret == 0) {
1277 os_memcpy(ssid, arg.assoc_ssid, arg.assoc_ssid_len);
1278 return arg.assoc_ssid_len;
1279 }
1280 wpa_printf(MSG_DEBUG, "nl80211: Scan result fetch failed: ret=%d (%s)",
1281 ret, strerror(-ret));
1282 return ret;
1283 }
1284
1285
1286 unsigned int nl80211_get_assoc_freq(struct wpa_driver_nl80211_data *drv)
1287 {
1288 struct nl_msg *msg;
1289 int ret;
1290 struct nl80211_get_assoc_freq_arg arg;
1291
1292 msg = nl80211_drv_msg(drv, NLM_F_DUMP, NL80211_CMD_GET_SCAN);
1293 os_memset(&arg, 0, sizeof(arg));
1294 arg.drv = drv;
1295 ret = send_and_recv_msgs(drv, msg, nl80211_get_assoc_freq_handler,
1296 &arg);
1297 if (ret == 0) {
1298 unsigned int freq = drv->nlmode == NL80211_IFTYPE_ADHOC ?
1299 arg.ibss_freq : arg.assoc_freq;
1300 wpa_printf(MSG_DEBUG, "nl80211: Operating frequency for the "
1301 "associated BSS from scan results: %u MHz", freq);
1302 if (freq)
1303 drv->assoc_freq = freq;
1304 return drv->assoc_freq;
1305 }
1306 wpa_printf(MSG_DEBUG, "nl80211: Scan result fetch failed: ret=%d "
1307 "(%s)", ret, strerror(-ret));
1308 return drv->assoc_freq;
1309 }
1310
1311
1312 static int get_link_signal(struct nl_msg *msg, void *arg)
1313 {
1314 struct nlattr *tb[NL80211_ATTR_MAX + 1];
1315 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
1316 struct nlattr *sinfo[NL80211_STA_INFO_MAX + 1];
1317 static struct nla_policy policy[NL80211_STA_INFO_MAX + 1] = {
1318 [NL80211_STA_INFO_SIGNAL] = { .type = NLA_U8 },
1319 [NL80211_STA_INFO_SIGNAL_AVG] = { .type = NLA_U8 },
1320 [NL80211_STA_INFO_BEACON_SIGNAL_AVG] = { .type = NLA_U8 },
1321 };
1322 struct nlattr *rinfo[NL80211_RATE_INFO_MAX + 1];
1323 static struct nla_policy rate_policy[NL80211_RATE_INFO_MAX + 1] = {
1324 [NL80211_RATE_INFO_BITRATE] = { .type = NLA_U16 },
1325 [NL80211_RATE_INFO_MCS] = { .type = NLA_U8 },
1326 [NL80211_RATE_INFO_40_MHZ_WIDTH] = { .type = NLA_FLAG },
1327 [NL80211_RATE_INFO_SHORT_GI] = { .type = NLA_FLAG },
1328 };
1329 struct wpa_signal_info *sig_change = arg;
1330
1331 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
1332 genlmsg_attrlen(gnlh, 0), NULL);
1333 if (!tb[NL80211_ATTR_STA_INFO] ||
1334 nla_parse_nested(sinfo, NL80211_STA_INFO_MAX,
1335 tb[NL80211_ATTR_STA_INFO], policy))
1336 return NL_SKIP;
1337 if (!sinfo[NL80211_STA_INFO_SIGNAL])
1338 return NL_SKIP;
1339
1340 sig_change->current_signal =
1341 (s8) nla_get_u8(sinfo[NL80211_STA_INFO_SIGNAL]);
1342
1343 if (sinfo[NL80211_STA_INFO_SIGNAL_AVG])
1344 sig_change->avg_signal =
1345 (s8) nla_get_u8(sinfo[NL80211_STA_INFO_SIGNAL_AVG]);
1346 else
1347 sig_change->avg_signal = 0;
1348
1349 if (sinfo[NL80211_STA_INFO_BEACON_SIGNAL_AVG])
1350 sig_change->avg_beacon_signal =
1351 (s8)
1352 nla_get_u8(sinfo[NL80211_STA_INFO_BEACON_SIGNAL_AVG]);
1353 else
1354 sig_change->avg_beacon_signal = 0;
1355
1356 if (sinfo[NL80211_STA_INFO_TX_BITRATE]) {
1357 if (nla_parse_nested(rinfo, NL80211_RATE_INFO_MAX,
1358 sinfo[NL80211_STA_INFO_TX_BITRATE],
1359 rate_policy)) {
1360 sig_change->current_txrate = 0;
1361 } else {
1362 if (rinfo[NL80211_RATE_INFO_BITRATE]) {
1363 sig_change->current_txrate =
1364 nla_get_u16(rinfo[
1365 NL80211_RATE_INFO_BITRATE]) * 100;
1366 }
1367 }
1368 }
1369
1370 return NL_SKIP;
1371 }
1372
1373
1374 int nl80211_get_link_signal(struct wpa_driver_nl80211_data *drv,
1375 struct wpa_signal_info *sig)
1376 {
1377 struct nl_msg *msg;
1378
1379 sig->current_signal = -9999;
1380 sig->current_txrate = 0;
1381
1382 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_GET_STATION)) ||
1383 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, drv->bssid)) {
1384 nlmsg_free(msg);
1385 return -ENOBUFS;
1386 }
1387
1388 return send_and_recv_msgs(drv, msg, get_link_signal, sig);
1389 }
1390
1391
1392 static int get_link_noise(struct nl_msg *msg, void *arg)
1393 {
1394 struct nlattr *tb[NL80211_ATTR_MAX + 1];
1395 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
1396 struct nlattr *sinfo[NL80211_SURVEY_INFO_MAX + 1];
1397 static struct nla_policy survey_policy[NL80211_SURVEY_INFO_MAX + 1] = {
1398 [NL80211_SURVEY_INFO_FREQUENCY] = { .type = NLA_U32 },
1399 [NL80211_SURVEY_INFO_NOISE] = { .type = NLA_U8 },
1400 };
1401 struct wpa_signal_info *sig_change = arg;
1402
1403 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
1404 genlmsg_attrlen(gnlh, 0), NULL);
1405
1406 if (!tb[NL80211_ATTR_SURVEY_INFO]) {
1407 wpa_printf(MSG_DEBUG, "nl80211: survey data missing!");
1408 return NL_SKIP;
1409 }
1410
1411 if (nla_parse_nested(sinfo, NL80211_SURVEY_INFO_MAX,
1412 tb[NL80211_ATTR_SURVEY_INFO],
1413 survey_policy)) {
1414 wpa_printf(MSG_DEBUG, "nl80211: failed to parse nested "
1415 "attributes!");
1416 return NL_SKIP;
1417 }
1418
1419 if (!sinfo[NL80211_SURVEY_INFO_FREQUENCY])
1420 return NL_SKIP;
1421
1422 if (nla_get_u32(sinfo[NL80211_SURVEY_INFO_FREQUENCY]) !=
1423 sig_change->frequency)
1424 return NL_SKIP;
1425
1426 if (!sinfo[NL80211_SURVEY_INFO_NOISE])
1427 return NL_SKIP;
1428
1429 sig_change->current_noise =
1430 (s8) nla_get_u8(sinfo[NL80211_SURVEY_INFO_NOISE]);
1431
1432 return NL_SKIP;
1433 }
1434
1435
1436 int nl80211_get_link_noise(struct wpa_driver_nl80211_data *drv,
1437 struct wpa_signal_info *sig_change)
1438 {
1439 struct nl_msg *msg;
1440
1441 sig_change->current_noise = 9999;
1442 sig_change->frequency = drv->assoc_freq;
1443
1444 msg = nl80211_drv_msg(drv, NLM_F_DUMP, NL80211_CMD_GET_SURVEY);
1445 return send_and_recv_msgs(drv, msg, get_link_noise, sig_change);
1446 }
1447
1448
1449 static void wpa_driver_nl80211_event_receive(int sock, void *eloop_ctx,
1450 void *handle)
1451 {
1452 struct nl_cb *cb = eloop_ctx;
1453 int res;
1454
1455 wpa_printf(MSG_MSGDUMP, "nl80211: Event message available");
1456
1457 res = nl_recvmsgs(handle, cb);
1458 if (res < 0) {
1459 wpa_printf(MSG_INFO, "nl80211: %s->nl_recvmsgs failed: %d",
1460 __func__, res);
1461 }
1462 }
1463
1464
1465 /**
1466 * wpa_driver_nl80211_set_country - ask nl80211 to set the regulatory domain
1467 * @priv: driver_nl80211 private data
1468 * @alpha2_arg: country to which to switch to
1469 * Returns: 0 on success, -1 on failure
1470 *
1471 * This asks nl80211 to set the regulatory domain for given
1472 * country ISO / IEC alpha2.
1473 */
1474 static int wpa_driver_nl80211_set_country(void *priv, const char *alpha2_arg)
1475 {
1476 struct i802_bss *bss = priv;
1477 struct wpa_driver_nl80211_data *drv = bss->drv;
1478 char alpha2[3];
1479 struct nl_msg *msg;
1480
1481 msg = nlmsg_alloc();
1482 if (!msg)
1483 return -ENOMEM;
1484
1485 alpha2[0] = alpha2_arg[0];
1486 alpha2[1] = alpha2_arg[1];
1487 alpha2[2] = '\0';
1488
1489 if (!nl80211_cmd(drv, msg, 0, NL80211_CMD_REQ_SET_REG) ||
1490 nla_put_string(msg, NL80211_ATTR_REG_ALPHA2, alpha2)) {
1491 nlmsg_free(msg);
1492 return -EINVAL;
1493 }
1494 if (send_and_recv_msgs(drv, msg, NULL, NULL))
1495 return -EINVAL;
1496 return 0;
1497 }
1498
1499
1500 static int nl80211_get_country(struct nl_msg *msg, void *arg)
1501 {
1502 char *alpha2 = arg;
1503 struct nlattr *tb_msg[NL80211_ATTR_MAX + 1];
1504 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
1505
1506 nla_parse(tb_msg, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
1507 genlmsg_attrlen(gnlh, 0), NULL);
1508 if (!tb_msg[NL80211_ATTR_REG_ALPHA2]) {
1509 wpa_printf(MSG_DEBUG, "nl80211: No country information available");
1510 return NL_SKIP;
1511 }
1512 os_strlcpy(alpha2, nla_data(tb_msg[NL80211_ATTR_REG_ALPHA2]), 3);
1513 return NL_SKIP;
1514 }
1515
1516
1517 static int wpa_driver_nl80211_get_country(void *priv, char *alpha2)
1518 {
1519 struct i802_bss *bss = priv;
1520 struct wpa_driver_nl80211_data *drv = bss->drv;
1521 struct nl_msg *msg;
1522 int ret;
1523
1524 msg = nlmsg_alloc();
1525 if (!msg)
1526 return -ENOMEM;
1527
1528 nl80211_cmd(drv, msg, 0, NL80211_CMD_GET_REG);
1529 alpha2[0] = '\0';
1530 ret = send_and_recv_msgs(drv, msg, nl80211_get_country, alpha2);
1531 if (!alpha2[0])
1532 ret = -1;
1533
1534 return ret;
1535 }
1536
1537
1538 static int wpa_driver_nl80211_init_nl_global(struct nl80211_global *global)
1539 {
1540 int ret;
1541
1542 global->nl_cb = nl_cb_alloc(NL_CB_DEFAULT);
1543 if (global->nl_cb == NULL) {
1544 wpa_printf(MSG_ERROR, "nl80211: Failed to allocate netlink "
1545 "callbacks");
1546 return -1;
1547 }
1548
1549 global->nl = nl_create_handle(global->nl_cb, "nl");
1550 if (global->nl == NULL)
1551 goto err;
1552
1553 global->nl80211_id = genl_ctrl_resolve(global->nl, "nl80211");
1554 if (global->nl80211_id < 0) {
1555 wpa_printf(MSG_ERROR, "nl80211: 'nl80211' generic netlink not "
1556 "found");
1557 goto err;
1558 }
1559
1560 global->nl_event = nl_create_handle(global->nl_cb, "event");
1561 if (global->nl_event == NULL)
1562 goto err;
1563
1564 ret = nl_get_multicast_id(global, "nl80211", "scan");
1565 if (ret >= 0)
1566 ret = nl_socket_add_membership(global->nl_event, ret);
1567 if (ret < 0) {
1568 wpa_printf(MSG_ERROR, "nl80211: Could not add multicast "
1569 "membership for scan events: %d (%s)",
1570 ret, strerror(-ret));
1571 goto err;
1572 }
1573
1574 ret = nl_get_multicast_id(global, "nl80211", "mlme");
1575 if (ret >= 0)
1576 ret = nl_socket_add_membership(global->nl_event, ret);
1577 if (ret < 0) {
1578 wpa_printf(MSG_ERROR, "nl80211: Could not add multicast "
1579 "membership for mlme events: %d (%s)",
1580 ret, strerror(-ret));
1581 goto err;
1582 }
1583
1584 ret = nl_get_multicast_id(global, "nl80211", "regulatory");
1585 if (ret >= 0)
1586 ret = nl_socket_add_membership(global->nl_event, ret);
1587 if (ret < 0) {
1588 wpa_printf(MSG_DEBUG, "nl80211: Could not add multicast "
1589 "membership for regulatory events: %d (%s)",
1590 ret, strerror(-ret));
1591 /* Continue without regulatory events */
1592 }
1593
1594 ret = nl_get_multicast_id(global, "nl80211", "vendor");
1595 if (ret >= 0)
1596 ret = nl_socket_add_membership(global->nl_event, ret);
1597 if (ret < 0) {
1598 wpa_printf(MSG_DEBUG, "nl80211: Could not add multicast "
1599 "membership for vendor events: %d (%s)",
1600 ret, strerror(-ret));
1601 /* Continue without vendor events */
1602 }
1603
1604 nl_cb_set(global->nl_cb, NL_CB_SEQ_CHECK, NL_CB_CUSTOM,
1605 no_seq_check, NULL);
1606 nl_cb_set(global->nl_cb, NL_CB_VALID, NL_CB_CUSTOM,
1607 process_global_event, global);
1608
1609 nl80211_register_eloop_read(&global->nl_event,
1610 wpa_driver_nl80211_event_receive,
1611 global->nl_cb);
1612
1613 return 0;
1614
1615 err:
1616 nl_destroy_handles(&global->nl_event);
1617 nl_destroy_handles(&global->nl);
1618 nl_cb_put(global->nl_cb);
1619 global->nl_cb = NULL;
1620 return -1;
1621 }
1622
1623
1624 static void nl80211_check_global(struct nl80211_global *global)
1625 {
1626 struct nl_handle *handle;
1627 const char *groups[] = { "scan", "mlme", "regulatory", "vendor", NULL };
1628 int ret;
1629 unsigned int i;
1630
1631 /*
1632 * Try to re-add memberships to handle case of cfg80211 getting reloaded
1633 * and all registration having been cleared.
1634 */
1635 handle = (void *) (((intptr_t) global->nl_event) ^
1636 ELOOP_SOCKET_INVALID);
1637
1638 for (i = 0; groups[i]; i++) {
1639 ret = nl_get_multicast_id(global, "nl80211", groups[i]);
1640 if (ret >= 0)
1641 ret = nl_socket_add_membership(handle, ret);
1642 if (ret < 0) {
1643 wpa_printf(MSG_INFO,
1644 "nl80211: Could not re-add multicast membership for %s events: %d (%s)",
1645 groups[i], ret, strerror(-ret));
1646 }
1647 }
1648 }
1649
1650
1651 static void wpa_driver_nl80211_rfkill_blocked(void *ctx)
1652 {
1653 struct wpa_driver_nl80211_data *drv = ctx;
1654
1655 wpa_printf(MSG_DEBUG, "nl80211: RFKILL blocked");
1656
1657 /*
1658 * rtnetlink ifdown handler will report interfaces other than the P2P
1659 * Device interface as disabled.
1660 */
1661 if (drv->nlmode == NL80211_IFTYPE_P2P_DEVICE)
1662 wpa_supplicant_event(drv->ctx, EVENT_INTERFACE_DISABLED, NULL);
1663 }
1664
1665
1666 static void wpa_driver_nl80211_rfkill_unblocked(void *ctx)
1667 {
1668 struct wpa_driver_nl80211_data *drv = ctx;
1669 wpa_printf(MSG_DEBUG, "nl80211: RFKILL unblocked");
1670 if (i802_set_iface_flags(drv->first_bss, 1)) {
1671 wpa_printf(MSG_DEBUG, "nl80211: Could not set interface UP "
1672 "after rfkill unblock");
1673 return;
1674 }
1675
1676 if (is_p2p_net_interface(drv->nlmode))
1677 nl80211_disable_11b_rates(drv, drv->ifindex, 1);
1678
1679 /*
1680 * rtnetlink ifup handler will report interfaces other than the P2P
1681 * Device interface as enabled.
1682 */
1683 if (drv->nlmode == NL80211_IFTYPE_P2P_DEVICE)
1684 wpa_supplicant_event(drv->ctx, EVENT_INTERFACE_ENABLED, NULL);
1685 }
1686
1687
1688 static void wpa_driver_nl80211_handle_eapol_tx_status(int sock,
1689 void *eloop_ctx,
1690 void *handle)
1691 {
1692 struct wpa_driver_nl80211_data *drv = eloop_ctx;
1693 u8 data[2048];
1694 struct msghdr msg;
1695 struct iovec entry;
1696 u8 control[512];
1697 struct cmsghdr *cmsg;
1698 int res, found_ee = 0, found_wifi = 0, acked = 0;
1699 union wpa_event_data event;
1700
1701 memset(&msg, 0, sizeof(msg));
1702 msg.msg_iov = &entry;
1703 msg.msg_iovlen = 1;
1704 entry.iov_base = data;
1705 entry.iov_len = sizeof(data);
1706 msg.msg_control = &control;
1707 msg.msg_controllen = sizeof(control);
1708
1709 res = recvmsg(sock, &msg, MSG_ERRQUEUE);
1710 /* if error or not fitting 802.3 header, return */
1711 if (res < 14)
1712 return;
1713
1714 for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg))
1715 {
1716 if (cmsg->cmsg_level == SOL_SOCKET &&
1717 cmsg->cmsg_type == SCM_WIFI_STATUS) {
1718 int *ack;
1719
1720 found_wifi = 1;
1721 ack = (void *)CMSG_DATA(cmsg);
1722 acked = *ack;
1723 }
1724
1725 if (cmsg->cmsg_level == SOL_PACKET &&
1726 cmsg->cmsg_type == PACKET_TX_TIMESTAMP) {
1727 struct sock_extended_err *err =
1728 (struct sock_extended_err *)CMSG_DATA(cmsg);
1729
1730 if (err->ee_origin == SO_EE_ORIGIN_TXSTATUS)
1731 found_ee = 1;
1732 }
1733 }
1734
1735 if (!found_ee || !found_wifi)
1736 return;
1737
1738 memset(&event, 0, sizeof(event));
1739 event.eapol_tx_status.dst = data;
1740 event.eapol_tx_status.data = data + 14;
1741 event.eapol_tx_status.data_len = res - 14;
1742 event.eapol_tx_status.ack = acked;
1743 wpa_supplicant_event(drv->ctx, EVENT_EAPOL_TX_STATUS, &event);
1744 }
1745
1746
1747 static int nl80211_init_bss(struct i802_bss *bss)
1748 {
1749 bss->nl_cb = nl_cb_alloc(NL_CB_DEFAULT);
1750 if (!bss->nl_cb)
1751 return -1;
1752
1753 nl_cb_set(bss->nl_cb, NL_CB_SEQ_CHECK, NL_CB_CUSTOM,
1754 no_seq_check, NULL);
1755 nl_cb_set(bss->nl_cb, NL_CB_VALID, NL_CB_CUSTOM,
1756 process_bss_event, bss);
1757
1758 return 0;
1759 }
1760
1761
1762 static void nl80211_destroy_bss(struct i802_bss *bss)
1763 {
1764 nl_cb_put(bss->nl_cb);
1765 bss->nl_cb = NULL;
1766 }
1767
1768
1769 static void
1770 wpa_driver_nl80211_drv_init_rfkill(struct wpa_driver_nl80211_data *drv)
1771 {
1772 struct rfkill_config *rcfg;
1773
1774 if (drv->rfkill)
1775 return;
1776
1777 rcfg = os_zalloc(sizeof(*rcfg));
1778 if (!rcfg)
1779 return;
1780
1781 rcfg->ctx = drv;
1782
1783 /* rfkill uses netdev sysfs for initialization. However, P2P Device is
1784 * not associated with a netdev, so use the name of some other interface
1785 * sharing the same wiphy as the P2P Device interface.
1786 *
1787 * Note: This is valid, as a P2P Device interface is always dynamically
1788 * created and is created only once another wpa_s interface was added.
1789 */
1790 if (drv->nlmode == NL80211_IFTYPE_P2P_DEVICE) {
1791 struct nl80211_global *global = drv->global;
1792 struct wpa_driver_nl80211_data *tmp1;
1793
1794 dl_list_for_each(tmp1, &global->interfaces,
1795 struct wpa_driver_nl80211_data, list) {
1796 if (drv == tmp1 || drv->wiphy_idx != tmp1->wiphy_idx ||
1797 !tmp1->rfkill)
1798 continue;
1799
1800 wpa_printf(MSG_DEBUG,
1801 "nl80211: Use (%s) to initialize P2P Device rfkill",
1802 tmp1->first_bss->ifname);
1803 os_strlcpy(rcfg->ifname, tmp1->first_bss->ifname,
1804 sizeof(rcfg->ifname));
1805 break;
1806 }
1807 } else {
1808 os_strlcpy(rcfg->ifname, drv->first_bss->ifname,
1809 sizeof(rcfg->ifname));
1810 }
1811
1812 rcfg->blocked_cb = wpa_driver_nl80211_rfkill_blocked;
1813 rcfg->unblocked_cb = wpa_driver_nl80211_rfkill_unblocked;
1814 drv->rfkill = rfkill_init(rcfg);
1815 if (!drv->rfkill) {
1816 wpa_printf(MSG_DEBUG, "nl80211: RFKILL status not available");
1817 os_free(rcfg);
1818 }
1819 }
1820
1821
1822 static void * wpa_driver_nl80211_drv_init(void *ctx, const char *ifname,
1823 void *global_priv, int hostapd,
1824 const u8 *set_addr,
1825 const char *driver_params)
1826 {
1827 struct wpa_driver_nl80211_data *drv;
1828 struct i802_bss *bss;
1829
1830 if (global_priv == NULL)
1831 return NULL;
1832 drv = os_zalloc(sizeof(*drv));
1833 if (drv == NULL)
1834 return NULL;
1835 drv->global = global_priv;
1836 drv->ctx = ctx;
1837 drv->hostapd = !!hostapd;
1838 drv->eapol_sock = -1;
1839
1840 /*
1841 * There is no driver capability flag for this, so assume it is
1842 * supported and disable this on first attempt to use if the driver
1843 * rejects the command due to missing support.
1844 */
1845 drv->set_rekey_offload = 1;
1846
1847 drv->num_if_indices = sizeof(drv->default_if_indices) / sizeof(int);
1848 drv->if_indices = drv->default_if_indices;
1849 drv->if_indices_reason = drv->default_if_indices_reason;
1850
1851 drv->first_bss = os_zalloc(sizeof(*drv->first_bss));
1852 if (!drv->first_bss) {
1853 os_free(drv);
1854 return NULL;
1855 }
1856 bss = drv->first_bss;
1857 bss->drv = drv;
1858 bss->ctx = ctx;
1859
1860 os_strlcpy(bss->ifname, ifname, sizeof(bss->ifname));
1861 drv->monitor_ifidx = -1;
1862 drv->monitor_sock = -1;
1863 drv->eapol_tx_sock = -1;
1864 drv->ap_scan_as_station = NL80211_IFTYPE_UNSPECIFIED;
1865
1866 if (nl80211_init_bss(bss))
1867 goto failed;
1868
1869 if (wpa_driver_nl80211_finish_drv_init(drv, set_addr, 1, driver_params))
1870 goto failed;
1871
1872 drv->eapol_tx_sock = socket(PF_PACKET, SOCK_DGRAM, 0);
1873 if (drv->eapol_tx_sock < 0)
1874 goto failed;
1875
1876 if (drv->data_tx_status) {
1877 int enabled = 1;
1878
1879 if (setsockopt(drv->eapol_tx_sock, SOL_SOCKET, SO_WIFI_STATUS,
1880 &enabled, sizeof(enabled)) < 0) {
1881 wpa_printf(MSG_DEBUG,
1882 "nl80211: wifi status sockopt failed\n");
1883 drv->data_tx_status = 0;
1884 if (!drv->use_monitor)
1885 drv->capa.flags &=
1886 ~WPA_DRIVER_FLAGS_EAPOL_TX_STATUS;
1887 } else {
1888 eloop_register_read_sock(drv->eapol_tx_sock,
1889 wpa_driver_nl80211_handle_eapol_tx_status,
1890 drv, NULL);
1891 }
1892 }
1893
1894 if (drv->global) {
1895 nl80211_check_global(drv->global);
1896 dl_list_add(&drv->global->interfaces, &drv->list);
1897 drv->in_interface_list = 1;
1898 }
1899
1900 return bss;
1901
1902 failed:
1903 wpa_driver_nl80211_deinit(bss);
1904 return NULL;
1905 }
1906
1907
1908 /**
1909 * wpa_driver_nl80211_init - Initialize nl80211 driver interface
1910 * @ctx: context to be used when calling wpa_supplicant functions,
1911 * e.g., wpa_supplicant_event()
1912 * @ifname: interface name, e.g., wlan0
1913 * @global_priv: private driver global data from global_init()
1914 * Returns: Pointer to private data, %NULL on failure
1915 */
1916 static void * wpa_driver_nl80211_init(void *ctx, const char *ifname,
1917 void *global_priv)
1918 {
1919 return wpa_driver_nl80211_drv_init(ctx, ifname, global_priv, 0, NULL,
1920 NULL);
1921 }
1922
1923
1924 static int nl80211_register_frame(struct i802_bss *bss,
1925 struct nl_handle *nl_handle,
1926 u16 type, const u8 *match, size_t match_len)
1927 {
1928 struct wpa_driver_nl80211_data *drv = bss->drv;
1929 struct nl_msg *msg;
1930 int ret;
1931 char buf[30];
1932
1933 buf[0] = '\0';
1934 wpa_snprintf_hex(buf, sizeof(buf), match, match_len);
1935 wpa_printf(MSG_DEBUG, "nl80211: Register frame type=0x%x (%s) nl_handle=%p match=%s",
1936 type, fc2str(type), nl_handle, buf);
1937
1938 if (!(msg = nl80211_cmd_msg(bss, 0, NL80211_CMD_REGISTER_ACTION)) ||
1939 nla_put_u16(msg, NL80211_ATTR_FRAME_TYPE, type) ||
1940 nla_put(msg, NL80211_ATTR_FRAME_MATCH, match_len, match)) {
1941 nlmsg_free(msg);
1942 return -1;
1943 }
1944
1945 ret = send_and_recv(drv->global, nl_handle, msg, NULL, NULL);
1946 if (ret) {
1947 wpa_printf(MSG_DEBUG, "nl80211: Register frame command "
1948 "failed (type=%u): ret=%d (%s)",
1949 type, ret, strerror(-ret));
1950 wpa_hexdump(MSG_DEBUG, "nl80211: Register frame match",
1951 match, match_len);
1952 }
1953 return ret;
1954 }
1955
1956
1957 static int nl80211_alloc_mgmt_handle(struct i802_bss *bss)
1958 {
1959 if (bss->nl_mgmt) {
1960 wpa_printf(MSG_DEBUG, "nl80211: Mgmt reporting "
1961 "already on! (nl_mgmt=%p)", bss->nl_mgmt);
1962 return -1;
1963 }
1964
1965 bss->nl_mgmt = nl_create_handle(bss->nl_cb, "mgmt");
1966 if (bss->nl_mgmt == NULL)
1967 return -1;
1968
1969 return 0;
1970 }
1971
1972
1973 static void nl80211_mgmt_handle_register_eloop(struct i802_bss *bss)
1974 {
1975 nl80211_register_eloop_read(&bss->nl_mgmt,
1976 wpa_driver_nl80211_event_receive,
1977 bss->nl_cb);
1978 }
1979
1980
1981 static int nl80211_register_action_frame(struct i802_bss *bss,
1982 const u8 *match, size_t match_len)
1983 {
1984 u16 type = (WLAN_FC_TYPE_MGMT << 2) | (WLAN_FC_STYPE_ACTION << 4);
1985 return nl80211_register_frame(bss, bss->nl_mgmt,
1986 type, match, match_len);
1987 }
1988
1989
1990 static int nl80211_mgmt_subscribe_non_ap(struct i802_bss *bss)
1991 {
1992 struct wpa_driver_nl80211_data *drv = bss->drv;
1993 int ret = 0;
1994
1995 if (nl80211_alloc_mgmt_handle(bss))
1996 return -1;
1997 wpa_printf(MSG_DEBUG, "nl80211: Subscribe to mgmt frames with non-AP "
1998 "handle %p", bss->nl_mgmt);
1999
2000 if (drv->nlmode == NL80211_IFTYPE_ADHOC) {
2001 u16 type = (WLAN_FC_TYPE_MGMT << 2) | (WLAN_FC_STYPE_AUTH << 4);
2002
2003 /* register for any AUTH message */
2004 nl80211_register_frame(bss, bss->nl_mgmt, type, NULL, 0);
2005 }
2006
2007 #ifdef CONFIG_INTERWORKING
2008 /* QoS Map Configure */
2009 if (nl80211_register_action_frame(bss, (u8 *) "\x01\x04", 2) < 0)
2010 ret = -1;
2011 #endif /* CONFIG_INTERWORKING */
2012 #if defined(CONFIG_P2P) || defined(CONFIG_INTERWORKING)
2013 /* GAS Initial Request */
2014 if (nl80211_register_action_frame(bss, (u8 *) "\x04\x0a", 2) < 0)
2015 ret = -1;
2016 /* GAS Initial Response */
2017 if (nl80211_register_action_frame(bss, (u8 *) "\x04\x0b", 2) < 0)
2018 ret = -1;
2019 /* GAS Comeback Request */
2020 if (nl80211_register_action_frame(bss, (u8 *) "\x04\x0c", 2) < 0)
2021 ret = -1;
2022 /* GAS Comeback Response */
2023 if (nl80211_register_action_frame(bss, (u8 *) "\x04\x0d", 2) < 0)
2024 ret = -1;
2025 /* Protected GAS Initial Request */
2026 if (nl80211_register_action_frame(bss, (u8 *) "\x09\x0a", 2) < 0)
2027 ret = -1;
2028 /* Protected GAS Initial Response */
2029 if (nl80211_register_action_frame(bss, (u8 *) "\x09\x0b", 2) < 0)
2030 ret = -1;
2031 /* Protected GAS Comeback Request */
2032 if (nl80211_register_action_frame(bss, (u8 *) "\x09\x0c", 2) < 0)
2033 ret = -1;
2034 /* Protected GAS Comeback Response */
2035 if (nl80211_register_action_frame(bss, (u8 *) "\x09\x0d", 2) < 0)
2036 ret = -1;
2037 #endif /* CONFIG_P2P || CONFIG_INTERWORKING */
2038 #ifdef CONFIG_P2P
2039 /* P2P Public Action */
2040 if (nl80211_register_action_frame(bss,
2041 (u8 *) "\x04\x09\x50\x6f\x9a\x09",
2042 6) < 0)
2043 ret = -1;
2044 /* P2P Action */
2045 if (nl80211_register_action_frame(bss,
2046 (u8 *) "\x7f\x50\x6f\x9a\x09",
2047 5) < 0)
2048 ret = -1;
2049 #endif /* CONFIG_P2P */
2050 #ifdef CONFIG_IEEE80211W
2051 /* SA Query Response */
2052 if (nl80211_register_action_frame(bss, (u8 *) "\x08\x01", 2) < 0)
2053 ret = -1;
2054 #endif /* CONFIG_IEEE80211W */
2055 #ifdef CONFIG_TDLS
2056 if ((drv->capa.flags & WPA_DRIVER_FLAGS_TDLS_SUPPORT)) {
2057 /* TDLS Discovery Response */
2058 if (nl80211_register_action_frame(bss, (u8 *) "\x04\x0e", 2) <
2059 0)
2060 ret = -1;
2061 }
2062 #endif /* CONFIG_TDLS */
2063 #ifdef CONFIG_FST
2064 /* FST Action frames */
2065 if (nl80211_register_action_frame(bss, (u8 *) "\x12", 1) < 0)
2066 ret = -1;
2067 #endif /* CONFIG_FST */
2068
2069 /* FT Action frames */
2070 if (nl80211_register_action_frame(bss, (u8 *) "\x06", 1) < 0)
2071 ret = -1;
2072 else
2073 drv->capa.key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_FT |
2074 WPA_DRIVER_CAPA_KEY_MGMT_FT_PSK;
2075
2076 /* WNM - BSS Transition Management Request */
2077 if (nl80211_register_action_frame(bss, (u8 *) "\x0a\x07", 2) < 0)
2078 ret = -1;
2079 /* WNM-Sleep Mode Response */
2080 if (nl80211_register_action_frame(bss, (u8 *) "\x0a\x11", 2) < 0)
2081 ret = -1;
2082
2083 #ifdef CONFIG_HS20
2084 /* WNM-Notification */
2085 if (nl80211_register_action_frame(bss, (u8 *) "\x0a\x1a", 2) < 0)
2086 ret = -1;
2087 #endif /* CONFIG_HS20 */
2088
2089 /* WMM-AC ADDTS Response */
2090 if (nl80211_register_action_frame(bss, (u8 *) "\x11\x01", 2) < 0)
2091 ret = -1;
2092
2093 /* WMM-AC DELTS */
2094 if (nl80211_register_action_frame(bss, (u8 *) "\x11\x02", 2) < 0)
2095 ret = -1;
2096
2097 /* Radio Measurement - Neighbor Report Response */
2098 if (nl80211_register_action_frame(bss, (u8 *) "\x05\x05", 2) < 0)
2099 ret = -1;
2100
2101 /* Radio Measurement - Radio Measurement Request */
2102 if (nl80211_register_action_frame(bss, (u8 *) "\x05\x00", 2) < 0)
2103 ret = -1;
2104
2105 /* Radio Measurement - Link Measurement Request */
2106 if ((drv->capa.rrm_flags & WPA_DRIVER_FLAGS_TX_POWER_INSERTION) &&
2107 (nl80211_register_action_frame(bss, (u8 *) "\x05\x02", 2) < 0))
2108 ret = -1;
2109
2110 nl80211_mgmt_handle_register_eloop(bss);
2111
2112 return ret;
2113 }
2114
2115
2116 static int nl80211_mgmt_subscribe_mesh(struct i802_bss *bss)
2117 {
2118 int ret = 0;
2119
2120 if (nl80211_alloc_mgmt_handle(bss))
2121 return -1;
2122
2123 wpa_printf(MSG_DEBUG,
2124 "nl80211: Subscribe to mgmt frames with mesh handle %p",
2125 bss->nl_mgmt);
2126
2127 /* Auth frames for mesh SAE */
2128 if (nl80211_register_frame(bss, bss->nl_mgmt,
2129 (WLAN_FC_TYPE_MGMT << 2) |
2130 (WLAN_FC_STYPE_AUTH << 4),
2131 NULL, 0) < 0)
2132 ret = -1;
2133
2134 /* Mesh peering open */
2135 if (nl80211_register_action_frame(bss, (u8 *) "\x0f\x01", 2) < 0)
2136 ret = -1;
2137 /* Mesh peering confirm */
2138 if (nl80211_register_action_frame(bss, (u8 *) "\x0f\x02", 2) < 0)
2139 ret = -1;
2140 /* Mesh peering close */
2141 if (nl80211_register_action_frame(bss, (u8 *) "\x0f\x03", 2) < 0)
2142 ret = -1;
2143
2144 nl80211_mgmt_handle_register_eloop(bss);
2145
2146 return ret;
2147 }
2148
2149
2150 static int nl80211_register_spurious_class3(struct i802_bss *bss)
2151 {
2152 struct nl_msg *msg;
2153 int ret;
2154
2155 msg = nl80211_bss_msg(bss, 0, NL80211_CMD_UNEXPECTED_FRAME);
2156 ret = send_and_recv(bss->drv->global, bss->nl_mgmt, msg, NULL, NULL);
2157 if (ret) {
2158 wpa_printf(MSG_DEBUG, "nl80211: Register spurious class3 "
2159 "failed: ret=%d (%s)",
2160 ret, strerror(-ret));
2161 }
2162 return ret;
2163 }
2164
2165
2166 static int nl80211_action_subscribe_ap(struct i802_bss *bss)
2167 {
2168 int ret = 0;
2169
2170 /* Public Action frames */
2171 if (nl80211_register_action_frame(bss, (u8 *) "\x04", 1) < 0)
2172 ret = -1;
2173 /* RRM Measurement Report */
2174 if (nl80211_register_action_frame(bss, (u8 *) "\x05\x01", 2) < 0)
2175 ret = -1;
2176 /* RRM Link Measurement Report */
2177 if (nl80211_register_action_frame(bss, (u8 *) "\x05\x03", 2) < 0)
2178 ret = -1;
2179 /* RRM Neighbor Report Request */
2180 if (nl80211_register_action_frame(bss, (u8 *) "\x05\x04", 2) < 0)
2181 ret = -1;
2182 /* FT Action frames */
2183 if (nl80211_register_action_frame(bss, (u8 *) "\x06", 1) < 0)
2184 ret = -1;
2185 #ifdef CONFIG_IEEE80211W
2186 /* SA Query */
2187 if (nl80211_register_action_frame(bss, (u8 *) "\x08", 1) < 0)
2188 ret = -1;
2189 #endif /* CONFIG_IEEE80211W */
2190 /* Protected Dual of Public Action */
2191 if (nl80211_register_action_frame(bss, (u8 *) "\x09", 1) < 0)
2192 ret = -1;
2193 /* WNM */
2194 if (nl80211_register_action_frame(bss, (u8 *) "\x0a", 1) < 0)
2195 ret = -1;
2196 /* WMM */
2197 if (nl80211_register_action_frame(bss, (u8 *) "\x11", 1) < 0)
2198 ret = -1;
2199 #ifdef CONFIG_FST
2200 /* FST Action frames */
2201 if (nl80211_register_action_frame(bss, (u8 *) "\x12", 1) < 0)
2202 ret = -1;
2203 #endif /* CONFIG_FST */
2204 /* Vendor-specific */
2205 if (nl80211_register_action_frame(bss, (u8 *) "\x7f", 1) < 0)
2206 ret = -1;
2207
2208 return ret;
2209 }
2210
2211
2212 static int nl80211_mgmt_subscribe_ap(struct i802_bss *bss)
2213 {
2214 static const int stypes[] = {
2215 WLAN_FC_STYPE_AUTH,
2216 WLAN_FC_STYPE_ASSOC_REQ,
2217 WLAN_FC_STYPE_REASSOC_REQ,
2218 WLAN_FC_STYPE_DISASSOC,
2219 WLAN_FC_STYPE_DEAUTH,
2220 WLAN_FC_STYPE_PROBE_REQ,
2221 /* Beacon doesn't work as mac80211 doesn't currently allow
2222 * it, but it wouldn't really be the right thing anyway as
2223 * it isn't per interface ... maybe just dump the scan
2224 * results periodically for OLBC?
2225 */
2226 /* WLAN_FC_STYPE_BEACON, */
2227 };
2228 unsigned int i;
2229
2230 if (nl80211_alloc_mgmt_handle(bss))
2231 return -1;
2232 wpa_printf(MSG_DEBUG, "nl80211: Subscribe to mgmt frames with AP "
2233 "handle %p", bss->nl_mgmt);
2234
2235 for (i = 0; i < ARRAY_SIZE(stypes); i++) {
2236 if (nl80211_register_frame(bss, bss->nl_mgmt,
2237 (WLAN_FC_TYPE_MGMT << 2) |
2238 (stypes[i] << 4),
2239 NULL, 0) < 0) {
2240 goto out_err;
2241 }
2242 }
2243
2244 if (nl80211_action_subscribe_ap(bss))
2245 goto out_err;
2246
2247 if (nl80211_register_spurious_class3(bss))
2248 goto out_err;
2249
2250 nl80211_mgmt_handle_register_eloop(bss);
2251 return 0;
2252
2253 out_err:
2254 nl_destroy_handles(&bss->nl_mgmt);
2255 return -1;
2256 }
2257
2258
2259 static int nl80211_mgmt_subscribe_ap_dev_sme(struct i802_bss *bss)
2260 {
2261 if (nl80211_alloc_mgmt_handle(bss))
2262 return -1;
2263 wpa_printf(MSG_DEBUG, "nl80211: Subscribe to mgmt frames with AP "
2264 "handle %p (device SME)", bss->nl_mgmt);
2265
2266 if (nl80211_action_subscribe_ap(bss))
2267 goto out_err;
2268
2269 nl80211_mgmt_handle_register_eloop(bss);
2270 return 0;
2271
2272 out_err:
2273 nl_destroy_handles(&bss->nl_mgmt);
2274 return -1;
2275 }
2276
2277
2278 static void nl80211_mgmt_unsubscribe(struct i802_bss *bss, const char *reason)
2279 {
2280 if (bss->nl_mgmt == NULL)
2281 return;
2282 wpa_printf(MSG_DEBUG, "nl80211: Unsubscribe mgmt frames handle %p "
2283 "(%s)", bss->nl_mgmt, reason);
2284 nl80211_destroy_eloop_handle(&bss->nl_mgmt);
2285
2286 nl80211_put_wiphy_data_ap(bss);
2287 }
2288
2289
2290 static void wpa_driver_nl80211_send_rfkill(void *eloop_ctx, void *timeout_ctx)
2291 {
2292 wpa_supplicant_event(timeout_ctx, EVENT_INTERFACE_DISABLED, NULL);
2293 }
2294
2295
2296 static void nl80211_del_p2pdev(struct i802_bss *bss)
2297 {
2298 struct nl_msg *msg;
2299 int ret;
2300
2301 msg = nl80211_cmd_msg(bss, 0, NL80211_CMD_DEL_INTERFACE);
2302 ret = send_and_recv_msgs(bss->drv, msg, NULL, NULL);
2303
2304 wpa_printf(MSG_DEBUG, "nl80211: Delete P2P Device %s (0x%llx): %s",
2305 bss->ifname, (long long unsigned int) bss->wdev_id,
2306 strerror(-ret));
2307 }
2308
2309
2310 static int nl80211_set_p2pdev(struct i802_bss *bss, int start)
2311 {
2312 struct nl_msg *msg;
2313 int ret;
2314
2315 msg = nl80211_cmd_msg(bss, 0, start ? NL80211_CMD_START_P2P_DEVICE :
2316 NL80211_CMD_STOP_P2P_DEVICE);
2317 ret = send_and_recv_msgs(bss->drv, msg, NULL, NULL);
2318
2319 wpa_printf(MSG_DEBUG, "nl80211: %s P2P Device %s (0x%llx): %s",
2320 start ? "Start" : "Stop",
2321 bss->ifname, (long long unsigned int) bss->wdev_id,
2322 strerror(-ret));
2323 return ret;
2324 }
2325
2326
2327 static int i802_set_iface_flags(struct i802_bss *bss, int up)
2328 {
2329 enum nl80211_iftype nlmode;
2330
2331 nlmode = nl80211_get_ifmode(bss);
2332 if (nlmode != NL80211_IFTYPE_P2P_DEVICE) {
2333 return linux_set_iface_flags(bss->drv->global->ioctl_sock,
2334 bss->ifname, up);
2335 }
2336
2337 /* P2P Device has start/stop which is equivalent */
2338 return nl80211_set_p2pdev(bss, up);
2339 }
2340
2341
2342 #ifdef CONFIG_TESTING_OPTIONS
2343 static int qca_vendor_test_cmd_handler(struct nl_msg *msg, void *arg)
2344 {
2345 /* struct wpa_driver_nl80211_data *drv = arg; */
2346 struct nlattr *tb[NL80211_ATTR_MAX + 1];
2347 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
2348
2349
2350 wpa_printf(MSG_DEBUG,
2351 "nl80211: QCA vendor test command response received");
2352
2353 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
2354 genlmsg_attrlen(gnlh, 0), NULL);
2355 if (!tb[NL80211_ATTR_VENDOR_DATA]) {
2356 wpa_printf(MSG_DEBUG, "nl80211: No vendor data attribute");
2357 return NL_SKIP;
2358 }
2359
2360 wpa_hexdump(MSG_DEBUG,
2361 "nl80211: Received QCA vendor test command response",
2362 nla_data(tb[NL80211_ATTR_VENDOR_DATA]),
2363 nla_len(tb[NL80211_ATTR_VENDOR_DATA]));
2364
2365 return NL_SKIP;
2366 }
2367 #endif /* CONFIG_TESTING_OPTIONS */
2368
2369
2370 static void qca_vendor_test(struct wpa_driver_nl80211_data *drv)
2371 {
2372 #ifdef CONFIG_TESTING_OPTIONS
2373 struct nl_msg *msg;
2374 struct nlattr *params;
2375 int ret;
2376
2377 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_VENDOR)) ||
2378 nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA) ||
2379 nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
2380 QCA_NL80211_VENDOR_SUBCMD_TEST) ||
2381 !(params = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA)) ||
2382 nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_TEST, 123)) {
2383 nlmsg_free(msg);
2384 return;
2385 }
2386 nla_nest_end(msg, params);
2387
2388 ret = send_and_recv_msgs(drv, msg, qca_vendor_test_cmd_handler, drv);
2389 wpa_printf(MSG_DEBUG,
2390 "nl80211: QCA vendor test command returned %d (%s)",
2391 ret, strerror(-ret));
2392 #endif /* CONFIG_TESTING_OPTIONS */
2393 }
2394
2395
2396 static int
2397 wpa_driver_nl80211_finish_drv_init(struct wpa_driver_nl80211_data *drv,
2398 const u8 *set_addr, int first,
2399 const char *driver_params)
2400 {
2401 struct i802_bss *bss = drv->first_bss;
2402 int send_rfkill_event = 0;
2403 enum nl80211_iftype nlmode;
2404
2405 drv->ifindex = if_nametoindex(bss->ifname);
2406 bss->ifindex = drv->ifindex;
2407 bss->wdev_id = drv->global->if_add_wdevid;
2408 bss->wdev_id_set = drv->global->if_add_wdevid_set;
2409
2410 bss->if_dynamic = drv->ifindex == drv->global->if_add_ifindex;
2411 bss->if_dynamic = bss->if_dynamic || drv->global->if_add_wdevid_set;
2412 drv->global->if_add_wdevid_set = 0;
2413
2414 if (!bss->if_dynamic && nl80211_get_ifmode(bss) == NL80211_IFTYPE_AP)
2415 bss->static_ap = 1;
2416
2417 if (first &&
2418 nl80211_get_ifmode(bss) != NL80211_IFTYPE_P2P_DEVICE &&
2419 linux_iface_up(drv->global->ioctl_sock, bss->ifname) > 0)
2420 drv->start_iface_up = 1;
2421
2422 if (wpa_driver_nl80211_capa(drv))
2423 return -1;
2424
2425 if (driver_params && nl80211_set_param(bss, driver_params) < 0)
2426 return -1;
2427
2428 wpa_printf(MSG_DEBUG, "nl80211: interface %s in phy %s",
2429 bss->ifname, drv->phyname);
2430
2431 if (set_addr &&
2432 (linux_set_iface_flags(drv->global->ioctl_sock, bss->ifname, 0) ||
2433 linux_set_ifhwaddr(drv->global->ioctl_sock, bss->ifname,
2434 set_addr)))
2435 return -1;
2436
2437 if (first && nl80211_get_ifmode(bss) == NL80211_IFTYPE_AP)
2438 drv->start_mode_ap = 1;
2439
2440 if (drv->hostapd || bss->static_ap)
2441 nlmode = NL80211_IFTYPE_AP;
2442 else if (bss->if_dynamic ||
2443 nl80211_get_ifmode(bss) == NL80211_IFTYPE_MESH_POINT)
2444 nlmode = nl80211_get_ifmode(bss);
2445 else
2446 nlmode = NL80211_IFTYPE_STATION;
2447
2448 if (wpa_driver_nl80211_set_mode(bss, nlmode) < 0) {
2449 wpa_printf(MSG_ERROR, "nl80211: Could not configure driver mode");
2450 return -1;
2451 }
2452
2453 if (nlmode == NL80211_IFTYPE_P2P_DEVICE)
2454 nl80211_get_macaddr(bss);
2455
2456 wpa_driver_nl80211_drv_init_rfkill(drv);
2457
2458 if (!rfkill_is_blocked(drv->rfkill)) {
2459 int ret = i802_set_iface_flags(bss, 1);
2460 if (ret) {
2461 wpa_printf(MSG_ERROR, "nl80211: Could not set "
2462 "interface '%s' UP", bss->ifname);
2463 return ret;
2464 }
2465
2466 if (is_p2p_net_interface(nlmode))
2467 nl80211_disable_11b_rates(bss->drv,
2468 bss->drv->ifindex, 1);
2469
2470 if (nlmode == NL80211_IFTYPE_P2P_DEVICE)
2471 return ret;
2472 } else {
2473 wpa_printf(MSG_DEBUG, "nl80211: Could not yet enable "
2474 "interface '%s' due to rfkill", bss->ifname);
2475 if (nlmode != NL80211_IFTYPE_P2P_DEVICE)
2476 drv->if_disabled = 1;
2477
2478 send_rfkill_event = 1;
2479 }
2480
2481 if (!drv->hostapd && nlmode != NL80211_IFTYPE_P2P_DEVICE)
2482 netlink_send_oper_ifla(drv->global->netlink, drv->ifindex,
2483 1, IF_OPER_DORMANT);
2484
2485 if (nlmode != NL80211_IFTYPE_P2P_DEVICE) {
2486 if (linux_get_ifhwaddr(drv->global->ioctl_sock, bss->ifname,
2487 bss->addr))
2488 return -1;
2489 os_memcpy(drv->perm_addr, bss->addr, ETH_ALEN);
2490 }
2491
2492 if (send_rfkill_event) {
2493 eloop_register_timeout(0, 0, wpa_driver_nl80211_send_rfkill,
2494 drv, drv->ctx);
2495 }
2496
2497 if (drv->vendor_cmd_test_avail)
2498 qca_vendor_test(drv);
2499
2500 return 0;
2501 }
2502
2503
2504 static int wpa_driver_nl80211_del_beacon(struct i802_bss *bss)
2505 {
2506 struct nl_msg *msg;
2507 struct wpa_driver_nl80211_data *drv = bss->drv;
2508
2509 wpa_printf(MSG_DEBUG, "nl80211: Remove beacon (ifindex=%d)",
2510 drv->ifindex);
2511 nl80211_put_wiphy_data_ap(bss);
2512 msg = nl80211_drv_msg(drv, 0, NL80211_CMD_DEL_BEACON);
2513 return send_and_recv_msgs(drv, msg, NULL, NULL);
2514 }
2515
2516
2517 /**
2518 * wpa_driver_nl80211_deinit - Deinitialize nl80211 driver interface
2519 * @bss: Pointer to private nl80211 data from wpa_driver_nl80211_init()
2520 *
2521 * Shut down driver interface and processing of driver events. Free
2522 * private data buffer if one was allocated in wpa_driver_nl80211_init().
2523 */
2524 static void wpa_driver_nl80211_deinit(struct i802_bss *bss)
2525 {
2526 struct wpa_driver_nl80211_data *drv = bss->drv;
2527 unsigned int i;
2528
2529 wpa_printf(MSG_INFO, "nl80211: deinit ifname=%s disabled_11b_rates=%d",
2530 bss->ifname, drv->disabled_11b_rates);
2531
2532 bss->in_deinit = 1;
2533 if (drv->data_tx_status)
2534 eloop_unregister_read_sock(drv->eapol_tx_sock);
2535 if (drv->eapol_tx_sock >= 0)
2536 close(drv->eapol_tx_sock);
2537
2538 if (bss->nl_preq)
2539 wpa_driver_nl80211_probe_req_report(bss, 0);
2540 if (bss->added_if_into_bridge) {
2541 if (linux_br_del_if(drv->global->ioctl_sock, bss->brname,
2542 bss->ifname) < 0)
2543 wpa_printf(MSG_INFO, "nl80211: Failed to remove "
2544 "interface %s from bridge %s: %s",
2545 bss->ifname, bss->brname, strerror(errno));
2546 if (drv->rtnl_sk)
2547 nl80211_handle_destroy(drv->rtnl_sk);
2548 }
2549 if (bss->added_bridge) {
2550 if (linux_set_iface_flags(drv->global->ioctl_sock, bss->brname,
2551 0) < 0)
2552 wpa_printf(MSG_INFO,
2553 "nl80211: Could not set bridge %s down",
2554 bss->brname);
2555 if (linux_br_del(drv->global->ioctl_sock, bss->brname) < 0)
2556 wpa_printf(MSG_INFO, "nl80211: Failed to remove "
2557 "bridge %s: %s",
2558 bss->brname, strerror(errno));
2559 }
2560
2561 nl80211_remove_monitor_interface(drv);
2562
2563 if (is_ap_interface(drv->nlmode))
2564 wpa_driver_nl80211_del_beacon(bss);
2565
2566 if (drv->eapol_sock >= 0) {
2567 eloop_unregister_read_sock(drv->eapol_sock);
2568 close(drv->eapol_sock);
2569 }
2570
2571 if (drv->if_indices != drv->default_if_indices)
2572 os_free(drv->if_indices);
2573
2574 if (drv->if_indices_reason != drv->default_if_indices_reason)
2575 os_free(drv->if_indices_reason);
2576
2577 if (drv->disabled_11b_rates)
2578 nl80211_disable_11b_rates(drv, drv->ifindex, 0);
2579
2580 netlink_send_oper_ifla(drv->global->netlink, drv->ifindex, 0,
2581 IF_OPER_UP);
2582 eloop_cancel_timeout(wpa_driver_nl80211_send_rfkill, drv, drv->ctx);
2583 rfkill_deinit(drv->rfkill);
2584
2585 eloop_cancel_timeout(wpa_driver_nl80211_scan_timeout, drv, drv->ctx);
2586
2587 if (!drv->start_iface_up)
2588 (void) i802_set_iface_flags(bss, 0);
2589
2590 if (drv->addr_changed) {
2591 if (linux_set_iface_flags(drv->global->ioctl_sock, bss->ifname,
2592 0) < 0) {
2593 wpa_printf(MSG_DEBUG,
2594 "nl80211: Could not set interface down to restore permanent MAC address");
2595 }
2596 if (linux_set_ifhwaddr(drv->global->ioctl_sock, bss->ifname,
2597 drv->perm_addr) < 0) {
2598 wpa_printf(MSG_DEBUG,
2599 "nl80211: Could not restore permanent MAC address");
2600 }
2601 }
2602
2603 if (drv->nlmode != NL80211_IFTYPE_P2P_DEVICE) {
2604 if (!drv->hostapd || !drv->start_mode_ap)
2605 wpa_driver_nl80211_set_mode(bss,
2606 NL80211_IFTYPE_STATION);
2607 nl80211_mgmt_unsubscribe(bss, "deinit");
2608 } else {
2609 nl80211_mgmt_unsubscribe(bss, "deinit");
2610 nl80211_del_p2pdev(bss);
2611 }
2612
2613 nl80211_destroy_bss(drv->first_bss);
2614
2615 os_free(drv->filter_ssids);
2616
2617 os_free(drv->auth_ie);
2618
2619 if (drv->in_interface_list)
2620 dl_list_del(&drv->list);
2621
2622 os_free(drv->extended_capa);
2623 os_free(drv->extended_capa_mask);
2624 for (i = 0; i < drv->num_iface_ext_capa; i++) {
2625 os_free(drv->iface_ext_capa[i].ext_capa);
2626 os_free(drv->iface_ext_capa[i].ext_capa_mask);
2627 }
2628 os_free(drv->first_bss);
2629 os_free(drv);
2630 }
2631
2632
2633 static u32 wpa_alg_to_cipher_suite(enum wpa_alg alg, size_t key_len)
2634 {
2635 switch (alg) {
2636 case WPA_ALG_WEP:
2637 if (key_len == 5)
2638 return RSN_CIPHER_SUITE_WEP40;
2639 return RSN_CIPHER_SUITE_WEP104;
2640 case WPA_ALG_TKIP:
2641 return RSN_CIPHER_SUITE_TKIP;
2642 case WPA_ALG_CCMP:
2643 return RSN_CIPHER_SUITE_CCMP;
2644 case WPA_ALG_GCMP:
2645 return RSN_CIPHER_SUITE_GCMP;
2646 case WPA_ALG_CCMP_256:
2647 return RSN_CIPHER_SUITE_CCMP_256;
2648 case WPA_ALG_GCMP_256:
2649 return RSN_CIPHER_SUITE_GCMP_256;
2650 case WPA_ALG_IGTK:
2651 return RSN_CIPHER_SUITE_AES_128_CMAC;
2652 case WPA_ALG_BIP_GMAC_128:
2653 return RSN_CIPHER_SUITE_BIP_GMAC_128;
2654 case WPA_ALG_BIP_GMAC_256:
2655 return RSN_CIPHER_SUITE_BIP_GMAC_256;
2656 case WPA_ALG_BIP_CMAC_256:
2657 return RSN_CIPHER_SUITE_BIP_CMAC_256;
2658 case WPA_ALG_SMS4:
2659 return RSN_CIPHER_SUITE_SMS4;
2660 case WPA_ALG_KRK:
2661 return RSN_CIPHER_SUITE_KRK;
2662 case WPA_ALG_NONE:
2663 case WPA_ALG_PMK:
2664 wpa_printf(MSG_ERROR, "nl80211: Unexpected encryption algorithm %d",
2665 alg);
2666 return 0;
2667 }
2668
2669 wpa_printf(MSG_ERROR, "nl80211: Unsupported encryption algorithm %d",
2670 alg);
2671 return 0;
2672 }
2673
2674
2675 static u32 wpa_cipher_to_cipher_suite(unsigned int cipher)
2676 {
2677 switch (cipher) {
2678 case WPA_CIPHER_CCMP_256:
2679 return RSN_CIPHER_SUITE_CCMP_256;
2680 case WPA_CIPHER_GCMP_256:
2681 return RSN_CIPHER_SUITE_GCMP_256;
2682 case WPA_CIPHER_CCMP:
2683 return RSN_CIPHER_SUITE_CCMP;
2684 case WPA_CIPHER_GCMP:
2685 return RSN_CIPHER_SUITE_GCMP;
2686 case WPA_CIPHER_TKIP:
2687 return RSN_CIPHER_SUITE_TKIP;
2688 case WPA_CIPHER_WEP104:
2689 return RSN_CIPHER_SUITE_WEP104;
2690 case WPA_CIPHER_WEP40:
2691 return RSN_CIPHER_SUITE_WEP40;
2692 case WPA_CIPHER_GTK_NOT_USED:
2693 return RSN_CIPHER_SUITE_NO_GROUP_ADDRESSED;
2694 }
2695
2696 return 0;
2697 }
2698
2699
2700 static int wpa_cipher_to_cipher_suites(unsigned int ciphers, u32 suites[],
2701 int max_suites)
2702 {
2703 int num_suites = 0;
2704
2705 if (num_suites < max_suites && ciphers & WPA_CIPHER_CCMP_256)
2706 suites[num_suites++] = RSN_CIPHER_SUITE_CCMP_256;
2707 if (num_suites < max_suites && ciphers & WPA_CIPHER_GCMP_256)
2708 suites[num_suites++] = RSN_CIPHER_SUITE_GCMP_256;
2709 if (num_suites < max_suites && ciphers & WPA_CIPHER_CCMP)
2710 suites[num_suites++] = RSN_CIPHER_SUITE_CCMP;
2711 if (num_suites < max_suites && ciphers & WPA_CIPHER_GCMP)
2712 suites[num_suites++] = RSN_CIPHER_SUITE_GCMP;
2713 if (num_suites < max_suites && ciphers & WPA_CIPHER_TKIP)
2714 suites[num_suites++] = RSN_CIPHER_SUITE_TKIP;
2715 if (num_suites < max_suites && ciphers & WPA_CIPHER_WEP104)
2716 suites[num_suites++] = RSN_CIPHER_SUITE_WEP104;
2717 if (num_suites < max_suites && ciphers & WPA_CIPHER_WEP40)
2718 suites[num_suites++] = RSN_CIPHER_SUITE_WEP40;
2719
2720 return num_suites;
2721 }
2722
2723
2724 #ifdef CONFIG_DRIVER_NL80211_QCA
2725 static int issue_key_mgmt_set_key(struct wpa_driver_nl80211_data *drv,
2726 const u8 *key, size_t key_len)
2727 {
2728 struct nl_msg *msg;
2729 int ret;
2730
2731 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_KEY_MGMT_OFFLOAD))
2732 return 0;
2733
2734 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_VENDOR)) ||
2735 nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA) ||
2736 nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
2737 QCA_NL80211_VENDOR_SUBCMD_KEY_MGMT_SET_KEY) ||
2738 nla_put(msg, NL80211_ATTR_VENDOR_DATA, key_len, key)) {
2739 nl80211_nlmsg_clear(msg);
2740 nlmsg_free(msg);
2741 return -1;
2742 }
2743 ret = send_and_recv_msgs(drv, msg, NULL, (void *) -1);
2744 if (ret) {
2745 wpa_printf(MSG_DEBUG,
2746 "nl80211: Key management set key failed: ret=%d (%s)",
2747 ret, strerror(-ret));
2748 }
2749
2750 return ret;
2751 }
2752 #endif /* CONFIG_DRIVER_NL80211_QCA */
2753
2754
2755 static int wpa_driver_nl80211_set_key(const char *ifname, struct i802_bss *bss,
2756 enum wpa_alg alg, const u8 *addr,
2757 int key_idx, int set_tx,
2758 const u8 *seq, size_t seq_len,
2759 const u8 *key, size_t key_len)
2760 {
2761 struct wpa_driver_nl80211_data *drv = bss->drv;
2762 int ifindex;
2763 struct nl_msg *msg = NULL;
2764 int ret;
2765 int tdls = 0;
2766
2767 /* Ignore for P2P Device */
2768 if (drv->nlmode == NL80211_IFTYPE_P2P_DEVICE)
2769 return 0;
2770
2771 ifindex = if_nametoindex(ifname);
2772 wpa_printf(MSG_DEBUG, "%s: ifindex=%d (%s) alg=%d addr=%p key_idx=%d "
2773 "set_tx=%d seq_len=%lu key_len=%lu",
2774 __func__, ifindex, ifname, alg, addr, key_idx, set_tx,
2775 (unsigned long) seq_len, (unsigned long) key_len);
2776 #ifdef CONFIG_TDLS
2777 if (key_idx == -1) {
2778 key_idx = 0;
2779 tdls = 1;
2780 }
2781 #endif /* CONFIG_TDLS */
2782
2783 #ifdef CONFIG_DRIVER_NL80211_QCA
2784 if (alg == WPA_ALG_PMK &&
2785 (drv->capa.flags & WPA_DRIVER_FLAGS_KEY_MGMT_OFFLOAD)) {
2786 wpa_printf(MSG_DEBUG, "%s: calling issue_key_mgmt_set_key",
2787 __func__);
2788 ret = issue_key_mgmt_set_key(drv, key, key_len);
2789 return ret;
2790 }
2791 #endif /* CONFIG_DRIVER_NL80211_QCA */
2792
2793 if (alg == WPA_ALG_NONE) {
2794 msg = nl80211_ifindex_msg(drv, ifindex, 0, NL80211_CMD_DEL_KEY);
2795 if (!msg)
2796 return -ENOBUFS;
2797 } else {
2798 u32 suite;
2799
2800 suite = wpa_alg_to_cipher_suite(alg, key_len);
2801 if (!suite)
2802 goto fail;
2803 msg = nl80211_ifindex_msg(drv, ifindex, 0, NL80211_CMD_NEW_KEY);
2804 if (!msg ||
2805 nla_put(msg, NL80211_ATTR_KEY_DATA, key_len, key) ||
2806 nla_put_u32(msg, NL80211_ATTR_KEY_CIPHER, suite))
2807 goto fail;
2808 wpa_hexdump_key(MSG_DEBUG, "nl80211: KEY_DATA", key, key_len);
2809 }
2810
2811 if (seq && seq_len) {
2812 if (nla_put(msg, NL80211_ATTR_KEY_SEQ, seq_len, seq))
2813 goto fail;
2814 wpa_hexdump(MSG_DEBUG, "nl80211: KEY_SEQ", seq, seq_len);
2815 }
2816
2817 if (addr && !is_broadcast_ether_addr(addr)) {
2818 wpa_printf(MSG_DEBUG, " addr=" MACSTR, MAC2STR(addr));
2819 if (nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr))
2820 goto fail;
2821
2822 if (alg != WPA_ALG_WEP && key_idx && !set_tx) {
2823 wpa_printf(MSG_DEBUG, " RSN IBSS RX GTK");
2824 if (nla_put_u32(msg, NL80211_ATTR_KEY_TYPE,
2825 NL80211_KEYTYPE_GROUP))
2826 goto fail;
2827 }
2828 } else if (addr && is_broadcast_ether_addr(addr)) {
2829 struct nlattr *types;
2830
2831 wpa_printf(MSG_DEBUG, " broadcast key");
2832
2833 types = nla_nest_start(msg, NL80211_ATTR_KEY_DEFAULT_TYPES);
2834 if (!types ||
2835 nla_put_flag(msg, NL80211_KEY_DEFAULT_TYPE_MULTICAST))
2836 goto fail;
2837 nla_nest_end(msg, types);
2838 }
2839 if (nla_put_u8(msg, NL80211_ATTR_KEY_IDX, key_idx))
2840 goto fail;
2841
2842 ret = send_and_recv_msgs(drv, msg, NULL, key ? (void *) -1 : NULL);
2843 if ((ret == -ENOENT || ret == -ENOLINK) && alg == WPA_ALG_NONE)
2844 ret = 0;
2845 if (ret)
2846 wpa_printf(MSG_DEBUG, "nl80211: set_key failed; err=%d %s)",
2847 ret, strerror(-ret));
2848
2849 /*
2850 * If we failed or don't need to set the default TX key (below),
2851 * we're done here.
2852 */
2853 if (ret || !set_tx || alg == WPA_ALG_NONE || tdls)
2854 return ret;
2855 if (is_ap_interface(drv->nlmode) && addr &&
2856 !is_broadcast_ether_addr(addr))
2857 return ret;
2858
2859 msg = nl80211_ifindex_msg(drv, ifindex, 0, NL80211_CMD_SET_KEY);
2860 if (!msg ||
2861 nla_put_u8(msg, NL80211_ATTR_KEY_IDX, key_idx) ||
2862 nla_put_flag(msg, (alg == WPA_ALG_IGTK ||
2863 alg == WPA_ALG_BIP_GMAC_128 ||
2864 alg == WPA_ALG_BIP_GMAC_256 ||
2865 alg == WPA_ALG_BIP_CMAC_256) ?
2866 NL80211_ATTR_KEY_DEFAULT_MGMT :
2867 NL80211_ATTR_KEY_DEFAULT))
2868 goto fail;
2869 if (addr && is_broadcast_ether_addr(addr)) {
2870 struct nlattr *types;
2871
2872 types = nla_nest_start(msg, NL80211_ATTR_KEY_DEFAULT_TYPES);
2873 if (!types ||
2874 nla_put_flag(msg, NL80211_KEY_DEFAULT_TYPE_MULTICAST))
2875 goto fail;
2876 nla_nest_end(msg, types);
2877 } else if (addr) {
2878 struct nlattr *types;
2879
2880 types = nla_nest_start(msg, NL80211_ATTR_KEY_DEFAULT_TYPES);
2881 if (!types ||
2882 nla_put_flag(msg, NL80211_KEY_DEFAULT_TYPE_UNICAST))
2883 goto fail;
2884 nla_nest_end(msg, types);
2885 }
2886
2887 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
2888 if (ret == -ENOENT)
2889 ret = 0;
2890 if (ret)
2891 wpa_printf(MSG_DEBUG, "nl80211: set_key default failed; "
2892 "err=%d %s)", ret, strerror(-ret));
2893 return ret;
2894
2895 fail:
2896 nl80211_nlmsg_clear(msg);
2897 nlmsg_free(msg);
2898 return -ENOBUFS;
2899 }
2900
2901
2902 static int nl_add_key(struct nl_msg *msg, enum wpa_alg alg,
2903 int key_idx, int defkey,
2904 const u8 *seq, size_t seq_len,
2905 const u8 *key, size_t key_len)
2906 {
2907 struct nlattr *key_attr = nla_nest_start(msg, NL80211_ATTR_KEY);
2908 u32 suite;
2909
2910 if (!key_attr)
2911 return -1;
2912
2913 suite = wpa_alg_to_cipher_suite(alg, key_len);
2914 if (!suite)
2915 return -1;
2916
2917 if (defkey && alg == WPA_ALG_IGTK) {
2918 if (nla_put_flag(msg, NL80211_KEY_DEFAULT_MGMT))
2919 return -1;
2920 } else if (defkey) {
2921 if (nla_put_flag(msg, NL80211_KEY_DEFAULT))
2922 return -1;
2923 }
2924
2925 if (nla_put_u8(msg, NL80211_KEY_IDX, key_idx) ||
2926 nla_put_u32(msg, NL80211_KEY_CIPHER, suite) ||
2927 (seq && seq_len &&
2928 nla_put(msg, NL80211_KEY_SEQ, seq_len, seq)) ||
2929 nla_put(msg, NL80211_KEY_DATA, key_len, key))
2930 return -1;
2931
2932 nla_nest_end(msg, key_attr);
2933
2934 return 0;
2935 }
2936
2937
2938 static int nl80211_set_conn_keys(struct wpa_driver_associate_params *params,
2939 struct nl_msg *msg)
2940 {
2941 int i, privacy = 0;
2942 struct nlattr *nl_keys, *nl_key;
2943
2944 for (i = 0; i < 4; i++) {
2945 if (!params->wep_key[i])
2946 continue;
2947 privacy = 1;
2948 break;
2949 }
2950 if (params->wps == WPS_MODE_PRIVACY)
2951 privacy = 1;
2952 if (params->pairwise_suite &&
2953 params->pairwise_suite != WPA_CIPHER_NONE)
2954 privacy = 1;
2955
2956 if (!privacy)
2957 return 0;
2958
2959 if (nla_put_flag(msg, NL80211_ATTR_PRIVACY))
2960 return -ENOBUFS;
2961
2962 nl_keys = nla_nest_start(msg, NL80211_ATTR_KEYS);
2963 if (!nl_keys)
2964 return -ENOBUFS;
2965
2966 for (i = 0; i < 4; i++) {
2967 if (!params->wep_key[i])
2968 continue;
2969
2970 nl_key = nla_nest_start(msg, i);
2971 if (!nl_key ||
2972 nla_put(msg, NL80211_KEY_DATA, params->wep_key_len[i],
2973 params->wep_key[i]) ||
2974 nla_put_u32(msg, NL80211_KEY_CIPHER,
2975 params->wep_key_len[i] == 5 ?
2976 RSN_CIPHER_SUITE_WEP40 :
2977 RSN_CIPHER_SUITE_WEP104) ||
2978 nla_put_u8(msg, NL80211_KEY_IDX, i) ||
2979 (i == params->wep_tx_keyidx &&
2980 nla_put_flag(msg, NL80211_KEY_DEFAULT)))
2981 return -ENOBUFS;
2982
2983 nla_nest_end(msg, nl_key);
2984 }
2985 nla_nest_end(msg, nl_keys);
2986
2987 return 0;
2988 }
2989
2990
2991 int wpa_driver_nl80211_mlme(struct wpa_driver_nl80211_data *drv,
2992 const u8 *addr, int cmd, u16 reason_code,
2993 int local_state_change)
2994 {
2995 int ret;
2996 struct nl_msg *msg;
2997
2998 if (!(msg = nl80211_drv_msg(drv, 0, cmd)) ||
2999 nla_put_u16(msg, NL80211_ATTR_REASON_CODE, reason_code) ||
3000 (addr && nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr)) ||
3001 (local_state_change &&
3002 nla_put_flag(msg, NL80211_ATTR_LOCAL_STATE_CHANGE))) {
3003 nlmsg_free(msg);
3004 return -1;
3005 }
3006
3007 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
3008 if (ret) {
3009 wpa_dbg(drv->ctx, MSG_DEBUG,
3010 "nl80211: MLME command failed: reason=%u ret=%d (%s)",
3011 reason_code, ret, strerror(-ret));
3012 }
3013 return ret;
3014 }
3015
3016
3017 static int wpa_driver_nl80211_disconnect(struct wpa_driver_nl80211_data *drv,
3018 int reason_code)
3019 {
3020 int ret;
3021
3022 wpa_printf(MSG_DEBUG, "%s(reason_code=%d)", __func__, reason_code);
3023 nl80211_mark_disconnected(drv);
3024 /* Disconnect command doesn't need BSSID - it uses cached value */
3025 ret = wpa_driver_nl80211_mlme(drv, NULL, NL80211_CMD_DISCONNECT,
3026 reason_code, 0);
3027 /*
3028 * For locally generated disconnect, supplicant already generates a
3029 * DEAUTH event, so ignore the event from NL80211.
3030 */
3031 drv->ignore_next_local_disconnect = ret == 0;
3032
3033 return ret;
3034 }
3035
3036
3037 static int wpa_driver_nl80211_deauthenticate(struct i802_bss *bss,
3038 const u8 *addr, int reason_code)
3039 {
3040 struct wpa_driver_nl80211_data *drv = bss->drv;
3041 int ret;
3042
3043 if (drv->nlmode == NL80211_IFTYPE_ADHOC) {
3044 nl80211_mark_disconnected(drv);
3045 return nl80211_leave_ibss(drv, 1);
3046 }
3047 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_SME))
3048 return wpa_driver_nl80211_disconnect(drv, reason_code);
3049 wpa_printf(MSG_DEBUG, "%s(addr=" MACSTR " reason_code=%d)",
3050 __func__, MAC2STR(addr), reason_code);
3051 nl80211_mark_disconnected(drv);
3052 ret = wpa_driver_nl80211_mlme(drv, addr, NL80211_CMD_DEAUTHENTICATE,
3053 reason_code, 0);
3054 /*
3055 * For locally generated deauthenticate, supplicant already generates a
3056 * DEAUTH event, so ignore the event from NL80211.
3057 */
3058 drv->ignore_next_local_deauth = ret == 0;
3059 return ret;
3060 }
3061
3062
3063 static void nl80211_copy_auth_params(struct wpa_driver_nl80211_data *drv,
3064 struct wpa_driver_auth_params *params)
3065 {
3066 int i;
3067
3068 drv->auth_freq = params->freq;
3069 drv->auth_alg = params->auth_alg;
3070 drv->auth_wep_tx_keyidx = params->wep_tx_keyidx;
3071 drv->auth_local_state_change = params->local_state_change;
3072 drv->auth_p2p = params->p2p;
3073
3074 if (params->bssid)
3075 os_memcpy(drv->auth_bssid_, params->bssid, ETH_ALEN);
3076 else
3077 os_memset(drv->auth_bssid_, 0, ETH_ALEN);
3078
3079 if (params->ssid) {
3080 os_memcpy(drv->auth_ssid, params->ssid, params->ssid_len);
3081 drv->auth_ssid_len = params->ssid_len;
3082 } else
3083 drv->auth_ssid_len = 0;
3084
3085
3086 os_free(drv->auth_ie);
3087 drv->auth_ie = NULL;
3088 drv->auth_ie_len = 0;
3089 if (params->ie) {
3090 drv->auth_ie = os_malloc(params->ie_len);
3091 if (drv->auth_ie) {
3092 os_memcpy(drv->auth_ie, params->ie, params->ie_len);
3093 drv->auth_ie_len = params->ie_len;
3094 }
3095 }
3096
3097 for (i = 0; i < 4; i++) {
3098 if (params->wep_key[i] && params->wep_key_len[i] &&
3099 params->wep_key_len[i] <= 16) {
3100 os_memcpy(drv->auth_wep_key[i], params->wep_key[i],
3101 params->wep_key_len[i]);
3102 drv->auth_wep_key_len[i] = params->wep_key_len[i];
3103 } else
3104 drv->auth_wep_key_len[i] = 0;
3105 }
3106 }
3107
3108
3109 static void nl80211_unmask_11b_rates(struct i802_bss *bss)
3110 {
3111 struct wpa_driver_nl80211_data *drv = bss->drv;
3112
3113 if (is_p2p_net_interface(drv->nlmode) || !drv->disabled_11b_rates)
3114 return;
3115
3116 /*
3117 * Looks like we failed to unmask 11b rates previously. This could
3118 * happen, e.g., if the interface was down at the point in time when a
3119 * P2P group was terminated.
3120 */
3121 wpa_printf(MSG_DEBUG,
3122 "nl80211: Interface %s mode is for non-P2P, but 11b rates were disabled - re-enable them",
3123 bss->ifname);
3124 nl80211_disable_11b_rates(drv, drv->ifindex, 0);
3125 }
3126
3127
3128 static int wpa_driver_nl80211_authenticate(
3129 struct i802_bss *bss, struct wpa_driver_auth_params *params)
3130 {
3131 struct wpa_driver_nl80211_data *drv = bss->drv;
3132 int ret = -1, i;
3133 struct nl_msg *msg;
3134 enum nl80211_auth_type type;
3135 enum nl80211_iftype nlmode;
3136 int count = 0;
3137 int is_retry;
3138
3139 nl80211_unmask_11b_rates(bss);
3140
3141 is_retry = drv->retry_auth;
3142 drv->retry_auth = 0;
3143 drv->ignore_deauth_event = 0;
3144
3145 nl80211_mark_disconnected(drv);
3146 os_memset(drv->auth_bssid, 0, ETH_ALEN);
3147 if (params->bssid)
3148 os_memcpy(drv->auth_attempt_bssid, params->bssid, ETH_ALEN);
3149 else
3150 os_memset(drv->auth_attempt_bssid, 0, ETH_ALEN);
3151 /* FIX: IBSS mode */
3152 nlmode = params->p2p ?
3153 NL80211_IFTYPE_P2P_CLIENT : NL80211_IFTYPE_STATION;
3154 if (drv->nlmode != nlmode &&
3155 wpa_driver_nl80211_set_mode(bss, nlmode) < 0)
3156 return -1;
3157
3158 retry:
3159 wpa_printf(MSG_DEBUG, "nl80211: Authenticate (ifindex=%d)",
3160 drv->ifindex);
3161
3162 msg = nl80211_drv_msg(drv, 0, NL80211_CMD_AUTHENTICATE);
3163 if (!msg)
3164 goto fail;
3165
3166 for (i = 0; i < 4; i++) {
3167 if (!params->wep_key[i])
3168 continue;
3169 wpa_driver_nl80211_set_key(bss->ifname, bss, WPA_ALG_WEP,
3170 NULL, i,
3171 i == params->wep_tx_keyidx, NULL, 0,
3172 params->wep_key[i],
3173 params->wep_key_len[i]);
3174 if (params->wep_tx_keyidx != i)
3175 continue;
3176 if (nl_add_key(msg, WPA_ALG_WEP, i, 1, NULL, 0,
3177 params->wep_key[i], params->wep_key_len[i]))
3178 goto fail;
3179 }
3180
3181 if (params->bssid) {
3182 wpa_printf(MSG_DEBUG, " * bssid=" MACSTR,
3183 MAC2STR(params->bssid));
3184 if (nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, params->bssid))
3185 goto fail;
3186 }
3187 if (params->freq) {
3188 wpa_printf(MSG_DEBUG, " * freq=%d", params->freq);
3189 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, params->freq))
3190 goto fail;
3191 }
3192 if (params->ssid) {
3193 wpa_hexdump_ascii(MSG_DEBUG, " * SSID",
3194 params->ssid, params->ssid_len);
3195 if (nla_put(msg, NL80211_ATTR_SSID, params->ssid_len,
3196 params->ssid))
3197 goto fail;
3198 }
3199 wpa_hexdump(MSG_DEBUG, " * IEs", params->ie, params->ie_len);
3200 if (params->ie &&
3201 nla_put(msg, NL80211_ATTR_IE, params->ie_len, params->ie))
3202 goto fail;
3203 if (params->auth_data) {
3204 wpa_hexdump(MSG_DEBUG, " * auth_data", params->auth_data,
3205 params->auth_data_len);
3206 if (nla_put(msg, NL80211_ATTR_SAE_DATA, params->auth_data_len,
3207 params->auth_data))
3208 goto fail;
3209 }
3210 if (params->auth_alg & WPA_AUTH_ALG_OPEN)
3211 type = NL80211_AUTHTYPE_OPEN_SYSTEM;
3212 else if (params->auth_alg & WPA_AUTH_ALG_SHARED)
3213 type = NL80211_AUTHTYPE_SHARED_KEY;
3214 else if (params->auth_alg & WPA_AUTH_ALG_LEAP)
3215 type = NL80211_AUTHTYPE_NETWORK_EAP;
3216 else if (params->auth_alg & WPA_AUTH_ALG_FT)
3217 type = NL80211_AUTHTYPE_FT;
3218 else if (params->auth_alg & WPA_AUTH_ALG_SAE)
3219 type = NL80211_AUTHTYPE_SAE;
3220 else if (params->auth_alg & WPA_AUTH_ALG_FILS)
3221 type = NL80211_AUTHTYPE_FILS_SK;
3222 else if (params->auth_alg & WPA_AUTH_ALG_FILS_SK_PFS)
3223 type = NL80211_AUTHTYPE_FILS_SK_PFS;
3224 else
3225 goto fail;
3226 wpa_printf(MSG_DEBUG, " * Auth Type %d", type);
3227 if (nla_put_u32(msg, NL80211_ATTR_AUTH_TYPE, type))
3228 goto fail;
3229 if (params->local_state_change) {
3230 wpa_printf(MSG_DEBUG, " * Local state change only");
3231 if (nla_put_flag(msg, NL80211_ATTR_LOCAL_STATE_CHANGE))
3232 goto fail;
3233 }
3234
3235 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
3236 msg = NULL;
3237 if (ret) {
3238 wpa_dbg(drv->ctx, MSG_DEBUG,
3239 "nl80211: MLME command failed (auth): ret=%d (%s)",
3240 ret, strerror(-ret));
3241 count++;
3242 if (ret == -EALREADY && count == 1 && params->bssid &&
3243 !params->local_state_change) {
3244 /*
3245 * mac80211 does not currently accept new
3246 * authentication if we are already authenticated. As a
3247 * workaround, force deauthentication and try again.
3248 */
3249 wpa_printf(MSG_DEBUG, "nl80211: Retry authentication "
3250 "after forced deauthentication");
3251 drv->ignore_deauth_event = 1;
3252 wpa_driver_nl80211_deauthenticate(
3253 bss, params->bssid,
3254 WLAN_REASON_PREV_AUTH_NOT_VALID);
3255 nlmsg_free(msg);
3256 goto retry;
3257 }
3258
3259 if (ret == -ENOENT && params->freq && !is_retry) {
3260 /*
3261 * cfg80211 has likely expired the BSS entry even
3262 * though it was previously available in our internal
3263 * BSS table. To recover quickly, start a single
3264 * channel scan on the specified channel.
3265 */
3266 struct wpa_driver_scan_params scan;
3267 int freqs[2];
3268
3269 os_memset(&scan, 0, sizeof(scan));
3270 scan.num_ssids = 1;
3271 if (params->ssid) {
3272 scan.ssids[0].ssid = params->ssid;
3273 scan.ssids[0].ssid_len = params->ssid_len;
3274 }
3275 freqs[0] = params->freq;
3276 freqs[1] = 0;
3277 scan.freqs = freqs;
3278 wpa_printf(MSG_DEBUG, "nl80211: Trigger single "
3279 "channel scan to refresh cfg80211 BSS "
3280 "entry");
3281 ret = wpa_driver_nl80211_scan(bss, &scan);
3282 if (ret == 0) {
3283 nl80211_copy_auth_params(drv, params);
3284 drv->scan_for_auth = 1;
3285 }
3286 } else if (is_retry) {
3287 /*
3288 * Need to indicate this with an event since the return
3289 * value from the retry is not delivered to core code.
3290 */
3291 union wpa_event_data event;
3292 wpa_printf(MSG_DEBUG, "nl80211: Authentication retry "
3293 "failed");
3294 os_memset(&event, 0, sizeof(event));
3295 os_memcpy(event.timeout_event.addr, drv->auth_bssid_,
3296 ETH_ALEN);
3297 wpa_supplicant_event(drv->ctx, EVENT_AUTH_TIMED_OUT,
3298 &event);
3299 }
3300 } else {
3301 wpa_printf(MSG_DEBUG,
3302 "nl80211: Authentication request send successfully");
3303 }
3304
3305 fail:
3306 nlmsg_free(msg);
3307 return ret;
3308 }
3309
3310
3311 int wpa_driver_nl80211_authenticate_retry(struct wpa_driver_nl80211_data *drv)
3312 {
3313 struct wpa_driver_auth_params params;
3314 struct i802_bss *bss = drv->first_bss;
3315 int i;
3316
3317 wpa_printf(MSG_DEBUG, "nl80211: Try to authenticate again");
3318
3319 os_memset(&params, 0, sizeof(params));
3320 params.freq = drv->auth_freq;
3321 params.auth_alg = drv->auth_alg;
3322 params.wep_tx_keyidx = drv->auth_wep_tx_keyidx;
3323 params.local_state_change = drv->auth_local_state_change;
3324 params.p2p = drv->auth_p2p;
3325
3326 if (!is_zero_ether_addr(drv->auth_bssid_))
3327 params.bssid = drv->auth_bssid_;
3328
3329 if (drv->auth_ssid_len) {
3330 params.ssid = drv->auth_ssid;
3331 params.ssid_len = drv->auth_ssid_len;
3332 }
3333
3334 params.ie = drv->auth_ie;
3335 params.ie_len = drv->auth_ie_len;
3336
3337 for (i = 0; i < 4; i++) {
3338 if (drv->auth_wep_key_len[i]) {
3339 params.wep_key[i] = drv->auth_wep_key[i];
3340 params.wep_key_len[i] = drv->auth_wep_key_len[i];
3341 }
3342 }
3343
3344 drv->retry_auth = 1;
3345 return wpa_driver_nl80211_authenticate(bss, &params);
3346 }
3347
3348
3349 static int wpa_driver_nl80211_send_frame(struct i802_bss *bss,
3350 const void *data, size_t len,
3351 int encrypt, int noack,
3352 unsigned int freq, int no_cck,
3353 int offchanok, unsigned int wait_time,
3354 const u16 *csa_offs,
3355 size_t csa_offs_len)
3356 {
3357 struct wpa_driver_nl80211_data *drv = bss->drv;
3358 u64 cookie;
3359 int res;
3360
3361 if (freq == 0 && drv->nlmode == NL80211_IFTYPE_ADHOC) {
3362 freq = nl80211_get_assoc_freq(drv);
3363 wpa_printf(MSG_DEBUG,
3364 "nl80211: send_frame - Use assoc_freq=%u for IBSS",
3365 freq);
3366 }
3367 if (freq == 0) {
3368 wpa_printf(MSG_DEBUG, "nl80211: send_frame - Use bss->freq=%u",
3369 bss->freq);
3370 freq = bss->freq;
3371 }
3372
3373 if (drv->use_monitor) {
3374 wpa_printf(MSG_DEBUG, "nl80211: send_frame(freq=%u bss->freq=%u) -> send_monitor",
3375 freq, bss->freq);
3376 return nl80211_send_monitor(drv, data, len, encrypt, noack);
3377 }
3378
3379 wpa_printf(MSG_DEBUG, "nl80211: send_frame -> send_frame_cmd");
3380 res = nl80211_send_frame_cmd(bss, freq, wait_time, data, len,
3381 &cookie, no_cck, noack, offchanok,
3382 csa_offs, csa_offs_len);
3383 if (res == 0 && !noack) {
3384 const struct ieee80211_mgmt *mgmt;
3385 u16 fc;
3386
3387 mgmt = (const struct ieee80211_mgmt *) data;
3388 fc = le_to_host16(mgmt->frame_control);
3389 if (WLAN_FC_GET_TYPE(fc) == WLAN_FC_TYPE_MGMT &&
3390 WLAN_FC_GET_STYPE(fc) == WLAN_FC_STYPE_ACTION) {
3391 wpa_printf(MSG_MSGDUMP,
3392 "nl80211: Update send_action_cookie from 0x%llx to 0x%llx",
3393 (long long unsigned int)
3394 drv->send_action_cookie,
3395 (long long unsigned int) cookie);
3396 drv->send_action_cookie = cookie;
3397 }
3398 }
3399
3400 return res;
3401 }
3402
3403
3404 static int wpa_driver_nl80211_send_mlme(struct i802_bss *bss, const u8 *data,
3405 size_t data_len, int noack,
3406 unsigned int freq, int no_cck,
3407 int offchanok,
3408 unsigned int wait_time,
3409 const u16 *csa_offs,
3410 size_t csa_offs_len)
3411 {
3412 struct wpa_driver_nl80211_data *drv = bss->drv;
3413 struct ieee80211_mgmt *mgmt;
3414 int encrypt = 1;
3415 u16 fc;
3416
3417 mgmt = (struct ieee80211_mgmt *) data;
3418 fc = le_to_host16(mgmt->frame_control);
3419 wpa_printf(MSG_DEBUG, "nl80211: send_mlme - da= " MACSTR
3420 " noack=%d freq=%u no_cck=%d offchanok=%d wait_time=%u fc=0x%x (%s) nlmode=%d",
3421 MAC2STR(mgmt->da), noack, freq, no_cck, offchanok, wait_time,
3422 fc, fc2str(fc), drv->nlmode);
3423
3424 if ((is_sta_interface(drv->nlmode) ||
3425 drv->nlmode == NL80211_IFTYPE_P2P_DEVICE) &&
3426 WLAN_FC_GET_TYPE(fc) == WLAN_FC_TYPE_MGMT &&
3427 WLAN_FC_GET_STYPE(fc) == WLAN_FC_STYPE_PROBE_RESP) {
3428 /*
3429 * The use of last_mgmt_freq is a bit of a hack,
3430 * but it works due to the single-threaded nature
3431 * of wpa_supplicant.
3432 */
3433 if (freq == 0) {
3434 wpa_printf(MSG_DEBUG, "nl80211: Use last_mgmt_freq=%d",
3435 drv->last_mgmt_freq);
3436 freq = drv->last_mgmt_freq;
3437 }
3438 return nl80211_send_frame_cmd(bss, freq, 0,
3439 data, data_len, NULL, 1, noack,
3440 1, csa_offs, csa_offs_len);
3441 }
3442
3443 if (drv->device_ap_sme && is_ap_interface(drv->nlmode)) {
3444 if (freq == 0) {
3445 wpa_printf(MSG_DEBUG, "nl80211: Use bss->freq=%d",
3446 bss->freq);
3447 freq = bss->freq;
3448 }
3449 return nl80211_send_frame_cmd(bss, freq,
3450 (int) freq == bss->freq ? 0 :
3451 wait_time,
3452 data, data_len,
3453 &drv->send_action_cookie,
3454 no_cck, noack, offchanok,
3455 csa_offs, csa_offs_len);
3456 }
3457
3458 if (WLAN_FC_GET_TYPE(fc) == WLAN_FC_TYPE_MGMT &&
3459 WLAN_FC_GET_STYPE(fc) == WLAN_FC_STYPE_AUTH) {
3460 /*
3461 * Only one of the authentication frame types is encrypted.
3462 * In order for static WEP encryption to work properly (i.e.,
3463 * to not encrypt the frame), we need to tell mac80211 about
3464 * the frames that must not be encrypted.
3465 */
3466 u16 auth_alg = le_to_host16(mgmt->u.auth.auth_alg);
3467 u16 auth_trans = le_to_host16(mgmt->u.auth.auth_transaction);
3468 if (auth_alg != WLAN_AUTH_SHARED_KEY || auth_trans != 3)
3469 encrypt = 0;
3470 }
3471
3472 wpa_printf(MSG_DEBUG, "nl80211: send_mlme -> send_frame");
3473 return wpa_driver_nl80211_send_frame(bss, data, data_len, encrypt,
3474 noack, freq, no_cck, offchanok,
3475 wait_time, csa_offs,
3476 csa_offs_len);
3477 }
3478
3479
3480 static int nl80211_put_basic_rates(struct nl_msg *msg, const int *basic_rates)
3481 {
3482 u8 rates[NL80211_MAX_SUPP_RATES];
3483 u8 rates_len = 0;
3484 int i;
3485
3486 if (!basic_rates)
3487 return 0;
3488
3489 for (i = 0; i < NL80211_MAX_SUPP_RATES && basic_rates[i] >= 0; i++)
3490 rates[rates_len++] = basic_rates[i] / 5;
3491
3492 return nla_put(msg, NL80211_ATTR_BSS_BASIC_RATES, rates_len, rates);
3493 }
3494
3495
3496 static int nl80211_set_bss(struct i802_bss *bss, int cts, int preamble,
3497 int slot, int ht_opmode, int ap_isolate,
3498 const int *basic_rates)
3499 {
3500 struct wpa_driver_nl80211_data *drv = bss->drv;
3501 struct nl_msg *msg;
3502
3503 if (!(msg = nl80211_bss_msg(bss, 0, NL80211_CMD_SET_BSS)) ||
3504 (cts >= 0 &&
3505 nla_put_u8(msg, NL80211_ATTR_BSS_CTS_PROT, cts)) ||
3506 (preamble >= 0 &&
3507 nla_put_u8(msg, NL80211_ATTR_BSS_SHORT_PREAMBLE, preamble)) ||
3508 (slot >= 0 &&
3509 nla_put_u8(msg, NL80211_ATTR_BSS_SHORT_SLOT_TIME, slot)) ||
3510 (ht_opmode >= 0 &&
3511 nla_put_u16(msg, NL80211_ATTR_BSS_HT_OPMODE, ht_opmode)) ||
3512 (ap_isolate >= 0 &&
3513 nla_put_u8(msg, NL80211_ATTR_AP_ISOLATE, ap_isolate)) ||
3514 nl80211_put_basic_rates(msg, basic_rates)) {
3515 nlmsg_free(msg);
3516 return -ENOBUFS;
3517 }
3518
3519 return send_and_recv_msgs(drv, msg, NULL, NULL);
3520 }
3521
3522
3523 static int wpa_driver_nl80211_set_acl(void *priv,
3524 struct hostapd_acl_params *params)
3525 {
3526 struct i802_bss *bss = priv;
3527 struct wpa_driver_nl80211_data *drv = bss->drv;
3528 struct nl_msg *msg;
3529 struct nl_msg *acl;
3530 unsigned int i;
3531 int ret;
3532
3533 if (!(drv->capa.max_acl_mac_addrs))
3534 return -ENOTSUP;
3535
3536 if (params->num_mac_acl > drv->capa.max_acl_mac_addrs)
3537 return -ENOTSUP;
3538
3539 wpa_printf(MSG_DEBUG, "nl80211: Set %s ACL (num_mac_acl=%u)",
3540 params->acl_policy ? "Accept" : "Deny", params->num_mac_acl);
3541
3542 acl = nlmsg_alloc();
3543 if (!acl)
3544 return -ENOMEM;
3545 for (i = 0; i < params->num_mac_acl; i++) {
3546 if (nla_put(acl, i + 1, ETH_ALEN, params->mac_acl[i].addr)) {
3547 nlmsg_free(acl);
3548 return -ENOMEM;
3549 }
3550 }
3551
3552 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_SET_MAC_ACL)) ||
3553 nla_put_u32(msg, NL80211_ATTR_ACL_POLICY, params->acl_policy ?
3554 NL80211_ACL_POLICY_DENY_UNLESS_LISTED :
3555 NL80211_ACL_POLICY_ACCEPT_UNLESS_LISTED) ||
3556 nla_put_nested(msg, NL80211_ATTR_MAC_ADDRS, acl)) {
3557 nlmsg_free(msg);
3558 nlmsg_free(acl);
3559 return -ENOMEM;
3560 }
3561 nlmsg_free(acl);
3562
3563 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
3564 if (ret) {
3565 wpa_printf(MSG_DEBUG, "nl80211: Failed to set MAC ACL: %d (%s)",
3566 ret, strerror(-ret));
3567 }
3568
3569 return ret;
3570 }
3571
3572
3573 static int nl80211_put_beacon_int(struct nl_msg *msg, int beacon_int)
3574 {
3575 if (beacon_int > 0) {
3576 wpa_printf(MSG_DEBUG, " * beacon_int=%d", beacon_int);
3577 return nla_put_u32(msg, NL80211_ATTR_BEACON_INTERVAL,
3578 beacon_int);
3579 }
3580
3581 return 0;
3582 }
3583
3584
3585 static int nl80211_put_dtim_period(struct nl_msg *msg, int dtim_period)
3586 {
3587 if (dtim_period > 0) {
3588 wpa_printf(MSG_DEBUG, " * dtim_period=%d", dtim_period);
3589 return nla_put_u32(msg, NL80211_ATTR_DTIM_PERIOD, dtim_period);
3590 }
3591
3592 return 0;
3593 }
3594
3595
3596 #ifdef CONFIG_MESH
3597 static int nl80211_set_mesh_config(void *priv,
3598 struct wpa_driver_mesh_bss_params *params)
3599 {
3600 struct i802_bss *bss = priv;
3601 struct wpa_driver_nl80211_data *drv = bss->drv;
3602 struct nl_msg *msg;
3603 int ret;
3604
3605 msg = nl80211_drv_msg(drv, 0, NL80211_CMD_SET_MESH_CONFIG);
3606 if (!msg)
3607 return -1;
3608
3609 ret = nl80211_put_mesh_config(msg, params);
3610 if (ret < 0) {
3611 nlmsg_free(msg);
3612 return ret;
3613 }
3614
3615 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
3616 if (ret) {
3617 wpa_printf(MSG_ERROR,
3618 "nl80211: Mesh config set failed: %d (%s)",
3619 ret, strerror(-ret));
3620 return ret;
3621 }
3622 return 0;
3623 }
3624 #endif /* CONFIG_MESH */
3625
3626
3627 static int nl80211_put_beacon_rate(struct nl_msg *msg, const u64 flags,
3628 struct wpa_driver_ap_params *params)
3629 {
3630 struct nlattr *bands, *band;
3631 struct nl80211_txrate_vht vht_rate;
3632
3633 if (!params->freq ||
3634 (params->beacon_rate == 0 &&
3635 params->rate_type == BEACON_RATE_LEGACY))
3636 return 0;
3637
3638 bands = nla_nest_start(msg, NL80211_ATTR_TX_RATES);
3639 if (!bands)
3640 return -1;
3641
3642 switch (params->freq->mode) {
3643 case HOSTAPD_MODE_IEEE80211B:
3644 case HOSTAPD_MODE_IEEE80211G:
3645 band = nla_nest_start(msg, NL80211_BAND_2GHZ);
3646 break;
3647 case HOSTAPD_MODE_IEEE80211A:
3648 band = nla_nest_start(msg, NL80211_BAND_5GHZ);
3649 break;
3650 case HOSTAPD_MODE_IEEE80211AD:
3651 band = nla_nest_start(msg, NL80211_BAND_60GHZ);
3652 break;
3653 default:
3654 return 0;
3655 }
3656
3657 if (!band)
3658 return -1;
3659
3660 os_memset(&vht_rate, 0, sizeof(vht_rate));
3661
3662 switch (params->rate_type) {
3663 case BEACON_RATE_LEGACY:
3664 if (!(flags & WPA_DRIVER_FLAGS_BEACON_RATE_LEGACY)) {
3665 wpa_printf(MSG_INFO,
3666 "nl80211: Driver does not support setting Beacon frame rate (legacy)");
3667 return -1;
3668 }
3669
3670 if (nla_put_u8(msg, NL80211_TXRATE_LEGACY,
3671 (u8) params->beacon_rate / 5) ||
3672 nla_put(msg, NL80211_TXRATE_HT, 0, NULL) ||
3673 (params->freq->vht_enabled &&
3674 nla_put(msg, NL80211_TXRATE_VHT, sizeof(vht_rate),
3675 &vht_rate)))
3676 return -1;
3677
3678 wpa_printf(MSG_DEBUG, " * beacon_rate = legacy:%u (* 100 kbps)",
3679 params->beacon_rate);
3680 break;
3681 case BEACON_RATE_HT:
3682 if (!(flags & WPA_DRIVER_FLAGS_BEACON_RATE_HT)) {
3683 wpa_printf(MSG_INFO,
3684 "nl80211: Driver does not support setting Beacon frame rate (HT)");
3685 return -1;
3686 }
3687 if (nla_put(msg, NL80211_TXRATE_LEGACY, 0, NULL) ||
3688 nla_put_u8(msg, NL80211_TXRATE_HT, params->beacon_rate) ||
3689 (params->freq->vht_enabled &&
3690 nla_put(msg, NL80211_TXRATE_VHT, sizeof(vht_rate),
3691 &vht_rate)))
3692 return -1;
3693 wpa_printf(MSG_DEBUG, " * beacon_rate = HT-MCS %u",
3694 params->beacon_rate);
3695 break;
3696 case BEACON_RATE_VHT:
3697 if (!(flags & WPA_DRIVER_FLAGS_BEACON_RATE_VHT)) {
3698 wpa_printf(MSG_INFO,
3699 "nl80211: Driver does not support setting Beacon frame rate (VHT)");
3700 return -1;
3701 }
3702 vht_rate.mcs[0] = BIT(params->beacon_rate);
3703 if (nla_put(msg, NL80211_TXRATE_LEGACY, 0, NULL))
3704 return -1;
3705 if (nla_put(msg, NL80211_TXRATE_HT, 0, NULL))
3706 return -1;
3707 if (nla_put(msg, NL80211_TXRATE_VHT, sizeof(vht_rate),
3708 &vht_rate))
3709 return -1;
3710 wpa_printf(MSG_DEBUG, " * beacon_rate = VHT-MCS %u",
3711 params->beacon_rate);
3712 break;
3713 }
3714
3715 nla_nest_end(msg, band);
3716 nla_nest_end(msg, bands);
3717
3718 return 0;
3719 }
3720
3721
3722 static int nl80211_set_multicast_to_unicast(struct i802_bss *bss,
3723 int multicast_to_unicast)
3724 {
3725 struct wpa_driver_nl80211_data *drv = bss->drv;
3726 struct nl_msg *msg;
3727 int ret;
3728
3729 msg = nl80211_bss_msg(bss, 0, NL80211_CMD_SET_MULTICAST_TO_UNICAST);
3730 if (!msg ||
3731 (multicast_to_unicast &&
3732 nla_put_flag(msg, NL80211_ATTR_MULTICAST_TO_UNICAST_ENABLED))) {
3733 wpa_printf(MSG_ERROR,
3734 "nl80211: Failed to build NL80211_CMD_SET_MULTICAST_TO_UNICAST msg for %s",
3735 bss->ifname);
3736 nlmsg_free(msg);
3737 return -ENOBUFS;
3738 }
3739
3740 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
3741
3742 switch (ret) {
3743 case 0:
3744 wpa_printf(MSG_DEBUG,
3745 "nl80211: multicast to unicast %s on interface %s",
3746 multicast_to_unicast ? "enabled" : "disabled",
3747 bss->ifname);
3748 break;
3749 case -EOPNOTSUPP:
3750 if (!multicast_to_unicast)
3751 break;
3752 wpa_printf(MSG_INFO,
3753 "nl80211: multicast to unicast not supported on interface %s",
3754 bss->ifname);
3755 break;
3756 default:
3757 wpa_printf(MSG_ERROR,
3758 "nl80211: %s multicast to unicast failed with %d (%s) on interface %s",
3759 multicast_to_unicast ? "enabling" : "disabling",
3760 ret, strerror(-ret), bss->ifname);
3761 break;
3762 }
3763
3764 return ret;
3765 }
3766
3767
3768 static int wpa_driver_nl80211_set_ap(void *priv,
3769 struct wpa_driver_ap_params *params)
3770 {
3771 struct i802_bss *bss = priv;
3772 struct wpa_driver_nl80211_data *drv = bss->drv;
3773 struct nl_msg *msg;
3774 u8 cmd = NL80211_CMD_NEW_BEACON;
3775 int ret;
3776 int beacon_set;
3777 int num_suites;
3778 int smps_mode;
3779 u32 suites[10], suite;
3780 u32 ver;
3781 #ifdef CONFIG_MESH
3782 struct wpa_driver_mesh_bss_params mesh_params;
3783 #endif /* CONFIG_MESH */
3784
3785 beacon_set = params->reenable ? 0 : bss->beacon_set;
3786
3787 wpa_printf(MSG_DEBUG, "nl80211: Set beacon (beacon_set=%d)",
3788 beacon_set);
3789 if (beacon_set)
3790 cmd = NL80211_CMD_SET_BEACON;
3791 else if (!drv->device_ap_sme && !drv->use_monitor &&
3792 !nl80211_get_wiphy_data_ap(bss))
3793 return -ENOBUFS;
3794
3795 wpa_hexdump(MSG_DEBUG, "nl80211: Beacon head",
3796 params->head, params->head_len);
3797 wpa_hexdump(MSG_DEBUG, "nl80211: Beacon tail",
3798 params->tail, params->tail_len);
3799 wpa_printf(MSG_DEBUG, "nl80211: ifindex=%d", bss->ifindex);
3800 wpa_printf(MSG_DEBUG, "nl80211: beacon_int=%d", params->beacon_int);
3801 wpa_printf(MSG_DEBUG, "nl80211: beacon_rate=%u", params->beacon_rate);
3802 wpa_printf(MSG_DEBUG, "nl80211: rate_type=%d", params->rate_type);
3803 wpa_printf(MSG_DEBUG, "nl80211: dtim_period=%d", params->dtim_period);
3804 wpa_hexdump_ascii(MSG_DEBUG, "nl80211: ssid",
3805 params->ssid, params->ssid_len);
3806 if (!(msg = nl80211_bss_msg(bss, 0, cmd)) ||
3807 nla_put(msg, NL80211_ATTR_BEACON_HEAD, params->head_len,
3808 params->head) ||
3809 nla_put(msg, NL80211_ATTR_BEACON_TAIL, params->tail_len,
3810 params->tail) ||
3811 nl80211_put_beacon_int(msg, params->beacon_int) ||
3812 nl80211_put_beacon_rate(msg, drv->capa.flags, params) ||
3813 nl80211_put_dtim_period(msg, params->dtim_period) ||
3814 nla_put(msg, NL80211_ATTR_SSID, params->ssid_len, params->ssid))
3815 goto fail;
3816 if (params->proberesp && params->proberesp_len) {
3817 wpa_hexdump(MSG_DEBUG, "nl80211: proberesp (offload)",
3818 params->proberesp, params->proberesp_len);
3819 if (nla_put(msg, NL80211_ATTR_PROBE_RESP, params->proberesp_len,
3820 params->proberesp))
3821 goto fail;
3822 }
3823 switch (params->hide_ssid) {
3824 case NO_SSID_HIDING:
3825 wpa_printf(MSG_DEBUG, "nl80211: hidden SSID not in use");
3826 if (nla_put_u32(msg, NL80211_ATTR_HIDDEN_SSID,
3827 NL80211_HIDDEN_SSID_NOT_IN_USE))
3828 goto fail;
3829 break;
3830 case HIDDEN_SSID_ZERO_LEN:
3831 wpa_printf(MSG_DEBUG, "nl80211: hidden SSID zero len");
3832 if (nla_put_u32(msg, NL80211_ATTR_HIDDEN_SSID,
3833 NL80211_HIDDEN_SSID_ZERO_LEN))
3834 goto fail;
3835 break;
3836 case HIDDEN_SSID_ZERO_CONTENTS:
3837 wpa_printf(MSG_DEBUG, "nl80211: hidden SSID zero contents");
3838 if (nla_put_u32(msg, NL80211_ATTR_HIDDEN_SSID,
3839 NL80211_HIDDEN_SSID_ZERO_CONTENTS))
3840 goto fail;
3841 break;
3842 }
3843 wpa_printf(MSG_DEBUG, "nl80211: privacy=%d", params->privacy);
3844 if (params->privacy &&
3845 nla_put_flag(msg, NL80211_ATTR_PRIVACY))
3846 goto fail;
3847 wpa_printf(MSG_DEBUG, "nl80211: auth_algs=0x%x", params->auth_algs);
3848 if ((params->auth_algs & (WPA_AUTH_ALG_OPEN | WPA_AUTH_ALG_SHARED)) ==
3849 (WPA_AUTH_ALG_OPEN | WPA_AUTH_ALG_SHARED)) {
3850 /* Leave out the attribute */
3851 } else if (params->auth_algs & WPA_AUTH_ALG_SHARED) {
3852 if (nla_put_u32(msg, NL80211_ATTR_AUTH_TYPE,
3853 NL80211_AUTHTYPE_SHARED_KEY))
3854 goto fail;
3855 } else {
3856 if (nla_put_u32(msg, NL80211_ATTR_AUTH_TYPE,
3857 NL80211_AUTHTYPE_OPEN_SYSTEM))
3858 goto fail;
3859 }
3860
3861 wpa_printf(MSG_DEBUG, "nl80211: wpa_version=0x%x", params->wpa_version);
3862 ver = 0;
3863 if (params->wpa_version & WPA_PROTO_WPA)
3864 ver |= NL80211_WPA_VERSION_1;
3865 if (params->wpa_version & WPA_PROTO_RSN)
3866 ver |= NL80211_WPA_VERSION_2;
3867 if (ver &&
3868 nla_put_u32(msg, NL80211_ATTR_WPA_VERSIONS, ver))
3869 goto fail;
3870
3871 wpa_printf(MSG_DEBUG, "nl80211: key_mgmt_suites=0x%x",
3872 params->key_mgmt_suites);
3873 num_suites = 0;
3874 if (params->key_mgmt_suites & WPA_KEY_MGMT_IEEE8021X)
3875 suites[num_suites++] = RSN_AUTH_KEY_MGMT_UNSPEC_802_1X;
3876 if (params->key_mgmt_suites & WPA_KEY_MGMT_PSK)
3877 suites[num_suites++] = RSN_AUTH_KEY_MGMT_PSK_OVER_802_1X;
3878 if (num_suites &&
3879 nla_put(msg, NL80211_ATTR_AKM_SUITES, num_suites * sizeof(u32),
3880 suites))
3881 goto fail;
3882
3883 if (params->key_mgmt_suites & WPA_KEY_MGMT_IEEE8021X_NO_WPA &&
3884 (!params->pairwise_ciphers ||
3885 params->pairwise_ciphers & (WPA_CIPHER_WEP104 | WPA_CIPHER_WEP40)) &&
3886 (nla_put_u16(msg, NL80211_ATTR_CONTROL_PORT_ETHERTYPE, ETH_P_PAE) ||
3887 nla_put_flag(msg, NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT)))
3888 goto fail;
3889
3890 wpa_printf(MSG_DEBUG, "nl80211: pairwise_ciphers=0x%x",
3891 params->pairwise_ciphers);
3892 num_suites = wpa_cipher_to_cipher_suites(params->pairwise_ciphers,
3893 suites, ARRAY_SIZE(suites));
3894 if (num_suites &&
3895 nla_put(msg, NL80211_ATTR_CIPHER_SUITES_PAIRWISE,
3896 num_suites * sizeof(u32), suites))
3897 goto fail;
3898
3899 wpa_printf(MSG_DEBUG, "nl80211: group_cipher=0x%x",
3900 params->group_cipher);
3901 suite = wpa_cipher_to_cipher_suite(params->group_cipher);
3902 if (suite &&
3903 nla_put_u32(msg, NL80211_ATTR_CIPHER_SUITE_GROUP, suite))
3904 goto fail;
3905
3906 if (params->ht_opmode != -1) {
3907 switch (params->smps_mode) {
3908 case HT_CAP_INFO_SMPS_DYNAMIC:
3909 wpa_printf(MSG_DEBUG, "nl80211: SMPS mode - dynamic");
3910 smps_mode = NL80211_SMPS_DYNAMIC;
3911 break;
3912 case HT_CAP_INFO_SMPS_STATIC:
3913 wpa_printf(MSG_DEBUG, "nl80211: SMPS mode - static");
3914 smps_mode = NL80211_SMPS_STATIC;
3915 break;
3916 default:
3917 /* invalid - fallback to smps off */
3918 case HT_CAP_INFO_SMPS_DISABLED:
3919 wpa_printf(MSG_DEBUG, "nl80211: SMPS mode - off");
3920 smps_mode = NL80211_SMPS_OFF;
3921 break;
3922 }
3923 if (nla_put_u32(msg, NL80211_ATTR_SMPS_MODE, smps_mode))
3924 goto fail;
3925 }
3926
3927 if (params->beacon_ies) {
3928 wpa_hexdump_buf(MSG_DEBUG, "nl80211: beacon_ies",
3929 params->beacon_ies);
3930 if (nla_put(msg, NL80211_ATTR_IE,
3931 wpabuf_len(params->beacon_ies),
3932 wpabuf_head(params->beacon_ies)))
3933 goto fail;
3934 }
3935 if (params->proberesp_ies) {
3936 wpa_hexdump_buf(MSG_DEBUG, "nl80211: proberesp_ies",
3937 params->proberesp_ies);
3938 if (nla_put(msg, NL80211_ATTR_IE_PROBE_RESP,
3939 wpabuf_len(params->proberesp_ies),
3940 wpabuf_head(params->proberesp_ies)))
3941 goto fail;
3942 }
3943 if (params->assocresp_ies) {
3944 wpa_hexdump_buf(MSG_DEBUG, "nl80211: assocresp_ies",
3945 params->assocresp_ies);
3946 if (nla_put(msg, NL80211_ATTR_IE_ASSOC_RESP,
3947 wpabuf_len(params->assocresp_ies),
3948 wpabuf_head(params->assocresp_ies)))
3949 goto fail;
3950 }
3951
3952 if (drv->capa.flags & WPA_DRIVER_FLAGS_INACTIVITY_TIMER) {
3953 wpa_printf(MSG_DEBUG, "nl80211: ap_max_inactivity=%d",
3954 params->ap_max_inactivity);
3955 if (nla_put_u16(msg, NL80211_ATTR_INACTIVITY_TIMEOUT,
3956 params->ap_max_inactivity))
3957 goto fail;
3958 }
3959
3960 #ifdef CONFIG_P2P
3961 if (params->p2p_go_ctwindow > 0) {
3962 if (drv->p2p_go_ctwindow_supported) {
3963 wpa_printf(MSG_DEBUG, "nl80211: P2P GO ctwindow=%d",
3964 params->p2p_go_ctwindow);
3965 if (nla_put_u8(msg, NL80211_ATTR_P2P_CTWINDOW,
3966 params->p2p_go_ctwindow))
3967 goto fail;
3968 } else {
3969 wpa_printf(MSG_INFO,
3970 "nl80211: Driver does not support CTWindow configuration - ignore this parameter");
3971 }
3972 }
3973 #endif /* CONFIG_P2P */
3974
3975 if (params->pbss) {
3976 wpa_printf(MSG_DEBUG, "nl80211: PBSS");
3977 if (nla_put_flag(msg, NL80211_ATTR_PBSS))
3978 goto fail;
3979 }
3980
3981 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
3982 if (ret) {
3983 wpa_printf(MSG_DEBUG, "nl80211: Beacon set failed: %d (%s)",
3984 ret, strerror(-ret));
3985 } else {
3986 bss->beacon_set = 1;
3987 nl80211_set_bss(bss, params->cts_protect, params->preamble,
3988 params->short_slot_time, params->ht_opmode,
3989 params->isolate, params->basic_rates);
3990 nl80211_set_multicast_to_unicast(bss,
3991 params->multicast_to_unicast);
3992 if (beacon_set && params->freq &&
3993 params->freq->bandwidth != bss->bandwidth) {
3994 wpa_printf(MSG_DEBUG,
3995 "nl80211: Update BSS %s bandwidth: %d -> %d",
3996 bss->ifname, bss->bandwidth,
3997 params->freq->bandwidth);
3998 ret = nl80211_set_channel(bss, params->freq, 1);
3999 if (ret) {
4000 wpa_printf(MSG_DEBUG,
4001 "nl80211: Frequency set failed: %d (%s)",
4002 ret, strerror(-ret));
4003 } else {
4004 wpa_printf(MSG_DEBUG,
4005 "nl80211: Frequency set succeeded for ht2040 coex");
4006 bss->bandwidth = params->freq->bandwidth;
4007 }
4008 } else if (!beacon_set && params->freq) {
4009 /*
4010 * cfg80211 updates the driver on frequence change in AP
4011 * mode only at the point when beaconing is started, so
4012 * set the initial value here.
4013 */
4014 bss->bandwidth = params->freq->bandwidth;
4015 }
4016 }
4017
4018 #ifdef CONFIG_MESH
4019 if (is_mesh_interface(drv->nlmode) && params->ht_opmode != -1) {
4020 os_memset(&mesh_params, 0, sizeof(mesh_params));
4021 mesh_params.flags |= WPA_DRIVER_MESH_CONF_FLAG_HT_OP_MODE;
4022 mesh_params.ht_opmode = params->ht_opmode;
4023 ret = nl80211_set_mesh_config(priv, &mesh_params);
4024 if (ret < 0)
4025 return ret;
4026 }
4027 #endif /* CONFIG_MESH */
4028
4029 return ret;
4030 fail:
4031 nlmsg_free(msg);
4032 return -ENOBUFS;
4033 }
4034
4035
4036 static int nl80211_put_freq_params(struct nl_msg *msg,
4037 const struct hostapd_freq_params *freq)
4038 {
4039 wpa_printf(MSG_DEBUG, " * freq=%d", freq->freq);
4040 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, freq->freq))
4041 return -ENOBUFS;
4042
4043 wpa_printf(MSG_DEBUG, " * vht_enabled=%d", freq->vht_enabled);
4044 wpa_printf(MSG_DEBUG, " * ht_enabled=%d", freq->ht_enabled);
4045
4046 if (freq->vht_enabled) {
4047 enum nl80211_chan_width cw;
4048
4049 wpa_printf(MSG_DEBUG, " * bandwidth=%d", freq->bandwidth);
4050 switch (freq->bandwidth) {
4051 case 20:
4052 cw = NL80211_CHAN_WIDTH_20;
4053 break;
4054 case 40:
4055 cw = NL80211_CHAN_WIDTH_40;
4056 break;
4057 case 80:
4058 if (freq->center_freq2)
4059 cw = NL80211_CHAN_WIDTH_80P80;
4060 else
4061 cw = NL80211_CHAN_WIDTH_80;
4062 break;
4063 case 160:
4064 cw = NL80211_CHAN_WIDTH_160;
4065 break;
4066 default:
4067 return -EINVAL;
4068 }
4069
4070 wpa_printf(MSG_DEBUG, " * channel_width=%d", cw);
4071 wpa_printf(MSG_DEBUG, " * center_freq1=%d",
4072 freq->center_freq1);
4073 wpa_printf(MSG_DEBUG, " * center_freq2=%d",
4074 freq->center_freq2);
4075 if (nla_put_u32(msg, NL80211_ATTR_CHANNEL_WIDTH, cw) ||
4076 nla_put_u32(msg, NL80211_ATTR_CENTER_FREQ1,
4077 freq->center_freq1) ||
4078 (freq->center_freq2 &&
4079 nla_put_u32(msg, NL80211_ATTR_CENTER_FREQ2,
4080 freq->center_freq2)))
4081 return -ENOBUFS;
4082 } else if (freq->ht_enabled) {
4083 enum nl80211_channel_type ct;
4084
4085 wpa_printf(MSG_DEBUG, " * sec_channel_offset=%d",
4086 freq->sec_channel_offset);
4087 switch (freq->sec_channel_offset) {
4088 case -1:
4089 ct = NL80211_CHAN_HT40MINUS;
4090 break;
4091 case 1:
4092 ct = NL80211_CHAN_HT40PLUS;
4093 break;
4094 default:
4095 ct = NL80211_CHAN_HT20;
4096 break;
4097 }
4098
4099 wpa_printf(MSG_DEBUG, " * channel_type=%d", ct);
4100 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE, ct))
4101 return -ENOBUFS;
4102 } else {
4103 wpa_printf(MSG_DEBUG, " * channel_type=%d",
4104 NL80211_CHAN_NO_HT);
4105 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE,
4106 NL80211_CHAN_NO_HT))
4107 return -ENOBUFS;
4108 }
4109 return 0;
4110 }
4111
4112
4113 static int nl80211_set_channel(struct i802_bss *bss,
4114 struct hostapd_freq_params *freq, int set_chan)
4115 {
4116 struct wpa_driver_nl80211_data *drv = bss->drv;
4117 struct nl_msg *msg;
4118 int ret;
4119
4120 wpa_printf(MSG_DEBUG,
4121 "nl80211: Set freq %d (ht_enabled=%d, vht_enabled=%d, bandwidth=%d MHz, cf1=%d MHz, cf2=%d MHz)",
4122 freq->freq, freq->ht_enabled, freq->vht_enabled,
4123 freq->bandwidth, freq->center_freq1, freq->center_freq2);
4124
4125 msg = nl80211_drv_msg(drv, 0, set_chan ? NL80211_CMD_SET_CHANNEL :
4126 NL80211_CMD_SET_WIPHY);
4127 if (!msg || nl80211_put_freq_params(msg, freq) < 0) {
4128 nlmsg_free(msg);
4129 return -1;
4130 }
4131
4132 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
4133 if (ret == 0) {
4134 bss->freq = freq->freq;
4135 return 0;
4136 }
4137 wpa_printf(MSG_DEBUG, "nl80211: Failed to set channel (freq=%d): "
4138 "%d (%s)", freq->freq, ret, strerror(-ret));
4139 return -1;
4140 }
4141
4142
4143 static u32 sta_flags_nl80211(int flags)
4144 {
4145 u32 f = 0;
4146
4147 if (flags & WPA_STA_AUTHORIZED)
4148 f |= BIT(NL80211_STA_FLAG_AUTHORIZED);
4149 if (flags & WPA_STA_WMM)
4150 f |= BIT(NL80211_STA_FLAG_WME);
4151 if (flags & WPA_STA_SHORT_PREAMBLE)
4152 f |= BIT(NL80211_STA_FLAG_SHORT_PREAMBLE);
4153 if (flags & WPA_STA_MFP)
4154 f |= BIT(NL80211_STA_FLAG_MFP);
4155 if (flags & WPA_STA_TDLS_PEER)
4156 f |= BIT(NL80211_STA_FLAG_TDLS_PEER);
4157 if (flags & WPA_STA_AUTHENTICATED)
4158 f |= BIT(NL80211_STA_FLAG_AUTHENTICATED);
4159 if (flags & WPA_STA_ASSOCIATED)
4160 f |= BIT(NL80211_STA_FLAG_ASSOCIATED);
4161
4162 return f;
4163 }
4164
4165
4166 #ifdef CONFIG_MESH
4167 static u32 sta_plink_state_nl80211(enum mesh_plink_state state)
4168 {
4169 switch (state) {
4170 case PLINK_IDLE:
4171 return NL80211_PLINK_LISTEN;
4172 case PLINK_OPN_SNT:
4173 return NL80211_PLINK_OPN_SNT;
4174 case PLINK_OPN_RCVD:
4175 return NL80211_PLINK_OPN_RCVD;
4176 case PLINK_CNF_RCVD:
4177 return NL80211_PLINK_CNF_RCVD;
4178 case PLINK_ESTAB:
4179 return NL80211_PLINK_ESTAB;
4180 case PLINK_HOLDING:
4181 return NL80211_PLINK_HOLDING;
4182 case PLINK_BLOCKED:
4183 return NL80211_PLINK_BLOCKED;
4184 default:
4185 wpa_printf(MSG_ERROR, "nl80211: Invalid mesh plink state %d",
4186 state);
4187 }
4188 return -1;
4189 }
4190 #endif /* CONFIG_MESH */
4191
4192
4193 static int wpa_driver_nl80211_sta_add(void *priv,
4194 struct hostapd_sta_add_params *params)
4195 {
4196 struct i802_bss *bss = priv;
4197 struct wpa_driver_nl80211_data *drv = bss->drv;
4198 struct nl_msg *msg;
4199 struct nl80211_sta_flag_update upd;
4200 int ret = -ENOBUFS;
4201
4202 if ((params->flags & WPA_STA_TDLS_PEER) &&
4203 !(drv->capa.flags & WPA_DRIVER_FLAGS_TDLS_SUPPORT))
4204 return -EOPNOTSUPP;
4205
4206 wpa_printf(MSG_DEBUG, "nl80211: %s STA " MACSTR,
4207 params->set ? "Set" : "Add", MAC2STR(params->addr));
4208 msg = nl80211_bss_msg(bss, 0, params->set ? NL80211_CMD_SET_STATION :
4209 NL80211_CMD_NEW_STATION);
4210 if (!msg || nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, params->addr))
4211 goto fail;
4212
4213 /*
4214 * Set the below properties only in one of the following cases:
4215 * 1. New station is added, already associated.
4216 * 2. Set WPA_STA_TDLS_PEER station.
4217 * 3. Set an already added unassociated station, if driver supports
4218 * full AP client state. (Set these properties after station became
4219 * associated will be rejected by the driver).
4220 */
4221 if (!params->set || (params->flags & WPA_STA_TDLS_PEER) ||
4222 (params->set && FULL_AP_CLIENT_STATE_SUPP(drv->capa.flags) &&
4223 (params->flags & WPA_STA_ASSOCIATED))) {
4224 wpa_hexdump(MSG_DEBUG, " * supported rates",
4225 params->supp_rates, params->supp_rates_len);
4226 wpa_printf(MSG_DEBUG, " * capability=0x%x",
4227 params->capability);
4228 if (nla_put(msg, NL80211_ATTR_STA_SUPPORTED_RATES,
4229 params->supp_rates_len, params->supp_rates) ||
4230 nla_put_u16(msg, NL80211_ATTR_STA_CAPABILITY,
4231 params->capability))
4232 goto fail;
4233
4234 if (params->ht_capabilities) {
4235 wpa_hexdump(MSG_DEBUG, " * ht_capabilities",
4236 (u8 *) params->ht_capabilities,
4237 sizeof(*params->ht_capabilities));
4238 if (nla_put(msg, NL80211_ATTR_HT_CAPABILITY,
4239 sizeof(*params->ht_capabilities),
4240 params->ht_capabilities))
4241 goto fail;
4242 }
4243
4244 if (params->vht_capabilities) {
4245 wpa_hexdump(MSG_DEBUG, " * vht_capabilities",
4246 (u8 *) params->vht_capabilities,
4247 sizeof(*params->vht_capabilities));
4248 if (nla_put(msg, NL80211_ATTR_VHT_CAPABILITY,
4249 sizeof(*params->vht_capabilities),
4250 params->vht_capabilities))
4251 goto fail;
4252 }
4253
4254 if (params->ext_capab) {
4255 wpa_hexdump(MSG_DEBUG, " * ext_capab",
4256 params->ext_capab, params->ext_capab_len);
4257 if (nla_put(msg, NL80211_ATTR_STA_EXT_CAPABILITY,
4258 params->ext_capab_len, params->ext_capab))
4259 goto fail;
4260 }
4261
4262 if (is_ap_interface(drv->nlmode) &&
4263 nla_put_u8(msg, NL80211_ATTR_STA_SUPPORT_P2P_PS,
4264 params->support_p2p_ps ?
4265 NL80211_P2P_PS_SUPPORTED :
4266 NL80211_P2P_PS_UNSUPPORTED))
4267 goto fail;
4268 }
4269 if (!params->set) {
4270 if (params->aid) {
4271 wpa_printf(MSG_DEBUG, " * aid=%u", params->aid);
4272 if (nla_put_u16(msg, NL80211_ATTR_STA_AID, params->aid))
4273 goto fail;
4274 } else {
4275 /*
4276 * cfg80211 validates that AID is non-zero, so we have
4277 * to make this a non-zero value for the TDLS case where
4278 * a dummy STA entry is used for now and for a station
4279 * that is still not associated.
4280 */
4281 wpa_printf(MSG_DEBUG, " * aid=1 (%s workaround)",
4282 (params->flags & WPA_STA_TDLS_PEER) ?
4283 "TDLS" : "UNASSOC_STA");
4284 if (nla_put_u16(msg, NL80211_ATTR_STA_AID, 1))
4285 goto fail;
4286 }
4287 wpa_printf(MSG_DEBUG, " * listen_interval=%u",
4288 params->listen_interval);
4289 if (nla_put_u16(msg, NL80211_ATTR_STA_LISTEN_INTERVAL,
4290 params->listen_interval))
4291 goto fail;
4292 } else if (params->aid && (params->flags & WPA_STA_TDLS_PEER)) {
4293 wpa_printf(MSG_DEBUG, " * peer_aid=%u", params->aid);
4294 if (nla_put_u16(msg, NL80211_ATTR_PEER_AID, params->aid))
4295 goto fail;
4296 } else if (FULL_AP_CLIENT_STATE_SUPP(drv->capa.flags) &&
4297 (params->flags & WPA_STA_ASSOCIATED)) {
4298 wpa_printf(MSG_DEBUG, " * aid=%u", params->aid);
4299 wpa_printf(MSG_DEBUG, " * listen_interval=%u",
4300 params->listen_interval);
4301 if (nla_put_u16(msg, NL80211_ATTR_STA_AID, params->aid) ||
4302 nla_put_u16(msg, NL80211_ATTR_STA_LISTEN_INTERVAL,
4303 params->listen_interval))
4304 goto fail;
4305 }
4306
4307 if (params->vht_opmode_enabled) {
4308 wpa_printf(MSG_DEBUG, " * opmode=%u", params->vht_opmode);
4309 if (nla_put_u8(msg, NL80211_ATTR_OPMODE_NOTIF,
4310 params->vht_opmode))
4311 goto fail;
4312 }
4313
4314 if (params->supp_channels) {
4315 wpa_hexdump(MSG_DEBUG, " * supported channels",
4316 params->supp_channels, params->supp_channels_len);
4317 if (nla_put(msg, NL80211_ATTR_STA_SUPPORTED_CHANNELS,
4318 params->supp_channels_len, params->supp_channels))
4319 goto fail;
4320 }
4321
4322 if (params->supp_oper_classes) {
4323 wpa_hexdump(MSG_DEBUG, " * supported operating classes",
4324 params->supp_oper_classes,
4325 params->supp_oper_classes_len);
4326 if (nla_put(msg, NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES,
4327 params->supp_oper_classes_len,
4328 params->supp_oper_classes))
4329 goto fail;
4330 }
4331
4332 os_memset(&upd, 0, sizeof(upd));
4333 upd.set = sta_flags_nl80211(params->flags);
4334 upd.mask = upd.set | sta_flags_nl80211(params->flags_mask);
4335
4336 /*
4337 * If the driver doesn't support full AP client state, ignore ASSOC/AUTH
4338 * flags, as nl80211 driver moves a new station, by default, into
4339 * associated state.
4340 *
4341 * On the other hand, if the driver supports that feature and the
4342 * station is added in unauthenticated state, set the
4343 * authenticated/associated bits in the mask to prevent moving this
4344 * station to associated state before it is actually associated.
4345 *
4346 * This is irrelevant for mesh mode where the station is added to the
4347 * driver as authenticated already, and ASSOCIATED isn't part of the
4348 * nl80211 API.
4349 */
4350 if (!is_mesh_interface(drv->nlmode)) {
4351 if (!FULL_AP_CLIENT_STATE_SUPP(drv->capa.flags)) {
4352 wpa_printf(MSG_DEBUG,
4353 "nl80211: Ignore ASSOC/AUTH flags since driver doesn't support full AP client state");
4354 upd.mask &= ~(BIT(NL80211_STA_FLAG_ASSOCIATED) |
4355 BIT(NL80211_STA_FLAG_AUTHENTICATED));
4356 } else if (!params->set &&
4357 !(params->flags & WPA_STA_TDLS_PEER)) {
4358 if (!(params->flags & WPA_STA_AUTHENTICATED))
4359 upd.mask |= BIT(NL80211_STA_FLAG_AUTHENTICATED);
4360 if (!(params->flags & WPA_STA_ASSOCIATED))
4361 upd.mask |= BIT(NL80211_STA_FLAG_ASSOCIATED);
4362 }
4363 #ifdef CONFIG_MESH
4364 } else {
4365 if (params->plink_state == PLINK_ESTAB && params->peer_aid) {
4366 ret = nla_put_u16(msg, NL80211_ATTR_MESH_PEER_AID,
4367 params->peer_aid);
4368 if (ret)
4369 goto fail;
4370 }
4371 #endif /* CONFIG_MESH */
4372 }
4373
4374 wpa_printf(MSG_DEBUG, " * flags set=0x%x mask=0x%x",
4375 upd.set, upd.mask);
4376 if (nla_put(msg, NL80211_ATTR_STA_FLAGS2, sizeof(upd), &upd))
4377 goto fail;
4378
4379 #ifdef CONFIG_MESH
4380 if (params->plink_state &&
4381 nla_put_u8(msg, NL80211_ATTR_STA_PLINK_STATE,
4382 sta_plink_state_nl80211(params->plink_state)))
4383 goto fail;
4384 #endif /* CONFIG_MESH */
4385
4386 if (params->flags & WPA_STA_WMM) {
4387 struct nlattr *wme = nla_nest_start(msg, NL80211_ATTR_STA_WME);
4388
4389 wpa_printf(MSG_DEBUG, " * qosinfo=0x%x", params->qosinfo);
4390 if (!wme ||
4391 nla_put_u8(msg, NL80211_STA_WME_UAPSD_QUEUES,
4392 params->qosinfo & WMM_QOSINFO_STA_AC_MASK) ||
4393 nla_put_u8(msg, NL80211_STA_WME_MAX_SP,
4394 (params->qosinfo >> WMM_QOSINFO_STA_SP_SHIFT) &
4395 WMM_QOSINFO_STA_SP_MASK))
4396 goto fail;
4397 nla_nest_end(msg, wme);
4398 }
4399
4400 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
4401 msg = NULL;
4402 if (ret)
4403 wpa_printf(MSG_DEBUG, "nl80211: NL80211_CMD_%s_STATION "
4404 "result: %d (%s)", params->set ? "SET" : "NEW", ret,
4405 strerror(-ret));
4406 if (ret == -EEXIST)
4407 ret = 0;
4408 fail:
4409 nlmsg_free(msg);
4410 return ret;
4411 }
4412
4413
4414 static void rtnl_neigh_delete_fdb_entry(struct i802_bss *bss, const u8 *addr)
4415 {
4416 #ifdef CONFIG_LIBNL3_ROUTE
4417 struct wpa_driver_nl80211_data *drv = bss->drv;
4418 struct rtnl_neigh *rn;
4419 struct nl_addr *nl_addr;
4420 int err;
4421
4422 rn = rtnl_neigh_alloc();
4423 if (!rn)
4424 return;
4425
4426 rtnl_neigh_set_family(rn, AF_BRIDGE);
4427 rtnl_neigh_set_ifindex(rn, bss->ifindex);
4428 nl_addr = nl_addr_build(AF_BRIDGE, (void *) addr, ETH_ALEN);
4429 if (!nl_addr) {
4430 rtnl_neigh_put(rn);
4431 return;
4432 }
4433 rtnl_neigh_set_lladdr(rn, nl_addr);
4434
4435 err = rtnl_neigh_delete(drv->rtnl_sk, rn, 0);
4436 if (err < 0) {
4437 wpa_printf(MSG_DEBUG, "nl80211: bridge FDB entry delete for "
4438 MACSTR " ifindex=%d failed: %s", MAC2STR(addr),
4439 bss->ifindex, nl_geterror(err));
4440 } else {
4441 wpa_printf(MSG_DEBUG, "nl80211: deleted bridge FDB entry for "
4442 MACSTR, MAC2STR(addr));
4443 }
4444
4445 nl_addr_put(nl_addr);
4446 rtnl_neigh_put(rn);
4447 #endif /* CONFIG_LIBNL3_ROUTE */
4448 }
4449
4450
4451 static int wpa_driver_nl80211_sta_remove(struct i802_bss *bss, const u8 *addr,
4452 int deauth, u16 reason_code)
4453 {
4454 struct wpa_driver_nl80211_data *drv = bss->drv;
4455 struct nl_msg *msg;
4456 int ret;
4457
4458 if (!(msg = nl80211_bss_msg(bss, 0, NL80211_CMD_DEL_STATION)) ||
4459 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
4460 (deauth == 0 &&
4461 nla_put_u8(msg, NL80211_ATTR_MGMT_SUBTYPE,
4462 WLAN_FC_STYPE_DISASSOC)) ||
4463 (deauth == 1 &&
4464 nla_put_u8(msg, NL80211_ATTR_MGMT_SUBTYPE,
4465 WLAN_FC_STYPE_DEAUTH)) ||
4466 (reason_code &&
4467 nla_put_u16(msg, NL80211_ATTR_REASON_CODE, reason_code))) {
4468 nlmsg_free(msg);
4469 return -ENOBUFS;
4470 }
4471
4472 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
4473 wpa_printf(MSG_DEBUG, "nl80211: sta_remove -> DEL_STATION %s " MACSTR
4474 " --> %d (%s)",
4475 bss->ifname, MAC2STR(addr), ret, strerror(-ret));
4476
4477 if (drv->rtnl_sk)
4478 rtnl_neigh_delete_fdb_entry(bss, addr);
4479
4480 if (ret == -ENOENT)
4481 return 0;
4482 return ret;
4483 }
4484
4485
4486 void nl80211_remove_iface(struct wpa_driver_nl80211_data *drv, int ifidx)
4487 {
4488 struct nl_msg *msg;
4489 struct wpa_driver_nl80211_data *drv2;
4490
4491 wpa_printf(MSG_DEBUG, "nl80211: Remove interface ifindex=%d", ifidx);
4492
4493 /* stop listening for EAPOL on this interface */
4494 dl_list_for_each(drv2, &drv->global->interfaces,
4495 struct wpa_driver_nl80211_data, list)
4496 {
4497 del_ifidx(drv2, ifidx, IFIDX_ANY);
4498 /* Remove all bridges learned for this iface */
4499 del_ifidx(drv2, IFIDX_ANY, ifidx);
4500 }
4501
4502 msg = nl80211_ifindex_msg(drv, ifidx, 0, NL80211_CMD_DEL_INTERFACE);
4503 if (send_and_recv_msgs(drv, msg, NULL, NULL) == 0)
4504 return;
4505 wpa_printf(MSG_ERROR, "Failed to remove interface (ifidx=%d)", ifidx);
4506 }
4507
4508
4509 const char * nl80211_iftype_str(enum nl80211_iftype mode)
4510 {
4511 switch (mode) {
4512 case NL80211_IFTYPE_ADHOC:
4513 return "ADHOC";
4514 case NL80211_IFTYPE_STATION:
4515 return "STATION";
4516 case NL80211_IFTYPE_AP:
4517 return "AP";
4518 case NL80211_IFTYPE_AP_VLAN:
4519 return "AP_VLAN";
4520 case NL80211_IFTYPE_WDS:
4521 return "WDS";
4522 case NL80211_IFTYPE_MONITOR:
4523 return "MONITOR";
4524 case NL80211_IFTYPE_MESH_POINT:
4525 return "MESH_POINT";
4526 case NL80211_IFTYPE_P2P_CLIENT:
4527 return "P2P_CLIENT";
4528 case NL80211_IFTYPE_P2P_GO:
4529 return "P2P_GO";
4530 case NL80211_IFTYPE_P2P_DEVICE:
4531 return "P2P_DEVICE";
4532 default:
4533 return "unknown";
4534 }
4535 }
4536
4537
4538 static int nl80211_create_iface_once(struct wpa_driver_nl80211_data *drv,
4539 const char *ifname,
4540 enum nl80211_iftype iftype,
4541 const u8 *addr, int wds,
4542 int (*handler)(struct nl_msg *, void *),
4543 void *arg)
4544 {
4545 struct nl_msg *msg;
4546 int ifidx;
4547 int ret = -ENOBUFS;
4548
4549 wpa_printf(MSG_DEBUG, "nl80211: Create interface iftype %d (%s)",
4550 iftype, nl80211_iftype_str(iftype));
4551
4552 msg = nl80211_cmd_msg(drv->first_bss, 0, NL80211_CMD_NEW_INTERFACE);
4553 if (!msg ||
4554 nla_put_string(msg, NL80211_ATTR_IFNAME, ifname) ||
4555 nla_put_u32(msg, NL80211_ATTR_IFTYPE, iftype))
4556 goto fail;
4557
4558 if (iftype == NL80211_IFTYPE_MONITOR) {
4559 struct nlattr *flags;
4560
4561 flags = nla_nest_start(msg, NL80211_ATTR_MNTR_FLAGS);
4562 if (!flags ||
4563 nla_put_flag(msg, NL80211_MNTR_FLAG_COOK_FRAMES))
4564 goto fail;
4565
4566 nla_nest_end(msg, flags);
4567 } else if (wds) {
4568 if (nla_put_u8(msg, NL80211_ATTR_4ADDR, wds))
4569 goto fail;
4570 }
4571
4572 /*
4573 * Tell cfg80211 that the interface belongs to the socket that created
4574 * it, and the interface should be deleted when the socket is closed.
4575 */
4576 if (nla_put_flag(msg, NL80211_ATTR_IFACE_SOCKET_OWNER))
4577 goto fail;
4578
4579 ret = send_and_recv_msgs(drv, msg, handler, arg);
4580 msg = NULL;
4581 if (ret) {
4582 fail:
4583 nlmsg_free(msg);
4584 wpa_printf(MSG_ERROR, "Failed to create interface %s: %d (%s)",
4585 ifname, ret, strerror(-ret));
4586 return ret;
4587 }
4588
4589 if (iftype == NL80211_IFTYPE_P2P_DEVICE)
4590 return 0;
4591
4592 ifidx = if_nametoindex(ifname);
4593 wpa_printf(MSG_DEBUG, "nl80211: New interface %s created: ifindex=%d",
4594 ifname, ifidx);
4595
4596 if (ifidx <= 0)
4597 return -1;
4598
4599 /*
4600 * Some virtual interfaces need to process EAPOL packets and events on
4601 * the parent interface. This is used mainly with hostapd.
4602 */
4603 if (drv->hostapd ||
4604 iftype == NL80211_IFTYPE_AP_VLAN ||
4605 iftype == NL80211_IFTYPE_WDS ||
4606 iftype == NL80211_IFTYPE_MONITOR) {
4607 /* start listening for EAPOL on this interface */
4608 add_ifidx(drv, ifidx, IFIDX_ANY);
4609 }
4610
4611 if (addr && iftype != NL80211_IFTYPE_MONITOR &&
4612 linux_set_ifhwaddr(drv->global->ioctl_sock, ifname, addr)) {
4613 nl80211_remove_iface(drv, ifidx);
4614 return -1;
4615 }
4616
4617 return ifidx;
4618 }
4619
4620
4621 int nl80211_create_iface(struct wpa_driver_nl80211_data *drv,
4622 const char *ifname, enum nl80211_iftype iftype,
4623 const u8 *addr, int wds,
4624 int (*handler)(struct nl_msg *, void *),
4625 void *arg, int use_existing)
4626 {
4627 int ret;
4628
4629 ret = nl80211_create_iface_once(drv, ifname, iftype, addr, wds, handler,
4630 arg);
4631
4632 /* if error occurred and interface exists already */
4633 if (ret == -ENFILE && if_nametoindex(ifname)) {
4634 if (use_existing) {
4635 wpa_printf(MSG_DEBUG, "nl80211: Continue using existing interface %s",
4636 ifname);
4637 if (addr && iftype != NL80211_IFTYPE_MONITOR &&
4638 linux_set_ifhwaddr(drv->global->ioctl_sock, ifname,
4639 addr) < 0 &&
4640 (linux_set_iface_flags(drv->global->ioctl_sock,
4641 ifname, 0) < 0 ||
4642 linux_set_ifhwaddr(drv->global->ioctl_sock, ifname,
4643 addr) < 0 ||
4644 linux_set_iface_flags(drv->global->ioctl_sock,
4645 ifname, 1) < 0))
4646 return -1;
4647 return -ENFILE;
4648 }
4649 wpa_printf(MSG_INFO, "Try to remove and re-create %s", ifname);
4650
4651 /* Try to remove the interface that was already there. */
4652 nl80211_remove_iface(drv, if_nametoindex(ifname));
4653
4654 /* Try to create the interface again */
4655 ret = nl80211_create_iface_once(drv, ifname, iftype, addr,
4656 wds, handler, arg);
4657 }
4658
4659 if (ret >= 0 && is_p2p_net_interface(iftype)) {
4660 wpa_printf(MSG_DEBUG,
4661 "nl80211: Interface %s created for P2P - disable 11b rates",
4662 ifname);
4663 nl80211_disable_11b_rates(drv, ret, 1);
4664 }
4665
4666 return ret;
4667 }
4668
4669
4670 static int nl80211_setup_ap(struct i802_bss *bss)
4671 {
4672 struct wpa_driver_nl80211_data *drv = bss->drv;
4673
4674 wpa_printf(MSG_DEBUG, "nl80211: Setup AP(%s) - device_ap_sme=%d use_monitor=%d",
4675 bss->ifname, drv->device_ap_sme, drv->use_monitor);
4676
4677 /*
4678 * Disable Probe Request reporting unless we need it in this way for
4679 * devices that include the AP SME, in the other case (unless using
4680 * monitor iface) we'll get it through the nl_mgmt socket instead.
4681 */
4682 if (!drv->device_ap_sme)
4683 wpa_driver_nl80211_probe_req_report(bss, 0);
4684
4685 if (!drv->device_ap_sme && !drv->use_monitor)
4686 if (nl80211_mgmt_subscribe_ap(bss))
4687 return -1;
4688
4689 if (drv->device_ap_sme && !drv->use_monitor)
4690 if (nl80211_mgmt_subscribe_ap_dev_sme(bss))
4691 wpa_printf(MSG_DEBUG,
4692 "nl80211: Failed to subscribe for mgmt frames from SME driver - trying to run without it");
4693
4694 if (!drv->device_ap_sme && drv->use_monitor &&
4695 nl80211_create_monitor_interface(drv) &&
4696 !drv->device_ap_sme)
4697 return -1;
4698
4699 if (drv->device_ap_sme &&
4700 wpa_driver_nl80211_probe_req_report(bss, 1) < 0) {
4701 wpa_printf(MSG_DEBUG, "nl80211: Failed to enable "
4702 "Probe Request frame reporting in AP mode");
4703 /* Try to survive without this */
4704 }
4705
4706 return 0;
4707 }
4708
4709
4710 static void nl80211_teardown_ap(struct i802_bss *bss)
4711 {
4712 struct wpa_driver_nl80211_data *drv = bss->drv;
4713
4714 wpa_printf(MSG_DEBUG, "nl80211: Teardown AP(%s) - device_ap_sme=%d use_monitor=%d",
4715 bss->ifname, drv->device_ap_sme, drv->use_monitor);
4716 if (drv->device_ap_sme) {
4717 wpa_driver_nl80211_probe_req_report(bss, 0);
4718 if (!drv->use_monitor)
4719 nl80211_mgmt_unsubscribe(bss, "AP teardown (dev SME)");
4720 } else if (drv->use_monitor)
4721 nl80211_remove_monitor_interface(drv);
4722 else
4723 nl80211_mgmt_unsubscribe(bss, "AP teardown");
4724
4725 nl80211_put_wiphy_data_ap(bss);
4726 bss->beacon_set = 0;
4727 }
4728
4729
4730 static int nl80211_send_eapol_data(struct i802_bss *bss,
4731 const u8 *addr, const u8 *data,
4732 size_t data_len)
4733 {
4734 struct sockaddr_ll ll;
4735 int ret;
4736
4737 if (bss->drv->eapol_tx_sock < 0) {
4738 wpa_printf(MSG_DEBUG, "nl80211: No socket to send EAPOL");
4739 return -1;
4740 }
4741
4742 os_memset(&ll, 0, sizeof(ll));
4743 ll.sll_family = AF_PACKET;
4744 ll.sll_ifindex = bss->ifindex;
4745 ll.sll_protocol = htons(ETH_P_PAE);
4746 ll.sll_halen = ETH_ALEN;
4747 os_memcpy(ll.sll_addr, addr, ETH_ALEN);
4748 ret = sendto(bss->drv->eapol_tx_sock, data, data_len, 0,
4749 (struct sockaddr *) &ll, sizeof(ll));
4750 if (ret < 0)
4751 wpa_printf(MSG_ERROR, "nl80211: EAPOL TX: %s",
4752 strerror(errno));
4753
4754 return ret;
4755 }
4756
4757
4758 static const u8 rfc1042_header[6] = { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00 };
4759
4760 static int wpa_driver_nl80211_hapd_send_eapol(
4761 void *priv, const u8 *addr, const u8 *data,
4762 size_t data_len, int encrypt, const u8 *own_addr, u32 flags)
4763 {
4764 struct i802_bss *bss = priv;
4765 struct wpa_driver_nl80211_data *drv = bss->drv;
4766 struct ieee80211_hdr *hdr;
4767 size_t len;
4768 u8 *pos;
4769 int res;
4770 int qos = flags & WPA_STA_WMM;
4771
4772 if (drv->device_ap_sme || !drv->use_monitor)
4773 return nl80211_send_eapol_data(bss, addr, data, data_len);
4774
4775 len = sizeof(*hdr) + (qos ? 2 : 0) + sizeof(rfc1042_header) + 2 +
4776 data_len;
4777 hdr = os_zalloc(len);
4778 if (hdr == NULL) {
4779 wpa_printf(MSG_INFO, "nl80211: Failed to allocate EAPOL buffer(len=%lu)",
4780 (unsigned long) len);
4781 return -1;
4782 }
4783
4784 hdr->frame_control =
4785 IEEE80211_FC(WLAN_FC_TYPE_DATA, WLAN_FC_STYPE_DATA);
4786 hdr->frame_control |= host_to_le16(WLAN_FC_FROMDS);
4787 if (encrypt)
4788 hdr->frame_control |= host_to_le16(WLAN_FC_ISWEP);
4789 if (qos) {
4790 hdr->frame_control |=
4791 host_to_le16(WLAN_FC_STYPE_QOS_DATA << 4);
4792 }
4793
4794 memcpy(hdr->IEEE80211_DA_FROMDS, addr, ETH_ALEN);
4795 memcpy(hdr->IEEE80211_BSSID_FROMDS, own_addr, ETH_ALEN);
4796 memcpy(hdr->IEEE80211_SA_FROMDS, own_addr, ETH_ALEN);
4797 pos = (u8 *) (hdr + 1);
4798
4799 if (qos) {
4800 /* Set highest priority in QoS header */
4801 pos[0] = 7;
4802 pos[1] = 0;
4803 pos += 2;
4804 }
4805
4806 memcpy(pos, rfc1042_header, sizeof(rfc1042_header));
4807 pos += sizeof(rfc1042_header);
4808 WPA_PUT_BE16(pos, ETH_P_PAE);
4809 pos += 2;
4810 memcpy(pos, data, data_len);
4811
4812 res = wpa_driver_nl80211_send_frame(bss, (u8 *) hdr, len, encrypt, 0,
4813 0, 0, 0, 0, NULL, 0);
4814 if (res < 0) {
4815 wpa_printf(MSG_ERROR, "i802_send_eapol - packet len: %lu - "
4816 "failed: %d (%s)",
4817 (unsigned long) len, errno, strerror(errno));
4818 }
4819 os_free(hdr);
4820
4821 return res;
4822 }
4823
4824
4825 static int wpa_driver_nl80211_sta_set_flags(void *priv, const u8 *addr,
4826 unsigned int total_flags,
4827 unsigned int flags_or,
4828 unsigned int flags_and)
4829 {
4830 struct i802_bss *bss = priv;
4831 struct nl_msg *msg;
4832 struct nlattr *flags;
4833 struct nl80211_sta_flag_update upd;
4834
4835 wpa_printf(MSG_DEBUG, "nl80211: Set STA flags - ifname=%s addr=" MACSTR
4836 " total_flags=0x%x flags_or=0x%x flags_and=0x%x authorized=%d",
4837 bss->ifname, MAC2STR(addr), total_flags, flags_or, flags_and,
4838 !!(total_flags & WPA_STA_AUTHORIZED));
4839
4840 if (!(msg = nl80211_bss_msg(bss, 0, NL80211_CMD_SET_STATION)) ||
4841 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr))
4842 goto fail;
4843
4844 /*
4845 * Backwards compatibility version using NL80211_ATTR_STA_FLAGS. This
4846 * can be removed eventually.
4847 */
4848 flags = nla_nest_start(msg, NL80211_ATTR_STA_FLAGS);
4849 if (!flags ||
4850 ((total_flags & WPA_STA_AUTHORIZED) &&
4851 nla_put_flag(msg, NL80211_STA_FLAG_AUTHORIZED)) ||
4852 ((total_flags & WPA_STA_WMM) &&
4853 nla_put_flag(msg, NL80211_STA_FLAG_WME)) ||
4854 ((total_flags & WPA_STA_SHORT_PREAMBLE) &&
4855 nla_put_flag(msg, NL80211_STA_FLAG_SHORT_PREAMBLE)) ||
4856 ((total_flags & WPA_STA_MFP) &&
4857 nla_put_flag(msg, NL80211_STA_FLAG_MFP)) ||
4858 ((total_flags & WPA_STA_TDLS_PEER) &&
4859 nla_put_flag(msg, NL80211_STA_FLAG_TDLS_PEER)))
4860 goto fail;
4861
4862 nla_nest_end(msg, flags);
4863
4864 os_memset(&upd, 0, sizeof(upd));
4865 upd.mask = sta_flags_nl80211(flags_or | ~flags_and);
4866 upd.set = sta_flags_nl80211(flags_or);
4867 if (nla_put(msg, NL80211_ATTR_STA_FLAGS2, sizeof(upd), &upd))
4868 goto fail;
4869
4870 return send_and_recv_msgs(bss->drv, msg, NULL, NULL);
4871 fail:
4872 nlmsg_free(msg);
4873 return -ENOBUFS;
4874 }
4875
4876
4877 static int wpa_driver_nl80211_ap(struct wpa_driver_nl80211_data *drv,
4878 struct wpa_driver_associate_params *params)
4879 {
4880 enum nl80211_iftype nlmode, old_mode;
4881
4882 if (params->p2p) {
4883 wpa_printf(MSG_DEBUG, "nl80211: Setup AP operations for P2P "
4884 "group (GO)");
4885 nlmode = NL80211_IFTYPE_P2P_GO;
4886 } else
4887 nlmode = NL80211_IFTYPE_AP;
4888
4889 old_mode = drv->nlmode;
4890 if (wpa_driver_nl80211_set_mode(drv->first_bss, nlmode)) {
4891 nl80211_remove_monitor_interface(drv);
4892 return -1;
4893 }
4894
4895 if (params->freq.freq &&
4896 nl80211_set_channel(drv->first_bss, &params->freq, 0)) {
4897 if (old_mode != nlmode)
4898 wpa_driver_nl80211_set_mode(drv->first_bss, old_mode);
4899 nl80211_remove_monitor_interface(drv);
4900 return -1;
4901 }
4902
4903 return 0;
4904 }
4905
4906
4907 static int nl80211_leave_ibss(struct wpa_driver_nl80211_data *drv,
4908 int reset_mode)
4909 {
4910 struct nl_msg *msg;
4911 int ret;
4912
4913 msg = nl80211_drv_msg(drv, 0, NL80211_CMD_LEAVE_IBSS);
4914 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
4915 if (ret) {
4916 wpa_printf(MSG_DEBUG, "nl80211: Leave IBSS failed: ret=%d "
4917 "(%s)", ret, strerror(-ret));
4918 } else {
4919 wpa_printf(MSG_DEBUG,
4920 "nl80211: Leave IBSS request sent successfully");
4921 }
4922
4923 if (reset_mode &&
4924 wpa_driver_nl80211_set_mode(drv->first_bss,
4925 NL80211_IFTYPE_STATION)) {
4926 wpa_printf(MSG_INFO, "nl80211: Failed to set interface into "
4927 "station mode");
4928 }
4929
4930 return ret;
4931 }
4932
4933
4934 static int nl80211_ht_vht_overrides(struct nl_msg *msg,
4935 struct wpa_driver_associate_params *params)
4936 {
4937 if (params->disable_ht && nla_put_flag(msg, NL80211_ATTR_DISABLE_HT))
4938 return -1;
4939
4940 if (params->htcaps && params->htcaps_mask) {
4941 int sz = sizeof(struct ieee80211_ht_capabilities);
4942 wpa_hexdump(MSG_DEBUG, " * htcaps", params->htcaps, sz);
4943 wpa_hexdump(MSG_DEBUG, " * htcaps_mask",
4944 params->htcaps_mask, sz);
4945 if (nla_put(msg, NL80211_ATTR_HT_CAPABILITY, sz,
4946 params->htcaps) ||
4947 nla_put(msg, NL80211_ATTR_HT_CAPABILITY_MASK, sz,
4948 params->htcaps_mask))
4949 return -1;
4950 }
4951
4952 #ifdef CONFIG_VHT_OVERRIDES
4953 if (params->disable_vht) {
4954 wpa_printf(MSG_DEBUG, " * VHT disabled");
4955 if (nla_put_flag(msg, NL80211_ATTR_DISABLE_VHT))
4956 return -1;
4957 }
4958
4959 if (params->vhtcaps && params->vhtcaps_mask) {
4960 int sz = sizeof(struct ieee80211_vht_capabilities);
4961 wpa_hexdump(MSG_DEBUG, " * vhtcaps", params->vhtcaps, sz);
4962 wpa_hexdump(MSG_DEBUG, " * vhtcaps_mask",
4963 params->vhtcaps_mask, sz);
4964 if (nla_put(msg, NL80211_ATTR_VHT_CAPABILITY, sz,
4965 params->vhtcaps) ||
4966 nla_put(msg, NL80211_ATTR_VHT_CAPABILITY_MASK, sz,
4967 params->vhtcaps_mask))
4968 return -1;
4969 }
4970 #endif /* CONFIG_VHT_OVERRIDES */
4971
4972 return 0;
4973 }
4974
4975
4976 static int wpa_driver_nl80211_ibss(struct wpa_driver_nl80211_data *drv,
4977 struct wpa_driver_associate_params *params)
4978 {
4979 struct nl_msg *msg;
4980 int ret = -1;
4981 int count = 0;
4982
4983 wpa_printf(MSG_DEBUG, "nl80211: Join IBSS (ifindex=%d)", drv->ifindex);
4984
4985 if (wpa_driver_nl80211_set_mode_ibss(drv->first_bss, &params->freq)) {
4986 wpa_printf(MSG_INFO, "nl80211: Failed to set interface into "
4987 "IBSS mode");
4988 return -1;
4989 }
4990
4991 retry:
4992 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_JOIN_IBSS)) ||
4993 params->ssid == NULL || params->ssid_len > sizeof(drv->ssid))
4994 goto fail;
4995
4996 wpa_hexdump_ascii(MSG_DEBUG, " * SSID",
4997 params->ssid, params->ssid_len);
4998 if (nla_put(msg, NL80211_ATTR_SSID, params->ssid_len, params->ssid))
4999 goto fail;
5000 os_memcpy(drv->ssid, params->ssid, params->ssid_len);
5001 drv->ssid_len = params->ssid_len;
5002
5003 if (nl80211_put_freq_params(msg, &params->freq) < 0 ||
5004 nl80211_put_beacon_int(msg, params->beacon_int))
5005 goto fail;
5006
5007 ret = nl80211_set_conn_keys(params, msg);
5008 if (ret)
5009 goto fail;
5010
5011 if (params->bssid && params->fixed_bssid) {
5012 wpa_printf(MSG_DEBUG, " * BSSID=" MACSTR,
5013 MAC2STR(params->bssid));
5014 if (nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, params->bssid))
5015 goto fail;
5016 }
5017
5018 if (params->fixed_freq) {
5019 wpa_printf(MSG_DEBUG, " * fixed_freq");
5020 if (nla_put_flag(msg, NL80211_ATTR_FREQ_FIXED))
5021 goto fail;
5022 }
5023
5024 if (params->key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X ||
5025 params->key_mgmt_suite == WPA_KEY_MGMT_PSK ||
5026 params->key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X_SHA256 ||
5027 params->key_mgmt_suite == WPA_KEY_MGMT_PSK_SHA256) {
5028 wpa_printf(MSG_DEBUG, " * control port");
5029 if (nla_put_flag(msg, NL80211_ATTR_CONTROL_PORT))
5030 goto fail;
5031 }
5032
5033 if (params->wpa_ie) {
5034 wpa_hexdump(MSG_DEBUG,
5035 " * Extra IEs for Beacon/Probe Response frames",
5036 params->wpa_ie, params->wpa_ie_len);
5037 if (nla_put(msg, NL80211_ATTR_IE, params->wpa_ie_len,
5038 params->wpa_ie))
5039 goto fail;
5040 }
5041
5042 ret = nl80211_ht_vht_overrides(msg, params);
5043 if (ret < 0)
5044 goto fail;
5045
5046 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
5047 msg = NULL;
5048 if (ret) {
5049 wpa_printf(MSG_DEBUG, "nl80211: Join IBSS failed: ret=%d (%s)",
5050 ret, strerror(-ret));
5051 count++;
5052 if (ret == -EALREADY && count == 1) {
5053 wpa_printf(MSG_DEBUG, "nl80211: Retry IBSS join after "
5054 "forced leave");
5055 nl80211_leave_ibss(drv, 0);
5056 nlmsg_free(msg);
5057 goto retry;
5058 }
5059 } else {
5060 wpa_printf(MSG_DEBUG,
5061 "nl80211: Join IBSS request sent successfully");
5062 }
5063
5064 fail:
5065 nlmsg_free(msg);
5066 return ret;
5067 }
5068
5069
5070 static int nl80211_connect_common(struct wpa_driver_nl80211_data *drv,
5071 struct wpa_driver_associate_params *params,
5072 struct nl_msg *msg)
5073 {
5074 if (nla_put_flag(msg, NL80211_ATTR_IFACE_SOCKET_OWNER))
5075 return -1;
5076
5077 if (params->bssid) {
5078 wpa_printf(MSG_DEBUG, " * bssid=" MACSTR,
5079 MAC2STR(params->bssid));
5080 if (nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, params->bssid))
5081 return -1;
5082 }
5083
5084 if (params->bssid_hint) {
5085 wpa_printf(MSG_DEBUG, " * bssid_hint=" MACSTR,
5086 MAC2STR(params->bssid_hint));
5087 if (nla_put(msg, NL80211_ATTR_MAC_HINT, ETH_ALEN,
5088 params->bssid_hint))
5089 return -1;
5090 }
5091
5092 if (params->freq.freq) {
5093 wpa_printf(MSG_DEBUG, " * freq=%d", params->freq.freq);
5094 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ,
5095 params->freq.freq))
5096 return -1;
5097 drv->assoc_freq = params->freq.freq;
5098 } else
5099 drv->assoc_freq = 0;
5100
5101 if (params->freq_hint) {
5102 wpa_printf(MSG_DEBUG, " * freq_hint=%d", params->freq_hint);
5103 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ_HINT,
5104 params->freq_hint))
5105 return -1;
5106 }
5107
5108 if (params->bg_scan_period >= 0) {
5109 wpa_printf(MSG_DEBUG, " * bg scan period=%d",
5110 params->bg_scan_period);
5111 if (nla_put_u16(msg, NL80211_ATTR_BG_SCAN_PERIOD,
5112 params->bg_scan_period))
5113 return -1;
5114 }
5115
5116 if (params->ssid) {
5117 wpa_hexdump_ascii(MSG_DEBUG, " * SSID",
5118 params->ssid, params->ssid_len);
5119 if (nla_put(msg, NL80211_ATTR_SSID, params->ssid_len,
5120 params->ssid))
5121 return -1;
5122 if (params->ssid_len > sizeof(drv->ssid))
5123 return -1;
5124 os_memcpy(drv->ssid, params->ssid, params->ssid_len);
5125 drv->ssid_len = params->ssid_len;
5126 }
5127
5128 wpa_hexdump(MSG_DEBUG, " * IEs", params->wpa_ie, params->wpa_ie_len);
5129 if (params->wpa_ie &&
5130 nla_put(msg, NL80211_ATTR_IE, params->wpa_ie_len, params->wpa_ie))
5131 return -1;
5132
5133 if (params->wpa_proto) {
5134 enum nl80211_wpa_versions ver = 0;
5135
5136 if (params->wpa_proto & WPA_PROTO_WPA)
5137 ver |= NL80211_WPA_VERSION_1;
5138 if (params->wpa_proto & WPA_PROTO_RSN)
5139 ver |= NL80211_WPA_VERSION_2;
5140
5141 wpa_printf(MSG_DEBUG, " * WPA Versions 0x%x", ver);
5142 if (nla_put_u32(msg, NL80211_ATTR_WPA_VERSIONS, ver))
5143 return -1;
5144 }
5145
5146 if (params->pairwise_suite != WPA_CIPHER_NONE) {
5147 u32 cipher = wpa_cipher_to_cipher_suite(params->pairwise_suite);
5148 wpa_printf(MSG_DEBUG, " * pairwise=0x%x", cipher);
5149 if (nla_put_u32(msg, NL80211_ATTR_CIPHER_SUITES_PAIRWISE,
5150 cipher))
5151 return -1;
5152 }
5153
5154 if (params->group_suite == WPA_CIPHER_GTK_NOT_USED &&
5155 !(drv->capa.enc & WPA_DRIVER_CAPA_ENC_GTK_NOT_USED)) {
5156 /*
5157 * This is likely to work even though many drivers do not
5158 * advertise support for operations without GTK.
5159 */
5160 wpa_printf(MSG_DEBUG, " * skip group cipher configuration for GTK_NOT_USED due to missing driver support advertisement");
5161 } else if (params->group_suite != WPA_CIPHER_NONE) {
5162 u32 cipher = wpa_cipher_to_cipher_suite(params->group_suite);
5163 wpa_printf(MSG_DEBUG, " * group=0x%x", cipher);
5164 if (nla_put_u32(msg, NL80211_ATTR_CIPHER_SUITE_GROUP, cipher))
5165 return -1;
5166 }
5167
5168 if (params->key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X ||
5169 params->key_mgmt_suite == WPA_KEY_MGMT_PSK ||
5170 params->key_mgmt_suite == WPA_KEY_MGMT_FT_IEEE8021X ||
5171 params->key_mgmt_suite == WPA_KEY_MGMT_FT_PSK ||
5172 params->key_mgmt_suite == WPA_KEY_MGMT_CCKM ||
5173 params->key_mgmt_suite == WPA_KEY_MGMT_OSEN ||
5174 params->key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X_SHA256 ||
5175 params->key_mgmt_suite == WPA_KEY_MGMT_PSK_SHA256 ||
5176 params->key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X_SUITE_B ||
5177 params->key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X_SUITE_B_192) {
5178 int mgmt = RSN_AUTH_KEY_MGMT_PSK_OVER_802_1X;
5179
5180 switch (params->key_mgmt_suite) {
5181 case WPA_KEY_MGMT_CCKM:
5182 mgmt = RSN_AUTH_KEY_MGMT_CCKM;
5183 break;
5184 case WPA_KEY_MGMT_IEEE8021X:
5185 mgmt = RSN_AUTH_KEY_MGMT_UNSPEC_802_1X;
5186 break;
5187 case WPA_KEY_MGMT_FT_IEEE8021X:
5188 mgmt = RSN_AUTH_KEY_MGMT_FT_802_1X;
5189 break;
5190 case WPA_KEY_MGMT_FT_PSK:
5191 mgmt = RSN_AUTH_KEY_MGMT_FT_PSK;
5192 break;
5193 case WPA_KEY_MGMT_IEEE8021X_SHA256:
5194 mgmt = RSN_AUTH_KEY_MGMT_802_1X_SHA256;
5195 break;
5196 case WPA_KEY_MGMT_PSK_SHA256:
5197 mgmt = RSN_AUTH_KEY_MGMT_PSK_SHA256;
5198 break;
5199 case WPA_KEY_MGMT_OSEN:
5200 mgmt = RSN_AUTH_KEY_MGMT_OSEN;
5201 break;
5202 case WPA_KEY_MGMT_IEEE8021X_SUITE_B:
5203 mgmt = RSN_AUTH_KEY_MGMT_802_1X_SUITE_B;
5204 break;
5205 case WPA_KEY_MGMT_IEEE8021X_SUITE_B_192:
5206 mgmt = RSN_AUTH_KEY_MGMT_802_1X_SUITE_B_192;
5207 break;
5208 case WPA_KEY_MGMT_PSK:
5209 default:
5210 mgmt = RSN_AUTH_KEY_MGMT_PSK_OVER_802_1X;
5211 break;
5212 }
5213 wpa_printf(MSG_DEBUG, " * akm=0x%x", mgmt);
5214 if (nla_put_u32(msg, NL80211_ATTR_AKM_SUITES, mgmt))
5215 return -1;
5216 }
5217
5218 if (nla_put_flag(msg, NL80211_ATTR_CONTROL_PORT))
5219 return -1;
5220
5221 if (params->key_mgmt_suite == WPA_KEY_MGMT_IEEE8021X_NO_WPA &&
5222 (params->pairwise_suite == WPA_CIPHER_NONE ||
5223 params->pairwise_suite == WPA_CIPHER_WEP104 ||
5224 params->pairwise_suite == WPA_CIPHER_WEP40) &&
5225 (nla_put_u16(msg, NL80211_ATTR_CONTROL_PORT_ETHERTYPE, ETH_P_PAE) ||
5226 nla_put_flag(msg, NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT)))
5227 return -1;
5228
5229 if (params->mgmt_frame_protection == MGMT_FRAME_PROTECTION_REQUIRED &&
5230 nla_put_u32(msg, NL80211_ATTR_USE_MFP, NL80211_MFP_REQUIRED))
5231 return -1;
5232
5233 if (params->rrm_used) {
5234 u32 drv_rrm_flags = drv->capa.rrm_flags;
5235 if ((!((drv_rrm_flags &
5236 WPA_DRIVER_FLAGS_DS_PARAM_SET_IE_IN_PROBES) &&
5237 (drv_rrm_flags & WPA_DRIVER_FLAGS_QUIET)) &&
5238 !(drv_rrm_flags & WPA_DRIVER_FLAGS_SUPPORT_RRM)) ||
5239 nla_put_flag(msg, NL80211_ATTR_USE_RRM))
5240 return -1;
5241 }
5242
5243 if (nl80211_ht_vht_overrides(msg, params) < 0)
5244 return -1;
5245
5246 if (params->p2p)
5247 wpa_printf(MSG_DEBUG, " * P2P group");
5248
5249 if (params->pbss) {
5250 wpa_printf(MSG_DEBUG, " * PBSS");
5251 if (nla_put_flag(msg, NL80211_ATTR_PBSS))
5252 return -1;
5253 }
5254
5255 drv->connect_reassoc = 0;
5256 if (params->prev_bssid) {
5257 wpa_printf(MSG_DEBUG, " * prev_bssid=" MACSTR,
5258 MAC2STR(params->prev_bssid));
5259 if (nla_put(msg, NL80211_ATTR_PREV_BSSID, ETH_ALEN,
5260 params->prev_bssid))
5261 return -1;
5262 drv->connect_reassoc = 1;
5263 }
5264
5265 return 0;
5266 }
5267
5268
5269 static int wpa_driver_nl80211_try_connect(
5270 struct wpa_driver_nl80211_data *drv,
5271 struct wpa_driver_associate_params *params)
5272 {
5273 struct nl_msg *msg;
5274 enum nl80211_auth_type type;
5275 int ret;
5276 int algs;
5277
5278 #ifdef CONFIG_DRIVER_NL80211_QCA
5279 if (params->req_key_mgmt_offload && params->psk &&
5280 (params->key_mgmt_suite == WPA_KEY_MGMT_PSK ||
5281 params->key_mgmt_suite == WPA_KEY_MGMT_PSK_SHA256 ||
5282 params->key_mgmt_suite == WPA_KEY_MGMT_FT_PSK)) {
5283 wpa_printf(MSG_DEBUG, "nl80211: Key management set PSK");
5284 ret = issue_key_mgmt_set_key(drv, params->psk, 32);
5285 if (ret)
5286 return ret;
5287 }
5288 #endif /* CONFIG_DRIVER_NL80211_QCA */
5289
5290 wpa_printf(MSG_DEBUG, "nl80211: Connect (ifindex=%d)", drv->ifindex);
5291 msg = nl80211_drv_msg(drv, 0, NL80211_CMD_CONNECT);
5292 if (!msg)
5293 return -1;
5294
5295 ret = nl80211_connect_common(drv, params, msg);
5296 if (ret)
5297 goto fail;
5298
5299 algs = 0;
5300 if (params->auth_alg & WPA_AUTH_ALG_OPEN)
5301 algs++;
5302 if (params->auth_alg & WPA_AUTH_ALG_SHARED)
5303 algs++;
5304 if (params->auth_alg & WPA_AUTH_ALG_LEAP)
5305 algs++;
5306 if (algs > 1) {
5307 wpa_printf(MSG_DEBUG, " * Leave out Auth Type for automatic "
5308 "selection");
5309 goto skip_auth_type;
5310 }
5311
5312 if (params->auth_alg & WPA_AUTH_ALG_OPEN)
5313 type = NL80211_AUTHTYPE_OPEN_SYSTEM;
5314 else if (params->auth_alg & WPA_AUTH_ALG_SHARED)
5315 type = NL80211_AUTHTYPE_SHARED_KEY;
5316 else if (params->auth_alg & WPA_AUTH_ALG_LEAP)
5317 type = NL80211_AUTHTYPE_NETWORK_EAP;
5318 else if (params->auth_alg & WPA_AUTH_ALG_FT)
5319 type = NL80211_AUTHTYPE_FT;
5320 else
5321 goto fail;
5322
5323 wpa_printf(MSG_DEBUG, " * Auth Type %d", type);
5324 if (nla_put_u32(msg, NL80211_ATTR_AUTH_TYPE, type))
5325 goto fail;
5326
5327 skip_auth_type:
5328 ret = nl80211_set_conn_keys(params, msg);
5329 if (ret)
5330 goto fail;
5331
5332 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
5333 msg = NULL;
5334 if (ret) {
5335 wpa_printf(MSG_DEBUG, "nl80211: MLME connect failed: ret=%d "
5336 "(%s)", ret, strerror(-ret));
5337 } else {
5338 wpa_printf(MSG_DEBUG,
5339 "nl80211: Connect request send successfully");
5340 }
5341
5342 fail:
5343 nlmsg_free(msg);
5344 return ret;
5345
5346 }
5347
5348
5349 static int wpa_driver_nl80211_connect(
5350 struct wpa_driver_nl80211_data *drv,
5351 struct wpa_driver_associate_params *params)
5352 {
5353 int ret;
5354
5355 /* Store the connection attempted bssid for future use */
5356 if (params->bssid)
5357 os_memcpy(drv->auth_attempt_bssid, params->bssid, ETH_ALEN);
5358 else
5359 os_memset(drv->auth_attempt_bssid, 0, ETH_ALEN);
5360
5361 ret = wpa_driver_nl80211_try_connect(drv, params);
5362 if (ret == -EALREADY) {
5363 /*
5364 * cfg80211 does not currently accept new connections if
5365 * we are already connected. As a workaround, force
5366 * disconnection and try again.
5367 */
5368 wpa_printf(MSG_DEBUG, "nl80211: Explicitly "
5369 "disconnecting before reassociation "
5370 "attempt");
5371 if (wpa_driver_nl80211_disconnect(
5372 drv, WLAN_REASON_PREV_AUTH_NOT_VALID))
5373 return -1;
5374 ret = wpa_driver_nl80211_try_connect(drv, params);
5375 }
5376 return ret;
5377 }
5378
5379
5380 static int wpa_driver_nl80211_associate(
5381 void *priv, struct wpa_driver_associate_params *params)
5382 {
5383 struct i802_bss *bss = priv;
5384 struct wpa_driver_nl80211_data *drv = bss->drv;
5385 int ret = -1;
5386 struct nl_msg *msg;
5387
5388 nl80211_unmask_11b_rates(bss);
5389
5390 if (params->mode == IEEE80211_MODE_AP)
5391 return wpa_driver_nl80211_ap(drv, params);
5392
5393 if (params->mode == IEEE80211_MODE_IBSS)
5394 return wpa_driver_nl80211_ibss(drv, params);
5395
5396 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_SME)) {
5397 enum nl80211_iftype nlmode = params->p2p ?
5398 NL80211_IFTYPE_P2P_CLIENT : NL80211_IFTYPE_STATION;
5399
5400 if (wpa_driver_nl80211_set_mode(priv, nlmode) < 0)
5401 return -1;
5402 return wpa_driver_nl80211_connect(drv, params);
5403 }
5404
5405 nl80211_mark_disconnected(drv);
5406
5407 wpa_printf(MSG_DEBUG, "nl80211: Associate (ifindex=%d)",
5408 drv->ifindex);
5409 msg = nl80211_drv_msg(drv, 0, NL80211_CMD_ASSOCIATE);
5410 if (!msg)
5411 return -1;
5412
5413 ret = nl80211_connect_common(drv, params, msg);
5414 if (ret)
5415 goto fail;
5416
5417 if (params->fils_kek) {
5418 wpa_printf(MSG_DEBUG, " * FILS KEK (len=%u)",
5419 (unsigned int) params->fils_kek_len);
5420 if (nla_put(msg, NL80211_ATTR_FILS_KEK, params->fils_kek_len,
5421 params->fils_kek))
5422 goto fail;
5423 }
5424 if (params->fils_nonces) {
5425 wpa_hexdump(MSG_DEBUG, " * FILS nonces (for AAD)",
5426 params->fils_nonces,
5427 params->fils_nonces_len);
5428 if (nla_put(msg, NL80211_ATTR_FILS_NONCES,
5429 params->fils_nonces_len, params->fils_nonces))
5430 goto fail;
5431 }
5432
5433 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
5434 msg = NULL;
5435 if (ret) {
5436 wpa_dbg(drv->ctx, MSG_DEBUG,
5437 "nl80211: MLME command failed (assoc): ret=%d (%s)",
5438 ret, strerror(-ret));
5439 nl80211_dump_scan(drv);
5440 } else {
5441 wpa_printf(MSG_DEBUG,
5442 "nl80211: Association request send successfully");
5443 }
5444
5445 fail:
5446 nlmsg_free(msg);
5447 return ret;
5448 }
5449
5450
5451 static int nl80211_set_mode(struct wpa_driver_nl80211_data *drv,
5452 int ifindex, enum nl80211_iftype mode)
5453 {
5454 struct nl_msg *msg;
5455 int ret = -ENOBUFS;
5456
5457 wpa_printf(MSG_DEBUG, "nl80211: Set mode ifindex %d iftype %d (%s)",
5458 ifindex, mode, nl80211_iftype_str(mode));
5459
5460 msg = nl80211_cmd_msg(drv->first_bss, 0, NL80211_CMD_SET_INTERFACE);
5461 if (!msg || nla_put_u32(msg, NL80211_ATTR_IFTYPE, mode))
5462 goto fail;
5463
5464 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
5465 msg = NULL;
5466 if (!ret)
5467 return 0;
5468 fail:
5469 nlmsg_free(msg);
5470 wpa_printf(MSG_DEBUG, "nl80211: Failed to set interface %d to mode %d:"
5471 " %d (%s)", ifindex, mode, ret, strerror(-ret));
5472 return ret;
5473 }
5474
5475
5476 static int wpa_driver_nl80211_set_mode_impl(
5477 struct i802_bss *bss,
5478 enum nl80211_iftype nlmode,
5479 struct hostapd_freq_params *desired_freq_params)
5480 {
5481 struct wpa_driver_nl80211_data *drv = bss->drv;
5482 int ret = -1;
5483 int i;
5484 int was_ap = is_ap_interface(drv->nlmode);
5485 int res;
5486 int mode_switch_res;
5487
5488 if (TEST_FAIL())
5489 return -1;
5490
5491 mode_switch_res = nl80211_set_mode(drv, drv->ifindex, nlmode);
5492 if (mode_switch_res && nlmode == nl80211_get_ifmode(bss))
5493 mode_switch_res = 0;
5494
5495 if (mode_switch_res == 0) {
5496 drv->nlmode = nlmode;
5497 ret = 0;
5498 goto done;
5499 }
5500
5501 if (mode_switch_res == -ENODEV)
5502 return -1;
5503
5504 if (nlmode == drv->nlmode) {
5505 wpa_printf(MSG_DEBUG, "nl80211: Interface already in "
5506 "requested mode - ignore error");
5507 ret = 0;
5508 goto done; /* Already in the requested mode */
5509 }
5510
5511 /* mac80211 doesn't allow mode changes while the device is up, so
5512 * take the device down, try to set the mode again, and bring the
5513 * device back up.
5514 */
5515 wpa_printf(MSG_DEBUG, "nl80211: Try mode change after setting "
5516 "interface down");
5517 for (i = 0; i < 10; i++) {
5518 res = i802_set_iface_flags(bss, 0);
5519 if (res == -EACCES || res == -ENODEV)
5520 break;
5521 if (res != 0) {
5522 wpa_printf(MSG_DEBUG, "nl80211: Failed to set "
5523 "interface down");
5524 os_sleep(0, 100000);
5525 continue;
5526 }
5527
5528 /*
5529 * Setting the mode will fail for some drivers if the phy is
5530 * on a frequency that the mode is disallowed in.
5531 */
5532 if (desired_freq_params) {
5533 res = nl80211_set_channel(bss, desired_freq_params, 0);
5534 if (res) {
5535 wpa_printf(MSG_DEBUG,
5536 "nl80211: Failed to set frequency on interface");
5537 }
5538 }
5539
5540 /* Try to set the mode again while the interface is down */
5541 mode_switch_res = nl80211_set_mode(drv, drv->ifindex, nlmode);
5542 if (mode_switch_res == -EBUSY) {
5543 wpa_printf(MSG_DEBUG,
5544 "nl80211: Delaying mode set while interface going down");
5545 os_sleep(0, 100000);
5546 continue;
5547 }
5548 ret = mode_switch_res;
5549 break;
5550 }
5551
5552 if (!ret) {
5553 wpa_printf(MSG_DEBUG, "nl80211: Mode change succeeded while "
5554 "interface is down");
5555 drv->nlmode = nlmode;
5556 drv->ignore_if_down_event = 1;
5557 }
5558
5559 /* Bring the interface back up */
5560 res = linux_set_iface_flags(drv->global->ioctl_sock, bss->ifname, 1);
5561 if (res != 0) {
5562 wpa_printf(MSG_DEBUG,
5563 "nl80211: Failed to set interface up after switching mode");
5564 ret = -1;
5565 }
5566
5567 done:
5568 if (ret) {
5569 wpa_printf(MSG_DEBUG, "nl80211: Interface mode change to %d "
5570 "from %d failed", nlmode, drv->nlmode);
5571 return ret;
5572 }
5573
5574 if (is_p2p_net_interface(nlmode)) {
5575 wpa_printf(MSG_DEBUG,
5576 "nl80211: Interface %s mode change to P2P - disable 11b rates",
5577 bss->ifname);
5578 nl80211_disable_11b_rates(drv, drv->ifindex, 1);
5579 } else if (drv->disabled_11b_rates) {
5580 wpa_printf(MSG_DEBUG,
5581 "nl80211: Interface %s mode changed to non-P2P - re-enable 11b rates",
5582 bss->ifname);
5583 nl80211_disable_11b_rates(drv, drv->ifindex, 0);
5584 }
5585
5586 if (is_ap_interface(nlmode)) {
5587 nl80211_mgmt_unsubscribe(bss, "start AP");
5588 /* Setup additional AP mode functionality if needed */
5589 if (nl80211_setup_ap(bss))
5590 return -1;
5591 } else if (was_ap) {
5592 /* Remove additional AP mode functionality */
5593 nl80211_teardown_ap(bss);
5594 } else {
5595 nl80211_mgmt_unsubscribe(bss, "mode change");
5596 }
5597
5598 if (is_mesh_interface(nlmode) &&
5599 nl80211_mgmt_subscribe_mesh(bss))
5600 return -1;
5601
5602 if (!bss->in_deinit && !is_ap_interface(nlmode) &&
5603 !is_mesh_interface(nlmode) &&
5604 nl80211_mgmt_subscribe_non_ap(bss) < 0)
5605 wpa_printf(MSG_DEBUG, "nl80211: Failed to register Action "
5606 "frame processing - ignore for now");
5607
5608 return 0;
5609 }
5610
5611
5612 int wpa_driver_nl80211_set_mode(struct i802_bss *bss,
5613 enum nl80211_iftype nlmode)
5614 {
5615 return wpa_driver_nl80211_set_mode_impl(bss, nlmode, NULL);
5616 }
5617
5618
5619 static int wpa_driver_nl80211_set_mode_ibss(struct i802_bss *bss,
5620 struct hostapd_freq_params *freq)
5621 {
5622 return wpa_driver_nl80211_set_mode_impl(bss, NL80211_IFTYPE_ADHOC,
5623 freq);
5624 }
5625
5626
5627 static int wpa_driver_nl80211_get_capa(void *priv,
5628 struct wpa_driver_capa *capa)
5629 {
5630 struct i802_bss *bss = priv;
5631 struct wpa_driver_nl80211_data *drv = bss->drv;
5632
5633 if (!drv->has_capability)
5634 return -1;
5635 os_memcpy(capa, &drv->capa, sizeof(*capa));
5636 if (drv->extended_capa && drv->extended_capa_mask) {
5637 capa->extended_capa = drv->extended_capa;
5638 capa->extended_capa_mask = drv->extended_capa_mask;
5639 capa->extended_capa_len = drv->extended_capa_len;
5640 }
5641
5642 return 0;
5643 }
5644
5645
5646 static int wpa_driver_nl80211_set_operstate(void *priv, int state)
5647 {
5648 struct i802_bss *bss = priv;
5649 struct wpa_driver_nl80211_data *drv = bss->drv;
5650
5651 wpa_printf(MSG_DEBUG, "nl80211: Set %s operstate %d->%d (%s)",
5652 bss->ifname, drv->operstate, state,
5653 state ? "UP" : "DORMANT");
5654 drv->operstate = state;
5655 return netlink_send_oper_ifla(drv->global->netlink, drv->ifindex, -1,
5656 state ? IF_OPER_UP : IF_OPER_DORMANT);
5657 }
5658
5659
5660 static int wpa_driver_nl80211_set_supp_port(void *priv, int authorized)
5661 {
5662 struct i802_bss *bss = priv;
5663 struct wpa_driver_nl80211_data *drv = bss->drv;
5664 struct nl_msg *msg;
5665 struct nl80211_sta_flag_update upd;
5666 int ret;
5667
5668 if (!drv->associated && is_zero_ether_addr(drv->bssid) && !authorized) {
5669 wpa_printf(MSG_DEBUG, "nl80211: Skip set_supp_port(unauthorized) while not associated");
5670 return 0;
5671 }
5672
5673 wpa_printf(MSG_DEBUG, "nl80211: Set supplicant port %sauthorized for "
5674 MACSTR, authorized ? "" : "un", MAC2STR(drv->bssid));
5675
5676 os_memset(&upd, 0, sizeof(upd));
5677 upd.mask = BIT(NL80211_STA_FLAG_AUTHORIZED);
5678 if (authorized)
5679 upd.set = BIT(NL80211_STA_FLAG_AUTHORIZED);
5680
5681 if (!(msg = nl80211_bss_msg(bss, 0, NL80211_CMD_SET_STATION)) ||
5682 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, drv->bssid) ||
5683 nla_put(msg, NL80211_ATTR_STA_FLAGS2, sizeof(upd), &upd)) {
5684 nlmsg_free(msg);
5685 return -ENOBUFS;
5686 }
5687
5688 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
5689 if (!ret)
5690 return 0;
5691 wpa_printf(MSG_DEBUG, "nl80211: Failed to set STA flag: %d (%s)",
5692 ret, strerror(-ret));
5693 return ret;
5694 }
5695
5696
5697 /* Set kernel driver on given frequency (MHz) */
5698 static int i802_set_freq(void *priv, struct hostapd_freq_params *freq)
5699 {
5700 struct i802_bss *bss = priv;
5701 return nl80211_set_channel(bss, freq, 0);
5702 }
5703
5704
5705 static inline int min_int(int a, int b)
5706 {
5707 if (a < b)
5708 return a;
5709 return b;
5710 }
5711
5712
5713 static int get_key_handler(struct nl_msg *msg, void *arg)
5714 {
5715 struct nlattr *tb[NL80211_ATTR_MAX + 1];
5716 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
5717
5718 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
5719 genlmsg_attrlen(gnlh, 0), NULL);
5720
5721 /*
5722 * TODO: validate the key index and mac address!
5723 * Otherwise, there's a race condition as soon as
5724 * the kernel starts sending key notifications.
5725 */
5726
5727 if (tb[NL80211_ATTR_KEY_SEQ])
5728 memcpy(arg, nla_data(tb[NL80211_ATTR_KEY_SEQ]),
5729 min_int(nla_len(tb[NL80211_ATTR_KEY_SEQ]), 6));
5730 return NL_SKIP;
5731 }
5732
5733
5734 static int i802_get_seqnum(const char *iface, void *priv, const u8 *addr,
5735 int idx, u8 *seq)
5736 {
5737 struct i802_bss *bss = priv;
5738 struct wpa_driver_nl80211_data *drv = bss->drv;
5739 struct nl_msg *msg;
5740
5741 msg = nl80211_ifindex_msg(drv, if_nametoindex(iface), 0,
5742 NL80211_CMD_GET_KEY);
5743 if (!msg ||
5744 (addr && nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr)) ||
5745 nla_put_u8(msg, NL80211_ATTR_KEY_IDX, idx)) {
5746 nlmsg_free(msg);
5747 return -ENOBUFS;
5748 }
5749
5750 memset(seq, 0, 6);
5751
5752 return send_and_recv_msgs(drv, msg, get_key_handler, seq);
5753 }
5754
5755
5756 static int i802_set_rts(void *priv, int rts)
5757 {
5758 struct i802_bss *bss = priv;
5759 struct wpa_driver_nl80211_data *drv = bss->drv;
5760 struct nl_msg *msg;
5761 int ret;
5762 u32 val;
5763
5764 if (rts >= 2347)
5765 val = (u32) -1;
5766 else
5767 val = rts;
5768
5769 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_SET_WIPHY)) ||
5770 nla_put_u32(msg, NL80211_ATTR_WIPHY_RTS_THRESHOLD, val)) {
5771 nlmsg_free(msg);
5772 return -ENOBUFS;
5773 }
5774
5775 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
5776 if (!ret)
5777 return 0;
5778 wpa_printf(MSG_DEBUG, "nl80211: Failed to set RTS threshold %d: "
5779 "%d (%s)", rts, ret, strerror(-ret));
5780 return ret;
5781 }
5782
5783
5784 static int i802_set_frag(void *priv, int frag)
5785 {
5786 struct i802_bss *bss = priv;
5787 struct wpa_driver_nl80211_data *drv = bss->drv;
5788 struct nl_msg *msg;
5789 int ret;
5790 u32 val;
5791
5792 if (frag >= 2346)
5793 val = (u32) -1;
5794 else
5795 val = frag;
5796
5797 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_SET_WIPHY)) ||
5798 nla_put_u32(msg, NL80211_ATTR_WIPHY_FRAG_THRESHOLD, val)) {
5799 nlmsg_free(msg);
5800 return -ENOBUFS;
5801 }
5802
5803 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
5804 if (!ret)
5805 return 0;
5806 wpa_printf(MSG_DEBUG, "nl80211: Failed to set fragmentation threshold "
5807 "%d: %d (%s)", frag, ret, strerror(-ret));
5808 return ret;
5809 }
5810
5811
5812 static int i802_flush(void *priv)
5813 {
5814 struct i802_bss *bss = priv;
5815 struct nl_msg *msg;
5816 int res;
5817
5818 wpa_printf(MSG_DEBUG, "nl80211: flush -> DEL_STATION %s (all)",
5819 bss->ifname);
5820
5821 /*
5822 * XXX: FIX! this needs to flush all VLANs too
5823 */
5824 msg = nl80211_bss_msg(bss, 0, NL80211_CMD_DEL_STATION);
5825 res = send_and_recv_msgs(bss->drv, msg, NULL, NULL);
5826 if (res) {
5827 wpa_printf(MSG_DEBUG, "nl80211: Station flush failed: ret=%d "
5828 "(%s)", res, strerror(-res));
5829 }
5830 return res;
5831 }
5832
5833
5834 static int get_sta_handler(struct nl_msg *msg, void *arg)
5835 {
5836 struct nlattr *tb[NL80211_ATTR_MAX + 1];
5837 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
5838 struct hostap_sta_driver_data *data = arg;
5839 struct nlattr *stats[NL80211_STA_INFO_MAX + 1];
5840 static struct nla_policy stats_policy[NL80211_STA_INFO_MAX + 1] = {
5841 [NL80211_STA_INFO_INACTIVE_TIME] = { .type = NLA_U32 },
5842 [NL80211_STA_INFO_RX_BYTES] = { .type = NLA_U32 },
5843 [NL80211_STA_INFO_TX_BYTES] = { .type = NLA_U32 },
5844 [NL80211_STA_INFO_RX_PACKETS] = { .type = NLA_U32 },
5845 [NL80211_STA_INFO_TX_PACKETS] = { .type = NLA_U32 },
5846 [NL80211_STA_INFO_TX_FAILED] = { .type = NLA_U32 },
5847 [NL80211_STA_INFO_RX_BYTES64] = { .type = NLA_U64 },
5848 [NL80211_STA_INFO_TX_BYTES64] = { .type = NLA_U64 },
5849 };
5850
5851 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
5852 genlmsg_attrlen(gnlh, 0), NULL);
5853
5854 /*
5855 * TODO: validate the interface and mac address!
5856 * Otherwise, there's a race condition as soon as
5857 * the kernel starts sending station notifications.
5858 */
5859
5860 if (!tb[NL80211_ATTR_STA_INFO]) {
5861 wpa_printf(MSG_DEBUG, "sta stats missing!");
5862 return NL_SKIP;
5863 }
5864 if (nla_parse_nested(stats, NL80211_STA_INFO_MAX,
5865 tb[NL80211_ATTR_STA_INFO],
5866 stats_policy)) {
5867 wpa_printf(MSG_DEBUG, "failed to parse nested attributes!");
5868 return NL_SKIP;
5869 }
5870
5871 if (stats[NL80211_STA_INFO_INACTIVE_TIME])
5872 data->inactive_msec =
5873 nla_get_u32(stats[NL80211_STA_INFO_INACTIVE_TIME]);
5874 /* For backwards compatibility, fetch the 32-bit counters first. */
5875 if (stats[NL80211_STA_INFO_RX_BYTES])
5876 data->rx_bytes = nla_get_u32(stats[NL80211_STA_INFO_RX_BYTES]);
5877 if (stats[NL80211_STA_INFO_TX_BYTES])
5878 data->tx_bytes = nla_get_u32(stats[NL80211_STA_INFO_TX_BYTES]);
5879 if (stats[NL80211_STA_INFO_RX_BYTES64] &&
5880 stats[NL80211_STA_INFO_TX_BYTES64]) {
5881 /*
5882 * The driver supports 64-bit counters, so use them to override
5883 * the 32-bit values.
5884 */
5885 data->rx_bytes =
5886 nla_get_u64(stats[NL80211_STA_INFO_RX_BYTES64]);
5887 data->tx_bytes =
5888 nla_get_u64(stats[NL80211_STA_INFO_TX_BYTES64]);
5889 data->bytes_64bit = 1;
5890 }
5891 if (stats[NL80211_STA_INFO_RX_PACKETS])
5892 data->rx_packets =
5893 nla_get_u32(stats[NL80211_STA_INFO_RX_PACKETS]);
5894 if (stats[NL80211_STA_INFO_TX_PACKETS])
5895 data->tx_packets =
5896 nla_get_u32(stats[NL80211_STA_INFO_TX_PACKETS]);
5897 if (stats[NL80211_STA_INFO_TX_FAILED])
5898 data->tx_retry_failed =
5899 nla_get_u32(stats[NL80211_STA_INFO_TX_FAILED]);
5900
5901 return NL_SKIP;
5902 }
5903
5904 static int i802_read_sta_data(struct i802_bss *bss,
5905 struct hostap_sta_driver_data *data,
5906 const u8 *addr)
5907 {
5908 struct nl_msg *msg;
5909
5910 if (!(msg = nl80211_bss_msg(bss, 0, NL80211_CMD_GET_STATION)) ||
5911 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr)) {
5912 nlmsg_free(msg);
5913 return -ENOBUFS;
5914 }
5915
5916 return send_and_recv_msgs(bss->drv, msg, get_sta_handler, data);
5917 }
5918
5919
5920 static int i802_set_tx_queue_params(void *priv, int queue, int aifs,
5921 int cw_min, int cw_max, int burst_time)
5922 {
5923 struct i802_bss *bss = priv;
5924 struct wpa_driver_nl80211_data *drv = bss->drv;
5925 struct nl_msg *msg;
5926 struct nlattr *txq, *params;
5927
5928 msg = nl80211_bss_msg(bss, 0, NL80211_CMD_SET_WIPHY);
5929 if (!msg)
5930 return -1;
5931
5932 txq = nla_nest_start(msg, NL80211_ATTR_WIPHY_TXQ_PARAMS);
5933 if (!txq)
5934 goto fail;
5935
5936 /* We are only sending parameters for a single TXQ at a time */
5937 params = nla_nest_start(msg, 1);
5938 if (!params)
5939 goto fail;
5940
5941 switch (queue) {
5942 case 0:
5943 if (nla_put_u8(msg, NL80211_TXQ_ATTR_QUEUE, NL80211_TXQ_Q_VO))
5944 goto fail;
5945 break;
5946 case 1:
5947 if (nla_put_u8(msg, NL80211_TXQ_ATTR_QUEUE, NL80211_TXQ_Q_VI))
5948 goto fail;
5949 break;
5950 case 2:
5951 if (nla_put_u8(msg, NL80211_TXQ_ATTR_QUEUE, NL80211_TXQ_Q_BE))
5952 goto fail;
5953 break;
5954 case 3:
5955 if (nla_put_u8(msg, NL80211_TXQ_ATTR_QUEUE, NL80211_TXQ_Q_BK))
5956 goto fail;
5957 break;
5958 }
5959 /* Burst time is configured in units of 0.1 msec and TXOP parameter in
5960 * 32 usec, so need to convert the value here. */
5961 if (nla_put_u16(msg, NL80211_TXQ_ATTR_TXOP,
5962 (burst_time * 100 + 16) / 32) ||
5963 nla_put_u16(msg, NL80211_TXQ_ATTR_CWMIN, cw_min) ||
5964 nla_put_u16(msg, NL80211_TXQ_ATTR_CWMAX, cw_max) ||
5965 nla_put_u8(msg, NL80211_TXQ_ATTR_AIFS, aifs))
5966 goto fail;
5967
5968 nla_nest_end(msg, params);
5969
5970 nla_nest_end(msg, txq);
5971
5972 if (send_and_recv_msgs(drv, msg, NULL, NULL) == 0)
5973 return 0;
5974 msg = NULL;
5975 fail:
5976 nlmsg_free(msg);
5977 return -1;
5978 }
5979
5980
5981 static int i802_set_sta_vlan(struct i802_bss *bss, const u8 *addr,
5982 const char *ifname, int vlan_id)
5983 {
5984 struct wpa_driver_nl80211_data *drv = bss->drv;
5985 struct nl_msg *msg;
5986 int ret;
5987
5988 wpa_printf(MSG_DEBUG, "nl80211: %s[%d]: set_sta_vlan(" MACSTR
5989 ", ifname=%s[%d], vlan_id=%d)",
5990 bss->ifname, if_nametoindex(bss->ifname),
5991 MAC2STR(addr), ifname, if_nametoindex(ifname), vlan_id);
5992 if (!(msg = nl80211_bss_msg(bss, 0, NL80211_CMD_SET_STATION)) ||
5993 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
5994 nla_put_u32(msg, NL80211_ATTR_STA_VLAN, if_nametoindex(ifname))) {
5995 nlmsg_free(msg);
5996 return -ENOBUFS;
5997 }
5998
5999 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
6000 if (ret < 0) {
6001 wpa_printf(MSG_ERROR, "nl80211: NL80211_ATTR_STA_VLAN (addr="
6002 MACSTR " ifname=%s vlan_id=%d) failed: %d (%s)",
6003 MAC2STR(addr), ifname, vlan_id, ret,
6004 strerror(-ret));
6005 }
6006 return ret;
6007 }
6008
6009
6010 static int i802_get_inact_sec(void *priv, const u8 *addr)
6011 {
6012 struct hostap_sta_driver_data data;
6013 int ret;
6014
6015 os_memset(&data, 0, sizeof(data));
6016 data.inactive_msec = (unsigned long) -1;
6017 ret = i802_read_sta_data(priv, &data, addr);
6018 if (ret == -ENOENT)
6019 return -ENOENT;
6020 if (ret || data.inactive_msec == (unsigned long) -1)
6021 return -1;
6022 return data.inactive_msec / 1000;
6023 }
6024
6025
6026 static int i802_sta_clear_stats(void *priv, const u8 *addr)
6027 {
6028 #if 0
6029 /* TODO */
6030 #endif
6031 return 0;
6032 }
6033
6034
6035 static int i802_sta_deauth(void *priv, const u8 *own_addr, const u8 *addr,
6036 int reason)
6037 {
6038 struct i802_bss *bss = priv;
6039 struct wpa_driver_nl80211_data *drv = bss->drv;
6040 struct ieee80211_mgmt mgmt;
6041 u8 channel;
6042
6043 if (ieee80211_freq_to_chan(bss->freq, &channel) ==
6044 HOSTAPD_MODE_IEEE80211AD) {
6045 /* Deauthentication is not used in DMG/IEEE 802.11ad;
6046 * disassociate the STA instead. */
6047 return i802_sta_disassoc(priv, own_addr, addr, reason);
6048 }
6049
6050 if (is_mesh_interface(drv->nlmode))
6051 return -1;
6052
6053 if (drv->device_ap_sme)
6054 return wpa_driver_nl80211_sta_remove(bss, addr, 1, reason);
6055
6056 memset(&mgmt, 0, sizeof(mgmt));
6057 mgmt.frame_control = IEEE80211_FC(WLAN_FC_TYPE_MGMT,
6058 WLAN_FC_STYPE_DEAUTH);
6059 memcpy(mgmt.da, addr, ETH_ALEN);
6060 memcpy(mgmt.sa, own_addr, ETH_ALEN);
6061 memcpy(mgmt.bssid, own_addr, ETH_ALEN);
6062 mgmt.u.deauth.reason_code = host_to_le16(reason);
6063 return wpa_driver_nl80211_send_mlme(bss, (u8 *) &mgmt,
6064 IEEE80211_HDRLEN +
6065 sizeof(mgmt.u.deauth), 0, 0, 0, 0,
6066 0, NULL, 0);
6067 }
6068
6069
6070 static int i802_sta_disassoc(void *priv, const u8 *own_addr, const u8 *addr,
6071 int reason)
6072 {
6073 struct i802_bss *bss = priv;
6074 struct wpa_driver_nl80211_data *drv = bss->drv;
6075 struct ieee80211_mgmt mgmt;
6076
6077 if (is_mesh_interface(drv->nlmode))
6078 return -1;
6079
6080 if (drv->device_ap_sme)
6081 return wpa_driver_nl80211_sta_remove(bss, addr, 0, reason);
6082
6083 memset(&mgmt, 0, sizeof(mgmt));
6084 mgmt.frame_control = IEEE80211_FC(WLAN_FC_TYPE_MGMT,
6085 WLAN_FC_STYPE_DISASSOC);
6086 memcpy(mgmt.da, addr, ETH_ALEN);
6087 memcpy(mgmt.sa, own_addr, ETH_ALEN);
6088 memcpy(mgmt.bssid, own_addr, ETH_ALEN);
6089 mgmt.u.disassoc.reason_code = host_to_le16(reason);
6090 return wpa_driver_nl80211_send_mlme(bss, (u8 *) &mgmt,
6091 IEEE80211_HDRLEN +
6092 sizeof(mgmt.u.disassoc), 0, 0, 0, 0,
6093 0, NULL, 0);
6094 }
6095
6096
6097 static void dump_ifidx(struct wpa_driver_nl80211_data *drv)
6098 {
6099 char buf[200], *pos, *end;
6100 int i, res;
6101
6102 pos = buf;
6103 end = pos + sizeof(buf);
6104
6105 for (i = 0; i < drv->num_if_indices; i++) {
6106 if (!drv->if_indices[i])
6107 continue;
6108 res = os_snprintf(pos, end - pos, " %d(%d)",
6109 drv->if_indices[i],
6110 drv->if_indices_reason[i]);
6111 if (os_snprintf_error(end - pos, res))
6112 break;
6113 pos += res;
6114 }
6115 *pos = '\0';
6116
6117 wpa_printf(MSG_DEBUG, "nl80211: if_indices[%d]:%s",
6118 drv->num_if_indices, buf);
6119 }
6120
6121
6122 static void add_ifidx(struct wpa_driver_nl80211_data *drv, int ifidx,
6123 int ifidx_reason)
6124 {
6125 int i;
6126 int *old, *old_reason;
6127
6128 wpa_printf(MSG_DEBUG,
6129 "nl80211: Add own interface ifindex %d (ifidx_reason %d)",
6130 ifidx, ifidx_reason);
6131 if (have_ifidx(drv, ifidx, ifidx_reason)) {
6132 wpa_printf(MSG_DEBUG, "nl80211: ifindex %d already in the list",
6133 ifidx);
6134 return;
6135 }
6136 for (i = 0; i < drv->num_if_indices; i++) {
6137 if (drv->if_indices[i] == 0) {
6138 drv->if_indices[i] = ifidx;
6139 drv->if_indices_reason[i] = ifidx_reason;
6140 dump_ifidx(drv);
6141 return;
6142 }
6143 }
6144
6145 if (drv->if_indices != drv->default_if_indices)
6146 old = drv->if_indices;
6147 else
6148 old = NULL;
6149
6150 if (drv->if_indices_reason != drv->default_if_indices_reason)
6151 old_reason = drv->if_indices_reason;
6152 else
6153 old_reason = NULL;
6154
6155 drv->if_indices = os_realloc_array(old, drv->num_if_indices + 1,
6156 sizeof(int));
6157 drv->if_indices_reason = os_realloc_array(old_reason,
6158 drv->num_if_indices + 1,
6159 sizeof(int));
6160 if (!drv->if_indices) {
6161 if (!old)
6162 drv->if_indices = drv->default_if_indices;
6163 else
6164 drv->if_indices = old;
6165 }
6166 if (!drv->if_indices_reason) {
6167 if (!old_reason)
6168 drv->if_indices_reason = drv->default_if_indices_reason;
6169 else
6170 drv->if_indices_reason = old_reason;
6171 }
6172 if (!drv->if_indices || !drv->if_indices_reason) {
6173 wpa_printf(MSG_ERROR, "Failed to reallocate memory for "
6174 "interfaces");
6175 wpa_printf(MSG_ERROR, "Ignoring EAPOL on interface %d", ifidx);
6176 return;
6177 }
6178 if (!old)
6179 os_memcpy(drv->if_indices, drv->default_if_indices,
6180 sizeof(drv->default_if_indices));
6181 if (!old_reason)
6182 os_memcpy(drv->if_indices_reason,
6183 drv->default_if_indices_reason,
6184 sizeof(drv->default_if_indices_reason));
6185 drv->if_indices[drv->num_if_indices] = ifidx;
6186 drv->if_indices_reason[drv->num_if_indices] = ifidx_reason;
6187 drv->num_if_indices++;
6188 dump_ifidx(drv);
6189 }
6190
6191
6192 static void del_ifidx(struct wpa_driver_nl80211_data *drv, int ifidx,
6193 int ifidx_reason)
6194 {
6195 int i;
6196
6197 for (i = 0; i < drv->num_if_indices; i++) {
6198 if ((drv->if_indices[i] == ifidx || ifidx == IFIDX_ANY) &&
6199 (drv->if_indices_reason[i] == ifidx_reason ||
6200 ifidx_reason == IFIDX_ANY)) {
6201 drv->if_indices[i] = 0;
6202 break;
6203 }
6204 }
6205 dump_ifidx(drv);
6206 }
6207
6208
6209 static int have_ifidx(struct wpa_driver_nl80211_data *drv, int ifidx,
6210 int ifidx_reason)
6211 {
6212 int i;
6213
6214 for (i = 0; i < drv->num_if_indices; i++)
6215 if (drv->if_indices[i] == ifidx &&
6216 (drv->if_indices_reason[i] == ifidx_reason ||
6217 ifidx_reason == IFIDX_ANY))
6218 return 1;
6219
6220 return 0;
6221 }
6222
6223
6224 static int i802_set_wds_sta(void *priv, const u8 *addr, int aid, int val,
6225 const char *bridge_ifname, char *ifname_wds)
6226 {
6227 struct i802_bss *bss = priv;
6228 struct wpa_driver_nl80211_data *drv = bss->drv;
6229 char name[IFNAMSIZ + 1];
6230
6231 os_snprintf(name, sizeof(name), "%s.sta%d", bss->ifname, aid);
6232 if (ifname_wds)
6233 os_strlcpy(ifname_wds, name, IFNAMSIZ + 1);
6234
6235 wpa_printf(MSG_DEBUG, "nl80211: Set WDS STA addr=" MACSTR
6236 " aid=%d val=%d name=%s", MAC2STR(addr), aid, val, name);
6237 if (val) {
6238 if (!if_nametoindex(name)) {
6239 if (nl80211_create_iface(drv, name,
6240 NL80211_IFTYPE_AP_VLAN,
6241 bss->addr, 1, NULL, NULL, 0) <
6242 0)
6243 return -1;
6244 if (bridge_ifname &&
6245 linux_br_add_if(drv->global->ioctl_sock,
6246 bridge_ifname, name) < 0)
6247 return -1;
6248 }
6249 if (linux_set_iface_flags(drv->global->ioctl_sock, name, 1)) {
6250 wpa_printf(MSG_ERROR, "nl80211: Failed to set WDS STA "
6251 "interface %s up", name);
6252 }
6253 return i802_set_sta_vlan(priv, addr, name, 0);
6254 } else {
6255 if (bridge_ifname)
6256 linux_br_del_if(drv->global->ioctl_sock, bridge_ifname,
6257 name);
6258
6259 i802_set_sta_vlan(priv, addr, bss->ifname, 0);
6260 nl80211_remove_iface(drv, if_nametoindex(name));
6261 return 0;
6262 }
6263 }
6264
6265
6266 static void handle_eapol(int sock, void *eloop_ctx, void *sock_ctx)
6267 {
6268 struct wpa_driver_nl80211_data *drv = eloop_ctx;
6269 struct sockaddr_ll lladdr;
6270 unsigned char buf[3000];
6271 int len;
6272 socklen_t fromlen = sizeof(lladdr);
6273
6274 len = recvfrom(sock, buf, sizeof(buf), 0,
6275 (struct sockaddr *)&lladdr, &fromlen);
6276 if (len < 0) {
6277 wpa_printf(MSG_ERROR, "nl80211: EAPOL recv failed: %s",
6278 strerror(errno));
6279 return;
6280 }
6281
6282 if (have_ifidx(drv, lladdr.sll_ifindex, IFIDX_ANY))
6283 drv_event_eapol_rx(drv->ctx, lladdr.sll_addr, buf, len);
6284 }
6285
6286
6287 static int i802_check_bridge(struct wpa_driver_nl80211_data *drv,
6288 struct i802_bss *bss,
6289 const char *brname, const char *ifname)
6290 {
6291 int br_ifindex;
6292 char in_br[IFNAMSIZ];
6293
6294 os_strlcpy(bss->brname, brname, IFNAMSIZ);
6295 br_ifindex = if_nametoindex(brname);
6296 if (br_ifindex == 0) {
6297 /*
6298 * Bridge was configured, but the bridge device does
6299 * not exist. Try to add it now.
6300 */
6301 if (linux_br_add(drv->global->ioctl_sock, brname) < 0) {
6302 wpa_printf(MSG_ERROR, "nl80211: Failed to add the "
6303 "bridge interface %s: %s",
6304 brname, strerror(errno));
6305 return -1;
6306 }
6307 bss->added_bridge = 1;
6308 br_ifindex = if_nametoindex(brname);
6309 add_ifidx(drv, br_ifindex, drv->ifindex);
6310 }
6311 bss->br_ifindex = br_ifindex;
6312
6313 if (linux_br_get(in_br, ifname) == 0) {
6314 if (os_strcmp(in_br, brname) == 0)
6315 return 0; /* already in the bridge */
6316
6317 wpa_printf(MSG_DEBUG, "nl80211: Removing interface %s from "
6318 "bridge %s", ifname, in_br);
6319 if (linux_br_del_if(drv->global->ioctl_sock, in_br, ifname) <
6320 0) {
6321 wpa_printf(MSG_ERROR, "nl80211: Failed to "
6322 "remove interface %s from bridge "
6323 "%s: %s",
6324 ifname, brname, strerror(errno));
6325 return -1;
6326 }
6327 }
6328
6329 wpa_printf(MSG_DEBUG, "nl80211: Adding interface %s into bridge %s",
6330 ifname, brname);
6331 if (linux_br_add_if(drv->global->ioctl_sock, brname, ifname) < 0) {
6332 wpa_printf(MSG_ERROR, "nl80211: Failed to add interface %s "
6333 "into bridge %s: %s",
6334 ifname, brname, strerror(errno));
6335 return -1;
6336 }
6337 bss->added_if_into_bridge = 1;
6338
6339 return 0;
6340 }
6341
6342
6343 static void *i802_init(struct hostapd_data *hapd,
6344 struct wpa_init_params *params)
6345 {
6346 struct wpa_driver_nl80211_data *drv;
6347 struct i802_bss *bss;
6348 size_t i;
6349 char master_ifname[IFNAMSIZ];
6350 int ifindex, br_ifindex = 0;
6351 int br_added = 0;
6352
6353 bss = wpa_driver_nl80211_drv_init(hapd, params->ifname,
6354 params->global_priv, 1,
6355 params->bssid, params->driver_params);
6356 if (bss == NULL)
6357 return NULL;
6358
6359 drv = bss->drv;
6360
6361 if (linux_br_get(master_ifname, params->ifname) == 0) {
6362 wpa_printf(MSG_DEBUG, "nl80211: Interface %s is in bridge %s",
6363 params->ifname, master_ifname);
6364 br_ifindex = if_nametoindex(master_ifname);
6365 os_strlcpy(bss->brname, master_ifname, IFNAMSIZ);
6366 } else if ((params->num_bridge == 0 || !params->bridge[0]) &&
6367 linux_master_get(master_ifname, params->ifname) == 0) {
6368 wpa_printf(MSG_DEBUG, "nl80211: Interface %s is in master %s",
6369 params->ifname, master_ifname);
6370 /* start listening for EAPOL on the master interface */
6371 add_ifidx(drv, if_nametoindex(master_ifname), drv->ifindex);
6372
6373 /* check if master itself is under bridge */
6374 if (linux_br_get(master_ifname, master_ifname) == 0) {
6375 wpa_printf(MSG_DEBUG, "nl80211: which is in bridge %s",
6376 master_ifname);
6377 br_ifindex = if_nametoindex(master_ifname);
6378 os_strlcpy(bss->brname, master_ifname, IFNAMSIZ);
6379 }
6380 } else {
6381 master_ifname[0] = '\0';
6382 }
6383
6384 bss->br_ifindex = br_ifindex;
6385
6386 for (i = 0; i < params->num_bridge; i++) {
6387 if (params->bridge[i]) {
6388 ifindex = if_nametoindex(params->bridge[i]);
6389 if (ifindex)
6390 add_ifidx(drv, ifindex, drv->ifindex);
6391 if (ifindex == br_ifindex)
6392 br_added = 1;
6393 }
6394 }
6395
6396 /* start listening for EAPOL on the default AP interface */
6397 add_ifidx(drv, drv->ifindex, IFIDX_ANY);
6398
6399 if (params->num_bridge && params->bridge[0]) {
6400 if (i802_check_bridge(drv, bss, params->bridge[0],
6401 params->ifname) < 0)
6402 goto failed;
6403 if (os_strcmp(params->bridge[0], master_ifname) != 0)
6404 br_added = 1;
6405 }
6406
6407 if (!br_added && br_ifindex &&
6408 (params->num_bridge == 0 || !params->bridge[0]))
6409 add_ifidx(drv, br_ifindex, drv->ifindex);
6410
6411 #ifdef CONFIG_LIBNL3_ROUTE
6412 if (bss->added_if_into_bridge) {
6413 drv->rtnl_sk = nl_socket_alloc();
6414 if (drv->rtnl_sk == NULL) {
6415 wpa_printf(MSG_ERROR, "nl80211: Failed to allocate nl_sock");
6416 goto failed;
6417 }
6418
6419 if (nl_connect(drv->rtnl_sk, NETLINK_ROUTE)) {
6420 wpa_printf(MSG_ERROR, "nl80211: Failed to connect nl_sock to NETLINK_ROUTE: %s",
6421 strerror(errno));
6422 goto failed;
6423 }
6424 }
6425 #endif /* CONFIG_LIBNL3_ROUTE */
6426
6427 drv->eapol_sock = socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_PAE));
6428 if (drv->eapol_sock < 0) {
6429 wpa_printf(MSG_ERROR, "nl80211: socket(PF_PACKET, SOCK_DGRAM, ETH_P_PAE) failed: %s",
6430 strerror(errno));
6431 goto failed;
6432 }
6433
6434 if (eloop_register_read_sock(drv->eapol_sock, handle_eapol, drv, NULL))
6435 {
6436 wpa_printf(MSG_INFO, "nl80211: Could not register read socket for eapol");
6437 goto failed;
6438 }
6439
6440 if (linux_get_ifhwaddr(drv->global->ioctl_sock, bss->ifname,
6441 params->own_addr))
6442 goto failed;
6443 os_memcpy(drv->perm_addr, params->own_addr, ETH_ALEN);
6444
6445 memcpy(bss->addr, params->own_addr, ETH_ALEN);
6446
6447 return bss;
6448
6449 failed:
6450 wpa_driver_nl80211_deinit(bss);
6451 return NULL;
6452 }
6453
6454
6455 static void i802_deinit(void *priv)
6456 {
6457 struct i802_bss *bss = priv;
6458 wpa_driver_nl80211_deinit(bss);
6459 }
6460
6461
6462 static enum nl80211_iftype wpa_driver_nl80211_if_type(
6463 enum wpa_driver_if_type type)
6464 {
6465 switch (type) {
6466 case WPA_IF_STATION:
6467 return NL80211_IFTYPE_STATION;
6468 case WPA_IF_P2P_CLIENT:
6469 case WPA_IF_P2P_GROUP:
6470 return NL80211_IFTYPE_P2P_CLIENT;
6471 case WPA_IF_AP_VLAN:
6472 return NL80211_IFTYPE_AP_VLAN;
6473 case WPA_IF_AP_BSS:
6474 return NL80211_IFTYPE_AP;
6475 case WPA_IF_P2P_GO:
6476 return NL80211_IFTYPE_P2P_GO;
6477 case WPA_IF_P2P_DEVICE:
6478 return NL80211_IFTYPE_P2P_DEVICE;
6479 case WPA_IF_MESH:
6480 return NL80211_IFTYPE_MESH_POINT;
6481 default:
6482 return -1;
6483 }
6484 }
6485
6486
6487 static int nl80211_addr_in_use(struct nl80211_global *global, const u8 *addr)
6488 {
6489 struct wpa_driver_nl80211_data *drv;
6490 dl_list_for_each(drv, &global->interfaces,
6491 struct wpa_driver_nl80211_data, list) {
6492 if (os_memcmp(addr, drv->first_bss->addr, ETH_ALEN) == 0)
6493 return 1;
6494 }
6495 return 0;
6496 }
6497
6498
6499 static int nl80211_vif_addr(struct wpa_driver_nl80211_data *drv, u8 *new_addr)
6500 {
6501 unsigned int idx;
6502
6503 if (!drv->global)
6504 return -1;
6505
6506 os_memcpy(new_addr, drv->first_bss->addr, ETH_ALEN);
6507 for (idx = 0; idx < 64; idx++) {
6508 new_addr[0] = drv->first_bss->addr[0] | 0x02;
6509 new_addr[0] ^= idx << 2;
6510 if (!nl80211_addr_in_use(drv->global, new_addr))
6511 break;
6512 }
6513 if (idx == 64)
6514 return -1;
6515
6516 wpa_printf(MSG_DEBUG, "nl80211: Assigned new virtual interface address "
6517 MACSTR, MAC2STR(new_addr));
6518
6519 return 0;
6520 }
6521
6522
6523 struct wdev_info {
6524 u64 wdev_id;
6525 int wdev_id_set;
6526 u8 macaddr[ETH_ALEN];
6527 };
6528
6529 static int nl80211_wdev_handler(struct nl_msg *msg, void *arg)
6530 {
6531 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
6532 struct nlattr *tb[NL80211_ATTR_MAX + 1];
6533 struct wdev_info *wi = arg;
6534
6535 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
6536 genlmsg_attrlen(gnlh, 0), NULL);
6537 if (tb[NL80211_ATTR_WDEV]) {
6538 wi->wdev_id = nla_get_u64(tb[NL80211_ATTR_WDEV]);
6539 wi->wdev_id_set = 1;
6540 }
6541
6542 if (tb[NL80211_ATTR_MAC])
6543 os_memcpy(wi->macaddr, nla_data(tb[NL80211_ATTR_MAC]),
6544 ETH_ALEN);
6545
6546 return NL_SKIP;
6547 }
6548
6549
6550 static int wpa_driver_nl80211_if_add(void *priv, enum wpa_driver_if_type type,
6551 const char *ifname, const u8 *addr,
6552 void *bss_ctx, void **drv_priv,
6553 char *force_ifname, u8 *if_addr,
6554 const char *bridge, int use_existing,
6555 int setup_ap)
6556 {
6557 enum nl80211_iftype nlmode;
6558 struct i802_bss *bss = priv;
6559 struct wpa_driver_nl80211_data *drv = bss->drv;
6560 int ifidx;
6561 int added = 1;
6562
6563 if (addr)
6564 os_memcpy(if_addr, addr, ETH_ALEN);
6565 nlmode = wpa_driver_nl80211_if_type(type);
6566 if (nlmode == NL80211_IFTYPE_P2P_DEVICE) {
6567 struct wdev_info p2pdev_info;
6568
6569 os_memset(&p2pdev_info, 0, sizeof(p2pdev_info));
6570 ifidx = nl80211_create_iface(drv, ifname, nlmode, addr,
6571 0, nl80211_wdev_handler,
6572 &p2pdev_info, use_existing);
6573 if (!p2pdev_info.wdev_id_set || ifidx != 0) {
6574 wpa_printf(MSG_ERROR, "nl80211: Failed to create a P2P Device interface %s",
6575 ifname);
6576 return -1;
6577 }
6578
6579 drv->global->if_add_wdevid = p2pdev_info.wdev_id;
6580 drv->global->if_add_wdevid_set = p2pdev_info.wdev_id_set;
6581 if (!is_zero_ether_addr(p2pdev_info.macaddr))
6582 os_memcpy(if_addr, p2pdev_info.macaddr, ETH_ALEN);
6583 wpa_printf(MSG_DEBUG, "nl80211: New P2P Device interface %s (0x%llx) created",
6584 ifname,
6585 (long long unsigned int) p2pdev_info.wdev_id);
6586 } else {
6587 ifidx = nl80211_create_iface(drv, ifname, nlmode, addr,
6588 0, NULL, NULL, use_existing);
6589 if (use_existing && ifidx == -ENFILE) {
6590 added = 0;
6591 ifidx = if_nametoindex(ifname);
6592 } else if (ifidx < 0) {
6593 return -1;
6594 }
6595 }
6596
6597 if (!addr) {
6598 if (nlmode == NL80211_IFTYPE_P2P_DEVICE)
6599 os_memcpy(if_addr, bss->addr, ETH_ALEN);
6600 else if (linux_get_ifhwaddr(drv->global->ioctl_sock,
6601 ifname, if_addr) < 0) {
6602 if (added)
6603 nl80211_remove_iface(drv, ifidx);
6604 return -1;
6605 }
6606 }
6607
6608 if (!addr &&
6609 (type == WPA_IF_P2P_CLIENT || type == WPA_IF_P2P_GROUP ||
6610 type == WPA_IF_P2P_GO || type == WPA_IF_MESH ||
6611 type == WPA_IF_STATION)) {
6612 /* Enforce unique address */
6613 u8 new_addr[ETH_ALEN];
6614
6615 if (linux_get_ifhwaddr(drv->global->ioctl_sock, ifname,
6616 new_addr) < 0) {
6617 if (added)
6618 nl80211_remove_iface(drv, ifidx);
6619 return -1;
6620 }
6621 if (nl80211_addr_in_use(drv->global, new_addr)) {
6622 wpa_printf(MSG_DEBUG, "nl80211: Allocate new address "
6623 "for interface %s type %d", ifname, type);
6624 if (nl80211_vif_addr(drv, new_addr) < 0) {
6625 if (added)
6626 nl80211_remove_iface(drv, ifidx);
6627 return -1;
6628 }
6629 if (linux_set_ifhwaddr(drv->global->ioctl_sock, ifname,
6630 new_addr) < 0) {
6631 if (added)
6632 nl80211_remove_iface(drv, ifidx);
6633 return -1;
6634 }
6635 }
6636 os_memcpy(if_addr, new_addr, ETH_ALEN);
6637 }
6638
6639 if (type == WPA_IF_AP_BSS && setup_ap) {
6640 struct i802_bss *new_bss = os_zalloc(sizeof(*new_bss));
6641 if (new_bss == NULL) {
6642 if (added)
6643 nl80211_remove_iface(drv, ifidx);
6644 return -1;
6645 }
6646
6647 if (bridge &&
6648 i802_check_bridge(drv, new_bss, bridge, ifname) < 0) {
6649 wpa_printf(MSG_ERROR, "nl80211: Failed to add the new "
6650 "interface %s to a bridge %s",
6651 ifname, bridge);
6652 if (added)
6653 nl80211_remove_iface(drv, ifidx);
6654 os_free(new_bss);
6655 return -1;
6656 }
6657
6658 if (linux_set_iface_flags(drv->global->ioctl_sock, ifname, 1))
6659 {
6660 if (added)
6661 nl80211_remove_iface(drv, ifidx);
6662 os_free(new_bss);
6663 return -1;
6664 }
6665 os_strlcpy(new_bss->ifname, ifname, IFNAMSIZ);
6666 os_memcpy(new_bss->addr, if_addr, ETH_ALEN);
6667 new_bss->ifindex = ifidx;
6668 new_bss->drv = drv;
6669 new_bss->next = drv->first_bss->next;
6670 new_bss->freq = drv->first_bss->freq;
6671 new_bss->ctx = bss_ctx;
6672 new_bss->added_if = added;
6673 drv->first_bss->next = new_bss;
6674 if (drv_priv)
6675 *drv_priv = new_bss;
6676 nl80211_init_bss(new_bss);
6677
6678 /* Subscribe management frames for this WPA_IF_AP_BSS */
6679 if (nl80211_setup_ap(new_bss))
6680 return -1;
6681 }
6682
6683 if (drv->global)
6684 drv->global->if_add_ifindex = ifidx;
6685
6686 /*
6687 * Some virtual interfaces need to process EAPOL packets and events on
6688 * the parent interface. This is used mainly with hostapd.
6689 */
6690 if (ifidx > 0 &&
6691 (drv->hostapd ||
6692 nlmode == NL80211_IFTYPE_AP_VLAN ||
6693 nlmode == NL80211_IFTYPE_WDS ||
6694 nlmode == NL80211_IFTYPE_MONITOR))
6695 add_ifidx(drv, ifidx, IFIDX_ANY);
6696
6697 return 0;
6698 }
6699
6700
6701 static int wpa_driver_nl80211_if_remove(struct i802_bss *bss,
6702 enum wpa_driver_if_type type,
6703 const char *ifname)
6704 {
6705 struct wpa_driver_nl80211_data *drv = bss->drv;
6706 int ifindex = if_nametoindex(ifname);
6707
6708 wpa_printf(MSG_DEBUG, "nl80211: %s(type=%d ifname=%s) ifindex=%d added_if=%d",
6709 __func__, type, ifname, ifindex, bss->added_if);
6710 if (ifindex > 0 && (bss->added_if || bss->ifindex != ifindex))
6711 nl80211_remove_iface(drv, ifindex);
6712 else if (ifindex > 0 && !bss->added_if) {
6713 struct wpa_driver_nl80211_data *drv2;
6714 dl_list_for_each(drv2, &drv->global->interfaces,
6715 struct wpa_driver_nl80211_data, list) {
6716 del_ifidx(drv2, ifindex, IFIDX_ANY);
6717 del_ifidx(drv2, IFIDX_ANY, ifindex);
6718 }
6719 }
6720
6721 if (type != WPA_IF_AP_BSS)
6722 return 0;
6723
6724 if (bss->added_if_into_bridge) {
6725 if (linux_br_del_if(drv->global->ioctl_sock, bss->brname,
6726 bss->ifname) < 0)
6727 wpa_printf(MSG_INFO, "nl80211: Failed to remove "
6728 "interface %s from bridge %s: %s",
6729 bss->ifname, bss->brname, strerror(errno));
6730 }
6731 if (bss->added_bridge) {
6732 if (linux_br_del(drv->global->ioctl_sock, bss->brname) < 0)
6733 wpa_printf(MSG_INFO, "nl80211: Failed to remove "
6734 "bridge %s: %s",
6735 bss->brname, strerror(errno));
6736 }
6737
6738 if (bss != drv->first_bss) {
6739 struct i802_bss *tbss;
6740
6741 wpa_printf(MSG_DEBUG, "nl80211: Not the first BSS - remove it");
6742 for (tbss = drv->first_bss; tbss; tbss = tbss->next) {
6743 if (tbss->next == bss) {
6744 tbss->next = bss->next;
6745 /* Unsubscribe management frames */
6746 nl80211_teardown_ap(bss);
6747 nl80211_destroy_bss(bss);
6748 if (!bss->added_if)
6749 i802_set_iface_flags(bss, 0);
6750 os_free(bss);
6751 bss = NULL;
6752 break;
6753 }
6754 }
6755 if (bss)
6756 wpa_printf(MSG_INFO, "nl80211: %s - could not find "
6757 "BSS %p in the list", __func__, bss);
6758 } else {
6759 wpa_printf(MSG_DEBUG, "nl80211: First BSS - reassign context");
6760 nl80211_teardown_ap(bss);
6761 if (!bss->added_if && !drv->first_bss->next)
6762 wpa_driver_nl80211_del_beacon(bss);
6763 nl80211_destroy_bss(bss);
6764 if (!bss->added_if)
6765 i802_set_iface_flags(bss, 0);
6766 if (drv->first_bss->next) {
6767 drv->first_bss = drv->first_bss->next;
6768 drv->ctx = drv->first_bss->ctx;
6769 os_free(bss);
6770 } else {
6771 wpa_printf(MSG_DEBUG, "nl80211: No second BSS to reassign context to");
6772 }
6773 }
6774
6775 return 0;
6776 }
6777
6778
6779 static int cookie_handler(struct nl_msg *msg, void *arg)
6780 {
6781 struct nlattr *tb[NL80211_ATTR_MAX + 1];
6782 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
6783 u64 *cookie = arg;
6784 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
6785 genlmsg_attrlen(gnlh, 0), NULL);
6786 if (tb[NL80211_ATTR_COOKIE])
6787 *cookie = nla_get_u64(tb[NL80211_ATTR_COOKIE]);
6788 return NL_SKIP;
6789 }
6790
6791
6792 static int nl80211_send_frame_cmd(struct i802_bss *bss,
6793 unsigned int freq, unsigned int wait,
6794 const u8 *buf, size_t buf_len,
6795 u64 *cookie_out, int no_cck, int no_ack,
6796 int offchanok, const u16 *csa_offs,
6797 size_t csa_offs_len)
6798 {
6799 struct wpa_driver_nl80211_data *drv = bss->drv;
6800 struct nl_msg *msg;
6801 u64 cookie;
6802 int ret = -1;
6803
6804 wpa_printf(MSG_MSGDUMP, "nl80211: CMD_FRAME freq=%u wait=%u no_cck=%d "
6805 "no_ack=%d offchanok=%d",
6806 freq, wait, no_cck, no_ack, offchanok);
6807 wpa_hexdump(MSG_MSGDUMP, "CMD_FRAME", buf, buf_len);
6808
6809 if (!(msg = nl80211_cmd_msg(bss, 0, NL80211_CMD_FRAME)) ||
6810 (freq && nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, freq)) ||
6811 (wait && nla_put_u32(msg, NL80211_ATTR_DURATION, wait)) ||
6812 (offchanok && ((drv->capa.flags & WPA_DRIVER_FLAGS_OFFCHANNEL_TX) ||
6813 drv->test_use_roc_tx) &&
6814 nla_put_flag(msg, NL80211_ATTR_OFFCHANNEL_TX_OK)) ||
6815 (no_cck && nla_put_flag(msg, NL80211_ATTR_TX_NO_CCK_RATE)) ||
6816 (no_ack && nla_put_flag(msg, NL80211_ATTR_DONT_WAIT_FOR_ACK)) ||
6817 (csa_offs && nla_put(msg, NL80211_ATTR_CSA_C_OFFSETS_TX,
6818 csa_offs_len * sizeof(u16), csa_offs)) ||
6819 nla_put(msg, NL80211_ATTR_FRAME, buf_len, buf))
6820 goto fail;
6821
6822 cookie = 0;
6823 ret = send_and_recv_msgs(drv, msg, cookie_handler, &cookie);
6824 msg = NULL;
6825 if (ret) {
6826 wpa_printf(MSG_DEBUG, "nl80211: Frame command failed: ret=%d "
6827 "(%s) (freq=%u wait=%u)", ret, strerror(-ret),
6828 freq, wait);
6829 } else {
6830 wpa_printf(MSG_MSGDUMP, "nl80211: Frame TX command accepted%s; "
6831 "cookie 0x%llx", no_ack ? " (no ACK)" : "",
6832 (long long unsigned int) cookie);
6833
6834 if (cookie_out)
6835 *cookie_out = no_ack ? (u64) -1 : cookie;
6836
6837 if (drv->num_send_action_cookies == MAX_SEND_ACTION_COOKIES) {
6838 wpa_printf(MSG_DEBUG,
6839 "nl80211: Drop oldest pending send action cookie 0x%llx",
6840 (long long unsigned int)
6841 drv->send_action_cookies[0]);
6842 os_memmove(&drv->send_action_cookies[0],
6843 &drv->send_action_cookies[1],
6844 (MAX_SEND_ACTION_COOKIES - 1) *
6845 sizeof(u64));
6846 drv->num_send_action_cookies--;
6847 }
6848 drv->send_action_cookies[drv->num_send_action_cookies] = cookie;
6849 drv->num_send_action_cookies++;
6850 }
6851
6852 fail:
6853 nlmsg_free(msg);
6854 return ret;
6855 }
6856
6857
6858 static int wpa_driver_nl80211_send_action(struct i802_bss *bss,
6859 unsigned int freq,
6860 unsigned int wait_time,
6861 const u8 *dst, const u8 *src,
6862 const u8 *bssid,
6863 const u8 *data, size_t data_len,
6864 int no_cck)
6865 {
6866 struct wpa_driver_nl80211_data *drv = bss->drv;
6867 int ret = -1;
6868 u8 *buf;
6869 struct ieee80211_hdr *hdr;
6870
6871 wpa_printf(MSG_DEBUG, "nl80211: Send Action frame (ifindex=%d, "
6872 "freq=%u MHz wait=%d ms no_cck=%d)",
6873 drv->ifindex, freq, wait_time, no_cck);
6874
6875 buf = os_zalloc(24 + data_len);
6876 if (buf == NULL)
6877 return ret;
6878 os_memcpy(buf + 24, data, data_len);
6879 hdr = (struct ieee80211_hdr *) buf;
6880 hdr->frame_control =
6881 IEEE80211_FC(WLAN_FC_TYPE_MGMT, WLAN_FC_STYPE_ACTION);
6882 os_memcpy(hdr->addr1, dst, ETH_ALEN);
6883 os_memcpy(hdr->addr2, src, ETH_ALEN);
6884 os_memcpy(hdr->addr3, bssid, ETH_ALEN);
6885
6886 if (os_memcmp(bss->addr, src, ETH_ALEN) != 0) {
6887 wpa_printf(MSG_DEBUG, "nl80211: Use random TA " MACSTR,
6888 MAC2STR(src));
6889 os_memcpy(bss->rand_addr, src, ETH_ALEN);
6890 } else {
6891 os_memset(bss->rand_addr, 0, ETH_ALEN);
6892 }
6893
6894 if (is_ap_interface(drv->nlmode) &&
6895 (!(drv->capa.flags & WPA_DRIVER_FLAGS_OFFCHANNEL_TX) ||
6896 (int) freq == bss->freq || drv->device_ap_sme ||
6897 !drv->use_monitor))
6898 ret = wpa_driver_nl80211_send_mlme(bss, buf, 24 + data_len,
6899 0, freq, no_cck, 1,
6900 wait_time, NULL, 0);
6901 else
6902 ret = nl80211_send_frame_cmd(bss, freq, wait_time, buf,
6903 24 + data_len,
6904 &drv->send_action_cookie,
6905 no_cck, 0, 1, NULL, 0);
6906
6907 os_free(buf);
6908 return ret;
6909 }
6910
6911
6912 static void nl80211_frame_wait_cancel(struct i802_bss *bss, u64 cookie)
6913 {
6914 struct wpa_driver_nl80211_data *drv = bss->drv;
6915 struct nl_msg *msg;
6916 int ret;
6917
6918 wpa_printf(MSG_DEBUG, "nl80211: Cancel TX frame wait: cookie=0x%llx",
6919 (long long unsigned int) cookie);
6920 if (!(msg = nl80211_cmd_msg(bss, 0, NL80211_CMD_FRAME_WAIT_CANCEL)) ||
6921 nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie)) {
6922 nlmsg_free(msg);
6923 return;
6924 }
6925
6926 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
6927 if (ret)
6928 wpa_printf(MSG_DEBUG, "nl80211: wait cancel failed: ret=%d "
6929 "(%s)", ret, strerror(-ret));
6930 }
6931
6932
6933 static void wpa_driver_nl80211_send_action_cancel_wait(void *priv)
6934 {
6935 struct i802_bss *bss = priv;
6936 struct wpa_driver_nl80211_data *drv = bss->drv;
6937 unsigned int i;
6938 u64 cookie;
6939
6940 /* Cancel the last pending TX cookie */
6941 nl80211_frame_wait_cancel(bss, drv->send_action_cookie);
6942
6943 /*
6944 * Cancel the other pending TX cookies, if any. This is needed since
6945 * the driver may keep a list of all pending offchannel TX operations
6946 * and free up the radio only once they have expired or cancelled.
6947 */
6948 for (i = drv->num_send_action_cookies; i > 0; i--) {
6949 cookie = drv->send_action_cookies[i - 1];
6950 if (cookie != drv->send_action_cookie)
6951 nl80211_frame_wait_cancel(bss, cookie);
6952 }
6953 drv->num_send_action_cookies = 0;
6954 }
6955
6956
6957 static int wpa_driver_nl80211_remain_on_channel(void *priv, unsigned int freq,
6958 unsigned int duration)
6959 {
6960 struct i802_bss *bss = priv;
6961 struct wpa_driver_nl80211_data *drv = bss->drv;
6962 struct nl_msg *msg;
6963 int ret;
6964 u64 cookie;
6965
6966 if (!(msg = nl80211_cmd_msg(bss, 0, NL80211_CMD_REMAIN_ON_CHANNEL)) ||
6967 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, freq) ||
6968 nla_put_u32(msg, NL80211_ATTR_DURATION, duration)) {
6969 nlmsg_free(msg);
6970 return -1;
6971 }
6972
6973 cookie = 0;
6974 ret = send_and_recv_msgs(drv, msg, cookie_handler, &cookie);
6975 if (ret == 0) {
6976 wpa_printf(MSG_DEBUG, "nl80211: Remain-on-channel cookie "
6977 "0x%llx for freq=%u MHz duration=%u",
6978 (long long unsigned int) cookie, freq, duration);
6979 drv->remain_on_chan_cookie = cookie;
6980 drv->pending_remain_on_chan = 1;
6981 return 0;
6982 }
6983 wpa_printf(MSG_DEBUG, "nl80211: Failed to request remain-on-channel "
6984 "(freq=%d duration=%u): %d (%s)",
6985 freq, duration, ret, strerror(-ret));
6986 return -1;
6987 }
6988
6989
6990 static int wpa_driver_nl80211_cancel_remain_on_channel(void *priv)
6991 {
6992 struct i802_bss *bss = priv;
6993 struct wpa_driver_nl80211_data *drv = bss->drv;
6994 struct nl_msg *msg;
6995 int ret;
6996
6997 if (!drv->pending_remain_on_chan) {
6998 wpa_printf(MSG_DEBUG, "nl80211: No pending remain-on-channel "
6999 "to cancel");
7000 return -1;
7001 }
7002
7003 wpa_printf(MSG_DEBUG, "nl80211: Cancel remain-on-channel with cookie "
7004 "0x%llx",
7005 (long long unsigned int) drv->remain_on_chan_cookie);
7006
7007 msg = nl80211_cmd_msg(bss, 0, NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL);
7008 if (!msg ||
7009 nla_put_u64(msg, NL80211_ATTR_COOKIE, drv->remain_on_chan_cookie)) {
7010 nlmsg_free(msg);
7011 return -1;
7012 }
7013
7014 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
7015 if (ret == 0)
7016 return 0;
7017 wpa_printf(MSG_DEBUG, "nl80211: Failed to cancel remain-on-channel: "
7018 "%d (%s)", ret, strerror(-ret));
7019 return -1;
7020 }
7021
7022
7023 static int wpa_driver_nl80211_probe_req_report(struct i802_bss *bss, int report)
7024 {
7025 struct wpa_driver_nl80211_data *drv = bss->drv;
7026
7027 if (!report) {
7028 if (bss->nl_preq && drv->device_ap_sme &&
7029 is_ap_interface(drv->nlmode) && !bss->in_deinit &&
7030 !bss->static_ap) {
7031 /*
7032 * Do not disable Probe Request reporting that was
7033 * enabled in nl80211_setup_ap().
7034 */
7035 wpa_printf(MSG_DEBUG, "nl80211: Skip disabling of "
7036 "Probe Request reporting nl_preq=%p while "
7037 "in AP mode", bss->nl_preq);
7038 } else if (bss->nl_preq) {
7039 wpa_printf(MSG_DEBUG, "nl80211: Disable Probe Request "
7040 "reporting nl_preq=%p", bss->nl_preq);
7041 nl80211_destroy_eloop_handle(&bss->nl_preq);
7042 }
7043 return 0;
7044 }
7045
7046 if (bss->nl_preq) {
7047 wpa_printf(MSG_DEBUG, "nl80211: Probe Request reporting "
7048 "already on! nl_preq=%p", bss->nl_preq);
7049 return 0;
7050 }
7051
7052 bss->nl_preq = nl_create_handle(drv->global->nl_cb, "preq");
7053 if (bss->nl_preq == NULL)
7054 return -1;
7055 wpa_printf(MSG_DEBUG, "nl80211: Enable Probe Request "
7056 "reporting nl_preq=%p", bss->nl_preq);
7057
7058 if (nl80211_register_frame(bss, bss->nl_preq,
7059 (WLAN_FC_TYPE_MGMT << 2) |
7060 (WLAN_FC_STYPE_PROBE_REQ << 4),
7061 NULL, 0) < 0)
7062 goto out_err;
7063
7064 nl80211_register_eloop_read(&bss->nl_preq,
7065 wpa_driver_nl80211_event_receive,
7066 bss->nl_cb);
7067
7068 return 0;
7069
7070 out_err:
7071 nl_destroy_handles(&bss->nl_preq);
7072 return -1;
7073 }
7074
7075
7076 static int nl80211_disable_11b_rates(struct wpa_driver_nl80211_data *drv,
7077 int ifindex, int disabled)
7078 {
7079 struct nl_msg *msg;
7080 struct nlattr *bands, *band;
7081 int ret;
7082
7083 wpa_printf(MSG_DEBUG,
7084 "nl80211: NL80211_CMD_SET_TX_BITRATE_MASK (ifindex=%d %s)",
7085 ifindex, disabled ? "NL80211_TXRATE_LEGACY=OFDM-only" :
7086 "no NL80211_TXRATE_LEGACY constraint");
7087
7088 msg = nl80211_ifindex_msg(drv, ifindex, 0,
7089 NL80211_CMD_SET_TX_BITRATE_MASK);
7090 if (!msg)
7091 return -1;
7092
7093 bands = nla_nest_start(msg, NL80211_ATTR_TX_RATES);
7094 if (!bands)
7095 goto fail;
7096
7097 /*
7098 * Disable 2 GHz rates 1, 2, 5.5, 11 Mbps by masking out everything
7099 * else apart from 6, 9, 12, 18, 24, 36, 48, 54 Mbps from non-MCS
7100 * rates. All 5 GHz rates are left enabled.
7101 */
7102 band = nla_nest_start(msg, NL80211_BAND_2GHZ);
7103 if (!band ||
7104 (disabled && nla_put(msg, NL80211_TXRATE_LEGACY, 8,
7105 "\x0c\x12\x18\x24\x30\x48\x60\x6c")))
7106 goto fail;
7107 nla_nest_end(msg, band);
7108
7109 nla_nest_end(msg, bands);
7110
7111 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
7112 if (ret) {
7113 wpa_printf(MSG_DEBUG, "nl80211: Set TX rates failed: ret=%d "
7114 "(%s)", ret, strerror(-ret));
7115 } else
7116 drv->disabled_11b_rates = disabled;
7117
7118 return ret;
7119
7120 fail:
7121 nlmsg_free(msg);
7122 return -1;
7123 }
7124
7125
7126 static int wpa_driver_nl80211_deinit_ap(void *priv)
7127 {
7128 struct i802_bss *bss = priv;
7129 struct wpa_driver_nl80211_data *drv = bss->drv;
7130 if (!is_ap_interface(drv->nlmode))
7131 return -1;
7132 wpa_driver_nl80211_del_beacon(bss);
7133 bss->beacon_set = 0;
7134
7135 /*
7136 * If the P2P GO interface was dynamically added, then it is
7137 * possible that the interface change to station is not possible.
7138 */
7139 if (drv->nlmode == NL80211_IFTYPE_P2P_GO && bss->if_dynamic)
7140 return 0;
7141
7142 return wpa_driver_nl80211_set_mode(priv, NL80211_IFTYPE_STATION);
7143 }
7144
7145
7146 static int wpa_driver_nl80211_stop_ap(void *priv)
7147 {
7148 struct i802_bss *bss = priv;
7149 struct wpa_driver_nl80211_data *drv = bss->drv;
7150 if (!is_ap_interface(drv->nlmode))
7151 return -1;
7152 wpa_driver_nl80211_del_beacon(bss);
7153 bss->beacon_set = 0;
7154 return 0;
7155 }
7156
7157
7158 static int wpa_driver_nl80211_deinit_p2p_cli(void *priv)
7159 {
7160 struct i802_bss *bss = priv;
7161 struct wpa_driver_nl80211_data *drv = bss->drv;
7162 if (drv->nlmode != NL80211_IFTYPE_P2P_CLIENT)
7163 return -1;
7164
7165 /*
7166 * If the P2P Client interface was dynamically added, then it is
7167 * possible that the interface change to station is not possible.
7168 */
7169 if (bss->if_dynamic)
7170 return 0;
7171
7172 return wpa_driver_nl80211_set_mode(priv, NL80211_IFTYPE_STATION);
7173 }
7174
7175
7176 static void wpa_driver_nl80211_resume(void *priv)
7177 {
7178 struct i802_bss *bss = priv;
7179 enum nl80211_iftype nlmode = nl80211_get_ifmode(bss);
7180
7181 if (i802_set_iface_flags(bss, 1))
7182 wpa_printf(MSG_DEBUG, "nl80211: Failed to set interface up on resume event");
7183
7184 if (is_p2p_net_interface(nlmode))
7185 nl80211_disable_11b_rates(bss->drv, bss->drv->ifindex, 1);
7186 }
7187
7188
7189 static int nl80211_signal_monitor(void *priv, int threshold, int hysteresis)
7190 {
7191 struct i802_bss *bss = priv;
7192 struct wpa_driver_nl80211_data *drv = bss->drv;
7193 struct nl_msg *msg;
7194 struct nlattr *cqm;
7195
7196 wpa_printf(MSG_DEBUG, "nl80211: Signal monitor threshold=%d "
7197 "hysteresis=%d", threshold, hysteresis);
7198
7199 if (!(msg = nl80211_bss_msg(bss, 0, NL80211_CMD_SET_CQM)) ||
7200 !(cqm = nla_nest_start(msg, NL80211_ATTR_CQM)) ||
7201 nla_put_u32(msg, NL80211_ATTR_CQM_RSSI_THOLD, threshold) ||
7202 nla_put_u32(msg, NL80211_ATTR_CQM_RSSI_HYST, hysteresis)) {
7203 nlmsg_free(msg);
7204 return -1;
7205 }
7206 nla_nest_end(msg, cqm);
7207
7208 return send_and_recv_msgs(drv, msg, NULL, NULL);
7209 }
7210
7211
7212 static int get_channel_width(struct nl_msg *msg, void *arg)
7213 {
7214 struct nlattr *tb[NL80211_ATTR_MAX + 1];
7215 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
7216 struct wpa_signal_info *sig_change = arg;
7217
7218 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
7219 genlmsg_attrlen(gnlh, 0), NULL);
7220
7221 sig_change->center_frq1 = -1;
7222 sig_change->center_frq2 = -1;
7223 sig_change->chanwidth = CHAN_WIDTH_UNKNOWN;
7224
7225 if (tb[NL80211_ATTR_CHANNEL_WIDTH]) {
7226 sig_change->chanwidth = convert2width(
7227 nla_get_u32(tb[NL80211_ATTR_CHANNEL_WIDTH]));
7228 if (tb[NL80211_ATTR_CENTER_FREQ1])
7229 sig_change->center_frq1 =
7230 nla_get_u32(tb[NL80211_ATTR_CENTER_FREQ1]);
7231 if (tb[NL80211_ATTR_CENTER_FREQ2])
7232 sig_change->center_frq2 =
7233 nla_get_u32(tb[NL80211_ATTR_CENTER_FREQ2]);
7234 }
7235
7236 return NL_SKIP;
7237 }
7238
7239
7240 static int nl80211_get_channel_width(struct wpa_driver_nl80211_data *drv,
7241 struct wpa_signal_info *sig)
7242 {
7243 struct nl_msg *msg;
7244
7245 msg = nl80211_drv_msg(drv, 0, NL80211_CMD_GET_INTERFACE);
7246 return send_and_recv_msgs(drv, msg, get_channel_width, sig);
7247 }
7248
7249
7250 static int nl80211_signal_poll(void *priv, struct wpa_signal_info *si)
7251 {
7252 struct i802_bss *bss = priv;
7253 struct wpa_driver_nl80211_data *drv = bss->drv;
7254 int res;
7255
7256 os_memset(si, 0, sizeof(*si));
7257 res = nl80211_get_link_signal(drv, si);
7258 if (res) {
7259 if (drv->nlmode != NL80211_IFTYPE_ADHOC &&
7260 drv->nlmode != NL80211_IFTYPE_MESH_POINT)
7261 return res;
7262 si->current_signal = 0;
7263 }
7264
7265 res = nl80211_get_channel_width(drv, si);
7266 if (res != 0)
7267 return res;
7268
7269 return nl80211_get_link_noise(drv, si);
7270 }
7271
7272
7273 static int nl80211_send_frame(void *priv, const u8 *data, size_t data_len,
7274 int encrypt)
7275 {
7276 struct i802_bss *bss = priv;
7277 return wpa_driver_nl80211_send_frame(bss, data, data_len, encrypt, 0,
7278 0, 0, 0, 0, NULL, 0);
7279 }
7280
7281
7282 static int nl80211_set_param(void *priv, const char *param)
7283 {
7284 struct i802_bss *bss = priv;
7285 struct wpa_driver_nl80211_data *drv = bss->drv;
7286
7287 if (param == NULL)
7288 return 0;
7289 wpa_printf(MSG_DEBUG, "nl80211: driver param='%s'", param);
7290
7291 #ifdef CONFIG_P2P
7292 if (os_strstr(param, "use_p2p_group_interface=1")) {
7293 wpa_printf(MSG_DEBUG, "nl80211: Use separate P2P group "
7294 "interface");
7295 drv->capa.flags |= WPA_DRIVER_FLAGS_P2P_CONCURRENT;
7296 drv->capa.flags |= WPA_DRIVER_FLAGS_P2P_MGMT_AND_NON_P2P;
7297 }
7298 #endif /* CONFIG_P2P */
7299
7300 if (os_strstr(param, "use_monitor=1"))
7301 drv->use_monitor = 1;
7302
7303 if (os_strstr(param, "force_connect_cmd=1")) {
7304 drv->capa.flags &= ~WPA_DRIVER_FLAGS_SME;
7305 drv->force_connect_cmd = 1;
7306 }
7307
7308 if (os_strstr(param, "force_bss_selection=1"))
7309 drv->capa.flags |= WPA_DRIVER_FLAGS_BSS_SELECTION;
7310
7311 if (os_strstr(param, "no_offchannel_tx=1")) {
7312 drv->capa.flags &= ~WPA_DRIVER_FLAGS_OFFCHANNEL_TX;
7313 drv->test_use_roc_tx = 1;
7314 }
7315
7316 return 0;
7317 }
7318
7319
7320 static void * nl80211_global_init(void *ctx)
7321 {
7322 struct nl80211_global *global;
7323 struct netlink_config *cfg;
7324
7325 global = os_zalloc(sizeof(*global));
7326 if (global == NULL)
7327 return NULL;
7328 global->ctx = ctx;
7329 global->ioctl_sock = -1;
7330 dl_list_init(&global->interfaces);
7331 global->if_add_ifindex = -1;
7332
7333 cfg = os_zalloc(sizeof(*cfg));
7334 if (cfg == NULL)
7335 goto err;
7336
7337 cfg->ctx = global;
7338 cfg->newlink_cb = wpa_driver_nl80211_event_rtm_newlink;
7339 cfg->dellink_cb = wpa_driver_nl80211_event_rtm_dellink;
7340 global->netlink = netlink_init(cfg);
7341 if (global->netlink == NULL) {
7342 os_free(cfg);
7343 goto err;
7344 }
7345
7346 if (wpa_driver_nl80211_init_nl_global(global) < 0)
7347 goto err;
7348
7349 global->ioctl_sock = socket(PF_INET, SOCK_DGRAM, 0);
7350 if (global->ioctl_sock < 0) {
7351 wpa_printf(MSG_ERROR, "nl80211: socket(PF_INET,SOCK_DGRAM) failed: %s",
7352 strerror(errno));
7353 goto err;
7354 }
7355
7356 return global;
7357
7358 err:
7359 nl80211_global_deinit(global);
7360 return NULL;
7361 }
7362
7363
7364 static void nl80211_global_deinit(void *priv)
7365 {
7366 struct nl80211_global *global = priv;
7367 if (global == NULL)
7368 return;
7369 if (!dl_list_empty(&global->interfaces)) {
7370 wpa_printf(MSG_ERROR, "nl80211: %u interface(s) remain at "
7371 "nl80211_global_deinit",
7372 dl_list_len(&global->interfaces));
7373 }
7374
7375 if (global->netlink)
7376 netlink_deinit(global->netlink);
7377
7378 nl_destroy_handles(&global->nl);
7379
7380 if (global->nl_event)
7381 nl80211_destroy_eloop_handle(&global->nl_event);
7382
7383 nl_cb_put(global->nl_cb);
7384
7385 if (global->ioctl_sock >= 0)
7386 close(global->ioctl_sock);
7387
7388 os_free(global);
7389 }
7390
7391
7392 static const char * nl80211_get_radio_name(void *priv)
7393 {
7394 struct i802_bss *bss = priv;
7395 struct wpa_driver_nl80211_data *drv = bss->drv;
7396 return drv->phyname;
7397 }
7398
7399
7400 static int nl80211_pmkid(struct i802_bss *bss, int cmd, const u8 *bssid,
7401 const u8 *pmkid)
7402 {
7403 struct nl_msg *msg;
7404
7405 if (!(msg = nl80211_bss_msg(bss, 0, cmd)) ||
7406 (pmkid && nla_put(msg, NL80211_ATTR_PMKID, 16, pmkid)) ||
7407 (bssid && nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))) {
7408 nlmsg_free(msg);
7409 return -ENOBUFS;
7410 }
7411
7412 return send_and_recv_msgs(bss->drv, msg, NULL, NULL);
7413 }
7414
7415
7416 static int nl80211_add_pmkid(void *priv, const u8 *bssid, const u8 *pmkid)
7417 {
7418 struct i802_bss *bss = priv;
7419 wpa_printf(MSG_DEBUG, "nl80211: Add PMKID for " MACSTR, MAC2STR(bssid));
7420 return nl80211_pmkid(bss, NL80211_CMD_SET_PMKSA, bssid, pmkid);
7421 }
7422
7423
7424 static int nl80211_remove_pmkid(void *priv, const u8 *bssid, const u8 *pmkid)
7425 {
7426 struct i802_bss *bss = priv;
7427 wpa_printf(MSG_DEBUG, "nl80211: Delete PMKID for " MACSTR,
7428 MAC2STR(bssid));
7429 return nl80211_pmkid(bss, NL80211_CMD_DEL_PMKSA, bssid, pmkid);
7430 }
7431
7432
7433 static int nl80211_flush_pmkid(void *priv)
7434 {
7435 struct i802_bss *bss = priv;
7436 wpa_printf(MSG_DEBUG, "nl80211: Flush PMKIDs");
7437 return nl80211_pmkid(bss, NL80211_CMD_FLUSH_PMKSA, NULL, NULL);
7438 }
7439
7440
7441 static void clean_survey_results(struct survey_results *survey_results)
7442 {
7443 struct freq_survey *survey, *tmp;
7444
7445 if (dl_list_empty(&survey_results->survey_list))
7446 return;
7447
7448 dl_list_for_each_safe(survey, tmp, &survey_results->survey_list,
7449 struct freq_survey, list) {
7450 dl_list_del(&survey->list);
7451 os_free(survey);
7452 }
7453 }
7454
7455
7456 static void add_survey(struct nlattr **sinfo, u32 ifidx,
7457 struct dl_list *survey_list)
7458 {
7459 struct freq_survey *survey;
7460
7461 survey = os_zalloc(sizeof(struct freq_survey));
7462 if (!survey)
7463 return;
7464
7465 survey->ifidx = ifidx;
7466 survey->freq = nla_get_u32(sinfo[NL80211_SURVEY_INFO_FREQUENCY]);
7467 survey->filled = 0;
7468
7469 if (sinfo[NL80211_SURVEY_INFO_NOISE]) {
7470 survey->nf = (int8_t)
7471 nla_get_u8(sinfo[NL80211_SURVEY_INFO_NOISE]);
7472 survey->filled |= SURVEY_HAS_NF;
7473 }
7474
7475 if (sinfo[NL80211_SURVEY_INFO_CHANNEL_TIME]) {
7476 survey->channel_time =
7477 nla_get_u64(sinfo[NL80211_SURVEY_INFO_CHANNEL_TIME]);
7478 survey->filled |= SURVEY_HAS_CHAN_TIME;
7479 }
7480
7481 if (sinfo[NL80211_SURVEY_INFO_CHANNEL_TIME_BUSY]) {
7482 survey->channel_time_busy =
7483 nla_get_u64(sinfo[NL80211_SURVEY_INFO_CHANNEL_TIME_BUSY]);
7484 survey->filled |= SURVEY_HAS_CHAN_TIME_BUSY;
7485 }
7486
7487 if (sinfo[NL80211_SURVEY_INFO_CHANNEL_TIME_RX]) {
7488 survey->channel_time_rx =
7489 nla_get_u64(sinfo[NL80211_SURVEY_INFO_CHANNEL_TIME_RX]);
7490 survey->filled |= SURVEY_HAS_CHAN_TIME_RX;
7491 }
7492
7493 if (sinfo[NL80211_SURVEY_INFO_CHANNEL_TIME_TX]) {
7494 survey->channel_time_tx =
7495 nla_get_u64(sinfo[NL80211_SURVEY_INFO_CHANNEL_TIME_TX]);
7496 survey->filled |= SURVEY_HAS_CHAN_TIME_TX;
7497 }
7498
7499 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)",
7500 survey->freq,
7501 survey->nf,
7502 (unsigned long int) survey->channel_time,
7503 (unsigned long int) survey->channel_time_busy,
7504 (unsigned long int) survey->channel_time_tx,
7505 (unsigned long int) survey->channel_time_rx,
7506 survey->filled);
7507
7508 dl_list_add_tail(survey_list, &survey->list);
7509 }
7510
7511
7512 static int check_survey_ok(struct nlattr **sinfo, u32 surveyed_freq,
7513 unsigned int freq_filter)
7514 {
7515 if (!freq_filter)
7516 return 1;
7517
7518 return freq_filter == surveyed_freq;
7519 }
7520
7521
7522 static int survey_handler(struct nl_msg *msg, void *arg)
7523 {
7524 struct nlattr *tb[NL80211_ATTR_MAX + 1];
7525 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
7526 struct nlattr *sinfo[NL80211_SURVEY_INFO_MAX + 1];
7527 struct survey_results *survey_results;
7528 u32 surveyed_freq = 0;
7529 u32 ifidx;
7530
7531 static struct nla_policy survey_policy[NL80211_SURVEY_INFO_MAX + 1] = {
7532 [NL80211_SURVEY_INFO_FREQUENCY] = { .type = NLA_U32 },
7533 [NL80211_SURVEY_INFO_NOISE] = { .type = NLA_U8 },
7534 };
7535
7536 survey_results = (struct survey_results *) arg;
7537
7538 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
7539 genlmsg_attrlen(gnlh, 0), NULL);
7540
7541 if (!tb[NL80211_ATTR_IFINDEX])
7542 return NL_SKIP;
7543
7544 ifidx = nla_get_u32(tb[NL80211_ATTR_IFINDEX]);
7545
7546 if (!tb[NL80211_ATTR_SURVEY_INFO])
7547 return NL_SKIP;
7548
7549 if (nla_parse_nested(sinfo, NL80211_SURVEY_INFO_MAX,
7550 tb[NL80211_ATTR_SURVEY_INFO],
7551 survey_policy))
7552 return NL_SKIP;
7553
7554 if (!sinfo[NL80211_SURVEY_INFO_FREQUENCY]) {
7555 wpa_printf(MSG_ERROR, "nl80211: Invalid survey data");
7556 return NL_SKIP;
7557 }
7558
7559 surveyed_freq = nla_get_u32(sinfo[NL80211_SURVEY_INFO_FREQUENCY]);
7560
7561 if (!check_survey_ok(sinfo, surveyed_freq,
7562 survey_results->freq_filter))
7563 return NL_SKIP;
7564
7565 if (survey_results->freq_filter &&
7566 survey_results->freq_filter != surveyed_freq) {
7567 wpa_printf(MSG_EXCESSIVE, "nl80211: Ignoring survey data for freq %d MHz",
7568 surveyed_freq);
7569 return NL_SKIP;
7570 }
7571
7572 add_survey(sinfo, ifidx, &survey_results->survey_list);
7573
7574 return NL_SKIP;
7575 }
7576
7577
7578 static int wpa_driver_nl80211_get_survey(void *priv, unsigned int freq)
7579 {
7580 struct i802_bss *bss = priv;
7581 struct wpa_driver_nl80211_data *drv = bss->drv;
7582 struct nl_msg *msg;
7583 int err;
7584 union wpa_event_data data;
7585 struct survey_results *survey_results;
7586
7587 os_memset(&data, 0, sizeof(data));
7588 survey_results = &data.survey_results;
7589
7590 dl_list_init(&survey_results->survey_list);
7591
7592 msg = nl80211_drv_msg(drv, NLM_F_DUMP, NL80211_CMD_GET_SURVEY);
7593 if (!msg)
7594 return -ENOBUFS;
7595
7596 if (freq)
7597 data.survey_results.freq_filter = freq;
7598
7599 do {
7600 wpa_printf(MSG_DEBUG, "nl80211: Fetch survey data");
7601 err = send_and_recv_msgs(drv, msg, survey_handler,
7602 survey_results);
7603 } while (err > 0);
7604
7605 if (err)
7606 wpa_printf(MSG_ERROR, "nl80211: Failed to process survey data");
7607 else
7608 wpa_supplicant_event(drv->ctx, EVENT_SURVEY, &data);
7609
7610 clean_survey_results(survey_results);
7611 return err;
7612 }
7613
7614
7615 static void nl80211_set_rekey_info(void *priv, const u8 *kek, size_t kek_len,
7616 const u8 *kck, size_t kck_len,
7617 const u8 *replay_ctr)
7618 {
7619 struct i802_bss *bss = priv;
7620 struct wpa_driver_nl80211_data *drv = bss->drv;
7621 struct nlattr *replay_nested;
7622 struct nl_msg *msg;
7623 int ret;
7624
7625 if (!drv->set_rekey_offload)
7626 return;
7627
7628 wpa_printf(MSG_DEBUG, "nl80211: Set rekey offload");
7629 if (!(msg = nl80211_bss_msg(bss, 0, NL80211_CMD_SET_REKEY_OFFLOAD)) ||
7630 !(replay_nested = nla_nest_start(msg, NL80211_ATTR_REKEY_DATA)) ||
7631 nla_put(msg, NL80211_REKEY_DATA_KEK, kek_len, kek) ||
7632 nla_put(msg, NL80211_REKEY_DATA_KCK, kck_len, kck) ||
7633 nla_put(msg, NL80211_REKEY_DATA_REPLAY_CTR, NL80211_REPLAY_CTR_LEN,
7634 replay_ctr)) {
7635 nl80211_nlmsg_clear(msg);
7636 nlmsg_free(msg);
7637 return;
7638 }
7639
7640 nla_nest_end(msg, replay_nested);
7641
7642 ret = send_and_recv_msgs(drv, msg, NULL, (void *) -1);
7643 if (ret == -EOPNOTSUPP) {
7644 wpa_printf(MSG_DEBUG,
7645 "nl80211: Driver does not support rekey offload");
7646 drv->set_rekey_offload = 0;
7647 }
7648 }
7649
7650
7651 static void nl80211_send_null_frame(struct i802_bss *bss, const u8 *own_addr,
7652 const u8 *addr, int qos)
7653 {
7654 /* send data frame to poll STA and check whether
7655 * this frame is ACKed */
7656 struct {
7657 struct ieee80211_hdr hdr;
7658 u16 qos_ctl;
7659 } STRUCT_PACKED nulldata;
7660 size_t size;
7661
7662 /* Send data frame to poll STA and check whether this frame is ACKed */
7663
7664 os_memset(&nulldata, 0, sizeof(nulldata));
7665
7666 if (qos) {
7667 nulldata.hdr.frame_control =
7668 IEEE80211_FC(WLAN_FC_TYPE_DATA,
7669 WLAN_FC_STYPE_QOS_NULL);
7670 size = sizeof(nulldata);
7671 } else {
7672 nulldata.hdr.frame_control =
7673 IEEE80211_FC(WLAN_FC_TYPE_DATA,
7674 WLAN_FC_STYPE_NULLFUNC);
7675 size = sizeof(struct ieee80211_hdr);
7676 }
7677
7678 nulldata.hdr.frame_control |= host_to_le16(WLAN_FC_FROMDS);
7679 os_memcpy(nulldata.hdr.IEEE80211_DA_FROMDS, addr, ETH_ALEN);
7680 os_memcpy(nulldata.hdr.IEEE80211_BSSID_FROMDS, own_addr, ETH_ALEN);
7681 os_memcpy(nulldata.hdr.IEEE80211_SA_FROMDS, own_addr, ETH_ALEN);
7682
7683 if (wpa_driver_nl80211_send_mlme(bss, (u8 *) &nulldata, size, 0, 0, 0,
7684 0, 0, NULL, 0) < 0)
7685 wpa_printf(MSG_DEBUG, "nl80211_send_null_frame: Failed to "
7686 "send poll frame");
7687 }
7688
7689 static void nl80211_poll_client(void *priv, const u8 *own_addr, const u8 *addr,
7690 int qos)
7691 {
7692 struct i802_bss *bss = priv;
7693 struct wpa_driver_nl80211_data *drv = bss->drv;
7694 struct nl_msg *msg;
7695 int ret;
7696
7697 if (!drv->poll_command_supported) {
7698 nl80211_send_null_frame(bss, own_addr, addr, qos);
7699 return;
7700 }
7701
7702 if (!(msg = nl80211_bss_msg(bss, 0, NL80211_CMD_PROBE_CLIENT)) ||
7703 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr)) {
7704 nlmsg_free(msg);
7705 return;
7706 }
7707
7708 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
7709 if (ret < 0) {
7710 wpa_printf(MSG_DEBUG, "nl80211: Client probe request for "
7711 MACSTR " failed: ret=%d (%s)",
7712 MAC2STR(addr), ret, strerror(-ret));
7713 }
7714 }
7715
7716
7717 static int nl80211_set_power_save(struct i802_bss *bss, int enabled)
7718 {
7719 struct nl_msg *msg;
7720
7721 if (!(msg = nl80211_bss_msg(bss, 0, NL80211_CMD_SET_POWER_SAVE)) ||
7722 nla_put_u32(msg, NL80211_ATTR_PS_STATE,
7723 enabled ? NL80211_PS_ENABLED : NL80211_PS_DISABLED)) {
7724 nlmsg_free(msg);
7725 return -ENOBUFS;
7726 }
7727 return send_and_recv_msgs(bss->drv, msg, NULL, NULL);
7728 }
7729
7730
7731 static int nl80211_set_p2p_powersave(void *priv, int legacy_ps, int opp_ps,
7732 int ctwindow)
7733 {
7734 struct i802_bss *bss = priv;
7735
7736 wpa_printf(MSG_DEBUG, "nl80211: set_p2p_powersave (legacy_ps=%d "
7737 "opp_ps=%d ctwindow=%d)", legacy_ps, opp_ps, ctwindow);
7738
7739 if (opp_ps != -1 || ctwindow != -1) {
7740 #ifdef ANDROID_P2P
7741 wpa_driver_set_p2p_ps(priv, legacy_ps, opp_ps, ctwindow);
7742 #else /* ANDROID_P2P */
7743 return -1; /* Not yet supported */
7744 #endif /* ANDROID_P2P */
7745 }
7746
7747 if (legacy_ps == -1)
7748 return 0;
7749 if (legacy_ps != 0 && legacy_ps != 1)
7750 return -1; /* Not yet supported */
7751
7752 return nl80211_set_power_save(bss, legacy_ps);
7753 }
7754
7755
7756 static int nl80211_start_radar_detection(void *priv,
7757 struct hostapd_freq_params *freq)
7758 {
7759 struct i802_bss *bss = priv;
7760 struct wpa_driver_nl80211_data *drv = bss->drv;
7761 struct nl_msg *msg;
7762 int ret;
7763
7764 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)",
7765 freq->freq, freq->ht_enabled, freq->vht_enabled,
7766 freq->bandwidth, freq->center_freq1, freq->center_freq2);
7767
7768 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_RADAR)) {
7769 wpa_printf(MSG_DEBUG, "nl80211: Driver does not support radar "
7770 "detection");
7771 return -1;
7772 }
7773
7774 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_RADAR_DETECT)) ||
7775 nl80211_put_freq_params(msg, freq) < 0) {
7776 nlmsg_free(msg);
7777 return -1;
7778 }
7779
7780 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
7781 if (ret == 0)
7782 return 0;
7783 wpa_printf(MSG_DEBUG, "nl80211: Failed to start radar detection: "
7784 "%d (%s)", ret, strerror(-ret));
7785 return -1;
7786 }
7787
7788 #ifdef CONFIG_TDLS
7789
7790 static int nl80211_send_tdls_mgmt(void *priv, const u8 *dst, u8 action_code,
7791 u8 dialog_token, u16 status_code,
7792 u32 peer_capab, int initiator, const u8 *buf,
7793 size_t len)
7794 {
7795 struct i802_bss *bss = priv;
7796 struct wpa_driver_nl80211_data *drv = bss->drv;
7797 struct nl_msg *msg;
7798
7799 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_TDLS_SUPPORT))
7800 return -EOPNOTSUPP;
7801
7802 if (!dst)
7803 return -EINVAL;
7804
7805 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_TDLS_MGMT)) ||
7806 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, dst) ||
7807 nla_put_u8(msg, NL80211_ATTR_TDLS_ACTION, action_code) ||
7808 nla_put_u8(msg, NL80211_ATTR_TDLS_DIALOG_TOKEN, dialog_token) ||
7809 nla_put_u16(msg, NL80211_ATTR_STATUS_CODE, status_code))
7810 goto fail;
7811 if (peer_capab) {
7812 /*
7813 * The internal enum tdls_peer_capability definition is
7814 * currently identical with the nl80211 enum
7815 * nl80211_tdls_peer_capability, so no conversion is needed
7816 * here.
7817 */
7818 if (nla_put_u32(msg, NL80211_ATTR_TDLS_PEER_CAPABILITY,
7819 peer_capab))
7820 goto fail;
7821 }
7822 if ((initiator &&
7823 nla_put_flag(msg, NL80211_ATTR_TDLS_INITIATOR)) ||
7824 nla_put(msg, NL80211_ATTR_IE, len, buf))
7825 goto fail;
7826
7827 return send_and_recv_msgs(drv, msg, NULL, NULL);
7828
7829 fail:
7830 nlmsg_free(msg);
7831 return -ENOBUFS;
7832 }
7833
7834
7835 static int nl80211_tdls_oper(void *priv, enum tdls_oper oper, const u8 *peer)
7836 {
7837 struct i802_bss *bss = priv;
7838 struct wpa_driver_nl80211_data *drv = bss->drv;
7839 struct nl_msg *msg;
7840 enum nl80211_tdls_operation nl80211_oper;
7841 int res;
7842
7843 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_TDLS_SUPPORT))
7844 return -EOPNOTSUPP;
7845
7846 switch (oper) {
7847 case TDLS_DISCOVERY_REQ:
7848 nl80211_oper = NL80211_TDLS_DISCOVERY_REQ;
7849 break;
7850 case TDLS_SETUP:
7851 nl80211_oper = NL80211_TDLS_SETUP;
7852 break;
7853 case TDLS_TEARDOWN:
7854 nl80211_oper = NL80211_TDLS_TEARDOWN;
7855 break;
7856 case TDLS_ENABLE_LINK:
7857 nl80211_oper = NL80211_TDLS_ENABLE_LINK;
7858 break;
7859 case TDLS_DISABLE_LINK:
7860 nl80211_oper = NL80211_TDLS_DISABLE_LINK;
7861 break;
7862 case TDLS_ENABLE:
7863 return 0;
7864 case TDLS_DISABLE:
7865 return 0;
7866 default:
7867 return -EINVAL;
7868 }
7869
7870 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_TDLS_OPER)) ||
7871 nla_put_u8(msg, NL80211_ATTR_TDLS_OPERATION, nl80211_oper) ||
7872 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, peer)) {
7873 nlmsg_free(msg);
7874 return -ENOBUFS;
7875 }
7876
7877 res = send_and_recv_msgs(drv, msg, NULL, NULL);
7878 wpa_printf(MSG_DEBUG, "nl80211: TDLS_OPER: oper=%d mac=" MACSTR
7879 " --> res=%d (%s)", nl80211_oper, MAC2STR(peer), res,
7880 strerror(-res));
7881 return res;
7882 }
7883
7884
7885 static int
7886 nl80211_tdls_enable_channel_switch(void *priv, const u8 *addr, u8 oper_class,
7887 const struct hostapd_freq_params *params)
7888 {
7889 struct i802_bss *bss = priv;
7890 struct wpa_driver_nl80211_data *drv = bss->drv;
7891 struct nl_msg *msg;
7892 int ret = -ENOBUFS;
7893
7894 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_TDLS_SUPPORT) ||
7895 !(drv->capa.flags & WPA_DRIVER_FLAGS_TDLS_CHANNEL_SWITCH))
7896 return -EOPNOTSUPP;
7897
7898 wpa_printf(MSG_DEBUG, "nl80211: Enable TDLS channel switch " MACSTR
7899 " oper_class=%u freq=%u",
7900 MAC2STR(addr), oper_class, params->freq);
7901 msg = nl80211_cmd_msg(bss, 0, NL80211_CMD_TDLS_CHANNEL_SWITCH);
7902 if (!msg ||
7903 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
7904 nla_put_u8(msg, NL80211_ATTR_OPER_CLASS, oper_class) ||
7905 (ret = nl80211_put_freq_params(msg, params))) {
7906 nlmsg_free(msg);
7907 wpa_printf(MSG_DEBUG, "nl80211: Could not build TDLS chan switch");
7908 return ret;
7909 }
7910
7911 return send_and_recv_msgs(drv, msg, NULL, NULL);
7912 }
7913
7914
7915 static int
7916 nl80211_tdls_disable_channel_switch(void *priv, const u8 *addr)
7917 {
7918 struct i802_bss *bss = priv;
7919 struct wpa_driver_nl80211_data *drv = bss->drv;
7920 struct nl_msg *msg;
7921
7922 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_TDLS_SUPPORT) ||
7923 !(drv->capa.flags & WPA_DRIVER_FLAGS_TDLS_CHANNEL_SWITCH))
7924 return -EOPNOTSUPP;
7925
7926 wpa_printf(MSG_DEBUG, "nl80211: Disable TDLS channel switch " MACSTR,
7927 MAC2STR(addr));
7928 msg = nl80211_cmd_msg(bss, 0, NL80211_CMD_TDLS_CANCEL_CHANNEL_SWITCH);
7929 if (!msg ||
7930 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr)) {
7931 nlmsg_free(msg);
7932 wpa_printf(MSG_DEBUG,
7933 "nl80211: Could not build TDLS cancel chan switch");
7934 return -ENOBUFS;
7935 }
7936
7937 return send_and_recv_msgs(drv, msg, NULL, NULL);
7938 }
7939
7940 #endif /* CONFIG TDLS */
7941
7942
7943 static int driver_nl80211_set_key(const char *ifname, void *priv,
7944 enum wpa_alg alg, const u8 *addr,
7945 int key_idx, int set_tx,
7946 const u8 *seq, size_t seq_len,
7947 const u8 *key, size_t key_len)
7948 {
7949 struct i802_bss *bss = priv;
7950 return wpa_driver_nl80211_set_key(ifname, bss, alg, addr, key_idx,
7951 set_tx, seq, seq_len, key, key_len);
7952 }
7953
7954
7955 static int driver_nl80211_scan2(void *priv,
7956 struct wpa_driver_scan_params *params)
7957 {
7958 struct i802_bss *bss = priv;
7959 #ifdef CONFIG_DRIVER_NL80211_QCA
7960 struct wpa_driver_nl80211_data *drv = bss->drv;
7961
7962 /*
7963 * Do a vendor specific scan if possible. If only_new_results is
7964 * set, do a normal scan since a kernel (cfg80211) BSS cache flush
7965 * cannot be achieved through a vendor scan. The below condition may
7966 * need to be modified if new scan flags are added in the future whose
7967 * functionality can only be achieved through a normal scan.
7968 */
7969 if (drv->scan_vendor_cmd_avail && !params->only_new_results)
7970 return wpa_driver_nl80211_vendor_scan(bss, params);
7971 #endif /* CONFIG_DRIVER_NL80211_QCA */
7972 return wpa_driver_nl80211_scan(bss, params);
7973 }
7974
7975
7976 static int driver_nl80211_deauthenticate(void *priv, const u8 *addr,
7977 int reason_code)
7978 {
7979 struct i802_bss *bss = priv;
7980 return wpa_driver_nl80211_deauthenticate(bss, addr, reason_code);
7981 }
7982
7983
7984 static int driver_nl80211_authenticate(void *priv,
7985 struct wpa_driver_auth_params *params)
7986 {
7987 struct i802_bss *bss = priv;
7988 return wpa_driver_nl80211_authenticate(bss, params);
7989 }
7990
7991
7992 static void driver_nl80211_deinit(void *priv)
7993 {
7994 struct i802_bss *bss = priv;
7995 wpa_driver_nl80211_deinit(bss);
7996 }
7997
7998
7999 static int driver_nl80211_if_remove(void *priv, enum wpa_driver_if_type type,
8000 const char *ifname)
8001 {
8002 struct i802_bss *bss = priv;
8003 return wpa_driver_nl80211_if_remove(bss, type, ifname);
8004 }
8005
8006
8007 static int driver_nl80211_send_mlme(void *priv, const u8 *data,
8008 size_t data_len, int noack,
8009 unsigned int freq,
8010 const u16 *csa_offs, size_t csa_offs_len)
8011 {
8012 struct i802_bss *bss = priv;
8013 return wpa_driver_nl80211_send_mlme(bss, data, data_len, noack,
8014 freq, 0, 0, 0, csa_offs,
8015 csa_offs_len);
8016 }
8017
8018
8019 static int driver_nl80211_sta_remove(void *priv, const u8 *addr)
8020 {
8021 struct i802_bss *bss = priv;
8022 return wpa_driver_nl80211_sta_remove(bss, addr, -1, 0);
8023 }
8024
8025
8026 static int driver_nl80211_set_sta_vlan(void *priv, const u8 *addr,
8027 const char *ifname, int vlan_id)
8028 {
8029 struct i802_bss *bss = priv;
8030 return i802_set_sta_vlan(bss, addr, ifname, vlan_id);
8031 }
8032
8033
8034 static int driver_nl80211_read_sta_data(void *priv,
8035 struct hostap_sta_driver_data *data,
8036 const u8 *addr)
8037 {
8038 struct i802_bss *bss = priv;
8039
8040 os_memset(data, 0, sizeof(*data));
8041 return i802_read_sta_data(bss, data, addr);
8042 }
8043
8044
8045 static int driver_nl80211_send_action(void *priv, unsigned int freq,
8046 unsigned int wait_time,
8047 const u8 *dst, const u8 *src,
8048 const u8 *bssid,
8049 const u8 *data, size_t data_len,
8050 int no_cck)
8051 {
8052 struct i802_bss *bss = priv;
8053 return wpa_driver_nl80211_send_action(bss, freq, wait_time, dst, src,
8054 bssid, data, data_len, no_cck);
8055 }
8056
8057
8058 static int driver_nl80211_probe_req_report(void *priv, int report)
8059 {
8060 struct i802_bss *bss = priv;
8061 return wpa_driver_nl80211_probe_req_report(bss, report);
8062 }
8063
8064
8065 static int wpa_driver_nl80211_update_ft_ies(void *priv, const u8 *md,
8066 const u8 *ies, size_t ies_len)
8067 {
8068 int ret;
8069 struct nl_msg *msg;
8070 struct i802_bss *bss = priv;
8071 struct wpa_driver_nl80211_data *drv = bss->drv;
8072 u16 mdid = WPA_GET_LE16(md);
8073
8074 wpa_printf(MSG_DEBUG, "nl80211: Updating FT IEs");
8075 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_UPDATE_FT_IES)) ||
8076 nla_put(msg, NL80211_ATTR_IE, ies_len, ies) ||
8077 nla_put_u16(msg, NL80211_ATTR_MDID, mdid)) {
8078 nlmsg_free(msg);
8079 return -ENOBUFS;
8080 }
8081
8082 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
8083 if (ret) {
8084 wpa_printf(MSG_DEBUG, "nl80211: update_ft_ies failed "
8085 "err=%d (%s)", ret, strerror(-ret));
8086 }
8087
8088 return ret;
8089 }
8090
8091
8092 static const u8 * wpa_driver_nl80211_get_macaddr(void *priv)
8093 {
8094 struct i802_bss *bss = priv;
8095 struct wpa_driver_nl80211_data *drv = bss->drv;
8096
8097 if (drv->nlmode != NL80211_IFTYPE_P2P_DEVICE)
8098 return NULL;
8099
8100 return bss->addr;
8101 }
8102
8103
8104 static const char * scan_state_str(enum scan_states scan_state)
8105 {
8106 switch (scan_state) {
8107 case NO_SCAN:
8108 return "NO_SCAN";
8109 case SCAN_REQUESTED:
8110 return "SCAN_REQUESTED";
8111 case SCAN_STARTED:
8112 return "SCAN_STARTED";
8113 case SCAN_COMPLETED:
8114 return "SCAN_COMPLETED";
8115 case SCAN_ABORTED:
8116 return "SCAN_ABORTED";
8117 case SCHED_SCAN_STARTED:
8118 return "SCHED_SCAN_STARTED";
8119 case SCHED_SCAN_STOPPED:
8120 return "SCHED_SCAN_STOPPED";
8121 case SCHED_SCAN_RESULTS:
8122 return "SCHED_SCAN_RESULTS";
8123 }
8124
8125 return "??";
8126 }
8127
8128
8129 static int wpa_driver_nl80211_status(void *priv, char *buf, size_t buflen)
8130 {
8131 struct i802_bss *bss = priv;
8132 struct wpa_driver_nl80211_data *drv = bss->drv;
8133 int res;
8134 char *pos, *end;
8135
8136 pos = buf;
8137 end = buf + buflen;
8138
8139 res = os_snprintf(pos, end - pos,
8140 "ifindex=%d\n"
8141 "ifname=%s\n"
8142 "brname=%s\n"
8143 "addr=" MACSTR "\n"
8144 "freq=%d\n"
8145 "%s%s%s%s%s",
8146 bss->ifindex,
8147 bss->ifname,
8148 bss->brname,
8149 MAC2STR(bss->addr),
8150 bss->freq,
8151 bss->beacon_set ? "beacon_set=1\n" : "",
8152 bss->added_if_into_bridge ?
8153 "added_if_into_bridge=1\n" : "",
8154 bss->added_bridge ? "added_bridge=1\n" : "",
8155 bss->in_deinit ? "in_deinit=1\n" : "",
8156 bss->if_dynamic ? "if_dynamic=1\n" : "");
8157 if (os_snprintf_error(end - pos, res))
8158 return pos - buf;
8159 pos += res;
8160
8161 if (bss->wdev_id_set) {
8162 res = os_snprintf(pos, end - pos, "wdev_id=%llu\n",
8163 (unsigned long long) bss->wdev_id);
8164 if (os_snprintf_error(end - pos, res))
8165 return pos - buf;
8166 pos += res;
8167 }
8168
8169 res = os_snprintf(pos, end - pos,
8170 "phyname=%s\n"
8171 "perm_addr=" MACSTR "\n"
8172 "drv_ifindex=%d\n"
8173 "operstate=%d\n"
8174 "scan_state=%s\n"
8175 "auth_bssid=" MACSTR "\n"
8176 "auth_attempt_bssid=" MACSTR "\n"
8177 "bssid=" MACSTR "\n"
8178 "prev_bssid=" MACSTR "\n"
8179 "associated=%d\n"
8180 "assoc_freq=%u\n"
8181 "monitor_sock=%d\n"
8182 "monitor_ifidx=%d\n"
8183 "monitor_refcount=%d\n"
8184 "last_mgmt_freq=%u\n"
8185 "eapol_tx_sock=%d\n"
8186 "%s%s%s%s%s%s%s%s%s%s%s%s%s",
8187 drv->phyname,
8188 MAC2STR(drv->perm_addr),
8189 drv->ifindex,
8190 drv->operstate,
8191 scan_state_str(drv->scan_state),
8192 MAC2STR(drv->auth_bssid),
8193 MAC2STR(drv->auth_attempt_bssid),
8194 MAC2STR(drv->bssid),
8195 MAC2STR(drv->prev_bssid),
8196 drv->associated,
8197 drv->assoc_freq,
8198 drv->monitor_sock,
8199 drv->monitor_ifidx,
8200 drv->monitor_refcount,
8201 drv->last_mgmt_freq,
8202 drv->eapol_tx_sock,
8203 drv->ignore_if_down_event ?
8204 "ignore_if_down_event=1\n" : "",
8205 drv->scan_complete_events ?
8206 "scan_complete_events=1\n" : "",
8207 drv->disabled_11b_rates ?
8208 "disabled_11b_rates=1\n" : "",
8209 drv->pending_remain_on_chan ?
8210 "pending_remain_on_chan=1\n" : "",
8211 drv->in_interface_list ? "in_interface_list=1\n" : "",
8212 drv->device_ap_sme ? "device_ap_sme=1\n" : "",
8213 drv->poll_command_supported ?
8214 "poll_command_supported=1\n" : "",
8215 drv->data_tx_status ? "data_tx_status=1\n" : "",
8216 drv->scan_for_auth ? "scan_for_auth=1\n" : "",
8217 drv->retry_auth ? "retry_auth=1\n" : "",
8218 drv->use_monitor ? "use_monitor=1\n" : "",
8219 drv->ignore_next_local_disconnect ?
8220 "ignore_next_local_disconnect=1\n" : "",
8221 drv->ignore_next_local_deauth ?
8222 "ignore_next_local_deauth=1\n" : "");
8223 if (os_snprintf_error(end - pos, res))
8224 return pos - buf;
8225 pos += res;
8226
8227 if (drv->has_capability) {
8228 res = os_snprintf(pos, end - pos,
8229 "capa.key_mgmt=0x%x\n"
8230 "capa.enc=0x%x\n"
8231 "capa.auth=0x%x\n"
8232 "capa.flags=0x%llx\n"
8233 "capa.rrm_flags=0x%x\n"
8234 "capa.max_scan_ssids=%d\n"
8235 "capa.max_sched_scan_ssids=%d\n"
8236 "capa.sched_scan_supported=%d\n"
8237 "capa.max_match_sets=%d\n"
8238 "capa.max_remain_on_chan=%u\n"
8239 "capa.max_stations=%u\n"
8240 "capa.probe_resp_offloads=0x%x\n"
8241 "capa.max_acl_mac_addrs=%u\n"
8242 "capa.num_multichan_concurrent=%u\n"
8243 "capa.mac_addr_rand_sched_scan_supported=%d\n"
8244 "capa.mac_addr_rand_scan_supported=%d\n"
8245 "capa.conc_capab=%u\n"
8246 "capa.max_conc_chan_2_4=%u\n"
8247 "capa.max_conc_chan_5_0=%u\n"
8248 "capa.max_sched_scan_plans=%u\n"
8249 "capa.max_sched_scan_plan_interval=%u\n"
8250 "capa.max_sched_scan_plan_iterations=%u\n",
8251 drv->capa.key_mgmt,
8252 drv->capa.enc,
8253 drv->capa.auth,
8254 (unsigned long long) drv->capa.flags,
8255 drv->capa.rrm_flags,
8256 drv->capa.max_scan_ssids,
8257 drv->capa.max_sched_scan_ssids,
8258 drv->capa.sched_scan_supported,
8259 drv->capa.max_match_sets,
8260 drv->capa.max_remain_on_chan,
8261 drv->capa.max_stations,
8262 drv->capa.probe_resp_offloads,
8263 drv->capa.max_acl_mac_addrs,
8264 drv->capa.num_multichan_concurrent,
8265 drv->capa.mac_addr_rand_sched_scan_supported,
8266 drv->capa.mac_addr_rand_scan_supported,
8267 drv->capa.conc_capab,
8268 drv->capa.max_conc_chan_2_4,
8269 drv->capa.max_conc_chan_5_0,
8270 drv->capa.max_sched_scan_plans,
8271 drv->capa.max_sched_scan_plan_interval,
8272 drv->capa.max_sched_scan_plan_iterations);
8273 if (os_snprintf_error(end - pos, res))
8274 return pos - buf;
8275 pos += res;
8276 }
8277
8278 return pos - buf;
8279 }
8280
8281
8282 static int set_beacon_data(struct nl_msg *msg, struct beacon_data *settings)
8283 {
8284 if ((settings->head &&
8285 nla_put(msg, NL80211_ATTR_BEACON_HEAD,
8286 settings->head_len, settings->head)) ||
8287 (settings->tail &&
8288 nla_put(msg, NL80211_ATTR_BEACON_TAIL,
8289 settings->tail_len, settings->tail)) ||
8290 (settings->beacon_ies &&
8291 nla_put(msg, NL80211_ATTR_IE,
8292 settings->beacon_ies_len, settings->beacon_ies)) ||
8293 (settings->proberesp_ies &&
8294 nla_put(msg, NL80211_ATTR_IE_PROBE_RESP,
8295 settings->proberesp_ies_len, settings->proberesp_ies)) ||
8296 (settings->assocresp_ies &&
8297 nla_put(msg, NL80211_ATTR_IE_ASSOC_RESP,
8298 settings->assocresp_ies_len, settings->assocresp_ies)) ||
8299 (settings->probe_resp &&
8300 nla_put(msg, NL80211_ATTR_PROBE_RESP,
8301 settings->probe_resp_len, settings->probe_resp)))
8302 return -ENOBUFS;
8303
8304 return 0;
8305 }
8306
8307
8308 static int nl80211_switch_channel(void *priv, struct csa_settings *settings)
8309 {
8310 struct nl_msg *msg;
8311 struct i802_bss *bss = priv;
8312 struct wpa_driver_nl80211_data *drv = bss->drv;
8313 struct nlattr *beacon_csa;
8314 int ret = -ENOBUFS;
8315 int csa_off_len = 0;
8316 int i;
8317
8318 wpa_printf(MSG_DEBUG, "nl80211: Channel switch request (cs_count=%u block_tx=%u freq=%d width=%d cf1=%d cf2=%d)",
8319 settings->cs_count, settings->block_tx,
8320 settings->freq_params.freq, settings->freq_params.bandwidth,
8321 settings->freq_params.center_freq1,
8322 settings->freq_params.center_freq2);
8323
8324 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_AP_CSA)) {
8325 wpa_printf(MSG_DEBUG, "nl80211: Driver does not support channel switch command");
8326 return -EOPNOTSUPP;
8327 }
8328
8329 if ((drv->nlmode != NL80211_IFTYPE_AP) &&
8330 (drv->nlmode != NL80211_IFTYPE_P2P_GO))
8331 return -EOPNOTSUPP;
8332
8333 /*
8334 * Remove empty counters, assuming Probe Response and Beacon frame
8335 * counters match. This implementation assumes that there are only two
8336 * counters.
8337 */
8338 if (settings->counter_offset_beacon[0] &&
8339 !settings->counter_offset_beacon[1]) {
8340 csa_off_len = 1;
8341 } else if (settings->counter_offset_beacon[1] &&
8342 !settings->counter_offset_beacon[0]) {
8343 csa_off_len = 1;
8344 settings->counter_offset_beacon[0] =
8345 settings->counter_offset_beacon[1];
8346 settings->counter_offset_presp[0] =
8347 settings->counter_offset_presp[1];
8348 } else if (settings->counter_offset_beacon[1] &&
8349 settings->counter_offset_beacon[0]) {
8350 csa_off_len = 2;
8351 } else {
8352 wpa_printf(MSG_ERROR, "nl80211: No CSA counters provided");
8353 return -EINVAL;
8354 }
8355
8356 /* Check CSA counters validity */
8357 if (drv->capa.max_csa_counters &&
8358 csa_off_len > drv->capa.max_csa_counters) {
8359 wpa_printf(MSG_ERROR,
8360 "nl80211: Too many CSA counters provided");
8361 return -EINVAL;
8362 }
8363
8364 if (!settings->beacon_csa.tail)
8365 return -EINVAL;
8366
8367 for (i = 0; i < csa_off_len; i++) {
8368 u16 csa_c_off_bcn = settings->counter_offset_beacon[i];
8369 u16 csa_c_off_presp = settings->counter_offset_presp[i];
8370
8371 if ((settings->beacon_csa.tail_len <= csa_c_off_bcn) ||
8372 (settings->beacon_csa.tail[csa_c_off_bcn] !=
8373 settings->cs_count))
8374 return -EINVAL;
8375
8376 if (settings->beacon_csa.probe_resp &&
8377 ((settings->beacon_csa.probe_resp_len <=
8378 csa_c_off_presp) ||
8379 (settings->beacon_csa.probe_resp[csa_c_off_presp] !=
8380 settings->cs_count)))
8381 return -EINVAL;
8382 }
8383
8384 if (!(msg = nl80211_bss_msg(bss, 0, NL80211_CMD_CHANNEL_SWITCH)) ||
8385 nla_put_u32(msg, NL80211_ATTR_CH_SWITCH_COUNT,
8386 settings->cs_count) ||
8387 (ret = nl80211_put_freq_params(msg, &settings->freq_params)) ||
8388 (settings->block_tx &&
8389 nla_put_flag(msg, NL80211_ATTR_CH_SWITCH_BLOCK_TX)))
8390 goto error;
8391
8392 /* beacon_after params */
8393 ret = set_beacon_data(msg, &settings->beacon_after);
8394 if (ret)
8395 goto error;
8396
8397 /* beacon_csa params */
8398 beacon_csa = nla_nest_start(msg, NL80211_ATTR_CSA_IES);
8399 if (!beacon_csa)
8400 goto fail;
8401
8402 ret = set_beacon_data(msg, &settings->beacon_csa);
8403 if (ret)
8404 goto error;
8405
8406 if (nla_put(msg, NL80211_ATTR_CSA_C_OFF_BEACON,
8407 csa_off_len * sizeof(u16),
8408 settings->counter_offset_beacon) ||
8409 (settings->beacon_csa.probe_resp &&
8410 nla_put(msg, NL80211_ATTR_CSA_C_OFF_PRESP,
8411 csa_off_len * sizeof(u16),
8412 settings->counter_offset_presp)))
8413 goto fail;
8414
8415 nla_nest_end(msg, beacon_csa);
8416 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
8417 if (ret) {
8418 wpa_printf(MSG_DEBUG, "nl80211: switch_channel failed err=%d (%s)",
8419 ret, strerror(-ret));
8420 }
8421 return ret;
8422
8423 fail:
8424 ret = -ENOBUFS;
8425 error:
8426 nlmsg_free(msg);
8427 wpa_printf(MSG_DEBUG, "nl80211: Could not build channel switch request");
8428 return ret;
8429 }
8430
8431
8432 static int nl80211_add_ts(void *priv, u8 tsid, const u8 *addr,
8433 u8 user_priority, u16 admitted_time)
8434 {
8435 struct i802_bss *bss = priv;
8436 struct wpa_driver_nl80211_data *drv = bss->drv;
8437 struct nl_msg *msg;
8438 int ret;
8439
8440 wpa_printf(MSG_DEBUG,
8441 "nl80211: add_ts request: tsid=%u admitted_time=%u up=%d",
8442 tsid, admitted_time, user_priority);
8443
8444 if (!is_sta_interface(drv->nlmode))
8445 return -ENOTSUP;
8446
8447 msg = nl80211_cmd_msg(bss, 0, NL80211_CMD_ADD_TX_TS);
8448 if (!msg ||
8449 nla_put_u8(msg, NL80211_ATTR_TSID, tsid) ||
8450 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
8451 nla_put_u8(msg, NL80211_ATTR_USER_PRIO, user_priority) ||
8452 nla_put_u16(msg, NL80211_ATTR_ADMITTED_TIME, admitted_time)) {
8453 nlmsg_free(msg);
8454 return -ENOBUFS;
8455 }
8456
8457 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
8458 if (ret)
8459 wpa_printf(MSG_DEBUG, "nl80211: add_ts failed err=%d (%s)",
8460 ret, strerror(-ret));
8461 return ret;
8462 }
8463
8464
8465 static int nl80211_del_ts(void *priv, u8 tsid, const u8 *addr)
8466 {
8467 struct i802_bss *bss = priv;
8468 struct wpa_driver_nl80211_data *drv = bss->drv;
8469 struct nl_msg *msg;
8470 int ret;
8471
8472 wpa_printf(MSG_DEBUG, "nl80211: del_ts request: tsid=%u", tsid);
8473
8474 if (!is_sta_interface(drv->nlmode))
8475 return -ENOTSUP;
8476
8477 if (!(msg = nl80211_cmd_msg(bss, 0, NL80211_CMD_DEL_TX_TS)) ||
8478 nla_put_u8(msg, NL80211_ATTR_TSID, tsid) ||
8479 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr)) {
8480 nlmsg_free(msg);
8481 return -ENOBUFS;
8482 }
8483
8484 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
8485 if (ret)
8486 wpa_printf(MSG_DEBUG, "nl80211: del_ts failed err=%d (%s)",
8487 ret, strerror(-ret));
8488 return ret;
8489 }
8490
8491
8492 #ifdef CONFIG_TESTING_OPTIONS
8493 static int cmd_reply_handler(struct nl_msg *msg, void *arg)
8494 {
8495 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
8496 struct wpabuf *buf = arg;
8497
8498 if (!buf)
8499 return NL_SKIP;
8500
8501 if ((size_t) genlmsg_attrlen(gnlh, 0) > wpabuf_tailroom(buf)) {
8502 wpa_printf(MSG_INFO, "nl80211: insufficient buffer space for reply");
8503 return NL_SKIP;
8504 }
8505
8506 wpabuf_put_data(buf, genlmsg_attrdata(gnlh, 0),
8507 genlmsg_attrlen(gnlh, 0));
8508
8509 return NL_SKIP;
8510 }
8511 #endif /* CONFIG_TESTING_OPTIONS */
8512
8513
8514 static int vendor_reply_handler(struct nl_msg *msg, void *arg)
8515 {
8516 struct nlattr *tb[NL80211_ATTR_MAX + 1];
8517 struct nlattr *nl_vendor_reply, *nl;
8518 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
8519 struct wpabuf *buf = arg;
8520 int rem;
8521
8522 if (!buf)
8523 return NL_SKIP;
8524
8525 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
8526 genlmsg_attrlen(gnlh, 0), NULL);
8527 nl_vendor_reply = tb[NL80211_ATTR_VENDOR_DATA];
8528
8529 if (!nl_vendor_reply)
8530 return NL_SKIP;
8531
8532 if ((size_t) nla_len(nl_vendor_reply) > wpabuf_tailroom(buf)) {
8533 wpa_printf(MSG_INFO, "nl80211: Vendor command: insufficient buffer space for reply");
8534 return NL_SKIP;
8535 }
8536
8537 nla_for_each_nested(nl, nl_vendor_reply, rem) {
8538 wpabuf_put_data(buf, nla_data(nl), nla_len(nl));
8539 }
8540
8541 return NL_SKIP;
8542 }
8543
8544
8545 static int nl80211_vendor_cmd(void *priv, unsigned int vendor_id,
8546 unsigned int subcmd, const u8 *data,
8547 size_t data_len, struct wpabuf *buf)
8548 {
8549 struct i802_bss *bss = priv;
8550 struct wpa_driver_nl80211_data *drv = bss->drv;
8551 struct nl_msg *msg;
8552 int ret;
8553
8554 #ifdef CONFIG_TESTING_OPTIONS
8555 if (vendor_id == 0xffffffff) {
8556 msg = nlmsg_alloc();
8557 if (!msg)
8558 return -ENOMEM;
8559
8560 nl80211_cmd(drv, msg, 0, subcmd);
8561 if (nlmsg_append(msg, (void *) data, data_len, NLMSG_ALIGNTO) <
8562 0)
8563 goto fail;
8564 ret = send_and_recv_msgs(drv, msg, cmd_reply_handler, buf);
8565 if (ret)
8566 wpa_printf(MSG_DEBUG, "nl80211: command failed err=%d",
8567 ret);
8568 return ret;
8569 }
8570 #endif /* CONFIG_TESTING_OPTIONS */
8571
8572 if (!(msg = nl80211_cmd_msg(bss, 0, NL80211_CMD_VENDOR)) ||
8573 nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, vendor_id) ||
8574 nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD, subcmd) ||
8575 (data &&
8576 nla_put(msg, NL80211_ATTR_VENDOR_DATA, data_len, data)))
8577 goto fail;
8578
8579 ret = send_and_recv_msgs(drv, msg, vendor_reply_handler, buf);
8580 if (ret)
8581 wpa_printf(MSG_DEBUG, "nl80211: vendor command failed err=%d",
8582 ret);
8583 return ret;
8584
8585 fail:
8586 nlmsg_free(msg);
8587 return -ENOBUFS;
8588 }
8589
8590
8591 static int nl80211_set_qos_map(void *priv, const u8 *qos_map_set,
8592 u8 qos_map_set_len)
8593 {
8594 struct i802_bss *bss = priv;
8595 struct wpa_driver_nl80211_data *drv = bss->drv;
8596 struct nl_msg *msg;
8597 int ret;
8598
8599 wpa_hexdump(MSG_DEBUG, "nl80211: Setting QoS Map",
8600 qos_map_set, qos_map_set_len);
8601
8602 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_SET_QOS_MAP)) ||
8603 nla_put(msg, NL80211_ATTR_QOS_MAP, qos_map_set_len, qos_map_set)) {
8604 nlmsg_free(msg);
8605 return -ENOBUFS;
8606 }
8607
8608 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
8609 if (ret)
8610 wpa_printf(MSG_DEBUG, "nl80211: Setting QoS Map failed");
8611
8612 return ret;
8613 }
8614
8615
8616 static int nl80211_set_wowlan(void *priv,
8617 const struct wowlan_triggers *triggers)
8618 {
8619 struct i802_bss *bss = priv;
8620 struct wpa_driver_nl80211_data *drv = bss->drv;
8621 struct nl_msg *msg;
8622 struct nlattr *wowlan_triggers;
8623 int ret;
8624
8625 wpa_printf(MSG_DEBUG, "nl80211: Setting wowlan");
8626
8627 if (!(msg = nl80211_cmd_msg(bss, 0, NL80211_CMD_SET_WOWLAN)) ||
8628 !(wowlan_triggers = nla_nest_start(msg,
8629 NL80211_ATTR_WOWLAN_TRIGGERS)) ||
8630 (triggers->any &&
8631 nla_put_flag(msg, NL80211_WOWLAN_TRIG_ANY)) ||
8632 (triggers->disconnect &&
8633 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT)) ||
8634 (triggers->magic_pkt &&
8635 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT)) ||
8636 (triggers->gtk_rekey_failure &&
8637 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE)) ||
8638 (triggers->eap_identity_req &&
8639 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST)) ||
8640 (triggers->four_way_handshake &&
8641 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE)) ||
8642 (triggers->rfkill_release &&
8643 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE))) {
8644 nlmsg_free(msg);
8645 return -ENOBUFS;
8646 }
8647
8648 nla_nest_end(msg, wowlan_triggers);
8649
8650 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
8651 if (ret)
8652 wpa_printf(MSG_DEBUG, "nl80211: Setting wowlan failed");
8653
8654 return ret;
8655 }
8656
8657
8658 #ifdef CONFIG_DRIVER_NL80211_QCA
8659 static int nl80211_roaming(void *priv, int allowed, const u8 *bssid)
8660 {
8661 struct i802_bss *bss = priv;
8662 struct wpa_driver_nl80211_data *drv = bss->drv;
8663 struct nl_msg *msg;
8664 struct nlattr *params;
8665
8666 wpa_printf(MSG_DEBUG, "nl80211: Roaming policy: allowed=%d", allowed);
8667
8668 if (!drv->roaming_vendor_cmd_avail) {
8669 wpa_printf(MSG_DEBUG,
8670 "nl80211: Ignore roaming policy change since driver does not provide command for setting it");
8671 return -1;
8672 }
8673
8674 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_VENDOR)) ||
8675 nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA) ||
8676 nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
8677 QCA_NL80211_VENDOR_SUBCMD_ROAMING) ||
8678 !(params = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA)) ||
8679 nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_ROAMING_POLICY,
8680 allowed ? QCA_ROAMING_ALLOWED_WITHIN_ESS :
8681 QCA_ROAMING_NOT_ALLOWED) ||
8682 (bssid &&
8683 nla_put(msg, QCA_WLAN_VENDOR_ATTR_MAC_ADDR, ETH_ALEN, bssid))) {
8684 nlmsg_free(msg);
8685 return -1;
8686 }
8687 nla_nest_end(msg, params);
8688
8689 return send_and_recv_msgs(drv, msg, NULL, NULL);
8690 }
8691 #endif /* CONFIG_DRIVER_NL80211_QCA */
8692
8693
8694 static int nl80211_set_mac_addr(void *priv, const u8 *addr)
8695 {
8696 struct i802_bss *bss = priv;
8697 struct wpa_driver_nl80211_data *drv = bss->drv;
8698 int new_addr = addr != NULL;
8699
8700 if (TEST_FAIL())
8701 return -1;
8702
8703 if (!addr)
8704 addr = drv->perm_addr;
8705
8706 if (linux_set_iface_flags(drv->global->ioctl_sock, bss->ifname, 0) < 0)
8707 return -1;
8708
8709 if (linux_set_ifhwaddr(drv->global->ioctl_sock, bss->ifname, addr) < 0)
8710 {
8711 wpa_printf(MSG_DEBUG,
8712 "nl80211: failed to set_mac_addr for %s to " MACSTR,
8713 bss->ifname, MAC2STR(addr));
8714 if (linux_set_iface_flags(drv->global->ioctl_sock, bss->ifname,
8715 1) < 0) {
8716 wpa_printf(MSG_DEBUG,
8717 "nl80211: Could not restore interface UP after failed set_mac_addr");
8718 }
8719 return -1;
8720 }
8721
8722 wpa_printf(MSG_DEBUG, "nl80211: set_mac_addr for %s to " MACSTR,
8723 bss->ifname, MAC2STR(addr));
8724 drv->addr_changed = new_addr;
8725 os_memcpy(bss->addr, addr, ETH_ALEN);
8726
8727 if (linux_set_iface_flags(drv->global->ioctl_sock, bss->ifname, 1) < 0)
8728 {
8729 wpa_printf(MSG_DEBUG,
8730 "nl80211: Could not restore interface UP after set_mac_addr");
8731 }
8732
8733 return 0;
8734 }
8735
8736
8737 #ifdef CONFIG_MESH
8738
8739 static int wpa_driver_nl80211_init_mesh(void *priv)
8740 {
8741 if (wpa_driver_nl80211_set_mode(priv, NL80211_IFTYPE_MESH_POINT)) {
8742 wpa_printf(MSG_INFO,
8743 "nl80211: Failed to set interface into mesh mode");
8744 return -1;
8745 }
8746 return 0;
8747 }
8748
8749
8750 static int nl80211_put_mesh_id(struct nl_msg *msg, const u8 *mesh_id,
8751 size_t mesh_id_len)
8752 {
8753 if (mesh_id) {
8754 wpa_hexdump_ascii(MSG_DEBUG, " * Mesh ID (SSID)",
8755 mesh_id, mesh_id_len);
8756 return nla_put(msg, NL80211_ATTR_MESH_ID, mesh_id_len, mesh_id);
8757 }
8758
8759 return 0;
8760 }
8761
8762
8763 static int nl80211_put_mesh_config(struct nl_msg *msg,
8764 struct wpa_driver_mesh_bss_params *params)
8765 {
8766 struct nlattr *container;
8767
8768 container = nla_nest_start(msg, NL80211_ATTR_MESH_CONFIG);
8769 if (!container)
8770 return -1;
8771
8772 if (((params->flags & WPA_DRIVER_MESH_CONF_FLAG_AUTO_PLINKS) &&
8773 nla_put_u32(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS,
8774 params->auto_plinks)) ||
8775 ((params->flags & WPA_DRIVER_MESH_CONF_FLAG_MAX_PEER_LINKS) &&
8776 nla_put_u16(msg, NL80211_MESHCONF_MAX_PEER_LINKS,
8777 params->max_peer_links)))
8778 return -1;
8779
8780 /*
8781 * Set NL80211_MESHCONF_PLINK_TIMEOUT even if user mpm is used because
8782 * the timer could disconnect stations even in that case.
8783 */
8784 if ((params->flags & WPA_DRIVER_MESH_CONF_FLAG_PEER_LINK_TIMEOUT) &&
8785 nla_put_u32(msg, NL80211_MESHCONF_PLINK_TIMEOUT,
8786 params->peer_link_timeout)) {
8787 wpa_printf(MSG_ERROR, "nl80211: Failed to set PLINK_TIMEOUT");
8788 return -1;
8789 }
8790
8791 if ((params->flags & WPA_DRIVER_MESH_CONF_FLAG_HT_OP_MODE) &&
8792 nla_put_u16(msg, NL80211_MESHCONF_HT_OPMODE, params->ht_opmode)) {
8793 wpa_printf(MSG_ERROR, "nl80211: Failed to set HT_OP_MODE");
8794 return -1;
8795 }
8796
8797 nla_nest_end(msg, container);
8798
8799 return 0;
8800 }
8801
8802
8803 static int nl80211_join_mesh(struct i802_bss *bss,
8804 struct wpa_driver_mesh_join_params *params)
8805 {
8806 struct wpa_driver_nl80211_data *drv = bss->drv;
8807 struct nl_msg *msg;
8808 struct nlattr *container;
8809 int ret = -1;
8810
8811 wpa_printf(MSG_DEBUG, "nl80211: mesh join (ifindex=%d)", drv->ifindex);
8812 msg = nl80211_drv_msg(drv, 0, NL80211_CMD_JOIN_MESH);
8813 if (!msg ||
8814 nl80211_put_freq_params(msg, &params->freq) ||
8815 nl80211_put_basic_rates(msg, params->basic_rates) ||
8816 nl80211_put_mesh_id(msg, params->meshid, params->meshid_len) ||
8817 nl80211_put_beacon_int(msg, params->beacon_int) ||
8818 nl80211_put_dtim_period(msg, params->dtim_period))
8819 goto fail;
8820
8821 wpa_printf(MSG_DEBUG, " * flags=%08X", params->flags);
8822
8823 container = nla_nest_start(msg, NL80211_ATTR_MESH_SETUP);
8824 if (!container)
8825 goto fail;
8826
8827 if (params->ies) {
8828 wpa_hexdump(MSG_DEBUG, " * IEs", params->ies, params->ie_len);
8829 if (nla_put(msg, NL80211_MESH_SETUP_IE, params->ie_len,
8830 params->ies))
8831 goto fail;
8832 }
8833 /* WPA_DRIVER_MESH_FLAG_OPEN_AUTH is treated as default by nl80211 */
8834 if (params->flags & WPA_DRIVER_MESH_FLAG_SAE_AUTH) {
8835 if (nla_put_u8(msg, NL80211_MESH_SETUP_AUTH_PROTOCOL, 0x1) ||
8836 nla_put_flag(msg, NL80211_MESH_SETUP_USERSPACE_AUTH))
8837 goto fail;
8838 }
8839 if ((params->flags & WPA_DRIVER_MESH_FLAG_AMPE) &&
8840 nla_put_flag(msg, NL80211_MESH_SETUP_USERSPACE_AMPE))
8841 goto fail;
8842 if ((params->flags & WPA_DRIVER_MESH_FLAG_USER_MPM) &&
8843 nla_put_flag(msg, NL80211_MESH_SETUP_USERSPACE_MPM))
8844 goto fail;
8845 nla_nest_end(msg, container);
8846
8847 params->conf.flags |= WPA_DRIVER_MESH_CONF_FLAG_AUTO_PLINKS;
8848 params->conf.flags |= WPA_DRIVER_MESH_CONF_FLAG_PEER_LINK_TIMEOUT;
8849 params->conf.flags |= WPA_DRIVER_MESH_CONF_FLAG_MAX_PEER_LINKS;
8850 if (nl80211_put_mesh_config(msg, &params->conf) < 0)
8851 goto fail;
8852
8853 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
8854 msg = NULL;
8855 if (ret) {
8856 wpa_printf(MSG_DEBUG, "nl80211: mesh join failed: ret=%d (%s)",
8857 ret, strerror(-ret));
8858 goto fail;
8859 }
8860 ret = 0;
8861 drv->assoc_freq = bss->freq = params->freq.freq;
8862 wpa_printf(MSG_DEBUG, "nl80211: mesh join request send successfully");
8863
8864 fail:
8865 nlmsg_free(msg);
8866 return ret;
8867 }
8868
8869
8870 static int
8871 wpa_driver_nl80211_join_mesh(void *priv,
8872 struct wpa_driver_mesh_join_params *params)
8873 {
8874 struct i802_bss *bss = priv;
8875 int ret, timeout;
8876
8877 timeout = params->conf.peer_link_timeout;
8878
8879 /* Disable kernel inactivity timer */
8880 if (params->flags & WPA_DRIVER_MESH_FLAG_USER_MPM)
8881 params->conf.peer_link_timeout = 0;
8882
8883 ret = nl80211_join_mesh(bss, params);
8884 if (ret == -EINVAL && params->conf.peer_link_timeout == 0) {
8885 wpa_printf(MSG_DEBUG,
8886 "nl80211: Mesh join retry for peer_link_timeout");
8887 /*
8888 * Old kernel does not support setting
8889 * NL80211_MESHCONF_PLINK_TIMEOUT to zero, so set 60 seconds
8890 * into future from peer_link_timeout.
8891 */
8892 params->conf.peer_link_timeout = timeout + 60;
8893 ret = nl80211_join_mesh(priv, params);
8894 }
8895
8896 params->conf.peer_link_timeout = timeout;
8897 return ret;
8898 }
8899
8900
8901 static int wpa_driver_nl80211_leave_mesh(void *priv)
8902 {
8903 struct i802_bss *bss = priv;
8904 struct wpa_driver_nl80211_data *drv = bss->drv;
8905 struct nl_msg *msg;
8906 int ret;
8907
8908 wpa_printf(MSG_DEBUG, "nl80211: mesh leave (ifindex=%d)", drv->ifindex);
8909 msg = nl80211_drv_msg(drv, 0, NL80211_CMD_LEAVE_MESH);
8910 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
8911 if (ret) {
8912 wpa_printf(MSG_DEBUG, "nl80211: mesh leave failed: ret=%d (%s)",
8913 ret, strerror(-ret));
8914 } else {
8915 wpa_printf(MSG_DEBUG,
8916 "nl80211: mesh leave request send successfully");
8917 }
8918
8919 if (wpa_driver_nl80211_set_mode(drv->first_bss,
8920 NL80211_IFTYPE_STATION)) {
8921 wpa_printf(MSG_INFO,
8922 "nl80211: Failed to set interface into station mode");
8923 }
8924 return ret;
8925 }
8926
8927 #endif /* CONFIG_MESH */
8928
8929
8930 static int wpa_driver_br_add_ip_neigh(void *priv, u8 version,
8931 const u8 *ipaddr, int prefixlen,
8932 const u8 *addr)
8933 {
8934 #ifdef CONFIG_LIBNL3_ROUTE
8935 struct i802_bss *bss = priv;
8936 struct wpa_driver_nl80211_data *drv = bss->drv;
8937 struct rtnl_neigh *rn;
8938 struct nl_addr *nl_ipaddr = NULL;
8939 struct nl_addr *nl_lladdr = NULL;
8940 int family, addrsize;
8941 int res;
8942
8943 if (!ipaddr || prefixlen == 0 || !addr)
8944 return -EINVAL;
8945
8946 if (bss->br_ifindex == 0) {
8947 wpa_printf(MSG_DEBUG,
8948 "nl80211: bridge must be set before adding an ip neigh to it");
8949 return -1;
8950 }
8951
8952 if (!drv->rtnl_sk) {
8953 wpa_printf(MSG_DEBUG,
8954 "nl80211: nl_sock for NETLINK_ROUTE is not initialized");
8955 return -1;
8956 }
8957
8958 if (version == 4) {
8959 family = AF_INET;
8960 addrsize = 4;
8961 } else if (version == 6) {
8962 family = AF_INET6;
8963 addrsize = 16;
8964 } else {
8965 return -EINVAL;
8966 }
8967
8968 rn = rtnl_neigh_alloc();
8969 if (rn == NULL)
8970 return -ENOMEM;
8971
8972 /* set the destination ip address for neigh */
8973 nl_ipaddr = nl_addr_build(family, (void *) ipaddr, addrsize);
8974 if (nl_ipaddr == NULL) {
8975 wpa_printf(MSG_DEBUG, "nl80211: nl_ipaddr build failed");
8976 res = -ENOMEM;
8977 goto errout;
8978 }
8979 nl_addr_set_prefixlen(nl_ipaddr, prefixlen);
8980 res = rtnl_neigh_set_dst(rn, nl_ipaddr);
8981 if (res) {
8982 wpa_printf(MSG_DEBUG,
8983 "nl80211: neigh set destination addr failed");
8984 goto errout;
8985 }
8986
8987 /* set the corresponding lladdr for neigh */
8988 nl_lladdr = nl_addr_build(AF_BRIDGE, (u8 *) addr, ETH_ALEN);
8989 if (nl_lladdr == NULL) {
8990 wpa_printf(MSG_DEBUG, "nl80211: neigh set lladdr failed");
8991 res = -ENOMEM;
8992 goto errout;
8993 }
8994 rtnl_neigh_set_lladdr(rn, nl_lladdr);
8995
8996 rtnl_neigh_set_ifindex(rn, bss->br_ifindex);
8997 rtnl_neigh_set_state(rn, NUD_PERMANENT);
8998
8999 res = rtnl_neigh_add(drv->rtnl_sk, rn, NLM_F_CREATE);
9000 if (res) {
9001 wpa_printf(MSG_DEBUG,
9002 "nl80211: Adding bridge ip neigh failed: %s",
9003 strerror(errno));
9004 }
9005 errout:
9006 if (nl_lladdr)
9007 nl_addr_put(nl_lladdr);
9008 if (nl_ipaddr)
9009 nl_addr_put(nl_ipaddr);
9010 if (rn)
9011 rtnl_neigh_put(rn);
9012 return res;
9013 #else /* CONFIG_LIBNL3_ROUTE */
9014 return -1;
9015 #endif /* CONFIG_LIBNL3_ROUTE */
9016 }
9017
9018
9019 static int wpa_driver_br_delete_ip_neigh(void *priv, u8 version,
9020 const u8 *ipaddr)
9021 {
9022 #ifdef CONFIG_LIBNL3_ROUTE
9023 struct i802_bss *bss = priv;
9024 struct wpa_driver_nl80211_data *drv = bss->drv;
9025 struct rtnl_neigh *rn;
9026 struct nl_addr *nl_ipaddr;
9027 int family, addrsize;
9028 int res;
9029
9030 if (!ipaddr)
9031 return -EINVAL;
9032
9033 if (version == 4) {
9034 family = AF_INET;
9035 addrsize = 4;
9036 } else if (version == 6) {
9037 family = AF_INET6;
9038 addrsize = 16;
9039 } else {
9040 return -EINVAL;
9041 }
9042
9043 if (bss->br_ifindex == 0) {
9044 wpa_printf(MSG_DEBUG,
9045 "nl80211: bridge must be set to delete an ip neigh");
9046 return -1;
9047 }
9048
9049 if (!drv->rtnl_sk) {
9050 wpa_printf(MSG_DEBUG,
9051 "nl80211: nl_sock for NETLINK_ROUTE is not initialized");
9052 return -1;
9053 }
9054
9055 rn = rtnl_neigh_alloc();
9056 if (rn == NULL)
9057 return -ENOMEM;
9058
9059 /* set the destination ip address for neigh */
9060 nl_ipaddr = nl_addr_build(family, (void *) ipaddr, addrsize);
9061 if (nl_ipaddr == NULL) {
9062 wpa_printf(MSG_DEBUG, "nl80211: nl_ipaddr build failed");
9063 res = -ENOMEM;
9064 goto errout;
9065 }
9066 res = rtnl_neigh_set_dst(rn, nl_ipaddr);
9067 if (res) {
9068 wpa_printf(MSG_DEBUG,
9069 "nl80211: neigh set destination addr failed");
9070 goto errout;
9071 }
9072
9073 rtnl_neigh_set_ifindex(rn, bss->br_ifindex);
9074
9075 res = rtnl_neigh_delete(drv->rtnl_sk, rn, 0);
9076 if (res) {
9077 wpa_printf(MSG_DEBUG,
9078 "nl80211: Deleting bridge ip neigh failed: %s",
9079 strerror(errno));
9080 }
9081 errout:
9082 if (nl_ipaddr)
9083 nl_addr_put(nl_ipaddr);
9084 if (rn)
9085 rtnl_neigh_put(rn);
9086 return res;
9087 #else /* CONFIG_LIBNL3_ROUTE */
9088 return -1;
9089 #endif /* CONFIG_LIBNL3_ROUTE */
9090 }
9091
9092
9093 static int linux_write_system_file(const char *path, unsigned int val)
9094 {
9095 char buf[50];
9096 int fd, len;
9097
9098 len = os_snprintf(buf, sizeof(buf), "%u\n", val);
9099 if (os_snprintf_error(sizeof(buf), len))
9100 return -1;
9101
9102 fd = open(path, O_WRONLY);
9103 if (fd < 0)
9104 return -1;
9105
9106 if (write(fd, buf, len) < 0) {
9107 wpa_printf(MSG_DEBUG,
9108 "nl80211: Failed to write Linux system file: %s with the value of %d",
9109 path, val);
9110 close(fd);
9111 return -1;
9112 }
9113 close(fd);
9114
9115 return 0;
9116 }
9117
9118
9119 static const char * drv_br_port_attr_str(enum drv_br_port_attr attr)
9120 {
9121 switch (attr) {
9122 case DRV_BR_PORT_ATTR_PROXYARP:
9123 return "proxyarp_wifi";
9124 case DRV_BR_PORT_ATTR_HAIRPIN_MODE:
9125 return "hairpin_mode";
9126 }
9127
9128 return NULL;
9129 }
9130
9131
9132 static int wpa_driver_br_port_set_attr(void *priv, enum drv_br_port_attr attr,
9133 unsigned int val)
9134 {
9135 struct i802_bss *bss = priv;
9136 char path[128];
9137 const char *attr_txt;
9138
9139 attr_txt = drv_br_port_attr_str(attr);
9140 if (attr_txt == NULL)
9141 return -EINVAL;
9142
9143 os_snprintf(path, sizeof(path), "/sys/class/net/%s/brport/%s",
9144 bss->ifname, attr_txt);
9145
9146 if (linux_write_system_file(path, val))
9147 return -1;
9148
9149 return 0;
9150 }
9151
9152
9153 static const char * drv_br_net_param_str(enum drv_br_net_param param)
9154 {
9155 switch (param) {
9156 case DRV_BR_NET_PARAM_GARP_ACCEPT:
9157 return "arp_accept";
9158 default:
9159 return NULL;
9160 }
9161 }
9162
9163
9164 static int wpa_driver_br_set_net_param(void *priv, enum drv_br_net_param param,
9165 unsigned int val)
9166 {
9167 struct i802_bss *bss = priv;
9168 char path[128];
9169 const char *param_txt;
9170 int ip_version = 4;
9171
9172 if (param == DRV_BR_MULTICAST_SNOOPING) {
9173 os_snprintf(path, sizeof(path),
9174 "/sys/devices/virtual/net/%s/bridge/multicast_snooping",
9175 bss->brname);
9176 goto set_val;
9177 }
9178
9179 param_txt = drv_br_net_param_str(param);
9180 if (param_txt == NULL)
9181 return -EINVAL;
9182
9183 switch (param) {
9184 case DRV_BR_NET_PARAM_GARP_ACCEPT:
9185 ip_version = 4;
9186 break;
9187 default:
9188 return -EINVAL;
9189 }
9190
9191 os_snprintf(path, sizeof(path), "/proc/sys/net/ipv%d/conf/%s/%s",
9192 ip_version, bss->brname, param_txt);
9193
9194 set_val:
9195 if (linux_write_system_file(path, val))
9196 return -1;
9197
9198 return 0;
9199 }
9200
9201
9202 #ifdef CONFIG_DRIVER_NL80211_QCA
9203
9204 static int hw_mode_to_qca_acs(enum hostapd_hw_mode hw_mode)
9205 {
9206 switch (hw_mode) {
9207 case HOSTAPD_MODE_IEEE80211B:
9208 return QCA_ACS_MODE_IEEE80211B;
9209 case HOSTAPD_MODE_IEEE80211G:
9210 return QCA_ACS_MODE_IEEE80211G;
9211 case HOSTAPD_MODE_IEEE80211A:
9212 return QCA_ACS_MODE_IEEE80211A;
9213 case HOSTAPD_MODE_IEEE80211AD:
9214 return QCA_ACS_MODE_IEEE80211AD;
9215 case HOSTAPD_MODE_IEEE80211ANY:
9216 return QCA_ACS_MODE_IEEE80211ANY;
9217 default:
9218 return -1;
9219 }
9220 }
9221
9222
9223 static int add_acs_freq_list(struct nl_msg *msg, const int *freq_list)
9224 {
9225 int i, len, ret;
9226 u32 *freqs;
9227
9228 if (!freq_list)
9229 return 0;
9230 len = int_array_len(freq_list);
9231 freqs = os_malloc(sizeof(u32) * len);
9232 if (!freqs)
9233 return -1;
9234 for (i = 0; i < len; i++)
9235 freqs[i] = freq_list[i];
9236 ret = nla_put(msg, QCA_WLAN_VENDOR_ATTR_ACS_FREQ_LIST,
9237 sizeof(u32) * len, freqs);
9238 os_free(freqs);
9239 return ret;
9240 }
9241
9242
9243 static int wpa_driver_do_acs(void *priv, struct drv_acs_params *params)
9244 {
9245 struct i802_bss *bss = priv;
9246 struct wpa_driver_nl80211_data *drv = bss->drv;
9247 struct nl_msg *msg;
9248 struct nlattr *data;
9249 int ret;
9250 int mode;
9251
9252 mode = hw_mode_to_qca_acs(params->hw_mode);
9253 if (mode < 0)
9254 return -1;
9255
9256 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_VENDOR)) ||
9257 nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA) ||
9258 nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
9259 QCA_NL80211_VENDOR_SUBCMD_DO_ACS) ||
9260 !(data = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA)) ||
9261 nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_ACS_HW_MODE, mode) ||
9262 (params->ht_enabled &&
9263 nla_put_flag(msg, QCA_WLAN_VENDOR_ATTR_ACS_HT_ENABLED)) ||
9264 (params->ht40_enabled &&
9265 nla_put_flag(msg, QCA_WLAN_VENDOR_ATTR_ACS_HT40_ENABLED)) ||
9266 (params->vht_enabled &&
9267 nla_put_flag(msg, QCA_WLAN_VENDOR_ATTR_ACS_VHT_ENABLED)) ||
9268 nla_put_u16(msg, QCA_WLAN_VENDOR_ATTR_ACS_CHWIDTH,
9269 params->ch_width) ||
9270 (params->ch_list_len &&
9271 nla_put(msg, QCA_WLAN_VENDOR_ATTR_ACS_CH_LIST, params->ch_list_len,
9272 params->ch_list)) ||
9273 add_acs_freq_list(msg, params->freq_list)) {
9274 nlmsg_free(msg);
9275 return -ENOBUFS;
9276 }
9277 nla_nest_end(msg, data);
9278
9279 wpa_printf(MSG_DEBUG,
9280 "nl80211: ACS Params: HW_MODE: %d HT: %d HT40: %d VHT: %d BW: %d CH_LIST_LEN: %u",
9281 params->hw_mode, params->ht_enabled, params->ht40_enabled,
9282 params->vht_enabled, params->ch_width, params->ch_list_len);
9283
9284 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
9285 if (ret) {
9286 wpa_printf(MSG_DEBUG,
9287 "nl80211: Failed to invoke driver ACS function: %s",
9288 strerror(errno));
9289 }
9290 return ret;
9291 }
9292
9293
9294 static int nl80211_set_band(void *priv, enum set_band band)
9295 {
9296 struct i802_bss *bss = priv;
9297 struct wpa_driver_nl80211_data *drv = bss->drv;
9298 struct nl_msg *msg;
9299 struct nlattr *data;
9300 int ret;
9301 enum qca_set_band qca_band;
9302
9303 if (!drv->setband_vendor_cmd_avail)
9304 return -1;
9305
9306 switch (band) {
9307 case WPA_SETBAND_AUTO:
9308 qca_band = QCA_SETBAND_AUTO;
9309 break;
9310 case WPA_SETBAND_5G:
9311 qca_band = QCA_SETBAND_5G;
9312 break;
9313 case WPA_SETBAND_2G:
9314 qca_band = QCA_SETBAND_2G;
9315 break;
9316 default:
9317 return -1;
9318 }
9319
9320 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_VENDOR)) ||
9321 nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA) ||
9322 nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
9323 QCA_NL80211_VENDOR_SUBCMD_SETBAND) ||
9324 !(data = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA)) ||
9325 nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_SETBAND_VALUE, qca_band)) {
9326 nlmsg_free(msg);
9327 return -ENOBUFS;
9328 }
9329 nla_nest_end(msg, data);
9330
9331 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
9332 if (ret) {
9333 wpa_printf(MSG_DEBUG,
9334 "nl80211: Driver setband function failed: %s",
9335 strerror(errno));
9336 }
9337 return ret;
9338 }
9339
9340
9341 struct nl80211_pcl {
9342 unsigned int num;
9343 unsigned int *freq_list;
9344 };
9345
9346 static int preferred_freq_info_handler(struct nl_msg *msg, void *arg)
9347 {
9348 struct nlattr *tb[NL80211_ATTR_MAX + 1];
9349 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
9350 struct nl80211_pcl *param = arg;
9351 struct nlattr *nl_vend, *attr;
9352 enum qca_iface_type iface_type;
9353 struct nlattr *tb_vendor[QCA_WLAN_VENDOR_ATTR_MAX + 1];
9354 unsigned int num, max_num;
9355 u32 *freqs;
9356
9357 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
9358 genlmsg_attrlen(gnlh, 0), NULL);
9359
9360 nl_vend = tb[NL80211_ATTR_VENDOR_DATA];
9361 if (!nl_vend)
9362 return NL_SKIP;
9363
9364 nla_parse(tb_vendor, QCA_WLAN_VENDOR_ATTR_MAX,
9365 nla_data(nl_vend), nla_len(nl_vend), NULL);
9366
9367 attr = tb_vendor[
9368 QCA_WLAN_VENDOR_ATTR_GET_PREFERRED_FREQ_LIST_IFACE_TYPE];
9369 if (!attr) {
9370 wpa_printf(MSG_ERROR, "nl80211: iface_type couldn't be found");
9371 param->num = 0;
9372 return NL_SKIP;
9373 }
9374
9375 iface_type = (enum qca_iface_type) nla_get_u32(attr);
9376 wpa_printf(MSG_DEBUG, "nl80211: Driver returned iface_type=%d",
9377 iface_type);
9378
9379 attr = tb_vendor[QCA_WLAN_VENDOR_ATTR_GET_PREFERRED_FREQ_LIST];
9380 if (!attr) {
9381 wpa_printf(MSG_ERROR,
9382 "nl80211: preferred_freq_list couldn't be found");
9383 param->num = 0;
9384 return NL_SKIP;
9385 }
9386
9387 /*
9388 * param->num has the maximum number of entries for which there
9389 * is room in the freq_list provided by the caller.
9390 */
9391 freqs = nla_data(attr);
9392 max_num = nla_len(attr) / sizeof(u32);
9393 if (max_num > param->num)
9394 max_num = param->num;
9395 for (num = 0; num < max_num; num++)
9396 param->freq_list[num] = freqs[num];
9397 param->num = num;
9398
9399 return NL_SKIP;
9400 }
9401
9402
9403 static int nl80211_get_pref_freq_list(void *priv,
9404 enum wpa_driver_if_type if_type,
9405 unsigned int *num,
9406 unsigned int *freq_list)
9407 {
9408 struct i802_bss *bss = priv;
9409 struct wpa_driver_nl80211_data *drv = bss->drv;
9410 struct nl_msg *msg;
9411 int ret;
9412 unsigned int i;
9413 struct nlattr *params;
9414 struct nl80211_pcl param;
9415 enum qca_iface_type iface_type;
9416
9417 if (!drv->get_pref_freq_list)
9418 return -1;
9419
9420 switch (if_type) {
9421 case WPA_IF_STATION:
9422 iface_type = QCA_IFACE_TYPE_STA;
9423 break;
9424 case WPA_IF_AP_BSS:
9425 iface_type = QCA_IFACE_TYPE_AP;
9426 break;
9427 case WPA_IF_P2P_GO:
9428 iface_type = QCA_IFACE_TYPE_P2P_GO;
9429 break;
9430 case WPA_IF_P2P_CLIENT:
9431 iface_type = QCA_IFACE_TYPE_P2P_CLIENT;
9432 break;
9433 case WPA_IF_IBSS:
9434 iface_type = QCA_IFACE_TYPE_IBSS;
9435 break;
9436 case WPA_IF_TDLS:
9437 iface_type = QCA_IFACE_TYPE_TDLS;
9438 break;
9439 default:
9440 return -1;
9441 }
9442
9443 param.num = *num;
9444 param.freq_list = freq_list;
9445
9446 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_VENDOR)) ||
9447 nla_put_u32(msg, NL80211_ATTR_IFINDEX, drv->ifindex) ||
9448 nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA) ||
9449 nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
9450 QCA_NL80211_VENDOR_SUBCMD_GET_PREFERRED_FREQ_LIST) ||
9451 !(params = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA)) ||
9452 nla_put_u32(msg,
9453 QCA_WLAN_VENDOR_ATTR_GET_PREFERRED_FREQ_LIST_IFACE_TYPE,
9454 iface_type)) {
9455 wpa_printf(MSG_ERROR,
9456 "%s: err in adding vendor_cmd and vendor_data",
9457 __func__);
9458 nlmsg_free(msg);
9459 return -1;
9460 }
9461 nla_nest_end(msg, params);
9462
9463 os_memset(freq_list, 0, *num * sizeof(freq_list[0]));
9464 ret = send_and_recv_msgs(drv, msg, preferred_freq_info_handler, &param);
9465 if (ret) {
9466 wpa_printf(MSG_ERROR,
9467 "%s: err in send_and_recv_msgs", __func__);
9468 return ret;
9469 }
9470
9471 *num = param.num;
9472
9473 for (i = 0; i < *num; i++) {
9474 wpa_printf(MSG_DEBUG, "nl80211: preferred_channel_list[%d]=%d",
9475 i, freq_list[i]);
9476 }
9477
9478 return 0;
9479 }
9480
9481
9482 static int nl80211_set_prob_oper_freq(void *priv, unsigned int freq)
9483 {
9484 struct i802_bss *bss = priv;
9485 struct wpa_driver_nl80211_data *drv = bss->drv;
9486 struct nl_msg *msg;
9487 int ret;
9488 struct nlattr *params;
9489
9490 if (!drv->set_prob_oper_freq)
9491 return -1;
9492
9493 wpa_printf(MSG_DEBUG,
9494 "nl80211: Set P2P probable operating freq %u for ifindex %d",
9495 freq, bss->ifindex);
9496
9497 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_VENDOR)) ||
9498 nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA) ||
9499 nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
9500 QCA_NL80211_VENDOR_SUBCMD_SET_PROBABLE_OPER_CHANNEL) ||
9501 !(params = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA)) ||
9502 nla_put_u32(msg,
9503 QCA_WLAN_VENDOR_ATTR_PROBABLE_OPER_CHANNEL_IFACE_TYPE,
9504 QCA_IFACE_TYPE_P2P_CLIENT) ||
9505 nla_put_u32(msg,
9506 QCA_WLAN_VENDOR_ATTR_PROBABLE_OPER_CHANNEL_FREQ,
9507 freq)) {
9508 wpa_printf(MSG_ERROR,
9509 "%s: err in adding vendor_cmd and vendor_data",
9510 __func__);
9511 nlmsg_free(msg);
9512 return -1;
9513 }
9514 nla_nest_end(msg, params);
9515
9516 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
9517 msg = NULL;
9518 if (ret) {
9519 wpa_printf(MSG_ERROR, "%s: err in send_and_recv_msgs",
9520 __func__);
9521 return ret;
9522 }
9523 nlmsg_free(msg);
9524 return 0;
9525 }
9526
9527
9528 static int nl80211_p2p_lo_start(void *priv, unsigned int freq,
9529 unsigned int period, unsigned int interval,
9530 unsigned int count, const u8 *device_types,
9531 size_t dev_types_len,
9532 const u8 *ies, size_t ies_len)
9533 {
9534 struct i802_bss *bss = priv;
9535 struct wpa_driver_nl80211_data *drv = bss->drv;
9536 struct nl_msg *msg;
9537 struct nlattr *container;
9538 int ret;
9539
9540 wpa_printf(MSG_DEBUG,
9541 "nl80211: Start P2P Listen offload: freq=%u, period=%u, interval=%u, count=%u",
9542 freq, period, interval, count);
9543
9544 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_P2P_LISTEN_OFFLOAD))
9545 return -1;
9546
9547 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_VENDOR)) ||
9548 nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA) ||
9549 nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
9550 QCA_NL80211_VENDOR_SUBCMD_P2P_LISTEN_OFFLOAD_START))
9551 goto fail;
9552
9553 container = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA);
9554 if (!container)
9555 goto fail;
9556
9557 if (nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_P2P_LISTEN_OFFLOAD_CHANNEL,
9558 freq) ||
9559 nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_P2P_LISTEN_OFFLOAD_PERIOD,
9560 period) ||
9561 nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_P2P_LISTEN_OFFLOAD_INTERVAL,
9562 interval) ||
9563 nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_P2P_LISTEN_OFFLOAD_COUNT,
9564 count) ||
9565 nla_put(msg, QCA_WLAN_VENDOR_ATTR_P2P_LISTEN_OFFLOAD_DEVICE_TYPES,
9566 dev_types_len, device_types) ||
9567 nla_put(msg, QCA_WLAN_VENDOR_ATTR_P2P_LISTEN_OFFLOAD_VENDOR_IE,
9568 ies_len, ies))
9569 goto fail;
9570
9571 nla_nest_end(msg, container);
9572 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
9573 msg = NULL;
9574 if (ret) {
9575 wpa_printf(MSG_DEBUG,
9576 "nl80211: Failed to send P2P Listen offload vendor command");
9577 goto fail;
9578 }
9579
9580 return 0;
9581
9582 fail:
9583 nlmsg_free(msg);
9584 return -1;
9585 }
9586
9587
9588 static int nl80211_p2p_lo_stop(void *priv)
9589 {
9590 struct i802_bss *bss = priv;
9591 struct wpa_driver_nl80211_data *drv = bss->drv;
9592 struct nl_msg *msg;
9593
9594 wpa_printf(MSG_DEBUG, "nl80211: Stop P2P Listen offload");
9595
9596 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_P2P_LISTEN_OFFLOAD))
9597 return -1;
9598
9599 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_VENDOR)) ||
9600 nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA) ||
9601 nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
9602 QCA_NL80211_VENDOR_SUBCMD_P2P_LISTEN_OFFLOAD_STOP)) {
9603 nlmsg_free(msg);
9604 return -1;
9605 }
9606
9607 return send_and_recv_msgs(drv, msg, NULL, NULL);
9608 }
9609
9610
9611 static int nl80211_set_tdls_mode(void *priv, int tdls_external_control)
9612 {
9613 struct i802_bss *bss = priv;
9614 struct wpa_driver_nl80211_data *drv = bss->drv;
9615 struct nl_msg *msg;
9616 struct nlattr *params;
9617 int ret;
9618 u32 tdls_mode;
9619
9620 wpa_printf(MSG_DEBUG,
9621 "nl80211: Set TDKS mode: tdls_external_control=%d",
9622 tdls_external_control);
9623
9624 if (tdls_external_control == 1)
9625 tdls_mode = QCA_WLAN_VENDOR_TDLS_TRIGGER_MODE_IMPLICIT |
9626 QCA_WLAN_VENDOR_TDLS_TRIGGER_MODE_EXTERNAL;
9627 else
9628 tdls_mode = QCA_WLAN_VENDOR_TDLS_TRIGGER_MODE_EXPLICIT;
9629
9630 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_VENDOR)) ||
9631 nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA) ||
9632 nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
9633 QCA_NL80211_VENDOR_SUBCMD_CONFIGURE_TDLS))
9634 goto fail;
9635
9636 params = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA);
9637 if (!params)
9638 goto fail;
9639
9640 if (nla_put_u32(msg, QCA_WLAN_VENDOR_ATTR_TDLS_CONFIG_TRIGGER_MODE,
9641 tdls_mode))
9642 goto fail;
9643
9644 nla_nest_end(msg, params);
9645
9646 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
9647 msg = NULL;
9648 if (ret) {
9649 wpa_printf(MSG_ERROR,
9650 "nl80211: Set TDLS mode failed: ret=%d (%s)",
9651 ret, strerror(-ret));
9652 goto fail;
9653 }
9654 return 0;
9655 fail:
9656 nlmsg_free(msg);
9657 return -1;
9658 }
9659
9660
9661 #ifdef CONFIG_MBO
9662
9663 static enum mbo_transition_reject_reason
9664 nl80211_mbo_reject_reason_mapping(enum qca_wlan_btm_candidate_status status)
9665 {
9666 switch (status) {
9667 case QCA_STATUS_REJECT_EXCESSIVE_FRAME_LOSS_EXPECTED:
9668 return MBO_TRANSITION_REJECT_REASON_FRAME_LOSS;
9669 case QCA_STATUS_REJECT_EXCESSIVE_DELAY_EXPECTED:
9670 return MBO_TRANSITION_REJECT_REASON_DELAY;
9671 case QCA_STATUS_REJECT_INSUFFICIENT_QOS_CAPACITY:
9672 return MBO_TRANSITION_REJECT_REASON_QOS_CAPACITY;
9673 case QCA_STATUS_REJECT_LOW_RSSI:
9674 return MBO_TRANSITION_REJECT_REASON_RSSI;
9675 case QCA_STATUS_REJECT_HIGH_INTERFERENCE:
9676 return MBO_TRANSITION_REJECT_REASON_INTERFERENCE;
9677 case QCA_STATUS_REJECT_UNKNOWN:
9678 default:
9679 return MBO_TRANSITION_REJECT_REASON_UNSPECIFIED;
9680 }
9681 }
9682
9683
9684 static void nl80211_parse_btm_candidate_info(struct candidate_list *candidate,
9685 struct nlattr *tb[], int num)
9686 {
9687 enum qca_wlan_btm_candidate_status status;
9688 char buf[50];
9689
9690 os_memcpy(candidate->bssid,
9691 nla_data(tb[QCA_WLAN_VENDOR_ATTR_BTM_CANDIDATE_INFO_BSSID]),
9692 ETH_ALEN);
9693
9694 status = nla_get_u32(
9695 tb[QCA_WLAN_VENDOR_ATTR_BTM_CANDIDATE_INFO_STATUS]);
9696 candidate->is_accept = status == QCA_STATUS_ACCEPT;
9697 candidate->reject_reason = nl80211_mbo_reject_reason_mapping(status);
9698
9699 if (candidate->is_accept)
9700 os_snprintf(buf, sizeof(buf), "Accepted");
9701 else
9702 os_snprintf(buf, sizeof(buf),
9703 "Rejected, Reject_reason: %d",
9704 candidate->reject_reason);
9705 wpa_printf(MSG_DEBUG, "nl80211: BSSID[%d]: " MACSTR " %s",
9706 num, MAC2STR(candidate->bssid), buf);
9707 }
9708
9709
9710 static int
9711 nl80211_get_bss_transition_status_handler(struct nl_msg *msg, void *arg)
9712 {
9713 struct wpa_bss_candidate_info *info = arg;
9714 struct candidate_list *candidate = info->candidates;
9715 struct nlattr *tb_msg[NL80211_ATTR_MAX + 1];
9716 struct nlattr *tb_vendor[QCA_WLAN_VENDOR_ATTR_MAX + 1];
9717 struct nlattr *tb[QCA_WLAN_VENDOR_ATTR_BTM_CANDIDATE_INFO_MAX + 1];
9718 static struct nla_policy policy[
9719 QCA_WLAN_VENDOR_ATTR_BTM_CANDIDATE_INFO_MAX + 1] = {
9720 [QCA_WLAN_VENDOR_ATTR_BTM_CANDIDATE_INFO_BSSID] = {
9721 .minlen = ETH_ALEN
9722 },
9723 [QCA_WLAN_VENDOR_ATTR_BTM_CANDIDATE_INFO_STATUS] = {
9724 .type = NLA_U32,
9725 },
9726 };
9727 struct nlattr *attr;
9728 int rem;
9729 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
9730 u8 num;
9731
9732 num = info->num; /* number of candidates sent to driver */
9733 info->num = 0;
9734 nla_parse(tb_msg, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
9735 genlmsg_attrlen(gnlh, 0), NULL);
9736
9737 if (!tb_msg[NL80211_ATTR_VENDOR_DATA] ||
9738 nla_parse_nested(tb_vendor, QCA_WLAN_VENDOR_ATTR_MAX,
9739 tb_msg[NL80211_ATTR_VENDOR_DATA], NULL) ||
9740 !tb_vendor[QCA_WLAN_VENDOR_ATTR_BTM_CANDIDATE_INFO])
9741 return NL_SKIP;
9742
9743 wpa_printf(MSG_DEBUG,
9744 "nl80211: WNM Candidate list received from driver");
9745 nla_for_each_nested(attr,
9746 tb_vendor[QCA_WLAN_VENDOR_ATTR_BTM_CANDIDATE_INFO],
9747 rem) {
9748 if (info->num >= num ||
9749 nla_parse_nested(
9750 tb, QCA_WLAN_VENDOR_ATTR_BTM_CANDIDATE_INFO_MAX,
9751 attr, policy) ||
9752 !tb[QCA_WLAN_VENDOR_ATTR_BTM_CANDIDATE_INFO_BSSID] ||
9753 !tb[QCA_WLAN_VENDOR_ATTR_BTM_CANDIDATE_INFO_STATUS])
9754 break;
9755
9756 nl80211_parse_btm_candidate_info(candidate, tb, info->num);
9757
9758 candidate++;
9759 info->num++;
9760 }
9761
9762 return NL_SKIP;
9763 }
9764
9765
9766 static struct wpa_bss_candidate_info *
9767 nl80211_get_bss_transition_status(void *priv, struct wpa_bss_trans_info *params)
9768 {
9769 struct i802_bss *bss = priv;
9770 struct wpa_driver_nl80211_data *drv = bss->drv;
9771 struct nl_msg *msg;
9772 struct nlattr *attr, *attr1, *attr2;
9773 struct wpa_bss_candidate_info *info;
9774 u8 i;
9775 int ret;
9776 u8 *pos;
9777
9778 if (!drv->fetch_bss_trans_status)
9779 return NULL;
9780
9781 info = os_zalloc(sizeof(*info));
9782 if (!info)
9783 return NULL;
9784 /* Allocate memory for number of candidates sent to driver */
9785 info->candidates = os_calloc(params->n_candidates,
9786 sizeof(*info->candidates));
9787 if (!info->candidates) {
9788 os_free(info);
9789 return NULL;
9790 }
9791
9792 /* Copy the number of candidates being sent to driver. This is used in
9793 * nl80211_get_bss_transition_status_handler() to limit the number of
9794 * candidates that can be populated in info->candidates and will be
9795 * later overwritten with the actual number of candidates received from
9796 * the driver.
9797 */
9798 info->num = params->n_candidates;
9799
9800 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_VENDOR)) ||
9801 nla_put_u32(msg, NL80211_ATTR_VENDOR_ID, OUI_QCA) ||
9802 nla_put_u32(msg, NL80211_ATTR_VENDOR_SUBCMD,
9803 QCA_NL80211_VENDOR_SUBCMD_FETCH_BSS_TRANSITION_STATUS))
9804 goto fail;
9805
9806 attr = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA);
9807 if (!attr)
9808 goto fail;
9809
9810 if (nla_put_u8(msg, QCA_WLAN_VENDOR_ATTR_BTM_MBO_TRANSITION_REASON,
9811 params->mbo_transition_reason))
9812 goto fail;
9813
9814 attr1 = nla_nest_start(msg, QCA_WLAN_VENDOR_ATTR_BTM_CANDIDATE_INFO);
9815 if (!attr1)
9816 goto fail;
9817
9818 wpa_printf(MSG_DEBUG,
9819 "nl80211: WNM Candidate list info sending to driver: mbo_transition_reason: %d n_candidates: %d",
9820 params->mbo_transition_reason, params->n_candidates);
9821 pos = params->bssid;
9822 for (i = 0; i < params->n_candidates; i++) {
9823 wpa_printf(MSG_DEBUG, "nl80211: BSSID[%d]: " MACSTR, i,
9824 MAC2STR(pos));
9825 attr2 = nla_nest_start(msg, i);
9826 if (!attr2 ||
9827 nla_put(msg, QCA_WLAN_VENDOR_ATTR_BTM_CANDIDATE_INFO_BSSID,
9828 ETH_ALEN, pos))
9829 goto fail;
9830 pos += ETH_ALEN;
9831 nla_nest_end(msg, attr2);
9832 }
9833
9834 nla_nest_end(msg, attr1);
9835 nla_nest_end(msg, attr);
9836
9837 ret = send_and_recv_msgs(drv, msg,
9838 nl80211_get_bss_transition_status_handler,
9839 info);
9840 msg = NULL;
9841 if (ret) {
9842 wpa_printf(MSG_ERROR,
9843 "nl80211: WNM Get BSS transition status failed: ret=%d (%s)",
9844 ret, strerror(-ret));
9845 goto fail;
9846 }
9847 return info;
9848
9849 fail:
9850 nlmsg_free(msg);
9851 os_free(info->candidates);
9852 os_free(info);
9853 return NULL;
9854 }
9855
9856 #endif /* CONFIG_MBO */
9857
9858 #endif /* CONFIG_DRIVER_NL80211_QCA */
9859
9860
9861 static int nl80211_write_to_file(const char *name, unsigned int val)
9862 {
9863 int fd, len;
9864 char tmp[128];
9865
9866 fd = open(name, O_RDWR);
9867 if (fd < 0) {
9868 wpa_printf(MSG_ERROR, "nl80211: Failed to open %s: %s",
9869 name, strerror(errno));
9870 return fd;
9871 }
9872
9873 len = os_snprintf(tmp, sizeof(tmp), "%u\n", val);
9874 len = write(fd, tmp, len);
9875 if (len < 0)
9876 wpa_printf(MSG_ERROR, "nl80211: Failed to write to %s: %s",
9877 name, strerror(errno));
9878 close(fd);
9879
9880 return 0;
9881 }
9882
9883
9884 static int nl80211_configure_data_frame_filters(void *priv, u32 filter_flags)
9885 {
9886 struct i802_bss *bss = priv;
9887 char path[128];
9888 int ret;
9889
9890 wpa_printf(MSG_DEBUG, "nl80211: Data frame filter flags=0x%x",
9891 filter_flags);
9892
9893 /* Configure filtering of unicast frame encrypted using GTK */
9894 ret = os_snprintf(path, sizeof(path),
9895 "/proc/sys/net/ipv4/conf/%s/drop_unicast_in_l2_multicast",
9896 bss->ifname);
9897 if (os_snprintf_error(sizeof(path), ret))
9898 return -1;
9899
9900 ret = nl80211_write_to_file(path,
9901 !!(filter_flags &
9902 WPA_DATA_FRAME_FILTER_FLAG_GTK));
9903 if (ret) {
9904 wpa_printf(MSG_ERROR,
9905 "nl80211: Failed to set IPv4 unicast in multicast filter");
9906 return ret;
9907 }
9908
9909 os_snprintf(path, sizeof(path),
9910 "/proc/sys/net/ipv6/conf/%s/drop_unicast_in_l2_multicast",
9911 bss->ifname);
9912 ret = nl80211_write_to_file(path,
9913 !!(filter_flags &
9914 WPA_DATA_FRAME_FILTER_FLAG_GTK));
9915
9916 if (ret) {
9917 wpa_printf(MSG_ERROR,
9918 "nl80211: Failed to set IPv6 unicast in multicast filter");
9919 return ret;
9920 }
9921
9922 /* Configure filtering of unicast frame encrypted using GTK */
9923 os_snprintf(path, sizeof(path),
9924 "/proc/sys/net/ipv4/conf/%s/drop_gratuitous_arp",
9925 bss->ifname);
9926 ret = nl80211_write_to_file(path,
9927 !!(filter_flags &
9928 WPA_DATA_FRAME_FILTER_FLAG_ARP));
9929 if (ret) {
9930 wpa_printf(MSG_ERROR,
9931 "nl80211: Failed set gratuitous ARP filter");
9932 return ret;
9933 }
9934
9935 /* Configure filtering of IPv6 NA frames */
9936 os_snprintf(path, sizeof(path),
9937 "/proc/sys/net/ipv6/conf/%s/drop_unsolicited_na",
9938 bss->ifname);
9939 ret = nl80211_write_to_file(path,
9940 !!(filter_flags &
9941 WPA_DATA_FRAME_FILTER_FLAG_NA));
9942 if (ret) {
9943 wpa_printf(MSG_ERROR,
9944 "nl80211: Failed to set unsolicited NA filter");
9945 return ret;
9946 }
9947
9948 return 0;
9949 }
9950
9951
9952 static int nl80211_get_ext_capab(void *priv, enum wpa_driver_if_type type,
9953 const u8 **ext_capa, const u8 **ext_capa_mask,
9954 unsigned int *ext_capa_len)
9955 {
9956 struct i802_bss *bss = priv;
9957 struct wpa_driver_nl80211_data *drv = bss->drv;
9958 enum nl80211_iftype nlmode;
9959 unsigned int i;
9960
9961 if (!ext_capa || !ext_capa_mask || !ext_capa_len)
9962 return -1;
9963
9964 nlmode = wpa_driver_nl80211_if_type(type);
9965
9966 /* By default, use the per-radio values */
9967 *ext_capa = drv->extended_capa;
9968 *ext_capa_mask = drv->extended_capa_mask;
9969 *ext_capa_len = drv->extended_capa_len;
9970
9971 /* Replace the default value if a per-interface type value exists */
9972 for (i = 0; i < drv->num_iface_ext_capa; i++) {
9973 if (nlmode == drv->iface_ext_capa[i].iftype) {
9974 *ext_capa = drv->iface_ext_capa[i].ext_capa;
9975 *ext_capa_mask = drv->iface_ext_capa[i].ext_capa_mask;
9976 *ext_capa_len = drv->iface_ext_capa[i].ext_capa_len;
9977 break;
9978 }
9979 }
9980
9981 return 0;
9982 }
9983
9984
9985 const struct wpa_driver_ops wpa_driver_nl80211_ops = {
9986 .name = "nl80211",
9987 .desc = "Linux nl80211/cfg80211",
9988 .get_bssid = wpa_driver_nl80211_get_bssid,
9989 .get_ssid = wpa_driver_nl80211_get_ssid,
9990 .set_key = driver_nl80211_set_key,
9991 .scan2 = driver_nl80211_scan2,
9992 .sched_scan = wpa_driver_nl80211_sched_scan,
9993 .stop_sched_scan = wpa_driver_nl80211_stop_sched_scan,
9994 .get_scan_results2 = wpa_driver_nl80211_get_scan_results,
9995 .abort_scan = wpa_driver_nl80211_abort_scan,
9996 .deauthenticate = driver_nl80211_deauthenticate,
9997 .authenticate = driver_nl80211_authenticate,
9998 .associate = wpa_driver_nl80211_associate,
9999 .global_init = nl80211_global_init,
10000 .global_deinit = nl80211_global_deinit,
10001 .init2 = wpa_driver_nl80211_init,
10002 .deinit = driver_nl80211_deinit,
10003 .get_capa = wpa_driver_nl80211_get_capa,
10004 .set_operstate = wpa_driver_nl80211_set_operstate,
10005 .set_supp_port = wpa_driver_nl80211_set_supp_port,
10006 .set_country = wpa_driver_nl80211_set_country,
10007 .get_country = wpa_driver_nl80211_get_country,
10008 .set_ap = wpa_driver_nl80211_set_ap,
10009 .set_acl = wpa_driver_nl80211_set_acl,
10010 .if_add = wpa_driver_nl80211_if_add,
10011 .if_remove = driver_nl80211_if_remove,
10012 .send_mlme = driver_nl80211_send_mlme,
10013 .get_hw_feature_data = nl80211_get_hw_feature_data,
10014 .sta_add = wpa_driver_nl80211_sta_add,
10015 .sta_remove = driver_nl80211_sta_remove,
10016 .hapd_send_eapol = wpa_driver_nl80211_hapd_send_eapol,
10017 .sta_set_flags = wpa_driver_nl80211_sta_set_flags,
10018 .hapd_init = i802_init,
10019 .hapd_deinit = i802_deinit,
10020 .set_wds_sta = i802_set_wds_sta,
10021 .get_seqnum = i802_get_seqnum,
10022 .flush = i802_flush,
10023 .get_inact_sec = i802_get_inact_sec,
10024 .sta_clear_stats = i802_sta_clear_stats,
10025 .set_rts = i802_set_rts,
10026 .set_frag = i802_set_frag,
10027 .set_tx_queue_params = i802_set_tx_queue_params,
10028 .set_sta_vlan = driver_nl80211_set_sta_vlan,
10029 .sta_deauth = i802_sta_deauth,
10030 .sta_disassoc = i802_sta_disassoc,
10031 .read_sta_data = driver_nl80211_read_sta_data,
10032 .set_freq = i802_set_freq,
10033 .send_action = driver_nl80211_send_action,
10034 .send_action_cancel_wait = wpa_driver_nl80211_send_action_cancel_wait,
10035 .remain_on_channel = wpa_driver_nl80211_remain_on_channel,
10036 .cancel_remain_on_channel =
10037 wpa_driver_nl80211_cancel_remain_on_channel,
10038 .probe_req_report = driver_nl80211_probe_req_report,
10039 .deinit_ap = wpa_driver_nl80211_deinit_ap,
10040 .deinit_p2p_cli = wpa_driver_nl80211_deinit_p2p_cli,
10041 .resume = wpa_driver_nl80211_resume,
10042 .signal_monitor = nl80211_signal_monitor,
10043 .signal_poll = nl80211_signal_poll,
10044 .send_frame = nl80211_send_frame,
10045 .set_param = nl80211_set_param,
10046 .get_radio_name = nl80211_get_radio_name,
10047 .add_pmkid = nl80211_add_pmkid,
10048 .remove_pmkid = nl80211_remove_pmkid,
10049 .flush_pmkid = nl80211_flush_pmkid,
10050 .set_rekey_info = nl80211_set_rekey_info,
10051 .poll_client = nl80211_poll_client,
10052 .set_p2p_powersave = nl80211_set_p2p_powersave,
10053 .start_dfs_cac = nl80211_start_radar_detection,
10054 .stop_ap = wpa_driver_nl80211_stop_ap,
10055 #ifdef CONFIG_TDLS
10056 .send_tdls_mgmt = nl80211_send_tdls_mgmt,
10057 .tdls_oper = nl80211_tdls_oper,
10058 .tdls_enable_channel_switch = nl80211_tdls_enable_channel_switch,
10059 .tdls_disable_channel_switch = nl80211_tdls_disable_channel_switch,
10060 #endif /* CONFIG_TDLS */
10061 .update_ft_ies = wpa_driver_nl80211_update_ft_ies,
10062 .get_mac_addr = wpa_driver_nl80211_get_macaddr,
10063 .get_survey = wpa_driver_nl80211_get_survey,
10064 .status = wpa_driver_nl80211_status,
10065 .switch_channel = nl80211_switch_channel,
10066 #ifdef ANDROID_P2P
10067 .set_noa = wpa_driver_set_p2p_noa,
10068 .get_noa = wpa_driver_get_p2p_noa,
10069 .set_ap_wps_ie = wpa_driver_set_ap_wps_p2p_ie,
10070 #endif /* ANDROID_P2P */
10071 #ifdef ANDROID
10072 #ifndef ANDROID_LIB_STUB
10073 .driver_cmd = wpa_driver_nl80211_driver_cmd,
10074 #endif /* !ANDROID_LIB_STUB */
10075 #endif /* ANDROID */
10076 .vendor_cmd = nl80211_vendor_cmd,
10077 .set_qos_map = nl80211_set_qos_map,
10078 .set_wowlan = nl80211_set_wowlan,
10079 .set_mac_addr = nl80211_set_mac_addr,
10080 #ifdef CONFIG_MESH
10081 .init_mesh = wpa_driver_nl80211_init_mesh,
10082 .join_mesh = wpa_driver_nl80211_join_mesh,
10083 .leave_mesh = wpa_driver_nl80211_leave_mesh,
10084 #endif /* CONFIG_MESH */
10085 .br_add_ip_neigh = wpa_driver_br_add_ip_neigh,
10086 .br_delete_ip_neigh = wpa_driver_br_delete_ip_neigh,
10087 .br_port_set_attr = wpa_driver_br_port_set_attr,
10088 .br_set_net_param = wpa_driver_br_set_net_param,
10089 .add_tx_ts = nl80211_add_ts,
10090 .del_tx_ts = nl80211_del_ts,
10091 .get_ifindex = nl80211_get_ifindex,
10092 #ifdef CONFIG_DRIVER_NL80211_QCA
10093 .roaming = nl80211_roaming,
10094 .do_acs = wpa_driver_do_acs,
10095 .set_band = nl80211_set_band,
10096 .get_pref_freq_list = nl80211_get_pref_freq_list,
10097 .set_prob_oper_freq = nl80211_set_prob_oper_freq,
10098 .p2p_lo_start = nl80211_p2p_lo_start,
10099 .p2p_lo_stop = nl80211_p2p_lo_stop,
10100 .set_default_scan_ies = nl80211_set_default_scan_ies,
10101 .set_tdls_mode = nl80211_set_tdls_mode,
10102 #ifdef CONFIG_MBO
10103 .get_bss_transition_status = nl80211_get_bss_transition_status,
10104 #endif /* CONFIG_MBO */
10105 #endif /* CONFIG_DRIVER_NL80211_QCA */
10106 .configure_data_frame_filters = nl80211_configure_data_frame_filters,
10107 .get_ext_capab = nl80211_get_ext_capab,
10108 };
Unnamed repository; edit this file 'description' to name the repository.