devices: add support for declaring compatible matched devices
[project/iwinfo.git] / iwinfo_utils.c
1 /*
2 * iwinfo - Wireless Information Library - Shared utility routines
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
23 #include "iwinfo/utils.h"
24
25
26 static int ioctl_socket = -1;
27 struct uci_context *uci_ctx = NULL;
28
29 static int iwinfo_ioctl_socket(void)
30 {
31 /* Prepare socket */
32 if (ioctl_socket == -1)
33 {
34 ioctl_socket = socket(AF_INET, SOCK_DGRAM, 0);
35 fcntl(ioctl_socket, F_SETFD, fcntl(ioctl_socket, F_GETFD) | FD_CLOEXEC);
36 }
37
38 return ioctl_socket;
39 }
40
41 int iwinfo_ioctl(int cmd, void *ifr)
42 {
43 int s = iwinfo_ioctl_socket();
44 return ioctl(s, cmd, ifr);
45 }
46
47 int iwinfo_dbm2mw(int in)
48 {
49 double res = 1.0;
50 int ip = in / 10;
51 int fp = in % 10;
52 int k;
53
54 for(k = 0; k < ip; k++) res *= 10;
55 for(k = 0; k < fp; k++) res *= LOG10_MAGIC;
56
57 return (int)res;
58 }
59
60 int iwinfo_mw2dbm(int in)
61 {
62 double fin = (double) in;
63 int res = 0;
64
65 while(fin > 10.0)
66 {
67 res += 10;
68 fin /= 10.0;
69 }
70
71 while(fin > 1.000001)
72 {
73 res += 1;
74 fin /= LOG10_MAGIC;
75 }
76
77 return (int)res;
78 }
79
80 static int iwinfo_bit(int value, int max)
81 {
82 int i;
83
84 if (max > 31 || !(value & ((1 << max) - 1)))
85 return -1;
86
87 for (i = 0; i < max; i++)
88 {
89 if (value & 1)
90 break;
91
92 value >>= 1;
93 }
94
95 return i;
96 }
97
98 static const char * const iwinfo_name(int mask, int max, const char * const names[])
99 {
100 int index = iwinfo_bit(mask, max);
101
102 if (index < 0)
103 return NULL;
104
105 return names[index];
106 }
107
108 const char * const iwinfo_band_name(int mask)
109 {
110 return iwinfo_name(mask, IWINFO_BAND_COUNT, IWINFO_BAND_NAMES);
111 }
112
113 const char * const iwinfo_htmode_name(int mask)
114 {
115 return iwinfo_name(mask, IWINFO_HTMODE_COUNT, IWINFO_HTMODE_NAMES);
116 }
117
118 uint32_t iwinfo_band2ghz(uint8_t band)
119 {
120 switch (band)
121 {
122 case IWINFO_BAND_24:
123 return 2;
124 case IWINFO_BAND_5:
125 return 5;
126 case IWINFO_BAND_6:
127 return 6;
128 case IWINFO_BAND_60:
129 return 60;
130 }
131
132 return 0;
133 }
134
135 uint8_t iwinfo_ghz2band(uint32_t ghz)
136 {
137 switch (ghz)
138 {
139 case 2:
140 return IWINFO_BAND_24;
141 case 5:
142 return IWINFO_BAND_5;
143 case 6:
144 return IWINFO_BAND_6;
145 case 60:
146 return IWINFO_BAND_60;
147 }
148
149 return 0;
150 }
151
152 size_t iwinfo_format_hwmodes(int modes, char *buf, size_t len)
153 {
154 // bit numbers as per IWINFO_80211_*: ad ac ax a b g n
155 const int order[IWINFO_80211_COUNT] = { 5, 4, 6, 0, 1, 2, 3 };
156 size_t res = 0;
157 int i;
158
159 *buf = 0;
160
161 if (!(modes & ((1 << IWINFO_80211_COUNT) - 1)))
162 return 0;
163
164 for (i = 0; i < IWINFO_80211_COUNT; i++)
165 if (modes & 1 << order[i])
166 res += snprintf(buf + res, len - res, "%s/", IWINFO_80211_NAMES[order[i]]);
167
168 if (res > 0)
169 {
170 res--;
171 buf[res] = 0;
172 }
173
174 return res;
175 }
176
177 int iwinfo_htmode_is_ht(int htmode)
178 {
179 switch (htmode)
180 {
181 case IWINFO_HTMODE_HT20:
182 case IWINFO_HTMODE_HT40:
183 return 1;
184 }
185
186 return 0;
187 }
188
189 int iwinfo_htmode_is_vht(int htmode)
190 {
191 switch (htmode)
192 {
193 case IWINFO_HTMODE_VHT20:
194 case IWINFO_HTMODE_VHT40:
195 case IWINFO_HTMODE_VHT80:
196 case IWINFO_HTMODE_VHT80_80:
197 case IWINFO_HTMODE_VHT160:
198 return 1;
199 }
200
201 return 0;
202 }
203
204 int iwinfo_htmode_is_he(int htmode)
205 {
206 switch (htmode)
207 {
208 case IWINFO_HTMODE_HE20:
209 case IWINFO_HTMODE_HE40:
210 case IWINFO_HTMODE_HE80:
211 case IWINFO_HTMODE_HE80_80:
212 case IWINFO_HTMODE_HE160:
213 return 1;
214 }
215
216 return 0;
217 }
218
219 int iwinfo_ifup(const char *ifname)
220 {
221 struct ifreq ifr;
222
223 strncpy(ifr.ifr_name, ifname, IFNAMSIZ - 1);
224
225 if (iwinfo_ioctl(SIOCGIFFLAGS, &ifr))
226 return 0;
227
228 ifr.ifr_flags |= (IFF_UP | IFF_RUNNING);
229
230 return !iwinfo_ioctl(SIOCSIFFLAGS, &ifr);
231 }
232
233 int iwinfo_ifdown(const char *ifname)
234 {
235 struct ifreq ifr;
236
237 strncpy(ifr.ifr_name, ifname, IFNAMSIZ - 1);
238
239 if (iwinfo_ioctl(SIOCGIFFLAGS, &ifr))
240 return 0;
241
242 ifr.ifr_flags &= ~(IFF_UP | IFF_RUNNING);
243
244 return !iwinfo_ioctl(SIOCSIFFLAGS, &ifr);
245 }
246
247 int iwinfo_ifmac(const char *ifname)
248 {
249 struct ifreq ifr;
250
251 strncpy(ifr.ifr_name, ifname, IFNAMSIZ - 1);
252
253 if (iwinfo_ioctl(SIOCGIFHWADDR, &ifr))
254 return 0;
255
256 ifr.ifr_hwaddr.sa_data[0] |= 0x02;
257 ifr.ifr_hwaddr.sa_data[1]++;
258 ifr.ifr_hwaddr.sa_data[2]++;
259
260 return !iwinfo_ioctl(SIOCSIFHWADDR, &ifr);
261 }
262
263 void iwinfo_close(void)
264 {
265 if (ioctl_socket > -1)
266 close(ioctl_socket);
267
268 ioctl_socket = -1;
269 }
270
271 struct iwinfo_hardware_entry * iwinfo_hardware(struct iwinfo_hardware_id *id)
272 {
273 FILE *db;
274 char buf[256] = { 0 };
275 static struct iwinfo_hardware_entry e;
276 struct iwinfo_hardware_entry *rv = NULL;
277
278 if (!(db = fopen(IWINFO_HARDWARE_FILE, "r")))
279 return NULL;
280
281 while (fgets(buf, sizeof(buf) - 1, db) != NULL)
282 {
283 memset(&e, 0, sizeof(e));
284
285 if (sscanf(buf, "%hx %hx %hx %hx %hd %hd \"%63[^\"]\" \"%63[^\"]\"",
286 &e.vendor_id, &e.device_id,
287 &e.subsystem_vendor_id, &e.subsystem_device_id,
288 &e.txpower_offset, &e.frequency_offset,
289 e.vendor_name, e.device_name) != 8 &&
290 sscanf(buf, "\"%127[^\"]\" %hd %hd \"%63[^\"]\" \"%63[^\"]\"",
291 e.compatible, &e.txpower_offset, &e.frequency_offset,
292 e.vendor_name, e.device_name) != 5)
293 continue;
294
295 if ((e.vendor_id != 0xffff) && (e.vendor_id != id->vendor_id))
296 continue;
297
298 if ((e.device_id != 0xffff) && (e.device_id != id->device_id))
299 continue;
300
301 if ((e.subsystem_vendor_id != 0xffff) &&
302 (e.subsystem_vendor_id != id->subsystem_vendor_id))
303 continue;
304
305 if ((e.subsystem_device_id != 0xffff) &&
306 (e.subsystem_device_id != id->subsystem_device_id))
307 continue;
308
309 if (strcmp(e.compatible, id->compatible))
310 continue;
311
312 rv = &e;
313 break;
314 }
315
316 fclose(db);
317 return rv;
318 }
319
320 int iwinfo_hardware_id_from_mtd(struct iwinfo_hardware_id *id)
321 {
322 FILE *mtd;
323 uint16_t *bc;
324
325 int fd, off;
326 unsigned int len;
327 char buf[128];
328
329 if (!(mtd = fopen("/proc/mtd", "r")))
330 return -1;
331
332 while (fgets(buf, sizeof(buf), mtd) != NULL)
333 {
334 if (fscanf(mtd, "mtd%d: %x %*x %127s", &off, &len, buf) < 3 ||
335 (strcmp(buf, "\"boardconfig\"") && strcmp(buf, "\"EEPROM\"") &&
336 strcmp(buf, "\"factory\"")))
337 {
338 off = -1;
339 continue;
340 }
341
342 break;
343 }
344
345 fclose(mtd);
346
347 if (off < 0)
348 return -1;
349
350 snprintf(buf, sizeof(buf), "/dev/mtdblock%d", off);
351
352 if ((fd = open(buf, O_RDONLY)) < 0)
353 return -1;
354
355 bc = mmap(NULL, len, PROT_READ, MAP_PRIVATE|MAP_LOCKED, fd, 0);
356
357 if ((void *)bc != MAP_FAILED)
358 {
359 id->vendor_id = 0;
360 id->device_id = 0;
361
362 for (off = len / 2 - 0x800; off >= 0; off -= 0x800)
363 {
364 /* AR531X board data magic */
365 if ((bc[off] == 0x3533) && (bc[off + 1] == 0x3131))
366 {
367 id->vendor_id = bc[off + 0x7d];
368 id->device_id = bc[off + 0x7c];
369 id->subsystem_vendor_id = bc[off + 0x84];
370 id->subsystem_device_id = bc[off + 0x83];
371 break;
372 }
373
374 /* AR5416 EEPROM magic */
375 else if ((bc[off] == 0xA55A) || (bc[off] == 0x5AA5))
376 {
377 id->vendor_id = bc[off + 0x0D];
378 id->device_id = bc[off + 0x0E];
379 id->subsystem_vendor_id = bc[off + 0x13];
380 id->subsystem_device_id = bc[off + 0x14];
381 break;
382 }
383
384 /* Rt3xxx SoC */
385 else if ((bc[off] == 0x3050) || (bc[off] == 0x5030) ||
386 (bc[off] == 0x3051) || (bc[off] == 0x5130) ||
387 (bc[off] == 0x3052) || (bc[off] == 0x5230) ||
388 (bc[off] == 0x3350) || (bc[off] == 0x5033) ||
389 (bc[off] == 0x3352) || (bc[off] == 0x5233) ||
390 (bc[off] == 0x3662) || (bc[off] == 0x6236) ||
391 (bc[off] == 0x3883) || (bc[off] == 0x8338) ||
392 (bc[off] == 0x5350) || (bc[off] == 0x5053))
393 {
394 /* vendor: RaLink */
395 id->vendor_id = 0x1814;
396 id->subsystem_vendor_id = 0x1814;
397
398 /* device */
399 if (((bc[off] & 0xf0) == 0x30) ||
400 ((bc[off] & 0xff) == 0x53))
401 id->device_id = (bc[off] >> 8) | (bc[off] & 0x00ff) << 8;
402 else
403 id->device_id = bc[off];
404
405 /* subsystem from EEPROM_NIC_CONF0_RF_TYPE */
406 id->subsystem_device_id = (bc[off + 0x1a] & 0x0f00) >> 8;
407 } else if ((bc[off] == 0x7620) || (bc[off] == 0x2076) ||
408 (bc[off] == 0x7628) || (bc[off] == 0x2876) ||
409 (bc[off] == 0x7688) || (bc[off] == 0x8876)) {
410 /* vendor: MediaTek */
411 id->vendor_id = 0x14c3;
412 id->subsystem_vendor_id = 0x14c3;
413
414 /* device */
415 if ((bc[off] & 0xff) == 0x76)
416 id->device_id = (bc[off] >> 8) | (bc[off] & 0x00ff) << 8;
417 else
418 id->device_id = bc[off];
419
420 /* subsystem from EEPROM_NIC_CONF0_RF_TYPE */
421 id->subsystem_device_id = (bc[off + 0x1a] & 0x0f00) >> 8;
422 }
423 }
424
425 munmap(bc, len);
426 }
427
428 close(fd);
429
430 return (id->vendor_id && id->device_id) ? 0 : -1;
431 }
432
433 static void iwinfo_parse_rsn_cipher(uint8_t idx, uint16_t *ciphers)
434 {
435 switch (idx)
436 {
437 case 0:
438 *ciphers |= IWINFO_CIPHER_NONE;
439 break;
440
441 case 1:
442 *ciphers |= IWINFO_CIPHER_WEP40;
443 break;
444
445 case 2:
446 *ciphers |= IWINFO_CIPHER_TKIP;
447 break;
448
449 case 3: /* WRAP */
450 break;
451
452 case 4:
453 *ciphers |= IWINFO_CIPHER_CCMP;
454 break;
455
456 case 5:
457 *ciphers |= IWINFO_CIPHER_WEP104;
458 break;
459
460 case 8:
461 *ciphers |= IWINFO_CIPHER_GCMP;
462 break;
463
464 case 9:
465 *ciphers |= IWINFO_CIPHER_GCMP256;
466 break;
467
468 case 10:
469 *ciphers |= IWINFO_CIPHER_CCMP256;
470 break;
471
472 case 6: /* AES-128-CMAC */
473 case 7: /* No group addressed */
474 case 11: /* BIP-GMAC-128 */
475 case 12: /* BIP-GMAC-256 */
476 case 13: /* BIP-CMAC-256 */
477 break;
478 }
479 }
480
481 void iwinfo_parse_rsn(struct iwinfo_crypto_entry *c, uint8_t *data, uint8_t len,
482 uint16_t defcipher, uint8_t defauth)
483 {
484 uint16_t i, count;
485 uint8_t wpa_version = 0;
486
487 static unsigned char ms_oui[3] = { 0x00, 0x50, 0xf2 };
488 static unsigned char ieee80211_oui[3] = { 0x00, 0x0f, 0xac };
489
490 data += 2;
491 len -= 2;
492
493 if (!memcmp(data, ms_oui, 3))
494 wpa_version |= 1;
495 else if (!memcmp(data, ieee80211_oui, 3))
496 wpa_version |= 2;
497
498 if (len < 4)
499 {
500 c->group_ciphers |= defcipher;
501 c->pair_ciphers |= defcipher;
502 c->auth_suites |= defauth;
503 return;
504 }
505
506 if (!memcmp(data, ms_oui, 3) || !memcmp(data, ieee80211_oui, 3))
507 iwinfo_parse_rsn_cipher(data[3], &c->group_ciphers);
508
509 data += 4;
510 len -= 4;
511
512 if (len < 2)
513 {
514 c->pair_ciphers |= defcipher;
515 c->auth_suites |= defauth;
516 return;
517 }
518
519 count = data[0] | (data[1] << 8);
520 if (2 + (count * 4) > len)
521 return;
522
523 for (i = 0; i < count; i++)
524 if (!memcmp(data + 2 + (i * 4), ms_oui, 3) ||
525 !memcmp(data + 2 + (i * 4), ieee80211_oui, 3))
526 iwinfo_parse_rsn_cipher(data[2 + (i * 4) + 3], &c->pair_ciphers);
527
528 data += 2 + (count * 4);
529 len -= 2 + (count * 4);
530
531 if (len < 2)
532 {
533 c->auth_suites |= defauth;
534 return;
535 }
536
537 count = data[0] | (data[1] << 8);
538 if (2 + (count * 4) > len)
539 return;
540
541 for (i = 0; i < count; i++)
542 {
543 if (!memcmp(data + 2 + (i * 4), ms_oui, 3) ||
544 !memcmp(data + 2 + (i * 4), ieee80211_oui, 3))
545 {
546 switch (data[2 + (i * 4) + 3])
547 {
548 case 1: /* IEEE 802.1x */
549 c->wpa_version |= wpa_version;
550 c->auth_suites |= IWINFO_KMGMT_8021x;
551 break;
552
553 case 2: /* PSK */
554 c->wpa_version |= wpa_version;
555 c->auth_suites |= IWINFO_KMGMT_PSK;
556 break;
557
558 case 3: /* FT/IEEE 802.1X */
559 case 4: /* FT/PSK */
560 case 5: /* IEEE 802.1X/SHA-256 */
561 case 6: /* PSK/SHA-256 */
562 case 7: /* TPK Handshake */
563 break;
564
565 case 8: /* SAE */
566 c->wpa_version |= 4;
567 c->auth_suites |= IWINFO_KMGMT_SAE;
568 break;
569
570 case 9: /* FT/SAE */
571 case 10: /* undefined */
572 break;
573
574 case 11: /* 802.1x Suite-B */
575 case 12: /* 802.1x Suite-B-192 */
576 case 13: /* FT/802.1x SHA-384 */
577 c->wpa_version |= 4;
578 c->auth_suites |= IWINFO_KMGMT_8021x;
579 break;
580
581 case 14: /* FILS SHA-256 */
582 case 15: /* FILS SHA-384 */
583 case 16: /* FT/FILS SHA-256 */
584 case 17: /* FT/FILS SHA-384 */
585 break;
586
587 case 18: /* OWE */
588 c->wpa_version |= 4;
589 c->auth_suites |= IWINFO_KMGMT_OWE;
590 break;
591 }
592 }
593 }
594
595 data += 2 + (count * 4);
596 len -= 2 + (count * 4);
597 }
598
599 struct uci_section *iwinfo_uci_get_radio(const char *name, const char *type)
600 {
601 struct uci_ptr ptr = {
602 .package = "wireless",
603 .section = name,
604 .flags = (name && *name == '@') ? UCI_LOOKUP_EXTENDED : 0,
605 };
606 const char *opt;
607
608 if (!uci_ctx) {
609 uci_ctx = uci_alloc_context();
610 if (!uci_ctx)
611 return NULL;
612 }
613
614 if (uci_lookup_ptr(uci_ctx, &ptr, NULL, true))
615 return NULL;
616
617 if (!ptr.s || strcmp(ptr.s->type, "wifi-device") != 0)
618 return NULL;
619
620 opt = uci_lookup_option_string(uci_ctx, ptr.s, "type");
621 if (!opt || strcmp(opt, type) != 0)
622 return NULL;
623
624 return ptr.s;
625 }
626
627 void iwinfo_uci_free(void)
628 {
629 if (!uci_ctx)
630 return;
631
632 uci_free_context(uci_ctx);
633 uci_ctx = NULL;
634 }
635
636
637 struct iwinfo_ubus_query_state {
638 const char *ifname;
639 const char *field;
640 size_t len;
641 char *buf;
642 };
643
644 static void iwinfo_ubus_query_cb(struct ubus_request *req, int type,
645 struct blob_attr *msg)
646 {
647 struct iwinfo_ubus_query_state *st = req->priv;
648
649 struct blobmsg_policy pol1[2] = {
650 { "ifname", BLOBMSG_TYPE_STRING },
651 { "config", BLOBMSG_TYPE_TABLE }
652 };
653
654 struct blobmsg_policy pol2 = { st->field, BLOBMSG_TYPE_STRING };
655 struct blob_attr *cur, *cur2, *cur3, *cfg[2], *res;
656 int rem, rem2, rem3;
657
658 blobmsg_for_each_attr(cur, msg, rem) {
659 if (blobmsg_type(cur) != BLOBMSG_TYPE_TABLE)
660 continue;
661
662 blobmsg_for_each_attr(cur2, cur, rem2) {
663 if (blobmsg_type(cur2) != BLOBMSG_TYPE_ARRAY)
664 continue;
665
666 if (strcmp(blobmsg_name(cur2), "interfaces"))
667 continue;
668
669 blobmsg_for_each_attr(cur3, cur2, rem3) {
670 blobmsg_parse(pol1, sizeof(pol1) / sizeof(pol1[0]), cfg,
671 blobmsg_data(cur3), blobmsg_len(cur3));
672
673 if (!cfg[0] || !cfg[1] ||
674 strcmp(blobmsg_get_string(cfg[0]), st->ifname))
675 continue;
676
677 blobmsg_parse(&pol2, 1, &res,
678 blobmsg_data(cfg[1]), blobmsg_len(cfg[1]));
679
680 if (!res)
681 continue;
682
683 strncpy(st->buf, blobmsg_get_string(res), st->len);
684 return;
685 }
686 }
687 }
688 }
689
690 int iwinfo_ubus_query(const char *ifname, const char *field,
691 char *buf, size_t len)
692 {
693 struct iwinfo_ubus_query_state st = {
694 .ifname = ifname,
695 .field = field,
696 .buf = buf,
697 .len = len
698 };
699
700 struct ubus_context *ctx = NULL;
701 struct blob_buf b = { };
702 int rv = -1;
703 uint32_t id;
704
705 blob_buf_init(&b, 0);
706
707 ctx = ubus_connect(NULL);
708
709 if (!ctx)
710 goto out;
711
712 if (ubus_lookup_id(ctx, "network.wireless", &id))
713 goto out;
714
715 if (ubus_invoke(ctx, id, "status", b.head, iwinfo_ubus_query_cb, &st, 250))
716 goto out;
717
718 rv = 0;
719
720 out:
721 if (ctx)
722 ubus_free(ctx);
723
724 blob_buf_free(&b);
725
726 return rv;
727 }