]> git.vomp.tv Git - vompclient.git/blob - ticonfig.c
Add some VT switching and locking
[vompclient.git] / 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 }