• source navigation  • diff markup  • identifier search  • freetext search  • 

Sources/iwinfo/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 int iwinfo_ifup(const char *ifname)
 81 {
 82         struct ifreq ifr;
 83 
 84         strncpy(ifr.ifr_name, ifname, IFNAMSIZ - 1);
 85 
 86         if (iwinfo_ioctl(SIOCGIFFLAGS, &ifr))
 87                 return 0;
 88 
 89         ifr.ifr_flags |= (IFF_UP | IFF_RUNNING);
 90 
 91         return !iwinfo_ioctl(SIOCSIFFLAGS, &ifr);
 92 }
 93 
 94 int iwinfo_ifdown(const char *ifname)
 95 {
 96         struct ifreq ifr;
 97 
 98         strncpy(ifr.ifr_name, ifname, IFNAMSIZ - 1);
 99 
100         if (iwinfo_ioctl(SIOCGIFFLAGS, &ifr))
101                 return 0;
102 
103         ifr.ifr_flags &= ~(IFF_UP | IFF_RUNNING);
104 
105         return !iwinfo_ioctl(SIOCSIFFLAGS, &ifr);
106 }
107 
108 int iwinfo_ifmac(const char *ifname)
109 {
110         struct ifreq ifr;
111 
112         strncpy(ifr.ifr_name, ifname, IFNAMSIZ - 1);
113 
114         if (iwinfo_ioctl(SIOCGIFHWADDR, &ifr))
115                 return 0;
116 
117         ifr.ifr_hwaddr.sa_data[0] |= 0x02;
118         ifr.ifr_hwaddr.sa_data[1]++;
119         ifr.ifr_hwaddr.sa_data[2]++;
120 
121         return !iwinfo_ioctl(SIOCSIFHWADDR, &ifr);
122 }
123 
124 void iwinfo_close(void)
125 {
126         if (ioctl_socket > -1)
127                 close(ioctl_socket);
128 
129         ioctl_socket = -1;
130 }
131 
132 struct iwinfo_hardware_entry * iwinfo_hardware(struct iwinfo_hardware_id *id)
133 {
134         FILE *db;
135         char buf[256] = { 0 };
136         static struct iwinfo_hardware_entry e;
137         struct iwinfo_hardware_entry *rv = NULL;
138 
139         if (!(db = fopen(IWINFO_HARDWARE_FILE, "r")))
140                 return NULL;
141 
142         while (fgets(buf, sizeof(buf) - 1, db) != NULL)
143         {
144                 memset(&e, 0, sizeof(e));
145 
146                 if (sscanf(buf, "%hx %hx %hx %hx %hd %hd \"%63[^\"]\" \"%63[^\"]\"",
147                                &e.vendor_id, &e.device_id,
148                                &e.subsystem_vendor_id, &e.subsystem_device_id,
149                                &e.txpower_offset, &e.frequency_offset,
150                                e.vendor_name, e.device_name) < 8)
151                         continue;
152 
153                 if ((e.vendor_id != 0xffff) && (e.vendor_id != id->vendor_id))
154                         continue;
155 
156                 if ((e.device_id != 0xffff) && (e.device_id != id->device_id))
157                         continue;
158 
159                 if ((e.subsystem_vendor_id != 0xffff) &&
160                         (e.subsystem_vendor_id != id->subsystem_vendor_id))
161                         continue;
162 
163                 if ((e.subsystem_device_id != 0xffff) &&
164                         (e.subsystem_device_id != id->subsystem_device_id))
165                         continue;
166 
167                 rv = &e;
168                 break;
169         }
170 
171         fclose(db);
172         return rv;
173 }
174 
175 int iwinfo_hardware_id_from_mtd(struct iwinfo_hardware_id *id)
176 {
177         FILE *mtd;
178         uint16_t *bc;
179 
180         int fd, off;
181         unsigned int len;
182         char buf[128];
183 
184         if (!(mtd = fopen("/proc/mtd", "r")))
185                 return -1;
186 
187         while (fgets(buf, sizeof(buf), mtd) != NULL)
188         {
189                 if (fscanf(mtd, "mtd%d: %x %*x %127s", &off, &len, buf) < 3 ||
190                     (strcmp(buf, "\"boardconfig\"") && strcmp(buf, "\"EEPROM\"") &&
191                      strcmp(buf, "\"factory\"")))
192                 {
193                         off = -1;
194                         continue;
195                 }
196 
197                 break;
198         }
199 
200         fclose(mtd);
201 
202         if (off < 0)
203                 return -1;
204 
205         snprintf(buf, sizeof(buf), "/dev/mtdblock%d", off);
206 
207         if ((fd = open(buf, O_RDONLY)) < 0)
208                 return -1;
209 
210         bc = mmap(NULL, len, PROT_READ, MAP_PRIVATE|MAP_LOCKED, fd, 0);
211 
212         if ((void *)bc != MAP_FAILED)
213         {
214                 id->vendor_id = 0;
215                 id->device_id = 0;
216 
217                 for (off = len / 2 - 0x800; off >= 0; off -= 0x800)
218                 {
219                         /* AR531X board data magic */
220                         if ((bc[off] == 0x3533) && (bc[off + 1] == 0x3131))
221                         {
222                                 id->vendor_id = bc[off + 0x7d];
223                                 id->device_id = bc[off + 0x7c];
224                                 id->subsystem_vendor_id = bc[off + 0x84];
225                                 id->subsystem_device_id = bc[off + 0x83];
226                                 break;
227                         }
228 
229                         /* AR5416 EEPROM magic */
230                         else if ((bc[off] == 0xA55A) || (bc[off] == 0x5AA5))
231                         {
232                                 id->vendor_id = bc[off + 0x0D];
233                                 id->device_id = bc[off + 0x0E];
234                                 id->subsystem_vendor_id = bc[off + 0x13];
235                                 id->subsystem_device_id = bc[off + 0x14];
236                                 break;
237                         }
238 
239                         /* Rt3xxx SoC */
240                         else if ((bc[off] == 0x3050) || (bc[off] == 0x5030) ||
241                                  (bc[off] == 0x3051) || (bc[off] == 0x5130) ||
242                                  (bc[off] == 0x3052) || (bc[off] == 0x5230) ||
243                                  (bc[off] == 0x3350) || (bc[off] == 0x5033) ||
244                                  (bc[off] == 0x3352) || (bc[off] == 0x5233) ||
245                                  (bc[off] == 0x3662) || (bc[off] == 0x6236) ||
246                                  (bc[off] == 0x3883) || (bc[off] == 0x8338) ||
247                                  (bc[off] == 0x5350) || (bc[off] == 0x5053))
248                         {
249                                 /* vendor: RaLink */
250                                 id->vendor_id = 0x1814;
251                                 id->subsystem_vendor_id = 0x1814;
252 
253                                 /* device */
254                                 if (((bc[off] & 0xf0) == 0x30) ||
255                                     ((bc[off] & 0xff) == 0x53))
256                                         id->device_id = (bc[off] >> 8) | (bc[off] & 0x00ff) << 8;
257                                 else
258                                         id->device_id = bc[off];
259 
260                                 /* subsystem from EEPROM_NIC_CONF0_RF_TYPE */
261                                 id->subsystem_device_id = (bc[off + 0x1a] & 0x0f00) >> 8;
262                         } else if ((bc[off] == 0x7620) || (bc[off] == 0x2076) ||
263                                    (bc[off] == 0x7628) || (bc[off] == 0x2876) ||
264                                    (bc[off] == 0x7688) || (bc[off] == 0x8876)) {
265                                 /* vendor: MediaTek */
266                                 id->vendor_id = 0x14c3;
267                                 id->subsystem_vendor_id = 0x14c3;
268 
269                                 /* device */
270                                 if ((bc[off] & 0xff) == 0x76)
271                                         id->device_id = (bc[off] >> 8) | (bc[off] & 0x00ff) << 8;
272                                 else
273                                         id->device_id = bc[off];
274 
275                                 /* subsystem from EEPROM_NIC_CONF0_RF_TYPE */
276                                 id->subsystem_device_id = (bc[off + 0x1a] & 0x0f00) >> 8;
277                         }
278                 }
279 
280                 munmap(bc, len);
281         }
282 
283         close(fd);
284 
285         return (id->vendor_id && id->device_id) ? 0 : -1;
286 }
287 
288 static void iwinfo_parse_rsn_cipher(uint8_t idx, uint8_t *ciphers)
289 {
290         switch (idx)
291         {
292                 case 0:
293                         *ciphers |= IWINFO_CIPHER_NONE;
294                         break;
295 
296                 case 1:
297                         *ciphers |= IWINFO_CIPHER_WEP40;
298                         break;
299 
300                 case 2:
301                         *ciphers |= IWINFO_CIPHER_TKIP;
302                         break;
303 
304                 case 3:  /* WRAP */
305                         break;
306 
307                 case 4:
308                         *ciphers |= IWINFO_CIPHER_CCMP;
309                         break;
310 
311                 case 5:
312                         *ciphers |= IWINFO_CIPHER_WEP104;
313                         break;
314 
315                 case 6:  /* AES-128-CMAC */
316                 case 7:  /* No group addressed */
317                 case 8:  /* GCMP */
318                 case 9:  /* GCMP-256 */
319                 case 10: /* CCMP-256 */
320                 case 11: /* BIP-GMAC-128 */
321                 case 12: /* BIP-GMAC-256 */
322                 case 13: /* BIP-CMAC-256 */
323                         break;
324         }
325 }
326 
327 void iwinfo_parse_bss_load(struct iwinfo_scanlist_entry *e, uint8_t *data)
328 {
329         e->has_bss_load = 1;
330         e->station_count = ((data[1] << 8) | data[0]);
331         e->channel_utilization = data[2];
332         e->admission_capacity = ((data[4] << 8) | data[3]);
333 }
334 
335 void iwinfo_parse_rsn(struct iwinfo_crypto_entry *c, uint8_t *data, uint8_t len,
336                                           uint8_t defcipher, uint8_t defauth)
337 {
338         uint16_t i, count;
339         uint8_t wpa_version = 0;
340 
341         static unsigned char ms_oui[3]        = { 0x00, 0x50, 0xf2 };
342         static unsigned char ieee80211_oui[3] = { 0x00, 0x0f, 0xac };
343 
344         data += 2;
345         len -= 2;
346 
347         if (!memcmp(data, ms_oui, 3))
348                 wpa_version |= 1;
349         else if (!memcmp(data, ieee80211_oui, 3))
350                 wpa_version |= 2;
351 
352         if (len < 4)
353         {
354                 c->group_ciphers |= defcipher;
355                 c->pair_ciphers  |= defcipher;
356                 c->auth_suites   |= defauth;
357                 return;
358         }
359 
360         if (!memcmp(data, ms_oui, 3) || !memcmp(data, ieee80211_oui, 3))
361                 iwinfo_parse_rsn_cipher(data[3], &c->group_ciphers);
362 
363         data += 4;
364         len -= 4;
365 
366         if (len < 2)
367         {
368                 c->pair_ciphers |= defcipher;
369                 c->auth_suites  |= defauth;
370                 return;
371         }
372 
373         count = data[0] | (data[1] << 8);
374         if (2 + (count * 4) > len)
375                 return;
376 
377         for (i = 0; i < count; i++)
378                 if (!memcmp(data + 2 + (i * 4), ms_oui, 3) ||
379                     !memcmp(data + 2 + (i * 4), ieee80211_oui, 3))
380                         iwinfo_parse_rsn_cipher(data[2 + (i * 4) + 3], &c->pair_ciphers);
381 
382         data += 2 + (count * 4);
383         len -= 2 + (count * 4);
384 
385         if (len < 2)
386         {
387                 c->auth_suites |= defauth;
388                 return;
389         }
390 
391         count = data[0] | (data[1] << 8);
392         if (2 + (count * 4) > len)
393                 return;
394 
395         for (i = 0; i < count; i++)
396         {
397                 if (!memcmp(data + 2 + (i * 4), ms_oui, 3) ||
398                         !memcmp(data + 2 + (i * 4), ieee80211_oui, 3))
399                 {
400                         switch (data[2 + (i * 4) + 3])
401                         {
402                                 case 1:  /* IEEE 802.1x */
403                                         c->wpa_version |= wpa_version;
404                                         c->auth_suites |= IWINFO_KMGMT_8021x;
405                                         break;
406 
407                                 case 2:  /* PSK */
408                                         c->wpa_version |= wpa_version;
409                                         c->auth_suites |= IWINFO_KMGMT_PSK;
410                                         break;
411 
412                                 case 3:  /* FT/IEEE 802.1X */
413                                 case 4:  /* FT/PSK */
414                                 case 5:  /* IEEE 802.1X/SHA-256 */
415                                 case 6:  /* PSK/SHA-256 */
416                                 case 7:  /* TPK Handshake */
417                                         break;
418 
419                                 case 8:  /* SAE */
420                                         c->wpa_version |= 4;
421                                         c->auth_suites |= IWINFO_KMGMT_SAE;
422                                         break;
423 
424                                 case 9:  /* FT/SAE */
425                                 case 10: /* undefined */
426                                         break;
427 
428                                 case 11: /* 802.1x Suite-B */
429                                 case 12: /* 802.1x Suite-B-192 */
430                                         c->wpa_version |= 4;
431                                         c->auth_suites |= IWINFO_KMGMT_8021x;
432                                         break;
433 
434                                 case 13: /* FT/802.1x SHA-384 */
435                                 case 14: /* FILS SHA-256 */
436                                 case 15: /* FILS SHA-384 */
437                                 case 16: /* FT/FILS SHA-256 */
438                                 case 17: /* FT/FILS SHA-384 */
439                                         break;
440 
441                                 case 18: /* OWE */
442                                         c->wpa_version |= 4;
443                                         c->auth_suites |= IWINFO_KMGMT_OWE;
444                                         break;
445                         }
446                 }
447         }
448 
449         data += 2 + (count * 4);
450         len -= 2 + (count * 4);
451 }
452 
453 struct uci_section *iwinfo_uci_get_radio(const char *name, const char *type)
454 {
455         struct uci_ptr ptr = {
456                 .package = "wireless",
457                 .section = name,
458                 .flags = (name && *name == '@') ? UCI_LOOKUP_EXTENDED : 0,
459         };
460         const char *opt;
461 
462         if (!uci_ctx) {
463                 uci_ctx = uci_alloc_context();
464                 if (!uci_ctx)
465                         return NULL;
466         }
467 
468         if (uci_lookup_ptr(uci_ctx, &ptr, NULL, true))
469                 return NULL;
470 
471         if (!ptr.s || strcmp(ptr.s->type, "wifi-device") != 0)
472                 return NULL;
473 
474         opt = uci_lookup_option_string(uci_ctx, ptr.s, "type");
475         if (!opt || strcmp(opt, type) != 0)
476                 return NULL;
477 
478         return ptr.s;
479 }
480 
481 void iwinfo_uci_free(void)
482 {
483         if (!uci_ctx)
484                 return;
485 
486         uci_free_context(uci_ctx);
487         uci_ctx = NULL;
488 }
489 
490 
491 struct iwinfo_ubus_query_state {
492         const char *ifname;
493         const char *field;
494         size_t len;
495         char *buf;
496 };
497 
498 static void iwinfo_ubus_query_cb(struct ubus_request *req, int type,
499                                  struct blob_attr *msg)
500 {
501         struct iwinfo_ubus_query_state *st = req->priv;
502 
503         struct blobmsg_policy pol1[2] = {
504                 { "ifname",  BLOBMSG_TYPE_STRING },
505                 { "config",  BLOBMSG_TYPE_TABLE }
506         };
507 
508         struct blobmsg_policy pol2 = { st->field, BLOBMSG_TYPE_STRING };
509         struct blob_attr *cur, *cur2, *cur3, *cfg[2], *res;
510         int rem, rem2, rem3;
511 
512         blobmsg_for_each_attr(cur, msg, rem) {
513                 if (blobmsg_type(cur) != BLOBMSG_TYPE_TABLE)
514                         continue;
515 
516                 blobmsg_for_each_attr(cur2, cur, rem2) {
517                         if (blobmsg_type(cur2) != BLOBMSG_TYPE_ARRAY)
518                                 continue;
519 
520                         if (strcmp(blobmsg_name(cur2), "interfaces"))
521                                 continue;
522 
523                         blobmsg_for_each_attr(cur3, cur2, rem3) {
524                                 blobmsg_parse(pol1, sizeof(pol1) / sizeof(pol1[0]), cfg,
525                                               blobmsg_data(cur3), blobmsg_len(cur3));
526 
527                                 if (!cfg[0] || !cfg[1] ||
528                                     strcmp(blobmsg_get_string(cfg[0]), st->ifname))
529                                         continue;
530 
531                                 blobmsg_parse(&pol2, 1, &res,
532                                               blobmsg_data(cfg[1]), blobmsg_len(cfg[1]));
533 
534                                 if (!res)
535                                         continue;
536 
537                                 strncpy(st->buf, blobmsg_get_string(res), st->len);
538                                 return;
539                         }
540                 }
541         }
542 }
543 
544 int iwinfo_ubus_query(const char *ifname, const char *field,
545                       char *buf, size_t len)
546 {
547         struct iwinfo_ubus_query_state st = {
548                 .ifname = ifname,
549                 .field = field,
550                 .buf = buf,
551                 .len = len
552         };
553 
554         struct ubus_context *ctx = NULL;
555         struct blob_buf b = { };
556         int rv = -1;
557         uint32_t id;
558 
559         blob_buf_init(&b, 0);
560 
561         ctx = ubus_connect(NULL);
562 
563         if (!ctx)
564                 goto out;
565 
566         if (ubus_lookup_id(ctx, "network.wireless", &id))
567                 goto out;
568 
569         if (ubus_invoke(ctx, id, "status", b.head, iwinfo_ubus_query_cb, &st, 250))
570                 goto out;
571 
572         rv = 0;
573 
574 out:
575         if (ctx)
576                 ubus_free(ctx);
577 
578         blob_buf_free(&b);
579 
580         return rv;
581 }
582 

This page was automatically generated by LXR 0.3.1.  •  OpenWrt