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         struct nlattr *rinfo[NL80211_RATE_INFO_MAX + 1];
1056
1057         static struct nla_policy stats_policy[NL80211_STA_INFO_MAX + 1] = {
1058                 [NL80211_STA_INFO_INACTIVE_TIME] = { .type = NLA_U32    },
1059                 [NL80211_STA_INFO_RX_PACKETS]    = { .type = NLA_U32    },
1060                 [NL80211_STA_INFO_TX_PACKETS]    = { .type = NLA_U32    },
1061                 [NL80211_STA_INFO_RX_BITRATE]    = { .type = NLA_NESTED },
1062                 [NL80211_STA_INFO_TX_BITRATE]    = { .type = NLA_NESTED },
1063                 [NL80211_STA_INFO_SIGNAL]        = { .type = NLA_U8     },
1064         };
1065
1066         static struct nla_policy rate_policy[NL80211_RATE_INFO_MAX + 1] = {
1067                 [NL80211_RATE_INFO_BITRATE]      = { .type = NLA_U16    },
1068                 [NL80211_RATE_INFO_MCS]          = { .type = NLA_U8     },
1069                 [NL80211_RATE_INFO_40_MHZ_WIDTH] = { .type = NLA_FLAG   },
1070                 [NL80211_RATE_INFO_SHORT_GI]     = { .type = NLA_FLAG   },
1071         };
1072
1073         /* advance to end of array */
1074         e += arr->count;
1075         memset(e, 0, sizeof(*e));
1076
1077         if (attr[NL80211_ATTR_MAC])
1078                 memcpy(e->mac, nla_data(attr[NL80211_ATTR_MAC]), 6);
1079
1080         if (attr[NL80211_ATTR_STA_INFO] &&
1081                 !nla_parse_nested(sinfo, NL80211_STA_INFO_MAX,
1082                         attr[NL80211_ATTR_STA_INFO], stats_policy))
1083         {
1084                 if (sinfo[NL80211_STA_INFO_SIGNAL])
1085                         e->signal = nla_get_u8(sinfo[NL80211_STA_INFO_SIGNAL]);
1086
1087                 if (sinfo[NL80211_STA_INFO_INACTIVE_TIME])
1088                         e->inactive = nla_get_u32(sinfo[NL80211_STA_INFO_INACTIVE_TIME]);
1089
1090                 if (sinfo[NL80211_STA_INFO_RX_PACKETS])
1091                         e->rx_packets = nla_get_u32(sinfo[NL80211_STA_INFO_RX_PACKETS]);
1092
1093                 if (sinfo[NL80211_STA_INFO_TX_PACKETS])
1094                         e->tx_packets = nla_get_u32(sinfo[NL80211_STA_INFO_TX_PACKETS]);
1095
1096                 if (sinfo[NL80211_STA_INFO_RX_BITRATE] &&
1097                         !nla_parse_nested(rinfo, NL80211_RATE_INFO_MAX,
1098                                 sinfo[NL80211_STA_INFO_RX_BITRATE], rate_policy))
1099                 {
1100                         if (rinfo[NL80211_RATE_INFO_BITRATE])
1101                                 e->rx_rate.rate =
1102                                         nla_get_u16(rinfo[NL80211_RATE_INFO_BITRATE]) * 100;
1103
1104                         if (rinfo[NL80211_RATE_INFO_MCS])
1105                                 e->rx_rate.mcs = nla_get_u8(rinfo[NL80211_RATE_INFO_MCS]);
1106
1107                         if (rinfo[NL80211_RATE_INFO_40_MHZ_WIDTH])
1108                                 e->rx_rate.is_40mhz = 1;
1109
1110                         if (rinfo[NL80211_RATE_INFO_SHORT_GI])
1111                                 e->rx_rate.is_short_gi = 1;
1112                 }
1113
1114                 if (sinfo[NL80211_STA_INFO_TX_BITRATE] &&
1115                         !nla_parse_nested(rinfo, NL80211_RATE_INFO_MAX,
1116                                 sinfo[NL80211_STA_INFO_TX_BITRATE], rate_policy))
1117                 {
1118                         if (rinfo[NL80211_RATE_INFO_BITRATE])
1119                                 e->tx_rate.rate =
1120                                         nla_get_u16(rinfo[NL80211_RATE_INFO_BITRATE]) * 100;
1121
1122                         if (rinfo[NL80211_RATE_INFO_MCS])
1123                                 e->tx_rate.mcs = nla_get_u8(rinfo[NL80211_RATE_INFO_MCS]);
1124
1125                         if (rinfo[NL80211_RATE_INFO_40_MHZ_WIDTH])
1126                                 e->tx_rate.is_40mhz = 1;
1127
1128                         if (rinfo[NL80211_RATE_INFO_SHORT_GI])
1129                                 e->tx_rate.is_short_gi = 1;
1130                 }
1131         }
1132
1133         e->noise = 0; /* filled in by caller */
1134         arr->count++;
1135
1136         return NL_SKIP;
1137 }
1138
1139 int nl80211_get_assoclist(const char *ifname, char *buf, int *len)
1140 {
1141         DIR *d;
1142         int i, noise = 0;
1143         struct dirent *de;
1144         struct nl80211_msg_conveyor *req;
1145         struct nl80211_array_buf arr = { .buf = buf, .count = 0 };
1146         struct iwinfo_assoclist_entry *e;
1147
1148         if ((d = opendir("/sys/class/net")) != NULL)
1149         {
1150                 while ((de = readdir(d)) != NULL)
1151                 {
1152                         if (!strncmp(de->d_name, ifname, strlen(ifname)) &&
1153                                 (!de->d_name[strlen(ifname)] ||
1154                                  !strncmp(&de->d_name[strlen(ifname)], ".sta", 4)))
1155                         {
1156                                 req = nl80211_msg(de->d_name, NL80211_CMD_GET_STATION,
1157                                                                   NLM_F_DUMP);
1158
1159                                 if (req)
1160                                 {
1161                                         nl80211_send(req, nl80211_get_assoclist_cb, &arr);
1162                                         nl80211_free(req);
1163                                 }
1164                         }
1165                 }
1166
1167                 closedir(d);
1168
1169                 if (!nl80211_get_noise(ifname, &noise))
1170                         for (i = 0, e = arr.buf; i < arr.count; i++, e++)
1171                                 e->noise = noise;
1172
1173                 *len = (arr.count * sizeof(struct iwinfo_assoclist_entry));
1174                 return 0;
1175         }
1176
1177         return -1;
1178 }
1179
1180 static int nl80211_get_txpwrlist_cb(struct nl_msg *msg, void *arg)
1181 {
1182         int *dbm_max = arg;
1183         int ch_cur, ch_cmp, bands_remain, freqs_remain;
1184
1185         struct nlattr **attr = nl80211_parse(msg);
1186         struct nlattr *bands[NL80211_BAND_ATTR_MAX + 1];
1187         struct nlattr *freqs[NL80211_FREQUENCY_ATTR_MAX + 1];
1188         struct nlattr *band, *freq;
1189
1190         static struct nla_policy freq_policy[NL80211_FREQUENCY_ATTR_MAX + 1] = {
1191                 [NL80211_FREQUENCY_ATTR_FREQ]         = { .type = NLA_U32  },
1192                 [NL80211_FREQUENCY_ATTR_DISABLED]     = { .type = NLA_FLAG },
1193                 [NL80211_FREQUENCY_ATTR_PASSIVE_SCAN] = { .type = NLA_FLAG },
1194                 [NL80211_FREQUENCY_ATTR_NO_IBSS]      = { .type = NLA_FLAG },
1195                 [NL80211_FREQUENCY_ATTR_RADAR]        = { .type = NLA_FLAG },
1196                 [NL80211_FREQUENCY_ATTR_MAX_TX_POWER] = { .type = NLA_U32  },
1197         };
1198
1199         ch_cur = *dbm_max; /* value int* is initialized with channel by caller */
1200         *dbm_max = -1;
1201
1202         nla_for_each_nested(band, attr[NL80211_ATTR_WIPHY_BANDS], bands_remain)
1203         {
1204                 nla_parse(bands, NL80211_BAND_ATTR_MAX, nla_data(band),
1205                           nla_len(band), NULL);
1206
1207                 nla_for_each_nested(freq,
1208                         bands[NL80211_BAND_ATTR_FREQS], freqs_remain)
1209                 {
1210                         nla_parse(freqs, NL80211_FREQUENCY_ATTR_MAX,
1211                                 nla_data(freq), nla_len(freq), freq_policy);
1212
1213                         ch_cmp = nl80211_freq2channel(
1214                                 nla_get_u32(freqs[NL80211_FREQUENCY_ATTR_FREQ]));
1215
1216                         if( (!ch_cur || (ch_cmp == ch_cur)) &&
1217                                 freqs[NL80211_FREQUENCY_ATTR_MAX_TX_POWER] )
1218                         {
1219                                 *dbm_max = (int)(0.01 * nla_get_u32(
1220                                         freqs[NL80211_FREQUENCY_ATTR_MAX_TX_POWER]));
1221
1222                                 break;
1223                         }
1224                 }
1225         }
1226
1227         return NL_SKIP;
1228 }
1229
1230 int nl80211_get_txpwrlist(const char *ifname, char *buf, int *len)
1231 {
1232         int ch_cur;
1233         int dbm_max = -1, dbm_cur, dbm_cnt;
1234         struct nl80211_msg_conveyor *req;
1235         struct iwinfo_txpwrlist_entry entry;
1236
1237         if (nl80211_get_channel(ifname, &ch_cur))
1238                 ch_cur = 0;
1239
1240         req = nl80211_msg(ifname, NL80211_CMD_GET_WIPHY, 0);
1241         if (req)
1242         {
1243                 /* initialize the value pointer with channel for callback */
1244                 dbm_max = ch_cur;
1245
1246                 nl80211_send(req, nl80211_get_txpwrlist_cb, &dbm_max);
1247                 nl80211_free(req);
1248         }
1249
1250         if (dbm_max > -1)
1251         {
1252                 for (dbm_cur = 0, dbm_cnt = 0;
1253                      dbm_cur < dbm_max;
1254                      dbm_cur++, dbm_cnt++)
1255                 {
1256                         entry.dbm = dbm_cur;
1257                         entry.mw  = iwinfo_dbm2mw(dbm_cur);
1258
1259                         memcpy(&buf[dbm_cnt * sizeof(entry)], &entry, sizeof(entry));
1260                 }
1261
1262                 entry.dbm = dbm_max;
1263                 entry.mw  = iwinfo_dbm2mw(dbm_max);
1264
1265                 memcpy(&buf[dbm_cnt * sizeof(entry)], &entry, sizeof(entry));
1266                 dbm_cnt++;
1267
1268                 *len = dbm_cnt * sizeof(entry);
1269                 return 0;
1270         }
1271
1272         return -1;
1273 }
1274
1275 static void nl80211_get_scancrypto(const char *spec,
1276         struct iwinfo_crypto_entry *c)
1277 {
1278         if (strstr(spec, "WPA") || strstr(spec, "WEP"))
1279         {
1280                 c->enabled = 1;
1281
1282                 if (strstr(spec, "WPA2-") && strstr(spec, "WPA-"))
1283                         c->wpa_version = 3;
1284
1285                 else if (strstr(spec, "WPA2"))
1286                         c->wpa_version = 2;
1287
1288                 else if (strstr(spec, "WPA"))
1289                         c->wpa_version = 1;
1290
1291                 else if (strstr(spec, "WEP"))
1292                         c->auth_algs = IWINFO_AUTH_OPEN | IWINFO_AUTH_SHARED;
1293
1294
1295                 if (strstr(spec, "PSK"))
1296                         c->auth_suites |= IWINFO_KMGMT_PSK;
1297
1298                 if (strstr(spec, "802.1X") || strstr(spec, "EAP"))
1299                         c->auth_suites |= IWINFO_KMGMT_8021x;
1300
1301                 if (strstr(spec, "WPA-NONE"))
1302                         c->auth_suites |= IWINFO_KMGMT_NONE;
1303
1304
1305                 if (strstr(spec, "TKIP"))
1306                         c->pair_ciphers |= IWINFO_CIPHER_TKIP;
1307
1308                 if (strstr(spec, "CCMP"))
1309                         c->pair_ciphers |= IWINFO_CIPHER_CCMP;
1310
1311                 if (strstr(spec, "WEP-40"))
1312                         c->pair_ciphers |= IWINFO_CIPHER_WEP40;
1313
1314                 if (strstr(spec, "WEP-104"))
1315                         c->pair_ciphers |= IWINFO_CIPHER_WEP104;
1316
1317                 c->group_ciphers = c->pair_ciphers;
1318         }
1319         else
1320         {
1321                 c->enabled = 0;
1322         }
1323 }
1324
1325 int nl80211_get_scanlist(const char *ifname, char *buf, int *len)
1326 {
1327         int freq, rssi, qmax, count;
1328         char *res;
1329         char ssid[128] = { 0 };
1330         char bssid[18] = { 0 };
1331         char cipher[256] = { 0 };
1332
1333         /* Got a radioX pseudo interface, find some interface on it or create one */
1334         if (!strncmp(ifname, "radio", 5))
1335         {
1336                 /* Reuse existing interface */
1337                 if ((res = nl80211_phy2ifname(ifname)) != NULL)
1338                 {
1339                         return nl80211_get_scanlist(res, buf, len);
1340                 }
1341
1342                 /* Need to spawn a temporary iface for scanning */
1343                 else if ((res = nl80211_ifadd(ifname)) != NULL)
1344                 {
1345                         count = nl80211_get_scanlist(res, buf, len);
1346                         nl80211_ifdel(res);
1347                         return count;
1348                 }
1349         }
1350
1351         struct iwinfo_scanlist_entry *e = (struct iwinfo_scanlist_entry *)buf;
1352
1353         /* WPA supplicant */
1354         if ((res = nl80211_wpactl_info(ifname, "SCAN", "CTRL-EVENT-SCAN-RESULTS")))
1355         {
1356                 if ((res = nl80211_wpactl_info(ifname, "SCAN_RESULTS", NULL)))
1357                 {
1358                         nl80211_get_quality_max(ifname, &qmax);
1359
1360                         /* skip header line */
1361                         while( *res++ != '\n' );
1362
1363                         count = 0;
1364
1365                         while( sscanf(res, "%17s %d %d %255s%*[ \t]%127[^\n]\n",
1366                                       bssid, &freq, &rssi, cipher, ssid) > 0 )
1367                         {
1368                                 /* BSSID */
1369                                 e->mac[0] = strtol(&bssid[0],  NULL, 16);
1370                                 e->mac[1] = strtol(&bssid[3],  NULL, 16);
1371                                 e->mac[2] = strtol(&bssid[6],  NULL, 16);
1372                                 e->mac[3] = strtol(&bssid[9],  NULL, 16);
1373                                 e->mac[4] = strtol(&bssid[12], NULL, 16);
1374                                 e->mac[5] = strtol(&bssid[15], NULL, 16);
1375
1376                                 /* SSID */
1377                                 memcpy(e->ssid, ssid,
1378                                         min(strlen(ssid), sizeof(e->ssid) - 1));
1379
1380                                 /* Mode (assume master) */
1381                                 sprintf((char *)e->mode, "Master");
1382
1383                                 /* Channel */
1384                                 e->channel = nl80211_freq2channel(freq);
1385
1386                                 /* Signal */
1387                                 e->signal = rssi;
1388
1389                                 /* Quality */
1390                                 if (rssi < 0)
1391                                 {
1392                                         /* The cfg80211 wext compat layer assumes a signal range
1393                                          * of -110 dBm to -40 dBm, the quality value is derived
1394                                          * by adding 110 to the signal level */
1395                                         if (rssi < -110)
1396                                                 rssi = -110;
1397                                         else if (rssi > -40)
1398                                                 rssi = -40;
1399
1400                                         e->quality = (rssi + 110);
1401                                 }
1402                                 else
1403                                 {
1404                                         e->quality = rssi;
1405                                 }
1406
1407                                 /* Max. Quality */
1408                                 e->quality_max = qmax;
1409
1410                                 /* Crypto */
1411                                 nl80211_get_scancrypto(cipher, &e->crypto);
1412
1413                                 /* advance to next line */
1414                                 while( *res && *res++ != '\n' );
1415
1416                                 count++;
1417                                 e++;
1418
1419                                 memset(ssid, 0, sizeof(ssid));
1420                                 memset(bssid, 0, sizeof(bssid));
1421                                 memset(cipher, 0, sizeof(cipher));
1422                         }
1423
1424                         *len = count * sizeof(struct iwinfo_scanlist_entry);
1425                         return 0;
1426                 }
1427         }
1428
1429         /* AP scan */
1430         else
1431         {
1432                 /* Got a temp interface, don't create yet another one */
1433                 if (!strncmp(ifname, "tmp.", 4))
1434                 {
1435                         if (!iwinfo_ifup(ifname))
1436                                 return -1;
1437
1438                         wext_get_scanlist(ifname, buf, len);
1439                         iwinfo_ifdown(ifname);
1440                         return 0;
1441                 }
1442
1443                 /* Spawn a new scan interface */
1444                 else
1445                 {
1446                         if (!(res = nl80211_ifadd(ifname)))
1447                                 goto out;
1448
1449                         if (!iwinfo_ifmac(res))
1450                                 goto out;
1451
1452                         /* if we can take the new interface up, the driver supports an
1453                          * additional interface and there's no need to tear down the ap */
1454                         if (iwinfo_ifup(res))
1455                         {
1456                                 wext_get_scanlist(res, buf, len);
1457                                 iwinfo_ifdown(res);
1458                         }
1459
1460                         /* driver cannot create secondary interface, take down ap
1461                          * during scan */
1462                         else if (iwinfo_ifdown(ifname) && iwinfo_ifup(res))
1463                         {
1464                                 wext_get_scanlist(res, buf, len);
1465                                 iwinfo_ifdown(res);
1466                                 iwinfo_ifup(ifname);
1467                                 nl80211_hostapd_hup(ifname);
1468                         }
1469
1470                 out:
1471                         nl80211_ifdel(res);
1472                         return 0;
1473                 }
1474         }
1475
1476         return -1;
1477 }
1478
1479 static int nl80211_get_freqlist_cb(struct nl_msg *msg, void *arg)
1480 {
1481         int bands_remain, freqs_remain;
1482
1483         struct nl80211_array_buf *arr = arg;
1484         struct iwinfo_freqlist_entry *e = arr->buf;
1485
1486         struct nlattr **attr = nl80211_parse(msg);
1487         struct nlattr *bands[NL80211_BAND_ATTR_MAX + 1];
1488         struct nlattr *freqs[NL80211_FREQUENCY_ATTR_MAX + 1];
1489         struct nlattr *band, *freq;
1490
1491         static struct nla_policy freq_policy[NL80211_FREQUENCY_ATTR_MAX + 1] = {
1492                 [NL80211_FREQUENCY_ATTR_FREQ]         = { .type = NLA_U32  },
1493                 [NL80211_FREQUENCY_ATTR_DISABLED]     = { .type = NLA_FLAG },
1494                 [NL80211_FREQUENCY_ATTR_PASSIVE_SCAN] = { .type = NLA_FLAG },
1495                 [NL80211_FREQUENCY_ATTR_NO_IBSS]      = { .type = NLA_FLAG },
1496                 [NL80211_FREQUENCY_ATTR_RADAR]        = { .type = NLA_FLAG },
1497                 [NL80211_FREQUENCY_ATTR_MAX_TX_POWER] = { .type = NLA_U32  },
1498         };
1499
1500         nla_for_each_nested(band, attr[NL80211_ATTR_WIPHY_BANDS], bands_remain)
1501         {
1502                 nla_parse(bands, NL80211_BAND_ATTR_MAX, nla_data(band),
1503                         nla_len(band), NULL);
1504
1505                 nla_for_each_nested(freq,
1506                         bands[NL80211_BAND_ATTR_FREQS], freqs_remain)
1507                 {
1508                         nla_parse(freqs, NL80211_FREQUENCY_ATTR_MAX,
1509                                 nla_data(freq), nla_len(freq), NULL);
1510
1511                         if( !freqs[NL80211_FREQUENCY_ATTR_FREQ] ||
1512                                 freqs[NL80211_FREQUENCY_ATTR_DISABLED] )
1513                                 continue;
1514
1515                         e->mhz = nla_get_u32(freqs[NL80211_FREQUENCY_ATTR_FREQ]);
1516                         e->channel = nl80211_freq2channel(e->mhz);
1517
1518                         e->restricted = (
1519                                 freqs[NL80211_FREQUENCY_ATTR_PASSIVE_SCAN] ||
1520                                 freqs[NL80211_FREQUENCY_ATTR_NO_IBSS]      ||
1521                                 freqs[NL80211_FREQUENCY_ATTR_RADAR]
1522                         ) ? 1 : 0;
1523
1524                         e++;
1525                         arr->count++;
1526                 }
1527         }
1528
1529         return NL_SKIP;
1530 }
1531
1532 int nl80211_get_freqlist(const char *ifname, char *buf, int *len)
1533 {
1534         struct nl80211_msg_conveyor *req;
1535         struct nl80211_array_buf arr = { .buf = buf, .count = 0 };
1536
1537         req = nl80211_msg(ifname, NL80211_CMD_GET_WIPHY, 0);
1538         if (req)
1539         {
1540                 nl80211_send(req, nl80211_get_freqlist_cb, &arr);
1541                 nl80211_free(req);
1542         }
1543
1544         if (arr.count > 0)
1545         {
1546                 *len = arr.count * sizeof(struct iwinfo_freqlist_entry);
1547                 return 0;
1548         }
1549
1550         return -1;
1551 }
1552
1553 static int nl80211_get_country_cb(struct nl_msg *msg, void *arg)
1554 {
1555         char *buf = arg;
1556         struct nlattr **attr = nl80211_parse(msg);
1557
1558         if (attr[NL80211_ATTR_REG_ALPHA2])
1559                 memcpy(buf, nla_data(attr[NL80211_ATTR_REG_ALPHA2]), 2);
1560         else
1561                 buf[0] = 0;
1562
1563         return NL_SKIP;
1564 }
1565
1566 int nl80211_get_country(const char *ifname, char *buf)
1567 {
1568         int rv = -1;
1569         struct nl80211_msg_conveyor *req;
1570
1571         req = nl80211_msg(ifname, NL80211_CMD_GET_REG, 0);
1572         if (req)
1573         {
1574                 nl80211_send(req, nl80211_get_country_cb, buf);
1575                 nl80211_free(req);
1576
1577                 if (buf[0])
1578                         rv = 0;
1579         }
1580
1581         return rv;
1582 }
1583
1584 int nl80211_get_countrylist(const char *ifname, char *buf, int *len)
1585 {
1586         int i, count;
1587         struct iwinfo_country_entry *e = (struct iwinfo_country_entry *)buf;
1588         const struct iwinfo_iso3166_label *l;
1589
1590         for( l = IWINFO_ISO3166_NAMES, count = 0; l->iso3166; l++, e++, count++ )
1591         {
1592                 e->iso3166 = l->iso3166;
1593                 e->ccode[0] = (l->iso3166 / 256);
1594                 e->ccode[1] = (l->iso3166 % 256);
1595         }
1596
1597         *len = (count * sizeof(struct iwinfo_country_entry));
1598         return 0;
1599 }
1600
1601 static int nl80211_get_hwmodelist_cb(struct nl_msg *msg, void *arg)
1602 {
1603         int *modes = arg;
1604         int bands_remain, freqs_remain;
1605         uint16_t caps = 0;
1606         struct nlattr **attr = nl80211_parse(msg);
1607         struct nlattr *bands[NL80211_BAND_ATTR_MAX + 1];
1608         struct nlattr *freqs[NL80211_FREQUENCY_ATTR_MAX + 1];
1609         struct nlattr *band, *freq;
1610
1611         *modes = 0;
1612
1613         if (attr[NL80211_ATTR_WIPHY_BANDS])
1614         {
1615                 nla_for_each_nested(band, attr[NL80211_ATTR_WIPHY_BANDS], bands_remain)
1616                 {
1617                         nla_parse(bands, NL80211_BAND_ATTR_MAX, nla_data(band),
1618                                 nla_len(band), NULL);
1619
1620                         if (bands[NL80211_BAND_ATTR_HT_CAPA])
1621                                 caps = nla_get_u16(bands[NL80211_BAND_ATTR_HT_CAPA]);
1622
1623                         /* Treat any nonzero capability as 11n */
1624                         if (caps > 0)
1625                                 *modes |= IWINFO_80211_N;
1626
1627                         nla_for_each_nested(freq,
1628                                 bands[NL80211_BAND_ATTR_FREQS], freqs_remain)
1629                         {
1630                                 nla_parse(freqs, NL80211_FREQUENCY_ATTR_MAX,
1631                                         nla_data(freq), nla_len(freq), NULL);
1632
1633                                 if (!freqs[NL80211_FREQUENCY_ATTR_FREQ])
1634                                         continue;
1635
1636                                 if (nla_get_u32(freqs[NL80211_FREQUENCY_ATTR_FREQ]) < 2485)
1637                                 {
1638                                         *modes |= IWINFO_80211_B;
1639                                         *modes |= IWINFO_80211_G;
1640                                 }
1641                                 else
1642                                 {
1643                                         *modes |= IWINFO_80211_A;
1644                                 }
1645                         }
1646                 }
1647         }
1648
1649         return NL_SKIP;
1650 }
1651
1652 int nl80211_get_hwmodelist(const char *ifname, int *buf)
1653 {
1654         struct nl80211_msg_conveyor *req;
1655
1656         req = nl80211_msg(ifname, NL80211_CMD_GET_WIPHY, 0);
1657         if (req)
1658         {
1659                 nl80211_send(req, nl80211_get_hwmodelist_cb, buf);
1660                 nl80211_free(req);
1661         }
1662
1663         return *buf ? 0 : -1;
1664 }
1665
1666 int nl80211_get_mbssid_support(const char *ifname, int *buf)
1667 {
1668         /* Test whether we can create another interface */
1669         char *nif = nl80211_ifadd(ifname);
1670
1671         if (nif)
1672         {
1673                 *buf = (iwinfo_ifmac(nif) && iwinfo_ifup(nif));
1674
1675                 iwinfo_ifdown(nif);
1676                 nl80211_ifdel(nif);
1677
1678                 return 0;
1679         }
1680
1681         return -1;
1682 }
1683
1684 int nl80211_get_hardware_id(const char *ifname, char *buf)
1685 {
1686         int rv;
1687         char *res;
1688
1689         /* Got a radioX pseudo interface, find some interface on it or create one */
1690         if (!strncmp(ifname, "radio", 5))
1691         {
1692                 /* Reuse existing interface */
1693                 if ((res = nl80211_phy2ifname(ifname)) != NULL)
1694                 {
1695                         rv = wext_get_hardware_id(res, buf);
1696                 }
1697
1698                 /* Need to spawn a temporary iface for finding IDs */
1699                 else if ((res = nl80211_ifadd(ifname)) != NULL)
1700                 {
1701                         rv = wext_get_hardware_id(res, buf);
1702                         nl80211_ifdel(res);
1703                 }
1704         }
1705         else
1706         {
1707                 rv = wext_get_hardware_id(ifname, buf);
1708         }
1709
1710         /* Failed to obtain hardware IDs, search board config */
1711         if (rv)
1712         {
1713                 rv = iwinfo_hardware_id_from_mtd(buf);
1714         }
1715
1716         return rv;
1717 }
1718
1719 static const struct iwinfo_hardware_entry *
1720 nl80211_get_hardware_entry(const char *ifname)
1721 {
1722         struct iwinfo_hardware_id id;
1723
1724         if (nl80211_get_hardware_id(ifname, (char *)&id))
1725                 return NULL;
1726
1727         return iwinfo_hardware(&id);
1728 }
1729
1730 int nl80211_get_hardware_name(const char *ifname, char *buf)
1731 {
1732         const struct iwinfo_hardware_entry *hw;
1733
1734         if (!(hw = nl80211_get_hardware_entry(ifname)))
1735                 sprintf(buf, "Generic MAC80211");
1736         else
1737                 sprintf(buf, "%s %s", hw->vendor_name, hw->device_name);
1738
1739         return 0;
1740 }
1741
1742 int nl80211_get_txpower_offset(const char *ifname, int *buf)
1743 {
1744         const struct iwinfo_hardware_entry *hw;
1745
1746         if (!(hw = nl80211_get_hardware_entry(ifname)))
1747                 return -1;
1748
1749         *buf = hw->txpower_offset;
1750         return 0;
1751 }
1752
1753 int nl80211_get_frequency_offset(const char *ifname, int *buf)
1754 {
1755         const struct iwinfo_hardware_entry *hw;
1756
1757         if (!(hw = nl80211_get_hardware_entry(ifname)))
1758                 return -1;
1759
1760         *buf = hw->frequency_offset;
1761         return 0;
1762 }