git.maemo.org Git - wpasupplicant/blob - src/drivers/driver_nl80211.c

   1 /*
   2  * WPA Supplicant - driver interaction with Linux nl80211/cfg80211
   3  * Copyright (c) 2003-2008, Jouni Malinen <j@w1.fi>
   4  *
   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.
   8  *
   9  * Alternatively, this software may be distributed under the terms of BSD
  10  * license.
  11  *
  12  * See README and COPYING for more details.
  13  */
  14
  15 #include "includes.h"
  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"
  23
  24 #include "common.h"
  25 #include "driver.h"
  26 #include "eloop.h"
  27 #include "ieee802_11_defs.h"
  28
  29 #ifndef IFF_LOWER_UP
  30 #define IFF_LOWER_UP   0x10000         /* driver signals L1 up         */
  31 #endif
  32 #ifndef IFF_DORMANT
  33 #define IFF_DORMANT    0x20000         /* driver signals dormant       */
  34 #endif
  35
  36 #ifndef IF_OPER_DORMANT
  37 #define IF_OPER_DORMANT 5
  38 #endif
  39 #ifndef IF_OPER_UP
  40 #define IF_OPER_UP 6
  41 #endif
  42
  43
  44 struct wpa_driver_nl80211_data {
  45         void *ctx;
  46         int link_event_sock;
  47         int ioctl_sock;
  48         char ifname[IFNAMSIZ + 1];
  49         int ifindex;
  50         int if_removed;
  51         struct wpa_driver_capa capa;
  52         int has_capability;
  53
  54         int operstate;
  55
  56         int scan_complete_events;
  57
  58         struct nl_handle *nl_handle;
  59         struct nl_cache *nl_cache;
  60         struct nl_cb *nl_cb;
  61         struct genl_family *nl80211;
  62
  63         u8 bssid[ETH_ALEN];
  64         int associated;
  65         u8 ssid[32];
  66         size_t ssid_len;
  67 };
  68
  69
  70 static void wpa_driver_nl80211_scan_timeout(void *eloop_ctx,
  71                                             void *timeout_ctx);
  72 static int wpa_driver_nl80211_set_mode(struct wpa_driver_nl80211_data *drv,
  73                                        int mode);
  74 static int wpa_driver_nl80211_get_range(void *priv);
  75 static int
  76 wpa_driver_nl80211_finish_drv_init(struct wpa_driver_nl80211_data *drv);
  77
  78
  79 /* nl80211 code */
  80 static int ack_handler(struct nl_msg *msg, void *arg)
  81 {
  82         int *err = arg;
  83         *err = 0;
  84         return NL_STOP;
  85 }
  86
  87 static int finish_handler(struct nl_msg *msg, void *arg)
  88 {
  89         int *ret = arg;
  90         *ret = 0;
  91         return NL_SKIP;
  92 }
  93
  94 static int error_handler(struct sockaddr_nl *nla, struct nlmsgerr *err,
  95                          void *arg)
  96 {
  97         int *ret = arg;
  98         *ret = err->error;
  99         return NL_SKIP;
 100 }
 101
 102 static int send_and_recv_msgs(struct wpa_driver_nl80211_data *drv,
 103                               struct nl_msg *msg,
 104                               int (*valid_handler)(struct nl_msg *, void *),
 105                               void *valid_data)
 106 {
 107         struct nl_cb *cb;
 108         int err = -ENOMEM;
 109
 110         cb = nl_cb_clone(drv->nl_cb);
 111         if (!cb)
 112                 goto out;
 113
 114         err = nl_send_auto_complete(drv->nl_handle, msg);
 115         if (err < 0)
 116                 goto out;
 117
 118         err = 1;
 119
 120         nl_cb_err(cb, NL_CB_CUSTOM, error_handler, &err);
 121         nl_cb_set(cb, NL_CB_FINISH, NL_CB_CUSTOM, finish_handler, &err);
 122         nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, ack_handler, &err);
 123
 124         if (valid_handler)
 125                 nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM,
 126                           valid_handler, valid_data);
 127
 128         while (err > 0)
 129                 nl_recvmsgs(drv->nl_handle, cb);
 130  out:
 131         nl_cb_put(cb);
 132         nlmsg_free(msg);
 133         return err;
 134 }
 135
 136
 137 struct family_data {
 138         const char *group;
 139         int id;
 140 };
 141
 142
 143 static int family_handler(struct nl_msg *msg, void *arg)
 144 {
 145         struct family_data *res = arg;
 146         struct nlattr *tb[CTRL_ATTR_MAX + 1];
 147         struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
 148         struct nlattr *mcgrp;
 149         int i;
 150
 151         nla_parse(tb, CTRL_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
 152                   genlmsg_attrlen(gnlh, 0), NULL);
 153         if (!tb[CTRL_ATTR_MCAST_GROUPS])
 154                 return NL_SKIP;
 155
 156         nla_for_each_nested(mcgrp, tb[CTRL_ATTR_MCAST_GROUPS], i) {
 157                 struct nlattr *tb2[CTRL_ATTR_MCAST_GRP_MAX + 1];
 158                 nla_parse(tb2, CTRL_ATTR_MCAST_GRP_MAX, nla_data(mcgrp),
 159                           nla_len(mcgrp), NULL);
 160                 if (!tb2[CTRL_ATTR_MCAST_GRP_NAME] ||
 161                     !tb2[CTRL_ATTR_MCAST_GRP_ID] ||
 162                     os_strncmp(nla_data(tb2[CTRL_ATTR_MCAST_GRP_NAME]),
 163                                res->group,
 164                                nla_len(tb2[CTRL_ATTR_MCAST_GRP_NAME])) != 0)
 165                         continue;
 166                 res->id = nla_get_u32(tb2[CTRL_ATTR_MCAST_GRP_ID]);
 167                 break;
 168         };
 169
 170         return NL_SKIP;
 171 }
 172
 173
 174 static int nl_get_multicast_id(struct wpa_driver_nl80211_data *drv,
 175                                const char *family, const char *group)
 176 {
 177         struct nl_msg *msg;
 178         int ret = -1;
 179         struct family_data res = { group, -ENOENT };
 180
 181         msg = nlmsg_alloc();
 182         if (!msg)
 183                 return -ENOMEM;
 184         genlmsg_put(msg, 0, 0, genl_ctrl_resolve(drv->nl_handle, "nlctrl"),
 185                     0, 0, CTRL_CMD_GETFAMILY, 0);
 186         NLA_PUT_STRING(msg, CTRL_ATTR_FAMILY_NAME, family);
 187
 188         ret = send_and_recv_msgs(drv, msg, family_handler, &res);
 189         msg = NULL;
 190         if (ret == 0)
 191                 ret = res.id;
 192
 193 nla_put_failure:
 194         nlmsg_free(msg);
 195         return ret;
 196 }
 197
 198
 199 static int wpa_driver_nl80211_send_oper_ifla(
 200         struct wpa_driver_nl80211_data *drv,
 201         int linkmode, int operstate)
 202 {
 203         struct {
 204                 struct nlmsghdr hdr;
 205                 struct ifinfomsg ifinfo;
 206                 char opts[16];
 207         } req;
 208         struct rtattr *rta;
 209         static int nl_seq;
 210         ssize_t ret;
 211
 212         os_memset(&req, 0, sizeof(req));
 213
 214         req.hdr.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
 215         req.hdr.nlmsg_type = RTM_SETLINK;
 216         req.hdr.nlmsg_flags = NLM_F_REQUEST;
 217         req.hdr.nlmsg_seq = ++nl_seq;
 218         req.hdr.nlmsg_pid = 0;
 219
 220         req.ifinfo.ifi_family = AF_UNSPEC;
 221         req.ifinfo.ifi_type = 0;
 222         req.ifinfo.ifi_index = drv->ifindex;
 223         req.ifinfo.ifi_flags = 0;
 224         req.ifinfo.ifi_change = 0;
 225
 226         if (linkmode != -1) {
 227                 rta = (struct rtattr *)
 228                         ((char *) &req + NLMSG_ALIGN(req.hdr.nlmsg_len));
 229                 rta->rta_type = IFLA_LINKMODE;
 230                 rta->rta_len = RTA_LENGTH(sizeof(char));
 231                 *((char *) RTA_DATA(rta)) = linkmode;
 232                 req.hdr.nlmsg_len = NLMSG_ALIGN(req.hdr.nlmsg_len) +
 233                         RTA_LENGTH(sizeof(char));
 234         }
 235         if (operstate != -1) {
 236                 rta = (struct rtattr *)
 237                         ((char *) &req + NLMSG_ALIGN(req.hdr.nlmsg_len));
 238                 rta->rta_type = IFLA_OPERSTATE;
 239                 rta->rta_len = RTA_LENGTH(sizeof(char));
 240                 *((char *) RTA_DATA(rta)) = operstate;
 241                 req.hdr.nlmsg_len = NLMSG_ALIGN(req.hdr.nlmsg_len) +
 242                         RTA_LENGTH(sizeof(char));
 243         }
 244
 245         wpa_printf(MSG_DEBUG, "WEXT: Operstate: linkmode=%d, operstate=%d",
 246                    linkmode, operstate);
 247
 248         ret = send(drv->link_event_sock, &req, req.hdr.nlmsg_len, 0);
 249         if (ret < 0) {
 250                 wpa_printf(MSG_DEBUG, "WEXT: Sending operstate IFLA failed: "
 251                            "%s (assume operstate is not supported)",
 252                            strerror(errno));
 253         }
 254
 255         return ret < 0 ? -1 : 0;
 256 }
 257
 258
 259 static int wpa_driver_nl80211_set_auth_param(
 260         struct wpa_driver_nl80211_data *drv, int idx, u32 value)
 261 {
 262         struct iwreq iwr;
 263         int ret = 0;
 264
 265         os_memset(&iwr, 0, sizeof(iwr));
 266         os_strlcpy(iwr.ifr_name, drv->ifname, IFNAMSIZ);
 267         iwr.u.param.flags = idx & IW_AUTH_INDEX;
 268         iwr.u.param.value = value;
 269
 270         if (ioctl(drv->ioctl_sock, SIOCSIWAUTH, &iwr) < 0) {
 271                 if (errno != EOPNOTSUPP) {
 272                         wpa_printf(MSG_DEBUG, "WEXT: SIOCSIWAUTH(param %d "
 273                                    "value 0x%x) failed: %s)",
 274                                    idx, value, strerror(errno));
 275                 }
 276                 ret = errno == EOPNOTSUPP ? -2 : -1;
 277         }
 278
 279         return ret;
 280 }
 281
 282
 283 static int wpa_driver_nl80211_get_bssid(void *priv, u8 *bssid)
 284 {
 285         struct wpa_driver_nl80211_data *drv = priv;
 286         if (!drv->associated)
 287                 return -1;
 288         os_memcpy(bssid, drv->bssid, ETH_ALEN);
 289         return 0;
 290 }
 291
 292
 293 static int wpa_driver_nl80211_get_ssid(void *priv, u8 *ssid)
 294 {
 295         struct wpa_driver_nl80211_data *drv = priv;
 296         if (!drv->associated)
 297                 return -1;
 298         os_memcpy(ssid, drv->ssid, drv->ssid_len);
 299         return drv->ssid_len;
 300 }
 301
 302
 303 static void wpa_driver_nl80211_event_link(struct wpa_driver_nl80211_data *drv,
 304                                           void *ctx, char *buf, size_t len,
 305                                           int del)
 306 {
 307         union wpa_event_data event;
 308
 309         os_memset(&event, 0, sizeof(event));
 310         if (len > sizeof(event.interface_status.ifname))
 311                 len = sizeof(event.interface_status.ifname) - 1;
 312         os_memcpy(event.interface_status.ifname, buf, len);
 313         event.interface_status.ievent = del ? EVENT_INTERFACE_REMOVED :
 314                 EVENT_INTERFACE_ADDED;
 315
 316         wpa_printf(MSG_DEBUG, "RTM_%sLINK, IFLA_IFNAME: Interface '%s' %s",
 317                    del ? "DEL" : "NEW",
 318                    event.interface_status.ifname,
 319                    del ? "removed" : "added");
 320
 321         if (os_strcmp(drv->ifname, event.interface_status.ifname) == 0) {
 322                 if (del)
 323                         drv->if_removed = 1;
 324                 else
 325                         drv->if_removed = 0;
 326         }
 327
 328         wpa_supplicant_event(ctx, EVENT_INTERFACE_STATUS, &event);
 329 }
 330
 331
 332 static int wpa_driver_nl80211_own_ifname(struct wpa_driver_nl80211_data *drv,
 333                                          struct nlmsghdr *h)
 334 {
 335         struct ifinfomsg *ifi;
 336         int attrlen, _nlmsg_len, rta_len;
 337         struct rtattr *attr;
 338
 339         ifi = NLMSG_DATA(h);
 340
 341         _nlmsg_len = NLMSG_ALIGN(sizeof(struct ifinfomsg));
 342
 343         attrlen = h->nlmsg_len - _nlmsg_len;
 344         if (attrlen < 0)
 345                 return 0;
 346
 347         attr = (struct rtattr *) (((char *) ifi) + _nlmsg_len);
 348
 349         rta_len = RTA_ALIGN(sizeof(struct rtattr));
 350         while (RTA_OK(attr, attrlen)) {
 351                 if (attr->rta_type == IFLA_IFNAME) {
 352                         if (os_strcmp(((char *) attr) + rta_len, drv->ifname)
 353                             == 0)
 354                                 return 1;
 355                         else
 356                                 break;
 357                 }
 358                 attr = RTA_NEXT(attr, attrlen);
 359         }
 360
 361         return 0;
 362 }
 363
 364
 365 static int wpa_driver_nl80211_own_ifindex(struct wpa_driver_nl80211_data *drv,
 366                                           int ifindex, struct nlmsghdr *h)
 367 {
 368         if (drv->ifindex == ifindex)
 369                 return 1;
 370
 371         if (drv->if_removed && wpa_driver_nl80211_own_ifname(drv, h)) {
 372                 drv->ifindex = if_nametoindex(drv->ifname);
 373                 wpa_printf(MSG_DEBUG, "nl80211: Update ifindex for a removed "
 374                            "interface");
 375                 wpa_driver_nl80211_finish_drv_init(drv);
 376                 return 1;
 377         }
 378
 379         return 0;
 380 }
 381
 382
 383 static void wpa_driver_nl80211_event_rtm_newlink(struct wpa_driver_nl80211_data *drv,
 384                                               void *ctx, struct nlmsghdr *h,
 385                                               size_t len)
 386 {
 387         struct ifinfomsg *ifi;
 388         int attrlen, _nlmsg_len, rta_len;
 389         struct rtattr * attr;
 390
 391         if (len < sizeof(*ifi))
 392                 return;
 393
 394         ifi = NLMSG_DATA(h);
 395
 396         if (!wpa_driver_nl80211_own_ifindex(drv, ifi->ifi_index, h)) {
 397                 wpa_printf(MSG_DEBUG, "Ignore event for foreign ifindex %d",
 398                            ifi->ifi_index);
 399                 return;
 400         }
 401
 402         wpa_printf(MSG_DEBUG, "RTM_NEWLINK: operstate=%d ifi_flags=0x%x "
 403                    "(%s%s%s%s)",
 404                    drv->operstate, ifi->ifi_flags,
 405                    (ifi->ifi_flags & IFF_UP) ? "[UP]" : "",
 406                    (ifi->ifi_flags & IFF_RUNNING) ? "[RUNNING]" : "",
 407                    (ifi->ifi_flags & IFF_LOWER_UP) ? "[LOWER_UP]" : "",
 408                    (ifi->ifi_flags & IFF_DORMANT) ? "[DORMANT]" : "");
 409         /*
 410          * Some drivers send the association event before the operup event--in
 411          * this case, lifting operstate in wpa_driver_nl80211_set_operstate()
 412          * fails. This will hit us when wpa_supplicant does not need to do
 413          * IEEE 802.1X authentication
 414          */
 415         if (drv->operstate == 1 &&
 416             (ifi->ifi_flags & (IFF_LOWER_UP | IFF_DORMANT)) == IFF_LOWER_UP &&
 417             !(ifi->ifi_flags & IFF_RUNNING))
 418                 wpa_driver_nl80211_send_oper_ifla(drv, -1, IF_OPER_UP);
 419
 420         _nlmsg_len = NLMSG_ALIGN(sizeof(struct ifinfomsg));
 421
 422         attrlen = h->nlmsg_len - _nlmsg_len;
 423         if (attrlen < 0)
 424                 return;
 425
 426         attr = (struct rtattr *) (((char *) ifi) + _nlmsg_len);
 427
 428         rta_len = RTA_ALIGN(sizeof(struct rtattr));
 429         while (RTA_OK(attr, attrlen)) {
 430                 if (attr->rta_type == IFLA_IFNAME) {
 431                         wpa_driver_nl80211_event_link(
 432                                 drv, ctx,
 433                                 ((char *) attr) + rta_len,
 434                                 attr->rta_len - rta_len, 0);
 435                 }
 436                 attr = RTA_NEXT(attr, attrlen);
 437         }
 438 }
 439
 440
 441 static void wpa_driver_nl80211_event_rtm_dellink(struct wpa_driver_nl80211_data *drv,
 442                                               void *ctx, struct nlmsghdr *h,
 443                                               size_t len)
 444 {
 445         struct ifinfomsg *ifi;
 446         int attrlen, _nlmsg_len, rta_len;
 447         struct rtattr * attr;
 448
 449         if (len < sizeof(*ifi))
 450                 return;
 451
 452         ifi = NLMSG_DATA(h);
 453
 454         _nlmsg_len = NLMSG_ALIGN(sizeof(struct ifinfomsg));
 455
 456         attrlen = h->nlmsg_len - _nlmsg_len;
 457         if (attrlen < 0)
 458                 return;
 459
 460         attr = (struct rtattr *) (((char *) ifi) + _nlmsg_len);
 461
 462         rta_len = RTA_ALIGN(sizeof(struct rtattr));
 463         while (RTA_OK(attr, attrlen)) {
 464                 if (attr->rta_type == IFLA_IFNAME) {
 465                         wpa_driver_nl80211_event_link(
 466                                 drv, ctx,
 467                                 ((char *) attr) + rta_len,
 468                                 attr->rta_len - rta_len, 1);
 469                 }
 470                 attr = RTA_NEXT(attr, attrlen);
 471         }
 472 }
 473
 474
 475 static void wpa_driver_nl80211_event_receive_link(int sock, void *eloop_ctx,
 476                                                   void *sock_ctx)
 477 {
 478         char buf[8192];
 479         int left;
 480         struct sockaddr_nl from;
 481         socklen_t fromlen;
 482         struct nlmsghdr *h;
 483         int max_events = 10;
 484
 485 try_again:
 486         fromlen = sizeof(from);
 487         left = recvfrom(sock, buf, sizeof(buf), MSG_DONTWAIT,
 488                         (struct sockaddr *) &from, &fromlen);
 489         if (left < 0) {
 490                 if (errno != EINTR && errno != EAGAIN)
 491                         perror("recvfrom(netlink)");
 492                 return;
 493         }
 494
 495         h = (struct nlmsghdr *) buf;
 496         while (left >= (int) sizeof(*h)) {
 497                 int len, plen;
 498
 499                 len = h->nlmsg_len;
 500                 plen = len - sizeof(*h);
 501                 if (len > left || plen < 0) {
 502                         wpa_printf(MSG_DEBUG, "Malformed netlink message: "
 503                                    "len=%d left=%d plen=%d",
 504                                    len, left, plen);
 505                         break;
 506                 }
 507
 508                 switch (h->nlmsg_type) {
 509                 case RTM_NEWLINK:
 510                         wpa_driver_nl80211_event_rtm_newlink(eloop_ctx, sock_ctx,
 511                                                           h, plen);
 512                         break;
 513                 case RTM_DELLINK:
 514                         wpa_driver_nl80211_event_rtm_dellink(eloop_ctx, sock_ctx,
 515                                                           h, plen);
 516                         break;
 517                 }
 518
 519                 len = NLMSG_ALIGN(len);
 520                 left -= len;
 521                 h = (struct nlmsghdr *) ((char *) h + len);
 522         }
 523
 524         if (left > 0) {
 525                 wpa_printf(MSG_DEBUG, "%d extra bytes in the end of netlink "
 526                            "message", left);
 527         }
 528
 529         if (--max_events > 0) {
 530                 /*
 531                  * Try to receive all events in one eloop call in order to
 532                  * limit race condition on cases where AssocInfo event, Assoc
 533                  * event, and EAPOL frames are received more or less at the
 534                  * same time. We want to process the event messages first
 535                  * before starting EAPOL processing.
 536                  */
 537                 goto try_again;
 538         }
 539 }
 540
 541
 542 static int no_seq_check(struct nl_msg *msg, void *arg)
 543 {
 544         return NL_OK;
 545 }
 546
 547
 548 static void mlme_event_auth(struct wpa_driver_nl80211_data *drv,
 549                             const u8 *frame, size_t len)
 550 {
 551         const struct ieee80211_mgmt *mgmt;
 552         union wpa_event_data event;
 553
 554         mgmt = (const struct ieee80211_mgmt *) frame;
 555         if (len < 24 + sizeof(mgmt->u.auth)) {
 556                 wpa_printf(MSG_DEBUG, "nl80211: Too short association event "
 557                            "frame");
 558                 return;
 559         }
 560
 561         os_memset(&event, 0, sizeof(event));
 562         os_memcpy(event.auth.peer, mgmt->sa, ETH_ALEN);
 563         event.auth.auth_type = le_to_host16(mgmt->u.auth.auth_alg);
 564         event.auth.status_code = le_to_host16(mgmt->u.auth.status_code);
 565         if (len > 24 + sizeof(mgmt->u.auth)) {
 566                 event.auth.ies = mgmt->u.auth.variable;
 567                 event.auth.ies_len = len - 24 - sizeof(mgmt->u.auth);
 568         }
 569
 570         wpa_supplicant_event(drv->ctx, EVENT_AUTH, &event);
 571 }
 572
 573
 574 static void mlme_event_assoc(struct wpa_driver_nl80211_data *drv,
 575                             const u8 *frame, size_t len)
 576 {
 577         const struct ieee80211_mgmt *mgmt;
 578         union wpa_event_data event;
 579         u16 status;
 580
 581         mgmt = (const struct ieee80211_mgmt *) frame;
 582         if (len < 24 + sizeof(mgmt->u.assoc_resp)) {
 583                 wpa_printf(MSG_DEBUG, "nl80211: Too short association event "
 584                            "frame");
 585                 return;
 586         }
 587
 588         status = le_to_host16(mgmt->u.assoc_resp.status_code);
 589         if (status != WLAN_STATUS_SUCCESS) {
 590                 wpa_printf(MSG_DEBUG, "nl80211: Association failed: status "
 591                            "code %d", status);
 592                 /* TODO: notify SME so that things like SA Query and comeback
 593                  * time can be implemented */
 594                 return;
 595         }
 596
 597         drv->associated = 1;
 598         os_memcpy(drv->bssid, mgmt->sa, ETH_ALEN);
 599
 600         os_memset(&event, 0, sizeof(event));
 601         if (len > 24 + sizeof(mgmt->u.assoc_resp)) {
 602                 event.assoc_info.resp_ies = (u8 *) mgmt->u.assoc_resp.variable;
 603                 event.assoc_info.resp_ies_len =
 604                         len - 24 - sizeof(mgmt->u.assoc_req);
 605         }
 606
 607         wpa_supplicant_event(drv->ctx, EVENT_ASSOC, &event);
 608 }
 609
 610
 611 static void mlme_event(struct wpa_driver_nl80211_data *drv,
 612                        enum nl80211_commands cmd, struct nlattr *frame)
 613 {
 614         if (frame == NULL) {
 615                 wpa_printf(MSG_DEBUG, "nl80211: MLME event %d without frame "
 616                            "data", cmd);
 617                 return;
 618         }
 619
 620         wpa_printf(MSG_DEBUG, "nl80211: MLME event %d", cmd);
 621         wpa_hexdump(MSG_MSGDUMP, "nl80211: MLME event frame",
 622                     nla_data(frame), nla_len(frame));
 623
 624         switch (cmd) {
 625         case NL80211_CMD_AUTHENTICATE:
 626                 mlme_event_auth(drv, nla_data(frame), nla_len(frame));
 627                 break;
 628         case NL80211_CMD_ASSOCIATE:
 629                 mlme_event_assoc(drv, nla_data(frame), nla_len(frame));
 630                 break;
 631         case NL80211_CMD_DEAUTHENTICATE:
 632                 drv->associated = 0;
 633                 wpa_supplicant_event(drv->ctx, EVENT_DEAUTH, NULL);
 634                 break;
 635         case NL80211_CMD_DISASSOCIATE:
 636                 drv->associated = 0;
 637                 wpa_supplicant_event(drv->ctx, EVENT_DISASSOC, NULL);
 638                 break;
 639         default:
 640                 break;
 641         }
 642 }
 643
 644
 645 static int process_event(struct nl_msg *msg, void *arg)
 646 {
 647         struct wpa_driver_nl80211_data *drv = arg;
 648         struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
 649         struct nlattr *tb[NL80211_ATTR_MAX + 1];
 650
 651         nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
 652                   genlmsg_attrlen(gnlh, 0), NULL);
 653
 654         if (tb[NL80211_ATTR_IFINDEX]) {
 655                 int ifindex = nla_get_u32(tb[NL80211_ATTR_IFINDEX]);
 656                 if (ifindex != drv->ifindex) {
 657                         wpa_printf(MSG_DEBUG, "nl80211: Ignored event (cmd=%d)"
 658                                    " for foreign interface (ifindex %d)",
 659                                    gnlh->cmd, ifindex);
 660                         return NL_SKIP;
 661                 }
 662         }
 663
 664         switch (gnlh->cmd) {
 665         case NL80211_CMD_NEW_SCAN_RESULTS:
 666                 wpa_printf(MSG_DEBUG, "nl80211: New scan results available");
 667                 drv->scan_complete_events = 1;
 668                 eloop_cancel_timeout(wpa_driver_nl80211_scan_timeout, drv,
 669                                      drv->ctx);
 670                 wpa_supplicant_event(drv->ctx, EVENT_SCAN_RESULTS, NULL);
 671                 break;
 672         case NL80211_CMD_SCAN_ABORTED:
 673                 wpa_printf(MSG_DEBUG, "nl80211: Scan aborted");
 674                 /*
 675                  * Need to indicate that scan results are available in order
 676                  * not to make wpa_supplicant stop its scanning.
 677                  */
 678                 eloop_cancel_timeout(wpa_driver_nl80211_scan_timeout, drv,
 679                                      drv->ctx);
 680                 wpa_supplicant_event(drv->ctx, EVENT_SCAN_RESULTS, NULL);
 681                 break;
 682         case NL80211_CMD_AUTHENTICATE:
 683         case NL80211_CMD_ASSOCIATE:
 684         case NL80211_CMD_DEAUTHENTICATE:
 685         case NL80211_CMD_DISASSOCIATE:
 686                 mlme_event(drv, gnlh->cmd, tb[NL80211_ATTR_FRAME]);
 687                 break;
 688         default:
 689                 wpa_printf(MSG_DEBUG, "nl80211: Ignored unknown event "
 690                            "(cmd=%d)", gnlh->cmd);
 691                 break;
 692         }
 693
 694         return NL_SKIP;
 695 }
 696
 697
 698 static void wpa_driver_nl80211_event_receive(int sock, void *eloop_ctx,
 699                                              void *sock_ctx)
 700 {
 701         struct nl_cb *cb;
 702         struct wpa_driver_nl80211_data *drv = eloop_ctx;
 703
 704         wpa_printf(MSG_DEBUG, "nl80211: Event message available");
 705
 706         cb = nl_cb_clone(drv->nl_cb);
 707         if (!cb)
 708                 return;
 709         nl_cb_set(cb, NL_CB_SEQ_CHECK, NL_CB_CUSTOM, no_seq_check, NULL);
 710         nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, process_event, drv);
 711         nl_recvmsgs(drv->nl_handle, cb);
 712         nl_cb_put(cb);
 713 }
 714
 715
 716 static int wpa_driver_nl80211_get_ifflags_ifname(struct wpa_driver_nl80211_data *drv,
 717                                               const char *ifname, int *flags)
 718 {
 719         struct ifreq ifr;
 720
 721         os_memset(&ifr, 0, sizeof(ifr));
 722         os_strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
 723         if (ioctl(drv->ioctl_sock, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
 724                 perror("ioctl[SIOCGIFFLAGS]");
 725                 return -1;
 726         }
 727         *flags = ifr.ifr_flags & 0xffff;
 728         return 0;
 729 }
 730
 731
 732 /**
 733  * wpa_driver_nl80211_get_ifflags - Get interface flags (SIOCGIFFLAGS)
 734  * @drv: driver_nl80211 private data
 735  * @flags: Pointer to returned flags value
 736  * Returns: 0 on success, -1 on failure
 737  */
 738 static int wpa_driver_nl80211_get_ifflags(struct wpa_driver_nl80211_data *drv,
 739                                           int *flags)
 740 {
 741         return wpa_driver_nl80211_get_ifflags_ifname(drv, drv->ifname, flags);
 742 }
 743
 744
 745 static int wpa_driver_nl80211_set_ifflags_ifname(
 746         struct wpa_driver_nl80211_data *drv,
 747         const char *ifname, int flags)
 748 {
 749         struct ifreq ifr;
 750
 751         os_memset(&ifr, 0, sizeof(ifr));
 752         os_strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
 753         ifr.ifr_flags = flags & 0xffff;
 754         if (ioctl(drv->ioctl_sock, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
 755                 perror("SIOCSIFFLAGS");
 756                 return -1;
 757         }
 758         return 0;
 759 }
 760
 761
 762 /**
 763  * wpa_driver_nl80211_set_ifflags - Set interface flags (SIOCSIFFLAGS)
 764  * @drv: driver_nl80211 private data
 765  * @flags: New value for flags
 766  * Returns: 0 on success, -1 on failure
 767  */
 768 static int wpa_driver_nl80211_set_ifflags(struct wpa_driver_nl80211_data *drv,
 769                                           int flags)
 770 {
 771         return wpa_driver_nl80211_set_ifflags_ifname(drv, drv->ifname, flags);
 772 }
 773
 774
 775 /**
 776  * wpa_driver_nl80211_set_country - ask nl80211 to set the regulatory domain
 777  * @priv: driver_nl80211 private data
 778  * @alpha2_arg: country to which to switch to
 779  * Returns: 0 on success, -1 on failure
 780  *
 781  * This asks nl80211 to set the regulatory domain for given
 782  * country ISO / IEC alpha2.
 783  */
 784 static int wpa_driver_nl80211_set_country(void *priv, const char *alpha2_arg)
 785 {
 786         struct wpa_driver_nl80211_data *drv = priv;
 787         char alpha2[3];
 788         struct nl_msg *msg;
 789
 790         msg = nlmsg_alloc();
 791         if (!msg)
 792                 goto nla_put_failure;
 793
 794         alpha2[0] = alpha2_arg[0];
 795         alpha2[1] = alpha2_arg[1];
 796         alpha2[2] = '\0';
 797
 798         genlmsg_put(msg, 0, 0, genl_family_get_id(drv->nl80211), 0,
 799                     0, NL80211_CMD_REQ_SET_REG, 0);
 800
 801         NLA_PUT_STRING(msg, NL80211_ATTR_REG_ALPHA2, alpha2);
 802         if (send_and_recv_msgs(drv, msg, NULL, NULL))
 803                 return -EINVAL;
 804         return 0;
 805 nla_put_failure:
 806         return -EINVAL;
 807 }
 808
 809
 810 struct wiphy_info_data {
 811         int max_scan_ssids;
 812         int ap_supported;
 813 };
 814
 815
 816 static int wiphy_info_handler(struct nl_msg *msg, void *arg)
 817 {
 818         struct nlattr *tb[NL80211_ATTR_MAX + 1];
 819         struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
 820         struct wiphy_info_data *info = arg;
 821
 822         nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
 823                   genlmsg_attrlen(gnlh, 0), NULL);
 824
 825         if (tb[NL80211_ATTR_MAX_NUM_SCAN_SSIDS])
 826                 info->max_scan_ssids =
 827                         nla_get_u8(tb[NL80211_ATTR_MAX_NUM_SCAN_SSIDS]);
 828
 829         if (tb[NL80211_ATTR_SUPPORTED_IFTYPES]) {
 830                 struct nlattr *nl_mode;
 831                 int i;
 832                 nla_for_each_nested(nl_mode,
 833                                     tb[NL80211_ATTR_SUPPORTED_IFTYPES], i) {
 834                         if (nl_mode->nla_type == NL80211_IFTYPE_AP) {
 835                                 info->ap_supported = 1;
 836                                 break;
 837                         }
 838                 }
 839         }
 840
 841         return NL_SKIP;
 842 }
 843
 844
 845 static int wpa_driver_nl80211_get_info(struct wpa_driver_nl80211_data *drv,
 846                                        struct wiphy_info_data *info)
 847 {
 848         struct nl_msg *msg;
 849
 850         os_memset(info, 0, sizeof(*info));
 851         msg = nlmsg_alloc();
 852         if (!msg)
 853                 return -1;
 854
 855         genlmsg_put(msg, 0, 0, genl_family_get_id(drv->nl80211), 0,
 856                     0, NL80211_CMD_GET_WIPHY, 0);
 857
 858         NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
 859
 860         if (send_and_recv_msgs(drv, msg, wiphy_info_handler, info) == 0)
 861                 return 0;
 862         msg = NULL;
 863 nla_put_failure:
 864         nlmsg_free(msg);
 865         return -1;
 866 }
 867
 868
 869 static void wpa_driver_nl80211_capa(struct wpa_driver_nl80211_data *drv)
 870 {
 871         struct wiphy_info_data info;
 872         if (wpa_driver_nl80211_get_info(drv, &info))
 873                 return;
 874         drv->has_capability = 1;
 875         drv->capa.max_scan_ssids = info.max_scan_ssids;
 876         if (info.ap_supported)
 877                 drv->capa.flags |= WPA_DRIVER_FLAGS_AP;
 878 }
 879
 880
 881 /**
 882  * wpa_driver_nl80211_init - Initialize nl80211 driver interface
 883  * @ctx: context to be used when calling wpa_supplicant functions,
 884  * e.g., wpa_supplicant_event()
 885  * @ifname: interface name, e.g., wlan0
 886  * Returns: Pointer to private data, %NULL on failure
 887  */
 888 static void * wpa_driver_nl80211_init(void *ctx, const char *ifname)
 889 {
 890         int s, ret;
 891         struct sockaddr_nl local;
 892         struct wpa_driver_nl80211_data *drv;
 893
 894         drv = os_zalloc(sizeof(*drv));
 895         if (drv == NULL)
 896                 return NULL;
 897         drv->ctx = ctx;
 898         os_strlcpy(drv->ifname, ifname, sizeof(drv->ifname));
 899
 900         drv->nl_cb = nl_cb_alloc(NL_CB_DEFAULT);
 901         if (drv->nl_cb == NULL) {
 902                 wpa_printf(MSG_ERROR, "nl80211: Failed to allocate netlink "
 903                            "callbacks");
 904                 goto err1;
 905         }
 906
 907         drv->nl_handle = nl_handle_alloc_cb(drv->nl_cb);
 908         if (drv->nl_handle == NULL) {
 909                 wpa_printf(MSG_ERROR, "nl80211: Failed to allocate netlink "
 910                            "callbacks");
 911                 goto err2;
 912         }
 913
 914         if (genl_connect(drv->nl_handle)) {
 915                 wpa_printf(MSG_ERROR, "nl80211: Failed to connect to generic "
 916                            "netlink");
 917                 goto err3;
 918         }
 919
 920         drv->nl_cache = genl_ctrl_alloc_cache(drv->nl_handle);
 921         if (drv->nl_cache == NULL) {
 922                 wpa_printf(MSG_ERROR, "nl80211: Failed to allocate generic "
 923                            "netlink cache");
 924                 goto err3;
 925         }
 926
 927         drv->nl80211 = genl_ctrl_search_by_name(drv->nl_cache, "nl80211");
 928         if (drv->nl80211 == NULL) {
 929                 wpa_printf(MSG_ERROR, "nl80211: 'nl80211' generic netlink not "
 930                            "found");
 931                 goto err4;
 932         }
 933
 934         ret = nl_get_multicast_id(drv, "nl80211", "scan");
 935         if (ret >= 0)
 936                 ret = nl_socket_add_membership(drv->nl_handle, ret);
 937         if (ret < 0) {
 938                 wpa_printf(MSG_ERROR, "nl80211: Could not add multicast "
 939                            "membership for scan events: %d (%s)",
 940                            ret, strerror(-ret));
 941                 goto err4;
 942         }
 943
 944         ret = nl_get_multicast_id(drv, "nl80211", "mlme");
 945         if (ret >= 0)
 946                 ret = nl_socket_add_membership(drv->nl_handle, ret);
 947         if (ret < 0) {
 948                 wpa_printf(MSG_ERROR, "nl80211: Could not add multicast "
 949                            "membership for mlme events: %d (%s)",
 950                            ret, strerror(-ret));
 951                 goto err4;
 952         }
 953         drv->capa.flags |= WPA_DRIVER_FLAGS_SME;
 954
 955         eloop_register_read_sock(nl_socket_get_fd(drv->nl_handle),
 956                                  wpa_driver_nl80211_event_receive, drv, ctx);
 957
 958         drv->ioctl_sock = socket(PF_INET, SOCK_DGRAM, 0);
 959         if (drv->ioctl_sock < 0) {
 960                 perror("socket(PF_INET,SOCK_DGRAM)");
 961                 goto err5;
 962         }
 963
 964         s = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
 965         if (s < 0) {
 966                 perror("socket(PF_NETLINK,SOCK_RAW,NETLINK_ROUTE)");
 967                 goto err6;
 968         }
 969
 970         os_memset(&local, 0, sizeof(local));
 971         local.nl_family = AF_NETLINK;
 972         local.nl_groups = RTMGRP_LINK;
 973         if (bind(s, (struct sockaddr *) &local, sizeof(local)) < 0) {
 974                 perror("bind(netlink)");
 975                 close(s);
 976                 goto err6;
 977         }
 978
 979         eloop_register_read_sock(s, wpa_driver_nl80211_event_receive_link, drv,
 980                                  ctx);
 981         drv->link_event_sock = s;
 982
 983         if (wpa_driver_nl80211_finish_drv_init(drv))
 984                 goto err7;
 985
 986         return drv;
 987
 988 err7:
 989         eloop_unregister_read_sock(drv->link_event_sock);
 990         close(drv->link_event_sock);
 991 err6:
 992         close(drv->ioctl_sock);
 993 err5:
 994         genl_family_put(drv->nl80211);
 995 err4:
 996         nl_cache_free(drv->nl_cache);
 997 err3:
 998         nl_handle_destroy(drv->nl_handle);
 999 err2:
1000         nl_cb_put(drv->nl_cb);
1001 err1:
1002         os_free(drv);
1003         return NULL;
1004 }
1005
1006
1007 static int
1008 wpa_driver_nl80211_finish_drv_init(struct wpa_driver_nl80211_data *drv)
1009 {
1010         int flags;
1011
1012         drv->ifindex = if_nametoindex(drv->ifname);
1013
1014         if (wpa_driver_nl80211_set_mode(drv, 0) < 0) {
1015                 wpa_printf(MSG_DEBUG, "nl80211: Could not configure driver to "
1016                            "use managed mode");
1017         }
1018
1019         if (wpa_driver_nl80211_get_ifflags(drv, &flags) != 0) {
1020                 wpa_printf(MSG_ERROR, "Could not get interface '%s' flags",
1021                            drv->ifname);
1022                 return -1;
1023         }
1024         if (!(flags & IFF_UP)) {
1025                 if (wpa_driver_nl80211_set_ifflags(drv, flags | IFF_UP) != 0) {
1026                         wpa_printf(MSG_ERROR, "Could not set interface '%s' "
1027                                    "UP", drv->ifname);
1028                         return -1;
1029                 }
1030         }
1031
1032         wpa_driver_nl80211_get_range(drv);
1033
1034         wpa_driver_nl80211_capa(drv);
1035
1036         wpa_driver_nl80211_send_oper_ifla(drv, 1, IF_OPER_DORMANT);
1037
1038         return 0;
1039 }
1040
1041
1042 /**
1043  * wpa_driver_nl80211_deinit - Deinitialize nl80211 driver interface
1044  * @priv: Pointer to private nl80211 data from wpa_driver_nl80211_init()
1045  *
1046  * Shut down driver interface and processing of driver events. Free
1047  * private data buffer if one was allocated in wpa_driver_nl80211_init().
1048  */
1049 static void wpa_driver_nl80211_deinit(void *priv)
1050 {
1051         struct wpa_driver_nl80211_data *drv = priv;
1052         int flags;
1053
1054         eloop_cancel_timeout(wpa_driver_nl80211_scan_timeout, drv, drv->ctx);
1055
1056         wpa_driver_nl80211_set_auth_param(drv, IW_AUTH_DROP_UNENCRYPTED, 0);
1057
1058         wpa_driver_nl80211_send_oper_ifla(priv, 0, IF_OPER_UP);
1059
1060         eloop_unregister_read_sock(drv->link_event_sock);
1061
1062         if (wpa_driver_nl80211_get_ifflags(drv, &flags) == 0)
1063                 (void) wpa_driver_nl80211_set_ifflags(drv, flags & ~IFF_UP);
1064         wpa_driver_nl80211_set_mode(drv, 0);
1065
1066         close(drv->link_event_sock);
1067         close(drv->ioctl_sock);
1068
1069         eloop_unregister_read_sock(nl_socket_get_fd(drv->nl_handle));
1070         genl_family_put(drv->nl80211);
1071         nl_cache_free(drv->nl_cache);
1072         nl_handle_destroy(drv->nl_handle);
1073         nl_cb_put(drv->nl_cb);
1074
1075         os_free(drv);
1076 }
1077
1078
1079 /**
1080  * wpa_driver_nl80211_scan_timeout - Scan timeout to report scan completion
1081  * @eloop_ctx: Unused
1082  * @timeout_ctx: ctx argument given to wpa_driver_nl80211_init()
1083  *
1084  * This function can be used as registered timeout when starting a scan to
1085  * generate a scan completed event if the driver does not report this.
1086  */
1087 static void wpa_driver_nl80211_scan_timeout(void *eloop_ctx, void *timeout_ctx)
1088 {
1089         wpa_printf(MSG_DEBUG, "Scan timeout - try to get results");
1090         wpa_supplicant_event(timeout_ctx, EVENT_SCAN_RESULTS, NULL);
1091 }
1092
1093
1094 /**
1095  * wpa_driver_nl80211_scan - Request the driver to initiate scan
1096  * @priv: Pointer to private wext data from wpa_driver_nl80211_init()
1097  * @params: Scan parameters
1098  * Returns: 0 on success, -1 on failure
1099  */
1100 static int wpa_driver_nl80211_scan(void *priv,
1101                                    struct wpa_driver_scan_params *params)
1102 {
1103         struct wpa_driver_nl80211_data *drv = priv;
1104         int ret = 0, timeout;
1105         struct nl_msg *msg, *ssids, *freqs;
1106         size_t i;
1107
1108         msg = nlmsg_alloc();
1109         ssids = nlmsg_alloc();
1110         freqs = nlmsg_alloc();
1111         if (!msg || !ssids || !freqs) {
1112                 nlmsg_free(msg);
1113                 nlmsg_free(ssids);
1114                 nlmsg_free(freqs);
1115                 return -1;
1116         }
1117
1118         genlmsg_put(msg, 0, 0, genl_family_get_id(drv->nl80211), 0, 0,
1119                     NL80211_CMD_TRIGGER_SCAN, 0);
1120
1121         NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
1122
1123         for (i = 0; i < params->num_ssids; i++) {
1124                 NLA_PUT(ssids, i + 1, params->ssids[i].ssid_len,
1125                         params->ssids[i].ssid);
1126         }
1127         if (params->num_ssids)
1128                 nla_put_nested(msg, NL80211_ATTR_SCAN_SSIDS, ssids);
1129
1130         if (params->extra_ies) {
1131                 NLA_PUT(msg, NL80211_ATTR_IE, params->extra_ies_len,
1132                         params->extra_ies);
1133         }
1134
1135         if (params->freqs) {
1136                 for (i = 0; params->freqs[i]; i++)
1137                         NLA_PUT_U32(freqs, i + 1, params->freqs[i]);
1138                 nla_put_nested(msg, NL80211_ATTR_SCAN_FREQUENCIES, freqs);
1139         }
1140
1141         ret = send_and_recv_msgs(drv, msg, NULL, NULL);
1142         msg = NULL;
1143         if (ret) {
1144                 wpa_printf(MSG_DEBUG, "nl80211: Scan trigger failed: ret=%d "
1145                            "(%s)", ret, strerror(-ret));
1146                 goto nla_put_failure;
1147         }
1148
1149         /* Not all drivers generate "scan completed" wireless event, so try to
1150          * read results after a timeout. */
1151         timeout = 10;
1152         if (drv->scan_complete_events) {
1153                 /*
1154                  * The driver seems to deliver events to notify when scan is
1155                  * complete, so use longer timeout to avoid race conditions
1156                  * with scanning and following association request.
1157                  */
1158                 timeout = 30;
1159         }
1160         wpa_printf(MSG_DEBUG, "Scan requested (ret=%d) - scan timeout %d "
1161                    "seconds", ret, timeout);
1162         eloop_cancel_timeout(wpa_driver_nl80211_scan_timeout, drv, drv->ctx);
1163         eloop_register_timeout(timeout, 0, wpa_driver_nl80211_scan_timeout,
1164                                drv, drv->ctx);
1165
1166 nla_put_failure:
1167         nlmsg_free(ssids);
1168         nlmsg_free(msg);
1169         nlmsg_free(freqs);
1170         return ret;
1171 }
1172
1173
1174 static int bss_info_handler(struct nl_msg *msg, void *arg)
1175 {
1176         struct nlattr *tb[NL80211_ATTR_MAX + 1];
1177         struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
1178         struct nlattr *bss[NL80211_BSS_MAX + 1];
1179         static struct nla_policy bss_policy[NL80211_BSS_MAX + 1] = {
1180                 [NL80211_BSS_BSSID] = { .type = NLA_UNSPEC },
1181                 [NL80211_BSS_FREQUENCY] = { .type = NLA_U32 },
1182                 [NL80211_BSS_TSF] = { .type = NLA_U64 },
1183                 [NL80211_BSS_BEACON_INTERVAL] = { .type = NLA_U16 },
1184                 [NL80211_BSS_CAPABILITY] = { .type = NLA_U16 },
1185                 [NL80211_BSS_INFORMATION_ELEMENTS] = { .type = NLA_UNSPEC },
1186                 [NL80211_BSS_SIGNAL_MBM] = { .type = NLA_U32 },
1187                 [NL80211_BSS_SIGNAL_UNSPEC] = { .type = NLA_U8 },
1188         };
1189         struct wpa_scan_results *res = arg;
1190         struct wpa_scan_res **tmp;
1191         struct wpa_scan_res *r;
1192         const u8 *ie;
1193         size_t ie_len;
1194
1195         nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
1196                   genlmsg_attrlen(gnlh, 0), NULL);
1197         if (!tb[NL80211_ATTR_BSS])
1198                 return NL_SKIP;
1199         if (nla_parse_nested(bss, NL80211_BSS_MAX, tb[NL80211_ATTR_BSS],
1200                              bss_policy))
1201                 return NL_SKIP;
1202         if (bss[NL80211_BSS_INFORMATION_ELEMENTS]) {
1203                 ie = nla_data(bss[NL80211_BSS_INFORMATION_ELEMENTS]);
1204                 ie_len = nla_len(bss[NL80211_BSS_INFORMATION_ELEMENTS]);
1205         } else {
1206                 ie = NULL;
1207                 ie_len = 0;
1208         }
1209
1210         r = os_zalloc(sizeof(*r) + ie_len);
1211         if (r == NULL)
1212                 return NL_SKIP;
1213         if (bss[NL80211_BSS_BSSID])
1214                 os_memcpy(r->bssid, nla_data(bss[NL80211_BSS_BSSID]),
1215                           ETH_ALEN);
1216         if (bss[NL80211_BSS_FREQUENCY])
1217                 r->freq = nla_get_u32(bss[NL80211_BSS_FREQUENCY]);
1218         if (bss[NL80211_BSS_BEACON_INTERVAL])
1219                 r->beacon_int = nla_get_u16(bss[NL80211_BSS_BEACON_INTERVAL]);
1220         if (bss[NL80211_BSS_CAPABILITY])
1221                 r->caps = nla_get_u16(bss[NL80211_BSS_CAPABILITY]);
1222         r->flags |= WPA_SCAN_NOISE_INVALID;
1223         if (bss[NL80211_BSS_SIGNAL_MBM]) {
1224                 r->level = nla_get_u32(bss[NL80211_BSS_SIGNAL_MBM]);
1225                 r->level /= 100; /* mBm to dBm */
1226                 r->flags |= WPA_SCAN_LEVEL_DBM | WPA_SCAN_QUAL_INVALID;
1227         } else if (bss[NL80211_BSS_SIGNAL_UNSPEC]) {
1228                 r->level = nla_get_u8(bss[NL80211_BSS_SIGNAL_UNSPEC]);
1229                 r->flags |= WPA_SCAN_LEVEL_INVALID;
1230         } else
1231                 r->flags |= WPA_SCAN_LEVEL_INVALID | WPA_SCAN_QUAL_INVALID;
1232         if (bss[NL80211_BSS_TSF])
1233                 r->tsf = nla_get_u64(bss[NL80211_BSS_TSF]);
1234         r->ie_len = ie_len;
1235         if (ie)
1236                 os_memcpy(r + 1, ie, ie_len);
1237
1238         tmp = os_realloc(res->res,
1239                          (res->num + 1) * sizeof(struct wpa_scan_res *));
1240         if (tmp == NULL) {
1241                 os_free(r);
1242                 return NL_SKIP;
1243         }
1244         tmp[res->num++] = r;
1245         res->res = tmp;
1246
1247         return NL_SKIP;
1248 }
1249
1250
1251 /**
1252  * wpa_driver_nl80211_get_scan_results - Fetch the latest scan results
1253  * @priv: Pointer to private wext data from wpa_driver_nl80211_init()
1254  * Returns: Scan results on success, -1 on failure
1255  */
1256 static struct wpa_scan_results *
1257 wpa_driver_nl80211_get_scan_results(void *priv)
1258 {
1259         struct wpa_driver_nl80211_data *drv = priv;
1260         struct nl_msg *msg;
1261         struct wpa_scan_results *res;
1262         int ret;
1263
1264         res = os_zalloc(sizeof(*res));
1265         if (res == NULL)
1266                 return 0;
1267         msg = nlmsg_alloc();
1268         if (!msg)
1269                 goto nla_put_failure;
1270
1271         genlmsg_put(msg, 0, 0, genl_family_get_id(drv->nl80211), 0, NLM_F_DUMP,
1272                     NL80211_CMD_GET_SCAN, 0);
1273         NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
1274
1275         ret = send_and_recv_msgs(drv, msg, bss_info_handler, res);
1276         msg = NULL;
1277         if (ret == 0) {
1278                 wpa_printf(MSG_DEBUG, "Received scan results (%lu BSSes)",
1279                            (unsigned long) res->num);
1280                 return res;
1281         }
1282         wpa_printf(MSG_DEBUG, "nl80211: Scan result fetch failed: ret=%d "
1283                    "(%s)", ret, strerror(-ret));
1284 nla_put_failure:
1285         nlmsg_free(msg);
1286         wpa_scan_results_free(res);
1287         return NULL;
1288 }
1289
1290
1291 static int wpa_driver_nl80211_get_range(void *priv)
1292 {
1293         struct wpa_driver_nl80211_data *drv = priv;
1294         struct iw_range *range;
1295         struct iwreq iwr;
1296         int minlen;
1297         size_t buflen;
1298
1299         /*
1300          * Use larger buffer than struct iw_range in order to allow the
1301          * structure to grow in the future.
1302          */
1303         buflen = sizeof(struct iw_range) + 500;
1304         range = os_zalloc(buflen);
1305         if (range == NULL)
1306                 return -1;
1307
1308         os_memset(&iwr, 0, sizeof(iwr));
1309         os_strlcpy(iwr.ifr_name, drv->ifname, IFNAMSIZ);
1310         iwr.u.data.pointer = (caddr_t) range;
1311         iwr.u.data.length = buflen;
1312
1313         minlen = ((char *) &range->enc_capa) - (char *) range +
1314                 sizeof(range->enc_capa);
1315
1316         if (ioctl(drv->ioctl_sock, SIOCGIWRANGE, &iwr) < 0) {
1317                 perror("ioctl[SIOCGIWRANGE]");
1318                 os_free(range);
1319                 return -1;
1320         } else if (iwr.u.data.length >= minlen &&
1321                    range->we_version_compiled >= 18) {
1322                 wpa_printf(MSG_DEBUG, "SIOCGIWRANGE: WE(compiled)=%d "
1323                            "WE(source)=%d enc_capa=0x%x",
1324                            range->we_version_compiled,
1325                            range->we_version_source,
1326                            range->enc_capa);
1327                 drv->has_capability = 1;
1328                 if (range->enc_capa & IW_ENC_CAPA_WPA) {
1329                         drv->capa.key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_WPA |
1330                                 WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK;
1331                 }
1332                 if (range->enc_capa & IW_ENC_CAPA_WPA2) {
1333                         drv->capa.key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_WPA2 |
1334                                 WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK;
1335                 }
1336                 drv->capa.enc |= WPA_DRIVER_CAPA_ENC_WEP40 |
1337                         WPA_DRIVER_CAPA_ENC_WEP104;
1338                 if (range->enc_capa & IW_ENC_CAPA_CIPHER_TKIP)
1339                         drv->capa.enc |= WPA_DRIVER_CAPA_ENC_TKIP;
1340                 if (range->enc_capa & IW_ENC_CAPA_CIPHER_CCMP)
1341                         drv->capa.enc |= WPA_DRIVER_CAPA_ENC_CCMP;
1342                 wpa_printf(MSG_DEBUG, "  capabilities: key_mgmt 0x%x enc 0x%x",
1343                            drv->capa.key_mgmt, drv->capa.enc);
1344         } else {
1345                 wpa_printf(MSG_DEBUG, "SIOCGIWRANGE: too old (short) data - "
1346                            "assuming WPA is not supported");
1347         }
1348
1349         os_free(range);
1350         return 0;
1351 }
1352
1353
1354 static int wpa_driver_nl80211_set_key(void *priv, wpa_alg alg,
1355                                       const u8 *addr, int key_idx,
1356                                       int set_tx, const u8 *seq,
1357                                       size_t seq_len,
1358                                       const u8 *key, size_t key_len)
1359 {
1360         struct wpa_driver_nl80211_data *drv = priv;
1361         int err;
1362         struct nl_msg *msg;
1363
1364         wpa_printf(MSG_DEBUG, "%s: alg=%d addr=%p key_idx=%d set_tx=%d "
1365                    "seq_len=%lu key_len=%lu",
1366                    __func__, alg, addr, key_idx, set_tx,
1367                    (unsigned long) seq_len, (unsigned long) key_len);
1368
1369         msg = nlmsg_alloc();
1370         if (msg == NULL)
1371                 return -1;
1372
1373         if (alg == WPA_ALG_NONE) {
1374                 genlmsg_put(msg, 0, 0, genl_family_get_id(drv->nl80211), 0, 0,
1375                             NL80211_CMD_DEL_KEY, 0);
1376         } else {
1377                 genlmsg_put(msg, 0, 0, genl_family_get_id(drv->nl80211), 0, 0,
1378                             NL80211_CMD_NEW_KEY, 0);
1379                 NLA_PUT(msg, NL80211_ATTR_KEY_DATA, key_len, key);
1380                 switch (alg) {
1381                 case WPA_ALG_WEP:
1382                         if (key_len == 5)
1383                                 NLA_PUT_U32(msg, NL80211_ATTR_KEY_CIPHER,
1384                                             0x000FAC01);
1385                         else
1386                                 NLA_PUT_U32(msg, NL80211_ATTR_KEY_CIPHER,
1387                                             0x000FAC05);
1388                         break;
1389                 case WPA_ALG_TKIP:
1390                         NLA_PUT_U32(msg, NL80211_ATTR_KEY_CIPHER, 0x000FAC02);
1391                         break;
1392                 case WPA_ALG_CCMP:
1393                         NLA_PUT_U32(msg, NL80211_ATTR_KEY_CIPHER, 0x000FAC04);
1394                         break;
1395                 default:
1396                         nlmsg_free(msg);
1397                         return -1;
1398                 }
1399         }
1400
1401         if (addr && os_memcmp(addr, "\xff\xff\xff\xff\xff\xff", ETH_ALEN) != 0)
1402         {
1403                 wpa_printf(MSG_DEBUG, "   addr=" MACSTR, MAC2STR(addr));
1404                 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, addr);
1405         }
1406         NLA_PUT_U8(msg, NL80211_ATTR_KEY_IDX, key_idx);
1407         NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
1408
1409         err = send_and_recv_msgs(drv, msg, NULL, NULL);
1410         if (err) {
1411                 wpa_printf(MSG_DEBUG, "nl80211: set_key failed; err=%d", err);
1412                 return -1;
1413         }
1414
1415         if (set_tx && alg != WPA_ALG_NONE) {
1416                 msg = nlmsg_alloc();
1417                 if (msg == NULL)
1418                         return -1;
1419
1420                 genlmsg_put(msg, 0, 0, genl_family_get_id(drv->nl80211), 0,
1421                             0, NL80211_CMD_SET_KEY, 0);
1422                 NLA_PUT_U8(msg, NL80211_ATTR_KEY_IDX, key_idx);
1423                 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
1424                 NLA_PUT_FLAG(msg, NL80211_ATTR_KEY_DEFAULT);
1425
1426                 err = send_and_recv_msgs(drv, msg, NULL, NULL);
1427                 if (err) {
1428                         wpa_printf(MSG_DEBUG, "nl80211: set default key "
1429                                    "failed; err=%d", err);
1430                         return -1;
1431                 }
1432         }
1433
1434         return 0;
1435
1436 nla_put_failure:
1437         return -ENOBUFS;
1438 }
1439
1440
1441 static int wpa_driver_nl80211_mlme(struct wpa_driver_nl80211_data *drv,
1442                                    const u8 *addr, int cmd, u16 reason_code)
1443 {
1444         int ret = -1;
1445         struct nl_msg *msg;
1446
1447         msg = nlmsg_alloc();
1448         if (!msg)
1449                 return -1;
1450
1451         genlmsg_put(msg, 0, 0, genl_family_get_id(drv->nl80211), 0, 0, cmd, 0);
1452
1453         NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
1454         NLA_PUT_U16(msg, NL80211_ATTR_REASON_CODE, reason_code);
1455         NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, addr);
1456
1457         ret = send_and_recv_msgs(drv, msg, NULL, NULL);
1458         msg = NULL;
1459         if (ret) {
1460                 wpa_printf(MSG_DEBUG, "nl80211: MLME command failed: ret=%d "
1461                            "(%s)", ret, strerror(-ret));
1462                 goto nla_put_failure;
1463         }
1464         ret = 0;
1465
1466 nla_put_failure:
1467         nlmsg_free(msg);
1468         return ret;
1469 }
1470
1471
1472 static int wpa_driver_nl80211_deauthenticate(void *priv, const u8 *addr,
1473                                              int reason_code)
1474 {
1475         struct wpa_driver_nl80211_data *drv = priv;
1476         wpa_printf(MSG_DEBUG, "%s", __func__);
1477         return wpa_driver_nl80211_mlme(drv, addr, NL80211_CMD_DEAUTHENTICATE,
1478                                        reason_code);
1479 }
1480
1481
1482 static int wpa_driver_nl80211_disassociate(void *priv, const u8 *addr,
1483                                            int reason_code)
1484 {
1485         struct wpa_driver_nl80211_data *drv = priv;
1486         wpa_printf(MSG_DEBUG, "%s", __func__);
1487         return wpa_driver_nl80211_mlme(drv, addr, NL80211_CMD_DISASSOCIATE,
1488                                        reason_code);
1489 }
1490
1491
1492 static int wpa_driver_nl80211_authenticate(
1493         void *priv, struct wpa_driver_auth_params *params)
1494 {
1495         struct wpa_driver_nl80211_data *drv = priv;
1496         int ret = -1;
1497         struct nl_msg *msg;
1498         enum nl80211_auth_type type;
1499
1500         drv->associated = 0;
1501
1502         msg = nlmsg_alloc();
1503         if (!msg)
1504                 return -1;
1505
1506         wpa_printf(MSG_DEBUG, "nl80211: Authenticate (ifindex=%d)",
1507                    drv->ifindex);
1508         genlmsg_put(msg, 0, 0, genl_family_get_id(drv->nl80211), 0, 0,
1509                     NL80211_CMD_AUTHENTICATE, 0);
1510
1511         NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
1512         if (params->bssid) {
1513                 wpa_printf(MSG_DEBUG, "  * bssid=" MACSTR,
1514                            MAC2STR(params->bssid));
1515                 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, params->bssid);
1516         }
1517         if (params->freq) {
1518                 wpa_printf(MSG_DEBUG, "  * freq=%d", params->freq);
1519                 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_FREQ, params->freq);
1520         }
1521         if (params->ssid) {
1522                 wpa_hexdump_ascii(MSG_DEBUG, "  * SSID",
1523                                   params->ssid, params->ssid_len);
1524                 NLA_PUT(msg, NL80211_ATTR_SSID, params->ssid_len,
1525                         params->ssid);
1526         }
1527         wpa_hexdump(MSG_DEBUG, "  * IEs", params->ie, params->ie_len);
1528         if (params->ie)
1529                 NLA_PUT(msg, NL80211_ATTR_IE, params->ie_len, params->ie);
1530         /*
1531          * TODO: if multiple auth_alg options enabled, try them one by one if
1532          * the AP rejects authentication due to unknown auth alg
1533          */
1534         if (params->auth_alg & AUTH_ALG_OPEN_SYSTEM)
1535                 type = NL80211_AUTHTYPE_OPEN_SYSTEM;
1536         else if (params->auth_alg & AUTH_ALG_SHARED_KEY)
1537                 type = NL80211_AUTHTYPE_SHARED_KEY;
1538         else if (params->auth_alg & AUTH_ALG_LEAP)
1539                 type = NL80211_AUTHTYPE_NETWORK_EAP;
1540         else if (params->auth_alg & AUTH_ALG_FT)
1541                 type = NL80211_AUTHTYPE_FT;
1542         else
1543                 goto nla_put_failure;
1544         wpa_printf(MSG_DEBUG, "  * Auth Type %d", type);
1545         NLA_PUT_U32(msg, NL80211_ATTR_AUTH_TYPE, type);
1546
1547         ret = send_and_recv_msgs(drv, msg, NULL, NULL);
1548         msg = NULL;
1549         if (ret) {
1550                 wpa_printf(MSG_DEBUG, "nl80211: MLME command failed: ret=%d "
1551                            "(%s)", ret, strerror(-ret));
1552                 goto nla_put_failure;
1553         }
1554         ret = 0;
1555         wpa_printf(MSG_DEBUG, "nl80211: Authentication request send "
1556                    "successfully");
1557
1558 nla_put_failure:
1559         nlmsg_free(msg);
1560         return ret;
1561 }
1562
1563
1564 #ifdef CONFIG_AP
1565 static int wpa_driver_nl80211_set_freq2(
1566         struct wpa_driver_nl80211_data *drv,
1567         struct wpa_driver_associate_params *params)
1568 {
1569         struct nl_msg *msg;
1570
1571         msg = nlmsg_alloc();
1572         if (!msg)
1573                 return -1;
1574
1575         genlmsg_put(msg, 0, 0, genl_family_get_id(drv->nl80211), 0, 0,
1576                     NL80211_CMD_SET_WIPHY, 0);
1577
1578         NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
1579
1580         /* TODO: proper channel configuration */
1581         NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_FREQ, 2437);
1582
1583         if (send_and_recv_msgs(drv, msg, NULL, NULL) == 0)
1584                 return 0;
1585 nla_put_failure:
1586         return -1;
1587 }
1588
1589
1590 static int wpa_driver_nl80211_ap(struct wpa_driver_nl80211_data *drv,
1591                                  struct wpa_driver_associate_params *params)
1592 {
1593         if (wpa_driver_nl80211_set_mode(drv, params->mode) ||
1594             wpa_driver_nl80211_set_freq2(drv, params))
1595                 return -1;
1596
1597         /* TODO: setup monitor interface (and add code somewhere to remove this
1598          * when AP mode is stopped; associate with mode != 2 or drv_deinit) */
1599         /* TODO: setup beacon */
1600
1601         return 0;
1602 }
1603 #endif /* CONFIG_AP */
1604
1605
1606 static int wpa_driver_nl80211_associate(
1607         void *priv, struct wpa_driver_associate_params *params)
1608 {
1609         struct wpa_driver_nl80211_data *drv = priv;
1610         int ret = -1;
1611         struct nl_msg *msg;
1612
1613 #ifdef CONFIG_AP
1614         if (params->mode == 2)
1615                 return wpa_driver_nl80211_ap(drv, params);
1616 #endif /* CONFIG_AP */
1617
1618         wpa_driver_nl80211_set_auth_param(drv, IW_AUTH_DROP_UNENCRYPTED,
1619                                           params->drop_unencrypted);
1620
1621         drv->associated = 0;
1622
1623         msg = nlmsg_alloc();
1624         if (!msg)
1625                 return -1;
1626
1627         wpa_printf(MSG_DEBUG, "nl80211: Associate (ifindex=%d)",
1628                    drv->ifindex);
1629         genlmsg_put(msg, 0, 0, genl_family_get_id(drv->nl80211), 0, 0,
1630                     NL80211_CMD_ASSOCIATE, 0);
1631
1632         NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
1633         if (params->bssid) {
1634                 wpa_printf(MSG_DEBUG, "  * bssid=" MACSTR,
1635                            MAC2STR(params->bssid));
1636                 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, params->bssid);
1637         }
1638         if (params->freq) {
1639                 wpa_printf(MSG_DEBUG, "  * freq=%d", params->freq);
1640                 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_FREQ, params->freq);
1641         }
1642         if (params->ssid) {
1643                 wpa_hexdump_ascii(MSG_DEBUG, "  * SSID",
1644                                   params->ssid, params->ssid_len);
1645                 NLA_PUT(msg, NL80211_ATTR_SSID, params->ssid_len,
1646                         params->ssid);
1647                 if (params->ssid_len > sizeof(drv->ssid))
1648                         goto nla_put_failure;
1649                 os_memcpy(drv->ssid, params->ssid, params->ssid_len);
1650                 drv->ssid_len = params->ssid_len;
1651         }
1652         wpa_hexdump(MSG_DEBUG, "  * IEs", params->wpa_ie, params->wpa_ie_len);
1653         if (params->wpa_ie)
1654                 NLA_PUT(msg, NL80211_ATTR_IE, params->wpa_ie_len,
1655                         params->wpa_ie);
1656
1657         ret = send_and_recv_msgs(drv, msg, NULL, NULL);
1658         msg = NULL;
1659         if (ret) {
1660                 wpa_printf(MSG_DEBUG, "nl80211: MLME command failed: ret=%d "
1661                            "(%s)", ret, strerror(-ret));
1662                 goto nla_put_failure;
1663         }
1664         ret = 0;
1665         wpa_printf(MSG_DEBUG, "nl80211: Association request send "
1666                    "successfully");
1667
1668 nla_put_failure:
1669         nlmsg_free(msg);
1670         return ret;
1671 }
1672
1673
1674 /**
1675  * wpa_driver_nl80211_set_mode - Set wireless mode (infra/adhoc), SIOCSIWMODE
1676  * @drv: Pointer to private driver data from wpa_driver_nl80211_init()
1677  * @mode: 0 = infra/BSS (associate with an AP), 1 = adhoc/IBSS
1678  * Returns: 0 on success, -1 on failure
1679  */
1680 static int wpa_driver_nl80211_set_mode(struct wpa_driver_nl80211_data *drv,
1681                                        int mode)
1682 {
1683         int ret = -1, flags;
1684         struct nl_msg *msg;
1685         int nlmode;
1686
1687         switch (mode) {
1688         case 0:
1689                 nlmode = NL80211_IFTYPE_STATION;
1690                 break;
1691         case 1:
1692                 nlmode = NL80211_IFTYPE_ADHOC;
1693                 break;
1694         case 2:
1695                 nlmode = NL80211_IFTYPE_AP;
1696                 break;
1697         default:
1698                 return -1;
1699         }
1700
1701         msg = nlmsg_alloc();
1702         if (!msg)
1703                 return -1;
1704
1705         genlmsg_put(msg, 0, 0, genl_family_get_id(drv->nl80211), 0,
1706                     0, NL80211_CMD_SET_INTERFACE, 0);
1707         NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
1708         NLA_PUT_U32(msg, NL80211_ATTR_IFTYPE, nlmode);
1709
1710         ret = send_and_recv_msgs(drv, msg, NULL, NULL);
1711         if (!ret)
1712                 return 0;
1713         else
1714                 goto try_again;
1715
1716 nla_put_failure:
1717         wpa_printf(MSG_ERROR, "nl80211: Failed to set interface mode: %d (%s)",
1718                    ret, strerror(-ret));
1719         return -1;
1720
1721 try_again:
1722         /* mac80211 doesn't allow mode changes while the device is up, so
1723          * take the device down, try to set the mode again, and bring the
1724          * device back up.
1725          */
1726         if (wpa_driver_nl80211_get_ifflags(drv, &flags) == 0) {
1727                 (void) wpa_driver_nl80211_set_ifflags(drv, flags & ~IFF_UP);
1728
1729                 /* Try to set the mode again while the interface is down */
1730                 msg = nlmsg_alloc();
1731                 if (!msg)
1732                         return -1;
1733
1734                 genlmsg_put(msg, 0, 0, genl_family_get_id(drv->nl80211), 0,
1735                             0, NL80211_CMD_SET_INTERFACE, 0);
1736                 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
1737                 NLA_PUT_U32(msg, NL80211_ATTR_IFTYPE, nlmode);
1738                 ret = send_and_recv_msgs(drv, msg, NULL, NULL);
1739                 if (ret) {
1740                         wpa_printf(MSG_ERROR, "Failed to set interface %s "
1741                                    "mode(try_again): %d (%s)",
1742                                    drv->ifname, ret, strerror(-ret));
1743                 }
1744
1745                 /* Ignore return value of get_ifflags to ensure that the device
1746                  * is always up like it was before this function was called.
1747                  */
1748                 (void) wpa_driver_nl80211_get_ifflags(drv, &flags);
1749                 (void) wpa_driver_nl80211_set_ifflags(drv, flags | IFF_UP);
1750         }
1751
1752         return ret;
1753 }
1754
1755
1756 static int wpa_driver_nl80211_get_capa(void *priv,
1757                                        struct wpa_driver_capa *capa)
1758 {
1759         struct wpa_driver_nl80211_data *drv = priv;
1760         if (!drv->has_capability)
1761                 return -1;
1762         os_memcpy(capa, &drv->capa, sizeof(*capa));
1763         return 0;
1764 }
1765
1766
1767 static int wpa_driver_nl80211_set_operstate(void *priv, int state)
1768 {
1769         struct wpa_driver_nl80211_data *drv = priv;
1770
1771         wpa_printf(MSG_DEBUG, "%s: operstate %d->%d (%s)",
1772                    __func__, drv->operstate, state, state ? "UP" : "DORMANT");
1773         drv->operstate = state;
1774         return wpa_driver_nl80211_send_oper_ifla(
1775                 drv, -1, state ? IF_OPER_UP : IF_OPER_DORMANT);
1776 }
1777
1778
1779 const struct wpa_driver_ops wpa_driver_nl80211_ops = {
1780         .name = "nl80211",
1781         .desc = "Linux nl80211/cfg80211",
1782         .get_bssid = wpa_driver_nl80211_get_bssid,
1783         .get_ssid = wpa_driver_nl80211_get_ssid,
1784         .set_key = wpa_driver_nl80211_set_key,
1785         .scan2 = wpa_driver_nl80211_scan,
1786         .get_scan_results2 = wpa_driver_nl80211_get_scan_results,
1787         .deauthenticate = wpa_driver_nl80211_deauthenticate,
1788         .disassociate = wpa_driver_nl80211_disassociate,
1789         .authenticate = wpa_driver_nl80211_authenticate,
1790         .associate = wpa_driver_nl80211_associate,
1791         .init = wpa_driver_nl80211_init,
1792         .deinit = wpa_driver_nl80211_deinit,
1793         .get_capa = wpa_driver_nl80211_get_capa,
1794         .set_operstate = wpa_driver_nl80211_set_operstate,
1795         .set_country = wpa_driver_nl80211_set_country,
1796 };