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