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