Lines Matching defs:drv
185 struct wpa_driver_nl80211_data *drv;
304 wpa_driver_nl80211_finish_drv_init(struct wpa_driver_nl80211_data *drv);
305 static int wpa_driver_nl80211_mlme(struct wpa_driver_nl80211_data *drv,
309 struct wpa_driver_nl80211_data *drv);
334 static void add_ifidx(struct wpa_driver_nl80211_data *drv, int ifidx);
335 static void del_ifidx(struct wpa_driver_nl80211_data *drv, int ifidx);
336 static int have_ifidx(struct wpa_driver_nl80211_data *drv, int ifidx);
341 static inline void add_ifidx(struct wpa_driver_nl80211_data *drv, int ifidx)
345 static inline void del_ifidx(struct wpa_driver_nl80211_data *drv, int ifidx)
349 static inline int have_ifidx(struct wpa_driver_nl80211_data *drv, int ifidx)
361 static int nl80211_disable_11b_rates(struct wpa_driver_nl80211_data *drv,
364 static int nl80211_leave_ibss(struct wpa_driver_nl80211_data *drv);
366 struct wpa_driver_nl80211_data *drv);
503 static void nl80211_mark_disconnected(struct wpa_driver_nl80211_data *drv)
505 if (drv->associated)
506 os_memcpy(drv->prev_bssid, drv->bssid, ETH_ALEN);
507 drv->associated = 0;
508 os_memset(drv->bssid, 0, ETH_ALEN);
513 struct wpa_driver_nl80211_data *drv;
600 int send_and_recv_msgs(struct wpa_driver_nl80211_data *drv,
605 return send_and_recv(drv->global, drv->global->nl, msg,
685 static void * nl80211_cmd(struct wpa_driver_nl80211_data *drv,
688 return genlmsg_put(msg, 0, 0, drv->global->nl80211_id,
735 nl80211_cmd(bss->drv, msg, 0, NL80211_CMD_GET_INTERFACE);
740 if (send_and_recv_msgs(bss->drv, msg, netdev_info_handler, &data) == 0)
761 nl80211_cmd(bss->drv, msg, 0, NL80211_CMD_GET_INTERFACE);
766 if (send_and_recv_msgs(bss->drv, msg, netdev_info_handler, &data) == 0)
787 nl80211_cmd(bss->drv, msg, 0, NL80211_CMD_GET_INTERFACE);
791 return send_and_recv_msgs(bss->drv, msg, netdev_info_handler, &data);
800 static int nl80211_register_beacons(struct wpa_driver_nl80211_data *drv,
810 nl80211_cmd(drv, msg, 0, NL80211_CMD_REGISTER_BEACONS);
814 ret = send_and_recv(drv->global, w->nl_beacons, msg, NULL, NULL);
842 struct wpa_driver_nl80211_data *drv;
859 dl_list_for_each(drv, &w->drvs, struct wpa_driver_nl80211_data,
864 wpa_supplicant_event(drv->ctx, EVENT_RX_MGMT, &event);
906 w->nl_beacons = nl_create_handle(bss->drv->global->nl_cb,
913 if (nl80211_register_beacons(bss->drv, w)) {
925 /* drv entry for this bss already there? */
927 if (tmp_bss->drv == bss->drv) {
934 dl_list_add(&w->drvs, &bss->drv->wiphy_list);
953 /* still any for this drv present? */
955 if (tmp_bss->drv == bss->drv) {
962 dl_list_del(&bss->drv->wiphy_list);
979 struct wpa_driver_nl80211_data *drv = bss->drv;
980 if (!drv->associated)
982 os_memcpy(bssid, drv->bssid, ETH_ALEN);
990 struct wpa_driver_nl80211_data *drv = bss->drv;
991 if (!drv->associated)
993 os_memcpy(ssid, drv->ssid, drv->ssid_len);
994 return drv->ssid_len;
998 static void wpa_driver_nl80211_event_link(struct wpa_driver_nl80211_data *drv,
1015 if (os_strcmp(drv->first_bss.ifname, event.interface_status.ifname) == 0) {
1017 if (drv->if_removed) {
1022 drv->if_removed = 1;
1024 if (if_nametoindex(drv->first_bss.ifname) == 0) {
1028 drv->first_bss.ifname);
1031 if (!drv->if_removed) {
1036 drv->if_removed = 0;
1040 wpa_supplicant_event(drv->ctx, EVENT_INTERFACE_STATUS, &event);
1044 static int wpa_driver_nl80211_own_ifname(struct wpa_driver_nl80211_data *drv,
1056 if (os_strcmp(((char *) attr) + rta_len, drv->first_bss.ifname)
1069 static int wpa_driver_nl80211_own_ifindex(struct wpa_driver_nl80211_data *drv,
1072 if (drv->ifindex == ifindex)
1075 if (drv->if_removed && wpa_driver_nl80211_own_ifname(drv, buf, len)) {
1078 wpa_driver_nl80211_finish_drv_init(drv);
1089 struct wpa_driver_nl80211_data *drv;
1090 dl_list_for_each(drv, &global->interfaces,
1092 if (wpa_driver_nl80211_own_ifindex(drv, idx, buf, len) ||
1093 have_ifidx(drv, idx))
1094 return drv;
1105 struct wpa_driver_nl80211_data *drv;
1111 drv = nl80211_find_drv(global, ifi->ifi_index, buf, len);
1112 if (!drv) {
1120 drv->operstate, ifi->ifi_flags,
1126 if (!drv->if_disabled && !(ifi->ifi_flags & IFF_UP)) {
1128 linux_iface_up(drv->global->ioctl_sock,
1129 drv->first_bss.ifname) > 0) {
1135 if (drv->ignore_if_down_event) {
1138 drv->ignore_if_down_event = 0;
1140 drv->if_disabled = 1;
1141 wpa_supplicant_event(drv->ctx,
1146 if (drv->if_disabled && (ifi->ifi_flags & IFF_UP)) {
1148 linux_iface_up(drv->global->ioctl_sock,
1149 drv->first_bss.ifname) == 0) {
1153 } else if (if_nametoindex(drv->first_bss.ifname) == 0) {
1156 drv->first_bss.ifname);
1157 } else if (drv->if_removed) {
1160 "removed", drv->first_bss.ifname);
1163 drv->if_disabled = 0;
1164 wpa_supplicant_event(drv->ctx, EVENT_INTERFACE_ENABLED,
1175 if (drv->operstate == 1 &&
1178 netlink_send_oper_ifla(drv->global->netlink, drv->ifindex,
1187 drv,
1200 add_ifidx(drv, brid);
1210 struct wpa_driver_nl80211_data *drv;
1215 drv = nl80211_find_drv(global, ifi->ifi_index, buf, len);
1216 if (!drv) {
1229 drv,
1243 del_ifidx(drv, brid);
1248 static void mlme_event_auth(struct wpa_driver_nl80211_data *drv,
1262 os_memcpy(drv->auth_bssid, mgmt->sa, ETH_ALEN);
1263 os_memset(drv->auth_attempt_bssid, 0, ETH_ALEN);
1275 wpa_supplicant_event(drv->ctx, EVENT_AUTH, &event);
1279 static unsigned int nl80211_get_assoc_freq(struct wpa_driver_nl80211_data *drv)
1290 nl80211_cmd(drv, msg, NLM_F_DUMP, NL80211_CMD_GET_SCAN);
1291 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
1293 arg.drv = drv;
1294 ret = send_and_recv_msgs(drv, msg, bss_info_handler, &arg);
1301 drv->assoc_freq = arg.assoc_freq;
1302 return drv->assoc_freq;
1308 return drv->assoc_freq;
1312 static void mlme_event_assoc(struct wpa_driver_nl80211_data *drv,
1339 wpa_supplicant_event(drv->ctx, EVENT_ASSOC_REJECT, &event);
1343 drv->associated = 1;
1344 os_memcpy(drv->bssid, mgmt->sa, ETH_ALEN);
1345 os_memcpy(drv->prev_bssid, mgmt->sa, ETH_ALEN);
1354 event.assoc_info.freq = drv->assoc_freq;
1356 wpa_supplicant_event(drv->ctx, EVENT_ASSOC, &event);
1360 static void mlme_event_connect(struct wpa_driver_nl80211_data *drv,
1367 if (drv->capa.flags & WPA_DRIVER_FLAGS_SME) {
1392 wpa_supplicant_event(drv->ctx, EVENT_ASSOC_REJECT, &event);
1396 drv->associated = 1;
1398 os_memcpy(drv->bssid, nla_data(addr), ETH_ALEN);
1399 os_memcpy(drv->prev_bssid, drv->bssid, ETH_ALEN);
1411 event.assoc_info.freq = nl80211_get_assoc_freq(drv);
1413 wpa_supplicant_event(drv->ctx, EVENT_ASSOC, &event);
1417 static void mlme_event_disconnect(struct wpa_driver_nl80211_data *drv,
1424 if (drv->capa.flags & WPA_DRIVER_FLAGS_SME) {
1434 if (drv->ignore_next_local_disconnect) {
1435 drv->ignore_next_local_disconnect = 0;
1447 nl80211_mark_disconnected(drv);
1452 wpa_supplicant_event(drv->ctx, EVENT_DEAUTH, &data);
1456 static void mlme_event_ch_switch(struct wpa_driver_nl80211_data *drv,
1486 wpa_supplicant_event(drv->ctx, EVENT_CH_SWITCH, &data);
1490 static void mlme_timeout_event(struct wpa_driver_nl80211_data *drv,
1511 wpa_supplicant_event(drv->ctx, ev, &event);
1515 static void mlme_event_mgmt(struct wpa_driver_nl80211_data *drv,
1540 drv->last_mgmt_freq = event.rx_action.freq;
1549 wpa_supplicant_event(drv->ctx, EVENT_RX_ACTION, &event);
1554 wpa_supplicant_event(drv->ctx, EVENT_RX_MGMT, &event);
1559 static void mlme_event_mgmt_tx_status(struct wpa_driver_nl80211_data *drv,
1568 if (!is_ap_interface(drv->nlmode)) {
1578 cookie_val == drv->send_action_cookie ?
1580 if (cookie_val != drv->send_action_cookie)
1594 wpa_supplicant_event(drv->ctx, EVENT_TX_STATUS, &event);
1598 static void mlme_event_deauth_disassoc(struct wpa_driver_nl80211_data *drv,
1616 if ((drv->capa.flags & WPA_DRIVER_FLAGS_SME) &&
1617 !drv->associated &&
1618 os_memcmp(bssid, drv->auth_bssid, ETH_ALEN) != 0 &&
1619 os_memcmp(bssid, drv->auth_attempt_bssid, ETH_ALEN) != 0 &&
1620 os_memcmp(bssid, drv->prev_bssid, ETH_ALEN) == 0) {
1628 MAC2STR(drv->auth_attempt_bssid));
1632 if (drv->associated != 0 &&
1633 os_memcmp(bssid, drv->bssid, ETH_ALEN) != 0 &&
1634 os_memcmp(bssid, drv->auth_bssid, ETH_ALEN) != 0) {
1647 nl80211_mark_disconnected(drv);
1656 !os_memcmp(mgmt->sa, drv->first_bss.addr, ETH_ALEN);
1666 !os_memcmp(mgmt->sa, drv->first_bss.addr, ETH_ALEN);
1676 wpa_supplicant_event(drv->ctx, type, &event);
1680 static void mlme_event_unprot_disconnect(struct wpa_driver_nl80211_data *drv,
1713 wpa_supplicant_event(drv->ctx, type, &event);
1723 struct wpa_driver_nl80211_data *drv = bss->drv;
1728 mlme_timeout_event(drv, cmd, addr);
1765 mlme_event_auth(drv, nla_data(frame), nla_len(frame));
1768 mlme_event_assoc(drv, nla_data(frame), nla_len(frame));
1771 mlme_event_deauth_disassoc(drv, EVENT_DEAUTH,
1775 mlme_event_deauth_disassoc(drv, EVENT_DISASSOC,
1779 mlme_event_mgmt(drv, freq, sig, nla_data(frame),
1783 mlme_event_mgmt_tx_status(drv, cookie, nla_data(frame),
1787 mlme_event_unprot_disconnect(drv, EVENT_UNPROT_DEAUTH,
1791 mlme_event_unprot_disconnect(drv, EVENT_UNPROT_DISASSOC,
1836 static void mlme_event_join_ibss(struct wpa_driver_nl80211_data *drv,
1846 os_memcpy(drv->bssid, nla_data(tb[NL80211_ATTR_MAC]), ETH_ALEN);
1849 nl80211_register_frame(&drv->first_bss, drv->first_bss.nl_mgmt,
1852 drv->associated = 1;
1854 MAC2STR(drv->bssid));
1856 wpa_supplicant_event(drv->ctx, EVENT_ASSOC, NULL);
1860 static void mlme_event_remain_on_channel(struct wpa_driver_nl80211_data *drv,
1891 cookie == drv->remain_on_chan_cookie ? "match" : "unknown");
1893 if (cookie != drv->remain_on_chan_cookie)
1897 drv->pending_remain_on_chan = 0;
1902 wpa_supplicant_event(drv->ctx, cancel_event ?
1908 static void mlme_event_ft_event(struct wpa_driver_nl80211_data *drv,
1932 wpa_supplicant_event(drv->ctx, EVENT_FT_RESPONSE, &data);
1936 static void send_scan_event(struct wpa_driver_nl80211_data *drv, int aborted,
1947 if (drv->scan_for_auth) {
1948 drv->scan_for_auth = 0;
1951 wpa_driver_nl80211_authenticate_retry(drv);
1981 wpa_supplicant_event(drv->ctx, EVENT_SCAN_RESULTS, &event);
2039 static int nl80211_get_link_signal(struct wpa_driver_nl80211_data *drv,
2051 nl80211_cmd(drv, msg, 0, NL80211_CMD_GET_STATION);
2053 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
2054 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, drv->bssid);
2056 return send_and_recv_msgs(drv, msg, get_link_signal, sig);
2107 static int nl80211_get_link_noise(struct wpa_driver_nl80211_data *drv,
2113 sig_change->frequency = drv->assoc_freq;
2119 nl80211_cmd(drv, msg, NLM_F_DUMP, NL80211_CMD_GET_SURVEY);
2121 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
2123 return send_and_recv_msgs(drv, msg, get_link_noise, sig_change);
2184 struct wpa_driver_nl80211_data *drv,
2193 nl80211_cmd(drv, msg, NLM_F_DUMP, NL80211_CMD_GET_SURVEY);
2195 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
2197 return send_and_recv_msgs(drv, msg, get_noise_for_scan_results,
2205 static void nl80211_cqm_event(struct wpa_driver_nl80211_data *drv,
2234 wpa_supplicant_event(drv->ctx, EVENT_STATION_LOW_ACK, &ed);
2253 res = nl80211_get_link_signal(drv, &sig);
2261 res = nl80211_get_link_noise(drv, &sig);
2268 wpa_supplicant_event(drv->ctx, EVENT_SIGNAL_CHANGE, &ed);
2272 static void nl80211_new_station_event(struct wpa_driver_nl80211_data *drv,
2283 if (is_ap_interface(drv->nlmode) && drv->device_ap_sme) {
2291 drv_event_assoc(drv->ctx, addr, ies, ies_len, 0);
2295 if (drv->nlmode != NL80211_IFTYPE_ADHOC)
2300 wpa_supplicant_event(drv->ctx, EVENT_IBSS_RSN_START, &data);
2304 static void nl80211_del_station_event(struct wpa_driver_nl80211_data *drv,
2316 if (is_ap_interface(drv->nlmode) && drv->device_ap_sme) {
2317 drv_event_disassoc(drv->ctx, addr);
2321 if (drv->nlmode != NL80211_IFTYPE_ADHOC)
2326 wpa_supplicant_event(drv->ctx, EVENT_IBSS_PEER_LOST, &data);
2330 static void nl80211_rekey_offload_event(struct wpa_driver_nl80211_data *drv,
2368 wpa_supplicant_event(drv->ctx, EVENT_DRIVER_GTK_REKEY, &data);
2372 static void nl80211_pmksa_candidate_event(struct wpa_driver_nl80211_data *drv,
2404 wpa_supplicant_event(drv->ctx, EVENT_PMKID_CANDIDATE, &data);
2408 static void nl80211_client_probe_event(struct wpa_driver_nl80211_data *drv,
2422 wpa_supplicant_event(drv->ctx, EVENT_DRIVER_CLIENT_POLL_OK, &data);
2426 static void nl80211_tdls_oper_event(struct wpa_driver_nl80211_data *drv,
2459 wpa_supplicant_event(drv->ctx, EVENT_TDLS, &data);
2463 static void nl80211_stop_ap(struct wpa_driver_nl80211_data *drv,
2466 wpa_supplicant_event(drv->ctx, EVENT_INTERFACE_UNAVAILABLE, NULL);
2470 static void nl80211_connect_failed_event(struct wpa_driver_nl80211_data *drv,
2503 wpa_supplicant_event(drv->ctx, EVENT_CONNECT_FAILED_REASON, &data);
2507 static void nl80211_radar_event(struct wpa_driver_nl80211_data *drv,
2525 wpa_supplicant_event(drv->ctx, EVENT_DFS_RADAR_DETECTED, &data);
2528 wpa_supplicant_event(drv->ctx, EVENT_DFS_CAC_FINISHED, &data);
2531 wpa_supplicant_event(drv->ctx, EVENT_DFS_CAC_ABORTED, &data);
2534 wpa_supplicant_event(drv->ctx, EVENT_DFS_NOP_FINISHED, &data);
2547 struct wpa_driver_nl80211_data *drv = bss->drv;
2558 wpa_supplicant_event(drv->ctx, EVENT_RX_FROM_UNKNOWN, &event);
2565 struct wpa_driver_nl80211_data *drv = bss->drv;
2570 if (drv->ap_scan_as_station != NL80211_IFTYPE_UNSPECIFIED &&
2573 wpa_driver_nl80211_set_mode(&drv->first_bss,
2574 drv->ap_scan_as_station);
2575 drv->ap_scan_as_station = NL80211_IFTYPE_UNSPECIFIED;
2580 wpa_dbg(drv->ctx, MSG_DEBUG, "nl80211: Scan trigger");
2583 wpa_dbg(drv->ctx, MSG_DEBUG, "nl80211: Sched scan started");
2586 wpa_dbg(drv->ctx, MSG_DEBUG, "nl80211: Sched scan stopped");
2587 wpa_supplicant_event(drv->ctx, EVENT_SCHED_SCAN_STOPPED, NULL);
2590 wpa_dbg(drv->ctx, MSG_DEBUG,
2592 drv->scan_complete_events = 1;
2593 eloop_cancel_timeout(wpa_driver_nl80211_scan_timeout, drv,
2594 drv->ctx);
2595 send_scan_event(drv, 0, tb);
2598 wpa_dbg(drv->ctx, MSG_DEBUG,
2600 send_scan_event(drv, 0, tb);
2603 wpa_dbg(drv->ctx, MSG_DEBUG, "nl80211: Scan aborted");
2608 eloop_cancel_timeout(wpa_driver_nl80211_scan_timeout, drv,
2609 drv->ctx);
2610 send_scan_event(drv, 1, tb);
2627 mlme_event_connect(drv, cmd,
2634 mlme_event_ch_switch(drv, tb[NL80211_ATTR_WIPHY_FREQ],
2638 mlme_event_disconnect(drv, tb[NL80211_ATTR_REASON_CODE],
2646 mlme_event_join_ibss(drv, tb);
2649 mlme_event_remain_on_channel(drv, 0, tb);
2652 mlme_event_remain_on_channel(drv, 1, tb);
2655 nl80211_cqm_event(drv, tb);
2659 wpa_supplicant_event(drv->ctx, EVENT_CHANNEL_LIST_CHANGED,
2664 wpa_supplicant_event(drv->ctx, EVENT_CHANNEL_LIST_CHANGED,
2668 nl80211_new_station_event(drv, tb);
2671 nl80211_del_station_event(drv, tb);
2674 nl80211_rekey_offload_event(drv, tb);
2677 nl80211_pmksa_candidate_event(drv, tb);
2680 nl80211_client_probe_event(drv, tb);
2683 nl80211_tdls_oper_event(drv, tb);
2686 nl80211_connect_failed_event(drv, tb);
2689 mlme_event_ft_event(drv, tb);
2692 nl80211_radar_event(drv, tb);
2695 nl80211_stop_ap(drv, tb);
2698 wpa_dbg(drv->ctx, MSG_DEBUG, "nl80211: Ignored unknown event "
2707 struct wpa_driver_nl80211_data *drv = arg;
2719 for (bss = &drv->first_bss; bss; bss = bss->next)
2730 for (bss = &drv->first_bss; bss; bss = bss->next) {
2750 struct wpa_driver_nl80211_data *drv, *tmp;
2766 dl_list_for_each_safe(drv, tmp, &global->interfaces,
2768 for (bss = &drv->first_bss; bss; bss = bss->next) {
2844 struct wpa_driver_nl80211_data *drv = bss->drv;
2856 nl80211_cmd(drv, msg, 0, NL80211_CMD_REQ_SET_REG);
2859 if (send_and_recv_msgs(drv, msg, NULL, NULL))
2884 static u32 get_nl80211_protocol_features(struct wpa_driver_nl80211_data *drv)
2893 nl80211_cmd(drv, msg, 0, NL80211_CMD_GET_PROTOCOL_FEATURES);
2894 if (send_and_recv_msgs(drv, msg, protocol_feature_handler, &feat) == 0)
2905 struct wpa_driver_nl80211_data *drv;
3153 struct wpa_driver_nl80211_data *drv = info->drv;
3159 os_strncpy(drv->phyname,
3161 sizeof(drv->phyname));
3210 drv->extended_capa == NULL) {
3211 drv->extended_capa =
3213 if (drv->extended_capa) {
3214 os_memcpy(drv->extended_capa,
3217 drv->extended_capa_len =
3220 drv->extended_capa_mask =
3222 if (drv->extended_capa_mask) {
3223 os_memcpy(drv->extended_capa_mask,
3227 os_free(drv->extended_capa);
3228 drv->extended_capa = NULL;
3229 drv->extended_capa_len = 0;
3237 static int wpa_driver_nl80211_get_info(struct wpa_driver_nl80211_data *drv,
3244 info->capa = &drv->capa;
3245 info->drv = drv;
3251 feat = get_nl80211_protocol_features(drv);
3253 nl80211_cmd(drv, msg, NLM_F_DUMP, NL80211_CMD_GET_WIPHY);
3255 nl80211_cmd(drv, msg, 0, NL80211_CMD_GET_WIPHY);
3258 if (nl80211_set_iface_id(msg, &drv->first_bss) < 0)
3261 if (send_and_recv_msgs(drv, msg, wiphy_info_handler, info))
3265 drv->capa.flags |= WPA_DRIVER_FLAGS_SME;
3273 drv->capa.flags |= WPA_DRIVER_FLAGS_P2P_CAPABLE;
3277 drv->capa.flags |= WPA_DRIVER_FLAGS_P2P_CONCURRENT;
3278 drv->capa.flags |= WPA_DRIVER_FLAGS_P2P_MGMT_AND_NON_P2P;
3283 drv->capa.num_multichan_concurrent =
3288 if (!drv->capa.max_remain_on_chan)
3289 drv->capa.max_remain_on_chan = 5000;
3298 static int wpa_driver_nl80211_capa(struct wpa_driver_nl80211_data *drv)
3301 if (wpa_driver_nl80211_get_info(drv, &info))
3307 drv->has_capability = 1;
3309 drv->capa.key_mgmt = WPA_DRIVER_CAPA_KEY_MGMT_WPA |
3313 drv->capa.enc = WPA_DRIVER_CAPA_ENC_WEP40 |
3317 drv->capa.auth = WPA_DRIVER_AUTH_OPEN |
3321 drv->capa.flags |= WPA_DRIVER_FLAGS_SANE_ERROR_CODES;
3322 drv->capa.flags |= WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC_DONE;
3323 drv->capa.flags |= WPA_DRIVER_FLAGS_EAPOL_TX_STATUS;
3326 drv->capa.flags |= WPA_DRIVER_FLAGS_DEAUTH_TX_STATUS;
3332 drv->capa.flags |= WPA_DRIVER_FLAGS_AP_MLME;
3335 drv->device_ap_sme = info.device_ap_sme;
3336 drv->poll_command_supported = info.poll_command_supported;
3337 drv->data_tx_status = info.data_tx_status;
3340 if(drv->capa.flags & WPA_DRIVER_FLAGS_OFFCHANNEL_TX) {
3344 drv->use_monitor = 0;
3351 drv->use_monitor = !info.poll_command_supported || !info.data_tx_status;
3354 if (drv->device_ap_sme && drv->use_monitor) {
3364 drv->use_monitor = 0;
3373 if (!drv->use_monitor && !info.data_tx_status)
3374 drv->capa.flags &= ~WPA_DRIVER_FLAGS_EAPOL_TX_STATUS;
3492 static int wpa_driver_nl80211_init_nl(struct wpa_driver_nl80211_data *drv)
3494 drv->nl_cb = nl_cb_alloc(NL_CB_DEFAULT);
3495 if (!drv->nl_cb) {
3500 nl_cb_set(drv->nl_cb, NL_CB_SEQ_CHECK, NL_CB_CUSTOM,
3502 nl_cb_set(drv->nl_cb, NL_CB_VALID, NL_CB_CUSTOM,
3503 process_drv_event, drv);
3521 struct wpa_driver_nl80211_data *drv = ctx;
3523 if (i802_set_iface_flags(&drv->first_bss, 1)) {
3536 struct wpa_driver_nl80211_data *drv = eloop_ctx;
3587 wpa_supplicant_event(drv->ctx, EVENT_EAPOL_TX_STATUS, &event);
3624 struct wpa_driver_nl80211_data *drv;
3630 drv = os_zalloc(sizeof(*drv));
3631 if (drv == NULL)
3633 drv->global = global_priv;
3634 drv->ctx = ctx;
3635 bss = &drv->first_bss;
3636 bss->drv = drv;
3640 drv->monitor_ifidx = -1;
3641 drv->monitor_sock = -1;
3642 drv->eapol_tx_sock = -1;
3643 drv->ap_scan_as_station = NL80211_IFTYPE_UNSPECIFIED;
3645 if (wpa_driver_nl80211_init_nl(drv)) {
3646 os_free(drv);
3656 rcfg->ctx = drv;
3660 drv->rfkill = rfkill_init(rcfg);
3661 if (drv->rfkill == NULL) {
3666 if (wpa_driver_nl80211_finish_drv_init(drv))
3669 drv->eapol_tx_sock = socket(PF_PACKET, SOCK_DGRAM, 0);
3670 if (drv->eapol_tx_sock < 0)
3673 if (drv->data_tx_status) {
3676 if (setsockopt(drv->eapol_tx_sock, SOL_SOCKET, SO_WIFI_STATUS,
3680 drv->data_tx_status = 0;
3681 if (!drv->use_monitor)
3682 drv->capa.flags &=
3685 eloop_register_read_sock(drv->eapol_tx_sock,
3687 drv, NULL);
3691 if (drv->global) {
3692 dl_list_add(&drv->global->interfaces, &drv->list);
3693 drv->in_interface_list = 1;
3708 struct wpa_driver_nl80211_data *drv = bss->drv;
3721 nl80211_cmd(drv, msg, 0, NL80211_CMD_REGISTER_ACTION);
3729 ret = send_and_recv(drv->global, nl_handle, msg, NULL, NULL);
3748 struct wpa_driver_nl80211_data *drv = bss->drv;
3756 bss->nl_mgmt = nl_create_handle(drv->nl_cb, "mgmt");
3779 struct wpa_driver_nl80211_data *drv = bss->drv;
3818 if ((drv->capa.flags & WPA_DRIVER_FLAGS_TDLS_SUPPORT)) {
3830 drv->capa.key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_FT |
3846 struct wpa_driver_nl80211_data *drv = bss->drv;
3854 nl80211_cmd(drv, msg, 0, NL80211_CMD_UNEXPECTED_FRAME);
3858 ret = send_and_recv(drv->global, bss->nl_mgmt, msg, NULL, NULL);
3964 struct wpa_driver_nl80211_data *drv = bss->drv;
3972 nl80211_cmd(drv, msg, 0, NL80211_CMD_DEL_INTERFACE);
3975 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
3989 struct wpa_driver_nl80211_data *drv = bss->drv;
3998 nl80211_cmd(drv, msg, 0, NL80211_CMD_START_P2P_DEVICE);
4000 nl80211_cmd(drv, msg, 0, NL80211_CMD_STOP_P2P_DEVICE);
4004 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
4024 return linux_set_iface_flags(bss->drv->global->ioctl_sock,
4034 wpa_driver_nl80211_finish_drv_init(struct wpa_driver_nl80211_data *drv)
4039 struct i802_bss *bss = &drv->first_bss;
4042 drv->ifindex = if_nametoindex(bss->ifname);
4043 bss->ifindex = drv->ifindex;
4044 bss->wdev_id = drv->global->if_add_wdevid;
4045 bss->wdev_id_set = drv->global->if_add_wdevid_set;
4047 bss->if_dynamic = drv->ifindex == drv->global->if_add_ifindex;
4048 bss->if_dynamic = bss->if_dynamic || drv->global->if_add_wdevid_set;
4049 drv->global->if_add_wdevid_set = 0;
4051 if (wpa_driver_nl80211_capa(drv))
4055 bss->ifname, drv->phyname);
4070 drv->nlmode = nlmode;
4080 if (linux_set_iface_flags(drv->global->ioctl_sock, bss->ifname, 1)) {
4081 if (rfkill_is_blocked(drv->rfkill)) {
4085 drv->if_disabled = 1;
4094 netlink_send_oper_ifla(drv->global->netlink, drv->ifindex,
4098 if (linux_get_ifhwaddr(drv->global->ioctl_sock, bss->ifname,
4104 drv, drv->ctx);
4111 static int wpa_driver_nl80211_del_beacon(struct wpa_driver_nl80211_data *drv)
4119 nl80211_cmd(drv, msg, 0, NL80211_CMD_DEL_BEACON);
4120 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
4122 return send_and_recv_msgs(drv, msg, NULL, NULL);
4138 struct wpa_driver_nl80211_data *drv = bss->drv;
4141 if (drv->data_tx_status)
4142 eloop_unregister_read_sock(drv->eapol_tx_sock);
4143 if (drv->eapol_tx_sock >= 0)
4144 close(drv->eapol_tx_sock);
4149 if (linux_br_del_if(drv->global->ioctl_sock, bss->brname,
4156 if (linux_br_del(drv->global->ioctl_sock, bss->brname) < 0)
4162 nl80211_remove_monitor_interface(drv);
4164 if (is_ap_interface(drv->nlmode))
4165 wpa_driver_nl80211_del_beacon(drv);
4168 if (drv->last_freq_ht) {
4172 freq.freq = drv->last_freq;
4176 if (drv->eapol_sock >= 0) {
4177 eloop_unregister_read_sock(drv->eapol_sock);
4178 close(drv->eapol_sock);
4181 if (drv->if_indices != drv->default_if_indices)
4182 os_free(drv->if_indices);
4185 if (drv->disabled_11b_rates)
4186 nl80211_disable_11b_rates(drv, drv->ifindex, 0);
4188 netlink_send_oper_ifla(drv->global->netlink, drv->ifindex, 0,
4190 rfkill_deinit(drv->rfkill);
4192 eloop_cancel_timeout(wpa_driver_nl80211_scan_timeout, drv, drv->ctx);
4195 if (drv->nlmode != NL80211_IFTYPE_P2P_DEVICE) {
4202 nl_cb_put(drv->nl_cb);
4204 nl80211_destroy_bss(&drv->first_bss);
4206 os_free(drv->filter_ssids);
4208 os_free(drv->auth_ie);
4210 if (drv->in_interface_list)
4211 dl_list_del(&drv->list);
4213 os_free(drv->extended_capa);
4214 os_free(drv->extended_capa_mask);
4215 os_free(drv);
4229 struct wpa_driver_nl80211_data *drv = eloop_ctx;
4230 if (drv->ap_scan_as_station != NL80211_IFTYPE_UNSPECIFIED) {
4231 wpa_driver_nl80211_set_mode(&drv->first_bss,
4232 drv->ap_scan_as_station);
4233 drv->ap_scan_as_station = NL80211_IFTYPE_UNSPECIFIED;
4241 nl80211_scan_common(struct wpa_driver_nl80211_data *drv, u8 cmd,
4251 nl80211_cmd(drv, msg, 0, cmd);
4254 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
4297 os_free(drv->filter_ssids);
4298 drv->filter_ssids = params->filter_ssids;
4300 drv->num_filter_ssids = params->num_filter_ssids;
4320 struct wpa_driver_nl80211_data *drv = bss->drv;
4324 wpa_dbg(drv->ctx, MSG_DEBUG, "nl80211: scan request");
4325 drv->scan_for_auth = 0;
4327 msg = nl80211_scan_common(drv, NL80211_CMD_TRIGGER_SCAN, params,
4354 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
4360 if (is_ap_interface(drv->nlmode)) {
4370 wpa_driver_nl80211_set_mode(bss, drv->nlmode);
4375 drv->ap_scan_as_station = drv->nlmode;
4387 if (drv->scan_complete_events) {
4397 eloop_cancel_timeout(wpa_driver_nl80211_scan_timeout, drv, drv->ctx);
4399 drv, drv->ctx);
4419 struct wpa_driver_nl80211_data *drv = bss->drv;
4424 wpa_dbg(drv->ctx, MSG_DEBUG, "nl80211: sched_scan request");
4427 if (!drv->capa.sched_scan_supported)
4431 msg = nl80211_scan_common(drv, NL80211_CMD_START_SCHED_SCAN, params,
4438 if ((drv->num_filter_ssids &&
4439 (int) drv->num_filter_ssids <= drv->capa.max_match_sets) ||
4446 for (i = 0; i < drv->num_filter_ssids; i++) {
4450 drv->filter_ssids[i].ssid,
4451 drv->filter_ssids[i].ssid_len);
4457 drv->filter_ssids[i].ssid_len,
4458 drv->filter_ssids[i].ssid);
4479 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
4507 struct wpa_driver_nl80211_data *drv = bss->drv;
4512 if (!drv->capa.sched_scan_supported)
4520 nl80211_cmd(drv, msg, 0, NL80211_CMD_STOP_SCHED_SCAN);
4522 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
4524 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
4562 static int nl80211_scan_filtered(struct wpa_driver_nl80211_data *drv,
4568 if (drv->filter_ssids == NULL)
4575 for (i = 0; i < drv->num_filter_ssids; i++) {
4576 if (ssid[1] == drv->filter_ssids[i].ssid_len &&
4577 os_memcmp(ssid + 2, drv->filter_ssids[i].ssid, ssid[1]) ==
4655 if (nl80211_scan_filtered(_arg->drv, ie ? ie : beacon_ie,
4755 static void clear_state_mismatch(struct wpa_driver_nl80211_data *drv,
4758 if (drv->capa.flags & WPA_DRIVER_FLAGS_SME) {
4761 wpa_driver_nl80211_mlme(drv, addr,
4769 struct wpa_driver_nl80211_data *drv, struct wpa_scan_results *res)
4780 if (is_sta_interface(drv->nlmode) &&
4781 os_memcmp(r->bssid, drv->bssid, ETH_ALEN) != 0 &&
4782 os_memcmp(r->bssid, drv->auth_bssid, ETH_ALEN) !=
4787 MAC2STR(drv->auth_bssid),
4788 MAC2STR(drv->bssid));
4789 clear_state_mismatch(drv, r->bssid);
4798 if (is_sta_interface(drv->nlmode) &&
4799 !drv->associated) {
4803 clear_state_mismatch(drv, r->bssid);
4804 } else if (is_sta_interface(drv->nlmode) &&
4805 os_memcmp(drv->bssid, r->bssid, ETH_ALEN) !=
4810 MAC2STR(drv->bssid));
4811 clear_state_mismatch(drv, r->bssid);
4812 clear_state_mismatch(drv, drv->bssid);
4820 nl80211_get_scan_results(struct wpa_driver_nl80211_data *drv)
4834 nl80211_cmd(drv, msg, NLM_F_DUMP, NL80211_CMD_GET_SCAN);
4835 if (nl80211_set_iface_id(msg, &drv->first_bss) < 0)
4838 arg.drv = drv;
4840 ret = send_and_recv_msgs(drv, msg, bss_info_handler, &arg);
4845 nl80211_get_noise_for_scan_results(drv, res);
4866 struct wpa_driver_nl80211_data *drv = bss->drv;
4869 res = nl80211_get_scan_results(drv);
4871 wpa_driver_nl80211_check_bss_status(drv, res);
4876 static void nl80211_dump_scan(struct wpa_driver_nl80211_data *drv)
4881 res = nl80211_get_scan_results(drv);
4906 struct wpa_driver_nl80211_data *drv = bss->drv;
4913 if (drv->nlmode == NL80211_IFTYPE_P2P_DEVICE)
4933 nl80211_cmd(drv, msg, 0, NL80211_CMD_DEL_KEY);
4935 nl80211_cmd(drv, msg, 0, NL80211_CMD_NEW_KEY);
5004 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
5017 if (is_ap_interface(drv->nlmode) && addr &&
5025 nl80211_cmd(drv, msg, 0, NL80211_CMD_SET_KEY);
5050 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
5181 static int wpa_driver_nl80211_mlme(struct wpa_driver_nl80211_data *drv,
5192 nl80211_cmd(drv, msg, 0, cmd);
5194 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
5201 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
5204 wpa_dbg(drv->ctx, MSG_DEBUG,
5217 static int wpa_driver_nl80211_disconnect(struct wpa_driver_nl80211_data *drv,
5223 nl80211_mark_disconnected(drv);
5225 ret = wpa_driver_nl80211_mlme(drv, NULL, NL80211_CMD_DISCONNECT,
5231 drv->ignore_next_local_disconnect = ret == 0;
5240 struct wpa_driver_nl80211_data *drv = bss->drv;
5241 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_SME))
5242 return wpa_driver_nl80211_disconnect(drv, reason_code);
5245 nl80211_mark_disconnected(drv);
5246 if (drv->nlmode == NL80211_IFTYPE_ADHOC)
5247 return nl80211_leave_ibss(drv);
5248 return wpa_driver_nl80211_mlme(drv, addr, NL80211_CMD_DEAUTHENTICATE,
5253 static void nl80211_copy_auth_params(struct wpa_driver_nl80211_data *drv,
5258 drv->auth_freq = params->freq;
5259 drv->auth_alg = params->auth_alg;
5260 drv->auth_wep_tx_keyidx = params->wep_tx_keyidx;
5261 drv->auth_local_state_change = params->local_state_change;
5262 drv->auth_p2p = params->p2p;
5265 os_memcpy(drv->auth_bssid_, params->bssid, ETH_ALEN);
5267 os_memset(drv->auth_bssid_, 0, ETH_ALEN);
5270 os_memcpy(drv->auth_ssid, params->ssid, params->ssid_len);
5271 drv->auth_ssid_len = params->ssid_len;
5273 drv->auth_ssid_len = 0;
5276 os_free(drv->auth_ie);
5277 drv->auth_ie = NULL;
5278 drv->auth_ie_len = 0;
5280 drv->auth_ie = os_malloc(params->ie_len);
5281 if (drv->auth_ie) {
5282 os_memcpy(drv->auth_ie, params->ie, params->ie_len);
5283 drv->auth_ie_len = params->ie_len;
5290 os_memcpy(drv->auth_wep_key[i], params->wep_key[i],
5292 drv->auth_wep_key_len[i] = params->wep_key_len[i];
5294 drv->auth_wep_key_len[i] = 0;
5302 struct wpa_driver_nl80211_data *drv = bss->drv;
5310 is_retry = drv->retry_auth;
5311 drv->retry_auth = 0;
5313 nl80211_mark_disconnected(drv);
5314 os_memset(drv->auth_bssid, 0, ETH_ALEN);
5316 os_memcpy(drv->auth_attempt_bssid, params->bssid, ETH_ALEN);
5318 os_memset(drv->auth_attempt_bssid, 0, ETH_ALEN);
5322 if (drv->nlmode != nlmode &&
5332 drv->ifindex);
5334 nl80211_cmd(drv, msg, 0, NL80211_CMD_AUTHENTICATE);
5353 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
5397 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
5400 wpa_dbg(drv->ctx, MSG_DEBUG,
5444 nl80211_copy_auth_params(drv, params);
5445 drv->scan_for_auth = 1;
5456 os_memcpy(event.timeout_event.addr, drv->auth_bssid_,
5458 wpa_supplicant_event(drv->ctx, EVENT_AUTH_TIMED_OUT,
5475 struct wpa_driver_nl80211_data *drv)
5478 struct i802_bss *bss = &drv->first_bss;
5484 params.freq = drv->auth_freq;
5485 params.auth_alg = drv->auth_alg;
5486 params.wep_tx_keyidx = drv->auth_wep_tx_keyidx;
5487 params.local_state_change = drv->auth_local_state_change;
5488 params.p2p = drv->auth_p2p;
5490 if (!is_zero_ether_addr(drv->auth_bssid_))
5491 params.bssid = drv->auth_bssid_;
5493 if (drv->auth_ssid_len) {
5494 params.ssid = drv->auth_ssid;
5495 params.ssid_len = drv->auth_ssid_len;
5498 params.ie = drv->auth_ie;
5499 params.ie_len = drv->auth_ie_len;
5502 if (drv->auth_wep_key_len[i]) {
5503 params.wep_key[i] = drv->auth_wep_key[i];
5504 params.wep_key_len[i] = drv->auth_wep_key_len[i];
5508 drv->retry_auth = 1;
6004 static int nl80211_set_ht40_flags(struct wpa_driver_nl80211_data *drv,
6013 nl80211_cmd(drv, msg, 0, NL80211_CMD_GET_REG);
6014 return send_and_recv_msgs(drv, msg, nl80211_get_reg, results);
6023 struct wpa_driver_nl80211_data *drv = bss->drv;
6038 feat = get_nl80211_protocol_features(drv);
6040 nl80211_cmd(drv, msg, NLM_F_DUMP, NL80211_CMD_GET_WIPHY);
6042 nl80211_cmd(drv, msg, 0, NL80211_CMD_GET_WIPHY);
6045 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
6047 if (send_and_recv_msgs(drv, msg, phy_info_handler, &result) == 0) {
6048 nl80211_set_ht40_flags(drv, &result);
6059 static int wpa_driver_nl80211_send_mntr(struct wpa_driver_nl80211_data *drv,
6097 if (drv->monitor_sock < 0) {
6107 res = sendmsg(drv->monitor_sock, &msg, 0);
6122 struct wpa_driver_nl80211_data *drv = bss->drv;
6128 if (drv->use_monitor)
6129 return wpa_driver_nl80211_send_mntr(drv, data, len,
6143 struct wpa_driver_nl80211_data *drv = bss->drv;
6151 if ((is_sta_interface(drv->nlmode) ||
6152 drv->nlmode == NL80211_IFTYPE_P2P_DEVICE) &&
6161 freq = drv->last_mgmt_freq;
6167 if (drv->device_ap_sme && is_ap_interface(drv->nlmode)) {
6174 &drv->send_action_cookie,
6202 struct wpa_driver_nl80211_data *drv = bss->drv;
6209 nl80211_cmd(drv, msg, 0, NL80211_CMD_SET_BSS);
6236 return send_and_recv_msgs(drv, msg, NULL, NULL);
6247 struct wpa_driver_nl80211_data *drv = bss->drv;
6253 if (!(drv->capa.max_acl_mac_addrs))
6256 if (params->num_mac_acl > drv->capa.max_acl_mac_addrs)
6266 nl80211_cmd(drv, msg, 0, NL80211_CMD_SET_MAC_ACL);
6268 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
6283 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
6301 struct wpa_driver_nl80211_data *drv = bss->drv;
6322 nl80211_cmd(drv, msg, 0, cmd);
6465 if (drv->capa.flags & WPA_DRIVER_FLAGS_INACTIVITY_TIMER) {
6472 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
6492 struct wpa_driver_nl80211_data *drv = bss->drv;
6504 nl80211_cmd(drv, msg, 0, NL80211_CMD_SET_WIPHY);
6506 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
6554 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
6591 struct wpa_driver_nl80211_data *drv = bss->drv;
6597 !(drv->capa.flags & WPA_DRIVER_FLAGS_TDLS_SUPPORT))
6606 nl80211_cmd(drv, msg, 0, params->set ? NL80211_CMD_SET_STATION :
6686 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
6702 struct wpa_driver_nl80211_data *drv = bss->drv;
6710 nl80211_cmd(drv, msg, 0, NL80211_CMD_DEL_STATION);
6716 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
6729 static void nl80211_remove_iface(struct wpa_driver_nl80211_data *drv,
6737 del_ifidx(drv, ifidx);
6743 nl80211_cmd(drv, msg, 0, NL80211_CMD_DEL_INTERFACE);
6746 if (send_and_recv_msgs(drv, msg, NULL, NULL) == 0)
6784 static int nl80211_create_iface_once(struct wpa_driver_nl80211_data *drv,
6802 nl80211_cmd(drv, msg, 0, NL80211_CMD_NEW_INTERFACE);
6803 if (nl80211_set_iface_id(msg, &drv->first_bss) < 0)
6822 ret = send_and_recv_msgs(drv, msg, handler, arg);
6843 add_ifidx(drv, ifidx);
6846 linux_set_ifhwaddr(drv->global->ioctl_sock, ifname, addr)) {
6847 nl80211_remove_iface(drv, ifidx);
6855 static int nl80211_create_iface(struct wpa_driver_nl80211_data *drv,
6863 ret = nl80211_create_iface_once(drv, ifname, iftype, addr, wds, handler,
6871 nl80211_remove_iface(drv, if_nametoindex(ifname));
6874 ret = nl80211_create_iface_once(drv, ifname, iftype, addr,
6879 nl80211_disable_11b_rates(drv, ret, 1);
6905 static void from_unknown_sta(struct wpa_driver_nl80211_data *drv,
6922 wpa_supplicant_event(drv->ctx, EVENT_RX_FROM_UNKNOWN, &event);
6926 static void handle_frame(struct wpa_driver_nl80211_data *drv,
6943 wpa_supplicant_event(drv->ctx, EVENT_RX_MGMT, &event);
6948 from_unknown_sta(drv, buf, len);
6951 from_unknown_sta(drv, buf, len);
6959 struct wpa_driver_nl80211_data *drv = eloop_ctx;
7017 handle_frame(drv, buf + iter.max_length,
7020 handle_tx_callback(drv->ctx, buf + iter.max_length,
7177 struct wpa_driver_nl80211_data *drv)
7179 drv->monitor_refcount--;
7180 if (drv->monitor_refcount > 0)
7183 if (drv->monitor_ifidx >= 0) {
7184 nl80211_remove_iface(drv, drv->monitor_ifidx);
7185 drv->monitor_ifidx = -1;
7187 if (drv->monitor_sock >= 0) {
7188 eloop_unregister_read_sock(drv->monitor_sock);
7189 close(drv->monitor_sock);
7190 drv->monitor_sock = -1;
7196 nl80211_create_monitor_interface(struct wpa_driver_nl80211_data *drv)
7203 if (drv->monitor_ifidx >= 0) {
7204 drv->monitor_refcount++;
7208 if (os_strncmp(drv->first_bss.ifname, "p2p-", 4) == 0) {
7215 snprintf(buf, IFNAMSIZ, "mon-%s", drv->first_bss.ifname + 4);
7218 snprintf(buf, IFNAMSIZ, "mon.%s", drv->first_bss.ifname);
7223 drv->monitor_ifidx =
7224 nl80211_create_iface(drv, buf, NL80211_IFTYPE_MONITOR, NULL,
7227 if (drv->monitor_ifidx == -EOPNOTSUPP) {
7236 drv->device_ap_sme = 1;
7239 if (drv->monitor_ifidx < 0)
7242 if (linux_set_iface_flags(drv->global->ioctl_sock, buf, 1))
7247 ll.sll_ifindex = drv->monitor_ifidx;
7248 drv->monitor_sock = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
7249 if (drv->monitor_sock < 0) {
7254 if (add_monitor_filter(drv->monitor_sock)) {
7260 if (bind(drv->monitor_sock, (struct sockaddr *) &ll, sizeof(ll)) < 0) {
7268 (drv->monitor_sock, SOL_SOCKET, SO_PRIORITY, &optval, optlen)) {
7273 if (eloop_register_read_sock(drv->monitor_sock, handle_monitor_read,
7274 drv, NULL)) {
7281 nl80211_remove_monitor_interface(drv);
7288 struct wpa_driver_nl80211_data *drv = bss->drv;
7291 "use_monitor=%d", drv->device_ap_sme, drv->use_monitor);
7298 if (!drv->device_ap_sme)
7301 if (!drv->device_ap_sme && !drv->use_monitor)
7305 if (drv->device_ap_sme && !drv->use_monitor)
7309 if (!drv->device_ap_sme && drv->use_monitor &&
7310 nl80211_create_monitor_interface(drv) &&
7311 !drv->device_ap_sme)
7315 if (drv->device_ap_sme && drv->use_monitor)
7319 if (drv->use_monitor &&
7320 nl80211_create_monitor_interface(drv))
7324 if (drv->device_ap_sme &&
7337 struct wpa_driver_nl80211_data *drv = bss->drv;
7339 if (drv->device_ap_sme) {
7341 if (!drv->use_monitor)
7343 } else if (drv->use_monitor)
7344 nl80211_remove_monitor_interface(drv);
7359 if (bss->drv->eapol_tx_sock < 0) {
7370 ret = sendto(bss->drv->eapol_tx_sock, data, data_len, 0,
7387 struct wpa_driver_nl80211_data *drv = bss->drv;
7394 if (drv->device_ap_sme || !drv->use_monitor)
7396 if (drv->device_ap_sme && !drv->use_monitor)
7455 struct wpa_driver_nl80211_data *drv = bss->drv;
7464 nl80211_cmd(drv, msg, 0, NL80211_CMD_SET_STATION);
7499 return send_and_recv_msgs(drv, msg, NULL, NULL);
7506 static int wpa_driver_nl80211_ap(struct wpa_driver_nl80211_data *drv,
7521 old_mode = drv->nlmode;
7522 if (wpa_driver_nl80211_set_mode(&drv->first_bss, nlmode)) {
7523 nl80211_remove_monitor_interface(drv);
7527 if (wpa_driver_nl80211_set_freq(&drv->first_bss, &freq)) {
7529 wpa_driver_nl80211_set_mode(&drv->first_bss, old_mode);
7530 nl80211_remove_monitor_interface(drv);
7538 static int nl80211_leave_ibss(struct wpa_driver_nl80211_data *drv)
7547 nl80211_cmd(drv, msg, 0, NL80211_CMD_LEAVE_IBSS);
7548 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
7549 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
7566 static int wpa_driver_nl80211_ibss(struct wpa_driver_nl80211_data *drv,
7573 wpa_printf(MSG_DEBUG, "nl80211: Join IBSS (ifindex=%d)", drv->ifindex);
7575 if (wpa_driver_nl80211_set_mode(&drv->first_bss,
7587 nl80211_cmd(drv, msg, 0, NL80211_CMD_JOIN_IBSS);
7588 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
7590 if (params->ssid == NULL || params->ssid_len > sizeof(drv->ssid))
7597 os_memcpy(drv->ssid, params->ssid, params->ssid_len);
7598 drv->ssid_len = params->ssid_len;
7629 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
7638 nl80211_leave_ibss(drv);
7655 struct wpa_driver_nl80211_data *drv,
7667 wpa_printf(MSG_DEBUG, "nl80211: Connect (ifindex=%d)", drv->ifindex);
7668 nl80211_cmd(drv, msg, 0, NL80211_CMD_CONNECT);
7670 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
7679 drv->assoc_freq = params->freq;
7681 drv->assoc_freq = 0;
7693 if (params->ssid_len > sizeof(drv->ssid))
7695 os_memcpy(drv->ssid, params->ssid, params->ssid_len);
7696 drv->ssid_len = params->ssid_len;
7858 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
7876 struct wpa_driver_nl80211_data *drv,
7879 int ret = wpa_driver_nl80211_try_connect(drv, params);
7890 drv, WLAN_REASON_PREV_AUTH_NOT_VALID))
7892 ret = wpa_driver_nl80211_try_connect(drv, params);
7902 struct wpa_driver_nl80211_data *drv = bss->drv;
7907 return wpa_driver_nl80211_ap(drv, params);
7910 return wpa_driver_nl80211_ibss(drv, params);
7912 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_SME)) {
7918 return wpa_driver_nl80211_connect(drv, params);
7921 nl80211_mark_disconnected(drv);
7928 drv->ifindex);
7929 nl80211_cmd(drv, msg, 0, NL80211_CMD_ASSOCIATE);
7931 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
7940 drv->assoc_freq = params->freq;
7942 drv->assoc_freq = 0;
7954 if (params->ssid_len > sizeof(drv->ssid))
7956 os_memcpy(drv->ssid, params->ssid, params->ssid_len);
7957 drv->ssid_len = params->ssid_len;
8055 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
8058 wpa_dbg(drv->ctx, MSG_DEBUG,
8061 nl80211_dump_scan(drv);
8074 static int nl80211_set_mode(struct wpa_driver_nl80211_data *drv,
8087 nl80211_cmd(drv, msg, 0, NL80211_CMD_SET_INTERFACE);
8088 if (nl80211_set_iface_id(msg, &drv->first_bss) < 0)
8092 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
8107 struct wpa_driver_nl80211_data *drv = bss->drv;
8110 int was_ap = is_ap_interface(drv->nlmode);
8113 res = nl80211_set_mode(drv, drv->ifindex, nlmode);
8118 drv->nlmode = nlmode;
8126 if (nlmode == drv->nlmode) {
8146 ret = nl80211_set_mode(drv, drv->ifindex, nlmode);
8163 drv->nlmode = nlmode;
8164 drv->ignore_if_down_event = 1;
8170 "from %d failed", nlmode, drv->nlmode);
8175 nl80211_disable_11b_rates(drv, drv->ifindex, 1);
8176 else if (drv->disabled_11b_rates)
8177 nl80211_disable_11b_rates(drv, drv->ifindex, 0);
8204 struct wpa_driver_nl80211_data *drv = bss->drv;
8205 if (!drv->has_capability)
8207 os_memcpy(capa, &drv->capa, sizeof(*capa));
8208 if (drv->extended_capa && drv->extended_capa_mask) {
8209 capa->extended_capa = drv->extended_capa;
8210 capa->extended_capa_mask = drv->extended_capa_mask;
8211 capa->extended_capa_len = drv->extended_capa_len;
8215 !drv->allow_p2p_device) {
8227 struct wpa_driver_nl80211_data *drv = bss->drv;
8230 __func__, drv->operstate, state, state ? "UP" : "DORMANT");
8231 drv->operstate = state;
8232 return netlink_send_oper_ifla(drv->global->netlink, drv->ifindex, -1,
8240 struct wpa_driver_nl80211_data *drv = bss->drv;
8245 MACSTR, authorized ? "" : "un", MAC2STR(drv->bssid));
8251 nl80211_cmd(drv, msg, 0, NL80211_CMD_SET_STATION);
8255 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, drv->bssid);
8263 return send_and_recv_msgs(drv, msg, NULL, NULL);
8313 struct wpa_driver_nl80211_data *drv = bss->drv;
8320 nl80211_cmd(drv, msg, 0, NL80211_CMD_GET_KEY);
8329 return send_and_recv_msgs(drv, msg, get_key_handler, seq);
8339 struct wpa_driver_nl80211_data *drv = bss->drv;
8353 nl80211_cmd(drv, msg, 0, NL80211_CMD_SET_WIPHY);
8354 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
8357 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
8372 struct wpa_driver_nl80211_data *drv = bss->drv;
8386 nl80211_cmd(drv, msg, 0, NL80211_CMD_SET_WIPHY);
8387 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
8390 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
8405 struct wpa_driver_nl80211_data *drv = bss->drv;
8415 nl80211_cmd(drv, msg, 0, NL80211_CMD_DEL_STATION);
8423 res = send_and_recv_msgs(drv, msg, NULL, NULL);
8496 struct wpa_driver_nl80211_data *drv = bss->drv;
8504 nl80211_cmd(drv, msg, 0, NL80211_CMD_GET_STATION);
8509 return send_and_recv_msgs(drv, msg, get_sta_handler, data);
8522 struct wpa_driver_nl80211_data *drv = bss->drv;
8530 nl80211_cmd(drv, msg, 0, NL80211_CMD_SET_WIPHY);
8568 if (send_and_recv_msgs(drv, msg, NULL, NULL) == 0)
8580 struct wpa_driver_nl80211_data *drv = bss->drv;
8588 nl80211_cmd(drv, msg, 0, NL80211_CMD_SET_STATION);
8596 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
8636 struct wpa_driver_nl80211_data *drv = bss->drv;
8639 if (drv->device_ap_sme)
8660 struct wpa_driver_nl80211_data *drv = bss->drv;
8663 if (drv->device_ap_sme)
8683 static void add_ifidx(struct wpa_driver_nl80211_data *drv, int ifidx)
8690 for (i = 0; i < drv->num_if_indices; i++) {
8691 if (drv->if_indices[i] == 0) {
8692 drv->if_indices[i] = ifidx;
8697 if (drv->if_indices != drv->default_if_indices)
8698 old = drv->if_indices;
8702 drv->if_indices = os_realloc_array(old, drv->num_if_indices + 1,
8704 if (!drv->if_indices) {
8706 drv->if_indices = drv->default_if_indices;
8708 drv->if_indices = old;
8714 os_memcpy(drv->if_indices, drv->default_if_indices,
8715 sizeof(drv->default_if_indices));
8716 drv->if_indices[drv->num_if_indices] = ifidx;
8717 drv->num_if_indices++;
8721 static void del_ifidx(struct wpa_driver_nl80211_data *drv, int ifidx)
8725 for (i = 0; i < drv->num_if_indices; i++) {
8726 if (drv->if_indices[i] == ifidx) {
8727 drv->if_indices[i] = 0;
8734 static int have_ifidx(struct wpa_driver_nl80211_data *drv, int ifidx)
8738 for (i = 0; i < drv->num_if_indices; i++)
8739 if (drv->if_indices[i] == ifidx)
8750 struct wpa_driver_nl80211_data *drv = bss->drv;
8761 if (nl80211_create_iface(drv, name,
8766 linux_br_add_if(drv->global->ioctl_sock,
8770 if (linux_set_iface_flags(drv->global->ioctl_sock, name, 1)) {
8777 linux_br_del_if(drv->global->ioctl_sock, bridge_ifname,
8789 struct wpa_driver_nl80211_data *drv = eloop_ctx;
8802 if (have_ifidx(drv, lladdr.sll_ifindex))
8803 drv_event_eapol_rx(drv->ctx, lladdr.sll_addr, buf, len);
8807 static int i802_check_bridge(struct wpa_driver_nl80211_data *drv,
8821 if (linux_br_add(drv->global->ioctl_sock, brname) < 0) {
8828 add_ifidx(drv, if_nametoindex(brname));
8837 if (linux_br_del_if(drv->global->ioctl_sock, in_br, ifname) <
8849 if (linux_br_add_if(drv->global->ioctl_sock, brname, ifname) < 0) {
8864 struct wpa_driver_nl80211_data *drv;
8876 drv = bss->drv;
8877 drv->nlmode = NL80211_IFTYPE_AP;
8878 drv->eapol_sock = -1;
8889 drv->num_if_indices = sizeof(drv->default_if_indices) / sizeof(int);
8890 drv->if_indices = drv->default_if_indices;
8895 add_ifidx(drv, ifindex);
8902 add_ifidx(drv, br_ifindex);
8905 add_ifidx(drv, drv->ifindex);
8907 if (linux_set_iface_flags(drv->global->ioctl_sock, bss->ifname, 0))
8911 if (linux_set_ifhwaddr(drv->global->ioctl_sock, bss->ifname,
8916 if (wpa_driver_nl80211_set_mode(bss, drv->nlmode)) {
8923 i802_check_bridge(drv, bss, params->bridge[0], params->ifname) < 0)
8926 if (linux_set_iface_flags(drv->global->ioctl_sock, bss->ifname, 1))
8929 drv->eapol_sock = socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_PAE));
8930 if (drv->eapol_sock < 0) {
8935 if (eloop_register_read_sock(drv->eapol_sock, handle_eapol, drv, NULL))
8941 if (linux_get_ifhwaddr(drv->global->ioctl_sock, bss->ifname,
8990 struct wpa_driver_nl80211_data *drv;
8991 dl_list_for_each(drv, &global->interfaces,
8993 if (os_memcmp(addr, drv->first_bss.addr, ETH_ALEN) == 0)
9000 static int nl80211_p2p_interface_addr(struct wpa_driver_nl80211_data *drv,
9005 if (!drv->global)
9008 os_memcpy(new_addr, drv->first_bss.addr, ETH_ALEN);
9010 new_addr[0] = drv->first_bss.addr[0] | 0x02;
9012 if (!nl80211_addr_in_use(drv->global, new_addr))
9062 struct wpa_driver_nl80211_data *drv = bss->drv;
9081 ifidx = nl80211_create_iface(drv, ifname, nlmode, addr,
9090 drv->global->if_add_wdevid = p2pdev_info.wdev_id;
9091 drv->global->if_add_wdevid_set = p2pdev_info.wdev_id_set;
9098 ifidx = nl80211_create_iface(drv, ifname, nlmode, addr,
9109 if (drv->nlmode == NL80211_IFTYPE_P2P_DEVICE)
9111 else if (linux_get_ifhwaddr(drv->global->ioctl_sock,
9113 nl80211_remove_iface(drv, ifidx);
9125 if (linux_get_ifhwaddr(drv->global->ioctl_sock, ifname,
9127 nl80211_remove_iface(drv, ifidx);
9130 if (nl80211_addr_in_use(drv->global, new_addr)) {
9133 if (nl80211_p2p_interface_addr(drv, new_addr) < 0) {
9134 nl80211_remove_iface(drv, ifidx);
9137 if (linux_set_ifhwaddr(drv->global->ioctl_sock, ifname,
9139 nl80211_remove_iface(drv, ifidx);
9149 i802_check_bridge(drv, new_bss, bridge, ifname) < 0) {
9152 nl80211_remove_iface(drv, ifidx);
9158 if (linux_set_iface_flags(drv->global->ioctl_sock, ifname, 1))
9160 nl80211_remove_iface(drv, ifidx);
9167 new_bss->drv = drv;
9168 new_bss->next = drv->first_bss.next;
9169 new_bss->freq = drv->first_bss.freq;
9171 drv->first_bss.next = new_bss;
9182 if (drv->global)
9183 drv->global->if_add_ifindex = ifidx;
9193 struct wpa_driver_nl80211_data *drv = bss->drv;
9201 nl80211_remove_iface(drv, ifindex);
9208 if (linux_br_del_if(drv->global->ioctl_sock, bss->brname,
9215 if (linux_br_del(drv->global->ioctl_sock, bss->brname) < 0)
9221 if (bss != &drv->first_bss) {
9224 for (tbss = &drv->first_bss; tbss; tbss = tbss->next) {
9264 struct wpa_driver_nl80211_data *drv = bss->drv;
9277 nl80211_cmd(drv, msg, 0, NL80211_CMD_FRAME);
9285 if (offchanok && (drv->capa.flags & WPA_DRIVER_FLAGS_OFFCHANNEL_TX))
9295 ret = send_and_recv_msgs(drv, msg, cookie_handler, &cookie);
9324 struct wpa_driver_nl80211_data *drv = bss->drv;
9331 drv->ifindex, freq, wait_time, no_cck);
9344 if (is_ap_interface(drv->nlmode))
9351 &drv->send_action_cookie,
9362 struct wpa_driver_nl80211_data *drv = bss->drv;
9371 (long long unsigned int) drv->send_action_cookie);
9372 nl80211_cmd(drv, msg, 0, NL80211_CMD_FRAME_WAIT_CANCEL);
9376 NLA_PUT_U64(msg, NL80211_ATTR_COOKIE, drv->send_action_cookie);
9378 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
9393 struct wpa_driver_nl80211_data *drv = bss->drv;
9402 nl80211_cmd(drv, msg, 0, NL80211_CMD_REMAIN_ON_CHANNEL);
9411 ret = send_and_recv_msgs(drv, msg, cookie_handler, &cookie);
9417 drv->remain_on_chan_cookie = cookie;
9418 drv->pending_remain_on_chan = 1;
9433 struct wpa_driver_nl80211_data *drv = bss->drv;
9437 if (!drv->pending_remain_on_chan) {
9445 (long long unsigned int) drv->remain_on_chan_cookie);
9451 nl80211_cmd(drv, msg, 0, NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL);
9456 NLA_PUT_U64(msg, NL80211_ATTR_COOKIE, drv->remain_on_chan_cookie);
9458 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
9472 struct wpa_driver_nl80211_data *drv = bss->drv;
9475 if (bss->nl_preq && drv->device_ap_sme &&
9476 is_ap_interface(drv->nlmode)) {
9500 bss->nl_preq = nl_create_handle(drv->global->nl_cb, "preq");
9524 static int nl80211_disable_11b_rates(struct wpa_driver_nl80211_data *drv,
9535 nl80211_cmd(drv, msg, 0, NL80211_CMD_SET_TX_BITRATE_MASK);
9558 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
9564 drv->disabled_11b_rates = disabled;
9577 struct wpa_driver_nl80211_data *drv = bss->drv;
9578 if (!is_ap_interface(drv->nlmode))
9580 wpa_driver_nl80211_del_beacon(drv);
9586 if (drv->nlmode == NL80211_IFTYPE_P2P_GO && bss->if_dynamic)
9596 struct wpa_driver_nl80211_data *drv = bss->drv;
9597 if (!is_ap_interface(drv->nlmode))
9599 wpa_driver_nl80211_del_beacon(drv);
9608 struct wpa_driver_nl80211_data *drv = bss->drv;
9609 if (drv->nlmode != NL80211_IFTYPE_P2P_CLIENT)
9636 struct wpa_driver_nl80211_data *drv = bss->drv;
9670 ret = wpa_driver_nl80211_send_action(bss, drv->assoc_freq, 0,
9671 drv->bssid, own_addr, drv->bssid,
9682 struct wpa_driver_nl80211_data *drv = bss->drv;
9694 nl80211_cmd(drv, msg, 0, NL80211_CMD_SET_CQM);
9706 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
9764 static int nl80211_get_channel_width(struct wpa_driver_nl80211_data *drv,
9773 nl80211_cmd(drv, msg, 0, NL80211_CMD_GET_INTERFACE);
9774 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
9776 return send_and_recv_msgs(drv, msg, get_channel_width, sig);
9787 struct wpa_driver_nl80211_data *drv = bss->drv;
9791 res = nl80211_get_link_signal(drv, si);
9795 res = nl80211_get_channel_width(drv, si);
9799 return nl80211_get_link_noise(drv, si);
9806 struct wpa_driver_nl80211_data *drv = bss->drv;
9815 drv->phyname);
9817 dl_list_for_each(driver, &drv->global->interfaces,
9819 if (drv == driver ||
9820 os_strcmp(drv->phyname, driver->phyname) != 0 ||
9837 drv->phyname, freq);
9842 "PHY (%s) in associated state", drv->phyname);
9866 struct wpa_driver_nl80211_data *drv = bss->drv;
9870 drv->capa.flags |= WPA_DRIVER_FLAGS_P2P_CONCURRENT;
9871 drv->capa.flags |= WPA_DRIVER_FLAGS_P2P_MGMT_AND_NON_P2P;
9876 struct wpa_driver_nl80211_data *drv = bss->drv;
9877 drv->allow_p2p_device = 1;
9883 struct wpa_driver_nl80211_data *drv = bss->drv;
9886 drv->capa.num_multichan_concurrent = 2;
9971 struct wpa_driver_nl80211_data *drv = bss->drv;
9972 return drv->phyname;
9985 nl80211_cmd(bss->drv, msg, 0, cmd);
9993 return send_and_recv_msgs(bss->drv, msg, NULL, NULL);
10162 struct wpa_driver_nl80211_data *drv = bss->drv;
10177 nl80211_cmd(drv, msg, NLM_F_DUMP, NL80211_CMD_GET_SURVEY);
10179 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
10186 err = send_and_recv_msgs(drv, msg, survey_handler,
10195 wpa_supplicant_event(drv->ctx, EVENT_SURVEY, &data);
10208 struct wpa_driver_nl80211_data *drv = bss->drv;
10216 nl80211_cmd(drv, msg, 0, NL80211_CMD_SET_REKEY_OFFLOAD);
10231 send_and_recv_msgs(drv, msg, NULL, NULL);
10280 struct wpa_driver_nl80211_data *drv = bss->drv;
10283 if (!drv->poll_command_supported) {
10292 nl80211_cmd(drv, msg, 0, NL80211_CMD_PROBE_CLIENT);
10297 send_and_recv_msgs(drv, msg, NULL, NULL);
10312 nl80211_cmd(bss->drv, msg, 0, NL80211_CMD_SET_POWER_SAVE);
10316 return send_and_recv_msgs(bss->drv, msg, NULL, NULL);
10350 struct wpa_driver_nl80211_data *drv = bss->drv;
10355 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_RADAR)) {
10365 nl80211_cmd(bss->drv, msg, 0, NL80211_CMD_RADAR_DETECT);
10366 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
10372 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
10388 struct wpa_driver_nl80211_data *drv = bss->drv;
10391 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_TDLS_SUPPORT))
10401 nl80211_cmd(drv, msg, 0, NL80211_CMD_TDLS_MGMT);
10402 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
10409 return send_and_recv_msgs(drv, msg, NULL, NULL);
10420 struct wpa_driver_nl80211_data *drv = bss->drv;
10424 if (!(drv->capa.flags & WPA_DRIVER_FLAGS_TDLS_SUPPORT))
10455 nl80211_cmd(drv, msg, 0, NL80211_CMD_TDLS_OPER);
10457 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
10460 return send_and_recv_msgs(drv, msg, NULL, NULL);
10480 static void wpa_driver_send_hang_msg(struct wpa_driver_nl80211_data *drv)
10485 wpa_msg(drv->ctx, MSG_INFO, WPA_EVENT_DRIVER_STATE "HANGED");
10492 struct wpa_driver_nl80211_data *drv = bss->drv;
10510 ret = ioctl(drv->global->ioctl_sock, SIOCDEVPRIVATE + 1, &ifr);
10514 wpa_driver_send_hang_msg(drv);
10526 struct wpa_driver_nl80211_data *drv = bss->drv;
10580 ret = ioctl(drv->global->ioctl_sock, SIOCDEVPRIVATE + 1, &ifr);
10585 wpa_driver_send_hang_msg(drv);
10715 struct wpa_driver_nl80211_data *drv = bss->drv;
10723 nl80211_cmd(drv, msg, 0, NL80211_CMD_UPDATE_FT_IES);
10724 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
10728 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
10745 struct wpa_driver_nl80211_data *drv = bss->drv;
10747 if (drv->nlmode != NL80211_IFTYPE_P2P_DEVICE)