projects / project / luci.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
libiwinfo: fail after 5 tries when there's no response from wpa_supplicant
[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_get_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 int nl80211_get_bitrate(const char *ifname, int *buf)
723 {
724 struct nl80211_rssi_rate rr;
725 struct nl80211_msg_conveyor *req;
726
727 if( !wext_get_bitrate(ifname, buf) )
728 return 0;
729
730 req = nl80211_msg(ifname, NL80211_CMD_GET_STATION, NLM_F_DUMP);
731 if( req )
732 {
733 rr.rssi = 0;
734 rr.rate = 0;
735
736 nl80211_cb(req, nl80211_get_signal_cb, &rr);
737 nl80211_send(req);
738 nl80211_free(req);
739
740 if( rr.rate )
741 {
742 *buf = (rr.rate * 100);
743 return 0;
744 }
745 }
746
747 return -1;
748 }
749
750 int nl80211_get_signal(const char *ifname, int *buf)
751 {
752 struct nl80211_rssi_rate rr;
753 struct nl80211_msg_conveyor *req;
754
755 if( !wext_get_signal(ifname, buf) )
756 return 0;
757
758 req = nl80211_msg(ifname, NL80211_CMD_GET_STATION, NLM_F_DUMP);
759 if( req )
760 {
761 rr.rssi = 0;
762 rr.rate = 0;
763
764 nl80211_cb(req, nl80211_get_signal_cb, &rr);
765 nl80211_send(req);
766 nl80211_free(req);
767
768 if( rr.rssi )
769 {
770 *buf = rr.rssi;
771 return 0;
772 }
773 }
774
775 return -1;
776 }
777
778 static int nl80211_get_noise_cb(struct nl_msg *msg, void *arg)
779 {
780 int8_t *noise = arg;
781 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
782 struct nlattr *tb[NL80211_ATTR_MAX + 1];
783 struct nlattr *si[NL80211_SURVEY_INFO_MAX + 1];
784
785 static struct nla_policy sp[NL80211_SURVEY_INFO_MAX + 1] = {
786 [NL80211_SURVEY_INFO_FREQUENCY] = { .type = NLA_U32 },
787 [NL80211_SURVEY_INFO_NOISE] = { .type = NLA_U8 },
788 };
789
790 nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
791 genlmsg_attrlen(gnlh, 0), NULL);
792
793 if (!tb[NL80211_ATTR_SURVEY_INFO])
794 return NL_SKIP;
795
796 if (nla_parse_nested(si, NL80211_SURVEY_INFO_MAX,
797 tb[NL80211_ATTR_SURVEY_INFO], sp))
798 return NL_SKIP;
799
800 if (!si[NL80211_SURVEY_INFO_NOISE])
801 return NL_SKIP;
802
803 if (!*noise || si[NL80211_SURVEY_INFO_IN_USE])
804 *noise = (int8_t)nla_get_u8(si[NL80211_SURVEY_INFO_NOISE]);
805
806 return NL_SKIP;
807 }
808
809
810 int nl80211_get_noise(const char *ifname, int *buf)
811 {
812 int8_t noise;
813 struct nl80211_msg_conveyor *req;
814
815 req = nl80211_msg(ifname, NL80211_CMD_GET_SURVEY, NLM_F_DUMP);
816 if (req)
817 {
818 noise = 0;
819
820 nl80211_cb(req, nl80211_get_noise_cb, &noise);
821 nl80211_send(req);
822 nl80211_free(req);
823
824 if (noise)
825 {
826 *buf = noise;
827 return 0;
828 }
829 }
830
831 return -1;
832 }
833
834 int nl80211_get_quality(const char *ifname, int *buf)
835 {
836 int signal;
837
838 if( wext_get_quality(ifname, buf) )
839 {
840 *buf = 0;
841
842 if( !nl80211_get_signal(ifname, &signal) )
843 {
844 /* A positive signal level is usually just a quality
845 * value, pass through as-is */
846 if( signal >= 0 )
847 {
848 *buf = signal;
849 }
850
851 /* The cfg80211 wext compat layer assumes a signal range
852 * of -110 dBm to -40 dBm, the quality value is derived
853 * by adding 110 to the signal level */
854 else
855 {
856 if( signal < -110 )
857 signal = -110;
858 else if( signal > -40 )
859 signal = -40;
860
861 *buf = (signal + 110);
862 }
863 }
864 }
865
866 return 0;
867 }
868
869 int nl80211_get_quality_max(const char *ifname, int *buf)
870 {
871 if( wext_get_quality_max(ifname, buf) )
872 /* The cfg80211 wext compat layer assumes a maximum
873 * quality of 70 */
874 *buf = 70;
875
876 return 0;
877 }
878
879 int nl80211_get_encryption(const char *ifname, char *buf)
880 {
881 int i;
882 char k[9];
883 char *val, *res;
884 struct iwinfo_crypto_entry *c = (struct iwinfo_crypto_entry *)buf;
885
886 /* Hostapd */
887 if( (res = nl80211_hostapd_info(ifname)) )
888 {
889 if( (val = nl80211_getval(ifname, res, "wpa")) != NULL )
890 c->wpa_version = atoi(val);
891
892 val = nl80211_getval(ifname, res, "wpa_key_mgmt");
893
894 if( !val || strstr(val, "PSK") )
895 c->auth_suites |= IWINFO_KMGMT_PSK;
896
897 if( val && strstr(val, "EAP") )
898 c->auth_suites |= IWINFO_KMGMT_8021x;
899
900 if( val && strstr(val, "NONE") )
901 c->auth_suites |= IWINFO_KMGMT_NONE;
902
903 if( (val = nl80211_getval(ifname, res, "wpa_pairwise")) != NULL )
904 {
905 if( strstr(val, "TKIP") )
906 c->pair_ciphers |= IWINFO_CIPHER_TKIP;
907
908 if( strstr(val, "CCMP") )
909 c->pair_ciphers |= IWINFO_CIPHER_CCMP;
910
911 if( strstr(val, "NONE") )
912 c->pair_ciphers |= IWINFO_CIPHER_NONE;
913 }
914
915 if( (val = nl80211_getval(ifname, res, "auth_algs")) != NULL )
916 {
917 switch(atoi(val)) {
918 case 1:
919 c->auth_algs |= IWINFO_AUTH_OPEN;
920 break;
921
922 case 2:
923 c->auth_algs |= IWINFO_AUTH_SHARED;
924 break;
925
926 case 3:
927 c->auth_algs |= IWINFO_AUTH_OPEN;
928 c->auth_algs |= IWINFO_AUTH_SHARED;
929 break;
930
931 default:
932 break;
933 }
934
935 for( i = 0; i < 4; i++ )
936 {
937 snprintf(k, sizeof(k), "wep_key%d", i);
938
939 if( (val = nl80211_getval(ifname, res, k)) )
940 {
941 if( (strlen(val) == 5) || (strlen(val) == 10) )
942 c->pair_ciphers |= IWINFO_CIPHER_WEP40;
943
944 else if( (strlen(val) == 13) || (strlen(val) == 26) )
945 c->pair_ciphers |= IWINFO_CIPHER_WEP104;
946 }
947 }
948 }
949
950 c->group_ciphers = c->pair_ciphers;
951 c->enabled = (c->auth_algs || c->auth_suites) ? 1 : 0;
952
953 return 0;
954 }
955
956 /* WPA supplicant */
957 else if( (res = nl80211_wpactl_info(ifname, "STATUS", NULL)) &&
958 (val = nl80211_getval(NULL, res, "pairwise_cipher")) )
959 {
960 /* WEP */
961 if( strstr(val, "WEP") )
962 {
963 if( strstr(val, "WEP-40") )
964 c->pair_ciphers |= IWINFO_CIPHER_WEP40;
965
966 else if( strstr(val, "WEP-104") )
967 c->pair_ciphers |= IWINFO_CIPHER_WEP104;
968
969 c->enabled = 1;
970 c->group_ciphers = c->pair_ciphers;
971
972 c->auth_suites |= IWINFO_KMGMT_NONE;
973 c->auth_algs |= IWINFO_AUTH_OPEN; /* XXX: assumption */
974 }
975
976 /* WPA */
977 else
978 {
979 if( strstr(val, "TKIP") )
980 c->pair_ciphers |= IWINFO_CIPHER_TKIP;
981
982 else if( strstr(val, "CCMP") )
983 c->pair_ciphers |= IWINFO_CIPHER_CCMP;
984
985 else if( strstr(val, "NONE") )
986 c->pair_ciphers |= IWINFO_CIPHER_NONE;
987
988 else if( strstr(val, "WEP-40") )
989 c->pair_ciphers |= IWINFO_CIPHER_WEP40;
990
991 else if( strstr(val, "WEP-104") )
992 c->pair_ciphers |= IWINFO_CIPHER_WEP104;
993
994
995 if( (val = nl80211_getval(NULL, res, "group_cipher")) )
996 {
997 if( strstr(val, "TKIP") )
998 c->group_ciphers |= IWINFO_CIPHER_TKIP;
999
1000 else if( strstr(val, "CCMP") )
1001 c->group_ciphers |= IWINFO_CIPHER_CCMP;
1002
1003 else if( strstr(val, "NONE") )
1004 c->group_ciphers |= IWINFO_CIPHER_NONE;
1005
1006 else if( strstr(val, "WEP-40") )
1007 c->group_ciphers |= IWINFO_CIPHER_WEP40;
1008
1009 else if( strstr(val, "WEP-104") )
1010 c->group_ciphers |= IWINFO_CIPHER_WEP104;
1011 }
1012
1013
1014 if( (val = nl80211_getval(NULL, res, "key_mgmt")) )
1015 {
1016 if( strstr(val, "WPA2") )
1017 c->wpa_version = 2;
1018
1019 else if( strstr(val, "WPA") )
1020 c->wpa_version = 1;
1021
1022
1023 if( strstr(val, "PSK") )
1024 c->auth_suites |= IWINFO_KMGMT_PSK;
1025
1026 else if( strstr(val, "EAP") || strstr(val, "802.1X") )
1027 c->auth_suites |= IWINFO_KMGMT_8021x;
1028
1029 else if( strstr(val, "NONE") )
1030 c->auth_suites |= IWINFO_KMGMT_NONE;
1031 }
1032
1033 c->enabled = (c->wpa_version && c->auth_suites) ? 1 : 0;
1034 }
1035
1036 return 0;
1037 }
1038
1039 return -1;
1040 }
1041
1042
1043 static int nl80211_get_assoclist_cb(struct nl_msg *msg, void *arg)
1044 {
1045 struct nl80211_assoc_count *ac = arg;
1046 struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
1047 struct nlattr *attr[NL80211_ATTR_MAX + 1];
1048 struct nlattr *sinfo[NL80211_STA_INFO_MAX + 1];
1049
1050 static struct nla_policy stats_policy[NL80211_STA_INFO_MAX + 1] = {
1051 [NL80211_STA_INFO_INACTIVE_TIME] = { .type = NLA_U32 },
1052 [NL80211_STA_INFO_RX_BYTES] = { .type = NLA_U32 },
1053 [NL80211_STA_INFO_TX_BYTES] = { .type = NLA_U32 },
1054 [NL80211_STA_INFO_RX_PACKETS] = { .type = NLA_U32 },
1055 [NL80211_STA_INFO_TX_PACKETS] = { .type = NLA_U32 },
1056 [NL80211_STA_INFO_SIGNAL] = { .type = NLA_U8 },
1057 [NL80211_STA_INFO_TX_BITRATE] = { .type = NLA_NESTED },
1058 [NL80211_STA_INFO_LLID] = { .type = NLA_U16 },
1059 [NL80211_STA_INFO_PLID] = { .type = NLA_U16 },
1060 [NL80211_STA_INFO_PLINK_STATE] = { .type = NLA_U8 },
1061 };
1062
1063 nla_parse(attr, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
1064 genlmsg_attrlen(gnlh, 0), NULL);
1065
1066 if( attr[NL80211_ATTR_MAC] )
1067 memcpy(ac->entry->mac, nla_data(attr[NL80211_ATTR_MAC]), 6);
1068
1069 if( attr[NL80211_ATTR_STA_INFO] )
1070 {
1071 if( !nla_parse_nested(sinfo, NL80211_STA_INFO_MAX,
1072 attr[NL80211_ATTR_STA_INFO], stats_policy) )
1073 {
1074 if( sinfo[NL80211_STA_INFO_SIGNAL] )
1075 ac->entry->signal = nla_get_u8(sinfo[NL80211_STA_INFO_SIGNAL]);
1076 }
1077 }
1078
1079 ac->entry->noise = ac->noise;
1080 ac->entry++;
1081 ac->count++;
1082
1083 return NL_SKIP;
1084 }
1085
1086 int nl80211_get_assoclist(const char *ifname, char *buf, int *len)
1087 {
1088 struct nl80211_assoc_count ac;
1089 struct nl80211_msg_conveyor *req;
1090
1091 nl80211_get_noise(ifname, &ac.noise);
1092
1093 req = nl80211_msg(ifname, NL80211_CMD_GET_STATION, NLM_F_DUMP);
1094 if( req )
1095 {
1096 ac.count = 0;
1097 ac.entry = (struct iwinfo_assoclist_entry *)buf;
1098
1099 nl80211_cb(req, nl80211_get_assoclist_cb, &ac);
1100 nl80211_send(req);
1101 nl80211_free(req);
1102
1103 *len = (ac.count * sizeof(struct iwinfo_assoclist_entry));
1104 return 0;
1105 }
1106
1107 return -1;
1108 }
1109
1110 int nl80211_get_txpwrlist(const char *ifname, char *buf, int *len)
1111 {
1112 int ch_cur, ch_cmp, bands_remain, freqs_remain;
1113 int dbm_max = -1, dbm_cur, dbm_cnt;
1114 struct nl80211_msg_conveyor *req, *res;
1115 struct nlattr *bands[NL80211_BAND_ATTR_MAX + 1];
1116 struct nlattr *freqs[NL80211_FREQUENCY_ATTR_MAX + 1];
1117 struct nlattr *band, *freq;
1118 struct iwinfo_txpwrlist_entry entry;
1119
1120 static struct nla_policy freq_policy[NL80211_FREQUENCY_ATTR_MAX + 1] = {
1121 [NL80211_FREQUENCY_ATTR_FREQ] = { .type = NLA_U32 },
1122 [NL80211_FREQUENCY_ATTR_DISABLED] = { .type = NLA_FLAG },
1123 [NL80211_FREQUENCY_ATTR_PASSIVE_SCAN] = { .type = NLA_FLAG },
1124 [NL80211_FREQUENCY_ATTR_NO_IBSS] = { .type = NLA_FLAG },
1125 [NL80211_FREQUENCY_ATTR_RADAR] = { .type = NLA_FLAG },
1126 [NL80211_FREQUENCY_ATTR_MAX_TX_POWER] = { .type = NLA_U32 },
1127 };
1128
1129 if( nl80211_get_channel(ifname, &ch_cur) )
1130 ch_cur = 0;
1131
1132 req = nl80211_msg(ifname, NL80211_CMD_GET_WIPHY, 0);
1133 if( req )
1134 {
1135 res = nl80211_send(req);
1136 if( res )
1137 {
1138 nla_for_each_nested(band,
1139 res->attr[NL80211_ATTR_WIPHY_BANDS], bands_remain)
1140 {
1141 nla_parse(bands, NL80211_BAND_ATTR_MAX, nla_data(band),
1142 nla_len(band), NULL);
1143
1144 nla_for_each_nested(freq,
1145 bands[NL80211_BAND_ATTR_FREQS], freqs_remain)
1146 {
1147 nla_parse(freqs, NL80211_FREQUENCY_ATTR_MAX,
1148 nla_data(freq), nla_len(freq), freq_policy);
1149
1150 ch_cmp = nl80211_freq2channel(
1151 nla_get_u32(freqs[NL80211_FREQUENCY_ATTR_FREQ]));
1152
1153 if( (!ch_cur || (ch_cmp == ch_cur)) &&
1154 freqs[NL80211_FREQUENCY_ATTR_MAX_TX_POWER] )
1155 {
1156 dbm_max = (int)(0.01 * nla_get_u32(
1157 freqs[NL80211_FREQUENCY_ATTR_MAX_TX_POWER]));
1158
1159 break;
1160 }
1161 }
1162 }
1163
1164 nl80211_free(res);
1165 }
1166 nl80211_free(req);
1167 }
1168
1169 if( dbm_max > -1 )
1170 {
1171 for( dbm_cur = 0, dbm_cnt = 0;
1172 dbm_cur < dbm_max;
1173 dbm_cur += 2, dbm_cnt++ )
1174 {
1175 entry.dbm = dbm_cur;
1176 entry.mw = iwinfo_dbm2mw(dbm_cur);
1177
1178 memcpy(&buf[dbm_cnt * sizeof(entry)], &entry, sizeof(entry));
1179 }
1180
1181 entry.dbm = dbm_max;
1182 entry.mw = iwinfo_dbm2mw(dbm_max);
1183
1184 memcpy(&buf[dbm_cnt * sizeof(entry)], &entry, sizeof(entry));
1185 dbm_cnt++;
1186
1187 *len = dbm_cnt * sizeof(entry);
1188 return 0;
1189 }
1190
1191 return -1;
1192 }
1193
1194 static void nl80211_get_scancrypto(const char *spec,
1195 struct iwinfo_crypto_entry *c)
1196 {
1197 if( strstr(spec, "WPA") || strstr(spec, "WEP") )
1198 {
1199 c->enabled = 1;
1200
1201 if( strstr(spec, "WPA2-") && strstr(spec, "WPA-") )
1202 c->wpa_version = 3;
1203
1204 else if( strstr(spec, "WPA2") )
1205 c->wpa_version = 2;
1206
1207 else if( strstr(spec, "WPA") )
1208 c->wpa_version = 1;
1209
1210 else if( strstr(spec, "WEP") )
1211 c->auth_algs = IWINFO_AUTH_OPEN | IWINFO_AUTH_SHARED;
1212
1213
1214 if( strstr(spec, "PSK") )
1215 c->auth_suites |= IWINFO_KMGMT_PSK;
1216
1217 if( strstr(spec, "802.1X") || strstr(spec, "EAP") )
1218 c->auth_suites |= IWINFO_KMGMT_8021x;
1219
1220 if( strstr(spec, "WPA-NONE") )
1221 c->auth_suites |= IWINFO_KMGMT_NONE;
1222
1223
1224 if( strstr(spec, "TKIP") )
1225 c->pair_ciphers |= IWINFO_CIPHER_TKIP;
1226
1227 if( strstr(spec, "CCMP") )
1228 c->pair_ciphers |= IWINFO_CIPHER_CCMP;
1229
1230 if( strstr(spec, "WEP-40") )
1231 c->pair_ciphers |= IWINFO_CIPHER_WEP40;
1232
1233 if( strstr(spec, "WEP-104") )
1234 c->pair_ciphers |= IWINFO_CIPHER_WEP104;
1235
1236 c->group_ciphers = c->pair_ciphers;
1237 }
1238 else
1239 {
1240 c->enabled = 0;
1241 }
1242 }
1243
1244 int nl80211_get_scanlist(const char *ifname, char *buf, int *len)
1245 {
1246 int freq, rssi, qmax, count;
1247 char *res;
1248 char ssid[128] = { 0 };
1249 char bssid[18] = { 0 };
1250 char cipher[256] = { 0 };
1251
1252 /* Got a radioX pseudo interface, find some interface on it or create one */
1253 if( !strncmp(ifname, "radio", 5) )
1254 {
1255 /* Reuse existing interface */
1256 if( (res = nl80211_phy2ifname(ifname)) != NULL )
1257 {
1258 return nl80211_get_scanlist(res, buf, len);
1259 }
1260
1261 /* Need to spawn a temporary iface for scanning */
1262 else if( (res = nl80211_ifadd(ifname)) != NULL )
1263 {
1264 count = nl80211_get_scanlist(res, buf, len);
1265 nl80211_ifdel(res);
1266 return count;
1267 }
1268 }
1269
1270 struct iwinfo_scanlist_entry *e = (struct iwinfo_scanlist_entry *)buf;
1271
1272 /* WPA supplicant */
1273 if( (res = nl80211_wpactl_info(ifname, "SCAN", "CTRL-EVENT-SCAN-RESULTS")) )
1274 {
1275 if( (res = nl80211_wpactl_info(ifname, "SCAN_RESULTS", NULL)) )
1276 {
1277 nl80211_get_quality_max(ifname, &qmax);
1278
1279 /* skip header line */
1280 while( *res++ != '\n' );
1281
1282 count = 0;
1283
1284 while( sscanf(res, "%17s %d %d %255s%*[ \t]%127[^\n]\n",
1285 bssid, &freq, &rssi, cipher, ssid) > 0 )
1286 {
1287 /* BSSID */
1288 e->mac[0] = strtol(&bssid[0], NULL, 16);
1289 e->mac[1] = strtol(&bssid[3], NULL, 16);
1290 e->mac[2] = strtol(&bssid[6], NULL, 16);
1291 e->mac[3] = strtol(&bssid[9], NULL, 16);
1292 e->mac[4] = strtol(&bssid[12], NULL, 16);
1293 e->mac[5] = strtol(&bssid[15], NULL, 16);
1294
1295 /* SSID */
1296 memcpy(e->ssid, ssid,
1297 min(strlen(ssid), sizeof(e->ssid) - 1));
1298
1299 /* Mode (assume master) */
1300 sprintf((char *)e->mode, "Master");
1301
1302 /* Channel */
1303 e->channel = nl80211_freq2channel(freq);
1304
1305 /* Signal */
1306 e->signal = rssi;
1307
1308 /* Quality */
1309 if( rssi < 0 )
1310 {
1311 /* The cfg80211 wext compat layer assumes a signal range
1312 * of -110 dBm to -40 dBm, the quality value is derived
1313 * by adding 110 to the signal level */
1314 if( rssi < -110 )
1315 rssi = -110;
1316 else if( rssi > -40 )
1317 rssi = -40;
1318
1319 e->quality = (rssi + 110);
1320 }
1321 else
1322 {
1323 e->quality = rssi;
1324 }
1325
1326 /* Max. Quality */
1327 e->quality_max = qmax;
1328
1329 /* Crypto */
1330 nl80211_get_scancrypto(cipher, &e->crypto);
1331
1332 /* advance to next line */
1333 while( *res && *res++ != '\n' );
1334
1335 count++;
1336 e++;
1337
1338 memset(ssid, 0, sizeof(ssid));
1339 memset(bssid, 0, sizeof(bssid));
1340 memset(cipher, 0, sizeof(cipher));
1341 }
1342
1343 *len = count * sizeof(struct iwinfo_scanlist_entry);
1344 return 0;
1345 }
1346 }
1347
1348 /* AP scan */
1349 else
1350 {
1351 /* Got a temp interface, don't create yet another one */
1352 if( !strncmp(ifname, "tmp.", 4) )
1353 {
1354 if( !iwinfo_ifup(ifname) )
1355 return -1;
1356
1357 wext_get_scanlist(ifname, buf, len);
1358 iwinfo_ifdown(ifname);
1359 return 0;
1360 }
1361
1362 /* Spawn a new scan interface */
1363 else
1364 {
1365 if( !(res = nl80211_ifadd(ifname)) )
1366 goto out;
1367
1368 if( !iwinfo_ifmac(res) )
1369 goto out;
1370
1371 /* if we can take the new interface up, the driver supports an
1372 * additional interface and there's no need to tear down the ap */
1373 if( iwinfo_ifup(res) )
1374 {
1375 wext_get_scanlist(res, buf, len);
1376 iwinfo_ifdown(res);
1377 }
1378
1379 /* driver cannot create secondary interface, take down ap
1380 * during scan */
1381 else if( iwinfo_ifdown(ifname) && iwinfo_ifup(res) )
1382 {
1383 wext_get_scanlist(res, buf, len);
1384 iwinfo_ifdown(res);
1385 iwinfo_ifup(ifname);
1386 nl80211_hostapd_hup(ifname);
1387 }
1388
1389 out:
1390 nl80211_ifdel(res);
1391 return 0;
1392 }
1393 }
1394
1395 return -1;
1396 }
1397
1398 int nl80211_get_freqlist(const char *ifname, char *buf, int *len)
1399 {
1400 int count = 0, bands_remain, freqs_remain;
1401 struct nl80211_msg_conveyor *req, *res;
1402 struct nlattr *bands[NL80211_BAND_ATTR_MAX + 1];
1403 struct nlattr *freqs[NL80211_FREQUENCY_ATTR_MAX + 1];
1404 struct nlattr *band, *freq;
1405 struct iwinfo_freqlist_entry *e = (struct iwinfo_freqlist_entry *)buf;
1406
1407 req = nl80211_msg(ifname, NL80211_CMD_GET_WIPHY, 0);
1408 if( req )
1409 {
1410 res = nl80211_send(req);
1411 if( res )
1412 {
1413 nla_for_each_nested(band,
1414 res->attr[NL80211_ATTR_WIPHY_BANDS], bands_remain)
1415 {
1416 nla_parse(bands, NL80211_BAND_ATTR_MAX, nla_data(band),
1417 nla_len(band), NULL);
1418
1419 nla_for_each_nested(freq,
1420 bands[NL80211_BAND_ATTR_FREQS], freqs_remain)
1421 {
1422 nla_parse(freqs, NL80211_FREQUENCY_ATTR_MAX,
1423 nla_data(freq), nla_len(freq), NULL);
1424
1425 if( !freqs[NL80211_FREQUENCY_ATTR_FREQ] ||
1426 freqs[NL80211_FREQUENCY_ATTR_DISABLED] )
1427 continue;
1428
1429 e->mhz = nla_get_u32(freqs[NL80211_FREQUENCY_ATTR_FREQ]);
1430 e->channel = nl80211_freq2channel(e->mhz);
1431
1432 e->restricted = (
1433 freqs[NL80211_FREQUENCY_ATTR_PASSIVE_SCAN] ||
1434 freqs[NL80211_FREQUENCY_ATTR_NO_IBSS] ||
1435 freqs[NL80211_FREQUENCY_ATTR_RADAR]
1436 ) ? 1 : 0;
1437
1438 e++;
1439 count++;
1440 }
1441 }
1442 nl80211_free(res);
1443 }
1444 nl80211_free(req);
1445 }
1446
1447 if( count > 0 )
1448 {
1449 *len = count * sizeof(struct iwinfo_freqlist_entry);
1450 return 0;
1451 }
1452
1453 return -1;
1454 }
1455
1456 int nl80211_get_country(const char *ifname, char *buf)
1457 {
1458 int rv = -1;
1459 struct nl80211_msg_conveyor *req, *res;
1460
1461 req = nl80211_msg(ifname, NL80211_CMD_GET_REG, 0);
1462 if( req )
1463 {
1464 res = nl80211_send(req);
1465 if( res )
1466 {
1467 if( res->attr[NL80211_ATTR_REG_ALPHA2] )
1468 {
1469 memcpy(buf, nla_data(res->attr[NL80211_ATTR_REG_ALPHA2]), 2);
1470 rv = 0;
1471 }
1472 nl80211_free(res);
1473 }
1474 nl80211_free(req);
1475 }
1476
1477 return rv;
1478 }
1479
1480 int nl80211_get_countrylist(const char *ifname, char *buf, int *len)
1481 {
1482 int i, count;
1483 struct iwinfo_iso3166_label *l;
1484 struct iwinfo_country_entry *e = (struct iwinfo_country_entry *)buf;
1485
1486 for( l = ISO3166_Names, count = 0; l->iso3166; l++, e++, count++ )
1487 {
1488 e->iso3166 = l->iso3166;
1489 e->ccode[0] = (l->iso3166 / 256);
1490 e->ccode[1] = (l->iso3166 % 256);
1491 }
1492
1493 *len = (count * sizeof(struct iwinfo_country_entry));
1494 return 0;
1495 }
1496
1497 int nl80211_get_hwmodelist(const char *ifname, int *buf)
1498 {
1499 int bands_remain, freqs_remain;
1500 struct nl80211_msg_conveyor *req, *res;
1501 struct nlattr *bands[NL80211_BAND_ATTR_MAX + 1];
1502 struct nlattr *freqs[NL80211_FREQUENCY_ATTR_MAX + 1];
1503 struct nlattr *band, *freq;
1504 uint16_t caps = 0;
1505
1506 req = nl80211_msg(ifname, NL80211_CMD_GET_WIPHY, 0);
1507 if( req )
1508 {
1509 res = nl80211_send(req);
1510 if( res )
1511 {
1512 nla_for_each_nested(band,
1513 res->attr[NL80211_ATTR_WIPHY_BANDS], bands_remain)
1514 {
1515 nla_parse(bands, NL80211_BAND_ATTR_MAX, nla_data(band),
1516 nla_len(band), NULL);
1517
1518 if( bands[NL80211_BAND_ATTR_HT_CAPA] )
1519 caps = nla_get_u16(bands[NL80211_BAND_ATTR_HT_CAPA]);
1520
1521 /* Treat any nonzero capability as 11n */
1522 if( caps > 0 )
1523 *buf |= IWINFO_80211_N;
1524
1525 nla_for_each_nested(freq,
1526 bands[NL80211_BAND_ATTR_FREQS], freqs_remain)
1527 {
1528 nla_parse(freqs, NL80211_FREQUENCY_ATTR_MAX,
1529 nla_data(freq), nla_len(freq), NULL);
1530
1531 if( !freqs[NL80211_FREQUENCY_ATTR_FREQ] )
1532 continue;
1533
1534 if( nla_get_u32(freqs[NL80211_FREQUENCY_ATTR_FREQ]) < 2485 )
1535 {
1536 *buf |= IWINFO_80211_B;
1537 *buf |= IWINFO_80211_G;
1538 }
1539 else
1540 {
1541 *buf |= IWINFO_80211_A;
1542 }
1543 }
1544 }
1545 nl80211_free(res);
1546 }
1547 nl80211_free(req);
1548 }
1549
1550 return *buf ? 0 : -1;
1551 }
1552
1553 int nl80211_get_mbssid_support(const char *ifname, int *buf)
1554 {
1555 /* Test whether we can create another interface */
1556 char *nif = nl80211_ifadd(ifname);
1557
1558 if( nif )
1559 {
1560 *buf = (iwinfo_ifmac(nif) && iwinfo_ifup(nif));
1561
1562 iwinfo_ifdown(nif);
1563 nl80211_ifdel(nif);
1564
1565 return 0;
1566 }
1567
1568 return -1;
1569 }
Lua Configuration Interface (mirror)