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