2 * WPA Supplicant - driver interaction with Linux nl80211/cfg80211
3 * Copyright (c) 2003-2008, Jouni Malinen <j@w1.fi>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
9 * Alternatively, this software may be distributed under the terms of BSD
12 * See README and COPYING for more details.
16 #include <sys/ioctl.h>
17 #include <net/if_arp.h>
18 #include <netlink/genl/genl.h>
19 #include <netlink/genl/family.h>
20 #include <netlink/genl/ctrl.h>
21 #include "nl80211_copy.h"
22 #include "wireless_copy.h"
27 #include "ieee802_11_defs.h"
30 #define IFF_LOWER_UP 0x10000 /* driver signals L1 up */
33 #define IFF_DORMANT 0x20000 /* driver signals dormant */
36 #ifndef IF_OPER_DORMANT
37 #define IF_OPER_DORMANT 5
44 struct wpa_driver_nl80211_data {
48 char ifname[IFNAMSIZ + 1];
51 struct wpa_driver_capa capa;
56 int scan_complete_events;
58 struct nl_handle *nl_handle;
59 struct nl_cache *nl_cache;
61 struct genl_family *nl80211;
70 static void wpa_driver_nl80211_scan_timeout(void *eloop_ctx,
72 static int wpa_driver_nl80211_set_mode(struct wpa_driver_nl80211_data *drv,
75 wpa_driver_nl80211_finish_drv_init(struct wpa_driver_nl80211_data *drv);
79 static int ack_handler(struct nl_msg *msg, void *arg)
86 static int finish_handler(struct nl_msg *msg, void *arg)
93 static int error_handler(struct sockaddr_nl *nla, struct nlmsgerr *err,
101 static int send_and_recv_msgs(struct wpa_driver_nl80211_data *drv,
103 int (*valid_handler)(struct nl_msg *, void *),
109 cb = nl_cb_clone(drv->nl_cb);
113 err = nl_send_auto_complete(drv->nl_handle, msg);
119 nl_cb_err(cb, NL_CB_CUSTOM, error_handler, &err);
120 nl_cb_set(cb, NL_CB_FINISH, NL_CB_CUSTOM, finish_handler, &err);
121 nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, ack_handler, &err);
124 nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM,
125 valid_handler, valid_data);
128 nl_recvmsgs(drv->nl_handle, cb);
142 static int family_handler(struct nl_msg *msg, void *arg)
144 struct family_data *res = arg;
145 struct nlattr *tb[CTRL_ATTR_MAX + 1];
146 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
147 struct nlattr *mcgrp;
150 nla_parse(tb, CTRL_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
151 genlmsg_attrlen(gnlh, 0), NULL);
152 if (!tb[CTRL_ATTR_MCAST_GROUPS])
155 nla_for_each_nested(mcgrp, tb[CTRL_ATTR_MCAST_GROUPS], i) {
156 struct nlattr *tb2[CTRL_ATTR_MCAST_GRP_MAX + 1];
157 nla_parse(tb2, CTRL_ATTR_MCAST_GRP_MAX, nla_data(mcgrp),
158 nla_len(mcgrp), NULL);
159 if (!tb2[CTRL_ATTR_MCAST_GRP_NAME] ||
160 !tb2[CTRL_ATTR_MCAST_GRP_ID] ||
161 os_strncmp(nla_data(tb2[CTRL_ATTR_MCAST_GRP_NAME]),
163 nla_len(tb2[CTRL_ATTR_MCAST_GRP_NAME])) != 0)
165 res->id = nla_get_u32(tb2[CTRL_ATTR_MCAST_GRP_ID]);
173 static int nl_get_multicast_id(struct wpa_driver_nl80211_data *drv,
174 const char *family, const char *group)
178 struct family_data res = { group, -ENOENT };
183 genlmsg_put(msg, 0, 0, genl_ctrl_resolve(drv->nl_handle, "nlctrl"),
184 0, 0, CTRL_CMD_GETFAMILY, 0);
185 NLA_PUT_STRING(msg, CTRL_ATTR_FAMILY_NAME, family);
187 ret = send_and_recv_msgs(drv, msg, family_handler, &res);
198 static int wpa_driver_nl80211_send_oper_ifla(
199 struct wpa_driver_nl80211_data *drv,
200 int linkmode, int operstate)
204 struct ifinfomsg ifinfo;
211 os_memset(&req, 0, sizeof(req));
213 req.hdr.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
214 req.hdr.nlmsg_type = RTM_SETLINK;
215 req.hdr.nlmsg_flags = NLM_F_REQUEST;
216 req.hdr.nlmsg_seq = ++nl_seq;
217 req.hdr.nlmsg_pid = 0;
219 req.ifinfo.ifi_family = AF_UNSPEC;
220 req.ifinfo.ifi_type = 0;
221 req.ifinfo.ifi_index = drv->ifindex;
222 req.ifinfo.ifi_flags = 0;
223 req.ifinfo.ifi_change = 0;
225 if (linkmode != -1) {
226 rta = (struct rtattr *)
227 ((char *) &req + NLMSG_ALIGN(req.hdr.nlmsg_len));
228 rta->rta_type = IFLA_LINKMODE;
229 rta->rta_len = RTA_LENGTH(sizeof(char));
230 *((char *) RTA_DATA(rta)) = linkmode;
231 req.hdr.nlmsg_len = NLMSG_ALIGN(req.hdr.nlmsg_len) +
232 RTA_LENGTH(sizeof(char));
234 if (operstate != -1) {
235 rta = (struct rtattr *)
236 ((char *) &req + NLMSG_ALIGN(req.hdr.nlmsg_len));
237 rta->rta_type = IFLA_OPERSTATE;
238 rta->rta_len = RTA_LENGTH(sizeof(char));
239 *((char *) RTA_DATA(rta)) = operstate;
240 req.hdr.nlmsg_len = NLMSG_ALIGN(req.hdr.nlmsg_len) +
241 RTA_LENGTH(sizeof(char));
244 wpa_printf(MSG_DEBUG, "WEXT: Operstate: linkmode=%d, operstate=%d",
245 linkmode, operstate);
247 ret = send(drv->link_event_sock, &req, req.hdr.nlmsg_len, 0);
249 wpa_printf(MSG_DEBUG, "WEXT: Sending operstate IFLA failed: "
250 "%s (assume operstate is not supported)",
254 return ret < 0 ? -1 : 0;
258 static int wpa_driver_nl80211_set_auth_param(
259 struct wpa_driver_nl80211_data *drv, int idx, u32 value)
264 os_memset(&iwr, 0, sizeof(iwr));
265 os_strlcpy(iwr.ifr_name, drv->ifname, IFNAMSIZ);
266 iwr.u.param.flags = idx & IW_AUTH_INDEX;
267 iwr.u.param.value = value;
269 if (ioctl(drv->ioctl_sock, SIOCSIWAUTH, &iwr) < 0) {
270 if (errno != EOPNOTSUPP) {
271 wpa_printf(MSG_DEBUG, "WEXT: SIOCSIWAUTH(param %d "
272 "value 0x%x) failed: %s)",
273 idx, value, strerror(errno));
275 ret = errno == EOPNOTSUPP ? -2 : -1;
282 static int wpa_driver_nl80211_get_bssid(void *priv, u8 *bssid)
284 struct wpa_driver_nl80211_data *drv = priv;
285 if (!drv->associated)
287 os_memcpy(bssid, drv->bssid, ETH_ALEN);
292 static int wpa_driver_nl80211_get_ssid(void *priv, u8 *ssid)
294 struct wpa_driver_nl80211_data *drv = priv;
295 if (!drv->associated)
297 os_memcpy(ssid, drv->ssid, drv->ssid_len);
298 return drv->ssid_len;
302 static void wpa_driver_nl80211_event_link(struct wpa_driver_nl80211_data *drv,
303 void *ctx, char *buf, size_t len,
306 union wpa_event_data event;
308 os_memset(&event, 0, sizeof(event));
309 if (len > sizeof(event.interface_status.ifname))
310 len = sizeof(event.interface_status.ifname) - 1;
311 os_memcpy(event.interface_status.ifname, buf, len);
312 event.interface_status.ievent = del ? EVENT_INTERFACE_REMOVED :
313 EVENT_INTERFACE_ADDED;
315 wpa_printf(MSG_DEBUG, "RTM_%sLINK, IFLA_IFNAME: Interface '%s' %s",
317 event.interface_status.ifname,
318 del ? "removed" : "added");
320 if (os_strcmp(drv->ifname, event.interface_status.ifname) == 0) {
327 wpa_supplicant_event(ctx, EVENT_INTERFACE_STATUS, &event);
331 static int wpa_driver_nl80211_own_ifname(struct wpa_driver_nl80211_data *drv,
334 struct ifinfomsg *ifi;
335 int attrlen, _nlmsg_len, rta_len;
340 _nlmsg_len = NLMSG_ALIGN(sizeof(struct ifinfomsg));
342 attrlen = h->nlmsg_len - _nlmsg_len;
346 attr = (struct rtattr *) (((char *) ifi) + _nlmsg_len);
348 rta_len = RTA_ALIGN(sizeof(struct rtattr));
349 while (RTA_OK(attr, attrlen)) {
350 if (attr->rta_type == IFLA_IFNAME) {
351 if (os_strcmp(((char *) attr) + rta_len, drv->ifname)
357 attr = RTA_NEXT(attr, attrlen);
364 static int wpa_driver_nl80211_own_ifindex(struct wpa_driver_nl80211_data *drv,
365 int ifindex, struct nlmsghdr *h)
367 if (drv->ifindex == ifindex)
370 if (drv->if_removed && wpa_driver_nl80211_own_ifname(drv, h)) {
371 drv->ifindex = if_nametoindex(drv->ifname);
372 wpa_printf(MSG_DEBUG, "nl80211: Update ifindex for a removed "
374 wpa_driver_nl80211_finish_drv_init(drv);
382 static void wpa_driver_nl80211_event_rtm_newlink(struct wpa_driver_nl80211_data *drv,
383 void *ctx, struct nlmsghdr *h,
386 struct ifinfomsg *ifi;
387 int attrlen, _nlmsg_len, rta_len;
388 struct rtattr * attr;
390 if (len < sizeof(*ifi))
395 if (!wpa_driver_nl80211_own_ifindex(drv, ifi->ifi_index, h)) {
396 wpa_printf(MSG_DEBUG, "Ignore event for foreign ifindex %d",
401 wpa_printf(MSG_DEBUG, "RTM_NEWLINK: operstate=%d ifi_flags=0x%x "
403 drv->operstate, ifi->ifi_flags,
404 (ifi->ifi_flags & IFF_UP) ? "[UP]" : "",
405 (ifi->ifi_flags & IFF_RUNNING) ? "[RUNNING]" : "",
406 (ifi->ifi_flags & IFF_LOWER_UP) ? "[LOWER_UP]" : "",
407 (ifi->ifi_flags & IFF_DORMANT) ? "[DORMANT]" : "");
409 * Some drivers send the association event before the operup event--in
410 * this case, lifting operstate in wpa_driver_nl80211_set_operstate()
411 * fails. This will hit us when wpa_supplicant does not need to do
412 * IEEE 802.1X authentication
414 if (drv->operstate == 1 &&
415 (ifi->ifi_flags & (IFF_LOWER_UP | IFF_DORMANT)) == IFF_LOWER_UP &&
416 !(ifi->ifi_flags & IFF_RUNNING))
417 wpa_driver_nl80211_send_oper_ifla(drv, -1, IF_OPER_UP);
419 _nlmsg_len = NLMSG_ALIGN(sizeof(struct ifinfomsg));
421 attrlen = h->nlmsg_len - _nlmsg_len;
425 attr = (struct rtattr *) (((char *) ifi) + _nlmsg_len);
427 rta_len = RTA_ALIGN(sizeof(struct rtattr));
428 while (RTA_OK(attr, attrlen)) {
429 if (attr->rta_type == IFLA_IFNAME) {
430 wpa_driver_nl80211_event_link(
432 ((char *) attr) + rta_len,
433 attr->rta_len - rta_len, 0);
435 attr = RTA_NEXT(attr, attrlen);
440 static void wpa_driver_nl80211_event_rtm_dellink(struct wpa_driver_nl80211_data *drv,
441 void *ctx, struct nlmsghdr *h,
444 struct ifinfomsg *ifi;
445 int attrlen, _nlmsg_len, rta_len;
446 struct rtattr * attr;
448 if (len < sizeof(*ifi))
453 _nlmsg_len = NLMSG_ALIGN(sizeof(struct ifinfomsg));
455 attrlen = h->nlmsg_len - _nlmsg_len;
459 attr = (struct rtattr *) (((char *) ifi) + _nlmsg_len);
461 rta_len = RTA_ALIGN(sizeof(struct rtattr));
462 while (RTA_OK(attr, attrlen)) {
463 if (attr->rta_type == IFLA_IFNAME) {
464 wpa_driver_nl80211_event_link(
466 ((char *) attr) + rta_len,
467 attr->rta_len - rta_len, 1);
469 attr = RTA_NEXT(attr, attrlen);
474 static void wpa_driver_nl80211_event_receive_link(int sock, void *eloop_ctx,
479 struct sockaddr_nl from;
485 fromlen = sizeof(from);
486 left = recvfrom(sock, buf, sizeof(buf), MSG_DONTWAIT,
487 (struct sockaddr *) &from, &fromlen);
489 if (errno != EINTR && errno != EAGAIN)
490 perror("recvfrom(netlink)");
494 h = (struct nlmsghdr *) buf;
495 while (left >= (int) sizeof(*h)) {
499 plen = len - sizeof(*h);
500 if (len > left || plen < 0) {
501 wpa_printf(MSG_DEBUG, "Malformed netlink message: "
502 "len=%d left=%d plen=%d",
507 switch (h->nlmsg_type) {
509 wpa_driver_nl80211_event_rtm_newlink(eloop_ctx, sock_ctx,
513 wpa_driver_nl80211_event_rtm_dellink(eloop_ctx, sock_ctx,
518 len = NLMSG_ALIGN(len);
520 h = (struct nlmsghdr *) ((char *) h + len);
524 wpa_printf(MSG_DEBUG, "%d extra bytes in the end of netlink "
528 if (--max_events > 0) {
530 * Try to receive all events in one eloop call in order to
531 * limit race condition on cases where AssocInfo event, Assoc
532 * event, and EAPOL frames are received more or less at the
533 * same time. We want to process the event messages first
534 * before starting EAPOL processing.
541 static int no_seq_check(struct nl_msg *msg, void *arg)
547 static void mlme_event_auth(struct wpa_driver_nl80211_data *drv,
548 const u8 *frame, size_t len)
550 const struct ieee80211_mgmt *mgmt;
551 union wpa_event_data event;
553 mgmt = (const struct ieee80211_mgmt *) frame;
554 if (len < 24 + sizeof(mgmt->u.auth)) {
555 wpa_printf(MSG_DEBUG, "nl80211: Too short association event "
560 os_memset(&event, 0, sizeof(event));
561 os_memcpy(event.auth.peer, mgmt->sa, ETH_ALEN);
562 event.auth.auth_type = le_to_host16(mgmt->u.auth.auth_alg);
563 event.auth.status_code = le_to_host16(mgmt->u.auth.status_code);
564 if (len > 24 + sizeof(mgmt->u.auth)) {
565 event.auth.ies = mgmt->u.auth.variable;
566 event.auth.ies_len = len - 24 - sizeof(mgmt->u.auth);
569 wpa_supplicant_event(drv->ctx, EVENT_AUTH, &event);
573 static void mlme_event_assoc(struct wpa_driver_nl80211_data *drv,
574 const u8 *frame, size_t len)
576 const struct ieee80211_mgmt *mgmt;
577 union wpa_event_data event;
580 mgmt = (const struct ieee80211_mgmt *) frame;
581 if (len < 24 + sizeof(mgmt->u.assoc_resp)) {
582 wpa_printf(MSG_DEBUG, "nl80211: Too short association event "
587 status = le_to_host16(mgmt->u.assoc_resp.status_code);
588 if (status != WLAN_STATUS_SUCCESS) {
589 wpa_printf(MSG_DEBUG, "nl80211: Association failed: status "
591 /* TODO: notify SME so that things like SA Query and comeback
592 * time can be implemented */
597 os_memcpy(drv->bssid, mgmt->sa, ETH_ALEN);
599 os_memset(&event, 0, sizeof(event));
600 if (len > 24 + sizeof(mgmt->u.assoc_resp)) {
601 event.assoc_info.resp_ies = (u8 *) mgmt->u.assoc_resp.variable;
602 event.assoc_info.resp_ies_len =
603 len - 24 - sizeof(mgmt->u.assoc_req);
606 wpa_supplicant_event(drv->ctx, EVENT_ASSOC, &event);
610 static void mlme_event(struct wpa_driver_nl80211_data *drv,
611 enum nl80211_commands cmd, struct nlattr *frame)
614 wpa_printf(MSG_DEBUG, "nl80211: MLME event %d without frame "
619 wpa_printf(MSG_DEBUG, "nl80211: MLME event %d", cmd);
620 wpa_hexdump(MSG_MSGDUMP, "nl80211: MLME event frame",
621 nla_data(frame), nla_len(frame));
624 case NL80211_CMD_AUTHENTICATE:
625 mlme_event_auth(drv, nla_data(frame), nla_len(frame));
627 case NL80211_CMD_ASSOCIATE:
628 mlme_event_assoc(drv, nla_data(frame), nla_len(frame));
630 case NL80211_CMD_DEAUTHENTICATE:
632 wpa_supplicant_event(drv->ctx, EVENT_DEAUTH, NULL);
634 case NL80211_CMD_DISASSOCIATE:
636 wpa_supplicant_event(drv->ctx, EVENT_DISASSOC, NULL);
644 static int process_event(struct nl_msg *msg, void *arg)
646 struct wpa_driver_nl80211_data *drv = arg;
647 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
648 struct nlattr *tb[NL80211_ATTR_MAX + 1];
650 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
651 genlmsg_attrlen(gnlh, 0), NULL);
653 if (tb[NL80211_ATTR_IFINDEX]) {
654 int ifindex = nla_get_u32(tb[NL80211_ATTR_IFINDEX]);
655 if (ifindex != drv->ifindex) {
656 wpa_printf(MSG_DEBUG, "nl80211: Ignored event (cmd=%d)"
657 " for foreign interface (ifindex %d)",
664 case NL80211_CMD_NEW_SCAN_RESULTS:
665 wpa_printf(MSG_DEBUG, "nl80211: New scan results available");
666 drv->scan_complete_events = 1;
667 eloop_cancel_timeout(wpa_driver_nl80211_scan_timeout, drv,
669 wpa_supplicant_event(drv->ctx, EVENT_SCAN_RESULTS, NULL);
671 case NL80211_CMD_SCAN_ABORTED:
672 wpa_printf(MSG_DEBUG, "nl80211: Scan aborted");
674 * Need to indicate that scan results are available in order
675 * not to make wpa_supplicant stop its scanning.
677 eloop_cancel_timeout(wpa_driver_nl80211_scan_timeout, drv,
679 wpa_supplicant_event(drv->ctx, EVENT_SCAN_RESULTS, NULL);
681 case NL80211_CMD_AUTHENTICATE:
682 case NL80211_CMD_ASSOCIATE:
683 case NL80211_CMD_DEAUTHENTICATE:
684 case NL80211_CMD_DISASSOCIATE:
685 mlme_event(drv, gnlh->cmd, tb[NL80211_ATTR_FRAME]);
688 wpa_printf(MSG_DEBUG, "nl80211: Ignored unknown event "
689 "(cmd=%d)", gnlh->cmd);
697 static void wpa_driver_nl80211_event_receive(int sock, void *eloop_ctx,
701 struct wpa_driver_nl80211_data *drv = eloop_ctx;
703 wpa_printf(MSG_DEBUG, "nl80211: Event message available");
705 cb = nl_cb_clone(drv->nl_cb);
708 nl_cb_set(cb, NL_CB_SEQ_CHECK, NL_CB_CUSTOM, no_seq_check, NULL);
709 nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, process_event, drv);
710 nl_recvmsgs(drv->nl_handle, cb);
715 static int wpa_driver_nl80211_get_ifflags_ifname(struct wpa_driver_nl80211_data *drv,
716 const char *ifname, int *flags)
720 os_memset(&ifr, 0, sizeof(ifr));
721 os_strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
722 if (ioctl(drv->ioctl_sock, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
723 perror("ioctl[SIOCGIFFLAGS]");
726 *flags = ifr.ifr_flags & 0xffff;
732 * wpa_driver_nl80211_get_ifflags - Get interface flags (SIOCGIFFLAGS)
733 * @drv: driver_nl80211 private data
734 * @flags: Pointer to returned flags value
735 * Returns: 0 on success, -1 on failure
737 static int wpa_driver_nl80211_get_ifflags(struct wpa_driver_nl80211_data *drv,
740 return wpa_driver_nl80211_get_ifflags_ifname(drv, drv->ifname, flags);
744 static int wpa_driver_nl80211_set_ifflags_ifname(
745 struct wpa_driver_nl80211_data *drv,
746 const char *ifname, int flags)
750 os_memset(&ifr, 0, sizeof(ifr));
751 os_strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
752 ifr.ifr_flags = flags & 0xffff;
753 if (ioctl(drv->ioctl_sock, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
754 perror("SIOCSIFFLAGS");
762 * wpa_driver_nl80211_set_ifflags - Set interface flags (SIOCSIFFLAGS)
763 * @drv: driver_nl80211 private data
764 * @flags: New value for flags
765 * Returns: 0 on success, -1 on failure
767 static int wpa_driver_nl80211_set_ifflags(struct wpa_driver_nl80211_data *drv,
770 return wpa_driver_nl80211_set_ifflags_ifname(drv, drv->ifname, flags);
775 * wpa_driver_nl80211_set_country - ask nl80211 to set the regulatory domain
776 * @priv: driver_nl80211 private data
777 * @alpha2_arg: country to which to switch to
778 * Returns: 0 on success, -1 on failure
780 * This asks nl80211 to set the regulatory domain for given
781 * country ISO / IEC alpha2.
783 static int wpa_driver_nl80211_set_country(void *priv, const char *alpha2_arg)
785 struct wpa_driver_nl80211_data *drv = priv;
791 goto nla_put_failure;
793 alpha2[0] = alpha2_arg[0];
794 alpha2[1] = alpha2_arg[1];
797 genlmsg_put(msg, 0, 0, genl_family_get_id(drv->nl80211), 0,
798 0, NL80211_CMD_REQ_SET_REG, 0);
800 NLA_PUT_STRING(msg, NL80211_ATTR_REG_ALPHA2, alpha2);
801 if (send_and_recv_msgs(drv, msg, NULL, NULL))
809 struct wiphy_info_data {
815 static int wiphy_info_handler(struct nl_msg *msg, void *arg)
817 struct nlattr *tb[NL80211_ATTR_MAX + 1];
818 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
819 struct wiphy_info_data *info = arg;
821 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
822 genlmsg_attrlen(gnlh, 0), NULL);
824 if (tb[NL80211_ATTR_MAX_NUM_SCAN_SSIDS])
825 info->max_scan_ssids =
826 nla_get_u8(tb[NL80211_ATTR_MAX_NUM_SCAN_SSIDS]);
828 if (tb[NL80211_ATTR_SUPPORTED_IFTYPES]) {
829 struct nlattr *nl_mode;
831 nla_for_each_nested(nl_mode,
832 tb[NL80211_ATTR_SUPPORTED_IFTYPES], i) {
833 if (nl_mode->nla_type == NL80211_IFTYPE_AP) {
834 info->ap_supported = 1;
844 static int wpa_driver_nl80211_get_info(struct wpa_driver_nl80211_data *drv,
845 struct wiphy_info_data *info)
849 os_memset(info, 0, sizeof(*info));
854 genlmsg_put(msg, 0, 0, genl_family_get_id(drv->nl80211), 0,
855 0, NL80211_CMD_GET_WIPHY, 0);
857 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
859 if (send_and_recv_msgs(drv, msg, wiphy_info_handler, info) == 0)
868 static void wpa_driver_nl80211_capa(struct wpa_driver_nl80211_data *drv)
870 struct wiphy_info_data info;
871 if (wpa_driver_nl80211_get_info(drv, &info))
873 drv->has_capability = 1;
874 /* For now, assume TKIP, CCMP, WPA, WPA2 are supported */
875 drv->capa.key_mgmt = WPA_DRIVER_CAPA_KEY_MGMT_WPA |
876 WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK |
877 WPA_DRIVER_CAPA_KEY_MGMT_WPA2 |
878 WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK;
879 drv->capa.enc = WPA_DRIVER_CAPA_ENC_WEP40 |
880 WPA_DRIVER_CAPA_ENC_WEP104 |
881 WPA_DRIVER_CAPA_ENC_TKIP |
882 WPA_DRIVER_CAPA_ENC_CCMP;
884 drv->capa.max_scan_ssids = info.max_scan_ssids;
885 if (info.ap_supported)
886 drv->capa.flags |= WPA_DRIVER_FLAGS_AP;
891 * wpa_driver_nl80211_init - Initialize nl80211 driver interface
892 * @ctx: context to be used when calling wpa_supplicant functions,
893 * e.g., wpa_supplicant_event()
894 * @ifname: interface name, e.g., wlan0
895 * Returns: Pointer to private data, %NULL on failure
897 static void * wpa_driver_nl80211_init(void *ctx, const char *ifname)
900 struct sockaddr_nl local;
901 struct wpa_driver_nl80211_data *drv;
903 drv = os_zalloc(sizeof(*drv));
907 os_strlcpy(drv->ifname, ifname, sizeof(drv->ifname));
909 drv->nl_cb = nl_cb_alloc(NL_CB_DEFAULT);
910 if (drv->nl_cb == NULL) {
911 wpa_printf(MSG_ERROR, "nl80211: Failed to allocate netlink "
916 drv->nl_handle = nl_handle_alloc_cb(drv->nl_cb);
917 if (drv->nl_handle == NULL) {
918 wpa_printf(MSG_ERROR, "nl80211: Failed to allocate netlink "
923 if (genl_connect(drv->nl_handle)) {
924 wpa_printf(MSG_ERROR, "nl80211: Failed to connect to generic "
929 drv->nl_cache = genl_ctrl_alloc_cache(drv->nl_handle);
930 if (drv->nl_cache == NULL) {
931 wpa_printf(MSG_ERROR, "nl80211: Failed to allocate generic "
936 drv->nl80211 = genl_ctrl_search_by_name(drv->nl_cache, "nl80211");
937 if (drv->nl80211 == NULL) {
938 wpa_printf(MSG_ERROR, "nl80211: 'nl80211' generic netlink not "
943 ret = nl_get_multicast_id(drv, "nl80211", "scan");
945 ret = nl_socket_add_membership(drv->nl_handle, ret);
947 wpa_printf(MSG_ERROR, "nl80211: Could not add multicast "
948 "membership for scan events: %d (%s)",
949 ret, strerror(-ret));
953 ret = nl_get_multicast_id(drv, "nl80211", "mlme");
955 ret = nl_socket_add_membership(drv->nl_handle, ret);
957 wpa_printf(MSG_ERROR, "nl80211: Could not add multicast "
958 "membership for mlme events: %d (%s)",
959 ret, strerror(-ret));
962 drv->capa.flags |= WPA_DRIVER_FLAGS_SME;
964 eloop_register_read_sock(nl_socket_get_fd(drv->nl_handle),
965 wpa_driver_nl80211_event_receive, drv, ctx);
967 drv->ioctl_sock = socket(PF_INET, SOCK_DGRAM, 0);
968 if (drv->ioctl_sock < 0) {
969 perror("socket(PF_INET,SOCK_DGRAM)");
973 s = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
975 perror("socket(PF_NETLINK,SOCK_RAW,NETLINK_ROUTE)");
979 os_memset(&local, 0, sizeof(local));
980 local.nl_family = AF_NETLINK;
981 local.nl_groups = RTMGRP_LINK;
982 if (bind(s, (struct sockaddr *) &local, sizeof(local)) < 0) {
983 perror("bind(netlink)");
988 eloop_register_read_sock(s, wpa_driver_nl80211_event_receive_link, drv,
990 drv->link_event_sock = s;
992 if (wpa_driver_nl80211_finish_drv_init(drv))
998 eloop_unregister_read_sock(drv->link_event_sock);
999 close(drv->link_event_sock);
1001 close(drv->ioctl_sock);
1003 genl_family_put(drv->nl80211);
1005 nl_cache_free(drv->nl_cache);
1007 nl_handle_destroy(drv->nl_handle);
1009 nl_cb_put(drv->nl_cb);
1017 wpa_driver_nl80211_finish_drv_init(struct wpa_driver_nl80211_data *drv)
1021 drv->ifindex = if_nametoindex(drv->ifname);
1023 if (wpa_driver_nl80211_set_mode(drv, 0) < 0) {
1024 wpa_printf(MSG_DEBUG, "nl80211: Could not configure driver to "
1025 "use managed mode");
1028 if (wpa_driver_nl80211_get_ifflags(drv, &flags) != 0) {
1029 wpa_printf(MSG_ERROR, "Could not get interface '%s' flags",
1033 if (!(flags & IFF_UP)) {
1034 if (wpa_driver_nl80211_set_ifflags(drv, flags | IFF_UP) != 0) {
1035 wpa_printf(MSG_ERROR, "Could not set interface '%s' "
1041 wpa_driver_nl80211_capa(drv);
1043 wpa_driver_nl80211_send_oper_ifla(drv, 1, IF_OPER_DORMANT);
1050 * wpa_driver_nl80211_deinit - Deinitialize nl80211 driver interface
1051 * @priv: Pointer to private nl80211 data from wpa_driver_nl80211_init()
1053 * Shut down driver interface and processing of driver events. Free
1054 * private data buffer if one was allocated in wpa_driver_nl80211_init().
1056 static void wpa_driver_nl80211_deinit(void *priv)
1058 struct wpa_driver_nl80211_data *drv = priv;
1061 eloop_cancel_timeout(wpa_driver_nl80211_scan_timeout, drv, drv->ctx);
1063 wpa_driver_nl80211_set_auth_param(drv, IW_AUTH_DROP_UNENCRYPTED, 0);
1065 wpa_driver_nl80211_send_oper_ifla(priv, 0, IF_OPER_UP);
1067 eloop_unregister_read_sock(drv->link_event_sock);
1069 if (wpa_driver_nl80211_get_ifflags(drv, &flags) == 0)
1070 (void) wpa_driver_nl80211_set_ifflags(drv, flags & ~IFF_UP);
1071 wpa_driver_nl80211_set_mode(drv, 0);
1073 close(drv->link_event_sock);
1074 close(drv->ioctl_sock);
1076 eloop_unregister_read_sock(nl_socket_get_fd(drv->nl_handle));
1077 genl_family_put(drv->nl80211);
1078 nl_cache_free(drv->nl_cache);
1079 nl_handle_destroy(drv->nl_handle);
1080 nl_cb_put(drv->nl_cb);
1087 * wpa_driver_nl80211_scan_timeout - Scan timeout to report scan completion
1088 * @eloop_ctx: Unused
1089 * @timeout_ctx: ctx argument given to wpa_driver_nl80211_init()
1091 * This function can be used as registered timeout when starting a scan to
1092 * generate a scan completed event if the driver does not report this.
1094 static void wpa_driver_nl80211_scan_timeout(void *eloop_ctx, void *timeout_ctx)
1096 wpa_printf(MSG_DEBUG, "Scan timeout - try to get results");
1097 wpa_supplicant_event(timeout_ctx, EVENT_SCAN_RESULTS, NULL);
1102 * wpa_driver_nl80211_scan - Request the driver to initiate scan
1103 * @priv: Pointer to private wext data from wpa_driver_nl80211_init()
1104 * @params: Scan parameters
1105 * Returns: 0 on success, -1 on failure
1107 static int wpa_driver_nl80211_scan(void *priv,
1108 struct wpa_driver_scan_params *params)
1110 struct wpa_driver_nl80211_data *drv = priv;
1111 int ret = 0, timeout;
1112 struct nl_msg *msg, *ssids, *freqs;
1115 msg = nlmsg_alloc();
1116 ssids = nlmsg_alloc();
1117 freqs = nlmsg_alloc();
1118 if (!msg || !ssids || !freqs) {
1125 genlmsg_put(msg, 0, 0, genl_family_get_id(drv->nl80211), 0, 0,
1126 NL80211_CMD_TRIGGER_SCAN, 0);
1128 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
1130 for (i = 0; i < params->num_ssids; i++) {
1131 NLA_PUT(ssids, i + 1, params->ssids[i].ssid_len,
1132 params->ssids[i].ssid);
1134 if (params->num_ssids)
1135 nla_put_nested(msg, NL80211_ATTR_SCAN_SSIDS, ssids);
1137 if (params->extra_ies) {
1138 NLA_PUT(msg, NL80211_ATTR_IE, params->extra_ies_len,
1142 if (params->freqs) {
1143 for (i = 0; params->freqs[i]; i++)
1144 NLA_PUT_U32(freqs, i + 1, params->freqs[i]);
1145 nla_put_nested(msg, NL80211_ATTR_SCAN_FREQUENCIES, freqs);
1148 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
1151 wpa_printf(MSG_DEBUG, "nl80211: Scan trigger failed: ret=%d "
1152 "(%s)", ret, strerror(-ret));
1153 goto nla_put_failure;
1156 /* Not all drivers generate "scan completed" wireless event, so try to
1157 * read results after a timeout. */
1159 if (drv->scan_complete_events) {
1161 * The driver seems to deliver events to notify when scan is
1162 * complete, so use longer timeout to avoid race conditions
1163 * with scanning and following association request.
1167 wpa_printf(MSG_DEBUG, "Scan requested (ret=%d) - scan timeout %d "
1168 "seconds", ret, timeout);
1169 eloop_cancel_timeout(wpa_driver_nl80211_scan_timeout, drv, drv->ctx);
1170 eloop_register_timeout(timeout, 0, wpa_driver_nl80211_scan_timeout,
1181 static int bss_info_handler(struct nl_msg *msg, void *arg)
1183 struct nlattr *tb[NL80211_ATTR_MAX + 1];
1184 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
1185 struct nlattr *bss[NL80211_BSS_MAX + 1];
1186 static struct nla_policy bss_policy[NL80211_BSS_MAX + 1] = {
1187 [NL80211_BSS_BSSID] = { .type = NLA_UNSPEC },
1188 [NL80211_BSS_FREQUENCY] = { .type = NLA_U32 },
1189 [NL80211_BSS_TSF] = { .type = NLA_U64 },
1190 [NL80211_BSS_BEACON_INTERVAL] = { .type = NLA_U16 },
1191 [NL80211_BSS_CAPABILITY] = { .type = NLA_U16 },
1192 [NL80211_BSS_INFORMATION_ELEMENTS] = { .type = NLA_UNSPEC },
1193 [NL80211_BSS_SIGNAL_MBM] = { .type = NLA_U32 },
1194 [NL80211_BSS_SIGNAL_UNSPEC] = { .type = NLA_U8 },
1196 struct wpa_scan_results *res = arg;
1197 struct wpa_scan_res **tmp;
1198 struct wpa_scan_res *r;
1202 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
1203 genlmsg_attrlen(gnlh, 0), NULL);
1204 if (!tb[NL80211_ATTR_BSS])
1206 if (nla_parse_nested(bss, NL80211_BSS_MAX, tb[NL80211_ATTR_BSS],
1209 if (bss[NL80211_BSS_INFORMATION_ELEMENTS]) {
1210 ie = nla_data(bss[NL80211_BSS_INFORMATION_ELEMENTS]);
1211 ie_len = nla_len(bss[NL80211_BSS_INFORMATION_ELEMENTS]);
1217 r = os_zalloc(sizeof(*r) + ie_len);
1220 if (bss[NL80211_BSS_BSSID])
1221 os_memcpy(r->bssid, nla_data(bss[NL80211_BSS_BSSID]),
1223 if (bss[NL80211_BSS_FREQUENCY])
1224 r->freq = nla_get_u32(bss[NL80211_BSS_FREQUENCY]);
1225 if (bss[NL80211_BSS_BEACON_INTERVAL])
1226 r->beacon_int = nla_get_u16(bss[NL80211_BSS_BEACON_INTERVAL]);
1227 if (bss[NL80211_BSS_CAPABILITY])
1228 r->caps = nla_get_u16(bss[NL80211_BSS_CAPABILITY]);
1229 r->flags |= WPA_SCAN_NOISE_INVALID;
1230 if (bss[NL80211_BSS_SIGNAL_MBM]) {
1231 r->level = nla_get_u32(bss[NL80211_BSS_SIGNAL_MBM]);
1232 r->level /= 100; /* mBm to dBm */
1233 r->flags |= WPA_SCAN_LEVEL_DBM | WPA_SCAN_QUAL_INVALID;
1234 } else if (bss[NL80211_BSS_SIGNAL_UNSPEC]) {
1235 r->level = nla_get_u8(bss[NL80211_BSS_SIGNAL_UNSPEC]);
1236 r->flags |= WPA_SCAN_LEVEL_INVALID;
1238 r->flags |= WPA_SCAN_LEVEL_INVALID | WPA_SCAN_QUAL_INVALID;
1239 if (bss[NL80211_BSS_TSF])
1240 r->tsf = nla_get_u64(bss[NL80211_BSS_TSF]);
1243 os_memcpy(r + 1, ie, ie_len);
1245 tmp = os_realloc(res->res,
1246 (res->num + 1) * sizeof(struct wpa_scan_res *));
1251 tmp[res->num++] = r;
1259 * wpa_driver_nl80211_get_scan_results - Fetch the latest scan results
1260 * @priv: Pointer to private wext data from wpa_driver_nl80211_init()
1261 * Returns: Scan results on success, -1 on failure
1263 static struct wpa_scan_results *
1264 wpa_driver_nl80211_get_scan_results(void *priv)
1266 struct wpa_driver_nl80211_data *drv = priv;
1268 struct wpa_scan_results *res;
1271 res = os_zalloc(sizeof(*res));
1274 msg = nlmsg_alloc();
1276 goto nla_put_failure;
1278 genlmsg_put(msg, 0, 0, genl_family_get_id(drv->nl80211), 0, NLM_F_DUMP,
1279 NL80211_CMD_GET_SCAN, 0);
1280 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
1282 ret = send_and_recv_msgs(drv, msg, bss_info_handler, res);
1285 wpa_printf(MSG_DEBUG, "Received scan results (%lu BSSes)",
1286 (unsigned long) res->num);
1289 wpa_printf(MSG_DEBUG, "nl80211: Scan result fetch failed: ret=%d "
1290 "(%s)", ret, strerror(-ret));
1293 wpa_scan_results_free(res);
1298 static int wpa_driver_nl80211_set_key(void *priv, wpa_alg alg,
1299 const u8 *addr, int key_idx,
1300 int set_tx, const u8 *seq,
1302 const u8 *key, size_t key_len)
1304 struct wpa_driver_nl80211_data *drv = priv;
1308 wpa_printf(MSG_DEBUG, "%s: alg=%d addr=%p key_idx=%d set_tx=%d "
1309 "seq_len=%lu key_len=%lu",
1310 __func__, alg, addr, key_idx, set_tx,
1311 (unsigned long) seq_len, (unsigned long) key_len);
1313 msg = nlmsg_alloc();
1317 if (alg == WPA_ALG_NONE) {
1318 genlmsg_put(msg, 0, 0, genl_family_get_id(drv->nl80211), 0, 0,
1319 NL80211_CMD_DEL_KEY, 0);
1321 genlmsg_put(msg, 0, 0, genl_family_get_id(drv->nl80211), 0, 0,
1322 NL80211_CMD_NEW_KEY, 0);
1323 NLA_PUT(msg, NL80211_ATTR_KEY_DATA, key_len, key);
1327 NLA_PUT_U32(msg, NL80211_ATTR_KEY_CIPHER,
1330 NLA_PUT_U32(msg, NL80211_ATTR_KEY_CIPHER,
1334 NLA_PUT_U32(msg, NL80211_ATTR_KEY_CIPHER, 0x000FAC02);
1337 NLA_PUT_U32(msg, NL80211_ATTR_KEY_CIPHER, 0x000FAC04);
1345 if (addr && os_memcmp(addr, "\xff\xff\xff\xff\xff\xff", ETH_ALEN) != 0)
1347 wpa_printf(MSG_DEBUG, " addr=" MACSTR, MAC2STR(addr));
1348 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, addr);
1350 NLA_PUT_U8(msg, NL80211_ATTR_KEY_IDX, key_idx);
1351 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
1353 err = send_and_recv_msgs(drv, msg, NULL, NULL);
1355 wpa_printf(MSG_DEBUG, "nl80211: set_key failed; err=%d", err);
1359 if (set_tx && alg != WPA_ALG_NONE) {
1360 msg = nlmsg_alloc();
1364 genlmsg_put(msg, 0, 0, genl_family_get_id(drv->nl80211), 0,
1365 0, NL80211_CMD_SET_KEY, 0);
1366 NLA_PUT_U8(msg, NL80211_ATTR_KEY_IDX, key_idx);
1367 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
1368 NLA_PUT_FLAG(msg, NL80211_ATTR_KEY_DEFAULT);
1370 err = send_and_recv_msgs(drv, msg, NULL, NULL);
1372 wpa_printf(MSG_DEBUG, "nl80211: set default key "
1373 "failed; err=%d", err);
1385 static int wpa_driver_nl80211_mlme(struct wpa_driver_nl80211_data *drv,
1386 const u8 *addr, int cmd, u16 reason_code)
1391 msg = nlmsg_alloc();
1395 genlmsg_put(msg, 0, 0, genl_family_get_id(drv->nl80211), 0, 0, cmd, 0);
1397 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
1398 NLA_PUT_U16(msg, NL80211_ATTR_REASON_CODE, reason_code);
1399 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, addr);
1401 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
1404 wpa_printf(MSG_DEBUG, "nl80211: MLME command failed: ret=%d "
1405 "(%s)", ret, strerror(-ret));
1406 goto nla_put_failure;
1416 static int wpa_driver_nl80211_deauthenticate(void *priv, const u8 *addr,
1419 struct wpa_driver_nl80211_data *drv = priv;
1420 wpa_printf(MSG_DEBUG, "%s", __func__);
1421 return wpa_driver_nl80211_mlme(drv, addr, NL80211_CMD_DEAUTHENTICATE,
1426 static int wpa_driver_nl80211_disassociate(void *priv, const u8 *addr,
1429 struct wpa_driver_nl80211_data *drv = priv;
1430 wpa_printf(MSG_DEBUG, "%s", __func__);
1431 return wpa_driver_nl80211_mlme(drv, addr, NL80211_CMD_DISASSOCIATE,
1436 static int wpa_driver_nl80211_authenticate(
1437 void *priv, struct wpa_driver_auth_params *params)
1439 struct wpa_driver_nl80211_data *drv = priv;
1442 enum nl80211_auth_type type;
1444 drv->associated = 0;
1446 msg = nlmsg_alloc();
1450 wpa_printf(MSG_DEBUG, "nl80211: Authenticate (ifindex=%d)",
1452 genlmsg_put(msg, 0, 0, genl_family_get_id(drv->nl80211), 0, 0,
1453 NL80211_CMD_AUTHENTICATE, 0);
1455 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
1456 if (params->bssid) {
1457 wpa_printf(MSG_DEBUG, " * bssid=" MACSTR,
1458 MAC2STR(params->bssid));
1459 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, params->bssid);
1462 wpa_printf(MSG_DEBUG, " * freq=%d", params->freq);
1463 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_FREQ, params->freq);
1466 wpa_hexdump_ascii(MSG_DEBUG, " * SSID",
1467 params->ssid, params->ssid_len);
1468 NLA_PUT(msg, NL80211_ATTR_SSID, params->ssid_len,
1471 wpa_hexdump(MSG_DEBUG, " * IEs", params->ie, params->ie_len);
1473 NLA_PUT(msg, NL80211_ATTR_IE, params->ie_len, params->ie);
1475 * TODO: if multiple auth_alg options enabled, try them one by one if
1476 * the AP rejects authentication due to unknown auth alg
1478 if (params->auth_alg & AUTH_ALG_OPEN_SYSTEM)
1479 type = NL80211_AUTHTYPE_OPEN_SYSTEM;
1480 else if (params->auth_alg & AUTH_ALG_SHARED_KEY)
1481 type = NL80211_AUTHTYPE_SHARED_KEY;
1482 else if (params->auth_alg & AUTH_ALG_LEAP)
1483 type = NL80211_AUTHTYPE_NETWORK_EAP;
1484 else if (params->auth_alg & AUTH_ALG_FT)
1485 type = NL80211_AUTHTYPE_FT;
1487 goto nla_put_failure;
1488 wpa_printf(MSG_DEBUG, " * Auth Type %d", type);
1489 NLA_PUT_U32(msg, NL80211_ATTR_AUTH_TYPE, type);
1491 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
1494 wpa_printf(MSG_DEBUG, "nl80211: MLME command failed: ret=%d "
1495 "(%s)", ret, strerror(-ret));
1496 goto nla_put_failure;
1499 wpa_printf(MSG_DEBUG, "nl80211: Authentication request send "
1509 static int wpa_driver_nl80211_set_freq2(
1510 struct wpa_driver_nl80211_data *drv,
1511 struct wpa_driver_associate_params *params)
1515 msg = nlmsg_alloc();
1519 genlmsg_put(msg, 0, 0, genl_family_get_id(drv->nl80211), 0, 0,
1520 NL80211_CMD_SET_WIPHY, 0);
1522 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
1524 /* TODO: proper channel configuration */
1525 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_FREQ, 2437);
1527 if (send_and_recv_msgs(drv, msg, NULL, NULL) == 0)
1534 static int wpa_driver_nl80211_ap(struct wpa_driver_nl80211_data *drv,
1535 struct wpa_driver_associate_params *params)
1537 if (wpa_driver_nl80211_set_mode(drv, params->mode) ||
1538 wpa_driver_nl80211_set_freq2(drv, params))
1541 /* TODO: setup monitor interface (and add code somewhere to remove this
1542 * when AP mode is stopped; associate with mode != 2 or drv_deinit) */
1543 /* TODO: setup beacon */
1547 #endif /* CONFIG_AP */
1550 static int wpa_driver_nl80211_associate(
1551 void *priv, struct wpa_driver_associate_params *params)
1553 struct wpa_driver_nl80211_data *drv = priv;
1558 if (params->mode == 2)
1559 return wpa_driver_nl80211_ap(drv, params);
1560 #endif /* CONFIG_AP */
1562 wpa_driver_nl80211_set_auth_param(drv, IW_AUTH_DROP_UNENCRYPTED,
1563 params->drop_unencrypted);
1565 drv->associated = 0;
1567 msg = nlmsg_alloc();
1571 wpa_printf(MSG_DEBUG, "nl80211: Associate (ifindex=%d)",
1573 genlmsg_put(msg, 0, 0, genl_family_get_id(drv->nl80211), 0, 0,
1574 NL80211_CMD_ASSOCIATE, 0);
1576 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
1577 if (params->bssid) {
1578 wpa_printf(MSG_DEBUG, " * bssid=" MACSTR,
1579 MAC2STR(params->bssid));
1580 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, params->bssid);
1583 wpa_printf(MSG_DEBUG, " * freq=%d", params->freq);
1584 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_FREQ, params->freq);
1587 wpa_hexdump_ascii(MSG_DEBUG, " * SSID",
1588 params->ssid, params->ssid_len);
1589 NLA_PUT(msg, NL80211_ATTR_SSID, params->ssid_len,
1591 if (params->ssid_len > sizeof(drv->ssid))
1592 goto nla_put_failure;
1593 os_memcpy(drv->ssid, params->ssid, params->ssid_len);
1594 drv->ssid_len = params->ssid_len;
1596 wpa_hexdump(MSG_DEBUG, " * IEs", params->wpa_ie, params->wpa_ie_len);
1598 NLA_PUT(msg, NL80211_ATTR_IE, params->wpa_ie_len,
1601 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
1604 wpa_printf(MSG_DEBUG, "nl80211: MLME command failed: ret=%d "
1605 "(%s)", ret, strerror(-ret));
1606 goto nla_put_failure;
1609 wpa_printf(MSG_DEBUG, "nl80211: Association request send "
1619 * wpa_driver_nl80211_set_mode - Set wireless mode (infra/adhoc)
1620 * @drv: Pointer to private driver data from wpa_driver_nl80211_init()
1621 * @mode: 0 = infra/BSS (associate with an AP), 1 = adhoc/IBSS
1622 * Returns: 0 on success, -1 on failure
1624 static int wpa_driver_nl80211_set_mode(struct wpa_driver_nl80211_data *drv,
1627 int ret = -1, flags;
1633 nlmode = NL80211_IFTYPE_STATION;
1636 nlmode = NL80211_IFTYPE_ADHOC;
1639 nlmode = NL80211_IFTYPE_AP;
1645 msg = nlmsg_alloc();
1649 genlmsg_put(msg, 0, 0, genl_family_get_id(drv->nl80211), 0,
1650 0, NL80211_CMD_SET_INTERFACE, 0);
1651 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
1652 NLA_PUT_U32(msg, NL80211_ATTR_IFTYPE, nlmode);
1654 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
1661 wpa_printf(MSG_ERROR, "nl80211: Failed to set interface mode: %d (%s)",
1662 ret, strerror(-ret));
1666 /* mac80211 doesn't allow mode changes while the device is up, so
1667 * take the device down, try to set the mode again, and bring the
1670 if (wpa_driver_nl80211_get_ifflags(drv, &flags) == 0) {
1671 (void) wpa_driver_nl80211_set_ifflags(drv, flags & ~IFF_UP);
1673 /* Try to set the mode again while the interface is down */
1674 msg = nlmsg_alloc();
1678 genlmsg_put(msg, 0, 0, genl_family_get_id(drv->nl80211), 0,
1679 0, NL80211_CMD_SET_INTERFACE, 0);
1680 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
1681 NLA_PUT_U32(msg, NL80211_ATTR_IFTYPE, nlmode);
1682 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
1684 wpa_printf(MSG_ERROR, "Failed to set interface %s "
1685 "mode(try_again): %d (%s)",
1686 drv->ifname, ret, strerror(-ret));
1689 /* Ignore return value of get_ifflags to ensure that the device
1690 * is always up like it was before this function was called.
1692 (void) wpa_driver_nl80211_get_ifflags(drv, &flags);
1693 (void) wpa_driver_nl80211_set_ifflags(drv, flags | IFF_UP);
1700 static int wpa_driver_nl80211_get_capa(void *priv,
1701 struct wpa_driver_capa *capa)
1703 struct wpa_driver_nl80211_data *drv = priv;
1704 if (!drv->has_capability)
1706 os_memcpy(capa, &drv->capa, sizeof(*capa));
1711 static int wpa_driver_nl80211_set_operstate(void *priv, int state)
1713 struct wpa_driver_nl80211_data *drv = priv;
1715 wpa_printf(MSG_DEBUG, "%s: operstate %d->%d (%s)",
1716 __func__, drv->operstate, state, state ? "UP" : "DORMANT");
1717 drv->operstate = state;
1718 return wpa_driver_nl80211_send_oper_ifla(
1719 drv, -1, state ? IF_OPER_UP : IF_OPER_DORMANT);
1723 const struct wpa_driver_ops wpa_driver_nl80211_ops = {
1725 .desc = "Linux nl80211/cfg80211",
1726 .get_bssid = wpa_driver_nl80211_get_bssid,
1727 .get_ssid = wpa_driver_nl80211_get_ssid,
1728 .set_key = wpa_driver_nl80211_set_key,
1729 .scan2 = wpa_driver_nl80211_scan,
1730 .get_scan_results2 = wpa_driver_nl80211_get_scan_results,
1731 .deauthenticate = wpa_driver_nl80211_deauthenticate,
1732 .disassociate = wpa_driver_nl80211_disassociate,
1733 .authenticate = wpa_driver_nl80211_authenticate,
1734 .associate = wpa_driver_nl80211_associate,
1735 .init = wpa_driver_nl80211_init,
1736 .deinit = wpa_driver_nl80211_deinit,
1737 .get_capa = wpa_driver_nl80211_get_capa,
1738 .set_operstate = wpa_driver_nl80211_set_operstate,
1739 .set_country = wpa_driver_nl80211_set_country,