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