package/network/utils/iwinfo/src/iwinfo_nl80211.c

   1 /*
   2  * iwinfo - Wireless Information Library - NL80211 Backend
   3  *
   4  *   Copyright (C) 2010 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 "iwinfo/nl80211.h"
  26 #include "iwinfo/wext.h"
  27
  28 #define min(x, y) ((x) < (y)) ? (x) : (y)
  29
  30 static struct nl80211_state *nls = NULL;
  31
  32 static int nl80211_init(void)
  33 {
  34         int err, fd;
  35
  36         if (!nls)
  37         {
  38                 nls = malloc(sizeof(struct nl80211_state));
  39                 if (!nls) {
  40                         err = -ENOMEM;
  41                         goto err;
  42                 }
  43
  44                 memset(nls, 0, sizeof(*nls));
  45
  46                 nls->nl_sock = nl_socket_alloc();
  47                 if (!nls->nl_sock) {
  48                         err = -ENOMEM;
  49                         goto err;
  50                 }
  51
  52                 if (genl_connect(nls->nl_sock)) {
  53                         err = -ENOLINK;
  54                         goto err;
  55                 }
  56
  57                 fd = nl_socket_get_fd(nls->nl_sock);
  58                 if (fcntl(fd, F_SETFD, fcntl(fd, F_GETFD) | FD_CLOEXEC) < 0) {
  59                         err = -EINVAL;
  60                         goto err;
  61                 }
  62
  63                 if (genl_ctrl_alloc_cache(nls->nl_sock, &nls->nl_cache)) {
  64                         err = -ENOMEM;
  65                         goto err;
  66                 }
  67
  68                 nls->nl80211 = genl_ctrl_search_by_name(nls->nl_cache, "nl80211");
  69                 if (!nls->nl80211) {
  70                         err = -ENOENT;
  71                         goto err;
  72                 }
  73
  74                 nls->nlctrl = genl_ctrl_search_by_name(nls->nl_cache, "nlctrl");
  75                 if (!nls->nlctrl) {
  76                         err = -ENOENT;
  77                         goto err;
  78                 }
  79         }
  80
  81         return 0;
  82
  83
  84 err:
  85         nl80211_close();
  86         return err;
  87 }
  88
  89
  90 static int nl80211_msg_error(struct sockaddr_nl *nla,
  91         struct nlmsgerr *err, void *arg)
  92 {
  93         int *ret = arg;
  94         *ret = err->error;
  95         return NL_STOP;
  96 }
  97
  98 static int nl80211_msg_finish(struct nl_msg *msg, void *arg)
  99 {
 100         int *ret = arg;
 101         *ret = 0;
 102         return NL_SKIP;
 103 }
 104
 105 static int nl80211_msg_ack(struct nl_msg *msg, void *arg)
 106 {
 107         int *ret = arg;
 108         *ret = 0;
 109         return NL_STOP;
 110 }
 111
 112 static int nl80211_msg_response(struct nl_msg *msg, void *arg)
 113 {
 114         return NL_SKIP;
 115 }
 116
 117 static void nl80211_free(struct nl80211_msg_conveyor *cv)
 118 {
 119         if (cv)
 120         {
 121                 if (cv->cb)
 122                         nl_cb_put(cv->cb);
 123
 124                 if (cv->msg)
 125                         nlmsg_free(cv->msg);
 126
 127                 cv->cb  = NULL;
 128                 cv->msg = NULL;
 129         }
 130 }
 131
 132 static struct nl80211_msg_conveyor * nl80211_new(struct genl_family *family,
 133                                                  int cmd, int flags)
 134 {
 135         static struct nl80211_msg_conveyor cv;
 136
 137         struct nl_msg *req = NULL;
 138         struct nl_cb *cb = NULL;
 139
 140         req = nlmsg_alloc();
 141         if (!req)
 142                 goto err;
 143
 144         cb = nl_cb_alloc(NL_CB_DEFAULT);
 145         if (!cb)
 146                 goto err;
 147
 148         genlmsg_put(req, 0, 0, genl_family_get_id(family), 0, flags, cmd, 0);
 149
 150         cv.msg = req;
 151         cv.cb  = cb;
 152
 153         return &cv;
 154
 155 err:
 156 nla_put_failure:
 157         if (cb)
 158                 nl_cb_put(cb);
 159
 160         if (req)
 161                 nlmsg_free(req);
 162
 163         return NULL;
 164 }
 165
 166 static struct nl80211_msg_conveyor * nl80211_ctl(int cmd, int flags)
 167 {
 168         if (nl80211_init() < 0)
 169                 return NULL;
 170
 171         return nl80211_new(nls->nlctrl, cmd, flags);
 172 }
 173
 174 static struct nl80211_msg_conveyor * nl80211_msg(const char *ifname,
 175                                                  int cmd, int flags)
 176 {
 177         int ifidx = -1, phyidx = -1;
 178         struct nl80211_msg_conveyor *cv;
 179
 180         if (nl80211_init() < 0)
 181                 return NULL;
 182
 183         if (!strncmp(ifname, "phy", 3))
 184                 phyidx = atoi(&ifname[3]);
 185         else if (!strncmp(ifname, "radio", 5))
 186                 phyidx = atoi(&ifname[5]);
 187         else if (!strncmp(ifname, "mon.", 4))
 188                 ifidx = if_nametoindex(&ifname[4]);
 189         else
 190                 ifidx = if_nametoindex(ifname);
 191
 192         if ((ifidx < 0) && (phyidx < 0))
 193                 return NULL;
 194
 195         cv = nl80211_new(nls->nl80211, cmd, flags);
 196         if (!cv)
 197                 return NULL;
 198
 199         if (ifidx > -1)
 200                 NLA_PUT_U32(cv->msg, NL80211_ATTR_IFINDEX, ifidx);
 201
 202         if (phyidx > -1)
 203                 NLA_PUT_U32(cv->msg, NL80211_ATTR_WIPHY, phyidx);
 204
 205         return cv;
 206
 207 nla_put_failure:
 208         nl80211_free(cv);
 209         return NULL;
 210 }
 211
 212 static struct nl80211_msg_conveyor * nl80211_send(
 213         struct nl80211_msg_conveyor *cv,
 214         int (*cb_func)(struct nl_msg *, void *), void *cb_arg
 215 ) {
 216         static struct nl80211_msg_conveyor rcv;
 217         int err = 1;
 218
 219         if (cb_func)
 220                 nl_cb_set(cv->cb, NL_CB_VALID, NL_CB_CUSTOM, cb_func, cb_arg);
 221         else
 222                 nl_cb_set(cv->cb, NL_CB_VALID, NL_CB_CUSTOM, nl80211_msg_response, &rcv);
 223
 224         if (nl_send_auto_complete(nls->nl_sock, cv->msg) < 0)
 225                 goto err;
 226
 227         nl_cb_err(cv->cb,               NL_CB_CUSTOM, nl80211_msg_error,  &err);
 228         nl_cb_set(cv->cb, NL_CB_FINISH, NL_CB_CUSTOM, nl80211_msg_finish, &err);
 229         nl_cb_set(cv->cb, NL_CB_ACK,    NL_CB_CUSTOM, nl80211_msg_ack,    &err);
 230
 231         while (err > 0)
 232                 nl_recvmsgs(nls->nl_sock, cv->cb);
 233
 234         return &rcv;
 235
 236 err:
 237         nl_cb_put(cv->cb);
 238         nlmsg_free(cv->msg);
 239
 240         return NULL;
 241 }
 242
 243 static struct nlattr ** nl80211_parse(struct nl_msg *msg)
 244 {
 245         struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
 246         static struct nlattr *attr[NL80211_ATTR_MAX + 1];
 247
 248         nla_parse(attr, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
 249                   genlmsg_attrlen(gnlh, 0), NULL);
 250
 251         return attr;
 252 }
 253
 254
 255 static int nl80211_subscribe_cb(struct nl_msg *msg, void *arg)
 256 {
 257         struct nl80211_group_conveyor *cv = arg;
 258
 259         struct nlattr **attr = nl80211_parse(msg);
 260         struct nlattr *mgrpinfo[CTRL_ATTR_MCAST_GRP_MAX + 1];
 261         struct nlattr *mgrp;
 262         int mgrpidx;
 263
 264         if (!attr[CTRL_ATTR_MCAST_GROUPS])
 265                 return NL_SKIP;
 266
 267         nla_for_each_nested(mgrp, attr[CTRL_ATTR_MCAST_GROUPS], mgrpidx)
 268         {
 269                 nla_parse(mgrpinfo, CTRL_ATTR_MCAST_GRP_MAX,
 270                           nla_data(mgrp), nla_len(mgrp), NULL);
 271
 272                 if (mgrpinfo[CTRL_ATTR_MCAST_GRP_ID] &&
 273                     mgrpinfo[CTRL_ATTR_MCAST_GRP_NAME] &&
 274                     !strncmp(nla_data(mgrpinfo[CTRL_ATTR_MCAST_GRP_NAME]),
 275                              cv->name, nla_len(mgrpinfo[CTRL_ATTR_MCAST_GRP_NAME])))
 276                 {
 277                         cv->id = nla_get_u32(mgrpinfo[CTRL_ATTR_MCAST_GRP_ID]);
 278                         break;
 279                 }
 280         }
 281
 282         return NL_SKIP;
 283 }
 284
 285 static int nl80211_subscribe(const char *family, const char *group)
 286 {
 287         struct nl80211_group_conveyor cv = { .name = group, .id = -ENOENT };
 288         struct nl80211_msg_conveyor *req;
 289
 290         req = nl80211_ctl(CTRL_CMD_GETFAMILY, 0);
 291         if (req)
 292         {
 293                 NLA_PUT_STRING(req->msg, CTRL_ATTR_FAMILY_NAME, family);
 294                 nl80211_send(req, nl80211_subscribe_cb, &cv);
 295
 296 nla_put_failure:
 297                 nl80211_free(req);
 298         }
 299
 300         return nl_socket_add_membership(nls->nl_sock, cv.id);
 301 }
 302
 303
 304 static int nl80211_wait_cb(struct nl_msg *msg, void *arg)
 305 {
 306         struct nl80211_event_conveyor *cv = arg;
 307         struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
 308
 309         if (gnlh->cmd == cv->wait)
 310                 cv->recv = gnlh->cmd;
 311
 312         return NL_SKIP;
 313 }
 314
 315 static int nl80211_wait_seq_check(struct nl_msg *msg, void *arg)
 316 {
 317         return NL_OK;
 318 }
 319
 320 static int nl80211_wait(const char *family, const char *group, int cmd)
 321 {
 322         struct nl80211_event_conveyor cv = { .wait = cmd };
 323         struct nl_cb *cb;
 324
 325         if (nl80211_subscribe(family, group))
 326                 return -ENOENT;
 327
 328         cb = nl_cb_alloc(NL_CB_DEFAULT);
 329
 330         if (!cb)
 331                 return -ENOMEM;
 332
 333         nl_cb_set(cb, NL_CB_SEQ_CHECK, NL_CB_CUSTOM, nl80211_wait_seq_check, NULL);
 334         nl_cb_set(cb, NL_CB_VALID,     NL_CB_CUSTOM, nl80211_wait_cb,        &cv );
 335
 336         while (!cv.recv)
 337                 nl_recvmsgs(nls->nl_sock, cb);
 338
 339         nl_cb_put(cb);
 340
 341         return 0;
 342 }
 343
 344
 345 static int nl80211_freq2channel(int freq)
 346 {
 347         if (freq == 2484)
 348                 return 14;
 349
 350         if (freq < 2484)
 351                 return (freq - 2407) / 5;
 352
 353         return (freq / 5) - 1000;
 354 }
 355
 356 static int nl80211_channel2freq(int channel, const char *band)
 357 {
 358         if (channel == 14)
 359                 return 2484;
 360
 361         if ((channel < 14) && (!band || band[0] != 'a'))
 362                 return (channel * 5) + 2407;
 363
 364         if (channel > 0)
 365                 return (1000 + channel) * 5;
 366
 367         return 0;
 368 }
 369
 370 static char * nl80211_getval(const char *ifname, const char *buf, const char *key)
 371 {
 372         int i, len;
 373         char lkey[64] = { 0 };
 374         const char *ln = buf;
 375         static char lval[256] = { 0 };
 376
 377         int matched_if = ifname ? 0 : 1;
 378
 379
 380         for( i = 0, len = strlen(buf); i < len; i++ )
 381         {
 382                 if (!lkey[0] && (buf[i] == ' ' || buf[i] == '\t'))
 383                 {
 384                         ln++;
 385                 }
 386                 else if (!lkey[0] && (buf[i] == '='))
 387                 {
 388                         if ((&buf[i] - ln) > 0)
 389                                 memcpy(lkey, ln, min(sizeof(lkey) - 1, &buf[i] - ln));
 390                 }
 391                 else if (buf[i] == '\n')
 392                 {
 393                         if (lkey[0])
 394                         {
 395                                 memcpy(lval, ln + strlen(lkey) + 1,
 396                                         min(sizeof(lval) - 1, &buf[i] - ln - strlen(lkey) - 1));
 397
 398                                 if ((ifname != NULL) &&
 399                                     (!strcmp(lkey, "interface") || !strcmp(lkey, "bss")) )
 400                                 {
 401                                         matched_if = !strcmp(lval, ifname);
 402                                 }
 403                                 else if (matched_if && !strcmp(lkey, key))
 404                                 {
 405                                         return lval;
 406                                 }
 407                         }
 408
 409                         ln = &buf[i+1];
 410                         memset(lkey, 0, sizeof(lkey));
 411                         memset(lval, 0, sizeof(lval));
 412                 }
 413         }
 414
 415         return NULL;
 416 }
 417
 418 static int nl80211_ifname2phy_cb(struct nl_msg *msg, void *arg)
 419 {
 420         char *buf = arg;
 421         struct nlattr **attr = nl80211_parse(msg);
 422
 423         if (attr[NL80211_ATTR_WIPHY_NAME])
 424                 memcpy(buf, nla_data(attr[NL80211_ATTR_WIPHY_NAME]),
 425                        nla_len(attr[NL80211_ATTR_WIPHY_NAME]));
 426         else
 427                 buf[0] = 0;
 428
 429         return NL_SKIP;
 430 }
 431
 432 static char * nl80211_ifname2phy(const char *ifname)
 433 {
 434         static char phy[32] = { 0 };
 435         struct nl80211_msg_conveyor *req;
 436
 437         memset(phy, 0, sizeof(phy));
 438
 439         req = nl80211_msg(ifname, NL80211_CMD_GET_WIPHY, 0);
 440         if (req)
 441         {
 442                 nl80211_send(req, nl80211_ifname2phy_cb, phy);
 443                 nl80211_free(req);
 444         }
 445
 446         return phy[0] ? phy : NULL;
 447 }
 448
 449 static char * nl80211_hostapd_info(const char *ifname)
 450 {
 451         char *phy;
 452         char path[32] = { 0 };
 453         static char buf[4096] = { 0 };
 454         FILE *conf;
 455
 456         if ((phy = nl80211_ifname2phy(ifname)) != NULL)
 457         {
 458                 snprintf(path, sizeof(path), "/var/run/hostapd-%s.conf", phy);
 459
 460                 if ((conf = fopen(path, "r")) != NULL)
 461                 {
 462                         fread(buf, sizeof(buf) - 1, 1, conf);
 463                         fclose(conf);
 464
 465                         return buf;
 466                 }
 467         }
 468
 469         return NULL;
 470 }
 471
 472 static inline int nl80211_wpactl_recv(int sock, char *buf, int blen)
 473 {
 474         fd_set rfds;
 475         struct timeval tv = { 2, 0 };
 476
 477         FD_ZERO(&rfds);
 478         FD_SET(sock, &rfds);
 479
 480         memset(buf, 0, blen);
 481
 482
 483         if (select(sock + 1, &rfds, NULL, NULL, &tv) < 0)
 484                 return -1;
 485
 486         if (!FD_ISSET(sock, &rfds))
 487                 return -1;
 488
 489         return recv(sock, buf, blen, 0);
 490 }
 491
 492 static char * nl80211_wpactl_info(const char *ifname, const char *cmd,
 493                                                                    const char *event)
 494 {
 495         int numtry = 0;
 496         int sock = -1;
 497         char *rv = NULL;
 498         size_t remote_length, local_length;
 499         static char buffer[10240] = { 0 };
 500
 501         struct sockaddr_un local = { 0 };
 502         struct sockaddr_un remote = { 0 };
 503
 504
 505         sock = socket(PF_UNIX, SOCK_DGRAM, 0);
 506         if (sock < 0)
 507                 return NULL;
 508
 509         remote.sun_family = AF_UNIX;
 510         remote_length = sizeof(remote.sun_family) + sprintf(remote.sun_path,
 511                 "/var/run/wpa_supplicant-%s/%s", ifname, ifname);
 512
 513         if (fcntl(sock, F_SETFD, fcntl(sock, F_GETFD) | FD_CLOEXEC) < 0)
 514                 goto out;
 515
 516         if (connect(sock, (struct sockaddr *) &remote, remote_length))
 517                 goto out;
 518
 519         local.sun_family = AF_UNIX;
 520         local_length = sizeof(local.sun_family) +
 521                 sprintf(local.sun_path, "/var/run/iwinfo-%s-%d", ifname, getpid());
 522
 523         if (bind(sock, (struct sockaddr *) &local, local_length))
 524                 goto out;
 525
 526
 527         if (event)
 528         {
 529                 send(sock, "ATTACH", 6, 0);
 530
 531                 if (nl80211_wpactl_recv(sock, buffer, sizeof(buffer)) <= 0)
 532                         goto out;
 533         }
 534
 535
 536         send(sock, cmd, strlen(cmd), 0);
 537
 538         while( numtry++ < 5 )
 539         {
 540                 if (nl80211_wpactl_recv(sock, buffer, sizeof(buffer)) <= 0)
 541                 {
 542                         if (event)
 543                                 continue;
 544
 545                         break;
 546                 }
 547
 548                 if ((!event && buffer[0] != '<') || (event && strstr(buffer, event)))
 549                         break;
 550         }
 551
 552         rv = buffer;
 553
 554 out:
 555         close(sock);
 556
 557         if (local.sun_family)
 558                 unlink(local.sun_path);
 559
 560         return rv;
 561 }
 562
 563 static inline int nl80211_readint(const char *path)
 564 {
 565         int fd;
 566         int rv = -1;
 567         char buffer[16];
 568
 569         if ((fd = open(path, O_RDONLY)) > -1)
 570         {
 571                 if (read(fd, buffer, sizeof(buffer)) > 0)
 572                         rv = atoi(buffer);
 573
 574                 close(fd);
 575         }
 576
 577         return rv;
 578 }
 579
 580 static char * nl80211_phy2ifname(const char *ifname)
 581 {
 582         int fd, ifidx = -1, cifidx = -1, phyidx = -1;
 583         char buffer[64];
 584         static char nif[IFNAMSIZ] = { 0 };
 585
 586         DIR *d;
 587         struct dirent *e;
 588
 589         if (!ifname)
 590                 return NULL;
 591         else if (!strncmp(ifname, "phy", 3))
 592                 phyidx = atoi(&ifname[3]);
 593         else if (!strncmp(ifname, "radio", 5))
 594                 phyidx = atoi(&ifname[5]);
 595
 596         memset(nif, 0, sizeof(nif));
 597
 598         if (phyidx > -1)
 599         {
 600                 if ((d = opendir("/sys/class/net")) != NULL)
 601                 {
 602                         while ((e = readdir(d)) != NULL)
 603                         {
 604                                 snprintf(buffer, sizeof(buffer),
 605                                          "/sys/class/net/%s/phy80211/index", e->d_name);
 606
 607                                 if (nl80211_readint(buffer) == phyidx)
 608                                 {
 609                                         snprintf(buffer, sizeof(buffer),
 610                                                  "/sys/class/net/%s/ifindex", e->d_name);
 611
 612                                         if ((cifidx = nl80211_readint(buffer)) >= 0 &&
 613                                             ((ifidx < 0) || (cifidx < ifidx)))
 614                                         {
 615                                                 ifidx = cifidx;
 616                                                 strncpy(nif, e->d_name, sizeof(nif));
 617                                         }
 618                                 }
 619                         }
 620
 621                         closedir(d);
 622                 }
 623         }
 624
 625         return nif[0] ? nif : NULL;
 626 }
 627
 628 static char * nl80211_ifadd(const char *ifname)
 629 {
 630         int phyidx;
 631         char *rv = NULL;
 632         static char nif[IFNAMSIZ] = { 0 };
 633         struct nl80211_msg_conveyor *req, *res;
 634
 635         req = nl80211_msg(ifname, NL80211_CMD_NEW_INTERFACE, 0);
 636         if (req)
 637         {
 638                 snprintf(nif, sizeof(nif), "tmp.%s", ifname);
 639
 640                 NLA_PUT_STRING(req->msg, NL80211_ATTR_IFNAME, nif);
 641                 NLA_PUT_U32(req->msg, NL80211_ATTR_IFTYPE, NL80211_IFTYPE_STATION);
 642
 643                 nl80211_send(req, NULL, NULL);
 644
 645                 rv = nif;
 646
 647         nla_put_failure:
 648                 nl80211_free(req);
 649         }
 650
 651         return rv;
 652 }
 653
 654 static void nl80211_ifdel(const char *ifname)
 655 {
 656         struct nl80211_msg_conveyor *req;
 657
 658         req = nl80211_msg(ifname, NL80211_CMD_DEL_INTERFACE, 0);
 659         if (req)
 660         {
 661                 NLA_PUT_STRING(req->msg, NL80211_ATTR_IFNAME, ifname);
 662
 663                 nl80211_send(req, NULL, NULL);
 664
 665         nla_put_failure:
 666                 nl80211_free(req);
 667         }
 668 }
 669
 670 static void nl80211_hostapd_hup(const char *ifname)
 671 {
 672         int fd, pid = 0;
 673         char buf[32];
 674         char *phy = nl80211_ifname2phy(ifname);
 675
 676         if (phy)
 677         {
 678                 snprintf(buf, sizeof(buf), "/var/run/wifi-%s.pid", phy);
 679                 if ((fd = open(buf, O_RDONLY)) > 0)
 680                 {
 681                         if (read(fd, buf, sizeof(buf)) > 0)
 682                                 pid = atoi(buf);
 683
 684                         close(fd);
 685                 }
 686
 687                 if (pid > 0)
 688                         kill(pid, 1);
 689         }
 690 }
 691
 692
 693 int nl80211_probe(const char *ifname)
 694 {
 695         return !!nl80211_ifname2phy(ifname);
 696 }
 697
 698 void nl80211_close(void)
 699 {
 700         if (nls)
 701         {
 702                 if (nls->nlctrl)
 703                         genl_family_put(nls->nlctrl);
 704
 705                 if (nls->nl80211)
 706                         genl_family_put(nls->nl80211);
 707
 708                 if (nls->nl_sock)
 709                         nl_socket_free(nls->nl_sock);
 710
 711                 if (nls->nl_cache)
 712                         nl_cache_free(nls->nl_cache);
 713
 714                 free(nls);
 715                 nls = NULL;
 716         }
 717 }
 718
 719 int nl80211_get_mode(const char *ifname, int *buf)
 720 {
 721         return wext_get_mode(ifname, buf);
 722 }
 723
 724 int nl80211_get_ssid(const char *ifname, char *buf)
 725 {
 726         char *ssid;
 727
 728         if (!wext_get_ssid(ifname, buf))
 729         {
 730                 return 0;
 731         }
 732         else if ((ssid = nl80211_hostapd_info(ifname)) &&
 733                  (ssid = nl80211_getval(ifname, ssid, "ssid")))
 734         {
 735                 memcpy(buf, ssid, strlen(ssid));
 736                 return 0;
 737         }
 738
 739         return -1;
 740 }
 741
 742 int nl80211_get_bssid(const char *ifname, char *buf)
 743 {
 744         char *bssid;
 745         unsigned char mac[6];
 746
 747         if (!wext_get_bssid(ifname, buf))
 748         {
 749                 return 0;
 750         }
 751         else if ((bssid = nl80211_hostapd_info(ifname)) &&
 752                  (bssid = nl80211_getval(ifname, bssid, "bssid")))
 753         {
 754                 mac[0] = strtol(&bssid[0],  NULL, 16);
 755                 mac[1] = strtol(&bssid[3],  NULL, 16);
 756                 mac[2] = strtol(&bssid[6],  NULL, 16);
 757                 mac[3] = strtol(&bssid[9],  NULL, 16);
 758                 mac[4] = strtol(&bssid[12], NULL, 16);
 759                 mac[5] = strtol(&bssid[15], NULL, 16);
 760
 761                 sprintf(buf, "%02X:%02X:%02X:%02X:%02X:%02X",
 762                         mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
 763
 764                 return 0;
 765         }
 766
 767         return -1;
 768 }
 769
 770
 771 static int nl80211_get_frequency_cb(struct nl_msg *msg, void *arg)
 772 {
 773         int *freq = arg;
 774         struct nlattr **attr = nl80211_parse(msg);
 775         struct nlattr *binfo[NL80211_BSS_MAX + 1];
 776
 777         static struct nla_policy bss_policy[NL80211_BSS_MAX + 1] = {
 778                 [NL80211_BSS_FREQUENCY] = { .type = NLA_U32 },
 779         };
 780
 781         if (attr[NL80211_ATTR_BSS] &&
 782             !nla_parse_nested(binfo, NL80211_BSS_MAX,
 783                               attr[NL80211_ATTR_BSS], bss_policy))
 784         {
 785                 if (binfo[NL80211_BSS_FREQUENCY])
 786                         *freq = nla_get_u32(binfo[NL80211_BSS_FREQUENCY]);
 787         }
 788
 789         return NL_SKIP;
 790 }
 791
 792 int nl80211_get_frequency(const char *ifname, int *buf)
 793 {
 794         char *res, *channel;
 795         struct nl80211_msg_conveyor *req;
 796
 797         *buf = 0;
 798
 799         if ((res = nl80211_hostapd_info(ifname)) &&
 800             (channel = nl80211_getval(NULL, res, "channel")))
 801         {
 802                 *buf = nl80211_channel2freq(atoi(channel),
 803                                             nl80211_getval(NULL, res, "hw_mode"));
 804         }
 805         else
 806         {
 807                 res = nl80211_phy2ifname(ifname);
 808                 req = nl80211_msg(res ? res : ifname, NL80211_CMD_GET_SCAN, NLM_F_DUMP);
 809
 810                 if (req)
 811                 {
 812                         nl80211_send(req, nl80211_get_frequency_cb, buf);
 813                         nl80211_free(req);
 814                 }
 815         }
 816
 817         return (*buf == 0) ? -1 : 0;
 818 }
 819
 820 int nl80211_get_channel(const char *ifname, int *buf)
 821 {
 822         if (!nl80211_get_frequency(ifname, buf))
 823         {
 824                 *buf = nl80211_freq2channel(*buf);
 825                 return 0;
 826         }
 827
 828         return -1;
 829 }
 830
 831
 832 int nl80211_get_txpower(const char *ifname, int *buf)
 833 {
 834         return wext_get_txpower(ifname, buf);
 835 }
 836
 837
 838 static int nl80211_fill_signal_cb(struct nl_msg *msg, void *arg)
 839 {
 840         int8_t dbm;
 841         int16_t mbit;
 842         struct nl80211_rssi_rate *rr = arg;
 843         struct nlattr **attr = nl80211_parse(msg);
 844         struct nlattr *sinfo[NL80211_STA_INFO_MAX + 1];
 845         struct nlattr *rinfo[NL80211_RATE_INFO_MAX + 1];
 846
 847         static struct nla_policy stats_policy[NL80211_STA_INFO_MAX + 1] = {
 848                 [NL80211_STA_INFO_INACTIVE_TIME] = { .type = NLA_U32    },
 849                 [NL80211_STA_INFO_RX_BYTES]      = { .type = NLA_U32    },
 850                 [NL80211_STA_INFO_TX_BYTES]      = { .type = NLA_U32    },
 851                 [NL80211_STA_INFO_RX_PACKETS]    = { .type = NLA_U32    },
 852                 [NL80211_STA_INFO_TX_PACKETS]    = { .type = NLA_U32    },
 853                 [NL80211_STA_INFO_SIGNAL]        = { .type = NLA_U8     },
 854                 [NL80211_STA_INFO_TX_BITRATE]    = { .type = NLA_NESTED },
 855                 [NL80211_STA_INFO_LLID]          = { .type = NLA_U16    },
 856                 [NL80211_STA_INFO_PLID]          = { .type = NLA_U16    },
 857                 [NL80211_STA_INFO_PLINK_STATE]   = { .type = NLA_U8     },
 858         };
 859
 860         static struct nla_policy rate_policy[NL80211_RATE_INFO_MAX + 1] = {
 861                 [NL80211_RATE_INFO_BITRATE]      = { .type = NLA_U16  },
 862                 [NL80211_RATE_INFO_MCS]          = { .type = NLA_U8   },
 863                 [NL80211_RATE_INFO_40_MHZ_WIDTH] = { .type = NLA_FLAG },
 864                 [NL80211_RATE_INFO_SHORT_GI]     = { .type = NLA_FLAG },
 865         };
 866
 867         if (attr[NL80211_ATTR_STA_INFO])
 868         {
 869                 if (!nla_parse_nested(sinfo, NL80211_STA_INFO_MAX,
 870                                       attr[NL80211_ATTR_STA_INFO], stats_policy))
 871                 {
 872                         if (sinfo[NL80211_STA_INFO_SIGNAL])
 873                         {
 874                                 dbm = nla_get_u8(sinfo[NL80211_STA_INFO_SIGNAL]);
 875                                 rr->rssi = rr->rssi ? (int8_t)((rr->rssi + dbm) / 2) : dbm;
 876                         }
 877
 878                         if (sinfo[NL80211_STA_INFO_TX_BITRATE])
 879                         {
 880                                 if (!nla_parse_nested(rinfo, NL80211_RATE_INFO_MAX,
 881                                                       sinfo[NL80211_STA_INFO_TX_BITRATE],
 882                                                       rate_policy))
 883                                 {
 884                                         if (rinfo[NL80211_RATE_INFO_BITRATE])
 885                                         {
 886                                                 mbit = nla_get_u16(rinfo[NL80211_RATE_INFO_BITRATE]);
 887                                                 rr->rate = rr->rate
 888                                                         ? (int16_t)((rr->rate + mbit) / 2) : mbit;
 889                                         }
 890                                 }
 891                         }
 892                 }
 893         }
 894
 895         return NL_SKIP;
 896 }
 897
 898 static void nl80211_fill_signal(const char *ifname, struct nl80211_rssi_rate *r)
 899 {
 900         DIR *d;
 901         struct dirent *de;
 902         struct nl80211_msg_conveyor *req;
 903
 904         r->rssi = 0;
 905         r->rate = 0;
 906
 907         if ((d = opendir("/sys/class/net")) != NULL)
 908         {
 909                 while ((de = readdir(d)) != NULL)
 910                 {
 911                         if (!strncmp(de->d_name, ifname, strlen(ifname)) &&
 912                             (!de->d_name[strlen(ifname)] ||
 913                              !strncmp(&de->d_name[strlen(ifname)], ".sta", 4)))
 914                         {
 915                                 req = nl80211_msg(de->d_name, NL80211_CMD_GET_STATION,
 916                                                   NLM_F_DUMP);
 917
 918                                 if (req)
 919                                 {
 920                                         nl80211_send(req, nl80211_fill_signal_cb, r);
 921                                         nl80211_free(req);
 922                                 }
 923                         }
 924                 }
 925
 926                 closedir(d);
 927         }
 928 }
 929
 930 int nl80211_get_bitrate(const char *ifname, int *buf)
 931 {
 932         struct nl80211_rssi_rate rr;
 933
 934         if (!wext_get_bitrate(ifname, buf))
 935                 return 0;
 936
 937         nl80211_fill_signal(ifname, &rr);
 938
 939         if (rr.rate)
 940         {
 941                 *buf = (rr.rate * 100);
 942                 return 0;
 943         }
 944
 945         return -1;
 946 }
 947
 948 int nl80211_get_signal(const char *ifname, int *buf)
 949 {
 950         struct nl80211_rssi_rate rr;
 951
 952         if (!wext_get_signal(ifname, buf))
 953                 return 0;
 954
 955         nl80211_fill_signal(ifname, &rr);
 956
 957         if (rr.rssi)
 958         {
 959                 *buf = rr.rssi;
 960                 return 0;
 961         }
 962
 963         return -1;
 964 }
 965
 966 static int nl80211_get_noise_cb(struct nl_msg *msg, void *arg)
 967 {
 968         int8_t *noise = arg;
 969         struct nlattr **tb = nl80211_parse(msg);
 970         struct nlattr *si[NL80211_SURVEY_INFO_MAX + 1];
 971
 972         static struct nla_policy sp[NL80211_SURVEY_INFO_MAX + 1] = {
 973                 [NL80211_SURVEY_INFO_FREQUENCY] = { .type = NLA_U32 },
 974                 [NL80211_SURVEY_INFO_NOISE]     = { .type = NLA_U8  },
 975         };
 976
 977         if (!tb[NL80211_ATTR_SURVEY_INFO])
 978                 return NL_SKIP;
 979
 980         if (nla_parse_nested(si, NL80211_SURVEY_INFO_MAX,
 981                              tb[NL80211_ATTR_SURVEY_INFO], sp))
 982                 return NL_SKIP;
 983
 984         if (!si[NL80211_SURVEY_INFO_NOISE])
 985                 return NL_SKIP;
 986
 987         if (!*noise || si[NL80211_SURVEY_INFO_IN_USE])
 988                 *noise = (int8_t)nla_get_u8(si[NL80211_SURVEY_INFO_NOISE]);
 989
 990         return NL_SKIP;
 991 }
 992
 993
 994 int nl80211_get_noise(const char *ifname, int *buf)
 995 {
 996         int8_t noise;
 997         struct nl80211_msg_conveyor *req;
 998
 999         req = nl80211_msg(ifname, NL80211_CMD_GET_SURVEY, NLM_F_DUMP);
1000         if (req)
1001         {
1002                 noise = 0;
1003
1004                 nl80211_send(req, nl80211_get_noise_cb, &noise);
1005                 nl80211_free(req);
1006
1007                 if (noise)
1008                 {
1009                         *buf = noise;
1010                         return 0;
1011                 }
1012         }
1013
1014         return -1;
1015 }
1016
1017 int nl80211_get_quality(const char *ifname, int *buf)
1018 {
1019         int signal;
1020
1021         if (wext_get_quality(ifname, buf))
1022         {
1023                 *buf = 0;
1024
1025                 if (!nl80211_get_signal(ifname, &signal))
1026                 {
1027                         /* A positive signal level is usually just a quality
1028                          * value, pass through as-is */
1029                         if (signal >= 0)
1030                         {
1031                                 *buf = signal;
1032                         }
1033
1034                         /* The cfg80211 wext compat layer assumes a signal range
1035                          * of -110 dBm to -40 dBm, the quality value is derived
1036                          * by adding 110 to the signal level */
1037                         else
1038                         {
1039                                 if (signal < -110)
1040                                         signal = -110;
1041                                 else if (signal > -40)
1042                                         signal = -40;
1043
1044                                 *buf = (signal + 110);
1045                         }
1046                 }
1047         }
1048
1049         return 0;
1050 }
1051
1052 int nl80211_get_quality_max(const char *ifname, int *buf)
1053 {
1054         if (wext_get_quality_max(ifname, buf))
1055                 /* The cfg80211 wext compat layer assumes a maximum
1056                  * quality of 70 */
1057                 *buf = 70;
1058
1059         return 0;
1060 }
1061
1062 int nl80211_get_encryption(const char *ifname, char *buf)
1063 {
1064         int i;
1065         char k[9];
1066         char *val, *res;
1067         struct iwinfo_crypto_entry *c = (struct iwinfo_crypto_entry *)buf;
1068
1069         /* WPA supplicant */
1070         if ((res = nl80211_wpactl_info(ifname, "STATUS", NULL)) &&
1071             (val = nl80211_getval(NULL, res, "pairwise_cipher")))
1072         {
1073                 /* WEP */
1074                 if (strstr(val, "WEP"))
1075                 {
1076                         if (strstr(val, "WEP-40"))
1077                                 c->pair_ciphers |= IWINFO_CIPHER_WEP40;
1078
1079                         else if (strstr(val, "WEP-104"))
1080                                 c->pair_ciphers |= IWINFO_CIPHER_WEP104;
1081
1082                         c->enabled       = 1;
1083                         c->group_ciphers = c->pair_ciphers;
1084
1085                         c->auth_suites |= IWINFO_KMGMT_NONE;
1086                         c->auth_algs   |= IWINFO_AUTH_OPEN; /* XXX: assumption */
1087                 }
1088
1089                 /* WPA */
1090                 else
1091                 {
1092                         if (strstr(val, "TKIP"))
1093                                 c->pair_ciphers |= IWINFO_CIPHER_TKIP;
1094
1095                         else if (strstr(val, "CCMP"))
1096                                 c->pair_ciphers |= IWINFO_CIPHER_CCMP;
1097
1098                         else if (strstr(val, "NONE"))
1099                                 c->pair_ciphers |= IWINFO_CIPHER_NONE;
1100
1101                         else if (strstr(val, "WEP-40"))
1102                                 c->pair_ciphers |= IWINFO_CIPHER_WEP40;
1103
1104                         else if (strstr(val, "WEP-104"))
1105                                 c->pair_ciphers |= IWINFO_CIPHER_WEP104;
1106
1107
1108                         if ((val = nl80211_getval(NULL, res, "group_cipher")))
1109                         {
1110                                 if (strstr(val, "TKIP"))
1111                                         c->group_ciphers |= IWINFO_CIPHER_TKIP;
1112
1113                                 else if (strstr(val, "CCMP"))
1114                                         c->group_ciphers |= IWINFO_CIPHER_CCMP;
1115
1116                                 else if (strstr(val, "NONE"))
1117                                         c->group_ciphers |= IWINFO_CIPHER_NONE;
1118
1119                                 else if (strstr(val, "WEP-40"))
1120                                         c->group_ciphers |= IWINFO_CIPHER_WEP40;
1121
1122                                 else if (strstr(val, "WEP-104"))
1123                                         c->group_ciphers |= IWINFO_CIPHER_WEP104;
1124                         }
1125
1126
1127                         if ((val = nl80211_getval(NULL, res, "key_mgmt")))
1128                         {
1129                                 if (strstr(val, "WPA2"))
1130                                         c->wpa_version = 2;
1131
1132                                 else if (strstr(val, "WPA"))
1133                                         c->wpa_version = 1;
1134
1135
1136                                 if (strstr(val, "PSK"))
1137                                         c->auth_suites |= IWINFO_KMGMT_PSK;
1138
1139                                 else if (strstr(val, "EAP") || strstr(val, "802.1X"))
1140                                         c->auth_suites |= IWINFO_KMGMT_8021x;
1141
1142                                 else if (strstr(val, "NONE"))
1143                                         c->auth_suites |= IWINFO_KMGMT_NONE;
1144                         }
1145
1146                         c->enabled = (c->wpa_version && c->auth_suites) ? 1 : 0;
1147                 }
1148
1149                 return 0;
1150         }
1151
1152         /* Hostapd */
1153         else if ((res = nl80211_hostapd_info(ifname)))
1154         {
1155                 if ((val = nl80211_getval(ifname, res, "wpa")) != NULL)
1156                         c->wpa_version = atoi(val);
1157
1158                 val = nl80211_getval(ifname, res, "wpa_key_mgmt");
1159
1160                 if (!val || strstr(val, "PSK"))
1161                         c->auth_suites |= IWINFO_KMGMT_PSK;
1162
1163                 if (val && strstr(val, "EAP"))
1164                         c->auth_suites |= IWINFO_KMGMT_8021x;
1165
1166                 if (val && strstr(val, "NONE"))
1167                         c->auth_suites |= IWINFO_KMGMT_NONE;
1168
1169                 if ((val = nl80211_getval(ifname, res, "wpa_pairwise")) != NULL)
1170                 {
1171                         if (strstr(val, "TKIP"))
1172                                 c->pair_ciphers |= IWINFO_CIPHER_TKIP;
1173
1174                         if (strstr(val, "CCMP"))
1175                                 c->pair_ciphers |= IWINFO_CIPHER_CCMP;
1176
1177                         if (strstr(val, "NONE"))
1178                                 c->pair_ciphers |= IWINFO_CIPHER_NONE;
1179                 }
1180
1181                 if ((val = nl80211_getval(ifname, res, "auth_algs")) != NULL)
1182                 {
1183                         switch(atoi(val)) {
1184                                 case 1:
1185                                         c->auth_algs |= IWINFO_AUTH_OPEN;
1186                                         break;
1187
1188                                 case 2:
1189                                         c->auth_algs |= IWINFO_AUTH_SHARED;
1190                                         break;
1191
1192                                 case 3:
1193                                         c->auth_algs |= IWINFO_AUTH_OPEN;
1194                                         c->auth_algs |= IWINFO_AUTH_SHARED;
1195                                         break;
1196
1197                                 default:
1198                                         break;
1199                         }
1200
1201                         for (i = 0; i < 4; i++)
1202                         {
1203                                 snprintf(k, sizeof(k), "wep_key%d", i);
1204
1205                                 if ((val = nl80211_getval(ifname, res, k)))
1206                                 {
1207                                         if ((strlen(val) == 5) || (strlen(val) == 10))
1208                                                 c->pair_ciphers |= IWINFO_CIPHER_WEP40;
1209
1210                                         else if ((strlen(val) == 13) || (strlen(val) == 26))
1211                                                 c->pair_ciphers |= IWINFO_CIPHER_WEP104;
1212                                 }
1213                         }
1214                 }
1215
1216                 c->group_ciphers = c->pair_ciphers;
1217                 c->enabled = (c->wpa_version || c->pair_ciphers) ? 1 : 0;
1218
1219                 return 0;
1220         }
1221
1222         return -1;
1223 }
1224
1225
1226 static int nl80211_get_assoclist_cb(struct nl_msg *msg, void *arg)
1227 {
1228         struct nl80211_array_buf *arr = arg;
1229         struct iwinfo_assoclist_entry *e = arr->buf;
1230         struct nlattr **attr = nl80211_parse(msg);
1231         struct nlattr *sinfo[NL80211_STA_INFO_MAX + 1];
1232         struct nlattr *rinfo[NL80211_RATE_INFO_MAX + 1];
1233
1234         static struct nla_policy stats_policy[NL80211_STA_INFO_MAX + 1] = {
1235                 [NL80211_STA_INFO_INACTIVE_TIME] = { .type = NLA_U32    },
1236                 [NL80211_STA_INFO_RX_PACKETS]    = { .type = NLA_U32    },
1237                 [NL80211_STA_INFO_TX_PACKETS]    = { .type = NLA_U32    },
1238                 [NL80211_STA_INFO_RX_BITRATE]    = { .type = NLA_NESTED },
1239                 [NL80211_STA_INFO_TX_BITRATE]    = { .type = NLA_NESTED },
1240                 [NL80211_STA_INFO_SIGNAL]        = { .type = NLA_U8     },
1241         };
1242
1243         static struct nla_policy rate_policy[NL80211_RATE_INFO_MAX + 1] = {
1244                 [NL80211_RATE_INFO_BITRATE]      = { .type = NLA_U16    },
1245                 [NL80211_RATE_INFO_MCS]          = { .type = NLA_U8     },
1246                 [NL80211_RATE_INFO_40_MHZ_WIDTH] = { .type = NLA_FLAG   },
1247                 [NL80211_RATE_INFO_SHORT_GI]     = { .type = NLA_FLAG   },
1248         };
1249
1250         /* advance to end of array */
1251         e += arr->count;
1252         memset(e, 0, sizeof(*e));
1253
1254         if (attr[NL80211_ATTR_MAC])
1255                 memcpy(e->mac, nla_data(attr[NL80211_ATTR_MAC]), 6);
1256
1257         if (attr[NL80211_ATTR_STA_INFO] &&
1258             !nla_parse_nested(sinfo, NL80211_STA_INFO_MAX,
1259                               attr[NL80211_ATTR_STA_INFO], stats_policy))
1260         {
1261                 if (sinfo[NL80211_STA_INFO_SIGNAL])
1262                         e->signal = nla_get_u8(sinfo[NL80211_STA_INFO_SIGNAL]);
1263
1264                 if (sinfo[NL80211_STA_INFO_INACTIVE_TIME])
1265                         e->inactive = nla_get_u32(sinfo[NL80211_STA_INFO_INACTIVE_TIME]);
1266
1267                 if (sinfo[NL80211_STA_INFO_RX_PACKETS])
1268                         e->rx_packets = nla_get_u32(sinfo[NL80211_STA_INFO_RX_PACKETS]);
1269
1270                 if (sinfo[NL80211_STA_INFO_TX_PACKETS])
1271                         e->tx_packets = nla_get_u32(sinfo[NL80211_STA_INFO_TX_PACKETS]);
1272
1273                 if (sinfo[NL80211_STA_INFO_RX_BITRATE] &&
1274                     !nla_parse_nested(rinfo, NL80211_RATE_INFO_MAX,
1275                                       sinfo[NL80211_STA_INFO_RX_BITRATE], rate_policy))
1276                 {
1277                         if (rinfo[NL80211_RATE_INFO_BITRATE])
1278                                 e->rx_rate.rate =
1279                                         nla_get_u16(rinfo[NL80211_RATE_INFO_BITRATE]) * 100;
1280
1281                         if (rinfo[NL80211_RATE_INFO_MCS])
1282                                 e->rx_rate.mcs = nla_get_u8(rinfo[NL80211_RATE_INFO_MCS]);
1283
1284                         if (rinfo[NL80211_RATE_INFO_40_MHZ_WIDTH])
1285                                 e->rx_rate.is_40mhz = 1;
1286
1287                         if (rinfo[NL80211_RATE_INFO_SHORT_GI])
1288                                 e->rx_rate.is_short_gi = 1;
1289                 }
1290
1291                 if (sinfo[NL80211_STA_INFO_TX_BITRATE] &&
1292                     !nla_parse_nested(rinfo, NL80211_RATE_INFO_MAX,
1293                                       sinfo[NL80211_STA_INFO_TX_BITRATE], rate_policy))
1294                 {
1295                         if (rinfo[NL80211_RATE_INFO_BITRATE])
1296                                 e->tx_rate.rate =
1297                                         nla_get_u16(rinfo[NL80211_RATE_INFO_BITRATE]) * 100;
1298
1299                         if (rinfo[NL80211_RATE_INFO_MCS])
1300                                 e->tx_rate.mcs = nla_get_u8(rinfo[NL80211_RATE_INFO_MCS]);
1301
1302                         if (rinfo[NL80211_RATE_INFO_40_MHZ_WIDTH])
1303                                 e->tx_rate.is_40mhz = 1;
1304
1305                         if (rinfo[NL80211_RATE_INFO_SHORT_GI])
1306                                 e->tx_rate.is_short_gi = 1;
1307                 }
1308         }
1309
1310         e->noise = 0; /* filled in by caller */
1311         arr->count++;
1312
1313         return NL_SKIP;
1314 }
1315
1316 int nl80211_get_assoclist(const char *ifname, char *buf, int *len)
1317 {
1318         DIR *d;
1319         int i, noise = 0;
1320         struct dirent *de;
1321         struct nl80211_msg_conveyor *req;
1322         struct nl80211_array_buf arr = { .buf = buf, .count = 0 };
1323         struct iwinfo_assoclist_entry *e;
1324
1325         if ((d = opendir("/sys/class/net")) != NULL)
1326         {
1327                 while ((de = readdir(d)) != NULL)
1328                 {
1329                         if (!strncmp(de->d_name, ifname, strlen(ifname)) &&
1330                             (!de->d_name[strlen(ifname)] ||
1331                              !strncmp(&de->d_name[strlen(ifname)], ".sta", 4)))
1332                         {
1333                                 req = nl80211_msg(de->d_name, NL80211_CMD_GET_STATION,
1334                                                   NLM_F_DUMP);
1335
1336                                 if (req)
1337                                 {
1338                                         nl80211_send(req, nl80211_get_assoclist_cb, &arr);
1339                                         nl80211_free(req);
1340                                 }
1341                         }
1342                 }
1343
1344                 closedir(d);
1345
1346                 if (!nl80211_get_noise(ifname, &noise))
1347                         for (i = 0, e = arr.buf; i < arr.count; i++, e++)
1348                                 e->noise = noise;
1349
1350                 *len = (arr.count * sizeof(struct iwinfo_assoclist_entry));
1351                 return 0;
1352         }
1353
1354         return -1;
1355 }
1356
1357 static int nl80211_get_txpwrlist_cb(struct nl_msg *msg, void *arg)
1358 {
1359         int *dbm_max = arg;
1360         int ch_cur, ch_cmp, bands_remain, freqs_remain;
1361
1362         struct nlattr **attr = nl80211_parse(msg);
1363         struct nlattr *bands[NL80211_BAND_ATTR_MAX + 1];
1364         struct nlattr *freqs[NL80211_FREQUENCY_ATTR_MAX + 1];
1365         struct nlattr *band, *freq;
1366
1367         static struct nla_policy freq_policy[NL80211_FREQUENCY_ATTR_MAX + 1] = {
1368                 [NL80211_FREQUENCY_ATTR_FREQ]         = { .type = NLA_U32  },
1369                 [NL80211_FREQUENCY_ATTR_DISABLED]     = { .type = NLA_FLAG },
1370                 [NL80211_FREQUENCY_ATTR_PASSIVE_SCAN] = { .type = NLA_FLAG },
1371                 [NL80211_FREQUENCY_ATTR_NO_IBSS]      = { .type = NLA_FLAG },
1372                 [NL80211_FREQUENCY_ATTR_RADAR]        = { .type = NLA_FLAG },
1373                 [NL80211_FREQUENCY_ATTR_MAX_TX_POWER] = { .type = NLA_U32  },
1374         };
1375
1376         ch_cur = *dbm_max; /* value int* is initialized with channel by caller */
1377         *dbm_max = -1;
1378
1379         nla_for_each_nested(band, attr[NL80211_ATTR_WIPHY_BANDS], bands_remain)
1380         {
1381                 nla_parse(bands, NL80211_BAND_ATTR_MAX, nla_data(band),
1382                           nla_len(band), NULL);
1383
1384                 nla_for_each_nested(freq, bands[NL80211_BAND_ATTR_FREQS], freqs_remain)
1385                 {
1386                         nla_parse(freqs, NL80211_FREQUENCY_ATTR_MAX,
1387                                   nla_data(freq), nla_len(freq), freq_policy);
1388
1389                         ch_cmp = nl80211_freq2channel(nla_get_u32(
1390                                 freqs[NL80211_FREQUENCY_ATTR_FREQ]));
1391
1392                         if ((!ch_cur || (ch_cmp == ch_cur)) &&
1393                             freqs[NL80211_FREQUENCY_ATTR_MAX_TX_POWER])
1394                         {
1395                                 *dbm_max = (int)(0.01 * nla_get_u32(
1396                                         freqs[NL80211_FREQUENCY_ATTR_MAX_TX_POWER]));
1397
1398                                 break;
1399                         }
1400                 }
1401         }
1402
1403         return NL_SKIP;
1404 }
1405
1406 int nl80211_get_txpwrlist(const char *ifname, char *buf, int *len)
1407 {
1408         int ch_cur;
1409         int dbm_max = -1, dbm_cur, dbm_cnt;
1410         struct nl80211_msg_conveyor *req;
1411         struct iwinfo_txpwrlist_entry entry;
1412
1413         if (nl80211_get_channel(ifname, &ch_cur))
1414                 ch_cur = 0;
1415
1416         req = nl80211_msg(ifname, NL80211_CMD_GET_WIPHY, 0);
1417         if (req)
1418         {
1419                 /* initialize the value pointer with channel for callback */
1420                 dbm_max = ch_cur;
1421
1422                 nl80211_send(req, nl80211_get_txpwrlist_cb, &dbm_max);
1423                 nl80211_free(req);
1424         }
1425
1426         if (dbm_max > 0)
1427         {
1428                 for (dbm_cur = 0, dbm_cnt = 0;
1429                      dbm_cur < dbm_max;
1430                      dbm_cur++, dbm_cnt++)
1431                 {
1432                         entry.dbm = dbm_cur;
1433                         entry.mw  = iwinfo_dbm2mw(dbm_cur);
1434
1435                         memcpy(&buf[dbm_cnt * sizeof(entry)], &entry, sizeof(entry));
1436                 }
1437
1438                 entry.dbm = dbm_max;
1439                 entry.mw  = iwinfo_dbm2mw(dbm_max);
1440
1441                 memcpy(&buf[dbm_cnt * sizeof(entry)], &entry, sizeof(entry));
1442                 dbm_cnt++;
1443
1444                 *len = dbm_cnt * sizeof(entry);
1445                 return 0;
1446         }
1447
1448         return -1;
1449 }
1450
1451 static void nl80211_get_scancrypto(const char *spec,
1452         struct iwinfo_crypto_entry *c)
1453 {
1454         if (strstr(spec, "WPA") || strstr(spec, "WEP"))
1455         {
1456                 c->enabled = 1;
1457
1458                 if (strstr(spec, "WPA2-") && strstr(spec, "WPA-"))
1459                         c->wpa_version = 3;
1460
1461                 else if (strstr(spec, "WPA2"))
1462                         c->wpa_version = 2;
1463
1464                 else if (strstr(spec, "WPA"))
1465                         c->wpa_version = 1;
1466
1467                 else if (strstr(spec, "WEP"))
1468                         c->auth_algs = IWINFO_AUTH_OPEN | IWINFO_AUTH_SHARED;
1469
1470
1471                 if (strstr(spec, "PSK"))
1472                         c->auth_suites |= IWINFO_KMGMT_PSK;
1473
1474                 if (strstr(spec, "802.1X") || strstr(spec, "EAP"))
1475                         c->auth_suites |= IWINFO_KMGMT_8021x;
1476
1477                 if (strstr(spec, "WPA-NONE"))
1478                         c->auth_suites |= IWINFO_KMGMT_NONE;
1479
1480
1481                 if (strstr(spec, "TKIP"))
1482                         c->pair_ciphers |= IWINFO_CIPHER_TKIP;
1483
1484                 if (strstr(spec, "CCMP"))
1485                         c->pair_ciphers |= IWINFO_CIPHER_CCMP;
1486
1487                 if (strstr(spec, "WEP-40"))
1488                         c->pair_ciphers |= IWINFO_CIPHER_WEP40;
1489
1490                 if (strstr(spec, "WEP-104"))
1491                         c->pair_ciphers |= IWINFO_CIPHER_WEP104;
1492
1493                 c->group_ciphers = c->pair_ciphers;
1494         }
1495         else
1496         {
1497                 c->enabled = 0;
1498         }
1499 }
1500
1501
1502 struct nl80211_scanlist {
1503         struct iwinfo_scanlist_entry *e;
1504         int len;
1505 };
1506
1507
1508 static void nl80211_get_scanlist_ie(struct nlattr **bss,
1509                                     struct iwinfo_scanlist_entry *e)
1510 {
1511         int ielen = nla_len(bss[NL80211_BSS_INFORMATION_ELEMENTS]);
1512         unsigned char *ie = nla_data(bss[NL80211_BSS_INFORMATION_ELEMENTS]);
1513         static unsigned char ms_oui[3] = { 0x00, 0x50, 0xf2 };
1514
1515         while (ielen >= 2 && ielen >= ie[1])
1516         {
1517                 switch (ie[0])
1518                 {
1519                 case 0: /* SSID */
1520                         memcpy(e->ssid, ie + 2, min(ie[1], IWINFO_ESSID_MAX_SIZE));
1521                         break;
1522
1523                 case 48: /* RSN */
1524                         iwinfo_parse_rsn(&e->crypto, ie + 2, ie[1],
1525                                          IWINFO_CIPHER_CCMP, IWINFO_KMGMT_8021x);
1526                         break;
1527
1528                 case 221: /* Vendor */
1529                         if (ie[1] >= 4 && !memcmp(ie + 2, ms_oui, 3) && ie[5] == 1)
1530                                 iwinfo_parse_rsn(&e->crypto, ie + 6, ie[1] - 4,
1531                                                  IWINFO_CIPHER_TKIP, IWINFO_KMGMT_PSK);
1532                         break;
1533                 }
1534
1535                 ielen -= ie[1] + 2;
1536                 ie += ie[1] + 2;
1537         }
1538 }
1539
1540 static int nl80211_get_scanlist_cb(struct nl_msg *msg, void *arg)
1541 {
1542         int8_t rssi;
1543         uint16_t caps;
1544
1545         struct nl80211_scanlist *sl = arg;
1546         struct nlattr **tb = nl80211_parse(msg);
1547         struct nlattr *bss[NL80211_BSS_MAX + 1];
1548
1549         static struct nla_policy bss_policy[NL80211_BSS_MAX + 1] = {
1550                 [NL80211_BSS_TSF]                  = { .type = NLA_U64 },
1551                 [NL80211_BSS_FREQUENCY]            = { .type = NLA_U32 },
1552                 [NL80211_BSS_BSSID]                = {                 },
1553                 [NL80211_BSS_BEACON_INTERVAL]      = { .type = NLA_U16 },
1554                 [NL80211_BSS_CAPABILITY]           = { .type = NLA_U16 },
1555                 [NL80211_BSS_INFORMATION_ELEMENTS] = {                 },
1556                 [NL80211_BSS_SIGNAL_MBM]           = { .type = NLA_U32 },
1557                 [NL80211_BSS_SIGNAL_UNSPEC]        = { .type = NLA_U8  },
1558                 [NL80211_BSS_STATUS]               = { .type = NLA_U32 },
1559                 [NL80211_BSS_SEEN_MS_AGO]          = { .type = NLA_U32 },
1560                 [NL80211_BSS_BEACON_IES]           = {                 },
1561         };
1562
1563         if (!tb[NL80211_ATTR_BSS] ||
1564                 nla_parse_nested(bss, NL80211_BSS_MAX, tb[NL80211_ATTR_BSS],
1565                                  bss_policy) ||
1566                 !bss[NL80211_BSS_BSSID])
1567         {
1568                 return NL_SKIP;
1569         }
1570
1571         if (bss[NL80211_BSS_CAPABILITY])
1572                 caps = nla_get_u16(bss[NL80211_BSS_CAPABILITY]);
1573         else
1574                 caps = 0;
1575
1576         memset(sl->e, 0, sizeof(*sl->e));
1577         memcpy(sl->e->mac, nla_data(bss[NL80211_BSS_BSSID]), 6);
1578
1579         if (caps & (1<<1))
1580                 sl->e->mode = IWINFO_OPMODE_ADHOC;
1581         else
1582                 sl->e->mode = IWINFO_OPMODE_MASTER;
1583
1584         if (caps & (1<<4))
1585                 sl->e->crypto.enabled = 1;
1586
1587         if (bss[NL80211_BSS_FREQUENCY])
1588                 sl->e->channel = nl80211_freq2channel(nla_get_u32(
1589                         bss[NL80211_BSS_FREQUENCY]));
1590
1591         if (bss[NL80211_BSS_INFORMATION_ELEMENTS])
1592                 nl80211_get_scanlist_ie(bss, sl->e);
1593
1594         if (bss[NL80211_BSS_SIGNAL_MBM])
1595         {
1596                 sl->e->signal =
1597                         (uint8_t)((int32_t)nla_get_u32(bss[NL80211_BSS_SIGNAL_MBM]) / 100);
1598
1599                 rssi = sl->e->signal - 0x100;
1600
1601                 if (rssi < -110)
1602                         rssi = -110;
1603                 else if (rssi > -40)
1604                         rssi = -40;
1605
1606                 sl->e->quality = (rssi + 110);
1607                 sl->e->quality_max = 70;
1608         }
1609
1610         if (sl->e->crypto.enabled && !sl->e->crypto.wpa_version)
1611         {
1612                 sl->e->crypto.auth_algs    = IWINFO_AUTH_OPEN | IWINFO_AUTH_SHARED;
1613                 sl->e->crypto.pair_ciphers = IWINFO_CIPHER_WEP40 | IWINFO_CIPHER_WEP104;
1614         }
1615
1616         sl->e++;
1617         sl->len++;
1618
1619         return NL_SKIP;
1620 }
1621
1622 static int nl80211_get_scanlist_nl(const char *ifname, char *buf, int *len)
1623 {
1624         struct nl80211_msg_conveyor *req;
1625         struct nl80211_scanlist sl = { .e = (struct iwinfo_scanlist_entry *)buf };
1626
1627         req = nl80211_msg(ifname, NL80211_CMD_TRIGGER_SCAN, 0);
1628         if (req)
1629         {
1630                 nl80211_send(req, NULL, NULL);
1631                 nl80211_free(req);
1632         }
1633
1634         nl80211_wait("nl80211", "scan", NL80211_CMD_NEW_SCAN_RESULTS);
1635
1636         req = nl80211_msg(ifname, NL80211_CMD_GET_SCAN, NLM_F_DUMP);
1637         if (req)
1638         {
1639                 nl80211_send(req, nl80211_get_scanlist_cb, &sl);
1640                 nl80211_free(req);
1641         }
1642
1643         *len = sl.len * sizeof(struct iwinfo_scanlist_entry);
1644         return *len ? 0 : -1;
1645 }
1646
1647 int nl80211_get_scanlist(const char *ifname, char *buf, int *len)
1648 {
1649         int freq, rssi, qmax, count;
1650         char *res;
1651         char ssid[128] = { 0 };
1652         char bssid[18] = { 0 };
1653         char cipher[256] = { 0 };
1654
1655         /* Got a radioX pseudo interface, find some interface on it or create one */
1656         if (!strncmp(ifname, "radio", 5))
1657         {
1658                 /* Reuse existing interface */
1659                 if ((res = nl80211_phy2ifname(ifname)) != NULL)
1660                 {
1661                         return nl80211_get_scanlist(res, buf, len);
1662                 }
1663
1664                 /* Need to spawn a temporary iface for scanning */
1665                 else if ((res = nl80211_ifadd(ifname)) != NULL)
1666                 {
1667                         count = nl80211_get_scanlist(res, buf, len);
1668                         nl80211_ifdel(res);
1669                         return count;
1670                 }
1671         }
1672
1673         struct iwinfo_scanlist_entry *e = (struct iwinfo_scanlist_entry *)buf;
1674
1675         /* WPA supplicant */
1676         if ((res = nl80211_wpactl_info(ifname, "SCAN", "CTRL-EVENT-SCAN-RESULTS")))
1677         {
1678                 if ((res = nl80211_wpactl_info(ifname, "SCAN_RESULTS", NULL)))
1679                 {
1680                         nl80211_get_quality_max(ifname, &qmax);
1681
1682                         /* skip header line */
1683                         while (*res++ != '\n');
1684
1685                         count = 0;
1686
1687                         while (sscanf(res, "%17s %d %d %255s%*[ \t]%127[^\n]\n",
1688                                       bssid, &freq, &rssi, cipher, ssid) > 0)
1689                         {
1690                                 /* BSSID */
1691                                 e->mac[0] = strtol(&bssid[0],  NULL, 16);
1692                                 e->mac[1] = strtol(&bssid[3],  NULL, 16);
1693                                 e->mac[2] = strtol(&bssid[6],  NULL, 16);
1694                                 e->mac[3] = strtol(&bssid[9],  NULL, 16);
1695                                 e->mac[4] = strtol(&bssid[12], NULL, 16);
1696                                 e->mac[5] = strtol(&bssid[15], NULL, 16);
1697
1698                                 /* SSID */
1699                                 memcpy(e->ssid, ssid, min(strlen(ssid), sizeof(e->ssid) - 1));
1700
1701                                 /* Mode (assume master) */
1702                                 e->mode = IWINFO_OPMODE_MASTER;
1703
1704                                 /* Channel */
1705                                 e->channel = nl80211_freq2channel(freq);
1706
1707                                 /* Signal */
1708                                 e->signal = rssi;
1709
1710                                 /* Quality */
1711                                 if (rssi < 0)
1712                                 {
1713                                         /* The cfg80211 wext compat layer assumes a signal range
1714                                          * of -110 dBm to -40 dBm, the quality value is derived
1715                                          * by adding 110 to the signal level */
1716                                         if (rssi < -110)
1717                                                 rssi = -110;
1718                                         else if (rssi > -40)
1719                                                 rssi = -40;
1720
1721                                         e->quality = (rssi + 110);
1722                                 }
1723                                 else
1724                                 {
1725                                         e->quality = rssi;
1726                                 }
1727
1728                                 /* Max. Quality */
1729                                 e->quality_max = qmax;
1730
1731                                 /* Crypto */
1732                                 nl80211_get_scancrypto(cipher, &e->crypto);
1733
1734                                 /* advance to next line */
1735                                 while (*res && *res++ != '\n');
1736
1737                                 count++;
1738                                 e++;
1739
1740                                 memset(ssid, 0, sizeof(ssid));
1741                                 memset(bssid, 0, sizeof(bssid));
1742                                 memset(cipher, 0, sizeof(cipher));
1743                         }
1744
1745                         *len = count * sizeof(struct iwinfo_scanlist_entry);
1746                         return 0;
1747                 }
1748         }
1749
1750         /* AP scan */
1751         else
1752         {
1753                 /* Got a temp interface, don't create yet another one */
1754                 if (!strncmp(ifname, "tmp.", 4))
1755                 {
1756                         if (!iwinfo_ifup(ifname))
1757                                 return -1;
1758
1759                         nl80211_get_scanlist_nl(ifname, buf, len);
1760                         iwinfo_ifdown(ifname);
1761                         return 0;
1762                 }
1763
1764                 /* Spawn a new scan interface */
1765                 else
1766                 {
1767                         if (!(res = nl80211_ifadd(ifname)))
1768                                 goto out;
1769
1770                         if (!iwinfo_ifmac(res))
1771                                 goto out;
1772
1773                         /* if we can take the new interface up, the driver supports an
1774                          * additional interface and there's no need to tear down the ap */
1775                         if (iwinfo_ifup(res))
1776                         {
1777                                 nl80211_get_scanlist_nl(res, buf, len);
1778                                 iwinfo_ifdown(res);
1779                         }
1780
1781                         /* driver cannot create secondary interface, take down ap
1782                          * during scan */
1783                         else if (iwinfo_ifdown(ifname) && iwinfo_ifup(res))
1784                         {
1785                                 nl80211_get_scanlist_nl(res, buf, len);
1786                                 iwinfo_ifdown(res);
1787                                 iwinfo_ifup(ifname);
1788                                 nl80211_hostapd_hup(ifname);
1789                         }
1790
1791                 out:
1792                         nl80211_ifdel(res);
1793                         return 0;
1794                 }
1795         }
1796
1797         return -1;
1798 }
1799
1800 static int nl80211_get_freqlist_cb(struct nl_msg *msg, void *arg)
1801 {
1802         int bands_remain, freqs_remain;
1803
1804         struct nl80211_array_buf *arr = arg;
1805         struct iwinfo_freqlist_entry *e = arr->buf;
1806
1807         struct nlattr **attr = nl80211_parse(msg);
1808         struct nlattr *bands[NL80211_BAND_ATTR_MAX + 1];
1809         struct nlattr *freqs[NL80211_FREQUENCY_ATTR_MAX + 1];
1810         struct nlattr *band, *freq;
1811
1812         static struct nla_policy freq_policy[NL80211_FREQUENCY_ATTR_MAX + 1] = {
1813                 [NL80211_FREQUENCY_ATTR_FREQ]         = { .type = NLA_U32  },
1814                 [NL80211_FREQUENCY_ATTR_DISABLED]     = { .type = NLA_FLAG },
1815                 [NL80211_FREQUENCY_ATTR_PASSIVE_SCAN] = { .type = NLA_FLAG },
1816                 [NL80211_FREQUENCY_ATTR_NO_IBSS]      = { .type = NLA_FLAG },
1817                 [NL80211_FREQUENCY_ATTR_RADAR]        = { .type = NLA_FLAG },
1818                 [NL80211_FREQUENCY_ATTR_MAX_TX_POWER] = { .type = NLA_U32  },
1819         };
1820
1821         nla_for_each_nested(band, attr[NL80211_ATTR_WIPHY_BANDS], bands_remain)
1822         {
1823                 nla_parse(bands, NL80211_BAND_ATTR_MAX,
1824                           nla_data(band), nla_len(band), NULL);
1825
1826                 nla_for_each_nested(freq, bands[NL80211_BAND_ATTR_FREQS], freqs_remain)
1827                 {
1828                         nla_parse(freqs, NL80211_FREQUENCY_ATTR_MAX,
1829                                   nla_data(freq), nla_len(freq), NULL);
1830
1831                         if (!freqs[NL80211_FREQUENCY_ATTR_FREQ] ||
1832                             freqs[NL80211_FREQUENCY_ATTR_DISABLED])
1833                                 continue;
1834
1835                         e->mhz = nla_get_u32(freqs[NL80211_FREQUENCY_ATTR_FREQ]);
1836                         e->channel = nl80211_freq2channel(e->mhz);
1837
1838                         e->restricted = (
1839                                 freqs[NL80211_FREQUENCY_ATTR_PASSIVE_SCAN] ||
1840                                 freqs[NL80211_FREQUENCY_ATTR_NO_IBSS]      ||
1841                                 freqs[NL80211_FREQUENCY_ATTR_RADAR]
1842                         ) ? 1 : 0;
1843
1844                         e++;
1845                         arr->count++;
1846                 }
1847         }
1848
1849         return NL_SKIP;
1850 }
1851
1852 int nl80211_get_freqlist(const char *ifname, char *buf, int *len)
1853 {
1854         struct nl80211_msg_conveyor *req;
1855         struct nl80211_array_buf arr = { .buf = buf, .count = 0 };
1856
1857         req = nl80211_msg(ifname, NL80211_CMD_GET_WIPHY, 0);
1858         if (req)
1859         {
1860                 nl80211_send(req, nl80211_get_freqlist_cb, &arr);
1861                 nl80211_free(req);
1862         }
1863
1864         if (arr.count > 0)
1865         {
1866                 *len = arr.count * sizeof(struct iwinfo_freqlist_entry);
1867                 return 0;
1868         }
1869
1870         return -1;
1871 }
1872
1873 static int nl80211_get_country_cb(struct nl_msg *msg, void *arg)
1874 {
1875         char *buf = arg;
1876         struct nlattr **attr = nl80211_parse(msg);
1877
1878         if (attr[NL80211_ATTR_REG_ALPHA2])
1879                 memcpy(buf, nla_data(attr[NL80211_ATTR_REG_ALPHA2]), 2);
1880         else
1881                 buf[0] = 0;
1882
1883         return NL_SKIP;
1884 }
1885
1886 int nl80211_get_country(const char *ifname, char *buf)
1887 {
1888         int rv = -1;
1889         struct nl80211_msg_conveyor *req;
1890
1891         req = nl80211_msg(ifname, NL80211_CMD_GET_REG, 0);
1892         if (req)
1893         {
1894                 nl80211_send(req, nl80211_get_country_cb, buf);
1895                 nl80211_free(req);
1896
1897                 if (buf[0])
1898                         rv = 0;
1899         }
1900
1901         return rv;
1902 }
1903
1904 int nl80211_get_countrylist(const char *ifname, char *buf, int *len)
1905 {
1906         int i, count;
1907         struct iwinfo_country_entry *e = (struct iwinfo_country_entry *)buf;
1908         const struct iwinfo_iso3166_label *l;
1909
1910         for (l = IWINFO_ISO3166_NAMES, count = 0; l->iso3166; l++, e++, count++)
1911         {
1912                 e->iso3166 = l->iso3166;
1913                 e->ccode[0] = (l->iso3166 / 256);
1914                 e->ccode[1] = (l->iso3166 % 256);
1915         }
1916
1917         *len = (count * sizeof(struct iwinfo_country_entry));
1918         return 0;
1919 }
1920
1921 static int nl80211_get_hwmodelist_cb(struct nl_msg *msg, void *arg)
1922 {
1923         int *modes = arg;
1924         int bands_remain, freqs_remain;
1925         uint16_t caps = 0;
1926         struct nlattr **attr = nl80211_parse(msg);
1927         struct nlattr *bands[NL80211_BAND_ATTR_MAX + 1];
1928         struct nlattr *freqs[NL80211_FREQUENCY_ATTR_MAX + 1];
1929         struct nlattr *band, *freq;
1930
1931         *modes = 0;
1932
1933         if (attr[NL80211_ATTR_WIPHY_BANDS])
1934         {
1935                 nla_for_each_nested(band, attr[NL80211_ATTR_WIPHY_BANDS], bands_remain)
1936                 {
1937                         nla_parse(bands, NL80211_BAND_ATTR_MAX,
1938                                   nla_data(band), nla_len(band), NULL);
1939
1940                         if (bands[NL80211_BAND_ATTR_HT_CAPA])
1941                                 caps = nla_get_u16(bands[NL80211_BAND_ATTR_HT_CAPA]);
1942
1943                         /* Treat any nonzero capability as 11n */
1944                         if (caps > 0)
1945                                 *modes |= IWINFO_80211_N;
1946
1947                         nla_for_each_nested(freq, bands[NL80211_BAND_ATTR_FREQS],
1948                                             freqs_remain)
1949                         {
1950                                 nla_parse(freqs, NL80211_FREQUENCY_ATTR_MAX,
1951                                           nla_data(freq), nla_len(freq), NULL);
1952
1953                                 if (!freqs[NL80211_FREQUENCY_ATTR_FREQ])
1954                                         continue;
1955
1956                                 if (nla_get_u32(freqs[NL80211_FREQUENCY_ATTR_FREQ]) < 2485)
1957                                 {
1958                                         *modes |= IWINFO_80211_B;
1959                                         *modes |= IWINFO_80211_G;
1960                                 }
1961                                 else
1962                                 {
1963                                         *modes |= IWINFO_80211_A;
1964                                 }
1965                         }
1966                 }
1967         }
1968
1969         return NL_SKIP;
1970 }
1971
1972 int nl80211_get_hwmodelist(const char *ifname, int *buf)
1973 {
1974         struct nl80211_msg_conveyor *req;
1975
1976         req = nl80211_msg(ifname, NL80211_CMD_GET_WIPHY, 0);
1977         if (req)
1978         {
1979                 nl80211_send(req, nl80211_get_hwmodelist_cb, buf);
1980                 nl80211_free(req);
1981         }
1982
1983         return *buf ? 0 : -1;
1984 }
1985
1986 int nl80211_get_mbssid_support(const char *ifname, int *buf)
1987 {
1988         /* Test whether we can create another interface */
1989         char *nif = nl80211_ifadd(ifname);
1990
1991         if (nif)
1992         {
1993                 *buf = (iwinfo_ifmac(nif) && iwinfo_ifup(nif));
1994
1995                 iwinfo_ifdown(nif);
1996                 nl80211_ifdel(nif);
1997
1998                 return 0;
1999         }
2000
2001         return -1;
2002 }
2003
2004 int nl80211_get_hardware_id(const char *ifname, char *buf)
2005 {
2006         int rv;
2007         char *res;
2008
2009         /* Got a radioX pseudo interface, find some interface on it or create one */
2010         if (!strncmp(ifname, "radio", 5))
2011         {
2012                 /* Reuse existing interface */
2013                 if ((res = nl80211_phy2ifname(ifname)) != NULL)
2014                 {
2015                         rv = wext_get_hardware_id(res, buf);
2016                 }
2017
2018                 /* Need to spawn a temporary iface for finding IDs */
2019                 else if ((res = nl80211_ifadd(ifname)) != NULL)
2020                 {
2021                         rv = wext_get_hardware_id(res, buf);
2022                         nl80211_ifdel(res);
2023                 }
2024         }
2025         else
2026         {
2027                 rv = wext_get_hardware_id(ifname, buf);
2028         }
2029
2030         /* Failed to obtain hardware IDs, search board config */
2031         if (rv)
2032         {
2033                 rv = iwinfo_hardware_id_from_mtd((struct iwinfo_hardware_id *)buf);
2034         }
2035
2036         return rv;
2037 }
2038
2039 static const struct iwinfo_hardware_entry *
2040 nl80211_get_hardware_entry(const char *ifname)
2041 {
2042         struct iwinfo_hardware_id id;
2043
2044         if (nl80211_get_hardware_id(ifname, (char *)&id))
2045                 return NULL;
2046
2047         return iwinfo_hardware(&id);
2048 }
2049
2050 int nl80211_get_hardware_name(const char *ifname, char *buf)
2051 {
2052         const struct iwinfo_hardware_entry *hw;
2053
2054         if (!(hw = nl80211_get_hardware_entry(ifname)))
2055                 sprintf(buf, "Generic MAC80211");
2056         else
2057                 sprintf(buf, "%s %s", hw->vendor_name, hw->device_name);
2058
2059         return 0;
2060 }
2061
2062 int nl80211_get_txpower_offset(const char *ifname, int *buf)
2063 {
2064         const struct iwinfo_hardware_entry *hw;
2065
2066         if (!(hw = nl80211_get_hardware_entry(ifname)))
2067                 return -1;
2068
2069         *buf = hw->txpower_offset;
2070         return 0;
2071 }
2072
2073 int nl80211_get_frequency_offset(const char *ifname, int *buf)
2074 {
2075         const struct iwinfo_hardware_entry *hw;
2076
2077         if (!(hw = nl80211_get_hardware_entry(ifname)))
2078                 return -1;
2079
2080         *buf = hw->frequency_offset;
2081         return 0;
2082 }