ticonfig.c

   1 // Adapted for vomp by Chris Tallon by changing "int main" to "int ticonfig_main"
   2
   3 /*
   4  *  Copyright (C) 2006, Jon Gettler
   5  *  http://www.mvpmc.org/
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  20 */
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <unistd.h>
  25 #include <string.h>
  26 #include <getopt.h>
  27 #include <netdb.h>
  28 #include <sys/ioctl.h>
  29 #include <net/if.h>
  30 #include <net/if_arp.h>
  31 #include <netinet/in.h>
  32 #include <errno.h>
  33 #include <fcntl.h>
  34
  35 #define DEVNAME   "eth1"
  36
  37 typedef struct {
  38   unsigned char device[16];
  39   unsigned long arg2;
  40   unsigned long arg3;
  41   unsigned long arg4;
  42   void *ptr;
  43 } ti_dev_t;
  44
  45 typedef struct {
  46   unsigned int len;
  47   char name[128];
  48 } ti_name_t;
  49
  50 typedef struct {
  51   unsigned int unknown[3];
  52   unsigned int len;
  53   char name[36];
  54   unsigned int unknown2[27];
  55 } ti_ssid_t;
  56
  57 typedef struct {
  58   unsigned int count;
  59   ti_ssid_t ssid[32];
  60 } ti_ssid_list_t;
  61
  62 static int sockfd = -1;
  63 static int config_started = 0;
  64 static char default_ssid[128];
  65 static char default_wep[128];
  66 static ti_ssid_list_t slist;
  67 static int verbose = 0;
  68
  69 static struct option opts[] = {
  70   { "help", no_argument, 0, 'h' },
  71   { "probe", no_argument, 0, 'p' },
  72   { "ssid", required_argument, 0, 's' },
  73   { "verbose", no_argument, 0, 'v' },
  74   { "wep", required_argument, 0, 'w' },
  75   { 0, 0, 0, 0 }
  76 };
  77
  78 static void
  79 print_help(char *prog)
  80 {
  81   printf("Usage: %s <options>\n", prog);
  82   printf("\t-h      \tprint this help\n");
  83   printf("\t-p      \tprobe for wireless networks\n");
  84   printf("\t-s ssid \tSSID to use\n");
  85   printf("\t-v      \tverbose\n");
  86 }
  87
  88 static int
  89 read_vpd(void)
  90 {
  91   int fd, i = 0;
  92   short *mtd;
  93   char *vpd, *network, *wep;
  94   char path[64];
  95
  96   if ((fd=open("/proc/mtd", O_RDONLY)) > 0) {
  97     FILE *f = fdopen(fd, "r");
  98     char line[64];
  99     /* read the header */
 100     fgets(line, sizeof(line), f);
 101     /* read each mtd entry */
 102     while (fgets(line, sizeof(line), f) != NULL) {
 103       if (strstr(line, " VPD") != NULL) {
 104         break;
 105       }
 106       i++;
 107     }
 108     fclose(f);
 109     close(fd);
 110   }
 111
 112   if (i != 2) {
 113     fprintf(stderr, "not running on a wireless MVP!\n");
 114     return -1;
 115   }
 116
 117   snprintf(path, sizeof(path), "/dev/mtd%d", i);
 118
 119   if ((fd=open(path, O_RDONLY)) < 0)
 120     return -1;
 121
 122   if ((mtd=malloc(65536)) == NULL) {
 123     close(fd);
 124     return -1;
 125   }
 126
 127   if (read(fd, mtd, 65536) != 65536) {
 128     close(fd);
 129     return -1;
 130   }
 131
 132   vpd = (char*)mtd;
 133
 134   close(fd);
 135
 136   network = vpd+0x2008;
 137   wep = vpd+0x2035;
 138
 139   if (network[0] != '\0') {
 140     if (verbose)
 141       printf("Default wireless network: '%s'\n", network);
 142     strcpy(default_ssid, network);
 143   } else {
 144     if (verbose)
 145       printf("No default wireless network found in flash\n");
 146   }
 147
 148   if (wep[0] != '\0') {
 149     if (verbose)
 150       printf("WEP key found!\n");
 151     strcpy(default_wep, wep);
 152   } else {
 153     if (verbose)
 154       printf("WEP key not found!\n");
 155   }
 156
 157   if (vpd[0x3000] != '\0') {
 158     if (verbose)
 159       printf("Default server: %d.%d.%d.%d\n",
 160              vpd[0x3000], vpd[0x3001],
 161              vpd[0x3002], vpd[0x3003]);
 162   } else {
 163     if (verbose)
 164       printf("No default server found in flash\n");
 165   }
 166
 167   free(mtd);
 168
 169   return 0;
 170 }
 171 static int
 172 init_device(int fd, char *name)
 173 {
 174   ti_dev_t dev;
 175   ti_name_t ssid;
 176
 177   memset(&dev, 0, sizeof(dev));
 178   memset(&ssid, 0, sizeof(ssid));
 179
 180   strcpy(dev.device, name);
 181   dev.arg2 = 0x00223834;
 182   dev.arg3 = 0x2;
 183   dev.arg4 = 0xd;
 184   dev.ptr = &ssid;
 185
 186   if (ioctl(fd, SIOCDEVPRIVATE, &dev) != 0) {
 187     perror("ioctl(SIOCDEVPRIVATE)");
 188     return -1;
 189   }
 190
 191   if (verbose)
 192     printf("device initialized!\n");
 193
 194   return 0;
 195 }
 196
 197 static int
 198 start_config_manager(int fd, char *name)
 199 {
 200   ti_dev_t dev;
 201   unsigned long buf[256];
 202
 203   memset(&dev, 0, sizeof(dev));
 204   strcpy(dev.device, name);
 205   dev.arg2 = 0x0022381c;
 206   dev.arg3 = 0x2;
 207   dev.arg4 = 0x4;
 208   dev.ptr = (void*)0x1;
 209
 210   if (ioctl(fd, SIOCDEVPRIVATE, &dev) != 0) {
 211     if (errno == EALREADY) {
 212       if (verbose)
 213         printf("config manager already running!\n");
 214       return 0;
 215     }
 216     perror("ioctl(SIOCDEVPRIVATE)");
 217     return -1;
 218   }
 219
 220   if (verbose)
 221     printf("config manager started!\n");
 222
 223   config_started = 1;
 224
 225   memset(&dev, 0, sizeof(dev));
 226   strcpy(dev.device, DEVNAME);
 227   dev.arg2 = 0x00223818;
 228   dev.arg3 = 0x1;
 229   dev.arg4 = 0x4;
 230   dev.ptr = (void*)0x0;
 231
 232   if (ioctl(sockfd, SIOCDEVPRIVATE+1, &dev) != 0) {
 233     perror("ioctl(SIOCDEVPRIVATE+1)");
 234     return -1;
 235   }
 236
 237   memset(&dev, 0, sizeof(dev));
 238   strcpy(dev.device, DEVNAME);
 239   dev.arg2 = 0x00222018;
 240   dev.arg3 = 0x2;
 241   dev.arg4 = 0x24;
 242   dev.ptr = (void*)buf;
 243
 244   buf[0] = 0x00000008;
 245   memcpy(buf+1, "NON-SSID", 8);
 246   buf[3] = 0x00000000;
 247   buf[4] = 0x00000000;
 248   buf[5] = 0x00000000;
 249   buf[6] = 0x00000000;
 250   buf[7] = 0x00000000;
 251
 252   if (ioctl(sockfd, SIOCDEVPRIVATE, &dev) != 0) {
 253     perror("ioctl(SIOCDEVPRIVATE)");
 254     return -1;
 255   }
 256
 257   return 0;
 258 }
 259
 260 static int
 261 up_device(int fd, char *name)
 262 {
 263   ti_dev_t dev;
 264   unsigned long buf[256];
 265
 266   if (verbose)
 267     printf("Bringing up eth1...\n");
 268
 269   memset(&dev, 0, sizeof(dev));
 270   memset(&buf, 0, sizeof(buf));
 271   strcpy(dev.device, DEVNAME);
 272   dev.arg2 = 0x00224420;
 273   dev.arg3 = 0x1;
 274   dev.arg4 = 0x75;
 275   dev.ptr = (void*)buf;
 276
 277   if (ioctl(sockfd, SIOCDEVPRIVATE+1, &dev) != 0) {
 278     perror("ioctl(SIOCDEVPRIVATE+1)");
 279     return -1;
 280   }
 281
 282   memset(&dev, 0, sizeof(dev));
 283   memset(&buf, 0, sizeof(buf));
 284   strcpy(dev.device, DEVNAME);
 285   dev.arg2 = 0x00222018;
 286   dev.arg3 = 0x2;
 287   dev.arg4 = 0x24;
 288   dev.ptr = (void*)buf;
 289
 290   buf[0] = strlen(default_ssid);
 291   strcpy((char*)(&buf[1]), default_ssid);
 292
 293   if (verbose)
 294     printf("Using SSID: '%s'\n", default_ssid);
 295
 296   if (ioctl(sockfd, SIOCDEVPRIVATE, &dev) != 0) {
 297     perror("ioctl(SIOCDEVPRIVATE)");
 298     return -1;
 299   }
 300
 301   memset(&dev, 0, sizeof(dev));
 302   memset(&buf, 0, sizeof(buf));
 303   strcpy(dev.device, DEVNAME);
 304   dev.arg2 = 0x00224420;
 305   dev.arg3 = 0x1;
 306   dev.arg4 = 0x75;
 307   dev.ptr = (void*)buf;
 308
 309   if (ioctl(sockfd, SIOCDEVPRIVATE+1, &dev) != 0) {
 310     perror("ioctl(SIOCDEVPRIVATE+1)");
 311     return -1;
 312   }
 313
 314   memset(&dev, 0, sizeof(dev));
 315   strcpy(dev.device, DEVNAME);
 316   dev.arg2 = 0x00223028;
 317   dev.arg3 = 0x1;
 318   dev.arg4 = 0x4;
 319
 320   if (ioctl(sockfd, SIOCDEVPRIVATE+1, &dev) != 0) {
 321     perror("ioctl(SIOCDEVPRIVATE+1)");
 322     return -1;
 323   }
 324
 325 #if 0
 326   if (verbose) {
 327     printf("Signal strength: %ddb\n", (int)dev.ptr);
 328     printf("Signal strength: %p\n", dev.ptr);
 329   }
 330 #endif
 331
 332   return 0;
 333 }
 334
 335 static void
 336 wep_copy(char *buf, char *key)
 337 {
 338   int i, len;
 339
 340   len = strlen(key) / 2;
 341
 342   for (i=0; i<len; i++) {
 343     int h, l;
 344
 345     h = key[i*2];
 346     l = key[i*2+1];
 347
 348     if ((h>='0') && (h<='9')) {
 349       h = h - '0';
 350     } else {
 351       h = h - 'A' + 10;
 352     }
 353     if ((l>='0') && (l<='9')) {
 354       l = l - '0';
 355     } else {
 356       l = l - 'A' + 10;
 357     }
 358
 359     buf[i] = (h << 4) | l;
 360   }
 361 }
 362
 363 static int
 364 up_device_wep(int fd, char *name)
 365 {
 366   ti_dev_t dev;
 367   unsigned long buf[256];
 368
 369   if (verbose)
 370     printf("Bringing up WEP-enabled eth1...\n");
 371
 372   if (init_device(sockfd, DEVNAME) < 0)
 373     return -1;
 374
 375   if (start_config_manager(sockfd, DEVNAME) < 0)
 376     return -1;
 377
 378 #if 0
 379   memset(&dev, 0, sizeof(dev));
 380   memset(&buf, 0, sizeof(buf));
 381   strcpy(dev.device, DEVNAME);
 382   dev.arg2 = 0x00224420;
 383   dev.arg3 = 0x1;
 384   dev.arg4 = 0x75;
 385   dev.ptr = (void*)buf;
 386   strcpy((char*)buf, default_ssid);
 387
 388   if (ioctl(sockfd, SIOCDEVPRIVATE+1, &dev) != 0) {
 389     perror("ioctl(SIOCDEVPRIVATE+1)");
 390     return -1;
 391   }
 392
 393   memset(&dev, 0, sizeof(dev));
 394   memset(&buf, 0, sizeof(buf));
 395   strcpy(dev.device, DEVNAME);
 396   dev.arg2 = 0x00222018;
 397   dev.arg3 = 0x2;
 398   dev.arg4 = 0x24;
 399   dev.ptr = (void*)buf;
 400
 401   buf[0] = strlen(default_ssid);
 402   strcpy((char*)(&buf[1]), default_ssid);
 403
 404   if (verbose)
 405     printf("Using SSID: '%s'\n", default_ssid);
 406
 407   if (ioctl(sockfd, SIOCDEVPRIVATE, &dev) != 0) {
 408     perror("ioctl(SIOCDEVPRIVATE)");
 409     return -1;
 410   }
 411 #endif
 412
 413   memset(&dev, 0, sizeof(dev));
 414   strcpy(dev.device, DEVNAME);
 415   dev.arg2 = 0x00223410;
 416   dev.arg3 = 0x2;
 417   dev.arg4 = 0x4;
 418
 419   if (ioctl(sockfd, SIOCDEVPRIVATE, &dev) != 0) {
 420     perror("ioctl(SIOCDEVPRIVATE)");
 421     return -1;
 422   }
 423
 424   memset(&dev, 0, sizeof(dev));
 425   strcpy(dev.device, DEVNAME);
 426   dev.arg2 = 0x00223488;
 427   dev.arg3 = 0x2;
 428   dev.arg4 = 0x4;
 429
 430   if (ioctl(sockfd, SIOCDEVPRIVATE, &dev) != 0) {
 431     /*
 432      * XXX: this error seems normal
 433      */
 434 #if 0
 435     perror("ioctl(SIOCDEVPRIVATE)");
 436     return -1;
 437 #endif
 438   }
 439
 440   memset(&dev, 0, sizeof(dev));
 441   memset(&buf, 0, sizeof(buf));
 442   strcpy(dev.device, DEVNAME);
 443   dev.arg2 = 0x00223404;
 444   dev.arg3 = 0x2;
 445   dev.arg4 = 0x2c;
 446   dev.ptr = (void*)buf;
 447
 448   buf[0] = 0x2c;
 449   buf[1] = 0x80000000;
 450   buf[2] = 0xd;
 451   wep_copy((char*)(buf+3), default_wep);
 452
 453   if (ioctl(sockfd, SIOCDEVPRIVATE, &dev) != 0) {
 454     perror("ioctl(SIOCDEVPRIVATE)");
 455     return -1;
 456   }
 457
 458   memset(&dev, 0, sizeof(dev));
 459   memset(&buf, 0, sizeof(buf));
 460   strcpy(dev.device, DEVNAME);
 461   dev.arg2 = 0x00222018;
 462   dev.arg3 = 0x2;
 463   dev.arg4 = 0x24;
 464   dev.ptr = (void*)buf;
 465
 466   buf[0] = strlen(default_ssid);
 467   strcpy((char*)(&buf[1]), default_ssid);
 468
 469   if (verbose)
 470     printf("Using SSID: '%s'\n", default_ssid);
 471
 472   if (ioctl(sockfd, SIOCDEVPRIVATE, &dev) != 0) {
 473     perror("ioctl(SIOCDEVPRIVATE)");
 474     return -1;
 475   }
 476
 477   memset(&dev, 0, sizeof(dev));
 478   memset(&buf, 0, sizeof(buf));
 479   strcpy(dev.device, DEVNAME);
 480   dev.arg2 = 0x00224420;
 481   dev.arg3 = 0x1;
 482   dev.arg4 = 0x75;
 483   dev.ptr = (void*)buf;
 484   strcpy((char*)(&buf[0]), default_ssid);
 485
 486   if (ioctl(sockfd, SIOCDEVPRIVATE+1, &dev) != 0) {
 487     perror("ioctl(SIOCDEVPRIVATE+1)");
 488     return -1;
 489   }
 490
 491   memset(&dev, 0, sizeof(dev));
 492   memset(&buf, 0, sizeof(buf));
 493   strcpy(dev.device, DEVNAME);
 494   dev.arg2 = 0x00224420;
 495   dev.arg3 = 0x1;
 496   dev.arg4 = 0x75;
 497   dev.ptr = (void*)buf;
 498
 499   if (ioctl(sockfd, SIOCDEVPRIVATE+1, &dev) != 0) {
 500     perror("ioctl(SIOCDEVPRIVATE+1)");
 501     return -1;
 502   }
 503
 504 #if 0
 505   memset(&dev, 0, sizeof(dev));
 506   strcpy(dev.device, DEVNAME);
 507   dev.arg2 = 0x00223028;
 508   dev.arg3 = 0x1;
 509   dev.arg4 = 0x4;
 510
 511   if (ioctl(sockfd, SIOCDEVPRIVATE+1, &dev) != 0) {
 512     perror("ioctl(SIOCDEVPRIVATE+1)");
 513     return -1;
 514   }
 515 #endif
 516
 517   return 0;
 518 }
 519
 520 int
 521 get_ssid_list(int fd, char *name)
 522 {
 523   ti_dev_t dev;
 524   int n;
 525
 526   memset(&dev, 0, sizeof(dev));
 527   strcpy(dev.device, name);
 528   dev.arg2 = 0x00222c20;
 529
 530   if (ioctl(fd, SIOCDEVPRIVATE, &dev) != 0) {
 531     perror("ioctl(SIOCDEVPRIVATE)");
 532     return -1;
 533   }
 534
 535   memset(&dev, 0, sizeof(dev));
 536   strcpy(dev.device, name);
 537   dev.arg2 = 0x00222c1c;
 538   dev.arg3 = 0x1;
 539   dev.arg4 = 0x4;
 540
 541   if (ioctl(fd, SIOCDEVPRIVATE, &dev) != 0) {
 542     perror("ioctl(SIOCDEVPRIVATE)");
 543     return -1;
 544   }
 545
 546   memset(&dev, 0, sizeof(dev));
 547   memset(&slist, 0, sizeof(slist));
 548   strcpy(dev.device, name);
 549   dev.arg2 = 0x0022200c;
 550   dev.arg3 = 0x1;
 551   dev.arg4 = 0x2710;
 552   dev.ptr = (void*)&slist;
 553
 554   if (ioctl(fd, SIOCDEVPRIVATE, &dev) != 0) {
 555     perror("ioctl(SIOCDEVPRIVATE)");
 556     return -1;
 557   }
 558
 559   n = slist.count;
 560
 561   if ((n > 0) && verbose)
 562     printf("Found %d wireless networks!\n", n);
 563
 564   return n;
 565 }
 566
 567 static int
 568 init(void)
 569 {
 570   struct ifreq ifr;
 571   ti_dev_t dev;
 572
 573   strncpy(ifr.ifr_name, DEVNAME, IFNAMSIZ);
 574
 575   if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
 576     perror("socket()");
 577     return -1;
 578   }
 579
 580   if (ioctl(sockfd, SIOCGIFFLAGS, &ifr) < 0) {
 581     perror("ioctl(SIOCGIFFLAGS)");
 582     return -1;
 583   }
 584
 585   if (ioctl(sockfd, SIOCSIFFLAGS, &ifr) < 0) {
 586     perror("ioctl(SIOCSIFFLAGS)");
 587     return -1;
 588   }
 589
 590   if (init_device(sockfd, DEVNAME) < 0)
 591     return -1;
 592
 593   if (start_config_manager(sockfd, DEVNAME) < 0)
 594     return -1;
 595
 596   memset(&dev, 0, sizeof(dev));
 597   strcpy(dev.device, DEVNAME);
 598   dev.arg2 = 0x00222020;
 599
 600   if (ioctl(sockfd, SIOCDEVPRIVATE, &dev) != 0) {
 601     perror("ioctl(SIOCDEVPRIVATE)");
 602     return -1;
 603   }
 604
 605   memset(&dev, 0, sizeof(dev));
 606   strcpy(dev.device, DEVNAME);
 607   dev.arg2 = 0x00222c20;
 608
 609   if (ioctl(sockfd, SIOCDEVPRIVATE, &dev) != 0) {
 610     perror("ioctl(SIOCDEVPRIVATE)");
 611     return -1;
 612   }
 613
 614   return 0;
 615 }
 616
 617 int
 618 ticonfig_main(int argc, char **argv)
 619 {
 620   int c, n, i;
 621   int opt_index;
 622   int do_probe = 0;
 623   char *ssid = NULL, *key = NULL;
 624   int found = 0;
 625   int with_wep = -1;
 626
 627   while ((c=getopt_long(argc, argv,
 628             "hps:w:v", opts, &opt_index)) != -1) {
 629     switch (c) {
 630     case 'h':
 631       print_help(argv[0]);
 632       exit(0);
 633       break;
 634     case 'p':
 635       do_probe = 1;
 636       break;
 637     case 's':
 638       ssid = strdup(optarg);
 639       break;
 640     case 'w':
 641       if (strcasecmp(optarg, "off") == 0) {
 642         with_wep = 0;
 643       } else if (strcasecmp(optarg, "on") == 0) {
 644         with_wep = 1;
 645       } else {
 646         with_wep = 1;
 647         key = strdup(optarg);
 648       }
 649       break;
 650     case 'v':
 651       verbose = 1;
 652       break;
 653     default:
 654       print_help(argv[0]);
 655       exit(1);
 656       break;
 657     }
 658   }
 659
 660   if (read_vpd() != 0) {
 661     fprintf(stderr, "VPD read failed!\n");
 662     exit(1);
 663   }
 664   if (key)
 665     strcpy(default_wep, key);
 666
 667   if (init() != 0) {
 668     fprintf(stderr, "initialization failed!\n");
 669     exit(1);
 670   }
 671
 672   n = get_ssid_list(sockfd, DEVNAME);
 673
 674   /*
 675    * After starting the config manager, we may need to wait a bit...
 676    */
 677   if ((n == 0) && (config_started == 1)) {
 678     sleep(1);
 679     n = get_ssid_list(sockfd, DEVNAME);
 680   }
 681
 682   if (n < 0) {
 683     fprintf(stderr, "SSID probe failed!\n");
 684     exit(1);
 685   } else if (n == 0) {
 686     fprintf(stderr, "no wireless networks found!\n");
 687     exit(1);
 688   }
 689
 690   if (do_probe) {
 691     for (i=0; i<n; i++) {
 692       printf("Found SSID: '%s'\n", slist.ssid[i].name);
 693     }
 694     exit(0);
 695   }
 696
 697   if (ssid) {
 698     strcpy(default_ssid, ssid);
 699   }
 700
 701   for (i=0; i<n; i++) {
 702     if (strcmp(default_ssid, slist.ssid[i].name) == 0)
 703       found = 1;
 704   }
 705
 706   if (!found) {
 707     printf("Warning: SSID '%s' not found during probe!\n",
 708            default_ssid);
 709   }
 710
 711   if ((default_wep[0] == '\0') || (with_wep == 0)) {
 712     if (up_device(sockfd, DEVNAME) < 0) {
 713       fprintf(stderr, "device bringup failed!\n");
 714       exit(1);
 715     }
 716     printf("wireless network enabled: SSID '%s' without WEP\n",
 717            default_ssid);
 718   } else {
 719     if (up_device_wep(sockfd, DEVNAME) < 0) {
 720       fprintf(stderr, "device bringup failed!\n");
 721       exit(1);
 722     }
 723     printf("wireless network enabled: SSID '%s' with WEP\n",
 724            default_ssid);
 725   }
 726
 727   return 0;
 728 }