package/network/utils/iwinfo/src/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 "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         int mode;
 452         char *phy;
 453         char path[32] = { 0 };
 454         static char buf[4096] = { 0 };
 455         FILE *conf;
 456
 457         if (nl80211_get_mode(ifname, &mode))
 458                 return NULL;
 459
 460         if ((mode == IWINFO_OPMODE_MASTER || mode == IWINFO_OPMODE_AP_VLAN) &&
 461             (phy = nl80211_ifname2phy(ifname)) != NULL)
 462         {
 463                 snprintf(path, sizeof(path), "/var/run/hostapd-%s.conf", phy);
 464
 465                 if ((conf = fopen(path, "r")) != NULL)
 466                 {
 467                         fread(buf, sizeof(buf) - 1, 1, conf);
 468                         fclose(conf);
 469
 470                         return buf;
 471                 }
 472         }
 473
 474         return NULL;
 475 }
 476
 477 static inline int nl80211_wpactl_recv(int sock, char *buf, int blen)
 478 {
 479         fd_set rfds;
 480         struct timeval tv = { 2, 0 };
 481
 482         FD_ZERO(&rfds);
 483         FD_SET(sock, &rfds);
 484
 485         memset(buf, 0, blen);
 486
 487
 488         if (select(sock + 1, &rfds, NULL, NULL, &tv) < 0)
 489                 return -1;
 490
 491         if (!FD_ISSET(sock, &rfds))
 492                 return -1;
 493
 494         return recv(sock, buf, blen, 0);
 495 }
 496
 497 static char * nl80211_wpactl_info(const char *ifname, const char *cmd,
 498                                                                    const char *event)
 499 {
 500         int numtry = 0;
 501         int sock = -1;
 502         char *rv = NULL;
 503         size_t remote_length, local_length;
 504         static char buffer[10240] = { 0 };
 505
 506         struct sockaddr_un local = { 0 };
 507         struct sockaddr_un remote = { 0 };
 508
 509
 510         sock = socket(PF_UNIX, SOCK_DGRAM, 0);
 511         if (sock < 0)
 512                 return NULL;
 513
 514         remote.sun_family = AF_UNIX;
 515         remote_length = sizeof(remote.sun_family) + sprintf(remote.sun_path,
 516                 "/var/run/wpa_supplicant-%s/%s", ifname, ifname);
 517
 518         if (fcntl(sock, F_SETFD, fcntl(sock, F_GETFD) | FD_CLOEXEC) < 0)
 519                 goto out;
 520
 521         if (connect(sock, (struct sockaddr *) &remote, remote_length))
 522                 goto out;
 523
 524         local.sun_family = AF_UNIX;
 525         local_length = sizeof(local.sun_family) +
 526                 sprintf(local.sun_path, "/var/run/iwinfo-%s-%d", ifname, getpid());
 527
 528         if (bind(sock, (struct sockaddr *) &local, local_length))
 529                 goto out;
 530
 531
 532         if (event)
 533         {
 534                 send(sock, "ATTACH", 6, 0);
 535
 536                 if (nl80211_wpactl_recv(sock, buffer, sizeof(buffer)) <= 0)
 537                         goto out;
 538         }
 539
 540
 541         send(sock, cmd, strlen(cmd), 0);
 542
 543         while( numtry++ < 5 )
 544         {
 545                 if (nl80211_wpactl_recv(sock, buffer, sizeof(buffer)) <= 0)
 546                 {
 547                         if (event)
 548                                 continue;
 549
 550                         break;
 551                 }
 552
 553                 if ((!event && buffer[0] != '<') || (event && strstr(buffer, event)))
 554                         break;
 555         }
 556
 557         rv = buffer;
 558
 559 out:
 560         close(sock);
 561
 562         if (local.sun_family)
 563                 unlink(local.sun_path);
 564
 565         return rv;
 566 }
 567
 568 static inline int nl80211_readint(const char *path)
 569 {
 570         int fd;
 571         int rv = -1;
 572         char buffer[16];
 573
 574         if ((fd = open(path, O_RDONLY)) > -1)
 575         {
 576                 if (read(fd, buffer, sizeof(buffer)) > 0)
 577                         rv = atoi(buffer);
 578
 579                 close(fd);
 580         }
 581
 582         return rv;
 583 }
 584
 585 static char * nl80211_phy2ifname(const char *ifname)
 586 {
 587         int fd, ifidx = -1, cifidx = -1, phyidx = -1;
 588         char buffer[64];
 589         static char nif[IFNAMSIZ] = { 0 };
 590
 591         DIR *d;
 592         struct dirent *e;
 593
 594         if (!ifname)
 595                 return NULL;
 596         else if (!strncmp(ifname, "phy", 3))
 597                 phyidx = atoi(&ifname[3]);
 598         else if (!strncmp(ifname, "radio", 5))
 599                 phyidx = atoi(&ifname[5]);
 600
 601         memset(nif, 0, sizeof(nif));
 602
 603         if (phyidx > -1)
 604         {
 605                 if ((d = opendir("/sys/class/net")) != NULL)
 606                 {
 607                         while ((e = readdir(d)) != NULL)
 608                         {
 609                                 snprintf(buffer, sizeof(buffer),
 610                                          "/sys/class/net/%s/phy80211/index", e->d_name);
 611
 612                                 if (nl80211_readint(buffer) == phyidx)
 613                                 {
 614                                         snprintf(buffer, sizeof(buffer),
 615                                                  "/sys/class/net/%s/ifindex", e->d_name);
 616
 617                                         if ((cifidx = nl80211_readint(buffer)) >= 0 &&
 618                                             ((ifidx < 0) || (cifidx < ifidx)))
 619                                         {
 620                                                 ifidx = cifidx;
 621                                                 strncpy(nif, e->d_name, sizeof(nif));
 622                                         }
 623                                 }
 624                         }
 625
 626                         closedir(d);
 627                 }
 628         }
 629
 630         return nif[0] ? nif : NULL;
 631 }
 632
 633 static char * nl80211_ifadd(const char *ifname)
 634 {
 635         int phyidx;
 636         char *rv = NULL;
 637         static char nif[IFNAMSIZ] = { 0 };
 638         struct nl80211_msg_conveyor *req, *res;
 639
 640         req = nl80211_msg(ifname, NL80211_CMD_NEW_INTERFACE, 0);
 641         if (req)
 642         {
 643                 snprintf(nif, sizeof(nif), "tmp.%s", ifname);
 644
 645                 NLA_PUT_STRING(req->msg, NL80211_ATTR_IFNAME, nif);
 646                 NLA_PUT_U32(req->msg, NL80211_ATTR_IFTYPE, NL80211_IFTYPE_STATION);
 647
 648                 nl80211_send(req, NULL, NULL);
 649
 650                 rv = nif;
 651
 652         nla_put_failure:
 653                 nl80211_free(req);
 654         }
 655
 656         return rv;
 657 }
 658
 659 static void nl80211_ifdel(const char *ifname)
 660 {
 661         struct nl80211_msg_conveyor *req;
 662
 663         req = nl80211_msg(ifname, NL80211_CMD_DEL_INTERFACE, 0);
 664         if (req)
 665         {
 666                 NLA_PUT_STRING(req->msg, NL80211_ATTR_IFNAME, ifname);
 667
 668                 nl80211_send(req, NULL, NULL);
 669
 670         nla_put_failure:
 671                 nl80211_free(req);
 672         }
 673 }
 674
 675 static void nl80211_hostapd_hup(const char *ifname)
 676 {
 677         int fd, pid = 0;
 678         char buf[32];
 679         char *phy = nl80211_ifname2phy(ifname);
 680
 681         if (phy)
 682         {
 683                 snprintf(buf, sizeof(buf), "/var/run/wifi-%s.pid", phy);
 684                 if ((fd = open(buf, O_RDONLY)) > 0)
 685                 {
 686                         if (read(fd, buf, sizeof(buf)) > 0)
 687                                 pid = atoi(buf);
 688
 689                         close(fd);
 690                 }
 691
 692                 if (pid > 0)
 693                         kill(pid, 1);
 694         }
 695 }
 696
 697
 698 int nl80211_probe(const char *ifname)
 699 {
 700         return !!nl80211_ifname2phy(ifname);
 701 }
 702
 703 void nl80211_close(void)
 704 {
 705         if (nls)
 706         {
 707                 if (nls->nlctrl)
 708                         genl_family_put(nls->nlctrl);
 709
 710                 if (nls->nl80211)
 711                         genl_family_put(nls->nl80211);
 712
 713                 if (nls->nl_sock)
 714                         nl_socket_free(nls->nl_sock);
 715
 716                 if (nls->nl_cache)
 717                         nl_cache_free(nls->nl_cache);
 718
 719                 free(nls);
 720                 nls = NULL;
 721         }
 722 }
 723
 724
 725 static int nl80211_get_mode_cb(struct nl_msg *msg, void *arg)
 726 {
 727         int *mode = arg;
 728         struct nlattr **tb = nl80211_parse(msg);
 729         const int ifmodes[NL80211_IFTYPE_MAX + 1] = {
 730                 IWINFO_OPMODE_UNKNOWN,          /* unspecified */
 731                 IWINFO_OPMODE_ADHOC,            /* IBSS */
 732                 IWINFO_OPMODE_CLIENT,           /* managed */
 733                 IWINFO_OPMODE_MASTER,           /* AP */
 734                 IWINFO_OPMODE_AP_VLAN,          /* AP/VLAN */
 735                 IWINFO_OPMODE_WDS,                      /* WDS */
 736                 IWINFO_OPMODE_MONITOR,          /* monitor */
 737                 IWINFO_OPMODE_MESHPOINT,        /* mesh point */
 738                 IWINFO_OPMODE_P2P_CLIENT,       /* P2P-client */
 739                 IWINFO_OPMODE_P2P_GO,           /* P2P-GO */
 740         };
 741
 742         if (tb[NL80211_ATTR_IFTYPE])
 743                 *mode = ifmodes[nla_get_u32(tb[NL80211_ATTR_IFTYPE])];
 744
 745         return NL_SKIP;
 746 }
 747
 748 int nl80211_get_mode(const char *ifname, int *buf)
 749 {
 750         char *res;
 751         struct nl80211_msg_conveyor *req;
 752
 753         res = nl80211_phy2ifname(ifname);
 754         req = nl80211_msg(res ? res : ifname, NL80211_CMD_GET_INTERFACE, 0);
 755         *buf = IWINFO_OPMODE_UNKNOWN;
 756
 757         if (req)
 758         {
 759                 nl80211_send(req, nl80211_get_mode_cb, buf);
 760                 nl80211_free(req);
 761         }
 762
 763         return (*buf == IWINFO_OPMODE_UNKNOWN) ? -1 : 0;
 764 }
 765
 766
 767 struct nl80211_ssid_bssid {
 768         unsigned char *ssid;
 769         unsigned char bssid[7];
 770 };
 771
 772 static int nl80211_get_ssid_bssid_cb(struct nl_msg *msg, void *arg)
 773 {
 774         int ielen;
 775         unsigned char *ie;
 776         struct nl80211_ssid_bssid *sb = arg;
 777         struct nlattr **tb = nl80211_parse(msg);
 778         struct nlattr *bss[NL80211_BSS_MAX + 1];
 779
 780         static struct nla_policy bss_policy[NL80211_BSS_MAX + 1] = {
 781                 [NL80211_BSS_INFORMATION_ELEMENTS] = {                 },
 782                 [NL80211_BSS_STATUS]               = { .type = NLA_U32 },
 783         };
 784
 785         if (!tb[NL80211_ATTR_BSS] ||
 786             nla_parse_nested(bss, NL80211_BSS_MAX, tb[NL80211_ATTR_BSS],
 787                              bss_policy) ||
 788             !bss[NL80211_BSS_BSSID] ||
 789             !bss[NL80211_BSS_STATUS] ||
 790             !bss[NL80211_BSS_INFORMATION_ELEMENTS])
 791         {
 792                 return NL_SKIP;
 793         }
 794
 795         switch (nla_get_u32(bss[NL80211_BSS_STATUS]))
 796         {
 797         case NL80211_BSS_STATUS_ASSOCIATED:
 798         case NL80211_BSS_STATUS_AUTHENTICATED:
 799         case NL80211_BSS_STATUS_IBSS_JOINED:
 800
 801                 if (sb->ssid)
 802                 {
 803                         ie = nla_data(bss[NL80211_BSS_INFORMATION_ELEMENTS]);
 804                         ielen = nla_len(bss[NL80211_BSS_INFORMATION_ELEMENTS]);
 805
 806                         while (ielen >= 2 && ielen >= ie[1])
 807                         {
 808                                 if (ie[0] == 0)
 809                                 {
 810                                         memcpy(sb->ssid, ie + 2, min(ie[1], IWINFO_ESSID_MAX_SIZE));
 811                                         return NL_SKIP;
 812                                 }
 813
 814                                 ielen -= ie[1] + 2;
 815                                 ie += ie[1] + 2;
 816                         }
 817                 }
 818                 else
 819                 {
 820                         sb->bssid[0] = 1;
 821                         memcpy(sb->bssid + 1, nla_data(bss[NL80211_BSS_BSSID]), 6);
 822                         return NL_SKIP;
 823                 }
 824
 825         default:
 826                 return NL_SKIP;
 827         }
 828 }
 829
 830 int nl80211_get_ssid(const char *ifname, char *buf)
 831 {
 832         char *res;
 833         struct nl80211_msg_conveyor *req;
 834         struct nl80211_ssid_bssid sb;
 835
 836         /* try to find ssid from scan dump results */
 837         res = nl80211_phy2ifname(ifname);
 838         req = nl80211_msg(res ? res : ifname, NL80211_CMD_GET_SCAN, NLM_F_DUMP);
 839
 840         sb.ssid = buf;
 841         *buf = 0;
 842
 843         if (req)
 844         {
 845                 nl80211_send(req, nl80211_get_ssid_bssid_cb, &sb);
 846                 nl80211_free(req);
 847         }
 848
 849         /* failed, try to find from hostapd info */
 850         if ((*buf == 0) &&
 851             (res = nl80211_hostapd_info(ifname)) &&
 852             (res = nl80211_getval(ifname, res, "ssid")))
 853         {
 854                 memcpy(buf, res, strlen(res));
 855         }
 856
 857         return (*buf == 0) ? -1 : 0;
 858 }
 859
 860 int nl80211_get_bssid(const char *ifname, char *buf)
 861 {
 862         char *res;
 863         struct nl80211_msg_conveyor *req;
 864         struct nl80211_ssid_bssid sb;
 865
 866         /* try to find bssid from scan dump results */
 867         res = nl80211_phy2ifname(ifname);
 868         req = nl80211_msg(res ? res : ifname, NL80211_CMD_GET_SCAN, NLM_F_DUMP);
 869
 870         sb.ssid = NULL;
 871         sb.bssid[0] = 0;
 872
 873         if (req)
 874         {
 875                 nl80211_send(req, nl80211_get_ssid_bssid_cb, &sb);
 876                 nl80211_free(req);
 877         }
 878
 879         /* failed, try to find mac from hostapd info */
 880         if ((sb.bssid[0] == 0) &&
 881             (res = nl80211_hostapd_info(ifname)) &&
 882             (res = nl80211_getval(ifname, res, "bssid")))
 883         {
 884                 sb.bssid[0] = 1;
 885                 sb.bssid[1] = strtol(&res[0],  NULL, 16);
 886                 sb.bssid[2] = strtol(&res[3],  NULL, 16);
 887                 sb.bssid[3] = strtol(&res[6],  NULL, 16);
 888                 sb.bssid[4] = strtol(&res[9],  NULL, 16);
 889                 sb.bssid[5] = strtol(&res[12], NULL, 16);
 890                 sb.bssid[6] = strtol(&res[15], NULL, 16);
 891         }
 892
 893         if (sb.bssid[0])
 894         {
 895                 sprintf(buf, "%02X:%02X:%02X:%02X:%02X:%02X",
 896                         sb.bssid[1], sb.bssid[2], sb.bssid[3],
 897                         sb.bssid[4], sb.bssid[5], sb.bssid[6]);
 898
 899                 return 0;
 900         }
 901
 902         return -1;
 903 }
 904
 905
 906 static int nl80211_get_frequency_scan_cb(struct nl_msg *msg, void *arg)
 907 {
 908         int *freq = arg;
 909         struct nlattr **attr = nl80211_parse(msg);
 910         struct nlattr *binfo[NL80211_BSS_MAX + 1];
 911
 912         static struct nla_policy bss_policy[NL80211_BSS_MAX + 1] = {
 913                 [NL80211_BSS_FREQUENCY] = { .type = NLA_U32 },
 914         };
 915
 916         if (attr[NL80211_ATTR_BSS] &&
 917             !nla_parse_nested(binfo, NL80211_BSS_MAX,
 918                               attr[NL80211_ATTR_BSS], bss_policy))
 919         {
 920                 if (binfo[NL80211_BSS_FREQUENCY])
 921                         *freq = nla_get_u32(binfo[NL80211_BSS_FREQUENCY]);
 922         }
 923
 924         return NL_SKIP;
 925 }
 926
 927 static int nl80211_get_frequency_info_cb(struct nl_msg *msg, void *arg)
 928 {
 929         int *freq = arg;
 930         struct nlattr **tb = nl80211_parse(msg);
 931
 932         if (tb[NL80211_ATTR_WIPHY_FREQ])
 933                 *freq = nla_get_u32(tb[NL80211_ATTR_WIPHY_FREQ]);
 934
 935         return NL_SKIP;
 936 }
 937
 938 int nl80211_get_frequency(const char *ifname, int *buf)
 939 {
 940         char *res, *channel;
 941         struct nl80211_msg_conveyor *req;
 942
 943         /* try to find frequency from interface info */
 944         res = nl80211_phy2ifname(ifname);
 945         req = nl80211_msg(res ? res : ifname, NL80211_CMD_GET_INTERFACE, 0);
 946         *buf = 0;
 947
 948         if (req)
 949         {
 950                 nl80211_send(req, nl80211_get_frequency_info_cb, buf);
 951                 nl80211_free(req);
 952         }
 953
 954         /* failed, try to find frequency from hostapd info */
 955         if ((*buf == 0) &&
 956             (res = nl80211_hostapd_info(ifname)) &&
 957             (channel = nl80211_getval(NULL, res, "channel")))
 958         {
 959                 *buf = nl80211_channel2freq(atoi(channel),
 960                                             nl80211_getval(NULL, res, "hw_mode"));
 961         }
 962         else
 963         {
 964                 /* failed, try to find frequency from scan results */
 965                 if (*buf == 0)
 966                 {
 967                         res = nl80211_phy2ifname(ifname);
 968                         req = nl80211_msg(res ? res : ifname, NL80211_CMD_GET_SCAN,
 969                                           NLM_F_DUMP);
 970
 971                         if (req)
 972                         {
 973                                 nl80211_send(req, nl80211_get_frequency_scan_cb, buf);
 974                                 nl80211_free(req);
 975                         }
 976                 }
 977         }
 978
 979         return (*buf == 0) ? -1 : 0;
 980 }
 981
 982 int nl80211_get_channel(const char *ifname, int *buf)
 983 {
 984         if (!nl80211_get_frequency(ifname, buf))
 985         {
 986                 *buf = nl80211_freq2channel(*buf);
 987                 return 0;
 988         }
 989
 990         return -1;
 991 }
 992
 993
 994 int nl80211_get_txpower(const char *ifname, int *buf)
 995 {
 996 #if 0
 997         char *res;
 998         char path[PATH_MAX];
 999
1000         res = nl80211_ifname2phy(ifname);
1001         snprintf(path, sizeof(path), "/sys/kernel/debug/ieee80211/%s/power",
1002                  res ? res : ifname);
1003
1004         if ((*buf = nl80211_readint(path)) > -1)
1005                 return 0;
1006 #endif
1007
1008         return wext_get_txpower(ifname, buf);
1009 }
1010
1011
1012 static int nl80211_fill_signal_cb(struct nl_msg *msg, void *arg)
1013 {
1014         int8_t dbm;
1015         int16_t mbit;
1016         struct nl80211_rssi_rate *rr = arg;
1017         struct nlattr **attr = nl80211_parse(msg);
1018         struct nlattr *sinfo[NL80211_STA_INFO_MAX + 1];
1019         struct nlattr *rinfo[NL80211_RATE_INFO_MAX + 1];
1020
1021         static struct nla_policy stats_policy[NL80211_STA_INFO_MAX + 1] = {
1022                 [NL80211_STA_INFO_INACTIVE_TIME] = { .type = NLA_U32    },
1023                 [NL80211_STA_INFO_RX_BYTES]      = { .type = NLA_U32    },
1024                 [NL80211_STA_INFO_TX_BYTES]      = { .type = NLA_U32    },
1025                 [NL80211_STA_INFO_RX_PACKETS]    = { .type = NLA_U32    },
1026                 [NL80211_STA_INFO_TX_PACKETS]    = { .type = NLA_U32    },
1027                 [NL80211_STA_INFO_SIGNAL]        = { .type = NLA_U8     },
1028                 [NL80211_STA_INFO_TX_BITRATE]    = { .type = NLA_NESTED },
1029                 [NL80211_STA_INFO_LLID]          = { .type = NLA_U16    },
1030                 [NL80211_STA_INFO_PLID]          = { .type = NLA_U16    },
1031                 [NL80211_STA_INFO_PLINK_STATE]   = { .type = NLA_U8     },
1032         };
1033
1034         static struct nla_policy rate_policy[NL80211_RATE_INFO_MAX + 1] = {
1035                 [NL80211_RATE_INFO_BITRATE]      = { .type = NLA_U16  },
1036                 [NL80211_RATE_INFO_MCS]          = { .type = NLA_U8   },
1037                 [NL80211_RATE_INFO_40_MHZ_WIDTH] = { .type = NLA_FLAG },
1038                 [NL80211_RATE_INFO_SHORT_GI]     = { .type = NLA_FLAG },
1039         };
1040
1041         if (attr[NL80211_ATTR_STA_INFO])
1042         {
1043                 if (!nla_parse_nested(sinfo, NL80211_STA_INFO_MAX,
1044                                       attr[NL80211_ATTR_STA_INFO], stats_policy))
1045                 {
1046                         if (sinfo[NL80211_STA_INFO_SIGNAL])
1047                         {
1048                                 dbm = nla_get_u8(sinfo[NL80211_STA_INFO_SIGNAL]);
1049                                 rr->rssi = rr->rssi ? (int8_t)((rr->rssi + dbm) / 2) : dbm;
1050                         }
1051
1052                         if (sinfo[NL80211_STA_INFO_TX_BITRATE])
1053                         {
1054                                 if (!nla_parse_nested(rinfo, NL80211_RATE_INFO_MAX,
1055                                                       sinfo[NL80211_STA_INFO_TX_BITRATE],
1056                                                       rate_policy))
1057                                 {
1058                                         if (rinfo[NL80211_RATE_INFO_BITRATE])
1059                                         {
1060                                                 mbit = nla_get_u16(rinfo[NL80211_RATE_INFO_BITRATE]);
1061                                                 rr->rate = rr->rate
1062                                                         ? (int16_t)((rr->rate + mbit) / 2) : mbit;
1063                                         }
1064                                 }
1065                         }
1066                 }
1067         }
1068
1069         return NL_SKIP;
1070 }
1071
1072 static void nl80211_fill_signal(const char *ifname, struct nl80211_rssi_rate *r)
1073 {
1074         DIR *d;
1075         struct dirent *de;
1076         struct nl80211_msg_conveyor *req;
1077
1078         r->rssi = 0;
1079         r->rate = 0;
1080
1081         if ((d = opendir("/sys/class/net")) != NULL)
1082         {
1083                 while ((de = readdir(d)) != NULL)
1084                 {
1085                         if (!strncmp(de->d_name, ifname, strlen(ifname)) &&
1086                             (!de->d_name[strlen(ifname)] ||
1087                              !strncmp(&de->d_name[strlen(ifname)], ".sta", 4)))
1088                         {
1089                                 req = nl80211_msg(de->d_name, NL80211_CMD_GET_STATION,
1090                                                   NLM_F_DUMP);
1091
1092                                 if (req)
1093                                 {
1094                                         nl80211_send(req, nl80211_fill_signal_cb, r);
1095                                         nl80211_free(req);
1096                                 }
1097                         }
1098                 }
1099
1100                 closedir(d);
1101         }
1102 }
1103
1104 int nl80211_get_bitrate(const char *ifname, int *buf)
1105 {
1106         struct nl80211_rssi_rate rr;
1107
1108         nl80211_fill_signal(ifname, &rr);
1109
1110         if (rr.rate)
1111         {
1112                 *buf = (rr.rate * 100);
1113                 return 0;
1114         }
1115
1116         return -1;
1117 }
1118
1119 int nl80211_get_signal(const char *ifname, int *buf)
1120 {
1121         struct nl80211_rssi_rate rr;
1122
1123         nl80211_fill_signal(ifname, &rr);
1124
1125         if (rr.rssi)
1126         {
1127                 *buf = rr.rssi;
1128                 return 0;
1129         }
1130
1131         return -1;
1132 }
1133
1134 static int nl80211_get_noise_cb(struct nl_msg *msg, void *arg)
1135 {
1136         int8_t *noise = arg;
1137         struct nlattr **tb = nl80211_parse(msg);
1138         struct nlattr *si[NL80211_SURVEY_INFO_MAX + 1];
1139
1140         static struct nla_policy sp[NL80211_SURVEY_INFO_MAX + 1] = {
1141                 [NL80211_SURVEY_INFO_FREQUENCY] = { .type = NLA_U32 },
1142                 [NL80211_SURVEY_INFO_NOISE]     = { .type = NLA_U8  },
1143         };
1144
1145         if (!tb[NL80211_ATTR_SURVEY_INFO])
1146                 return NL_SKIP;
1147
1148         if (nla_parse_nested(si, NL80211_SURVEY_INFO_MAX,
1149                              tb[NL80211_ATTR_SURVEY_INFO], sp))
1150                 return NL_SKIP;
1151
1152         if (!si[NL80211_SURVEY_INFO_NOISE])
1153                 return NL_SKIP;
1154
1155         if (!*noise || si[NL80211_SURVEY_INFO_IN_USE])
1156                 *noise = (int8_t)nla_get_u8(si[NL80211_SURVEY_INFO_NOISE]);
1157
1158         return NL_SKIP;
1159 }
1160
1161
1162 int nl80211_get_noise(const char *ifname, int *buf)
1163 {
1164         int8_t noise;
1165         struct nl80211_msg_conveyor *req;
1166
1167         req = nl80211_msg(ifname, NL80211_CMD_GET_SURVEY, NLM_F_DUMP);
1168         if (req)
1169         {
1170                 noise = 0;
1171
1172                 nl80211_send(req, nl80211_get_noise_cb, &noise);
1173                 nl80211_free(req);
1174
1175                 if (noise)
1176                 {
1177                         *buf = noise;
1178                         return 0;
1179                 }
1180         }
1181
1182         return -1;
1183 }
1184
1185 int nl80211_get_quality(const char *ifname, int *buf)
1186 {
1187         int signal;
1188
1189         if (!nl80211_get_signal(ifname, &signal))
1190         {
1191                 /* A positive signal level is usually just a quality
1192                  * value, pass through as-is */
1193                 if (signal >= 0)
1194                 {
1195                         *buf = signal;
1196                 }
1197
1198                 /* The cfg80211 wext compat layer assumes a signal range
1199                  * of -110 dBm to -40 dBm, the quality value is derived
1200                  * by adding 110 to the signal level */
1201                 else
1202                 {
1203                         if (signal < -110)
1204                                 signal = -110;
1205                         else if (signal > -40)
1206                                 signal = -40;
1207
1208                         *buf = (signal + 110);
1209                 }
1210
1211                 return 0;
1212         }
1213
1214         return -1;
1215 }
1216
1217 int nl80211_get_quality_max(const char *ifname, int *buf)
1218 {
1219         /* The cfg80211 wext compat layer assumes a maximum
1220          * quality of 70 */
1221         *buf = 70;
1222
1223         return 0;
1224 }
1225
1226 int nl80211_get_encryption(const char *ifname, char *buf)
1227 {
1228         int i;
1229         char k[9];
1230         char *val, *res;
1231         struct iwinfo_crypto_entry *c = (struct iwinfo_crypto_entry *)buf;
1232
1233         /* WPA supplicant */
1234         if ((res = nl80211_wpactl_info(ifname, "STATUS", NULL)) &&
1235             (val = nl80211_getval(NULL, res, "pairwise_cipher")))
1236         {
1237                 /* WEP */
1238                 if (strstr(val, "WEP"))
1239                 {
1240                         if (strstr(val, "WEP-40"))
1241                                 c->pair_ciphers |= IWINFO_CIPHER_WEP40;
1242
1243                         else if (strstr(val, "WEP-104"))
1244                                 c->pair_ciphers |= IWINFO_CIPHER_WEP104;
1245
1246                         c->enabled       = 1;
1247                         c->group_ciphers = c->pair_ciphers;
1248
1249                         c->auth_suites |= IWINFO_KMGMT_NONE;
1250                         c->auth_algs   |= IWINFO_AUTH_OPEN; /* XXX: assumption */
1251                 }
1252
1253                 /* WPA */
1254                 else
1255                 {
1256                         if (strstr(val, "TKIP"))
1257                                 c->pair_ciphers |= IWINFO_CIPHER_TKIP;
1258
1259                         else if (strstr(val, "CCMP"))
1260                                 c->pair_ciphers |= IWINFO_CIPHER_CCMP;
1261
1262                         else if (strstr(val, "NONE"))
1263                                 c->pair_ciphers |= IWINFO_CIPHER_NONE;
1264
1265                         else if (strstr(val, "WEP-40"))
1266                                 c->pair_ciphers |= IWINFO_CIPHER_WEP40;
1267
1268                         else if (strstr(val, "WEP-104"))
1269                                 c->pair_ciphers |= IWINFO_CIPHER_WEP104;
1270
1271
1272                         if ((val = nl80211_getval(NULL, res, "group_cipher")))
1273                         {
1274                                 if (strstr(val, "TKIP"))
1275                                         c->group_ciphers |= IWINFO_CIPHER_TKIP;
1276
1277                                 else if (strstr(val, "CCMP"))
1278                                         c->group_ciphers |= IWINFO_CIPHER_CCMP;
1279
1280                                 else if (strstr(val, "NONE"))
1281                                         c->group_ciphers |= IWINFO_CIPHER_NONE;
1282
1283                                 else if (strstr(val, "WEP-40"))
1284                                         c->group_ciphers |= IWINFO_CIPHER_WEP40;
1285
1286                                 else if (strstr(val, "WEP-104"))
1287                                         c->group_ciphers |= IWINFO_CIPHER_WEP104;
1288                         }
1289
1290
1291                         if ((val = nl80211_getval(NULL, res, "key_mgmt")))
1292                         {
1293                                 if (strstr(val, "WPA2"))
1294                                         c->wpa_version = 2;
1295
1296                                 else if (strstr(val, "WPA"))
1297                                         c->wpa_version = 1;
1298
1299
1300                                 if (strstr(val, "PSK"))
1301                                         c->auth_suites |= IWINFO_KMGMT_PSK;
1302
1303                                 else if (strstr(val, "EAP") || strstr(val, "802.1X"))
1304                                         c->auth_suites |= IWINFO_KMGMT_8021x;
1305
1306                                 else if (strstr(val, "NONE"))
1307                                         c->auth_suites |= IWINFO_KMGMT_NONE;
1308                         }
1309
1310                         c->enabled = (c->wpa_version && c->auth_suites) ? 1 : 0;
1311                 }
1312
1313                 return 0;
1314         }
1315
1316         /* Hostapd */
1317         else if ((res = nl80211_hostapd_info(ifname)))
1318         {
1319                 if ((val = nl80211_getval(ifname, res, "wpa")) != NULL)
1320                         c->wpa_version = atoi(val);
1321
1322                 val = nl80211_getval(ifname, res, "wpa_key_mgmt");
1323
1324                 if (!val || strstr(val, "PSK"))
1325                         c->auth_suites |= IWINFO_KMGMT_PSK;
1326
1327                 if (val && strstr(val, "EAP"))
1328                         c->auth_suites |= IWINFO_KMGMT_8021x;
1329
1330                 if (val && strstr(val, "NONE"))
1331                         c->auth_suites |= IWINFO_KMGMT_NONE;
1332
1333                 if ((val = nl80211_getval(ifname, res, "wpa_pairwise")) != NULL)
1334                 {
1335                         if (strstr(val, "TKIP"))
1336                                 c->pair_ciphers |= IWINFO_CIPHER_TKIP;
1337
1338                         if (strstr(val, "CCMP"))
1339                                 c->pair_ciphers |= IWINFO_CIPHER_CCMP;
1340
1341                         if (strstr(val, "NONE"))
1342                                 c->pair_ciphers |= IWINFO_CIPHER_NONE;
1343                 }
1344
1345                 if ((val = nl80211_getval(ifname, res, "auth_algs")) != NULL)
1346                 {
1347                         switch(atoi(val)) {
1348                                 case 1:
1349                                         c->auth_algs |= IWINFO_AUTH_OPEN;
1350                                         break;
1351
1352                                 case 2:
1353                                         c->auth_algs |= IWINFO_AUTH_SHARED;
1354                                         break;
1355
1356                                 case 3:
1357                                         c->auth_algs |= IWINFO_AUTH_OPEN;
1358                                         c->auth_algs |= IWINFO_AUTH_SHARED;
1359                                         break;
1360
1361                                 default:
1362                                         break;
1363                         }
1364
1365                         for (i = 0; i < 4; i++)
1366                         {
1367                                 snprintf(k, sizeof(k), "wep_key%d", i);
1368
1369                                 if ((val = nl80211_getval(ifname, res, k)))
1370                                 {
1371                                         if ((strlen(val) == 5) || (strlen(val) == 10))
1372                                                 c->pair_ciphers |= IWINFO_CIPHER_WEP40;
1373
1374                                         else if ((strlen(val) == 13) || (strlen(val) == 26))
1375                                                 c->pair_ciphers |= IWINFO_CIPHER_WEP104;
1376                                 }
1377                         }
1378                 }
1379
1380                 c->group_ciphers = c->pair_ciphers;
1381                 c->enabled = (c->wpa_version || c->pair_ciphers) ? 1 : 0;
1382
1383                 return 0;
1384         }
1385
1386         return -1;
1387 }
1388
1389
1390 static int nl80211_get_assoclist_cb(struct nl_msg *msg, void *arg)
1391 {
1392         struct nl80211_array_buf *arr = arg;
1393         struct iwinfo_assoclist_entry *e = arr->buf;
1394         struct nlattr **attr = nl80211_parse(msg);
1395         struct nlattr *sinfo[NL80211_STA_INFO_MAX + 1];
1396         struct nlattr *rinfo[NL80211_RATE_INFO_MAX + 1];
1397
1398         static struct nla_policy stats_policy[NL80211_STA_INFO_MAX + 1] = {
1399                 [NL80211_STA_INFO_INACTIVE_TIME] = { .type = NLA_U32    },
1400                 [NL80211_STA_INFO_RX_PACKETS]    = { .type = NLA_U32    },
1401                 [NL80211_STA_INFO_TX_PACKETS]    = { .type = NLA_U32    },
1402                 [NL80211_STA_INFO_RX_BITRATE]    = { .type = NLA_NESTED },
1403                 [NL80211_STA_INFO_TX_BITRATE]    = { .type = NLA_NESTED },
1404                 [NL80211_STA_INFO_SIGNAL]        = { .type = NLA_U8     },
1405         };
1406
1407         static struct nla_policy rate_policy[NL80211_RATE_INFO_MAX + 1] = {
1408                 [NL80211_RATE_INFO_BITRATE]      = { .type = NLA_U16    },
1409                 [NL80211_RATE_INFO_MCS]          = { .type = NLA_U8     },
1410                 [NL80211_RATE_INFO_40_MHZ_WIDTH] = { .type = NLA_FLAG   },
1411                 [NL80211_RATE_INFO_SHORT_GI]     = { .type = NLA_FLAG   },
1412         };
1413
1414         /* advance to end of array */
1415         e += arr->count;
1416         memset(e, 0, sizeof(*e));
1417
1418         if (attr[NL80211_ATTR_MAC])
1419                 memcpy(e->mac, nla_data(attr[NL80211_ATTR_MAC]), 6);
1420
1421         if (attr[NL80211_ATTR_STA_INFO] &&
1422             !nla_parse_nested(sinfo, NL80211_STA_INFO_MAX,
1423                               attr[NL80211_ATTR_STA_INFO], stats_policy))
1424         {
1425                 if (sinfo[NL80211_STA_INFO_SIGNAL])
1426                         e->signal = nla_get_u8(sinfo[NL80211_STA_INFO_SIGNAL]);
1427
1428                 if (sinfo[NL80211_STA_INFO_INACTIVE_TIME])
1429                         e->inactive = nla_get_u32(sinfo[NL80211_STA_INFO_INACTIVE_TIME]);
1430
1431                 if (sinfo[NL80211_STA_INFO_RX_PACKETS])
1432                         e->rx_packets = nla_get_u32(sinfo[NL80211_STA_INFO_RX_PACKETS]);
1433
1434                 if (sinfo[NL80211_STA_INFO_TX_PACKETS])
1435                         e->tx_packets = nla_get_u32(sinfo[NL80211_STA_INFO_TX_PACKETS]);
1436
1437                 if (sinfo[NL80211_STA_INFO_RX_BITRATE] &&
1438                     !nla_parse_nested(rinfo, NL80211_RATE_INFO_MAX,
1439                                       sinfo[NL80211_STA_INFO_RX_BITRATE], rate_policy))
1440                 {
1441                         if (rinfo[NL80211_RATE_INFO_BITRATE])
1442                                 e->rx_rate.rate =
1443                                         nla_get_u16(rinfo[NL80211_RATE_INFO_BITRATE]) * 100;
1444
1445                         if (rinfo[NL80211_RATE_INFO_MCS])
1446                                 e->rx_rate.mcs = nla_get_u8(rinfo[NL80211_RATE_INFO_MCS]);
1447
1448                         if (rinfo[NL80211_RATE_INFO_40_MHZ_WIDTH])
1449                                 e->rx_rate.is_40mhz = 1;
1450
1451                         if (rinfo[NL80211_RATE_INFO_SHORT_GI])
1452                                 e->rx_rate.is_short_gi = 1;
1453                 }
1454
1455                 if (sinfo[NL80211_STA_INFO_TX_BITRATE] &&
1456                     !nla_parse_nested(rinfo, NL80211_RATE_INFO_MAX,
1457                                       sinfo[NL80211_STA_INFO_TX_BITRATE], rate_policy))
1458                 {
1459                         if (rinfo[NL80211_RATE_INFO_BITRATE])
1460                                 e->tx_rate.rate =
1461                                         nla_get_u16(rinfo[NL80211_RATE_INFO_BITRATE]) * 100;
1462
1463                         if (rinfo[NL80211_RATE_INFO_MCS])
1464                                 e->tx_rate.mcs = nla_get_u8(rinfo[NL80211_RATE_INFO_MCS]);
1465
1466                         if (rinfo[NL80211_RATE_INFO_40_MHZ_WIDTH])
1467                                 e->tx_rate.is_40mhz = 1;
1468
1469                         if (rinfo[NL80211_RATE_INFO_SHORT_GI])
1470                                 e->tx_rate.is_short_gi = 1;
1471                 }
1472         }
1473
1474         e->noise = 0; /* filled in by caller */
1475         arr->count++;
1476
1477         return NL_SKIP;
1478 }
1479
1480 int nl80211_get_assoclist(const char *ifname, char *buf, int *len)
1481 {
1482         DIR *d;
1483         int i, noise = 0;
1484         struct dirent *de;
1485         struct nl80211_msg_conveyor *req;
1486         struct nl80211_array_buf arr = { .buf = buf, .count = 0 };
1487         struct iwinfo_assoclist_entry *e;
1488
1489         if ((d = opendir("/sys/class/net")) != NULL)
1490         {
1491                 while ((de = readdir(d)) != NULL)
1492                 {
1493                         if (!strncmp(de->d_name, ifname, strlen(ifname)) &&
1494                             (!de->d_name[strlen(ifname)] ||
1495                              !strncmp(&de->d_name[strlen(ifname)], ".sta", 4)))
1496                         {
1497                                 req = nl80211_msg(de->d_name, NL80211_CMD_GET_STATION,
1498                                                   NLM_F_DUMP);
1499
1500                                 if (req)
1501                                 {
1502                                         nl80211_send(req, nl80211_get_assoclist_cb, &arr);
1503                                         nl80211_free(req);
1504                                 }
1505                         }
1506                 }
1507
1508                 closedir(d);
1509
1510                 if (!nl80211_get_noise(ifname, &noise))
1511                         for (i = 0, e = arr.buf; i < arr.count; i++, e++)
1512                                 e->noise = noise;
1513
1514                 *len = (arr.count * sizeof(struct iwinfo_assoclist_entry));
1515                 return 0;
1516         }
1517
1518         return -1;
1519 }
1520
1521 static int nl80211_get_txpwrlist_cb(struct nl_msg *msg, void *arg)
1522 {
1523         int *dbm_max = arg;
1524         int ch_cur, ch_cmp, bands_remain, freqs_remain;
1525
1526         struct nlattr **attr = nl80211_parse(msg);
1527         struct nlattr *bands[NL80211_BAND_ATTR_MAX + 1];
1528         struct nlattr *freqs[NL80211_FREQUENCY_ATTR_MAX + 1];
1529         struct nlattr *band, *freq;
1530
1531         static struct nla_policy freq_policy[NL80211_FREQUENCY_ATTR_MAX + 1] = {
1532                 [NL80211_FREQUENCY_ATTR_FREQ]         = { .type = NLA_U32  },
1533                 [NL80211_FREQUENCY_ATTR_DISABLED]     = { .type = NLA_FLAG },
1534                 [NL80211_FREQUENCY_ATTR_PASSIVE_SCAN] = { .type = NLA_FLAG },
1535                 [NL80211_FREQUENCY_ATTR_NO_IBSS]      = { .type = NLA_FLAG },
1536                 [NL80211_FREQUENCY_ATTR_RADAR]        = { .type = NLA_FLAG },
1537                 [NL80211_FREQUENCY_ATTR_MAX_TX_POWER] = { .type = NLA_U32  },
1538         };
1539
1540         ch_cur = *dbm_max; /* value int* is initialized with channel by caller */
1541         *dbm_max = -1;
1542
1543         nla_for_each_nested(band, attr[NL80211_ATTR_WIPHY_BANDS], bands_remain)
1544         {
1545                 nla_parse(bands, NL80211_BAND_ATTR_MAX, nla_data(band),
1546                           nla_len(band), NULL);
1547
1548                 nla_for_each_nested(freq, bands[NL80211_BAND_ATTR_FREQS], freqs_remain)
1549                 {
1550                         nla_parse(freqs, NL80211_FREQUENCY_ATTR_MAX,
1551                                   nla_data(freq), nla_len(freq), freq_policy);
1552
1553                         ch_cmp = nl80211_freq2channel(nla_get_u32(
1554                                 freqs[NL80211_FREQUENCY_ATTR_FREQ]));
1555
1556                         if ((!ch_cur || (ch_cmp == ch_cur)) &&
1557                             freqs[NL80211_FREQUENCY_ATTR_MAX_TX_POWER])
1558                         {
1559                                 *dbm_max = (int)(0.01 * nla_get_u32(
1560                                         freqs[NL80211_FREQUENCY_ATTR_MAX_TX_POWER]));
1561
1562                                 break;
1563                         }
1564                 }
1565         }
1566
1567         return NL_SKIP;
1568 }
1569
1570 int nl80211_get_txpwrlist(const char *ifname, char *buf, int *len)
1571 {
1572         int ch_cur;
1573         int dbm_max = -1, dbm_cur, dbm_cnt;
1574         struct nl80211_msg_conveyor *req;
1575         struct iwinfo_txpwrlist_entry entry;
1576
1577         if (nl80211_get_channel(ifname, &ch_cur))
1578                 ch_cur = 0;
1579
1580         req = nl80211_msg(ifname, NL80211_CMD_GET_WIPHY, 0);
1581         if (req)
1582         {
1583                 /* initialize the value pointer with channel for callback */
1584                 dbm_max = ch_cur;
1585
1586                 nl80211_send(req, nl80211_get_txpwrlist_cb, &dbm_max);
1587                 nl80211_free(req);
1588         }
1589
1590         if (dbm_max > 0)
1591         {
1592                 for (dbm_cur = 0, dbm_cnt = 0;
1593                      dbm_cur < dbm_max;
1594                      dbm_cur++, dbm_cnt++)
1595                 {
1596                         entry.dbm = dbm_cur;
1597                         entry.mw  = iwinfo_dbm2mw(dbm_cur);
1598
1599                         memcpy(&buf[dbm_cnt * sizeof(entry)], &entry, sizeof(entry));
1600                 }
1601
1602                 entry.dbm = dbm_max;
1603                 entry.mw  = iwinfo_dbm2mw(dbm_max);
1604
1605                 memcpy(&buf[dbm_cnt * sizeof(entry)], &entry, sizeof(entry));
1606                 dbm_cnt++;
1607
1608                 *len = dbm_cnt * sizeof(entry);
1609                 return 0;
1610         }
1611
1612         return -1;
1613 }
1614
1615 static void nl80211_get_scancrypto(const char *spec,
1616         struct iwinfo_crypto_entry *c)
1617 {
1618         if (strstr(spec, "WPA") || strstr(spec, "WEP"))
1619         {
1620                 c->enabled = 1;
1621
1622                 if (strstr(spec, "WPA2-") && strstr(spec, "WPA-"))
1623                         c->wpa_version = 3;
1624
1625                 else if (strstr(spec, "WPA2"))
1626                         c->wpa_version = 2;
1627
1628                 else if (strstr(spec, "WPA"))
1629                         c->wpa_version = 1;
1630
1631                 else if (strstr(spec, "WEP"))
1632                         c->auth_algs = IWINFO_AUTH_OPEN | IWINFO_AUTH_SHARED;
1633
1634
1635                 if (strstr(spec, "PSK"))
1636                         c->auth_suites |= IWINFO_KMGMT_PSK;
1637
1638                 if (strstr(spec, "802.1X") || strstr(spec, "EAP"))
1639                         c->auth_suites |= IWINFO_KMGMT_8021x;
1640
1641                 if (strstr(spec, "WPA-NONE"))
1642                         c->auth_suites |= IWINFO_KMGMT_NONE;
1643
1644
1645                 if (strstr(spec, "TKIP"))
1646                         c->pair_ciphers |= IWINFO_CIPHER_TKIP;
1647
1648                 if (strstr(spec, "CCMP"))
1649                         c->pair_ciphers |= IWINFO_CIPHER_CCMP;
1650
1651                 if (strstr(spec, "WEP-40"))
1652                         c->pair_ciphers |= IWINFO_CIPHER_WEP40;
1653
1654                 if (strstr(spec, "WEP-104"))
1655                         c->pair_ciphers |= IWINFO_CIPHER_WEP104;
1656
1657                 c->group_ciphers = c->pair_ciphers;
1658         }
1659         else
1660         {
1661                 c->enabled = 0;
1662         }
1663 }
1664
1665
1666 struct nl80211_scanlist {
1667         struct iwinfo_scanlist_entry *e;
1668         int len;
1669 };
1670
1671
1672 static void nl80211_get_scanlist_ie(struct nlattr **bss,
1673                                     struct iwinfo_scanlist_entry *e)
1674 {
1675         int ielen = nla_len(bss[NL80211_BSS_INFORMATION_ELEMENTS]);
1676         unsigned char *ie = nla_data(bss[NL80211_BSS_INFORMATION_ELEMENTS]);
1677         static unsigned char ms_oui[3] = { 0x00, 0x50, 0xf2 };
1678
1679         while (ielen >= 2 && ielen >= ie[1])
1680         {
1681                 switch (ie[0])
1682                 {
1683                 case 0: /* SSID */
1684                         memcpy(e->ssid, ie + 2, min(ie[1], IWINFO_ESSID_MAX_SIZE));
1685                         break;
1686
1687                 case 48: /* RSN */
1688                         iwinfo_parse_rsn(&e->crypto, ie + 2, ie[1],
1689                                          IWINFO_CIPHER_CCMP, IWINFO_KMGMT_8021x);
1690                         break;
1691
1692                 case 221: /* Vendor */
1693                         if (ie[1] >= 4 && !memcmp(ie + 2, ms_oui, 3) && ie[5] == 1)
1694                                 iwinfo_parse_rsn(&e->crypto, ie + 6, ie[1] - 4,
1695                                                  IWINFO_CIPHER_TKIP, IWINFO_KMGMT_PSK);
1696                         break;
1697                 }
1698
1699                 ielen -= ie[1] + 2;
1700                 ie += ie[1] + 2;
1701         }
1702 }
1703
1704 static int nl80211_get_scanlist_cb(struct nl_msg *msg, void *arg)
1705 {
1706         int8_t rssi;
1707         uint16_t caps;
1708
1709         struct nl80211_scanlist *sl = arg;
1710         struct nlattr **tb = nl80211_parse(msg);
1711         struct nlattr *bss[NL80211_BSS_MAX + 1];
1712
1713         static struct nla_policy bss_policy[NL80211_BSS_MAX + 1] = {
1714                 [NL80211_BSS_TSF]                  = { .type = NLA_U64 },
1715                 [NL80211_BSS_FREQUENCY]            = { .type = NLA_U32 },
1716                 [NL80211_BSS_BSSID]                = {                 },
1717                 [NL80211_BSS_BEACON_INTERVAL]      = { .type = NLA_U16 },
1718                 [NL80211_BSS_CAPABILITY]           = { .type = NLA_U16 },
1719                 [NL80211_BSS_INFORMATION_ELEMENTS] = {                 },
1720                 [NL80211_BSS_SIGNAL_MBM]           = { .type = NLA_U32 },
1721                 [NL80211_BSS_SIGNAL_UNSPEC]        = { .type = NLA_U8  },
1722                 [NL80211_BSS_STATUS]               = { .type = NLA_U32 },
1723                 [NL80211_BSS_SEEN_MS_AGO]          = { .type = NLA_U32 },
1724                 [NL80211_BSS_BEACON_IES]           = {                 },
1725         };
1726
1727         if (!tb[NL80211_ATTR_BSS] ||
1728                 nla_parse_nested(bss, NL80211_BSS_MAX, tb[NL80211_ATTR_BSS],
1729                                  bss_policy) ||
1730                 !bss[NL80211_BSS_BSSID])
1731         {
1732                 return NL_SKIP;
1733         }
1734
1735         if (bss[NL80211_BSS_CAPABILITY])
1736                 caps = nla_get_u16(bss[NL80211_BSS_CAPABILITY]);
1737         else
1738                 caps = 0;
1739
1740         memset(sl->e, 0, sizeof(*sl->e));
1741         memcpy(sl->e->mac, nla_data(bss[NL80211_BSS_BSSID]), 6);
1742
1743         if (caps & (1<<1))
1744                 sl->e->mode = IWINFO_OPMODE_ADHOC;
1745         else
1746                 sl->e->mode = IWINFO_OPMODE_MASTER;
1747
1748         if (caps & (1<<4))
1749                 sl->e->crypto.enabled = 1;
1750
1751         if (bss[NL80211_BSS_FREQUENCY])
1752                 sl->e->channel = nl80211_freq2channel(nla_get_u32(
1753                         bss[NL80211_BSS_FREQUENCY]));
1754
1755         if (bss[NL80211_BSS_INFORMATION_ELEMENTS])
1756                 nl80211_get_scanlist_ie(bss, sl->e);
1757
1758         if (bss[NL80211_BSS_SIGNAL_MBM])
1759         {
1760                 sl->e->signal =
1761                         (uint8_t)((int32_t)nla_get_u32(bss[NL80211_BSS_SIGNAL_MBM]) / 100);
1762
1763                 rssi = sl->e->signal - 0x100;
1764
1765                 if (rssi < -110)
1766                         rssi = -110;
1767                 else if (rssi > -40)
1768                         rssi = -40;
1769
1770                 sl->e->quality = (rssi + 110);
1771                 sl->e->quality_max = 70;
1772         }
1773
1774         if (sl->e->crypto.enabled && !sl->e->crypto.wpa_version)
1775         {
1776                 sl->e->crypto.auth_algs    = IWINFO_AUTH_OPEN | IWINFO_AUTH_SHARED;
1777                 sl->e->crypto.pair_ciphers = IWINFO_CIPHER_WEP40 | IWINFO_CIPHER_WEP104;
1778         }
1779
1780         sl->e++;
1781         sl->len++;
1782
1783         return NL_SKIP;
1784 }
1785
1786 static int nl80211_get_scanlist_nl(const char *ifname, char *buf, int *len)
1787 {
1788         struct nl80211_msg_conveyor *req;
1789         struct nl80211_scanlist sl = { .e = (struct iwinfo_scanlist_entry *)buf };
1790
1791         req = nl80211_msg(ifname, NL80211_CMD_TRIGGER_SCAN, 0);
1792         if (req)
1793         {
1794                 nl80211_send(req, NULL, NULL);
1795                 nl80211_free(req);
1796         }
1797
1798         nl80211_wait("nl80211", "scan", NL80211_CMD_NEW_SCAN_RESULTS);
1799
1800         req = nl80211_msg(ifname, NL80211_CMD_GET_SCAN, NLM_F_DUMP);
1801         if (req)
1802         {
1803                 nl80211_send(req, nl80211_get_scanlist_cb, &sl);
1804                 nl80211_free(req);
1805         }
1806
1807         *len = sl.len * sizeof(struct iwinfo_scanlist_entry);
1808         return *len ? 0 : -1;
1809 }
1810
1811 int nl80211_get_scanlist(const char *ifname, char *buf, int *len)
1812 {
1813         int freq, rssi, qmax, count;
1814         char *res;
1815         char ssid[128] = { 0 };
1816         char bssid[18] = { 0 };
1817         char cipher[256] = { 0 };
1818
1819         /* Got a radioX pseudo interface, find some interface on it or create one */
1820         if (!strncmp(ifname, "radio", 5))
1821         {
1822                 /* Reuse existing interface */
1823                 if ((res = nl80211_phy2ifname(ifname)) != NULL)
1824                 {
1825                         return nl80211_get_scanlist(res, buf, len);
1826                 }
1827
1828                 /* Need to spawn a temporary iface for scanning */
1829                 else if ((res = nl80211_ifadd(ifname)) != NULL)
1830                 {
1831                         count = nl80211_get_scanlist(res, buf, len);
1832                         nl80211_ifdel(res);
1833                         return count;
1834                 }
1835         }
1836
1837         struct iwinfo_scanlist_entry *e = (struct iwinfo_scanlist_entry *)buf;
1838
1839         /* WPA supplicant */
1840         if ((res = nl80211_wpactl_info(ifname, "SCAN", "CTRL-EVENT-SCAN-RESULTS")))
1841         {
1842                 if ((res = nl80211_wpactl_info(ifname, "SCAN_RESULTS", NULL)))
1843                 {
1844                         nl80211_get_quality_max(ifname, &qmax);
1845
1846                         /* skip header line */
1847                         while (*res++ != '\n');
1848
1849                         count = 0;
1850
1851                         while (sscanf(res, "%17s %d %d %255s%*[ \t]%127[^\n]\n",
1852                                       bssid, &freq, &rssi, cipher, ssid) > 0)
1853                         {
1854                                 /* BSSID */
1855                                 e->mac[0] = strtol(&bssid[0],  NULL, 16);
1856                                 e->mac[1] = strtol(&bssid[3],  NULL, 16);
1857                                 e->mac[2] = strtol(&bssid[6],  NULL, 16);
1858                                 e->mac[3] = strtol(&bssid[9],  NULL, 16);
1859                                 e->mac[4] = strtol(&bssid[12], NULL, 16);
1860                                 e->mac[5] = strtol(&bssid[15], NULL, 16);
1861
1862                                 /* SSID */
1863                                 memcpy(e->ssid, ssid, min(strlen(ssid), sizeof(e->ssid) - 1));
1864
1865                                 /* Mode (assume master) */
1866                                 e->mode = IWINFO_OPMODE_MASTER;
1867
1868                                 /* Channel */
1869                                 e->channel = nl80211_freq2channel(freq);
1870
1871                                 /* Signal */
1872                                 e->signal = rssi;
1873
1874                                 /* Quality */
1875                                 if (rssi < 0)
1876                                 {
1877                                         /* The cfg80211 wext compat layer assumes a signal range
1878                                          * of -110 dBm to -40 dBm, the quality value is derived
1879                                          * by adding 110 to the signal level */
1880                                         if (rssi < -110)
1881                                                 rssi = -110;
1882                                         else if (rssi > -40)
1883                                                 rssi = -40;
1884
1885                                         e->quality = (rssi + 110);
1886                                 }
1887                                 else
1888                                 {
1889                                         e->quality = rssi;
1890                                 }
1891
1892                                 /* Max. Quality */
1893                                 e->quality_max = qmax;
1894
1895                                 /* Crypto */
1896                                 nl80211_get_scancrypto(cipher, &e->crypto);
1897
1898                                 /* advance to next line */
1899                                 while (*res && *res++ != '\n');
1900
1901                                 count++;
1902                                 e++;
1903
1904                                 memset(ssid, 0, sizeof(ssid));
1905                                 memset(bssid, 0, sizeof(bssid));
1906                                 memset(cipher, 0, sizeof(cipher));
1907                         }
1908
1909                         *len = count * sizeof(struct iwinfo_scanlist_entry);
1910                         return 0;
1911                 }
1912         }
1913
1914         /* AP scan */
1915         else
1916         {
1917                 /* Got a temp interface, don't create yet another one */
1918                 if (!strncmp(ifname, "tmp.", 4))
1919                 {
1920                         if (!iwinfo_ifup(ifname))
1921                                 return -1;
1922
1923                         nl80211_get_scanlist_nl(ifname, buf, len);
1924                         iwinfo_ifdown(ifname);
1925                         return 0;
1926                 }
1927
1928                 /* Spawn a new scan interface */
1929                 else
1930                 {
1931                         if (!(res = nl80211_ifadd(ifname)))
1932                                 goto out;
1933
1934                         if (!iwinfo_ifmac(res))
1935                                 goto out;
1936
1937                         /* if we can take the new interface up, the driver supports an
1938                          * additional interface and there's no need to tear down the ap */
1939                         if (iwinfo_ifup(res))
1940                         {
1941                                 nl80211_get_scanlist_nl(res, buf, len);
1942                                 iwinfo_ifdown(res);
1943                         }
1944
1945                         /* driver cannot create secondary interface, take down ap
1946                          * during scan */
1947                         else if (iwinfo_ifdown(ifname) && iwinfo_ifup(res))
1948                         {
1949                                 nl80211_get_scanlist_nl(res, buf, len);
1950                                 iwinfo_ifdown(res);
1951                                 iwinfo_ifup(ifname);
1952                                 nl80211_hostapd_hup(ifname);
1953                         }
1954
1955                 out:
1956                         nl80211_ifdel(res);
1957                         return 0;
1958                 }
1959         }
1960
1961         return -1;
1962 }
1963
1964 static int nl80211_get_freqlist_cb(struct nl_msg *msg, void *arg)
1965 {
1966         int bands_remain, freqs_remain;
1967
1968         struct nl80211_array_buf *arr = arg;
1969         struct iwinfo_freqlist_entry *e = arr->buf;
1970
1971         struct nlattr **attr = nl80211_parse(msg);
1972         struct nlattr *bands[NL80211_BAND_ATTR_MAX + 1];
1973         struct nlattr *freqs[NL80211_FREQUENCY_ATTR_MAX + 1];
1974         struct nlattr *band, *freq;
1975
1976         static struct nla_policy freq_policy[NL80211_FREQUENCY_ATTR_MAX + 1] = {
1977                 [NL80211_FREQUENCY_ATTR_FREQ]         = { .type = NLA_U32  },
1978                 [NL80211_FREQUENCY_ATTR_DISABLED]     = { .type = NLA_FLAG },
1979                 [NL80211_FREQUENCY_ATTR_PASSIVE_SCAN] = { .type = NLA_FLAG },
1980                 [NL80211_FREQUENCY_ATTR_NO_IBSS]      = { .type = NLA_FLAG },
1981                 [NL80211_FREQUENCY_ATTR_RADAR]        = { .type = NLA_FLAG },
1982                 [NL80211_FREQUENCY_ATTR_MAX_TX_POWER] = { .type = NLA_U32  },
1983         };
1984
1985         nla_for_each_nested(band, attr[NL80211_ATTR_WIPHY_BANDS], bands_remain)
1986         {
1987                 nla_parse(bands, NL80211_BAND_ATTR_MAX,
1988                           nla_data(band), nla_len(band), NULL);
1989
1990                 nla_for_each_nested(freq, bands[NL80211_BAND_ATTR_FREQS], freqs_remain)
1991                 {
1992                         nla_parse(freqs, NL80211_FREQUENCY_ATTR_MAX,
1993                                   nla_data(freq), nla_len(freq), NULL);
1994
1995                         if (!freqs[NL80211_FREQUENCY_ATTR_FREQ] ||
1996                             freqs[NL80211_FREQUENCY_ATTR_DISABLED])
1997                                 continue;
1998
1999                         e->mhz = nla_get_u32(freqs[NL80211_FREQUENCY_ATTR_FREQ]);
2000                         e->channel = nl80211_freq2channel(e->mhz);
2001
2002                         e->restricted = (
2003                                 freqs[NL80211_FREQUENCY_ATTR_PASSIVE_SCAN] ||
2004                                 freqs[NL80211_FREQUENCY_ATTR_NO_IBSS]      ||
2005                                 freqs[NL80211_FREQUENCY_ATTR_RADAR]
2006                         ) ? 1 : 0;
2007
2008                         e++;
2009                         arr->count++;
2010                 }
2011         }
2012
2013         return NL_SKIP;
2014 }
2015
2016 int nl80211_get_freqlist(const char *ifname, char *buf, int *len)
2017 {
2018         struct nl80211_msg_conveyor *req;
2019         struct nl80211_array_buf arr = { .buf = buf, .count = 0 };
2020
2021         req = nl80211_msg(ifname, NL80211_CMD_GET_WIPHY, 0);
2022         if (req)
2023         {
2024                 nl80211_send(req, nl80211_get_freqlist_cb, &arr);
2025                 nl80211_free(req);
2026         }
2027
2028         if (arr.count > 0)
2029         {
2030                 *len = arr.count * sizeof(struct iwinfo_freqlist_entry);
2031                 return 0;
2032         }
2033
2034         return -1;
2035 }
2036
2037 static int nl80211_get_country_cb(struct nl_msg *msg, void *arg)
2038 {
2039         char *buf = arg;
2040         struct nlattr **attr = nl80211_parse(msg);
2041
2042         if (attr[NL80211_ATTR_REG_ALPHA2])
2043                 memcpy(buf, nla_data(attr[NL80211_ATTR_REG_ALPHA2]), 2);
2044         else
2045                 buf[0] = 0;
2046
2047         return NL_SKIP;
2048 }
2049
2050 int nl80211_get_country(const char *ifname, char *buf)
2051 {
2052         int rv = -1;
2053         struct nl80211_msg_conveyor *req;
2054
2055         req = nl80211_msg(ifname, NL80211_CMD_GET_REG, 0);
2056         if (req)
2057         {
2058                 nl80211_send(req, nl80211_get_country_cb, buf);
2059                 nl80211_free(req);
2060
2061                 if (buf[0])
2062                         rv = 0;
2063         }
2064
2065         return rv;
2066 }
2067
2068 int nl80211_get_countrylist(const char *ifname, char *buf, int *len)
2069 {
2070         int i, count;
2071         struct iwinfo_country_entry *e = (struct iwinfo_country_entry *)buf;
2072         const struct iwinfo_iso3166_label *l;
2073
2074         for (l = IWINFO_ISO3166_NAMES, count = 0; l->iso3166; l++, e++, count++)
2075         {
2076                 e->iso3166 = l->iso3166;
2077                 e->ccode[0] = (l->iso3166 / 256);
2078                 e->ccode[1] = (l->iso3166 % 256);
2079         }
2080
2081         *len = (count * sizeof(struct iwinfo_country_entry));
2082         return 0;
2083 }
2084
2085 static int nl80211_get_hwmodelist_cb(struct nl_msg *msg, void *arg)
2086 {
2087         int *modes = arg;
2088         int bands_remain, freqs_remain;
2089         uint16_t caps = 0;
2090         struct nlattr **attr = nl80211_parse(msg);
2091         struct nlattr *bands[NL80211_BAND_ATTR_MAX + 1];
2092         struct nlattr *freqs[NL80211_FREQUENCY_ATTR_MAX + 1];
2093         struct nlattr *band, *freq;
2094
2095         *modes = 0;
2096
2097         if (attr[NL80211_ATTR_WIPHY_BANDS])
2098         {
2099                 nla_for_each_nested(band, attr[NL80211_ATTR_WIPHY_BANDS], bands_remain)
2100                 {
2101                         nla_parse(bands, NL80211_BAND_ATTR_MAX,
2102                                   nla_data(band), nla_len(band), NULL);
2103
2104                         if (bands[NL80211_BAND_ATTR_HT_CAPA])
2105                                 caps = nla_get_u16(bands[NL80211_BAND_ATTR_HT_CAPA]);
2106
2107                         /* Treat any nonzero capability as 11n */
2108                         if (caps > 0)
2109                                 *modes |= IWINFO_80211_N;
2110
2111                         nla_for_each_nested(freq, bands[NL80211_BAND_ATTR_FREQS],
2112                                             freqs_remain)
2113                         {
2114                                 nla_parse(freqs, NL80211_FREQUENCY_ATTR_MAX,
2115                                           nla_data(freq), nla_len(freq), NULL);
2116
2117                                 if (!freqs[NL80211_FREQUENCY_ATTR_FREQ])
2118                                         continue;
2119
2120                                 if (nla_get_u32(freqs[NL80211_FREQUENCY_ATTR_FREQ]) < 2485)
2121                                 {
2122                                         *modes |= IWINFO_80211_B;
2123                                         *modes |= IWINFO_80211_G;
2124                                 }
2125                                 else
2126                                 {
2127                                         *modes |= IWINFO_80211_A;
2128                                 }
2129                         }
2130                 }
2131         }
2132
2133         return NL_SKIP;
2134 }
2135
2136 int nl80211_get_hwmodelist(const char *ifname, int *buf)
2137 {
2138         struct nl80211_msg_conveyor *req;
2139
2140         req = nl80211_msg(ifname, NL80211_CMD_GET_WIPHY, 0);
2141         if (req)
2142         {
2143                 nl80211_send(req, nl80211_get_hwmodelist_cb, buf);
2144                 nl80211_free(req);
2145         }
2146
2147         return *buf ? 0 : -1;
2148 }
2149
2150 int nl80211_get_mbssid_support(const char *ifname, int *buf)
2151 {
2152         /* Test whether we can create another interface */
2153         char *nif = nl80211_ifadd(ifname);
2154
2155         if (nif)
2156         {
2157                 *buf = (iwinfo_ifmac(nif) && iwinfo_ifup(nif));
2158
2159                 iwinfo_ifdown(nif);
2160                 nl80211_ifdel(nif);
2161
2162                 return 0;
2163         }
2164
2165         return -1;
2166 }
2167
2168 int nl80211_get_hardware_id(const char *ifname, char *buf)
2169 {
2170         int rv;
2171         char *res;
2172
2173         /* Got a radioX pseudo interface, find some interface on it or create one */
2174         if (!strncmp(ifname, "radio", 5))
2175         {
2176                 /* Reuse existing interface */
2177                 if ((res = nl80211_phy2ifname(ifname)) != NULL)
2178                 {
2179                         rv = wext_get_hardware_id(res, buf);
2180                 }
2181
2182                 /* Need to spawn a temporary iface for finding IDs */
2183                 else if ((res = nl80211_ifadd(ifname)) != NULL)
2184                 {
2185                         rv = wext_get_hardware_id(res, buf);
2186                         nl80211_ifdel(res);
2187                 }
2188         }
2189         else
2190         {
2191                 rv = wext_get_hardware_id(ifname, buf);
2192         }
2193
2194         /* Failed to obtain hardware IDs, search board config */
2195         if (rv)
2196         {
2197                 rv = iwinfo_hardware_id_from_mtd((struct iwinfo_hardware_id *)buf);
2198         }
2199
2200         return rv;
2201 }
2202
2203 static const struct iwinfo_hardware_entry *
2204 nl80211_get_hardware_entry(const char *ifname)
2205 {
2206         struct iwinfo_hardware_id id;
2207
2208         if (nl80211_get_hardware_id(ifname, (char *)&id))
2209                 return NULL;
2210
2211         return iwinfo_hardware(&id);
2212 }
2213
2214 int nl80211_get_hardware_name(const char *ifname, char *buf)
2215 {
2216         const struct iwinfo_hardware_entry *hw;
2217
2218         if (!(hw = nl80211_get_hardware_entry(ifname)))
2219                 sprintf(buf, "Generic MAC80211");
2220         else
2221                 sprintf(buf, "%s %s", hw->vendor_name, hw->device_name);
2222
2223         return 0;
2224 }
2225
2226 int nl80211_get_txpower_offset(const char *ifname, int *buf)
2227 {
2228         const struct iwinfo_hardware_entry *hw;
2229
2230         if (!(hw = nl80211_get_hardware_entry(ifname)))
2231                 return -1;
2232
2233         *buf = hw->txpower_offset;
2234         return 0;
2235 }
2236
2237 int nl80211_get_frequency_offset(const char *ifname, int *buf)
2238 {
2239         const struct iwinfo_hardware_entry *hw;
2240
2241         if (!(hw = nl80211_get_hardware_entry(ifname)))
2242                 return -1;
2243
2244         *buf = hw->frequency_offset;
2245         return 0;
2246 }