Lines Matching defs:drv
164 wpa_driver_nl80211_finish_drv_init(struct wpa_driver_nl80211_data *drv,
178 static void add_ifidx(struct wpa_driver_nl80211_data *drv, int ifidx,
180 static void del_ifidx(struct wpa_driver_nl80211_data *drv, int ifidx,
182 static int have_ifidx(struct wpa_driver_nl80211_data *drv, int ifidx,
187 static int nl80211_disable_11b_rates(struct wpa_driver_nl80211_data *drv,
190 static int nl80211_leave_ibss(struct wpa_driver_nl80211_data *drv,
249 struct i802_bss * get_bss_ifindex(struct wpa_driver_nl80211_data *drv,
254 for (bss = drv->first_bss; bss; bss = bss->next) {
269 void nl80211_mark_disconnected(struct wpa_driver_nl80211_data *drv)
271 if (drv->associated)
272 os_memcpy(drv->prev_bssid, drv->bssid, ETH_ALEN);
273 drv->associated = 0;
274 os_memset(&drv->sta_mlo_info, 0, sizeof(drv->sta_mlo_info));
275 os_memset(drv->bssid, 0, ETH_ALEN);
276 drv->first_bss->flink->freq = 0;
278 os_free(drv->pending_roam_data);
279 drv->pending_roam_data = NULL;
280 os_free(drv->pending_t2lm_data);
281 drv->pending_t2lm_data = NULL;
282 os_free(drv->pending_link_reconfig_data);
283 drv->pending_link_reconfig_data = NULL;
286 drv->auth_mld = false;
287 drv->auth_mld_link_id = -1;
288 os_memset(drv->auth_ap_mld_addr, 0, ETH_ALEN);
455 static int send_event_marker(struct wpa_driver_nl80211_data *drv)
468 if (!nl80211_cmd(drv, msg, 0, NL80211_CMD_GET_PROTOCOL_FEATURES))
471 handle = (void *) (((intptr_t) drv->global->nl_event) ^
586 static int nl80211_put_control_port(struct wpa_driver_nl80211_data *drv,
591 ((drv->capa.flags2 & WPA_DRIVER_FLAGS2_CONTROL_PORT_RX) &&
661 void * nl80211_cmd(struct wpa_driver_nl80211_data *drv,
666 return genlmsg_put(msg, 0, 0, drv->global->nl80211_id,
687 if (!nl80211_cmd(bss->drv, msg, flags, cmd) ||
698 nl80211_ifindex_msg_build(struct wpa_driver_nl80211_data *drv,
705 if (!nl80211_cmd(drv, msg, flags, cmd) ||
716 nl80211_ifindex_msg(struct wpa_driver_nl80211_data *drv, int ifindex,
719 return nl80211_ifindex_msg_build(drv, nlmsg_alloc(), ifindex, flags,
724 struct nl_msg * nl80211_drv_msg(struct wpa_driver_nl80211_data *drv, int flags,
727 return nl80211_ifindex_msg(drv, drv->ifindex, flags, cmd);
733 return nl80211_ifindex_msg(bss->drv, bss->ifindex, flags, cmd);
782 if (send_and_recv_resp(bss->drv, msg, netdev_info_handler, &data) == 0)
799 if (send_and_recv_resp(bss->drv, msg, netdev_info_handler, &data) == 0)
815 return send_and_recv_resp(bss->drv, msg, netdev_info_handler, &data);
827 send_and_recv_resp(bss->drv, msg, netdev_info_handler, &data))
833 static int nl80211_register_beacons(struct wpa_driver_nl80211_data *drv,
843 if (!nl80211_cmd(drv, msg, 0, NL80211_CMD_REGISTER_BEACONS) ||
849 ret = send_and_recv(drv->global, w->nl_beacons, msg, NULL, NULL,
878 struct wpa_driver_nl80211_data *drv;
895 dl_list_for_each(drv, &w->drvs, struct wpa_driver_nl80211_data,
900 wpa_supplicant_event(drv->ctx, EVENT_RX_MGMT, &event);
947 w->nl_beacons = nl_create_handle(bss->drv->global->nl_cb,
954 if (nl80211_register_beacons(bss->drv, w)) {
967 /* drv entry for this bss already there? */
969 if (tmp_bss->drv == bss->drv) {
976 dl_list_add(&w->drvs, &bss->drv->wiphy_list);
995 /* still any for this drv present? */
997 if (tmp_bss->drv == bss->drv) {
1004 dl_list_del(&bss->drv->wiphy_list);
1021 struct wpa_driver_nl80211_data *drv = bss->drv;
1023 return drv->ifindex;
1030 struct wpa_driver_nl80211_data *drv = bss->drv;
1031 if (!drv->associated)
1033 os_memcpy(bssid, drv->bssid, ETH_ALEN);
1041 struct wpa_driver_nl80211_data *drv = bss->drv;
1042 if (!drv->associated)
1044 os_memcpy(ssid, drv->ssid, drv->ssid_len);
1045 return drv->ssid_len;
1098 struct wpa_driver_nl80211_data *drv = bss->drv;
1100 if (!drv->associated)
1103 if (drv->capa.flags & WPA_DRIVER_FLAGS_SME) {
1106 msg = nl80211_drv_msg(drv, 0, NL80211_CMD_GET_INTERFACE);
1107 if (send_and_recv_resp(drv, msg, get_mlo_info,
1108 &drv->sta_mlo_info))
1112 os_memcpy(mlo_info, &drv->sta_mlo_info, sizeof(*mlo_info));
1118 struct nl80211_global *global, struct wpa_driver_nl80211_data *drv,
1123 if (drv && os_strcmp(drv->first_bss->ifname, ifname) == 0) {
1124 if (if_nametoindex(drv->first_bss->ifname) == 0) {
1126 drv->first_bss->ifname);
1129 if (!drv->if_removed)
1132 drv->first_bss->ifname);
1133 drv->if_removed = 0;
1141 if (drv)
1142 wpa_supplicant_event(drv->ctx, EVENT_INTERFACE_STATUS, &event);
1150 struct nl80211_global *global, struct wpa_driver_nl80211_data *drv,
1155 if (drv && os_strcmp(drv->first_bss->ifname, ifname) == 0) {
1156 if (drv->if_removed) {
1163 drv->if_removed = 1;
1174 if (drv)
1175 wpa_supplicant_event(drv->ctx, EVENT_INTERFACE_STATUS, &event);
1182 static int wpa_driver_nl80211_own_ifname(struct wpa_driver_nl80211_data *drv,
1195 drv->first_bss->ifname) == 0)
1207 static int wpa_driver_nl80211_own_ifindex(struct wpa_driver_nl80211_data *drv,
1210 if (drv->ifindex == ifindex)
1213 if (drv->if_removed && wpa_driver_nl80211_own_ifname(drv, buf, len)) {
1214 nl80211_check_global(drv->global);
1217 if (wpa_driver_nl80211_finish_drv_init(drv, NULL, 0, NULL) < 0)
1230 struct wpa_driver_nl80211_data *drv;
1235 dl_list_for_each(drv, &global->interfaces,
1237 res = wpa_driver_nl80211_own_ifindex(drv, idx, buf, len);
1243 return drv;
1245 if (res > 0 || have_ifidx(drv, idx, IFIDX_ANY))
1246 return drv;
1252 static void nl80211_refresh_mac(struct wpa_driver_nl80211_data *drv,
1258 bss = get_bss_ifindex(drv, ifindex);
1260 linux_get_ifhwaddr(drv->global->ioctl_sock,
1274 wpa_supplicant_event(drv->ctx,
1285 struct wpa_driver_nl80211_data *drv;
1337 drv = nl80211_find_drv(global, ifi->ifi_index, buf, len, &init_failed);
1338 if (!drv)
1343 if (!drv->if_disabled && !(ifi->ifi_flags & IFF_UP)) {
1346 linux_iface_up(drv->global->ioctl_sock, namebuf) > 0) {
1349 drv->ignore_if_down_event = 0;
1351 nl80211_refresh_mac(drv, ifi->ifi_index, 1);
1356 if (os_strcmp(drv->first_bss->ifname, ifname) != 0) {
1359 drv->first_bss->ifname);
1360 } else if (drv->ignore_if_down_event) {
1363 drv->ignore_if_down_event = 0;
1365 drv->if_disabled = 1;
1366 wpa_supplicant_event(drv->ctx,
1370 * Try to get drv again, since it may be removed as
1374 drv = nl80211_find_drv(global, ifi->ifi_index,
1376 if (!drv)
1381 if (drv->if_disabled && (ifi->ifi_flags & IFF_UP)) {
1384 linux_iface_up(drv->global->ioctl_sock, namebuf) == 0) {
1392 if (os_strcmp(drv->first_bss->ifname, ifname) != 0) {
1395 drv->first_bss->ifname);
1396 } else if (if_nametoindex(drv->first_bss->ifname) == 0) {
1399 drv->first_bss->ifname);
1400 } else if (drv->if_removed) {
1403 "removed", drv->first_bss->ifname);
1406 nl80211_refresh_mac(drv, ifi->ifi_index, 0);
1408 drv->if_disabled = 0;
1409 wpa_supplicant_event(drv->ctx, EVENT_INTERFACE_ENABLED,
1420 if (drv->operstate == 1 &&
1424 netlink_send_oper_ifla(drv->global->netlink, drv->ifindex,
1430 wpa_driver_nl80211_event_newlink(global, drv, ifi->ifi_index,
1433 if (ifi->ifi_family == AF_BRIDGE && brid && drv) {
1445 add_ifidx(drv, brid, ifi->ifi_index);
1447 for (bss = drv->first_bss; bss; bss = bss->next) {
1462 struct wpa_driver_nl80211_data *drv;
1509 drv = nl80211_find_drv(global, ifi->ifi_index, buf, len, NULL);
1511 if (ifi->ifi_family == AF_BRIDGE && brid && drv) {
1524 del_ifidx(drv, brid, ifi->ifi_index);
1528 wpa_driver_nl80211_event_dellink(global, drv, ifi->ifi_index,
1534 struct wpa_driver_nl80211_data *drv;
1558 struct wpa_driver_nl80211_data *drv = ctx->drv;
1584 if (!drv->sta_mlo_info.valid_links ||
1585 drv->sta_mlo_info.assoc_link_id == link_id) {
1612 if (!drv->sta_mlo_info.valid_links ||
1613 drv->sta_mlo_info.assoc_link_id == link_id) {
1639 int nl80211_get_assoc_ssid(struct wpa_driver_nl80211_data *drv, u8 *ssid)
1647 msg = nl80211_drv_msg(drv, NLM_F_DUMP, NL80211_CMD_GET_SCAN);
1649 arg.drv = drv;
1650 ret = send_and_recv_resp(drv, msg, nl80211_get_assoc_freq_handler,
1673 unsigned int nl80211_get_assoc_freq(struct wpa_driver_nl80211_data *drv)
1681 msg = nl80211_drv_msg(drv, NLM_F_DUMP, NL80211_CMD_GET_SCAN);
1683 arg.drv = drv;
1684 ret = send_and_recv_resp(drv, msg, nl80211_get_assoc_freq_handler,
1698 unsigned int freq = drv->nlmode == NL80211_IFTYPE_ADHOC ?
1703 drv->assoc_freq = freq;
1705 if (drv->sta_mlo_info.valid_links) {
1709 drv->sta_mlo_info.links[i].freq = arg.freq[i];
1712 return drv->assoc_freq;
1716 return drv->assoc_freq;
1764 int nl80211_get_link_noise(struct wpa_driver_nl80211_data *drv,
1770 sig_change->frequency = drv->assoc_freq;
1772 msg = nl80211_drv_msg(drv, NLM_F_DUMP, NL80211_CMD_GET_SURVEY);
1773 return send_and_recv_resp(drv, msg, get_link_noise, sig_change);
1833 struct wpa_driver_nl80211_data *drv = bss->drv;
1836 msg = nl80211_drv_msg(drv, 0, NL80211_CMD_GET_INTERFACE);
1837 return send_and_recv_resp(drv, msg, get_channel_info, ci);
1869 struct wpa_driver_nl80211_data *drv = bss->drv;
1881 if (!nl80211_cmd(drv, msg, 0, NL80211_CMD_REQ_SET_REG) ||
1886 if (send_and_recv_cmd(drv, msg))
1912 struct wpa_driver_nl80211_data *drv = bss->drv;
1920 nl80211_cmd(drv, msg, 0, NL80211_CMD_GET_REG);
1922 if (drv->capa.flags & WPA_DRIVER_FLAGS_SELF_MANAGED_REGULATORY) {
1925 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, drv->wiphy_idx)) {
1932 ret = send_and_recv_resp(drv, msg, nl80211_get_country, alpha2);
2089 struct wpa_driver_nl80211_data *drv = ctx;
2097 if (drv->nlmode == NL80211_IFTYPE_P2P_DEVICE)
2098 wpa_supplicant_event(drv->ctx, EVENT_INTERFACE_DISABLED, NULL);
2104 struct wpa_driver_nl80211_data *drv = ctx;
2106 if (i802_set_iface_flags(drv->first_bss, 1)) {
2112 if (is_p2p_net_interface(drv->nlmode))
2113 nl80211_disable_11b_rates(drv, drv->ifindex, 1);
2119 if (drv->nlmode == NL80211_IFTYPE_P2P_DEVICE)
2120 wpa_supplicant_event(drv->ctx, EVENT_INTERFACE_ENABLED, NULL);
2128 struct wpa_driver_nl80211_data *drv = eloop_ctx;
2179 wpa_supplicant_event(drv->ctx, EVENT_EAPOL_TX_STATUS, &event);
2230 wpa_driver_nl80211_drv_init_rfkill(struct wpa_driver_nl80211_data *drv)
2234 if (drv->rfkill)
2241 rcfg->ctx = drv;
2250 if (drv->nlmode == NL80211_IFTYPE_P2P_DEVICE) {
2251 struct nl80211_global *global = drv->global;
2256 if (drv == tmp1 || drv->wiphy_idx != tmp1->wiphy_idx ||
2268 os_strlcpy(rcfg->ifname, drv->first_bss->ifname,
2274 drv->rfkill = rfkill_init(rcfg);
2275 if (!drv->rfkill) {
2287 struct wpa_driver_nl80211_data *drv;
2312 drv = os_zalloc(sizeof(*drv));
2313 if (drv == NULL)
2315 drv->global = global_priv;
2316 drv->ctx = ctx;
2317 drv->hostapd = !!hostapd;
2318 drv->eapol_sock = -1;
2325 drv->set_rekey_offload = 1;
2327 drv->num_if_indices = ARRAY_SIZE(drv->default_if_indices);
2328 drv->if_indices = drv->default_if_indices;
2330 drv->first_bss = os_zalloc(sizeof(*drv->first_bss));
2331 if (!drv->first_bss) {
2332 os_free(drv);
2335 bss = drv->first_bss;
2336 bss->drv = drv;
2340 drv->monitor_ifidx = -1;
2341 drv->monitor_sock = -1;
2342 drv->eapol_tx_sock = -1;
2343 drv->ap_scan_as_station = NL80211_IFTYPE_UNSPECIFIED;
2348 if (wpa_driver_nl80211_finish_drv_init(drv, set_addr, 1, driver_params))
2351 if (drv->capa.flags2 & WPA_DRIVER_FLAGS2_CONTROL_PORT_TX_STATUS) {
2352 drv->control_port_ap = 1;
2356 drv->eapol_tx_sock = socket(PF_PACKET, SOCK_DGRAM, 0);
2357 if (drv->eapol_tx_sock < 0)
2360 if (drv->data_tx_status) {
2363 if (setsockopt(drv->eapol_tx_sock, SOL_SOCKET, SO_WIFI_STATUS,
2368 drv->data_tx_status = 0;
2369 if (!drv->use_monitor)
2370 drv->capa.flags &=
2374 drv->eapol_tx_sock,
2376 drv, NULL);
2381 if (drv->global) {
2382 nl80211_check_global(drv->global);
2383 dl_list_add(&drv->global->interfaces, &drv->list);
2384 drv->in_interface_list = 1;
2423 struct wpa_driver_nl80211_data *drv = bss->drv;
2442 ret = send_and_recv(drv->global, nl_handle, msg, NULL, NULL,
2498 struct wpa_driver_nl80211_data *drv = bss->drv;
2507 if (drv->nlmode == NL80211_IFTYPE_ADHOC) {
2510 } else if ((drv->capa.flags & WPA_DRIVER_FLAGS_SAE) &&
2511 !(drv->capa.flags & WPA_DRIVER_FLAGS_SME)) {
2594 if ((drv->capa.flags & WPA_DRIVER_FLAGS_TDLS_SUPPORT)) {
2610 else if (!drv->has_driver_key_mgmt) {
2615 drv->capa.key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_FT |
2620 drv->capa.key_mgmt_iftype[i] = drv->capa.key_mgmt;
2654 if (!drv->no_rrm &&
2659 if ((drv->capa.rrm_flags & WPA_DRIVER_FLAGS_TX_POWER_INSERTION) &&
2722 ret = send_and_recv(bss->drv->global, bss->nl_mgmt, msg, NULL, NULL,
2834 if (bss->drv->device_ap_sme) {
2877 ret = send_and_recv_cmd(bss->drv, msg);
2892 ret = send_and_recv_cmd(bss->drv, msg);
2908 return linux_set_iface_flags(bss->drv->global->ioctl_sock,
2920 /* struct wpa_driver_nl80211_data *drv = arg; */
2945 static void qca_vendor_test(struct wpa_driver_nl80211_data *drv)
2952 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_VENDOR)) ||
2963 ret = send_and_recv_resp(drv, msg, qca_vendor_test_cmd_handler, drv);
2972 wpa_driver_nl80211_finish_drv_init(struct wpa_driver_nl80211_data *drv,
2976 struct i802_bss *bss = drv->first_bss;
2980 drv->ifindex = if_nametoindex(bss->ifname);
2981 bss->ifindex = drv->ifindex;
2982 bss->wdev_id = drv->global->if_add_wdevid;
2983 bss->wdev_id_set = drv->global->if_add_wdevid_set;
2985 bss->if_dynamic = drv->ifindex == drv->global->if_add_ifindex;
2986 bss->if_dynamic = bss->if_dynamic || drv->global->if_add_wdevid_set;
2987 drv->global->if_add_wdevid_set = 0;
2994 linux_iface_up(drv->global->ioctl_sock, bss->ifname) > 0)
2995 drv->start_iface_up = 1;
2997 if (wpa_driver_nl80211_capa(drv))
3004 bss->ifname, drv->phyname);
3007 (linux_set_iface_flags(drv->global->ioctl_sock, bss->ifname, 0) ||
3008 linux_set_ifhwaddr(drv->global->ioctl_sock, bss->ifname,
3013 drv->start_mode_sta = 1;
3015 if (drv->hostapd || bss->static_ap)
3031 wpa_driver_nl80211_drv_init_rfkill(drv);
3033 if (!rfkill_is_blocked(drv->rfkill)) {
3042 nl80211_disable_11b_rates(bss->drv,
3043 bss->drv->ifindex, 1);
3051 drv->if_disabled = 1;
3056 if (!drv->hostapd && nlmode != NL80211_IFTYPE_P2P_DEVICE)
3057 netlink_send_oper_ifla(drv->global->netlink, drv->ifindex,
3061 if (linux_get_ifhwaddr(drv->global->ioctl_sock, bss->ifname,
3064 os_memcpy(drv->perm_addr, bss->addr, ETH_ALEN);
3069 drv, drv->ctx);
3072 if (drv->vendor_cmd_test_avail)
3073 qca_vendor_test(drv);
3083 struct wpa_driver_nl80211_data *drv = bss->drv;
3110 return send_and_recv_cmd(drv, msg);
3132 struct wpa_driver_nl80211_data *drv = bss->drv;
3136 bss->ifname, drv->disabled_11b_rates);
3139 if (drv->data_tx_status)
3140 eloop_unregister_read_sock(drv->eapol_tx_sock);
3141 if (drv->eapol_tx_sock >= 0)
3142 close(drv->eapol_tx_sock);
3147 if (linux_br_del_if(drv->global->ioctl_sock, bss->brname,
3154 if (drv->rtnl_sk)
3155 nl_socket_free(drv->rtnl_sk);
3158 if (linux_set_iface_flags(drv->global->ioctl_sock, bss->brname,
3163 if (linux_br_del(drv->global->ioctl_sock, bss->brname) < 0)
3169 nl80211_remove_monitor_interface(drv);
3171 if (is_ap_interface(drv->nlmode)) {
3176 if (drv->eapol_sock >= 0) {
3177 eloop_unregister_read_sock(drv->eapol_sock);
3178 close(drv->eapol_sock);
3181 if (drv->if_indices != drv->default_if_indices)
3182 os_free(drv->if_indices);
3184 if (drv->disabled_11b_rates)
3185 nl80211_disable_11b_rates(drv, drv->ifindex, 0);
3187 netlink_send_oper_ifla(drv->global->netlink, drv->ifindex, 0,
3189 eloop_cancel_timeout(wpa_driver_nl80211_send_rfkill, drv, drv->ctx);
3190 rfkill_deinit(drv->rfkill);
3192 eloop_cancel_timeout(wpa_driver_nl80211_scan_timeout, drv, drv->ctx);
3194 if (!drv->start_iface_up)
3197 if (drv->addr_changed) {
3198 if (linux_set_iface_flags(drv->global->ioctl_sock, bss->ifname,
3203 if (linux_set_ifhwaddr(drv->global->ioctl_sock, bss->ifname,
3204 drv->perm_addr) < 0) {
3210 if (drv->nlmode != NL80211_IFTYPE_P2P_DEVICE) {
3211 if (drv->start_mode_sta)
3220 nl80211_destroy_bss(drv->first_bss);
3222 os_free(drv->filter_ssids);
3224 os_free(drv->auth_ie);
3225 os_free(drv->auth_data);
3227 if (drv->in_interface_list)
3228 dl_list_del(&drv->list);
3230 os_free(drv->extended_capa);
3231 os_free(drv->extended_capa_mask);
3232 for (i = 0; i < drv->num_iface_capa; i++) {
3233 os_free(drv->iface_capa[i].ext_capa);
3234 os_free(drv->iface_capa[i].ext_capa_mask);
3236 os_free(drv->first_bss);
3238 os_free(drv->pending_roam_data);
3240 os_free(drv);
3372 static int issue_key_mgmt_set_key(struct wpa_driver_nl80211_data *drv,
3378 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_KEY_MGMT_OFFLOAD))
3381 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_VENDOR)) ||
3390 ret = send_and_recv_cmd(drv, msg);
3402 static int nl80211_set_pmk(struct wpa_driver_nl80211_data *drv,
3413 if (!addr && drv->associated)
3414 addr = drv->bssid;
3421 msg = nl80211_drv_msg(drv, 0, NL80211_CMD_SET_PMK);
3430 ret = send_and_recv_cmd(drv, msg);
3443 struct wpa_driver_nl80211_data *drv = bss->drv;
3463 if (drv->nlmode == NL80211_IFTYPE_P2P_DEVICE)
3480 (drv->capa.flags & WPA_DRIVER_FLAGS_KEY_MGMT_OFFLOAD)) {
3483 ret = issue_key_mgmt_set_key(drv, key, key_len);
3489 if (drv->capa.flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE_8021X)
3490 return nl80211_set_pmk(drv, key, key_len, addr);
3505 msg = nl80211_ifindex_msg(drv, ifindex, 0, NL80211_CMD_SET_KEY);
3515 msg = nl80211_ifindex_msg(drv, ifindex, 0, NL80211_CMD_DEL_KEY);
3527 msg = nl80211_ifindex_msg(drv, ifindex, 0, NL80211_CMD_NEW_KEY);
3592 if (vlan_id && (drv->capa.flags & WPA_DRIVER_FLAGS_VLAN_OFFLOAD)) {
3604 ret = send_and_recv_cmd(drv, msg);
3624 msg = nl80211_ifindex_msg(drv, ifindex, 0, NL80211_CMD_SET_KEY);
3659 if (vlan_id && (drv->capa.flags & WPA_DRIVER_FLAGS_VLAN_OFFLOAD)) {
3673 ret = send_and_recv_cmd(drv, msg);
3779 int wpa_driver_nl80211_mlme(struct wpa_driver_nl80211_data *drv,
3787 if (!(msg = nl80211_drv_msg(drv, 0, cmd)) ||
3796 ret = send_and_recv(drv->global, bss->nl_connect, msg,
3799 wpa_dbg(drv->ctx, MSG_DEBUG,
3807 static int wpa_driver_nl80211_disconnect(struct wpa_driver_nl80211_data *drv,
3814 nl80211_mark_disconnected(drv);
3816 ret = wpa_driver_nl80211_mlme(drv, NULL, NL80211_CMD_DISCONNECT,
3823 drv->ignore_next_local_disconnect = send_event_marker(drv);
3832 struct wpa_driver_nl80211_data *drv = bss->drv;
3835 if (drv->nlmode == NL80211_IFTYPE_ADHOC) {
3836 nl80211_mark_disconnected(drv);
3837 return nl80211_leave_ibss(drv, 1);
3839 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_SME)) {
3840 return wpa_driver_nl80211_disconnect(drv, reason_code, bss);
3844 nl80211_mark_disconnected(drv);
3845 ret = wpa_driver_nl80211_mlme(drv, addr, NL80211_CMD_DEAUTHENTICATE,
3852 drv->ignore_next_local_deauth = send_event_marker(drv);
3858 static void nl80211_copy_auth_params(struct wpa_driver_nl80211_data *drv,
3863 drv->auth_freq = params->freq;
3864 drv->auth_alg = params->auth_alg;
3865 drv->auth_wep_tx_keyidx = params->wep_tx_keyidx;
3866 drv->auth_local_state_change = params->local_state_change;
3867 drv->auth_p2p = params->p2p;
3870 os_memcpy(drv->auth_bssid_, params->bssid, ETH_ALEN);
3872 os_memset(drv->auth_bssid_, 0, ETH_ALEN);
3875 os_memcpy(drv->auth_ssid, params->ssid, params->ssid_len);
3876 drv->auth_ssid_len = params->ssid_len;
3878 drv->auth_ssid_len = 0;
3881 os_free(drv->auth_ie);
3882 drv->auth_ie = NULL;
3883 drv->auth_ie_len = 0;
3885 drv->auth_ie = os_malloc(params->ie_len);
3886 if (drv->auth_ie) {
3887 os_memcpy(drv->auth_ie, params->ie, params->ie_len);
3888 drv->auth_ie_len = params->ie_len;
3893 drv->auth_mld = params->mld;
3894 drv->auth_mld_link_id = params->mld_link_id;
3895 os_memcpy(drv->auth_ap_mld_addr, params->ap_mld_addr, ETH_ALEN);
3897 drv->auth_mld = false;
3898 drv->auth_mld_link_id = -1;
3901 os_free(drv->auth_data);
3902 drv->auth_data = NULL;
3903 drv->auth_data_len = 0;
3905 drv->auth_data = os_memdup(params->auth_data,
3907 if (drv->auth_data)
3908 drv->auth_data_len = params->auth_data_len;
3914 os_memcpy(drv->auth_wep_key[i], params->wep_key[i],
3916 drv->auth_wep_key_len[i] = params->wep_key_len[i];
3918 drv->auth_wep_key_len[i] = 0;
3925 struct wpa_driver_nl80211_data *drv = bss->drv;
3927 if (is_p2p_net_interface(drv->nlmode) || !drv->disabled_11b_rates)
3938 nl80211_disable_11b_rates(drv, drv->ifindex, 0);
3966 struct wpa_driver_nl80211_data *drv = bss->drv;
3977 is_retry = drv->retry_auth;
3978 drv->retry_auth = 0;
3979 drv->ignore_deauth_event = 0;
3981 nl80211_mark_disconnected(drv);
3982 os_memset(drv->auth_bssid, 0, ETH_ALEN);
3984 os_memcpy(drv->auth_attempt_bssid, params->bssid, ETH_ALEN);
3986 os_memset(drv->auth_attempt_bssid, 0, ETH_ALEN);
3990 if (drv->nlmode != nlmode &&
3996 drv->ifindex);
3998 msg = nl80211_drv_msg(drv, 0, NL80211_CMD_AUTHENTICATE);
4075 ret = send_and_recv_cmd(drv, msg);
4078 wpa_dbg(drv->ctx, MSG_DEBUG,
4091 drv->ignore_deauth_event = 1;
4123 nl80211_copy_auth_params(drv, params);
4124 drv->scan_for_auth = 1;
4135 os_memcpy(event.timeout_event.addr, drv->auth_bssid_,
4137 wpa_supplicant_event(drv->ctx, EVENT_AUTH_TIMED_OUT,
4151 int wpa_driver_nl80211_authenticate_retry(struct wpa_driver_nl80211_data *drv)
4154 struct i802_bss *bss = drv->first_bss;
4161 params.freq = drv->auth_freq;
4162 params.auth_alg = drv->auth_alg;
4163 params.wep_tx_keyidx = drv->auth_wep_tx_keyidx;
4164 params.local_state_change = drv->auth_local_state_change;
4165 params.p2p = drv->auth_p2p;
4167 if (!is_zero_ether_addr(drv->auth_bssid_))
4168 params.bssid = drv->auth_bssid_;
4170 if (drv->auth_ssid_len) {
4171 params.ssid = drv->auth_ssid;
4172 params.ssid_len = drv->auth_ssid_len;
4175 params.ie = drv->auth_ie;
4176 params.ie_len = drv->auth_ie_len;
4177 params.auth_data = drv->auth_data;
4178 params.auth_data_len = drv->auth_data_len;
4179 params.mld = drv->auth_mld;
4180 params.mld_link_id = drv->auth_mld_link_id;
4181 if (drv->auth_mld) {
4182 os_memcpy(ap_mld_addr, drv->auth_ap_mld_addr, ETH_ALEN);
4187 if (drv->auth_wep_key_len[i]) {
4188 params.wep_key[i] = drv->auth_wep_key[i];
4189 params.wep_key_len[i] = drv->auth_wep_key_len[i];
4193 drv->retry_auth = 1;
4250 struct wpa_driver_nl80211_data *drv = bss->drv;
4265 no_encrypt, fc, fc2str(fc), drv->nlmode);
4267 if ((is_sta_interface(drv->nlmode) ||
4268 drv->nlmode == NL80211_IFTYPE_P2P_DEVICE) &&
4278 drv->last_mgmt_freq);
4279 freq = drv->last_mgmt_freq;
4288 if (drv->device_ap_sme && is_ap_interface(drv->nlmode)) {
4315 if (is_sta_interface(drv->nlmode) &&
4319 (drv->capa.flags & WPA_DRIVER_FLAGS_SAE) &&
4320 !(drv->capa.flags & WPA_DRIVER_FLAGS_SME)) {
4321 freq = nl80211_get_assoc_freq(drv);
4338 if (is_sta_interface(drv->nlmode) &&
4350 if (freq == 0 && drv->nlmode == NL80211_IFTYPE_ADHOC) {
4351 freq = nl80211_get_assoc_freq(drv);
4362 if (drv->use_monitor && is_ap_interface(drv->nlmode)) {
4366 return nl80211_send_monitor(drv, data, data_len, encrypt,
4376 if (no_encrypt && !encrypt && !drv->use_monitor) {
4379 if (nl80211_create_monitor_interface(drv) < 0)
4381 res = nl80211_send_monitor(drv, data, data_len, encrypt,
4383 nl80211_remove_monitor_interface(drv);
4393 drv->send_frame_link_id = link_id;
4419 struct wpa_driver_nl80211_data *drv = bss->drv;
4440 return send_and_recv_cmd(drv, msg);
4448 struct wpa_driver_nl80211_data *drv = bss->drv;
4455 if (!(drv->capa.max_acl_mac_addrs))
4458 if (params->num_mac_acl > drv->capa.max_acl_mac_addrs)
4486 if (!(msg = nl80211_ifindex_msg_build(drv, nlmsg_alloc_size(nlmsg_sz),
4487 drv->ifindex, 0,
4499 ret = send_and_recv_cmd(drv, msg);
4537 struct wpa_driver_nl80211_data *drv = bss->drv;
4541 msg = nl80211_drv_msg(drv, 0, NL80211_CMD_SET_MESH_CONFIG);
4551 ret = send_and_recv_cmd(drv, msg);
4682 struct wpa_driver_nl80211_data *drv = bss->drv;
4697 ret = send_and_recv_cmd(drv, msg);
4755 if (!bss->drv->fils_discovery) {
4787 if (!bss->drv->unsol_bcast_probe_resp) {
4890 static void qca_set_allowed_ap_freqs(struct wpa_driver_nl80211_data *drv,
4898 if (!drv->set_wifi_conf_vendor_cmd_avail || !drv->qca_ap_allowed_freqs)
4903 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_VENDOR)) ||
4927 ret = send_and_recv_cmd(drv, msg);
5050 struct wpa_driver_nl80211_data *drv = bss->drv;
5084 else if (!drv->device_ap_sme && !drv->use_monitor &&
5105 nl80211_put_beacon_rate(msg, drv->capa.flags, drv->capa.flags2,
5183 if ((unsigned int) num_suites > drv->capa.max_num_akms)
5186 num_suites, drv->capa.max_num_akms);
5193 (drv->capa.flags2 & WPA_DRIVER_FLAGS2_4WAY_HANDSHAKE_AP_PSK) &&
5199 (drv->capa.flags2 & WPA_DRIVER_FLAGS2_SAE_OFFLOAD_AP) &&
5205 if (nl80211_put_control_port(drv, msg) < 0)
5214 if (drv->device_ap_sme) {
5230 if (nl80211_attr_supported(drv,
5277 if (drv->capa.flags & WPA_DRIVER_FLAGS_INACTIVITY_TIMER) {
5287 if (drv->p2p_go_ctwindow_supported) {
5309 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_FTM_RESPONDER)) {
5367 nl80211_attr_supported(drv, NL80211_ATTR_HE_BSS_COLOR)) {
5418 qca_set_allowed_ap_freqs(drv, params->allowed_freqs,
5426 ret = send_and_recv(drv->global, bss->nl_connect, msg, NULL, NULL, NULL,
5467 if (is_mesh_interface(drv->nlmode) && params->ht_opmode != -1) {
5487 struct wpa_driver_nl80211_data *drv = bss->drv;
5497 msg = nl80211_drv_msg(drv, 0, set_chan ? NL80211_CMD_SET_CHANNEL :
5514 ret = send_and_recv_cmd(drv, msg);
5579 struct wpa_driver_nl80211_data *drv = bss->drv;
5587 !(drv->capa.flags & WPA_DRIVER_FLAGS_TDLS_SUPPORT))
5617 (params->set && FULL_AP_CLIENT_STATE_SUPP(drv->capa.flags) &&
5683 if (is_ap_interface(drv->nlmode) &&
5717 } else if (FULL_AP_CLIENT_STATE_SUPP(drv->capa.flags) &&
5771 if (!is_mesh_interface(drv->nlmode)) {
5772 if (!FULL_AP_CLIENT_STATE_SUPP(drv->capa.flags)) {
5808 FULL_AP_CLIENT_STATE_SUPP(drv->capa.flags)) &&
5855 ret = send_and_recv_cmd(drv, msg);
5870 struct wpa_driver_nl80211_data *drv = bss->drv;
5885 nl_send_auto_complete(drv->rtnl_sk, msg) < 0)
5888 err = nl_wait_for_ack(drv->rtnl_sk);
5906 struct wpa_driver_nl80211_data *drv = bss->drv;
5924 ret = send_and_recv_cmd(drv, msg);
5929 if (drv->rtnl_sk)
5938 void nl80211_remove_iface(struct wpa_driver_nl80211_data *drv, int ifidx)
5946 dl_list_for_each(drv2, &drv->global->interfaces,
5954 msg = nl80211_ifindex_msg(drv, ifidx, 0, NL80211_CMD_DEL_INTERFACE);
5955 if (send_and_recv_cmd(drv, msg) == 0)
5994 static int nl80211_create_iface_once(struct wpa_driver_nl80211_data *drv,
6008 msg = nl80211_cmd_msg(drv->first_bss, 0, NL80211_CMD_NEW_INTERFACE);
6039 ret = send_and_recv_resp(drv, msg, handler, arg);
6063 if (drv->hostapd ||
6068 add_ifidx(drv, ifidx, IFIDX_ANY);
6072 linux_set_ifhwaddr(drv->global->ioctl_sock, ifname, addr)) {
6073 nl80211_remove_iface(drv, ifidx);
6081 int nl80211_create_iface(struct wpa_driver_nl80211_data *drv,
6089 ret = nl80211_create_iface_once(drv, ifname, iftype, addr, wds, handler,
6098 linux_set_ifhwaddr(drv->global->ioctl_sock, ifname,
6100 (linux_set_iface_flags(drv->global->ioctl_sock,
6102 linux_set_ifhwaddr(drv->global->ioctl_sock, ifname,
6104 linux_set_iface_flags(drv->global->ioctl_sock,
6112 nl80211_remove_iface(drv, if_nametoindex(ifname));
6115 ret = nl80211_create_iface_once(drv, ifname, iftype, addr,
6123 nl80211_disable_11b_rates(drv, ret, 1);
6132 struct wpa_driver_nl80211_data *drv = bss->drv;
6135 bss->ifname, drv->device_ap_sme, drv->use_monitor);
6142 if (!drv->device_ap_sme)
6145 if (!drv->device_ap_sme && !drv->use_monitor)
6149 if (drv->device_ap_sme && !drv->use_monitor)
6154 if (!drv->device_ap_sme && drv->use_monitor &&
6155 nl80211_create_monitor_interface(drv) &&
6156 !drv->device_ap_sme)
6159 if (drv->device_ap_sme &&
6172 struct wpa_driver_nl80211_data *drv = bss->drv;
6175 bss->ifname, drv->device_ap_sme, drv->use_monitor);
6176 if (drv->device_ap_sme) {
6178 if (!drv->use_monitor)
6180 } else if (drv->use_monitor)
6181 nl80211_remove_monitor_interface(drv);
6221 ret = send_and_recv(bss->drv->global, bss->drv->global->nl, msg,
6228 struct wpa_driver_nl80211_data *drv = bss->drv;
6233 drv->eapol_tx_cookie = cookie;
6234 drv->eapol_tx_link_id = link_id;
6248 if (bss->drv->eapol_tx_sock < 0) {
6259 ret = sendto(bss->drv->eapol_tx_sock, data, data_len, 0,
6277 struct wpa_driver_nl80211_data *drv = bss->drv;
6286 if (drv->control_port_ap &&
6287 (drv->capa.flags & WPA_DRIVER_FLAGS_CONTROL_PORT))
6292 if (drv->device_ap_sme || !drv->use_monitor)
6332 res = nl80211_send_monitor(drv, hdr, len, encrypt, 0);
6389 return send_and_recv_cmd(bss->drv, msg);
6412 ret = send_and_recv_cmd(bss->drv, msg);
6425 static int wpa_driver_nl80211_ap(struct wpa_driver_nl80211_data *drv,
6437 old_mode = drv->nlmode;
6438 if (wpa_driver_nl80211_set_mode(drv->first_bss, nlmode)) {
6439 nl80211_remove_monitor_interface(drv);
6444 nl80211_set_channel(drv->first_bss, ¶ms->freq, 0)) {
6446 wpa_driver_nl80211_set_mode(drv->first_bss, old_mode);
6447 nl80211_remove_monitor_interface(drv);
6455 static int nl80211_leave_ibss(struct wpa_driver_nl80211_data *drv,
6461 msg = nl80211_drv_msg(drv, 0, NL80211_CMD_LEAVE_IBSS);
6462 ret = send_and_recv(drv->global, drv->first_bss->nl_connect, msg, NULL,
6473 wpa_driver_nl80211_set_mode(drv->first_bss,
6539 static int wpa_driver_nl80211_ibss(struct wpa_driver_nl80211_data *drv,
6546 wpa_printf(MSG_DEBUG, "nl80211: Join IBSS (ifindex=%d)", drv->ifindex);
6548 if (wpa_driver_nl80211_set_mode_ibss(drv->first_bss, ¶ms->freq)) {
6555 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_JOIN_IBSS)) ||
6556 params->ssid == NULL || params->ssid_len > sizeof(drv->ssid))
6563 os_memcpy(drv->ssid, params->ssid, params->ssid_len);
6564 drv->ssid_len = params->ssid_len;
6593 if (nl80211_put_control_port(drv, msg))
6612 ret = send_and_recv(drv->global, drv->first_bss->nl_connect, msg, NULL,
6622 nl80211_leave_ibss(drv, 0);
6637 static int nl80211_put_fils_connect_params(struct wpa_driver_nl80211_data *drv,
6689 static int nl80211_connect_common(struct wpa_driver_nl80211_data *drv,
6732 os_memcpy(drv->sta_mlo_info.links[link_id].bssid,
6740 os_memcpy(drv->sta_mlo_info.ap_mld_addr,
6742 drv->sta_mlo_info.assoc_link_id = mld_params->assoc_link_id;
6743 drv->sta_mlo_info.req_links = mld_params->valid_links;
6769 drv->assoc_freq = params->freq.freq;
6771 drv->assoc_freq = 0;
6806 if (params->ssid_len > sizeof(drv->ssid))
6808 os_memcpy(drv->ssid, params->ssid, params->ssid_len);
6809 drv->ssid_len = params->ssid_len;
6827 if (nl80211_attr_supported(drv,
6849 !(drv->capa.enc & WPA_DRIVER_CAPA_ENC_GTK_NOT_USED)) {
6891 if (drv->capa.max_num_akms <=
6895 drv->capa.max_num_akms,
6900 mgmt = os_malloc(sizeof(u32) * drv->capa.max_num_akms);
6976 if (drv->capa.max_num_akms > 1) {
6979 drv->capa.max_num_akms - 1);
6995 (drv->capa.flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE_8021X)) {
7003 (drv->capa.flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE_PSK)) {
7009 if (nl80211_put_control_port(drv, msg))
7020 u32 drv_rrm_flags = drv->capa.rrm_flags;
7041 drv->connect_reassoc = 0;
7048 drv->connect_reassoc = 1;
7052 nl80211_put_fils_connect_params(drv, params, msg) != 0)
7057 (!(drv->capa.flags & WPA_DRIVER_FLAGS_SME)) &&
7061 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_SME) &&
7070 struct wpa_driver_nl80211_data *drv,
7084 ret = issue_key_mgmt_set_key(drv, params->psk, 32);
7090 wpa_printf(MSG_DEBUG, "nl80211: Connect (ifindex=%d)", drv->ifindex);
7091 msg = nl80211_drv_msg(drv, 0, NL80211_CMD_CONNECT);
7095 ret = nl80211_connect_common(drv, params, msg);
7104 (drv->capa.flags & WPA_DRIVER_FLAGS_MFP_OPTIONAL) &&
7116 (drv->capa.flags2 & WPA_DRIVER_FLAGS2_SAE_OFFLOAD_STA)) {
7168 ret = send_and_recv(drv->global, bss->nl_connect, msg, NULL, NULL, NULL,
7176 drv->roam_indication_done = false;
7191 struct wpa_driver_nl80211_data *drv,
7199 os_memcpy(drv->auth_attempt_bssid, params->bssid, ETH_ALEN);
7201 os_memset(drv->auth_attempt_bssid, 0, ETH_ALEN);
7203 ret = wpa_driver_nl80211_try_connect(drv, params, bss);
7214 drv, WLAN_REASON_PREV_AUTH_NOT_VALID, bss))
7216 ret = wpa_driver_nl80211_try_connect(drv, params, bss);
7226 struct wpa_driver_nl80211_data *drv = bss->drv;
7234 return wpa_driver_nl80211_ap(drv, params);
7237 return wpa_driver_nl80211_ibss(drv, params);
7239 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_SME)) {
7246 return wpa_driver_nl80211_connect(drv, params, bss);
7249 nl80211_mark_disconnected(drv);
7252 drv->ifindex);
7253 msg = nl80211_drv_msg(drv, 0, NL80211_CMD_ASSOCIATE);
7257 ret = nl80211_connect_common(drv, params, msg);
7284 ret = send_and_recv(drv->global, drv->first_bss->nl_connect,
7299 wpa_dbg(drv->ctx, MSG_DEBUG,
7302 nl80211_dump_scan(drv);
7328 static int nl80211_set_mode(struct wpa_driver_nl80211_data *drv,
7337 msg = nl80211_cmd_msg(drv->first_bss, 0, NL80211_CMD_SET_INTERFACE);
7341 ret = send_and_recv_cmd(drv, msg);
7358 struct wpa_driver_nl80211_data *drv = bss->drv;
7361 int was_ap = is_ap_interface(drv->nlmode);
7368 mode_switch_res = nl80211_set_mode(drv, drv->ifindex, nlmode);
7373 drv->nlmode = nlmode;
7381 if (nlmode == drv->nlmode) {
7423 if (linux_br_del_if(drv->global->ioctl_sock,
7432 mode_switch_res = nl80211_set_mode(drv, drv->ifindex, nlmode);
7446 drv->nlmode = nlmode;
7447 drv->ignore_if_down_event = 1;
7451 res = linux_set_iface_flags(drv->global->ioctl_sock, bss->ifname, 1);
7461 "from %d failed", nlmode, drv->nlmode);
7469 nl80211_disable_11b_rates(drv, drv->ifindex, 1);
7470 } else if (drv->disabled_11b_rates) {
7474 nl80211_disable_11b_rates(drv, drv->ifindex, 0);
7505 struct wpa_driver_nl80211_data *drv = bss->drv;
7506 int was_ap = is_ap_interface(drv->nlmode);
7508 wpa_driver_nl80211_set_mode(bss, drv->ap_scan_as_station);
7509 if (!was_ap && is_ap_interface(drv->ap_scan_as_station) &&
7515 if (linux_br_add_if(drv->global->ioctl_sock, bss->brname,
7522 drv->ap_scan_as_station = NL80211_IFTYPE_UNSPECIFIED;
7545 struct wpa_driver_nl80211_data *drv = bss->drv;
7547 if (!drv->has_capability)
7549 os_memcpy(capa, &drv->capa, sizeof(*capa));
7550 if (drv->extended_capa && drv->extended_capa_mask) {
7551 capa->extended_capa = drv->extended_capa;
7552 capa->extended_capa_mask = drv->extended_capa_mask;
7553 capa->extended_capa_len = drv->extended_capa_len;
7563 struct wpa_driver_nl80211_data *drv = bss->drv;
7566 bss->ifname, drv->operstate, state,
7568 drv->operstate = state;
7569 return netlink_send_oper_ifla(drv->global->netlink, drv->ifindex, -1,
7577 struct wpa_driver_nl80211_data *drv = bss->drv;
7581 const u8 *connected_addr = drv->sta_mlo_info.valid_links ?
7582 drv->sta_mlo_info.ap_mld_addr : drv->bssid;
7584 if (!drv->associated && is_zero_ether_addr(connected_addr) &&
7605 ret = send_and_recv_cmd(drv, msg);
7656 struct wpa_driver_nl80211_data *drv = bss->drv;
7660 msg = nl80211_ifindex_msg(drv, if_nametoindex(iface), 0,
7672 res = send_and_recv_resp(drv, msg, get_key_handler, seq);
7686 struct wpa_driver_nl80211_data *drv = bss->drv;
7696 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_SET_WIPHY)) ||
7702 ret = send_and_recv_cmd(drv, msg);
7714 struct wpa_driver_nl80211_data *drv = bss->drv;
7724 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_SET_WIPHY)) ||
7730 ret = send_and_recv_cmd(drv, msg);
7761 res = send_and_recv_cmd(bss->drv, msg);
8080 int nl80211_get_link_signal(struct wpa_driver_nl80211_data *drv,
8089 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_GET_STATION)) ||
8095 return send_and_recv_resp(drv, msg, get_sta_handler, data);
8111 return send_and_recv_resp(bss->drv, msg, get_sta_handler, data);
8120 struct wpa_driver_nl80211_data *drv = bss->drv;
8173 res = send_and_recv_cmd(drv, msg);
8189 struct wpa_driver_nl80211_data *drv = bss->drv;
8199 (vlan_id && (drv->capa.flags & WPA_DRIVER_FLAGS_VLAN_OFFLOAD) &&
8208 ret = send_and_recv_cmd(drv, msg);
8248 struct wpa_driver_nl80211_data *drv = bss->drv;
8260 if (is_mesh_interface(drv->nlmode))
8263 if (drv->device_ap_sme)
8284 struct wpa_driver_nl80211_data *drv = bss->drv;
8287 if (is_mesh_interface(drv->nlmode))
8290 if (drv->device_ap_sme)
8307 static void dump_ifidx(struct wpa_driver_nl80211_data *drv)
8315 for (i = 0; i < drv->num_if_indices; i++) {
8316 if (!drv->if_indices[i].ifindex)
8319 drv->if_indices[i].ifindex,
8320 drv->if_indices[i].reason);
8328 drv->num_if_indices, buf);
8332 static void add_ifidx(struct wpa_driver_nl80211_data *drv, int ifidx,
8341 if (have_ifidx(drv, ifidx, ifidx_reason)) {
8346 for (i = 0; i < drv->num_if_indices; i++) {
8347 if (drv->if_indices[i].ifindex == 0) {
8348 drv->if_indices[i].ifindex = ifidx;
8349 drv->if_indices[i].reason = ifidx_reason;
8350 dump_ifidx(drv);
8355 if (drv->if_indices != drv->default_if_indices)
8356 old = drv->if_indices;
8360 drv->if_indices = os_realloc_array(old, drv->num_if_indices + 1,
8362 if (!drv->if_indices) {
8364 drv->if_indices = drv->default_if_indices;
8366 drv->if_indices = old;
8373 os_memcpy(drv->if_indices, drv->default_if_indices,
8374 sizeof(drv->default_if_indices));
8375 drv->if_indices[drv->num_if_indices].ifindex = ifidx;
8376 drv->if_indices[drv->num_if_indices].reason = ifidx_reason;
8377 drv->num_if_indices++;
8378 dump_ifidx(drv);
8382 static void del_ifidx(struct wpa_driver_nl80211_data *drv, int ifidx,
8387 for (i = 0; i < drv->num_if_indices; i++) {
8388 if ((drv->if_indices[i].ifindex == ifidx ||
8390 (drv->if_indices[i].reason == ifidx_reason ||
8392 drv->if_indices[i].ifindex = 0;
8393 drv->if_indices[i].reason = 0;
8397 dump_ifidx(drv);
8401 static int have_ifidx(struct wpa_driver_nl80211_data *drv, int ifidx,
8406 for (i = 0; i < drv->num_if_indices; i++)
8407 if (drv->if_indices[i].ifindex == ifidx &&
8408 (drv->if_indices[i].reason == ifidx_reason ||
8420 struct wpa_driver_nl80211_data *drv = bss->drv;
8439 if (nl80211_create_iface(drv, name,
8445 linux_br_add_if(drv->global->ioctl_sock,
8457 if (linux_set_iface_flags(drv->global->ioctl_sock, name, 1)) {
8465 linux_br_del_if(drv->global->ioctl_sock, bridge_ifname,
8473 nl80211_remove_iface(drv, if_nametoindex(name));
8487 struct wpa_driver_nl80211_data *drv = eloop_ctx;
8501 if (have_ifidx(drv, lladdr.sll_ifindex, IFIDX_ANY))
8502 drv_event_eapol_rx(drv->ctx, lladdr.sll_addr, buf, len);
8506 static int i802_check_bridge(struct wpa_driver_nl80211_data *drv,
8520 if (linux_br_add(drv->global->ioctl_sock, brname) < 0) {
8528 add_ifidx(drv, br_ifindex, drv->ifindex);
8540 if (linux_br_del_if(drv->global->ioctl_sock, in_br, ifname) <
8552 if (linux_br_add_if(drv->global->ioctl_sock, brname, ifname) < 0) {
8571 struct wpa_driver_nl80211_data *drv;
8584 drv = bss->drv;
8596 add_ifidx(drv, if_nametoindex(master_ifname), drv->ifindex);
8615 add_ifidx(drv, ifindex, drv->ifindex);
8622 add_ifidx(drv, drv->ifindex, IFIDX_ANY);
8625 if (i802_check_bridge(drv, bss, params->bridge[0],
8634 add_ifidx(drv, br_ifindex, drv->ifindex);
8639 drv->rtnl_sk = nl_socket_alloc();
8640 if (drv->rtnl_sk == NULL) {
8645 err = nl_connect(drv->rtnl_sk, NETLINK_ROUTE);
8653 if (drv->capa.flags2 & WPA_DRIVER_FLAGS2_CONTROL_PORT_RX) {
8659 drv->eapol_sock = socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_PAE));
8660 if (drv->eapol_sock < 0) {
8666 if (eloop_register_read_sock(drv->eapol_sock, handle_eapol, drv, NULL))
8673 if (linux_get_ifhwaddr(drv->global->ioctl_sock, bss->ifname,
8676 os_memcpy(drv->perm_addr, params->own_addr, ETH_ALEN);
8722 struct wpa_driver_nl80211_data *drv;
8723 dl_list_for_each(drv, &global->interfaces,
8725 if (ether_addr_equal(addr, drv->first_bss->addr))
8732 static int nl80211_vif_addr(struct wpa_driver_nl80211_data *drv, u8 *new_addr)
8736 if (!drv->global)
8739 os_memcpy(new_addr, drv->first_bss->addr, ETH_ALEN);
8741 new_addr[0] = drv->first_bss->addr[0] | 0x02;
8743 if (!nl80211_addr_in_use(drv->global, new_addr))
8792 struct wpa_driver_nl80211_data *drv = bss->drv;
8803 ifidx = nl80211_create_iface(drv, ifname, nlmode, addr,
8812 drv->global->if_add_wdevid = p2pdev_info.wdev_id;
8813 drv->global->if_add_wdevid_set = p2pdev_info.wdev_id_set;
8820 ifidx = nl80211_create_iface(drv, ifname, nlmode, addr,
8833 else if (linux_get_ifhwaddr(drv->global->ioctl_sock,
8836 nl80211_remove_iface(drv, ifidx);
8848 if (linux_get_ifhwaddr(drv->global->ioctl_sock, ifname,
8851 nl80211_remove_iface(drv, ifidx);
8854 if (nl80211_addr_in_use(drv->global, new_addr)) {
8857 if (nl80211_vif_addr(drv, new_addr) < 0) {
8859 nl80211_remove_iface(drv, ifidx);
8862 if (linux_set_ifhwaddr(drv->global->ioctl_sock, ifname,
8865 nl80211_remove_iface(drv, ifidx);
8877 nl80211_remove_iface(drv, ifidx);
8882 i802_check_bridge(drv, new_bss, bridge, ifname) < 0) {
8887 nl80211_remove_iface(drv, ifidx);
8892 if (linux_set_iface_flags(drv->global->ioctl_sock, ifname, 1))
8895 nl80211_remove_iface(drv, ifidx);
8902 new_bss->drv = drv;
8903 new_bss->next = drv->first_bss->next;
8908 new_bss->flink->freq = drv->first_bss->flink->freq;
8911 drv->first_bss->next = new_bss;
8921 if (drv->global)
8922 drv->global->if_add_ifindex = ifidx;
8929 (drv->hostapd ||
8933 add_ifidx(drv, ifidx, IFIDX_ANY);
8943 struct wpa_driver_nl80211_data *drv = bss->drv;
8949 nl80211_remove_iface(drv, ifindex);
8952 dl_list_for_each(drv2, &drv->global->interfaces,
8963 if (linux_br_del_if(drv->global->ioctl_sock, bss->brname,
8970 if (linux_br_del(drv->global->ioctl_sock, bss->brname) < 0)
8976 if (bss != drv->first_bss) {
8980 for (tbss = drv->first_bss; tbss; tbss = tbss->next) {
9001 if (!bss->added_if && !drv->first_bss->next)
9006 if (drv->first_bss->next) {
9007 drv->first_bss = drv->first_bss->next;
9008 drv->ctx = drv->first_bss->ctx;
9009 drv->ifindex = drv->first_bss->ifindex;
9040 struct wpa_driver_nl80211_data *drv = bss->drv;
9055 (offchanok && ((drv->capa.flags & WPA_DRIVER_FLAGS_OFFCHANNEL_TX) ||
9056 drv->test_use_roc_tx) &&
9066 ret = send_and_recv_resp(drv, msg, cookie_handler, &cookie);
9078 drv->send_frame_cookie = no_ack ? (u64) -1 : cookie;
9085 if (drv->num_send_frame_cookies == MAX_SEND_FRAME_COOKIES) {
9089 drv->send_frame_cookies[0]);
9090 os_memmove(&drv->send_frame_cookies[0],
9091 &drv->send_frame_cookies[1],
9094 drv->num_send_frame_cookies--;
9096 drv->send_frame_cookies[drv->num_send_frame_cookies] = cookie;
9097 drv->num_send_frame_cookies++;
9114 struct wpa_driver_nl80211_data *drv = bss->drv;
9120 if (is_ap_interface(drv->nlmode) && (int) freq == bss->flink->freq &&
9124 if (!freq && is_sta_interface(drv->nlmode))
9130 drv->ifindex, freq, wait_time, no_cck, offchanok,
9153 if (is_mesh_interface(drv->nlmode)) {
9174 if (is_ap_interface(drv->nlmode) &&
9175 (!(drv->capa.flags & WPA_DRIVER_FLAGS_OFFCHANNEL_TX) ||
9176 (int) freq == bss->flink->freq || drv->device_ap_sme ||
9177 !drv->use_monitor))
9194 struct wpa_driver_nl80211_data *drv = bss->drv;
9206 ret = send_and_recv_cmd(drv, msg);
9216 struct wpa_driver_nl80211_data *drv = bss->drv;
9221 if (drv->send_frame_cookie != (u64) -1)
9222 nl80211_frame_wait_cancel(bss, drv->send_frame_cookie);
9229 for (i = drv->num_send_frame_cookies; i > 0; i--) {
9230 cookie = drv->send_frame_cookies[i - 1];
9231 if (cookie != drv->send_frame_cookie)
9234 drv->num_send_frame_cookies = 0;
9279 struct wpa_driver_nl80211_data *drv = bss->drv;
9287 nl80211_put_any_link_id(msg, &drv->sta_mlo_info, freq)) {
9293 ret = send_and_recv_resp(drv, msg, cookie_handler, &cookie);
9298 drv->remain_on_chan_cookie = cookie;
9299 drv->pending_remain_on_chan = 1;
9312 struct wpa_driver_nl80211_data *drv = bss->drv;
9316 if (!drv->pending_remain_on_chan) {
9324 (long long unsigned int) drv->remain_on_chan_cookie);
9328 nla_put_u64(msg, NL80211_ATTR_COOKIE, drv->remain_on_chan_cookie)) {
9333 ret = send_and_recv_cmd(drv, msg);
9344 struct wpa_driver_nl80211_data *drv = bss->drv;
9347 if (bss->nl_preq && drv->device_ap_sme &&
9348 is_ap_interface(drv->nlmode) && !bss->in_deinit &&
9371 bss->nl_preq = nl_create_handle(drv->global->nl_cb, "preq");
9395 static int nl80211_disable_11b_rates(struct wpa_driver_nl80211_data *drv,
9407 msg = nl80211_ifindex_msg(drv, ifindex, 0,
9430 ret = send_and_recv_cmd(drv, msg);
9435 drv->disabled_11b_rates = disabled;
9447 struct wpa_driver_nl80211_data *drv = bss->drv;
9497 ret = send_and_recv_cmd(drv, msg);
9526 struct wpa_driver_nl80211_data *drv = bss->drv;
9528 if (!is_ap_interface(drv->nlmode))
9540 if (drv->nlmode == NL80211_IFTYPE_P2P_GO && bss->if_dynamic)
9550 struct wpa_driver_nl80211_data *drv = bss->drv;
9552 if (!is_ap_interface(drv->nlmode))
9572 struct wpa_driver_nl80211_data *drv = bss->drv;
9573 if (drv->nlmode != NL80211_IFTYPE_P2P_CLIENT)
9596 nl80211_disable_11b_rates(bss->drv, bss->drv->ifindex, 1);
9603 struct wpa_driver_nl80211_data *drv = bss->drv;
9619 return send_and_recv_cmd(drv, msg);
9651 static int nl80211_get_channel_width(struct wpa_driver_nl80211_data *drv,
9656 msg = nl80211_drv_msg(drv, 0, NL80211_CMD_GET_INTERFACE);
9657 return send_and_recv_resp(drv, msg, get_channel_width, sig);
9664 struct wpa_driver_nl80211_data *drv = bss->drv;
9668 res = nl80211_get_link_signal(drv, drv->bssid, &si->data);
9670 if (drv->nlmode != NL80211_IFTYPE_ADHOC &&
9671 drv->nlmode != NL80211_IFTYPE_MESH_POINT)
9676 res = nl80211_get_channel_width(drv, si);
9680 return nl80211_get_link_noise(drv, si);
9732 static int nl80211_get_links_noise(struct wpa_driver_nl80211_data *drv,
9737 msg = nl80211_drv_msg(drv, NLM_F_DUMP, NL80211_CMD_GET_SURVEY);
9738 return send_and_recv_resp(drv, msg, get_links_noise, mlo_sig);
9786 static int nl80211_get_links_channel_width(struct wpa_driver_nl80211_data *drv,
9791 msg = nl80211_drv_msg(drv, 0, NL80211_CMD_GET_INTERFACE);
9792 return send_and_recv_resp(drv, msg, get_links_channel_width, mlo_sig);
9800 struct wpa_driver_nl80211_data *drv = bss->drv;
9804 if (drv->nlmode != NL80211_IFTYPE_STATION ||
9805 !drv->sta_mlo_info.valid_links)
9809 mlo_si->valid_links = drv->sta_mlo_info.valid_links;
9812 res = nl80211_get_link_signal(drv,
9813 drv->sta_mlo_info.links[i].bssid,
9822 mlo_si->links[i].frequency = drv->sta_mlo_info.links[i].freq;
9825 res = nl80211_get_links_channel_width(drv, mlo_si);
9829 return nl80211_get_links_noise(drv, mlo_si);
9836 struct wpa_driver_nl80211_data *drv = bss->drv;
9846 drv->capa.flags |= WPA_DRIVER_FLAGS_P2P_CONCURRENT;
9847 drv->capa.flags |= WPA_DRIVER_FLAGS_P2P_MGMT_AND_NON_P2P;
9852 drv->use_monitor = 1;
9855 drv->capa.flags &= ~WPA_DRIVER_FLAGS_SME;
9856 drv->force_connect_cmd = 1;
9860 drv->capa.flags |= WPA_DRIVER_FLAGS_BSS_SELECTION;
9863 drv->capa.flags &= ~WPA_DRIVER_FLAGS_OFFCHANNEL_TX;
9864 drv->test_use_roc_tx = 1;
9868 drv->capa.flags &= ~WPA_DRIVER_FLAGS_CONTROL_PORT;
9869 drv->capa.flags2 &= ~(WPA_DRIVER_FLAGS2_CONTROL_PORT_RX |
9871 drv->control_port_ap = 0;
9875 drv->control_port_ap = 1;
9878 drv->capa.flags2 &= ~WPA_DRIVER_FLAGS2_CONTROL_PORT_TX_STATUS;
9879 drv->control_port_ap = 0;
9883 drv->capa.flags &= ~WPA_DRIVER_FLAGS_FULL_AP_CLIENT_STATE;
9886 drv->no_rrm = 1;
9888 if (!bss->in_deinit && !is_ap_interface(drv->nlmode) &&
9889 !is_mesh_interface(drv->nlmode)) {
9898 drv->capa.flags2 |= WPA_DRIVER_FLAGS2_SEC_LTF_STA |
9988 struct wpa_driver_nl80211_data *drv = bss->drv;
9989 return drv->phyname;
10027 return send_and_recv_cmd(bss->drv, msg);
10103 return send_and_recv_cmd(bss->drv, msg);
10247 struct wpa_driver_nl80211_data *drv = bss->drv;
10258 msg = nl80211_drv_msg(drv, NLM_F_DUMP, NL80211_CMD_GET_SURVEY);
10267 err = send_and_recv_resp(drv, msg, survey_handler,
10274 wpa_supplicant_event(drv->ctx, EVENT_SURVEY, &data);
10286 struct wpa_driver_nl80211_data *drv = bss->drv;
10291 if (!drv->set_rekey_offload)
10308 ret = send_and_recv_cmd(drv, msg);
10312 drv->set_rekey_offload = 0;
10359 struct wpa_driver_nl80211_data *drv = bss->drv;
10364 if (!drv->poll_command_supported) {
10375 ret = send_and_recv_resp(drv, msg, cookie_handler, &cookie);
10401 ret = send_and_recv_cmd(bss->drv, msg);
10441 struct wpa_driver_nl80211_data *drv = bss->drv;
10449 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_RADAR)) {
10455 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_RADAR_DETECT)) ||
10461 ret = send_and_recv_cmd(drv, msg);
10494 nl80211_tdls_set_discovery_resp_link(struct wpa_driver_nl80211_data *drv,
10504 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_VENDOR)) ||
10505 nla_put_u32(msg, NL80211_ATTR_IFINDEX, drv->ifindex) ||
10520 return send_and_recv_cmd(drv, msg);
10535 struct wpa_driver_nl80211_data *drv = bss->drv;
10538 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_TDLS_SUPPORT))
10545 nl80211_tdls_set_discovery_resp_link(drv, link_id) < 0)
10548 if (link_id < 0 && drv->sta_mlo_info.valid_links)
10549 link_id = drv->sta_mlo_info.assoc_link_id;
10551 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_TDLS_MGMT)) ||
10563 return send_and_recv_cmd(drv, msg);
10574 struct wpa_driver_nl80211_data *drv = bss->drv;
10579 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_TDLS_SUPPORT))
10606 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_TDLS_OPER)) ||
10613 res = send_and_recv_cmd(drv, msg);
10626 struct wpa_driver_nl80211_data *drv = bss->drv;
10630 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_TDLS_SUPPORT) ||
10631 !(drv->capa.flags & WPA_DRIVER_FLAGS_TDLS_CHANNEL_SWITCH))
10647 return send_and_recv_cmd(drv, msg);
10655 struct wpa_driver_nl80211_data *drv = bss->drv;
10658 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_TDLS_SUPPORT) ||
10659 !(drv->capa.flags & WPA_DRIVER_FLAGS_TDLS_CHANNEL_SWITCH))
10673 return send_and_recv_cmd(drv, msg);
10693 struct wpa_driver_nl80211_data *drv = bss->drv;
10702 if (drv->scan_vendor_cmd_avail && !params->only_new_results)
10746 struct wpa_driver_nl80211_data *drv = bss->drv;
10760 if (drv->first_bss == bss && bss->valid_links)
10761 drv->ctx = bss->ctx;
10776 struct wpa_driver_nl80211_data *drv = bss->drv;
10783 for (bss = drv->first_bss; bss; bss = bss->next) {
10874 struct wpa_driver_nl80211_data *drv = bss->drv;
10878 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_UPDATE_FT_IES)) ||
10885 ret = send_and_recv_cmd(drv, msg);
10901 struct wpa_driver_nl80211_data *drv = bss->drv;
10913 ret = send_and_recv_cmd(drv, msg);
10927 struct wpa_driver_nl80211_data *drv = bss->drv;
10929 if (drv->nlmode != NL80211_IFTYPE_P2P_DEVICE)
10964 struct wpa_driver_nl80211_data *drv = bss->drv;
11022 drv->phyname,
11023 MAC2STR(drv->perm_addr),
11024 drv->ifindex,
11025 drv->operstate,
11026 scan_state_str(drv->scan_state),
11027 MAC2STR(drv->auth_bssid),
11028 MAC2STR(drv->auth_attempt_bssid),
11029 MAC2STR(drv->bssid),
11030 MAC2STR(drv->prev_bssid),
11031 drv->associated,
11032 drv->assoc_freq,
11033 drv->monitor_sock,
11034 drv->monitor_ifidx,
11035 drv->monitor_refcount,
11036 drv->last_mgmt_freq,
11037 drv->eapol_tx_sock,
11038 drv->ignore_if_down_event ?
11040 drv->scan_complete_events ?
11042 drv->disabled_11b_rates ?
11044 drv->pending_remain_on_chan ?
11046 drv->in_interface_list ? "in_interface_list=1\n" : "",
11047 drv->device_ap_sme ? "device_ap_sme=1\n" : "",
11048 drv->poll_command_supported ?
11050 drv->data_tx_status ? "data_tx_status=1\n" : "",
11051 drv->scan_for_auth ? "scan_for_auth=1\n" : "",
11052 drv->retry_auth ? "retry_auth=1\n" : "",
11053 drv->use_monitor ? "use_monitor=1\n" : "",
11054 drv->ignore_next_local_disconnect ?
11056 drv->ignore_next_local_deauth ?
11062 if (drv->sta_mlo_info.valid_links) {
11064 struct driver_sta_mlo_info *mlo = &drv->sta_mlo_info;
11101 if (drv->has_capability) {
11128 drv->capa.key_mgmt,
11129 drv->capa.enc,
11130 drv->capa.auth,
11131 (unsigned long long) drv->capa.flags,
11132 (unsigned long long) drv->capa.flags2,
11133 drv->capa.rrm_flags,
11134 drv->capa.max_scan_ssids,
11135 drv->capa.max_sched_scan_ssids,
11136 drv->capa.sched_scan_supported,
11137 drv->capa.max_match_sets,
11138 drv->capa.max_remain_on_chan,
11139 drv->capa.max_stations,
11140 drv->capa.probe_resp_offloads,
11141 drv->capa.max_acl_mac_addrs,
11142 drv->capa.num_multichan_concurrent,
11143 drv->capa.mac_addr_rand_sched_scan_supported,
11144 drv->capa.mac_addr_rand_scan_supported,
11145 drv->capa.conc_capab,
11146 drv->capa.max_conc_chan_2_4,
11147 drv->capa.max_conc_chan_5_0,
11148 drv->capa.max_sched_scan_plans,
11149 drv->capa.max_sched_scan_plan_interval,
11150 drv->capa.max_sched_scan_plan_iterations,
11151 drv->capa.mbssid_max_interfaces,
11152 drv->capa.ema_max_periodicity);
11160 nl80211_cmd(drv, msg, 0, NL80211_CMD_GET_REG) &&
11161 nla_put_u32(msg, NL80211_ATTR_WIPHY, drv->wiphy_idx) == 0) {
11162 if (send_and_recv_resp(drv, msg, nl80211_get_country,
11209 struct wpa_driver_nl80211_data *drv = bss->drv;
11230 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_AP_CSA)) {
11235 if (drv->nlmode != NL80211_IFTYPE_AP &&
11236 drv->nlmode != NL80211_IFTYPE_P2P_GO &&
11237 drv->nlmode != NL80211_IFTYPE_MESH_POINT)
11264 if (drv->capa.max_csa_counters &&
11265 csa_off_len > drv->capa.max_csa_counters) {
11335 ret = send_and_recv_cmd(drv, msg);
11355 struct wpa_driver_nl80211_data *drv = bss->drv;
11364 if (drv->nlmode != NL80211_IFTYPE_AP)
11437 ret = send_and_recv_cmd(drv, msg);
11457 struct wpa_driver_nl80211_data *drv = bss->drv;
11465 if (!is_sta_interface(drv->nlmode))
11478 ret = send_and_recv_cmd(drv, msg);
11489 struct wpa_driver_nl80211_data *drv = bss->drv;
11495 if (!is_sta_interface(drv->nlmode))
11505 ret = send_and_recv_cmd(drv, msg);
11592 struct wpa_driver_nl80211_data *drv = bss->drv;
11602 nl80211_cmd(drv, msg, 0, subcmd);
11609 ret = send_and_recv(drv->global, bss->nl_connect, msg,
11634 ret = send_and_recv_resp(drv, msg, vendor_reply_handler, buf);
11650 struct wpa_driver_nl80211_data *drv = bss->drv;
11663 ret = send_and_recv_cmd(drv, msg);
11689 struct wpa_driver_nl80211_data *drv = bss->drv;
11696 msg = nl80211_drv_msg(drv, 0, NL80211_CMD_GET_WOWLAN);
11698 ret = send_and_recv_resp(drv, msg, get_wowlan_handler, &wowlan_enabled);
11715 struct wpa_driver_nl80211_data *drv = bss->drv;
11745 ret = send_and_recv_cmd(drv, msg);
11757 struct wpa_driver_nl80211_data *drv = bss->drv;
11763 if (!drv->roaming_vendor_cmd_avail) {
11769 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_VENDOR)) ||
11784 return send_and_recv_cmd(drv, msg);
11791 struct wpa_driver_nl80211_data *drv = bss->drv;
11797 if (!drv->set_wifi_conf_vendor_cmd_avail)
11800 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_VENDOR)) ||
11812 return send_and_recv_cmd(drv, msg);
11823 struct wpa_driver_nl80211_data *drv = bss->drv;
11832 if (!drv->roam_vendor_cmd_avail)
11835 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_VENDOR)) ||
11869 return send_and_recv_cmd(drv, msg);
11880 struct wpa_driver_nl80211_data *drv = bss->drv;
11884 if (!drv->add_sta_node_vendor_cmd_avail)
11889 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_VENDOR)) ||
11907 return send_and_recv_cmd(drv, msg);
11916 struct wpa_driver_nl80211_data *drv = bss->drv;
11923 addr = drv->perm_addr;
11925 if (linux_set_iface_flags(drv->global->ioctl_sock, bss->ifname, 0) < 0)
11928 if (linux_set_ifhwaddr(drv->global->ioctl_sock, bss->ifname, addr) < 0)
11933 if (linux_set_iface_flags(drv->global->ioctl_sock, bss->ifname,
11943 drv->addr_changed = new_addr;
11947 if (linux_set_iface_flags(drv->global->ioctl_sock, bss->ifname, 1) < 0)
12032 struct wpa_driver_nl80211_data *drv = bss->drv;
12037 wpa_printf(MSG_DEBUG, "nl80211: mesh join (ifindex=%d)", drv->ifindex);
12038 msg = nl80211_drv_msg(drv, 0, NL80211_CMD_JOIN_MESH);
12084 ret = send_and_recv(drv->global, bss->nl_connect, msg, NULL, NULL, NULL,
12093 drv->assoc_freq = bss->flink->freq = params->freq.freq;
12136 struct wpa_driver_nl80211_data *drv = bss->drv;
12140 wpa_printf(MSG_DEBUG, "nl80211: mesh leave (ifindex=%d)", drv->ifindex);
12141 msg = nl80211_drv_msg(drv, 0, NL80211_CMD_LEAVE_MESH);
12142 ret = send_and_recv(drv->global, bss->nl_connect, msg, NULL, NULL, NULL,
12150 drv->first_bss->flink->freq = 0;
12153 if (drv->start_mode_sta &&
12154 wpa_driver_nl80211_set_mode(drv->first_bss,
12167 struct wpa_driver_nl80211_data *drv = bss->drv;
12171 msg = nl80211_drv_msg(drv, 0, NL80211_CMD_PROBE_MESH_LINK);
12179 ret = send_and_recv_cmd(drv, msg);
12200 struct wpa_driver_nl80211_data *drv = bss->drv;
12218 if (!drv->rtnl_sk) {
12244 res = nl_send_auto_complete(drv->rtnl_sk, msg);
12248 res = nl_wait_for_ack(drv->rtnl_sk);
12264 struct wpa_driver_nl80211_data *drv = bss->drv;
12292 if (!drv->rtnl_sk) {
12307 res = nl_send_auto_complete(drv->rtnl_sk, msg);
12311 res = nl_wait_for_ack(drv->rtnl_sk);
12518 static int nl80211_qca_do_acs(struct wpa_driver_nl80211_data *drv,
12530 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_VENDOR)) ||
12564 ret = send_and_recv_cmd(drv, msg);
12577 struct wpa_driver_nl80211_data *drv = bss->drv;
12584 if (!drv->setband_vendor_cmd_avail ||
12608 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_VENDOR)) ||
12622 ret = send_and_recv_cmd(drv, msg);
12768 struct wpa_driver_nl80211_data *drv = bss->drv;
12776 if (!drv->get_pref_freq_list)
12805 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_VENDOR)) ||
12806 nla_put_u32(msg, NL80211_ATTR_IFINDEX, drv->ifindex) ||
12824 ret = send_and_recv_resp(drv, msg, preferred_freq_info_handler, ¶m);
12847 struct wpa_driver_nl80211_data *drv = bss->drv;
12852 if (!drv->set_prob_oper_freq)
12859 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_VENDOR)) ||
12878 ret = send_and_recv_cmd(drv, msg);
12897 struct wpa_driver_nl80211_data *drv = bss->drv;
12906 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_P2P_LISTEN_OFFLOAD))
12909 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_VENDOR)) ||
12934 ret = send_and_recv_cmd(drv, msg);
12953 struct wpa_driver_nl80211_data *drv = bss->drv;
12958 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_P2P_LISTEN_OFFLOAD))
12961 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_VENDOR)) ||
12969 return send_and_recv_cmd(drv, msg);
12976 struct wpa_driver_nl80211_data *drv = bss->drv;
12992 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_VENDOR)) ||
13008 ret = send_and_recv_cmd(drv, msg);
13132 struct wpa_driver_nl80211_data *drv = bss->drv;
13140 if (!drv->fetch_bss_trans_status)
13162 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_VENDOR)) ||
13199 ret = send_and_recv_resp(drv, msg,
13228 struct wpa_driver_nl80211_data *drv = bss->drv;
13233 if (!drv->set_wifi_conf_vendor_cmd_avail)
13236 if (!(msg = nl80211_drv_msg(drv, 0, NL80211_CMD_VENDOR)) ||
13254 ret = send_and_recv_cmd(drv, msg);
13279 struct wpa_driver_nl80211_data *drv = bss->drv;
13281 wpa_dbg(drv->ctx, MSG_DEBUG,
13284 msg = nl80211_drv_msg(drv, 0, NL80211_CMD_VENDOR);
13325 return send_and_recv_cmd(drv, msg);
13353 struct wpa_driver_nl80211_data *drv = bss->drv;
13357 if (!drv->secure_ranging_ctx_vendor_cmd_avail)
13363 wpa_dbg(drv->ctx, MSG_DEBUG,
13367 msg = nl80211_drv_msg(drv, 0, NL80211_CMD_VENDOR);
13421 ret = send_and_recv_cmd(drv, msg);
13438 static int wpa_driver_do_broadcom_acs(struct wpa_driver_nl80211_data *drv,
13450 msg = nl80211_drv_msg(drv, 0, NL80211_CMD_VENDOR);
13475 ret = send_and_recv_cmd(drv, msg);
13494 struct wpa_driver_nl80211_data *drv = bss->drv;
13498 if (drv->qca_do_acs)
13499 return nl80211_qca_do_acs(drv, params);
13503 if (drv->brcm_do_acs)
13504 return wpa_driver_do_broadcom_acs(drv, params);
13626 struct wpa_driver_nl80211_data *drv = bss->drv;
13636 *ext_capa = drv->extended_capa;
13637 *ext_capa_mask = drv->extended_capa_mask;
13638 *ext_capa_len = drv->extended_capa_len;
13641 for (i = 0; i < drv->num_iface_capa; i++) {
13642 if (nlmode == drv->iface_capa[i].iftype) {
13643 *ext_capa = drv->iface_capa[i].ext_capa;
13644 *ext_capa_mask = drv->iface_capa[i].ext_capa_mask;
13645 *ext_capa_len = drv->iface_capa[i].ext_capa_len;
13658 struct wpa_driver_nl80211_data *drv = bss->drv;
13672 for (i = 0; i < drv->num_iface_capa; i++) {
13673 if (nlmode == drv->iface_capa[i].iftype) {
13674 *eml_capa = drv->iface_capa[i].eml_capa;
13676 drv->iface_capa[i].mld_capa_and_ops;
13690 struct wpa_driver_nl80211_data *drv = bss->drv;
13700 if (drv->capa.flags & WPA_DRIVER_FLAGS_SME)
13703 msg = nl80211_drv_msg(drv, 0, NL80211_CMD_UPDATE_CONNECT_PARAMS);
13708 drv->ifindex);
13727 nl80211_put_fils_connect_params(drv, params, msg))
13730 ret = send_and_recv_cmd(drv, msg);
13733 wpa_dbg(drv->ctx, MSG_DEBUG,
13747 struct wpa_driver_nl80211_data *drv = bss->drv;
13756 if ((is_ap_interface(drv->nlmode) && !bss->drv->device_ap_sme) ||
13757 (drv->capa.flags & WPA_DRIVER_FLAGS_SME))
13760 wpa_dbg(drv->ctx, MSG_DEBUG,
13763 msg = nl80211_drv_msg(drv, 0, NL80211_CMD_EXTERNAL_AUTH);
13773 ret = send_and_recv_cmd(drv, msg);
13791 struct wpa_driver_nl80211_data *drv = bss->drv;
13798 msg = nl80211_cmd_msg(drv->first_bss, 0, NL80211_CMD_SET_INTERFACE);
13803 if (linux_br_del_if(drv->global->ioctl_sock,
13813 ret = send_and_recv_cmd(drv, msg);
13822 i802_check_bridge(drv, bss, bridge_ifname, bss->ifname) < 0)
13839 struct wpa_driver_nl80211_data *drv = bss->drv;
13843 if (!drv->multicast_registrations || !bss->nl_mgmt)
13861 struct wpa_driver_nl80211_data *drv = bss->drv;
13868 if (drv->nlmode != NL80211_IFTYPE_AP) {
13871 drv->nlmode);
13903 ret = send_and_recv_cmd(drv, msg);
13930 struct wpa_driver_nl80211_data *drv = bss->drv;
13944 ret = send_and_recv_cmd(drv, msg);
13975 struct wpa_driver_nl80211_data *drv = bss->drv;
13985 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_SME))
13988 if (!drv->associated)
13991 return wpa_driver_nl80211_mlme(drv, drv->bssid,
13994 drv->first_bss);