iwinfo_nl80211.c

   1 /*
   2  * iwinfo - Wireless Information Library - NL80211 Backend
   3  *
   4  *   Copyright (C) 2010-2013 Jo-Philipp Wich <xm@subsignal.org>
   5  *
   6  * The iwinfo library is free software: you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License version 2
   8  * as published by the Free Software Foundation.
   9  *
  10  * The iwinfo library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  13  * See the GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with the iwinfo library. If not, see http://www.gnu.org/licenses/.
  17  *
  18  * The signal handling code is derived from the official madwifi tools,
  19  * wlanconfig.c in particular. The encryption property handling was
  20  * inspired by the hostapd madwifi driver.
  21  *
  22  * Parts of this code are derived from the Linux iw utility.
  23  */
  24
  25 #include <limits.h>
  26 #include <glob.h>
  27 #include <fnmatch.h>
  28 #include "iwinfo_nl80211.h"
  29
  30 #define min(x, y) ((x) < (y)) ? (x) : (y)
  31
  32 static struct nl80211_state *nls = NULL;
  33
  34 static void nl80211_close(void)
  35 {
  36         if (nls)
  37         {
  38                 if (nls->nlctrl)
  39                         genl_family_put(nls->nlctrl);
  40
  41                 if (nls->nl80211)
  42                         genl_family_put(nls->nl80211);
  43
  44                 if (nls->nl_sock)
  45                         nl_socket_free(nls->nl_sock);
  46
  47                 if (nls->nl_cache)
  48                         nl_cache_free(nls->nl_cache);
  49
  50                 free(nls);
  51                 nls = NULL;
  52         }
  53 }
  54
  55 static int nl80211_init(void)
  56 {
  57         int err, fd;
  58
  59         if (!nls)
  60         {
  61                 nls = malloc(sizeof(struct nl80211_state));
  62                 if (!nls) {
  63                         err = -ENOMEM;
  64                         goto err;
  65                 }
  66
  67                 memset(nls, 0, sizeof(*nls));
  68
  69                 nls->nl_sock = nl_socket_alloc();
  70                 if (!nls->nl_sock) {
  71                         err = -ENOMEM;
  72                         goto err;
  73                 }
  74
  75                 if (genl_connect(nls->nl_sock)) {
  76                         err = -ENOLINK;
  77                         goto err;
  78                 }
  79
  80                 fd = nl_socket_get_fd(nls->nl_sock);
  81                 if (fcntl(fd, F_SETFD, fcntl(fd, F_GETFD) | FD_CLOEXEC) < 0) {
  82                         err = -EINVAL;
  83                         goto err;
  84                 }
  85
  86                 if (genl_ctrl_alloc_cache(nls->nl_sock, &nls->nl_cache)) {
  87                         err = -ENOMEM;
  88                         goto err;
  89                 }
  90
  91                 nls->nl80211 = genl_ctrl_search_by_name(nls->nl_cache, "nl80211");
  92                 if (!nls->nl80211) {
  93                         err = -ENOENT;
  94                         goto err;
  95                 }
  96
  97                 nls->nlctrl = genl_ctrl_search_by_name(nls->nl_cache, "nlctrl");
  98                 if (!nls->nlctrl) {
  99                         err = -ENOENT;
 100                         goto err;
 101                 }
 102         }
 103
 104         return 0;
 105
 106
 107 err:
 108         nl80211_close();
 109         return err;
 110 }
 111
 112 static int nl80211_readint(const char *path)
 113 {
 114         int fd;
 115         int rv = -1;
 116         char buffer[16];
 117
 118         if ((fd = open(path, O_RDONLY)) > -1)
 119         {
 120                 if (read(fd, buffer, sizeof(buffer)) > 0)
 121                         rv = atoi(buffer);
 122
 123                 close(fd);
 124         }
 125
 126         return rv;
 127 }
 128
 129 static int nl80211_readstr(const char *path, char *buffer, int length)
 130 {
 131         int fd;
 132         int rv = -1;
 133
 134         if ((fd = open(path, O_RDONLY)) > -1)
 135         {
 136                 if ((rv = read(fd, buffer, length - 1)) > 0)
 137                 {
 138                         if (buffer[rv - 1] == '\n')
 139                                 rv--;
 140
 141                         buffer[rv] = 0;
 142                 }
 143
 144                 close(fd);
 145         }
 146
 147         return rv;
 148 }
 149
 150
 151 static int nl80211_msg_error(struct sockaddr_nl *nla,
 152         struct nlmsgerr *err, void *arg)
 153 {
 154         int *ret = arg;
 155         *ret = err->error;
 156         return NL_STOP;
 157 }
 158
 159 static int nl80211_msg_finish(struct nl_msg *msg, void *arg)
 160 {
 161         int *ret = arg;
 162         *ret = 0;
 163         return NL_SKIP;
 164 }
 165
 166 static int nl80211_msg_ack(struct nl_msg *msg, void *arg)
 167 {
 168         int *ret = arg;
 169         *ret = 0;
 170         return NL_STOP;
 171 }
 172
 173 static int nl80211_msg_response(struct nl_msg *msg, void *arg)
 174 {
 175         return NL_SKIP;
 176 }
 177
 178 static void nl80211_free(struct nl80211_msg_conveyor *cv)
 179 {
 180         if (cv)
 181         {
 182                 if (cv->cb)
 183                         nl_cb_put(cv->cb);
 184
 185                 if (cv->msg)
 186                         nlmsg_free(cv->msg);
 187
 188                 cv->cb  = NULL;
 189                 cv->msg = NULL;
 190         }
 191 }
 192
 193 static struct nl80211_msg_conveyor * nl80211_new(struct genl_family *family,
 194                                                  int cmd, int flags)
 195 {
 196         static struct nl80211_msg_conveyor cv;
 197
 198         struct nl_msg *req = NULL;
 199         struct nl_cb *cb = NULL;
 200
 201         req = nlmsg_alloc();
 202         if (!req)
 203                 goto err;
 204
 205         cb = nl_cb_alloc(NL_CB_DEFAULT);
 206         if (!cb)
 207                 goto err;
 208
 209         genlmsg_put(req, 0, 0, genl_family_get_id(family), 0, flags, cmd, 0);
 210
 211         cv.msg = req;
 212         cv.cb  = cb;
 213
 214         return &cv;
 215
 216 err:
 217 nla_put_failure:
 218         if (cb)
 219                 nl_cb_put(cb);
 220
 221         if (req)
 222                 nlmsg_free(req);
 223
 224         return NULL;
 225 }
 226
 227 static struct nl80211_msg_conveyor * nl80211_ctl(int cmd, int flags)
 228 {
 229         if (nl80211_init() < 0)
 230                 return NULL;
 231
 232         return nl80211_new(nls->nlctrl, cmd, flags);
 233 }
 234
 235 static int nl80211_phy_idx_from_uci_path(struct uci_section *s)
 236 {
 237         const char *opt;
 238         char buf[128];
 239         int idx = -1;
 240         glob_t gl;
 241
 242         opt = uci_lookup_option_string(uci_ctx, s, "path");
 243         if (!opt)
 244                 return -1;
 245
 246         snprintf(buf, sizeof(buf), "/sys/devices/%s/ieee80211/*/index", opt);  /**/
 247         if (glob(buf, 0, NULL, &gl))
 248                 return -1;
 249
 250         if (gl.gl_pathc > 0)
 251                 idx = nl80211_readint(gl.gl_pathv[0]);
 252
 253         globfree(&gl);
 254
 255         return idx;
 256 }
 257
 258 static int nl80211_phy_idx_from_uci_macaddr(struct uci_section *s)
 259 {
 260         const char *opt;
 261         char buf[128];
 262         int i, idx = -1;
 263         glob_t gl;
 264
 265         opt = uci_lookup_option_string(uci_ctx, s, "macaddr");
 266         if (!opt)
 267                 return -1;
 268
 269         snprintf(buf, sizeof(buf), "/sys/class/ieee80211/*", opt);      /**/
 270         if (glob(buf, 0, NULL, &gl))
 271                 return -1;
 272
 273         for (i = 0; i < gl.gl_pathc; i++)
 274         {
 275                 snprintf(buf, sizeof(buf), "%s/macaddress", gl.gl_pathv[i]);
 276                 if (nl80211_readstr(buf, buf, sizeof(buf)) <= 0)
 277                         continue;
 278
 279                 if (fnmatch(opt, buf, FNM_CASEFOLD))
 280                         continue;
 281
 282                 snprintf(buf, sizeof(buf), "%s/index", gl.gl_pathv[i]);
 283                 if ((idx = nl80211_readint(buf)) > -1)
 284                         break;
 285         }
 286
 287         globfree(&gl);
 288
 289         return idx;
 290 }
 291
 292 static int nl80211_phy_idx_from_uci_phy(struct uci_section *s)
 293 {
 294         const char *opt;
 295         char buf[128];
 296
 297         opt = uci_lookup_option_string(uci_ctx, s, "phy");
 298         if (!opt)
 299                 return -1;
 300
 301         snprintf(buf, sizeof(buf), "/sys/class/ieee80211/%s/index", opt);
 302         return nl80211_readint(buf);
 303 }
 304
 305 static int nl80211_phy_idx_from_uci(const char *name)
 306 {
 307         struct uci_section *s;
 308         int idx = -1;
 309
 310         s = iwinfo_uci_get_radio(name, "mac80211");
 311         if (!s)
 312                 goto free;
 313
 314         idx = nl80211_phy_idx_from_uci_path(s);
 315
 316         if (idx < 0)
 317                 idx = nl80211_phy_idx_from_uci_macaddr(s);
 318
 319         if (idx < 0)
 320                 idx = nl80211_phy_idx_from_uci_phy(s);
 321
 322 free:
 323         iwinfo_uci_free();
 324         return idx;
 325 }
 326
 327 static struct nl80211_msg_conveyor * nl80211_msg(const char *ifname,
 328                                                  int cmd, int flags)
 329 {
 330         int ifidx = -1, phyidx = -1;
 331         struct nl80211_msg_conveyor *cv;
 332
 333         if (ifname == NULL)
 334                 return NULL;
 335
 336         if (nl80211_init() < 0)
 337                 return NULL;
 338
 339         if (!strncmp(ifname, "phy", 3))
 340                 phyidx = atoi(&ifname[3]);
 341         else if (!strncmp(ifname, "radio", 5))
 342                 phyidx = nl80211_phy_idx_from_uci(ifname);
 343         else if (!strncmp(ifname, "mon.", 4))
 344                 ifidx = if_nametoindex(&ifname[4]);
 345         else
 346                 ifidx = if_nametoindex(ifname);
 347
 348         /* Valid ifidx must be greater than 0 */
 349         if ((ifidx <= 0) && (phyidx < 0))
 350                 return NULL;
 351
 352         cv = nl80211_new(nls->nl80211, cmd, flags);
 353         if (!cv)
 354                 return NULL;
 355
 356         if (ifidx > -1)
 357                 NLA_PUT_U32(cv->msg, NL80211_ATTR_IFINDEX, ifidx);
 358
 359         if (phyidx > -1)
 360                 NLA_PUT_U32(cv->msg, NL80211_ATTR_WIPHY, phyidx);
 361
 362         return cv;
 363
 364 nla_put_failure:
 365         nl80211_free(cv);
 366         return NULL;
 367 }
 368
 369 static struct nl80211_msg_conveyor * nl80211_send(
 370         struct nl80211_msg_conveyor *cv,
 371         int (*cb_func)(struct nl_msg *, void *), void *cb_arg
 372 ) {
 373         static struct nl80211_msg_conveyor rcv;
 374         int err = 1;
 375
 376         if (cb_func)
 377                 nl_cb_set(cv->cb, NL_CB_VALID, NL_CB_CUSTOM, cb_func, cb_arg);
 378         else
 379                 nl_cb_set(cv->cb, NL_CB_VALID, NL_CB_CUSTOM, nl80211_msg_response, &rcv);
 380
 381         if (nl_send_auto_complete(nls->nl_sock, cv->msg) < 0)
 382                 goto err;
 383
 384         nl_cb_err(cv->cb,               NL_CB_CUSTOM, nl80211_msg_error,  &err);
 385         nl_cb_set(cv->cb, NL_CB_FINISH, NL_CB_CUSTOM, nl80211_msg_finish, &err);
 386         nl_cb_set(cv->cb, NL_CB_ACK,    NL_CB_CUSTOM, nl80211_msg_ack,    &err);
 387
 388         while (err > 0)
 389                 nl_recvmsgs(nls->nl_sock, cv->cb);
 390
 391         return &rcv;
 392
 393 err:
 394         nl_cb_put(cv->cb);
 395         nlmsg_free(cv->msg);
 396
 397         return NULL;
 398 }
 399
 400 static struct nlattr ** nl80211_parse(struct nl_msg *msg)
 401 {
 402         struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
 403         static struct nlattr *attr[NL80211_ATTR_MAX + 1];
 404
 405         nla_parse(attr, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
 406                   genlmsg_attrlen(gnlh, 0), NULL);
 407
 408         return attr;
 409 }
 410
 411
 412 static int nl80211_subscribe_cb(struct nl_msg *msg, void *arg)
 413 {
 414         struct nl80211_group_conveyor *cv = arg;
 415
 416         struct nlattr **attr = nl80211_parse(msg);
 417         struct nlattr *mgrpinfo[CTRL_ATTR_MCAST_GRP_MAX + 1];
 418         struct nlattr *mgrp;
 419         int mgrpidx;
 420
 421         if (!attr[CTRL_ATTR_MCAST_GROUPS])
 422                 return NL_SKIP;
 423
 424         nla_for_each_nested(mgrp, attr[CTRL_ATTR_MCAST_GROUPS], mgrpidx)
 425         {
 426                 nla_parse(mgrpinfo, CTRL_ATTR_MCAST_GRP_MAX,
 427                           nla_data(mgrp), nla_len(mgrp), NULL);
 428
 429                 if (mgrpinfo[CTRL_ATTR_MCAST_GRP_ID] &&
 430                     mgrpinfo[CTRL_ATTR_MCAST_GRP_NAME] &&
 431                     !strncmp(nla_data(mgrpinfo[CTRL_ATTR_MCAST_GRP_NAME]),
 432                              cv->name, nla_len(mgrpinfo[CTRL_ATTR_MCAST_GRP_NAME])))
 433                 {
 434                         cv->id = nla_get_u32(mgrpinfo[CTRL_ATTR_MCAST_GRP_ID]);
 435                         break;
 436                 }
 437         }
 438
 439         return NL_SKIP;
 440 }
 441
 442 static int nl80211_subscribe(const char *family, const char *group)
 443 {
 444         struct nl80211_group_conveyor cv = { .name = group, .id = -ENOENT };
 445         struct nl80211_msg_conveyor *req;
 446
 447         req = nl80211_ctl(CTRL_CMD_GETFAMILY, 0);
 448         if (req)
 449         {
 450                 NLA_PUT_STRING(req->msg, CTRL_ATTR_FAMILY_NAME, family);
 451                 nl80211_send(req, nl80211_subscribe_cb, &cv);
 452
 453 nla_put_failure:
 454                 nl80211_free(req);
 455         }
 456
 457         return nl_socket_add_membership(nls->nl_sock, cv.id);
 458 }
 459
 460
 461 static int nl80211_wait_cb(struct nl_msg *msg, void *arg)
 462 {
 463         struct nl80211_event_conveyor *cv = arg;
 464         struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
 465
 466         if (gnlh->cmd == cv->wait)
 467                 cv->recv = gnlh->cmd;
 468
 469         return NL_SKIP;
 470 }
 471
 472 static int nl80211_wait_seq_check(struct nl_msg *msg, void *arg)
 473 {
 474         return NL_OK;
 475 }
 476
 477 static int nl80211_wait(const char *family, const char *group, int cmd)
 478 {
 479         struct nl80211_event_conveyor cv = { .wait = cmd };
 480         struct nl_cb *cb;
 481
 482         if (nl80211_subscribe(family, group))
 483                 return -ENOENT;
 484
 485         cb = nl_cb_alloc(NL_CB_DEFAULT);
 486
 487         if (!cb)
 488                 return -ENOMEM;
 489
 490         nl_cb_set(cb, NL_CB_SEQ_CHECK, NL_CB_CUSTOM, nl80211_wait_seq_check, NULL);
 491         nl_cb_set(cb, NL_CB_VALID,     NL_CB_CUSTOM, nl80211_wait_cb,        &cv );
 492
 493         while (!cv.recv)
 494                 nl_recvmsgs(nls->nl_sock, cb);
 495
 496         nl_cb_put(cb);
 497
 498         return 0;
 499 }
 500
 501
 502 static int nl80211_freq2channel(int freq)
 503 {
 504         if (freq == 2484)
 505                 return 14;
 506         else if (freq < 2484)
 507                 return (freq - 2407) / 5;
 508         else if (freq >= 4910 && freq <= 4980)
 509                 return (freq - 4000) / 5;
 510         else
 511                 return (freq - 5000) / 5;
 512 }
 513
 514 static int nl80211_channel2freq(int channel, const char *band)
 515 {
 516         if (!band || band[0] != 'a')
 517         {
 518                 if (channel == 14)
 519                         return 2484;
 520                 else if (channel < 14)
 521                         return (channel * 5) + 2407;
 522         }
 523         else
 524         {
 525                 if (channel >= 182 && channel <= 196)
 526                         return (channel * 5) + 4000;
 527                 else
 528                         return (channel * 5) + 5000;
 529         }
 530
 531         return 0;
 532 }
 533
 534 static char * nl80211_getval(const char *ifname, const char *buf, const char *key)
 535 {
 536         int i, len;
 537         char lkey[64] = { 0 };
 538         const char *ln = buf;
 539         static char lval[256] = { 0 };
 540
 541         int matched_if = ifname ? 0 : 1;
 542
 543
 544         for( i = 0, len = strlen(buf); i < len; i++ )
 545         {
 546                 if (!lkey[0] && (buf[i] == ' ' || buf[i] == '\t'))
 547                 {
 548                         ln++;
 549                 }
 550                 else if (!lkey[0] && (buf[i] == '='))
 551                 {
 552                         if ((&buf[i] - ln) > 0)
 553                                 memcpy(lkey, ln, min(sizeof(lkey) - 1, &buf[i] - ln));
 554                 }
 555                 else if (buf[i] == '\n')
 556                 {
 557                         if (lkey[0])
 558                         {
 559                                 memcpy(lval, ln + strlen(lkey) + 1,
 560                                         min(sizeof(lval) - 1, &buf[i] - ln - strlen(lkey) - 1));
 561
 562                                 if ((ifname != NULL) &&
 563                                     (!strcmp(lkey, "interface") || !strcmp(lkey, "bss")) )
 564                                 {
 565                                         matched_if = !strcmp(lval, ifname);
 566                                 }
 567                                 else if (matched_if && !strcmp(lkey, key))
 568                                 {
 569                                         return lval;
 570                                 }
 571                         }
 572
 573                         ln = &buf[i+1];
 574                         memset(lkey, 0, sizeof(lkey));
 575                         memset(lval, 0, sizeof(lval));
 576                 }
 577         }
 578
 579         return NULL;
 580 }
 581
 582 static int nl80211_ifname2phy_cb(struct nl_msg *msg, void *arg)
 583 {
 584         char *buf = arg;
 585         struct nlattr **attr = nl80211_parse(msg);
 586
 587         if (attr[NL80211_ATTR_WIPHY_NAME])
 588                 memcpy(buf, nla_data(attr[NL80211_ATTR_WIPHY_NAME]),
 589                        nla_len(attr[NL80211_ATTR_WIPHY_NAME]));
 590         else
 591                 buf[0] = 0;
 592
 593         return NL_SKIP;
 594 }
 595
 596 static char * nl80211_ifname2phy(const char *ifname)
 597 {
 598         static char phy[32] = { 0 };
 599         struct nl80211_msg_conveyor *req;
 600
 601         memset(phy, 0, sizeof(phy));
 602
 603         req = nl80211_msg(ifname, NL80211_CMD_GET_WIPHY, 0);
 604         if (req)
 605         {
 606                 nl80211_send(req, nl80211_ifname2phy_cb, phy);
 607                 nl80211_free(req);
 608         }
 609
 610         return phy[0] ? phy : NULL;
 611 }
 612
 613 static char * nl80211_phy2ifname(const char *ifname)
 614 {
 615         int fd, ifidx = -1, cifidx = -1, phyidx = -1;
 616         char buffer[64];
 617         static char nif[IFNAMSIZ] = { 0 };
 618
 619         DIR *d;
 620         struct dirent *e;
 621
 622         /* Only accept phy name of the form phy%d or radio%d */
 623         if (!ifname)
 624                 return NULL;
 625         else if (!strncmp(ifname, "phy", 3))
 626                 phyidx = atoi(&ifname[3]);
 627         else if (!strncmp(ifname, "radio", 5))
 628                 phyidx = nl80211_phy_idx_from_uci(ifname);
 629         else
 630                 return NULL;
 631
 632         memset(nif, 0, sizeof(nif));
 633
 634         if (phyidx > -1)
 635         {
 636                 if ((d = opendir("/sys/class/net")) != NULL)
 637                 {
 638                         while ((e = readdir(d)) != NULL)
 639                         {
 640                                 snprintf(buffer, sizeof(buffer),
 641                                          "/sys/class/net/%s/phy80211/index", e->d_name);
 642
 643                                 if (nl80211_readint(buffer) == phyidx)
 644                                 {
 645                                         snprintf(buffer, sizeof(buffer),
 646                                                  "/sys/class/net/%s/ifindex", e->d_name);
 647
 648                                         if ((cifidx = nl80211_readint(buffer)) >= 0 &&
 649                                             ((ifidx < 0) || (cifidx < ifidx)))
 650                                         {
 651                                                 ifidx = cifidx;
 652                                                 strncpy(nif, e->d_name, sizeof(nif));
 653                                         }
 654                                 }
 655                         }
 656
 657                         closedir(d);
 658                 }
 659         }
 660
 661         return nif[0] ? nif : NULL;
 662 }
 663
 664 static int nl80211_get_mode_cb(struct nl_msg *msg, void *arg)
 665 {
 666         int *mode = arg;
 667         struct nlattr **tb = nl80211_parse(msg);
 668         const int ifmodes[NL80211_IFTYPE_MAX + 1] = {
 669                 IWINFO_OPMODE_UNKNOWN,          /* unspecified */
 670                 IWINFO_OPMODE_ADHOC,            /* IBSS */
 671                 IWINFO_OPMODE_CLIENT,           /* managed */
 672                 IWINFO_OPMODE_MASTER,           /* AP */
 673                 IWINFO_OPMODE_AP_VLAN,          /* AP/VLAN */
 674                 IWINFO_OPMODE_WDS,                      /* WDS */
 675                 IWINFO_OPMODE_MONITOR,          /* monitor */
 676                 IWINFO_OPMODE_MESHPOINT,        /* mesh point */
 677                 IWINFO_OPMODE_P2P_CLIENT,       /* P2P-client */
 678                 IWINFO_OPMODE_P2P_GO,           /* P2P-GO */
 679         };
 680
 681         if (tb[NL80211_ATTR_IFTYPE])
 682                 *mode = ifmodes[nla_get_u32(tb[NL80211_ATTR_IFTYPE])];
 683
 684         return NL_SKIP;
 685 }
 686
 687
 688 static int nl80211_get_mode(const char *ifname, int *buf)
 689 {
 690         char *res;
 691         struct nl80211_msg_conveyor *req;
 692
 693         res = nl80211_phy2ifname(ifname);
 694         req = nl80211_msg(res ? res : ifname, NL80211_CMD_GET_INTERFACE, 0);
 695         *buf = IWINFO_OPMODE_UNKNOWN;
 696
 697         if (req)
 698         {
 699                 nl80211_send(req, nl80211_get_mode_cb, buf);
 700                 nl80211_free(req);
 701         }
 702
 703         return (*buf == IWINFO_OPMODE_UNKNOWN) ? -1 : 0;
 704 }
 705
 706 static char * nl80211_hostapd_info(const char *ifname)
 707 {
 708         int mode;
 709         char *phy;
 710         char path[32] = { 0 };
 711         static char buf[4096] = { 0 };
 712         FILE *conf;
 713
 714         if (nl80211_get_mode(ifname, &mode))
 715                 return NULL;
 716
 717         if ((mode == IWINFO_OPMODE_MASTER || mode == IWINFO_OPMODE_AP_VLAN) &&
 718             (phy = nl80211_ifname2phy(ifname)) != NULL)
 719         {
 720                 snprintf(path, sizeof(path), "/var/run/hostapd-%s.conf", phy);
 721
 722                 if ((conf = fopen(path, "r")) != NULL)
 723                 {
 724                         fread(buf, sizeof(buf) - 1, 1, conf);
 725                         fclose(conf);
 726
 727                         return buf;
 728                 }
 729         }
 730
 731         return NULL;
 732 }
 733
 734 static inline int nl80211_wpactl_recv(int sock, char *buf, int blen)
 735 {
 736         fd_set rfds;
 737         struct timeval tv = { 2, 0 };
 738
 739         FD_ZERO(&rfds);
 740         FD_SET(sock, &rfds);
 741
 742         memset(buf, 0, blen);
 743
 744
 745         if (select(sock + 1, &rfds, NULL, NULL, &tv) < 0)
 746                 return -1;
 747
 748         if (!FD_ISSET(sock, &rfds))
 749                 return -1;
 750
 751         return recv(sock, buf, blen, 0);
 752 }
 753
 754 static char * nl80211_wpactl_info(const char *ifname, const char *cmd,
 755                                                                    const char *event)
 756 {
 757         int numtry = 0;
 758         int sock = -1;
 759         char *rv = NULL;
 760         size_t remote_length, local_length;
 761         static char buffer[10240] = { 0 };
 762
 763         struct sockaddr_un local = { 0 };
 764         struct sockaddr_un remote = { 0 };
 765
 766
 767         sock = socket(PF_UNIX, SOCK_DGRAM, 0);
 768         if (sock < 0)
 769                 return NULL;
 770
 771         remote.sun_family = AF_UNIX;
 772         remote_length = sizeof(remote.sun_family) + sprintf(remote.sun_path,
 773                 "/var/run/wpa_supplicant-%s/%s", ifname, ifname);
 774
 775         if (fcntl(sock, F_SETFD, fcntl(sock, F_GETFD) | FD_CLOEXEC) < 0)
 776                 goto out;
 777
 778         if (connect(sock, (struct sockaddr *) &remote, remote_length))
 779         {
 780                 remote_length = sizeof(remote.sun_family) + sprintf(remote.sun_path,
 781                         "/var/run/wpa_supplicant/%s", ifname);
 782
 783                 if (connect(sock, (struct sockaddr *) &remote, remote_length))
 784                         goto out;
 785         }
 786
 787         local.sun_family = AF_UNIX;
 788         local_length = sizeof(local.sun_family) +
 789                 sprintf(local.sun_path, "/var/run/iwinfo-%s-%d", ifname, getpid());
 790
 791         if (bind(sock, (struct sockaddr *) &local, local_length))
 792                 goto out;
 793
 794
 795         if (event)
 796         {
 797                 send(sock, "ATTACH", 6, 0);
 798
 799                 if (nl80211_wpactl_recv(sock, buffer, sizeof(buffer)-1) <= 0)
 800                         goto out;
 801         }
 802
 803
 804         send(sock, cmd, strlen(cmd), 0);
 805
 806         /* we might have to scan up to 72 channels / 256ms per channel */
 807         /* this makes up to 18.5s hence 10 tries */
 808         while( numtry++ < 10 )
 809         {
 810                 char *bracket;
 811
 812                 /* make sure there is a terminating nul byte */
 813                 if (nl80211_wpactl_recv(sock, buffer, sizeof(buffer)-1) <= 0)
 814                 {
 815                         if (event)
 816                                 continue;
 817
 818                         break;
 819                 }
 820
 821                 if ((!event && buffer[0] != '<') || (event && strstr(buffer, event)))
 822                         break;
 823
 824                 /* there may be more than max(numtry) BSS-ADDED events */
 825                 /* ignore them similar to wpa_cli */
 826                 if (buffer[0] == '<' &&
 827                                 (bracket=strchr(buffer,'>')) != NULL &&
 828                                 strncmp(bracket+1,"CTRL-EVENT-BSS-ADDED",20) == 0)
 829                         numtry--;
 830         }
 831
 832         rv = buffer;
 833
 834 out:
 835         close(sock);
 836
 837         if (local.sun_family)
 838                 unlink(local.sun_path);
 839
 840         return rv;
 841 }
 842
 843 static char * nl80211_ifadd(const char *ifname)
 844 {
 845         int phyidx;
 846         char *rv = NULL, path[PATH_MAX];
 847         static char nif[IFNAMSIZ] = { 0 };
 848         struct nl80211_msg_conveyor *req, *res;
 849         FILE *sysfs;
 850
 851         req = nl80211_msg(ifname, NL80211_CMD_NEW_INTERFACE, 0);
 852         if (req)
 853         {
 854                 snprintf(nif, sizeof(nif), "tmp.%s", ifname);
 855
 856                 NLA_PUT_STRING(req->msg, NL80211_ATTR_IFNAME, nif);
 857                 NLA_PUT_U32(req->msg, NL80211_ATTR_IFTYPE, NL80211_IFTYPE_STATION);
 858
 859                 nl80211_send(req, NULL, NULL);
 860
 861                 snprintf(path, sizeof(path) - 1,
 862                          "/proc/sys/net/ipv6/conf/%s/disable_ipv6", nif);
 863
 864                 if ((sysfs = fopen(path, "w")) != NULL)
 865                 {
 866                         fwrite("0\n", 1, 2, sysfs);
 867                         fclose(sysfs);
 868                 }
 869
 870                 rv = nif;
 871
 872         nla_put_failure:
 873                 nl80211_free(req);
 874         }
 875
 876         return rv;
 877 }
 878
 879 static void nl80211_ifdel(const char *ifname)
 880 {
 881         struct nl80211_msg_conveyor *req;
 882
 883         req = nl80211_msg(ifname, NL80211_CMD_DEL_INTERFACE, 0);
 884         if (req)
 885         {
 886                 NLA_PUT_STRING(req->msg, NL80211_ATTR_IFNAME, ifname);
 887
 888                 nl80211_send(req, NULL, NULL);
 889
 890         nla_put_failure:
 891                 nl80211_free(req);
 892         }
 893 }
 894
 895 static void nl80211_hostapd_hup(const char *ifname)
 896 {
 897         int fd, pid = 0;
 898         char buf[32];
 899         char *phy = nl80211_ifname2phy(ifname);
 900
 901         if (phy)
 902         {
 903                 snprintf(buf, sizeof(buf), "/var/run/wifi-%s.pid", phy);
 904                 if ((fd = open(buf, O_RDONLY)) > 0)
 905                 {
 906                         if (read(fd, buf, sizeof(buf)) > 0)
 907                                 pid = atoi(buf);
 908
 909                         close(fd);
 910                 }
 911
 912                 if (pid > 0)
 913                         kill(pid, 1);
 914         }
 915 }
 916
 917
 918 static int nl80211_probe(const char *ifname)
 919 {
 920         return !!nl80211_ifname2phy(ifname);
 921 }
 922
 923 struct nl80211_ssid_bssid {
 924         unsigned char *ssid;
 925         unsigned char bssid[7];
 926 };
 927
 928 static int nl80211_get_ssid_bssid_cb(struct nl_msg *msg, void *arg)
 929 {
 930         int ielen;
 931         unsigned char *ie;
 932         struct nl80211_ssid_bssid *sb = arg;
 933         struct nlattr **tb = nl80211_parse(msg);
 934         struct nlattr *bss[NL80211_BSS_MAX + 1];
 935
 936         static struct nla_policy bss_policy[NL80211_BSS_MAX + 1] = {
 937                 [NL80211_BSS_INFORMATION_ELEMENTS] = {                 },
 938                 [NL80211_BSS_STATUS]               = { .type = NLA_U32 },
 939         };
 940
 941         if (!tb[NL80211_ATTR_BSS] ||
 942             nla_parse_nested(bss, NL80211_BSS_MAX, tb[NL80211_ATTR_BSS],
 943                              bss_policy) ||
 944             !bss[NL80211_BSS_BSSID] ||
 945             !bss[NL80211_BSS_STATUS] ||
 946             !bss[NL80211_BSS_INFORMATION_ELEMENTS])
 947         {
 948                 return NL_SKIP;
 949         }
 950
 951         switch (nla_get_u32(bss[NL80211_BSS_STATUS]))
 952         {
 953         case NL80211_BSS_STATUS_ASSOCIATED:
 954         case NL80211_BSS_STATUS_AUTHENTICATED:
 955         case NL80211_BSS_STATUS_IBSS_JOINED:
 956
 957                 if (sb->ssid)
 958                 {
 959                         ie = nla_data(bss[NL80211_BSS_INFORMATION_ELEMENTS]);
 960                         ielen = nla_len(bss[NL80211_BSS_INFORMATION_ELEMENTS]);
 961
 962                         while (ielen >= 2 && ielen >= ie[1])
 963                         {
 964                                 if (ie[0] == 0)
 965                                 {
 966                                         memcpy(sb->ssid, ie + 2, min(ie[1], IWINFO_ESSID_MAX_SIZE));
 967                                         return NL_SKIP;
 968                                 }
 969
 970                                 ielen -= ie[1] + 2;
 971                                 ie += ie[1] + 2;
 972                         }
 973                 }
 974                 else
 975                 {
 976                         sb->bssid[0] = 1;
 977                         memcpy(sb->bssid + 1, nla_data(bss[NL80211_BSS_BSSID]), 6);
 978                         return NL_SKIP;
 979                 }
 980
 981         default:
 982                 return NL_SKIP;
 983         }
 984 }
 985
 986 static int nl80211_get_ssid(const char *ifname, char *buf)
 987 {
 988         char *res;
 989         struct nl80211_msg_conveyor *req;
 990         struct nl80211_ssid_bssid sb;
 991
 992         /* try to find ssid from scan dump results */
 993         res = nl80211_phy2ifname(ifname);
 994         req = nl80211_msg(res ? res : ifname, NL80211_CMD_GET_SCAN, NLM_F_DUMP);
 995
 996         sb.ssid = buf;
 997         *buf = 0;
 998
 999         if (req)
1000         {
1001                 nl80211_send(req, nl80211_get_ssid_bssid_cb, &sb);
1002                 nl80211_free(req);
1003         }
1004
1005         /* failed, try to find from hostapd info */
1006         if ((*buf == 0) &&
1007             (res = nl80211_hostapd_info(ifname)) &&
1008             (res = nl80211_getval(ifname, res, "ssid")))
1009         {
1010                 memcpy(buf, res, strlen(res));
1011         }
1012
1013         return (*buf == 0) ? -1 : 0;
1014 }
1015
1016 static int nl80211_get_bssid(const char *ifname, char *buf)
1017 {
1018         char *res;
1019         struct nl80211_msg_conveyor *req;
1020         struct nl80211_ssid_bssid sb;
1021
1022         /* try to find bssid from scan dump results */
1023         res = nl80211_phy2ifname(ifname);
1024         req = nl80211_msg(res ? res : ifname, NL80211_CMD_GET_SCAN, NLM_F_DUMP);
1025
1026         sb.ssid = NULL;
1027         sb.bssid[0] = 0;
1028
1029         if (req)
1030         {
1031                 nl80211_send(req, nl80211_get_ssid_bssid_cb, &sb);
1032                 nl80211_free(req);
1033         }
1034
1035         /* failed, try to find mac from hostapd info */
1036         if ((sb.bssid[0] == 0) &&
1037             (res = nl80211_hostapd_info(ifname)) &&
1038             (res = nl80211_getval(ifname, res, "bssid")))
1039         {
1040                 sb.bssid[0] = 1;
1041                 sb.bssid[1] = strtol(&res[0],  NULL, 16);
1042                 sb.bssid[2] = strtol(&res[3],  NULL, 16);
1043                 sb.bssid[3] = strtol(&res[6],  NULL, 16);
1044                 sb.bssid[4] = strtol(&res[9],  NULL, 16);
1045                 sb.bssid[5] = strtol(&res[12], NULL, 16);
1046                 sb.bssid[6] = strtol(&res[15], NULL, 16);
1047         }
1048
1049         if (sb.bssid[0])
1050         {
1051                 sprintf(buf, "%02X:%02X:%02X:%02X:%02X:%02X",
1052                         sb.bssid[1], sb.bssid[2], sb.bssid[3],
1053                         sb.bssid[4], sb.bssid[5], sb.bssid[6]);
1054
1055                 return 0;
1056         }
1057
1058         return -1;
1059 }
1060
1061
1062 static int nl80211_get_frequency_scan_cb(struct nl_msg *msg, void *arg)
1063 {
1064         int *freq = arg;
1065         struct nlattr **attr = nl80211_parse(msg);
1066         struct nlattr *binfo[NL80211_BSS_MAX + 1];
1067
1068         static struct nla_policy bss_policy[NL80211_BSS_MAX + 1] = {
1069                 [NL80211_BSS_FREQUENCY] = { .type = NLA_U32 },
1070                 [NL80211_BSS_STATUS]    = { .type = NLA_U32 },
1071         };
1072
1073         if (attr[NL80211_ATTR_BSS] &&
1074             !nla_parse_nested(binfo, NL80211_BSS_MAX,
1075                               attr[NL80211_ATTR_BSS], bss_policy))
1076         {
1077                 if (binfo[NL80211_BSS_STATUS] && binfo[NL80211_BSS_FREQUENCY])
1078                         *freq = nla_get_u32(binfo[NL80211_BSS_FREQUENCY]);
1079         }
1080
1081         return NL_SKIP;
1082 }
1083
1084 static int nl80211_get_frequency_info_cb(struct nl_msg *msg, void *arg)
1085 {
1086         int *freq = arg;
1087         struct nlattr **tb = nl80211_parse(msg);
1088
1089         if (tb[NL80211_ATTR_WIPHY_FREQ])
1090                 *freq = nla_get_u32(tb[NL80211_ATTR_WIPHY_FREQ]);
1091
1092         return NL_SKIP;
1093 }
1094
1095 static int nl80211_get_frequency(const char *ifname, int *buf)
1096 {
1097         int chn;
1098         char *res, *channel;
1099         struct nl80211_msg_conveyor *req;
1100
1101         /* try to find frequency from interface info */
1102         res = nl80211_phy2ifname(ifname);
1103         req = nl80211_msg(res ? res : ifname, NL80211_CMD_GET_INTERFACE, 0);
1104         *buf = 0;
1105
1106         if (req)
1107         {
1108                 nl80211_send(req, nl80211_get_frequency_info_cb, buf);
1109                 nl80211_free(req);
1110         }
1111
1112         /* failed, try to find frequency from hostapd info */
1113         if ((*buf == 0) &&
1114             (res = nl80211_hostapd_info(ifname)) &&
1115             (channel = nl80211_getval(NULL, res, "channel")))
1116         {
1117                 chn = atoi(channel);
1118                 *buf = nl80211_channel2freq(chn, nl80211_getval(NULL, res, "hw_mode"));
1119         }
1120         else
1121         {
1122                 /* failed, try to find frequency from scan results */
1123                 if (*buf == 0)
1124                 {
1125                         res = nl80211_phy2ifname(ifname);
1126                         req = nl80211_msg(res ? res : ifname, NL80211_CMD_GET_SCAN,
1127                                           NLM_F_DUMP);
1128
1129                         if (req)
1130                         {
1131                                 nl80211_send(req, nl80211_get_frequency_scan_cb, buf);
1132                                 nl80211_free(req);
1133                         }
1134                 }
1135         }
1136
1137         return (*buf == 0) ? -1 : 0;
1138 }
1139
1140 static int nl80211_get_channel(const char *ifname, int *buf)
1141 {
1142         if (!nl80211_get_frequency(ifname, buf))
1143         {
1144                 *buf = nl80211_freq2channel(*buf);
1145                 return 0;
1146         }
1147
1148         return -1;
1149 }
1150
1151
1152 static int nl80211_get_txpower(const char *ifname, int *buf)
1153 {
1154 #if 0
1155         char *res;
1156         char path[PATH_MAX];
1157
1158         res = nl80211_ifname2phy(ifname);
1159         snprintf(path, sizeof(path), "/sys/kernel/debug/ieee80211/%s/power",
1160                  res ? res : ifname);
1161
1162         if ((*buf = nl80211_readint(path)) > -1)
1163                 return 0;
1164 #endif
1165
1166         return wext_ops.txpower(ifname, buf);
1167 }
1168
1169
1170 static int nl80211_fill_signal_cb(struct nl_msg *msg, void *arg)
1171 {
1172         int8_t dbm;
1173         int16_t mbit;
1174         struct nl80211_rssi_rate *rr = arg;
1175         struct nlattr **attr = nl80211_parse(msg);
1176         struct nlattr *sinfo[NL80211_STA_INFO_MAX + 1];
1177         struct nlattr *rinfo[NL80211_RATE_INFO_MAX + 1];
1178
1179         static struct nla_policy stats_policy[NL80211_STA_INFO_MAX + 1] = {
1180                 [NL80211_STA_INFO_INACTIVE_TIME] = { .type = NLA_U32    },
1181                 [NL80211_STA_INFO_RX_BYTES]      = { .type = NLA_U32    },
1182                 [NL80211_STA_INFO_TX_BYTES]      = { .type = NLA_U32    },
1183                 [NL80211_STA_INFO_RX_PACKETS]    = { .type = NLA_U32    },
1184                 [NL80211_STA_INFO_TX_PACKETS]    = { .type = NLA_U32    },
1185                 [NL80211_STA_INFO_SIGNAL]        = { .type = NLA_U8     },
1186                 [NL80211_STA_INFO_TX_BITRATE]    = { .type = NLA_NESTED },
1187                 [NL80211_STA_INFO_LLID]          = { .type = NLA_U16    },
1188                 [NL80211_STA_INFO_PLID]          = { .type = NLA_U16    },
1189                 [NL80211_STA_INFO_PLINK_STATE]   = { .type = NLA_U8     },
1190         };
1191
1192         static struct nla_policy rate_policy[NL80211_RATE_INFO_MAX + 1] = {
1193                 [NL80211_RATE_INFO_BITRATE]      = { .type = NLA_U16  },
1194                 [NL80211_RATE_INFO_MCS]          = { .type = NLA_U8   },
1195                 [NL80211_RATE_INFO_40_MHZ_WIDTH] = { .type = NLA_FLAG },
1196                 [NL80211_RATE_INFO_SHORT_GI]     = { .type = NLA_FLAG },
1197         };
1198
1199         if (attr[NL80211_ATTR_STA_INFO])
1200         {
1201                 if (!nla_parse_nested(sinfo, NL80211_STA_INFO_MAX,
1202                                       attr[NL80211_ATTR_STA_INFO], stats_policy))
1203                 {
1204                         if (sinfo[NL80211_STA_INFO_SIGNAL])
1205                         {
1206                                 dbm = nla_get_u8(sinfo[NL80211_STA_INFO_SIGNAL]);
1207                                 rr->rssi = rr->rssi ? (int8_t)((rr->rssi + dbm) / 2) : dbm;
1208                         }
1209
1210                         if (sinfo[NL80211_STA_INFO_TX_BITRATE])
1211                         {
1212                                 if (!nla_parse_nested(rinfo, NL80211_RATE_INFO_MAX,
1213                                                       sinfo[NL80211_STA_INFO_TX_BITRATE],
1214                                                       rate_policy))
1215                                 {
1216                                         if (rinfo[NL80211_RATE_INFO_BITRATE])
1217                                         {
1218                                                 mbit = nla_get_u16(rinfo[NL80211_RATE_INFO_BITRATE]);
1219                                                 rr->rate = rr->rate
1220                                                         ? (int16_t)((rr->rate + mbit) / 2) : mbit;
1221                                         }
1222                                 }
1223                         }
1224                 }
1225         }
1226
1227         return NL_SKIP;
1228 }
1229
1230 static void nl80211_fill_signal(const char *ifname, struct nl80211_rssi_rate *r)
1231 {
1232         DIR *d;
1233         struct dirent *de;
1234         struct nl80211_msg_conveyor *req;
1235
1236         r->rssi = 0;
1237         r->rate = 0;
1238
1239         if ((d = opendir("/sys/class/net")) != NULL)
1240         {
1241                 while ((de = readdir(d)) != NULL)
1242                 {
1243                         if (!strncmp(de->d_name, ifname, strlen(ifname)) &&
1244                             (!de->d_name[strlen(ifname)] ||
1245                              !strncmp(&de->d_name[strlen(ifname)], ".sta", 4)))
1246                         {
1247                                 req = nl80211_msg(de->d_name, NL80211_CMD_GET_STATION,
1248                                                   NLM_F_DUMP);
1249
1250                                 if (req)
1251                                 {
1252                                         nl80211_send(req, nl80211_fill_signal_cb, r);
1253                                         nl80211_free(req);
1254                                 }
1255                         }
1256                 }
1257
1258                 closedir(d);
1259         }
1260 }
1261
1262 static int nl80211_get_bitrate(const char *ifname, int *buf)
1263 {
1264         struct nl80211_rssi_rate rr;
1265
1266         nl80211_fill_signal(ifname, &rr);
1267
1268         if (rr.rate)
1269         {
1270                 *buf = (rr.rate * 100);
1271                 return 0;
1272         }
1273
1274         return -1;
1275 }
1276
1277 static int nl80211_get_signal(const char *ifname, int *buf)
1278 {
1279         struct nl80211_rssi_rate rr;
1280
1281         nl80211_fill_signal(ifname, &rr);
1282
1283         if (rr.rssi)
1284         {
1285                 *buf = rr.rssi;
1286                 return 0;
1287         }
1288
1289         return -1;
1290 }
1291
1292 static int nl80211_get_noise_cb(struct nl_msg *msg, void *arg)
1293 {
1294         int8_t *noise = arg;
1295         struct nlattr **tb = nl80211_parse(msg);
1296         struct nlattr *si[NL80211_SURVEY_INFO_MAX + 1];
1297
1298         static struct nla_policy sp[NL80211_SURVEY_INFO_MAX + 1] = {
1299                 [NL80211_SURVEY_INFO_FREQUENCY] = { .type = NLA_U32 },
1300                 [NL80211_SURVEY_INFO_NOISE]     = { .type = NLA_U8  },
1301         };
1302
1303         if (!tb[NL80211_ATTR_SURVEY_INFO])
1304                 return NL_SKIP;
1305
1306         if (nla_parse_nested(si, NL80211_SURVEY_INFO_MAX,
1307                              tb[NL80211_ATTR_SURVEY_INFO], sp))
1308                 return NL_SKIP;
1309
1310         if (!si[NL80211_SURVEY_INFO_NOISE])
1311                 return NL_SKIP;
1312
1313         if (!*noise || si[NL80211_SURVEY_INFO_IN_USE])
1314                 *noise = (int8_t)nla_get_u8(si[NL80211_SURVEY_INFO_NOISE]);
1315
1316         return NL_SKIP;
1317 }
1318
1319
1320 static int nl80211_get_noise(const char *ifname, int *buf)
1321 {
1322         int8_t noise;
1323         struct nl80211_msg_conveyor *req;
1324
1325         req = nl80211_msg(ifname, NL80211_CMD_GET_SURVEY, NLM_F_DUMP);
1326         if (req)
1327         {
1328                 noise = 0;
1329
1330                 nl80211_send(req, nl80211_get_noise_cb, &noise);
1331                 nl80211_free(req);
1332
1333                 if (noise)
1334                 {
1335                         *buf = noise;
1336                         return 0;
1337                 }
1338         }
1339
1340         return -1;
1341 }
1342
1343 static int nl80211_get_quality(const char *ifname, int *buf)
1344 {
1345         int signal;
1346
1347         if (!nl80211_get_signal(ifname, &signal))
1348         {
1349                 /* A positive signal level is usually just a quality
1350                  * value, pass through as-is */
1351                 if (signal >= 0)
1352                 {
1353                         *buf = signal;
1354                 }
1355
1356                 /* The cfg80211 wext compat layer assumes a signal range
1357                  * of -110 dBm to -40 dBm, the quality value is derived
1358                  * by adding 110 to the signal level */
1359                 else
1360                 {
1361                         if (signal < -110)
1362                                 signal = -110;
1363                         else if (signal > -40)
1364                                 signal = -40;
1365
1366                         *buf = (signal + 110);
1367                 }
1368
1369                 return 0;
1370         }
1371
1372         return -1;
1373 }
1374
1375 static int nl80211_get_quality_max(const char *ifname, int *buf)
1376 {
1377         /* The cfg80211 wext compat layer assumes a maximum
1378          * quality of 70 */
1379         *buf = 70;
1380
1381         return 0;
1382 }
1383
1384 static int nl80211_get_encryption(const char *ifname, char *buf)
1385 {
1386         int i;
1387         char k[9];
1388         char *val, *res;
1389         struct iwinfo_crypto_entry *c = (struct iwinfo_crypto_entry *)buf;
1390
1391         /* WPA supplicant */
1392         if ((res = nl80211_wpactl_info(ifname, "STATUS", NULL)) &&
1393             (val = nl80211_getval(NULL, res, "pairwise_cipher")))
1394         {
1395                 /* WEP */
1396                 if (strstr(val, "WEP"))
1397                 {
1398                         if (strstr(val, "WEP-40"))
1399                                 c->pair_ciphers |= IWINFO_CIPHER_WEP40;
1400
1401                         else if (strstr(val, "WEP-104"))
1402                                 c->pair_ciphers |= IWINFO_CIPHER_WEP104;
1403
1404                         c->enabled       = 1;
1405                         c->group_ciphers = c->pair_ciphers;
1406
1407                         c->auth_suites |= IWINFO_KMGMT_NONE;
1408                         c->auth_algs   |= IWINFO_AUTH_OPEN; /* XXX: assumption */
1409                 }
1410
1411                 /* WPA */
1412                 else
1413                 {
1414                         if (strstr(val, "TKIP"))
1415                                 c->pair_ciphers |= IWINFO_CIPHER_TKIP;
1416
1417                         else if (strstr(val, "CCMP"))
1418                                 c->pair_ciphers |= IWINFO_CIPHER_CCMP;
1419
1420                         else if (strstr(val, "NONE"))
1421                                 c->pair_ciphers |= IWINFO_CIPHER_NONE;
1422
1423                         else if (strstr(val, "WEP-40"))
1424                                 c->pair_ciphers |= IWINFO_CIPHER_WEP40;
1425
1426                         else if (strstr(val, "WEP-104"))
1427                                 c->pair_ciphers |= IWINFO_CIPHER_WEP104;
1428
1429
1430                         if ((val = nl80211_getval(NULL, res, "group_cipher")))
1431                         {
1432                                 if (strstr(val, "TKIP"))
1433                                         c->group_ciphers |= IWINFO_CIPHER_TKIP;
1434
1435                                 else if (strstr(val, "CCMP"))
1436                                         c->group_ciphers |= IWINFO_CIPHER_CCMP;
1437
1438                                 else if (strstr(val, "NONE"))
1439                                         c->group_ciphers |= IWINFO_CIPHER_NONE;
1440
1441                                 else if (strstr(val, "WEP-40"))
1442                                         c->group_ciphers |= IWINFO_CIPHER_WEP40;
1443
1444                                 else if (strstr(val, "WEP-104"))
1445                                         c->group_ciphers |= IWINFO_CIPHER_WEP104;
1446                         }
1447
1448
1449                         if ((val = nl80211_getval(NULL, res, "key_mgmt")))
1450                         {
1451                                 if (strstr(val, "WPA2"))
1452                                         c->wpa_version = 2;
1453
1454                                 else if (strstr(val, "WPA"))
1455                                         c->wpa_version = 1;
1456
1457
1458                                 if (strstr(val, "PSK"))
1459                                         c->auth_suites |= IWINFO_KMGMT_PSK;
1460
1461                                 else if (strstr(val, "EAP") || strstr(val, "802.1X"))
1462                                         c->auth_suites |= IWINFO_KMGMT_8021x;
1463
1464                                 else if (strstr(val, "NONE"))
1465                                         c->auth_suites |= IWINFO_KMGMT_NONE;
1466                         }
1467
1468                         c->enabled = (c->wpa_version && c->auth_suites) ? 1 : 0;
1469                 }
1470
1471                 return 0;
1472         }
1473
1474         /* Hostapd */
1475         else if ((res = nl80211_hostapd_info(ifname)))
1476         {
1477                 if ((val = nl80211_getval(ifname, res, "wpa")) != NULL)
1478                         c->wpa_version = atoi(val);
1479
1480                 val = nl80211_getval(ifname, res, "wpa_key_mgmt");
1481
1482                 if (!val || strstr(val, "PSK"))
1483                         c->auth_suites |= IWINFO_KMGMT_PSK;
1484
1485                 if (val && strstr(val, "EAP"))
1486                         c->auth_suites |= IWINFO_KMGMT_8021x;
1487
1488                 if (val && strstr(val, "NONE"))
1489                         c->auth_suites |= IWINFO_KMGMT_NONE;
1490
1491                 if ((val = nl80211_getval(ifname, res, "wpa_pairwise")) != NULL)
1492                 {
1493                         if (strstr(val, "TKIP"))
1494                                 c->pair_ciphers |= IWINFO_CIPHER_TKIP;
1495
1496                         if (strstr(val, "CCMP"))
1497                                 c->pair_ciphers |= IWINFO_CIPHER_CCMP;
1498
1499                         if (strstr(val, "NONE"))
1500                                 c->pair_ciphers |= IWINFO_CIPHER_NONE;
1501                 }
1502
1503                 if ((val = nl80211_getval(ifname, res, "auth_algs")) != NULL)
1504                 {
1505                         switch(atoi(val)) {
1506                                 case 1:
1507                                         c->auth_algs |= IWINFO_AUTH_OPEN;
1508                                         break;
1509
1510                                 case 2:
1511                                         c->auth_algs |= IWINFO_AUTH_SHARED;
1512                                         break;
1513
1514                                 case 3:
1515                                         c->auth_algs |= IWINFO_AUTH_OPEN;
1516                                         c->auth_algs |= IWINFO_AUTH_SHARED;
1517                                         break;
1518
1519                                 default:
1520                                         break;
1521                         }
1522
1523                         for (i = 0; i < 4; i++)
1524                         {
1525                                 snprintf(k, sizeof(k), "wep_key%d", i);
1526
1527                                 if ((val = nl80211_getval(ifname, res, k)))
1528                                 {
1529                                         if ((strlen(val) == 5) || (strlen(val) == 10))
1530                                                 c->pair_ciphers |= IWINFO_CIPHER_WEP40;
1531
1532                                         else if ((strlen(val) == 13) || (strlen(val) == 26))
1533                                                 c->pair_ciphers |= IWINFO_CIPHER_WEP104;
1534                                 }
1535                         }
1536                 }
1537
1538                 c->group_ciphers = c->pair_ciphers;
1539                 c->enabled = (c->wpa_version || c->pair_ciphers) ? 1 : 0;
1540
1541                 return 0;
1542         }
1543
1544         return -1;
1545 }
1546
1547 static int nl80211_get_phyname(const char *ifname, char *buf)
1548 {
1549         const char *name;
1550
1551         name = nl80211_ifname2phy(ifname);
1552
1553         if (name)
1554         {
1555                 strcpy(buf, name);
1556                 return 0;
1557         }
1558         else if ((name = nl80211_phy2ifname(ifname)) != NULL)
1559         {
1560                 name = nl80211_ifname2phy(name);
1561
1562                 if (name)
1563                 {
1564                         strcpy(buf, ifname);
1565                         return 0;
1566                 }
1567         }
1568
1569         return -1;
1570 }
1571
1572
1573 static int nl80211_get_assoclist_cb(struct nl_msg *msg, void *arg)
1574 {
1575         struct nl80211_array_buf *arr = arg;
1576         struct iwinfo_assoclist_entry *e = arr->buf;
1577         struct nlattr **attr = nl80211_parse(msg);
1578         struct nlattr *sinfo[NL80211_STA_INFO_MAX + 1];
1579         struct nlattr *rinfo[NL80211_RATE_INFO_MAX + 1];
1580
1581         static struct nla_policy stats_policy[NL80211_STA_INFO_MAX + 1] = {
1582                 [NL80211_STA_INFO_INACTIVE_TIME] = { .type = NLA_U32    },
1583                 [NL80211_STA_INFO_RX_PACKETS]    = { .type = NLA_U32    },
1584                 [NL80211_STA_INFO_TX_PACKETS]    = { .type = NLA_U32    },
1585                 [NL80211_STA_INFO_RX_BITRATE]    = { .type = NLA_NESTED },
1586                 [NL80211_STA_INFO_TX_BITRATE]    = { .type = NLA_NESTED },
1587                 [NL80211_STA_INFO_SIGNAL]        = { .type = NLA_U8     },
1588         };
1589
1590         static struct nla_policy rate_policy[NL80211_RATE_INFO_MAX + 1] = {
1591                 [NL80211_RATE_INFO_BITRATE]      = { .type = NLA_U16    },
1592                 [NL80211_RATE_INFO_MCS]          = { .type = NLA_U8     },
1593                 [NL80211_RATE_INFO_40_MHZ_WIDTH] = { .type = NLA_FLAG   },
1594                 [NL80211_RATE_INFO_SHORT_GI]     = { .type = NLA_FLAG   },
1595         };
1596
1597         /* advance to end of array */
1598         e += arr->count;
1599         memset(e, 0, sizeof(*e));
1600
1601         if (attr[NL80211_ATTR_MAC])
1602                 memcpy(e->mac, nla_data(attr[NL80211_ATTR_MAC]), 6);
1603
1604         if (attr[NL80211_ATTR_STA_INFO] &&
1605             !nla_parse_nested(sinfo, NL80211_STA_INFO_MAX,
1606                               attr[NL80211_ATTR_STA_INFO], stats_policy))
1607         {
1608                 if (sinfo[NL80211_STA_INFO_SIGNAL])
1609                         e->signal = nla_get_u8(sinfo[NL80211_STA_INFO_SIGNAL]);
1610
1611                 if (sinfo[NL80211_STA_INFO_INACTIVE_TIME])
1612                         e->inactive = nla_get_u32(sinfo[NL80211_STA_INFO_INACTIVE_TIME]);
1613
1614                 if (sinfo[NL80211_STA_INFO_RX_PACKETS])
1615                         e->rx_packets = nla_get_u32(sinfo[NL80211_STA_INFO_RX_PACKETS]);
1616
1617                 if (sinfo[NL80211_STA_INFO_TX_PACKETS])
1618                         e->tx_packets = nla_get_u32(sinfo[NL80211_STA_INFO_TX_PACKETS]);
1619
1620                 if (sinfo[NL80211_STA_INFO_RX_BITRATE] &&
1621                     !nla_parse_nested(rinfo, NL80211_RATE_INFO_MAX,
1622                                       sinfo[NL80211_STA_INFO_RX_BITRATE], rate_policy))
1623                 {
1624                         if (rinfo[NL80211_RATE_INFO_BITRATE])
1625                                 e->rx_rate.rate =
1626                                         nla_get_u16(rinfo[NL80211_RATE_INFO_BITRATE]) * 100;
1627
1628                         if (rinfo[NL80211_RATE_INFO_MCS])
1629                                 e->rx_rate.mcs = nla_get_u8(rinfo[NL80211_RATE_INFO_MCS]);
1630
1631                         if (rinfo[NL80211_RATE_INFO_40_MHZ_WIDTH])
1632                                 e->rx_rate.is_40mhz = 1;
1633
1634                         if (rinfo[NL80211_RATE_INFO_SHORT_GI])
1635                                 e->rx_rate.is_short_gi = 1;
1636                 }
1637
1638                 if (sinfo[NL80211_STA_INFO_TX_BITRATE] &&
1639                     !nla_parse_nested(rinfo, NL80211_RATE_INFO_MAX,
1640                                       sinfo[NL80211_STA_INFO_TX_BITRATE], rate_policy))
1641                 {
1642                         if (rinfo[NL80211_RATE_INFO_BITRATE])
1643                                 e->tx_rate.rate =
1644                                         nla_get_u16(rinfo[NL80211_RATE_INFO_BITRATE]) * 100;
1645
1646                         if (rinfo[NL80211_RATE_INFO_MCS])
1647                                 e->tx_rate.mcs = nla_get_u8(rinfo[NL80211_RATE_INFO_MCS]);
1648
1649                         if (rinfo[NL80211_RATE_INFO_40_MHZ_WIDTH])
1650                                 e->tx_rate.is_40mhz = 1;
1651
1652                         if (rinfo[NL80211_RATE_INFO_SHORT_GI])
1653                                 e->tx_rate.is_short_gi = 1;
1654                 }
1655         }
1656
1657         e->noise = 0; /* filled in by caller */
1658         arr->count++;
1659
1660         return NL_SKIP;
1661 }
1662
1663 static int nl80211_get_assoclist(const char *ifname, char *buf, int *len)
1664 {
1665         DIR *d;
1666         int i, noise = 0;
1667         struct dirent *de;
1668         struct nl80211_msg_conveyor *req;
1669         struct nl80211_array_buf arr = { .buf = buf, .count = 0 };
1670         struct iwinfo_assoclist_entry *e;
1671
1672         if ((d = opendir("/sys/class/net")) != NULL)
1673         {
1674                 while ((de = readdir(d)) != NULL)
1675                 {
1676                         if (!strncmp(de->d_name, ifname, strlen(ifname)) &&
1677                             (!de->d_name[strlen(ifname)] ||
1678                              !strncmp(&de->d_name[strlen(ifname)], ".sta", 4)))
1679                         {
1680                                 req = nl80211_msg(de->d_name, NL80211_CMD_GET_STATION,
1681                                                   NLM_F_DUMP);
1682
1683                                 if (req)
1684                                 {
1685                                         nl80211_send(req, nl80211_get_assoclist_cb, &arr);
1686                                         nl80211_free(req);
1687                                 }
1688                         }
1689                 }
1690
1691                 closedir(d);
1692
1693                 if (!nl80211_get_noise(ifname, &noise))
1694                         for (i = 0, e = arr.buf; i < arr.count; i++, e++)
1695                                 e->noise = noise;
1696
1697                 *len = (arr.count * sizeof(struct iwinfo_assoclist_entry));
1698                 return 0;
1699         }
1700
1701         return -1;
1702 }
1703
1704 static int nl80211_get_txpwrlist_cb(struct nl_msg *msg, void *arg)
1705 {
1706         int *dbm_max = arg;
1707         int ch_cur, ch_cmp, bands_remain, freqs_remain;
1708
1709         struct nlattr **attr = nl80211_parse(msg);
1710         struct nlattr *bands[NL80211_BAND_ATTR_MAX + 1];
1711         struct nlattr *freqs[NL80211_FREQUENCY_ATTR_MAX + 1];
1712         struct nlattr *band, *freq;
1713
1714         static struct nla_policy freq_policy[NL80211_FREQUENCY_ATTR_MAX + 1] = {
1715                 [NL80211_FREQUENCY_ATTR_FREQ]         = { .type = NLA_U32  },
1716                 [NL80211_FREQUENCY_ATTR_DISABLED]     = { .type = NLA_FLAG },
1717                 [NL80211_FREQUENCY_ATTR_PASSIVE_SCAN] = { .type = NLA_FLAG },
1718                 [NL80211_FREQUENCY_ATTR_NO_IBSS]      = { .type = NLA_FLAG },
1719                 [NL80211_FREQUENCY_ATTR_RADAR]        = { .type = NLA_FLAG },
1720                 [NL80211_FREQUENCY_ATTR_MAX_TX_POWER] = { .type = NLA_U32  },
1721         };
1722
1723         ch_cur = *dbm_max; /* value int* is initialized with channel by caller */
1724         *dbm_max = -1;
1725
1726         nla_for_each_nested(band, attr[NL80211_ATTR_WIPHY_BANDS], bands_remain)
1727         {
1728                 nla_parse(bands, NL80211_BAND_ATTR_MAX, nla_data(band),
1729                           nla_len(band), NULL);
1730
1731                 nla_for_each_nested(freq, bands[NL80211_BAND_ATTR_FREQS], freqs_remain)
1732                 {
1733                         nla_parse(freqs, NL80211_FREQUENCY_ATTR_MAX,
1734                                   nla_data(freq), nla_len(freq), freq_policy);
1735
1736                         ch_cmp = nl80211_freq2channel(nla_get_u32(
1737                                 freqs[NL80211_FREQUENCY_ATTR_FREQ]));
1738
1739                         if ((!ch_cur || (ch_cmp == ch_cur)) &&
1740                             freqs[NL80211_FREQUENCY_ATTR_MAX_TX_POWER])
1741                         {
1742                                 *dbm_max = (int)(0.01 * nla_get_u32(
1743                                         freqs[NL80211_FREQUENCY_ATTR_MAX_TX_POWER]));
1744
1745                                 break;
1746                         }
1747                 }
1748         }
1749
1750         return NL_SKIP;
1751 }
1752
1753 static int nl80211_get_txpwrlist(const char *ifname, char *buf, int *len)
1754 {
1755         int ch_cur;
1756         int dbm_max = -1, dbm_cur, dbm_cnt;
1757         struct nl80211_msg_conveyor *req;
1758         struct iwinfo_txpwrlist_entry entry;
1759
1760         if (nl80211_get_channel(ifname, &ch_cur))
1761                 ch_cur = 0;
1762
1763         req = nl80211_msg(ifname, NL80211_CMD_GET_WIPHY, 0);
1764         if (req)
1765         {
1766                 /* initialize the value pointer with channel for callback */
1767                 dbm_max = ch_cur;
1768
1769                 nl80211_send(req, nl80211_get_txpwrlist_cb, &dbm_max);
1770                 nl80211_free(req);
1771         }
1772
1773         if (dbm_max > 0)
1774         {
1775                 for (dbm_cur = 0, dbm_cnt = 0;
1776                      dbm_cur < dbm_max;
1777                      dbm_cur++, dbm_cnt++)
1778                 {
1779                         entry.dbm = dbm_cur;
1780                         entry.mw  = iwinfo_dbm2mw(dbm_cur);
1781
1782                         memcpy(&buf[dbm_cnt * sizeof(entry)], &entry, sizeof(entry));
1783                 }
1784
1785                 entry.dbm = dbm_max;
1786                 entry.mw  = iwinfo_dbm2mw(dbm_max);
1787
1788                 memcpy(&buf[dbm_cnt * sizeof(entry)], &entry, sizeof(entry));
1789                 dbm_cnt++;
1790
1791                 *len = dbm_cnt * sizeof(entry);
1792                 return 0;
1793         }
1794
1795         return -1;
1796 }
1797
1798 static void nl80211_get_scancrypto(const char *spec,
1799         struct iwinfo_crypto_entry *c)
1800 {
1801         if (strstr(spec, "WPA") || strstr(spec, "WEP"))
1802         {
1803                 c->enabled = 1;
1804
1805                 if (strstr(spec, "WPA2-") && strstr(spec, "WPA-"))
1806                         c->wpa_version = 3;
1807
1808                 else if (strstr(spec, "WPA2"))
1809                         c->wpa_version = 2;
1810
1811                 else if (strstr(spec, "WPA"))
1812                         c->wpa_version = 1;
1813
1814                 else if (strstr(spec, "WEP"))
1815                         c->auth_algs = IWINFO_AUTH_OPEN | IWINFO_AUTH_SHARED;
1816
1817
1818                 if (strstr(spec, "PSK"))
1819                         c->auth_suites |= IWINFO_KMGMT_PSK;
1820
1821                 if (strstr(spec, "802.1X") || strstr(spec, "EAP"))
1822                         c->auth_suites |= IWINFO_KMGMT_8021x;
1823
1824                 if (strstr(spec, "WPA-NONE"))
1825                         c->auth_suites |= IWINFO_KMGMT_NONE;
1826
1827
1828                 if (strstr(spec, "TKIP"))
1829                         c->pair_ciphers |= IWINFO_CIPHER_TKIP;
1830
1831                 if (strstr(spec, "CCMP"))
1832                         c->pair_ciphers |= IWINFO_CIPHER_CCMP;
1833
1834                 if (strstr(spec, "WEP-40"))
1835                         c->pair_ciphers |= IWINFO_CIPHER_WEP40;
1836
1837                 if (strstr(spec, "WEP-104"))
1838                         c->pair_ciphers |= IWINFO_CIPHER_WEP104;
1839
1840                 c->group_ciphers = c->pair_ciphers;
1841         }
1842         else
1843         {
1844                 c->enabled = 0;
1845         }
1846 }
1847
1848
1849 struct nl80211_scanlist {
1850         struct iwinfo_scanlist_entry *e;
1851         int len;
1852 };
1853
1854
1855 static void nl80211_get_scanlist_ie(struct nlattr **bss,
1856                                     struct iwinfo_scanlist_entry *e)
1857 {
1858         int ielen = nla_len(bss[NL80211_BSS_INFORMATION_ELEMENTS]);
1859         unsigned char *ie = nla_data(bss[NL80211_BSS_INFORMATION_ELEMENTS]);
1860         static unsigned char ms_oui[3] = { 0x00, 0x50, 0xf2 };
1861         int len;
1862
1863         while (ielen >= 2 && ielen >= ie[1])
1864         {
1865                 switch (ie[0])
1866                 {
1867                 case 0: /* SSID */
1868                         len = min(ie[1], IWINFO_ESSID_MAX_SIZE);
1869                         memcpy(e->ssid, ie + 2, len);
1870                         e->ssid[len] = 0;
1871                         break;
1872
1873                 case 48: /* RSN */
1874                         iwinfo_parse_rsn(&e->crypto, ie + 2, ie[1],
1875                                          IWINFO_CIPHER_CCMP, IWINFO_KMGMT_8021x);
1876                         break;
1877
1878                 case 221: /* Vendor */
1879                         if (ie[1] >= 4 && !memcmp(ie + 2, ms_oui, 3) && ie[5] == 1)
1880                                 iwinfo_parse_rsn(&e->crypto, ie + 6, ie[1] - 4,
1881                                                  IWINFO_CIPHER_TKIP, IWINFO_KMGMT_PSK);
1882                         break;
1883                 }
1884
1885                 ielen -= ie[1] + 2;
1886                 ie += ie[1] + 2;
1887         }
1888 }
1889
1890 static int nl80211_get_scanlist_cb(struct nl_msg *msg, void *arg)
1891 {
1892         int8_t rssi;
1893         uint16_t caps;
1894
1895         struct nl80211_scanlist *sl = arg;
1896         struct nlattr **tb = nl80211_parse(msg);
1897         struct nlattr *bss[NL80211_BSS_MAX + 1];
1898
1899         static struct nla_policy bss_policy[NL80211_BSS_MAX + 1] = {
1900                 [NL80211_BSS_TSF]                  = { .type = NLA_U64 },
1901                 [NL80211_BSS_FREQUENCY]            = { .type = NLA_U32 },
1902                 [NL80211_BSS_BSSID]                = {                 },
1903                 [NL80211_BSS_BEACON_INTERVAL]      = { .type = NLA_U16 },
1904                 [NL80211_BSS_CAPABILITY]           = { .type = NLA_U16 },
1905                 [NL80211_BSS_INFORMATION_ELEMENTS] = {                 },
1906                 [NL80211_BSS_SIGNAL_MBM]           = { .type = NLA_U32 },
1907                 [NL80211_BSS_SIGNAL_UNSPEC]        = { .type = NLA_U8  },
1908                 [NL80211_BSS_STATUS]               = { .type = NLA_U32 },
1909                 [NL80211_BSS_SEEN_MS_AGO]          = { .type = NLA_U32 },
1910                 [NL80211_BSS_BEACON_IES]           = {                 },
1911         };
1912
1913         if (!tb[NL80211_ATTR_BSS] ||
1914                 nla_parse_nested(bss, NL80211_BSS_MAX, tb[NL80211_ATTR_BSS],
1915                                  bss_policy) ||
1916                 !bss[NL80211_BSS_BSSID])
1917         {
1918                 return NL_SKIP;
1919         }
1920
1921         if (bss[NL80211_BSS_CAPABILITY])
1922                 caps = nla_get_u16(bss[NL80211_BSS_CAPABILITY]);
1923         else
1924                 caps = 0;
1925
1926         memset(sl->e, 0, sizeof(*sl->e));
1927         memcpy(sl->e->mac, nla_data(bss[NL80211_BSS_BSSID]), 6);
1928
1929         if (caps & (1<<1))
1930                 sl->e->mode = IWINFO_OPMODE_ADHOC;
1931         else if (caps & (1<<0))
1932                 sl->e->mode = IWINFO_OPMODE_MASTER;
1933         else
1934                 sl->e->mode = IWINFO_OPMODE_MESHPOINT;
1935
1936         if (caps & (1<<4))
1937                 sl->e->crypto.enabled = 1;
1938
1939         if (bss[NL80211_BSS_FREQUENCY])
1940                 sl->e->channel = nl80211_freq2channel(nla_get_u32(
1941                         bss[NL80211_BSS_FREQUENCY]));
1942
1943         if (bss[NL80211_BSS_INFORMATION_ELEMENTS])
1944                 nl80211_get_scanlist_ie(bss, sl->e);
1945
1946         if (bss[NL80211_BSS_SIGNAL_MBM])
1947         {
1948                 sl->e->signal =
1949                         (uint8_t)((int32_t)nla_get_u32(bss[NL80211_BSS_SIGNAL_MBM]) / 100);
1950
1951                 rssi = sl->e->signal - 0x100;
1952
1953                 if (rssi < -110)
1954                         rssi = -110;
1955                 else if (rssi > -40)
1956                         rssi = -40;
1957
1958                 sl->e->quality = (rssi + 110);
1959                 sl->e->quality_max = 70;
1960         }
1961
1962         if (sl->e->crypto.enabled && !sl->e->crypto.wpa_version)
1963         {
1964                 sl->e->crypto.auth_algs    = IWINFO_AUTH_OPEN | IWINFO_AUTH_SHARED;
1965                 sl->e->crypto.pair_ciphers = IWINFO_CIPHER_WEP40 | IWINFO_CIPHER_WEP104;
1966         }
1967
1968         sl->e++;
1969         sl->len++;
1970
1971         return NL_SKIP;
1972 }
1973
1974 static int nl80211_get_scanlist_nl(const char *ifname, char *buf, int *len)
1975 {
1976         struct nl80211_msg_conveyor *req;
1977         struct nl80211_scanlist sl = { .e = (struct iwinfo_scanlist_entry *)buf };
1978
1979         req = nl80211_msg(ifname, NL80211_CMD_TRIGGER_SCAN, 0);
1980         if (req)
1981         {
1982                 nl80211_send(req, NULL, NULL);
1983                 nl80211_free(req);
1984         }
1985
1986         nl80211_wait("nl80211", "scan", NL80211_CMD_NEW_SCAN_RESULTS);
1987
1988         req = nl80211_msg(ifname, NL80211_CMD_GET_SCAN, NLM_F_DUMP);
1989         if (req)
1990         {
1991                 nl80211_send(req, nl80211_get_scanlist_cb, &sl);
1992                 nl80211_free(req);
1993         }
1994
1995         *len = sl.len * sizeof(struct iwinfo_scanlist_entry);
1996         return *len ? 0 : -1;
1997 }
1998
1999 static int wpasupp_ssid_decode(const char *in, char *out, int outlen)
2000 {
2001 #define hex(x) \
2002         (((x) >= 'a') ? ((x) - 'a' + 10) : \
2003                 (((x) >= 'A') ? ((x) - 'A' + 10) : ((x) - '0')))
2004
2005         int len = 0;
2006
2007         while (*in)
2008         {
2009                 if (len + 1 >= outlen)
2010                         break;
2011
2012                 switch (*in)
2013                 {
2014                 case '\\':
2015                         in++;
2016                         switch (*in)
2017                         {
2018                         case 'n':
2019                                 out[len++] = '\n'; in++;
2020                                 break;
2021
2022                         case 'r':
2023                                 out[len++] = '\r'; in++;
2024                                 break;
2025
2026                         case 't':
2027                                 out[len++] = '\t'; in++;
2028                                 break;
2029
2030                         case 'e':
2031                                 out[len++] = '\e'; in++;
2032                                 break;
2033
2034                         case 'x':
2035                                 if (isxdigit(*(in+1)) && isxdigit(*(in+2)))
2036                                         out[len++] = hex(*(in+1)) * 16 + hex(*(in+2));
2037                                 in += 3;
2038                                 break;
2039
2040                         default:
2041                                 out[len++] = *in++;
2042                                 break;
2043                         }
2044                         break;
2045
2046                 default:
2047                         out[len++] = *in++;
2048                         break;
2049                 }
2050         }
2051
2052         if (outlen > len)
2053                 out[len] = '\0';
2054
2055         return len;
2056 }
2057
2058 static int nl80211_get_scanlist(const char *ifname, char *buf, int *len)
2059 {
2060         int freq, rssi, qmax, count, mode;
2061         char *res;
2062         char ssid[129] = { 0 };
2063         char bssid[18] = { 0 };
2064         char cipher[256] = { 0 };
2065
2066         /* Got a radioX pseudo interface, find some interface on it or create one */
2067         if (!strncmp(ifname, "radio", 5))
2068         {
2069                 /* Reuse existing interface */
2070                 if ((res = nl80211_phy2ifname(ifname)) != NULL)
2071                 {
2072                         return nl80211_get_scanlist(res, buf, len);
2073                 }
2074
2075                 /* Need to spawn a temporary iface for scanning */
2076                 else if ((res = nl80211_ifadd(ifname)) != NULL)
2077                 {
2078                         count = nl80211_get_scanlist(res, buf, len);
2079                         nl80211_ifdel(res);
2080                         return count;
2081                 }
2082         }
2083
2084         struct iwinfo_scanlist_entry *e = (struct iwinfo_scanlist_entry *)buf;
2085
2086         /* WPA supplicant */
2087         if ((res = nl80211_wpactl_info(ifname, "SCAN", "CTRL-EVENT-SCAN-RESULTS")))
2088         {
2089                 if ((res = nl80211_wpactl_info(ifname, "SCAN_RESULTS", NULL)))
2090                 {
2091                         nl80211_get_quality_max(ifname, &qmax);
2092
2093                         count = -1;
2094
2095                         do {
2096                                 if (res[0] == '<')
2097                                 {
2098                                         /* skip log lines */
2099                                         goto nextline;
2100                                 }
2101                                 if (count < 0)
2102                                 {
2103                                         /* skip header line */
2104                                         count++;
2105                                         goto nextline;
2106                                 }
2107                                 if (sscanf(res, "%17s %d %d %255s%*[ \t]%128[^\n]\n",
2108                                               bssid, &freq, &rssi, cipher, ssid) < 5)
2109                                 {
2110                                         /* skip malformed lines */
2111                                         goto nextline;
2112                                 }
2113                                 /* BSSID */
2114                                 e->mac[0] = strtol(&bssid[0],  NULL, 16);
2115                                 e->mac[1] = strtol(&bssid[3],  NULL, 16);
2116                                 e->mac[2] = strtol(&bssid[6],  NULL, 16);
2117                                 e->mac[3] = strtol(&bssid[9],  NULL, 16);
2118                                 e->mac[4] = strtol(&bssid[12], NULL, 16);
2119                                 e->mac[5] = strtol(&bssid[15], NULL, 16);
2120
2121                                 /* SSID */
2122                                 wpasupp_ssid_decode(ssid, e->ssid, sizeof(e->ssid));
2123
2124                                 /* Mode (assume master) */
2125                                 if (strstr(cipher,"[MESH]"))
2126                                         e->mode = IWINFO_OPMODE_MESHPOINT;
2127                                 else
2128                                         e->mode = IWINFO_OPMODE_MASTER;
2129
2130                                 /* Channel */
2131                                 e->channel = nl80211_freq2channel(freq);
2132
2133                                 /* Signal */
2134                                 e->signal = rssi;
2135
2136                                 /* Quality */
2137                                 if (rssi < 0)
2138                                 {
2139                                         /* The cfg80211 wext compat layer assumes a signal range
2140                                          * of -110 dBm to -40 dBm, the quality value is derived
2141                                          * by adding 110 to the signal level */
2142                                         if (rssi < -110)
2143                                                 rssi = -110;
2144                                         else if (rssi > -40)
2145                                                 rssi = -40;
2146
2147                                         e->quality = (rssi + 110);
2148                                 }
2149                                 else
2150                                 {
2151                                         e->quality = rssi;
2152                                 }
2153
2154                                 /* Max. Quality */
2155                                 e->quality_max = qmax;
2156
2157                                 /* Crypto */
2158                                 nl80211_get_scancrypto(cipher, &e->crypto);
2159
2160                                 count++;
2161                                 e++;
2162
2163                                 memset(ssid, 0, sizeof(ssid));
2164                                 memset(bssid, 0, sizeof(bssid));
2165                                 memset(cipher, 0, sizeof(cipher));
2166
2167                         nextline:
2168                                 /* advance to next line */
2169                                 while( *res && *res++ != '\n' );
2170                         }
2171                         while( *res );
2172
2173                         *len = count * sizeof(struct iwinfo_scanlist_entry);
2174                         return 0;
2175                 }
2176         }
2177
2178         /* station / ad-hoc / monitor scan */
2179         else if (!nl80211_get_mode(ifname, &mode) &&
2180                  (mode == IWINFO_OPMODE_ADHOC ||
2181                   mode == IWINFO_OPMODE_MASTER ||
2182                   mode == IWINFO_OPMODE_CLIENT ||
2183                   mode == IWINFO_OPMODE_MONITOR) &&
2184                  iwinfo_ifup(ifname))
2185         {
2186                 return nl80211_get_scanlist_nl(ifname, buf, len);
2187         }
2188
2189         /* AP scan */
2190         else
2191         {
2192                 /* Got a temp interface, don't create yet another one */
2193                 if (!strncmp(ifname, "tmp.", 4))
2194                 {
2195                         if (!iwinfo_ifup(ifname))
2196                                 return -1;
2197
2198                         nl80211_get_scanlist_nl(ifname, buf, len);
2199                         iwinfo_ifdown(ifname);
2200                         return 0;
2201                 }
2202
2203                 /* Spawn a new scan interface */
2204                 else
2205                 {
2206                         if (!(res = nl80211_ifadd(ifname)))
2207                                 goto out;
2208
2209                         iwinfo_ifmac(res);
2210
2211                         /* if we can take the new interface up, the driver supports an
2212                          * additional interface and there's no need to tear down the ap */
2213                         if (iwinfo_ifup(res))
2214                         {
2215                                 nl80211_get_scanlist_nl(res, buf, len);
2216                                 iwinfo_ifdown(res);
2217                         }
2218
2219                         /* driver cannot create secondary interface, take down ap
2220                          * during scan */
2221                         else if (iwinfo_ifdown(ifname) && iwinfo_ifup(res))
2222                         {
2223                                 nl80211_get_scanlist_nl(res, buf, len);
2224                                 iwinfo_ifdown(res);
2225                                 iwinfo_ifup(ifname);
2226                                 nl80211_hostapd_hup(ifname);
2227                         }
2228
2229                 out:
2230                         nl80211_ifdel(res);
2231                         return 0;
2232                 }
2233         }
2234
2235         return -1;
2236 }
2237
2238 static int nl80211_get_freqlist_cb(struct nl_msg *msg, void *arg)
2239 {
2240         int bands_remain, freqs_remain;
2241
2242         struct nl80211_array_buf *arr = arg;
2243         struct iwinfo_freqlist_entry *e = arr->buf;
2244
2245         struct nlattr **attr = nl80211_parse(msg);
2246         struct nlattr *bands[NL80211_BAND_ATTR_MAX + 1];
2247         struct nlattr *freqs[NL80211_FREQUENCY_ATTR_MAX + 1];
2248         struct nlattr *band, *freq;
2249
2250         static struct nla_policy freq_policy[NL80211_FREQUENCY_ATTR_MAX + 1] = {
2251                 [NL80211_FREQUENCY_ATTR_FREQ]         = { .type = NLA_U32  },
2252                 [NL80211_FREQUENCY_ATTR_DISABLED]     = { .type = NLA_FLAG },
2253                 [NL80211_FREQUENCY_ATTR_PASSIVE_SCAN] = { .type = NLA_FLAG },
2254                 [NL80211_FREQUENCY_ATTR_NO_IBSS]      = { .type = NLA_FLAG },
2255                 [NL80211_FREQUENCY_ATTR_RADAR]        = { .type = NLA_FLAG },
2256                 [NL80211_FREQUENCY_ATTR_MAX_TX_POWER] = { .type = NLA_U32  },
2257         };
2258
2259         nla_for_each_nested(band, attr[NL80211_ATTR_WIPHY_BANDS], bands_remain)
2260         {
2261                 nla_parse(bands, NL80211_BAND_ATTR_MAX,
2262                           nla_data(band), nla_len(band), NULL);
2263
2264                 nla_for_each_nested(freq, bands[NL80211_BAND_ATTR_FREQS], freqs_remain)
2265                 {
2266                         nla_parse(freqs, NL80211_FREQUENCY_ATTR_MAX,
2267                                   nla_data(freq), nla_len(freq), NULL);
2268
2269                         if (!freqs[NL80211_FREQUENCY_ATTR_FREQ] ||
2270                             freqs[NL80211_FREQUENCY_ATTR_DISABLED])
2271                                 continue;
2272
2273                         e->mhz = nla_get_u32(freqs[NL80211_FREQUENCY_ATTR_FREQ]);
2274                         e->channel = nl80211_freq2channel(e->mhz);
2275
2276                         e->restricted = (
2277                                 freqs[NL80211_FREQUENCY_ATTR_PASSIVE_SCAN] ||
2278                                 freqs[NL80211_FREQUENCY_ATTR_NO_IBSS]      ||
2279                                 freqs[NL80211_FREQUENCY_ATTR_RADAR]
2280                         ) ? 1 : 0;
2281
2282                         e++;
2283                         arr->count++;
2284                 }
2285         }
2286
2287         return NL_SKIP;
2288 }
2289
2290 static int nl80211_get_freqlist(const char *ifname, char *buf, int *len)
2291 {
2292         struct nl80211_msg_conveyor *req;
2293         struct nl80211_array_buf arr = { .buf = buf, .count = 0 };
2294
2295         req = nl80211_msg(ifname, NL80211_CMD_GET_WIPHY, 0);
2296         if (req)
2297         {
2298                 nl80211_send(req, nl80211_get_freqlist_cb, &arr);
2299                 nl80211_free(req);
2300         }
2301
2302         if (arr.count > 0)
2303         {
2304                 *len = arr.count * sizeof(struct iwinfo_freqlist_entry);
2305                 return 0;
2306         }
2307
2308         return -1;
2309 }
2310
2311 static int nl80211_get_country_cb(struct nl_msg *msg, void *arg)
2312 {
2313         char *buf = arg;
2314         struct nlattr **attr = nl80211_parse(msg);
2315
2316         if (attr[NL80211_ATTR_REG_ALPHA2])
2317                 memcpy(buf, nla_data(attr[NL80211_ATTR_REG_ALPHA2]), 2);
2318         else
2319                 buf[0] = 0;
2320
2321         return NL_SKIP;
2322 }
2323
2324 static int nl80211_get_country(const char *ifname, char *buf)
2325 {
2326         int rv = -1;
2327         struct nl80211_msg_conveyor *req;
2328
2329         req = nl80211_msg(ifname, NL80211_CMD_GET_REG, 0);
2330         if (req)
2331         {
2332                 nl80211_send(req, nl80211_get_country_cb, buf);
2333                 nl80211_free(req);
2334
2335                 if (buf[0])
2336                         rv = 0;
2337         }
2338
2339         return rv;
2340 }
2341
2342 static int nl80211_get_countrylist(const char *ifname, char *buf, int *len)
2343 {
2344         int i, count;
2345         struct iwinfo_country_entry *e = (struct iwinfo_country_entry *)buf;
2346         const struct iwinfo_iso3166_label *l;
2347
2348         for (l = IWINFO_ISO3166_NAMES, count = 0; l->iso3166; l++, e++, count++)
2349         {
2350                 e->iso3166 = l->iso3166;
2351                 e->ccode[0] = (l->iso3166 / 256);
2352                 e->ccode[1] = (l->iso3166 % 256);
2353         }
2354
2355         *len = (count * sizeof(struct iwinfo_country_entry));
2356         return 0;
2357 }
2358
2359 static int nl80211_get_hwmodelist_cb(struct nl_msg *msg, void *arg)
2360 {
2361         int *modes = arg;
2362         int bands_remain, freqs_remain;
2363         uint16_t caps = 0;
2364         uint32_t vht_caps = 0;
2365         struct nlattr **attr = nl80211_parse(msg);
2366         struct nlattr *bands[NL80211_BAND_ATTR_MAX + 1];
2367         struct nlattr *freqs[NL80211_FREQUENCY_ATTR_MAX + 1];
2368         struct nlattr *band, *freq;
2369
2370         *modes = 0;
2371
2372         if (attr[NL80211_ATTR_WIPHY_BANDS])
2373         {
2374                 nla_for_each_nested(band, attr[NL80211_ATTR_WIPHY_BANDS], bands_remain)
2375                 {
2376                         nla_parse(bands, NL80211_BAND_ATTR_MAX,
2377                                   nla_data(band), nla_len(band), NULL);
2378
2379                         if (bands[NL80211_BAND_ATTR_HT_CAPA])
2380                                 caps = nla_get_u16(bands[NL80211_BAND_ATTR_HT_CAPA]);
2381
2382                         /* Treat any nonzero capability as 11n */
2383                         if (caps > 0)
2384                                 *modes |= IWINFO_80211_N;
2385
2386                         if (bands[NL80211_BAND_ATTR_VHT_CAPA])
2387                                 vht_caps = nla_get_u32(bands[NL80211_BAND_ATTR_VHT_CAPA]);
2388
2389                         /* Treat any nonzero capability as 11ac */
2390                         if (vht_caps > 0)
2391                                 *modes |= IWINFO_80211_AC;
2392
2393                         nla_for_each_nested(freq, bands[NL80211_BAND_ATTR_FREQS],
2394                                             freqs_remain)
2395                         {
2396                                 nla_parse(freqs, NL80211_FREQUENCY_ATTR_MAX,
2397                                           nla_data(freq), nla_len(freq), NULL);
2398
2399                                 if (!freqs[NL80211_FREQUENCY_ATTR_FREQ])
2400                                         continue;
2401
2402                                 if (nla_get_u32(freqs[NL80211_FREQUENCY_ATTR_FREQ]) < 2485)
2403                                 {
2404                                         *modes |= IWINFO_80211_B;
2405                                         *modes |= IWINFO_80211_G;
2406                                 }
2407                                 else if (!(*modes & IWINFO_80211_AC))
2408                                 {
2409                                         *modes |= IWINFO_80211_A;
2410                                 }
2411                         }
2412                 }
2413         }
2414
2415         return NL_SKIP;
2416 }
2417
2418 static int nl80211_get_hwmodelist(const char *ifname, int *buf)
2419 {
2420         struct nl80211_msg_conveyor *req;
2421
2422         req = nl80211_msg(ifname, NL80211_CMD_GET_WIPHY, 0);
2423         if (req)
2424         {
2425                 nl80211_send(req, nl80211_get_hwmodelist_cb, buf);
2426                 nl80211_free(req);
2427         }
2428
2429         return *buf ? 0 : -1;
2430 }
2431
2432 static int nl80211_get_ifcomb_cb(struct nl_msg *msg, void *arg)
2433 {
2434         struct nlattr **attr = nl80211_parse(msg);
2435         struct nlattr *comb;
2436         int *ret = arg;
2437         int comb_rem, limit_rem, mode_rem;
2438
2439         *ret = 0;
2440         if (!attr[NL80211_ATTR_INTERFACE_COMBINATIONS])
2441                 return NL_SKIP;
2442
2443         nla_for_each_nested(comb, attr[NL80211_ATTR_INTERFACE_COMBINATIONS], comb_rem)
2444         {
2445                 static struct nla_policy iface_combination_policy[NUM_NL80211_IFACE_COMB] = {
2446                         [NL80211_IFACE_COMB_LIMITS] = { .type = NLA_NESTED },
2447                         [NL80211_IFACE_COMB_MAXNUM] = { .type = NLA_U32 },
2448                 };
2449                 struct nlattr *tb_comb[NUM_NL80211_IFACE_COMB+1];
2450                 static struct nla_policy iface_limit_policy[NUM_NL80211_IFACE_LIMIT] = {
2451                         [NL80211_IFACE_LIMIT_TYPES] = { .type = NLA_NESTED },
2452                         [NL80211_IFACE_LIMIT_MAX] = { .type = NLA_U32 },
2453                 };
2454                 struct nlattr *tb_limit[NUM_NL80211_IFACE_LIMIT+1];
2455                 struct nlattr *limit;
2456
2457                 nla_parse_nested(tb_comb, NUM_NL80211_IFACE_COMB, comb, iface_combination_policy);
2458
2459                 if (!tb_comb[NL80211_IFACE_COMB_LIMITS])
2460                         continue;
2461
2462                 nla_for_each_nested(limit, tb_comb[NL80211_IFACE_COMB_LIMITS], limit_rem)
2463                 {
2464                         struct nlattr *mode;
2465
2466                         nla_parse_nested(tb_limit, NUM_NL80211_IFACE_LIMIT, limit, iface_limit_policy);
2467
2468                         if (!tb_limit[NL80211_IFACE_LIMIT_TYPES] ||
2469                             !tb_limit[NL80211_IFACE_LIMIT_MAX])
2470                                 continue;
2471
2472                         if (nla_get_u32(tb_limit[NL80211_IFACE_LIMIT_MAX]) < 2)
2473                                 continue;
2474
2475                         nla_for_each_nested(mode, tb_limit[NL80211_IFACE_LIMIT_TYPES], mode_rem) {
2476                                 if (nla_type(mode) == NL80211_IFTYPE_AP)
2477                                         *ret = 1;
2478                         }
2479                 }
2480         }
2481
2482         return NL_SKIP;
2483 }
2484
2485 static int nl80211_get_mbssid_support(const char *ifname, int *buf)
2486 {
2487         struct nl80211_msg_conveyor *req;
2488
2489         req = nl80211_msg(ifname, NL80211_CMD_GET_WIPHY, 0);
2490         if (!req)
2491                 return -1;
2492
2493         nl80211_send(req, nl80211_get_ifcomb_cb, buf);
2494         nl80211_free(req);
2495         return 0;
2496 }
2497
2498 static int nl80211_get_hardware_id(const char *ifname, char *buf)
2499 {
2500         int rv;
2501         char *res;
2502
2503         /* Got a radioX pseudo interface, find some interface on it or create one */
2504         if (!strncmp(ifname, "radio", 5))
2505         {
2506                 /* Reuse existing interface */
2507                 if ((res = nl80211_phy2ifname(ifname)) != NULL)
2508                 {
2509                         rv = wext_ops.hardware_id(res, buf);
2510                 }
2511
2512                 /* Need to spawn a temporary iface for finding IDs */
2513                 else if ((res = nl80211_ifadd(ifname)) != NULL)
2514                 {
2515                         rv = wext_ops.hardware_id(res, buf);
2516                         nl80211_ifdel(res);
2517                 }
2518         }
2519         else
2520         {
2521                 rv = wext_ops.hardware_id(ifname, buf);
2522         }
2523
2524         /* Failed to obtain hardware IDs, search board config */
2525         if (rv)
2526         {
2527                 rv = iwinfo_hardware_id_from_mtd((struct iwinfo_hardware_id *)buf);
2528         }
2529
2530         return rv;
2531 }
2532
2533 static const struct iwinfo_hardware_entry *
2534 nl80211_get_hardware_entry(const char *ifname)
2535 {
2536         struct iwinfo_hardware_id id;
2537
2538         if (nl80211_get_hardware_id(ifname, (char *)&id))
2539                 return NULL;
2540
2541         return iwinfo_hardware(&id);
2542 }
2543
2544 static int nl80211_get_hardware_name(const char *ifname, char *buf)
2545 {
2546         const struct iwinfo_hardware_entry *hw;
2547
2548         if (!(hw = nl80211_get_hardware_entry(ifname)))
2549                 sprintf(buf, "Generic MAC80211");
2550         else
2551                 sprintf(buf, "%s %s", hw->vendor_name, hw->device_name);
2552
2553         return 0;
2554 }
2555
2556 static int nl80211_get_txpower_offset(const char *ifname, int *buf)
2557 {
2558         const struct iwinfo_hardware_entry *hw;
2559
2560         if (!(hw = nl80211_get_hardware_entry(ifname)))
2561                 return -1;
2562
2563         *buf = hw->txpower_offset;
2564         return 0;
2565 }
2566
2567 static int nl80211_get_frequency_offset(const char *ifname, int *buf)
2568 {
2569         const struct iwinfo_hardware_entry *hw;
2570
2571         if (!(hw = nl80211_get_hardware_entry(ifname)))
2572                 return -1;
2573
2574         *buf = hw->frequency_offset;
2575         return 0;
2576 }
2577
2578 static int nl80211_lookup_phyname(const char *section, char *buf)
2579 {
2580         int idx;
2581
2582         if ((idx = nl80211_phy_idx_from_uci(section)) < 0)
2583                 return -1;
2584
2585         sprintf(buf, "phy%d", idx);
2586         return 0;
2587 }
2588
2589 const struct iwinfo_ops nl80211_ops = {
2590         .name             = "nl80211",
2591         .probe            = nl80211_probe,
2592         .channel          = nl80211_get_channel,
2593         .frequency        = nl80211_get_frequency,
2594         .frequency_offset = nl80211_get_frequency_offset,
2595         .txpower          = nl80211_get_txpower,
2596         .txpower_offset   = nl80211_get_txpower_offset,
2597         .bitrate          = nl80211_get_bitrate,
2598         .signal           = nl80211_get_signal,
2599         .noise            = nl80211_get_noise,
2600         .quality          = nl80211_get_quality,
2601         .quality_max      = nl80211_get_quality_max,
2602         .mbssid_support   = nl80211_get_mbssid_support,
2603         .hwmodelist       = nl80211_get_hwmodelist,
2604         .mode             = nl80211_get_mode,
2605         .ssid             = nl80211_get_ssid,
2606         .bssid            = nl80211_get_bssid,
2607         .country          = nl80211_get_country,
2608         .hardware_id      = nl80211_get_hardware_id,
2609         .hardware_name    = nl80211_get_hardware_name,
2610         .encryption       = nl80211_get_encryption,
2611         .phyname          = nl80211_get_phyname,
2612         .assoclist        = nl80211_get_assoclist,
2613         .txpwrlist        = nl80211_get_txpwrlist,
2614         .scanlist         = nl80211_get_scanlist,
2615         .freqlist         = nl80211_get_freqlist,
2616         .countrylist      = nl80211_get_countrylist,
2617         .lookup_phy       = nl80211_lookup_phyname,
2618         .close            = nl80211_close
2619 };