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