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