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