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

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