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