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