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 void iwinfo_parse_rsn(struct iwinfo_crypto_entry *c, uint8_t *data, uint8_t len,
 289                                           uint8_t defcipher, uint8_t defauth)
 290 {
 291         uint16_t i, count;
 292
 293         static unsigned char ms_oui[3]        = { 0x00, 0x50, 0xf2 };
 294         static unsigned char ieee80211_oui[3] = { 0x00, 0x0f, 0xac };
 295
 296         data += 2;
 297         len -= 2;
 298
 299         if (!memcmp(data, ms_oui, 3))
 300                 c->wpa_version += 1;
 301         else if (!memcmp(data, ieee80211_oui, 3))
 302                 c->wpa_version += 2;
 303
 304         if (len < 4)
 305         {
 306                 c->group_ciphers |= defcipher;
 307                 c->pair_ciphers  |= defcipher;
 308                 c->auth_suites   |= defauth;
 309                 return;
 310         }
 311
 312         if (!memcmp(data, ms_oui, 3) || !memcmp(data, ieee80211_oui, 3))
 313         {
 314                 switch (data[3])
 315                 {
 316                         case 1: c->group_ciphers |= IWINFO_CIPHER_WEP40;  break;
 317                         case 2: c->group_ciphers |= IWINFO_CIPHER_TKIP;   break;
 318                         case 4: c->group_ciphers |= IWINFO_CIPHER_CCMP;   break;
 319                         case 5: c->group_ciphers |= IWINFO_CIPHER_WEP104; break;
 320                         case 6:  /* AES-128-CMAC */ break;
 321                         default: /* proprietary */  break;
 322                 }
 323         }
 324
 325         data += 4;
 326         len -= 4;
 327
 328         if (len < 2)
 329         {
 330                 c->pair_ciphers |= defcipher;
 331                 c->auth_suites  |= defauth;
 332                 return;
 333         }
 334
 335         count = data[0] | (data[1] << 8);
 336         if (2 + (count * 4) > len)
 337                 return;
 338
 339         for (i = 0; i < count; i++)
 340         {
 341                 if (!memcmp(data + 2 + (i * 4), ms_oui, 3) ||
 342                         !memcmp(data + 2 + (i * 4), ieee80211_oui, 3))
 343                 {
 344                         switch (data[2 + (i * 4) + 3])
 345                         {
 346                                 case 1: c->pair_ciphers |= IWINFO_CIPHER_WEP40;  break;
 347                                 case 2: c->pair_ciphers |= IWINFO_CIPHER_TKIP;   break;
 348                                 case 4: c->pair_ciphers |= IWINFO_CIPHER_CCMP;   break;
 349                                 case 5: c->pair_ciphers |= IWINFO_CIPHER_WEP104; break;
 350                                 case 6:  /* AES-128-CMAC */ break;
 351                                 default: /* proprietary */  break;
 352                         }
 353                 }
 354         }
 355
 356         data += 2 + (count * 4);
 357         len -= 2 + (count * 4);
 358
 359         if (len < 2)
 360         {
 361                 c->auth_suites |= defauth;
 362                 return;
 363         }
 364
 365         count = data[0] | (data[1] << 8);
 366         if (2 + (count * 4) > len)
 367                 return;
 368
 369         for (i = 0; i < count; i++)
 370         {
 371                 if (!memcmp(data + 2 + (i * 4), ms_oui, 3) ||
 372                         !memcmp(data + 2 + (i * 4), ieee80211_oui, 3))
 373                 {
 374                         switch (data[2 + (i * 4) + 3])
 375                         {
 376                                 case 1: c->auth_suites |= IWINFO_KMGMT_8021x; break;
 377                                 case 2: c->auth_suites |= IWINFO_KMGMT_PSK;   break;
 378                                 case 3:  /* FT/IEEE 802.1X */                 break;
 379                                 case 4:  /* FT/PSK */                         break;
 380                                 case 5:  /* IEEE 802.1X/SHA-256 */            break;
 381                                 case 6:  /* PSK/SHA-256 */                    break;
 382                                 default: /* proprietary */                    break;
 383                         }
 384                 }
 385         }
 386
 387         data += 2 + (count * 4);
 388         len -= 2 + (count * 4);
 389 }
 390
 391 struct uci_section *iwinfo_uci_get_radio(const char *name, const char *type)
 392 {
 393         struct uci_ptr ptr = {
 394                 .package = "wireless",
 395                 .section = name,
 396                 .flags = (name && *name == '@') ? UCI_LOOKUP_EXTENDED : 0,
 397         };
 398         const char *opt;
 399
 400         if (!uci_ctx) {
 401                 uci_ctx = uci_alloc_context();
 402                 if (!uci_ctx)
 403                         return NULL;
 404         }
 405
 406         if (uci_lookup_ptr(uci_ctx, &ptr, NULL, true))
 407                 return NULL;
 408
 409         if (!ptr.s || strcmp(ptr.s->type, "wifi-device") != 0)
 410                 return NULL;
 411
 412         opt = uci_lookup_option_string(uci_ctx, ptr.s, "type");
 413         if (!opt || strcmp(opt, type) != 0)
 414                 return NULL;
 415
 416         return ptr.s;
 417 }
 418
 419 void iwinfo_uci_free(void)
 420 {
 421         if (!uci_ctx)
 422                 return;
 423
 424         uci_free_context(uci_ctx);
 425         uci_ctx = NULL;
 426 }
 427
 428
 429 struct iwinfo_ubus_query_state {
 430         const char *ifname;
 431         const char *field;
 432         size_t len;
 433         char *buf;
 434 };
 435
 436 static void iwinfo_ubus_query_cb(struct ubus_request *req, int type,
 437                                  struct blob_attr *msg)
 438 {
 439         struct iwinfo_ubus_query_state *st = req->priv;
 440
 441         struct blobmsg_policy pol1[2] = {
 442                 { "ifname",  BLOBMSG_TYPE_STRING },
 443                 { "config",  BLOBMSG_TYPE_TABLE }
 444         };
 445
 446         struct blobmsg_policy pol2 = { st->field, BLOBMSG_TYPE_STRING };
 447         struct blob_attr *cur, *cur2, *cur3, *cfg[2], *res;
 448         int rem, rem2, rem3;
 449
 450         blobmsg_for_each_attr(cur, msg, rem) {
 451                 if (blobmsg_type(cur) != BLOBMSG_TYPE_TABLE)
 452                         continue;
 453
 454                 blobmsg_for_each_attr(cur2, cur, rem2) {
 455                         if (blobmsg_type(cur2) != BLOBMSG_TYPE_ARRAY)
 456                                 continue;
 457
 458                         if (strcmp(blobmsg_name(cur2), "interfaces"))
 459                                 continue;
 460
 461                         blobmsg_for_each_attr(cur3, cur2, rem3) {
 462                                 blobmsg_parse(pol1, sizeof(pol1) / sizeof(pol1[0]), cfg,
 463                                               blobmsg_data(cur3), blobmsg_len(cur3));
 464
 465                                 if (!cfg[0] || !cfg[1] ||
 466                                     strcmp(blobmsg_get_string(cfg[0]), st->ifname))
 467                                         continue;
 468
 469                                 blobmsg_parse(&pol2, 1, &res,
 470                                               blobmsg_data(cfg[1]), blobmsg_len(cfg[1]));
 471
 472                                 if (!res)
 473                                         continue;
 474
 475                                 strncpy(st->buf, blobmsg_get_string(res), st->len);
 476                                 return;
 477                         }
 478                 }
 479         }
 480 }
 481
 482 int iwinfo_ubus_query(const char *ifname, const char *field,
 483                       char *buf, size_t len)
 484 {
 485         struct iwinfo_ubus_query_state st = {
 486                 .ifname = ifname,
 487                 .field = field,
 488                 .buf = buf,
 489                 .len = len
 490         };
 491
 492         struct ubus_context *ctx = NULL;
 493         struct blob_buf b = { };
 494         int rv = -1;
 495         uint32_t id;
 496
 497         blob_buf_init(&b, 0);
 498
 499         ctx = ubus_connect(NULL);
 500
 501         if (!ctx)
 502                 goto out;
 503
 504         if (ubus_lookup_id(ctx, "network.wireless", &id))
 505                 goto out;
 506
 507         if (ubus_invoke(ctx, id, "status", b.head, iwinfo_ubus_query_cb, &st, 250))
 508                 goto out;
 509
 510         rv = 0;
 511
 512 out:
 513         if (ctx)
 514                 ubus_free(ctx);
 515
 516         blob_buf_free(&b);
 517
 518         return rv;
 519 }