eyefi-config.c

   1 /*
   2  * eyefitest.c
   3  *
   4  * Copyright (C) 2008 Dave Hansen <dave@sr71.net>
   5  *
   6  * This software may be redistributed and/or modified under the terms of
   7  * the GNU General Public License ("GPL") version 2 as published by the
   8  * Free Software Foundation.
   9  */
  10
  11 #include <assert.h>
  12 #include <string.h>
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <unistd.h>
  16 #include <getopt.h>
  17 #include <sys/types.h>
  18 #include <sys/stat.h>
  19 #include <fcntl.h>
  20 #include <errno.h>
  21
  22 #include "eyefi-config.h"
  23
  24 int debug_level = 1;
  25 #define debug_printf(level, args...) do {       \
  26         if ((level) <= debug_level)             \
  27                 fprintf(stderr, ## args);       \
  28         } while(0)
  29
  30 #define O_DIRECT        00040000        /* direct disk access hint */
  31
  32 enum eyefi_file {
  33         REQC,
  34         REQM,
  35         RSPC,
  36         RSPM
  37 };
  38
  39 #define PATHNAME_MAX 4096
  40 char eyefi_mount[PATHNAME_MAX]; // PATH_MAX anyone?
  41 static char *eyefi_file_name(enum eyefi_file file)
  42 {
  43         switch (file) {
  44         case REQC: return "reqc";
  45         case REQM: return "reqm";
  46         case RSPC: return "rspc";
  47         case RSPM: return "rspm";
  48         }
  49
  50         return NULL;
  51 }
  52
  53 static char *eyefi_file_on(enum eyefi_file file, char *mnt)
  54 {
  55         char *filename = eyefi_file_name(file);
  56         char *full = malloc(PATHNAME_MAX);
  57
  58         sprintf(&full[0], "%s/EyeFi/%s", mnt, filename);
  59         debug_printf(4, "eyefile nr: %d on '%s' is: '%s'\n", file, mnt, &full[0]);
  60         return full;
  61 }
  62
  63
  64 #define BUFSZ 16384
  65 #define EYEFI_BUF_SIZE 16384
  66 char unaligned_buf[BUFSZ*2];
  67 void *buf;
  68
  69 /*
  70  * Just a few functions so that I can't easily forget about
  71  * endinness.
  72  */
  73 struct __be32 {
  74         u32 val;
  75 } __attribute__((packed));
  76 typedef struct __be32 be32;
  77
  78 /*
  79  * These two obviously need to get fixed for
  80  * big endian machines.
  81  */
  82 u32 be32_to_u32(be32 src)
  83 {
  84         return swap_bytes(src.val);
  85 }
  86 be32 u32_to_be32(u32 src)
  87 {
  88         be32 ret;
  89         ret.val = swap_bytes(src);
  90         return ret;
  91 }
  92
  93 void dumpbuf(const char *buffer, int bytesToWrite)
  94 {
  95     int i;
  96     static char linebuf[500];
  97
  98     for (i=0; i < bytesToWrite; i += 16) {
  99         char *tmpbuf = &linebuf[0];
 100         unsigned long sum = 0;
 101         int j;
 102 #define lprintf(args...)        do {            \
 103         tmpbuf += sprintf(tmpbuf, ## args);\
 104 } while (0)
 105
 106         lprintf("[%03d]: ", i);
 107         for (j=0; j < 16; j++) {
 108                 u8 c = ((unsigned char *)buffer)[i+j];
 109                 lprintf("%02x ", (unsigned int)c);
 110                 sum += c;
 111         }
 112         lprintf(" |");
 113         for (j=0; j < 16; j++) {
 114                 u8 c = ((unsigned char *)buffer)[i+j];
 115                 if (c >= 'a' && c <= 'z')
 116                         lprintf("%c", c);
 117                 else if (c >= 'A' && c <= 'Z')
 118                         lprintf("%c", c);
 119                 else if (c >= '0' && c <= '9')
 120                         lprintf("%c", c);
 121                 else if (c >= 0x20 && c <= 127)
 122                         lprintf("%c", c);
 123                 else
 124                         lprintf(".");
 125         }
 126         lprintf("|\n");
 127         if (sum == 0)
 128                 continue;
 129         printf("%s", linebuf);
 130         //if (i > 200)
 131         //      break;
 132     }
 133 }
 134
 135 struct card_seq_num {
 136         u32 seq;
 137 } __attribute__((packed));
 138
 139 void read_from(enum eyefi_file);
 140 void write_to(enum eyefi_file, void *, int);
 141 struct card_seq_num read_seq_from(enum eyefi_file file)
 142 {
 143         struct card_seq_num *ret;
 144         read_from(file);
 145         ret = buf;
 146         return *ret;
 147 }
 148
 149 /*
 150  * For O_DIRECT writes to files, we need
 151  * to be 512 byte aligned on Linux, I think.
 152  * So, just align this to something big
 153  * and be done with it.  FIXME :)
 154  */
 155 void align_buf(void)
 156 {
 157         unsigned long addr = (unsigned long)&unaligned_buf[BUFSZ];
 158         addr &= ~(BUFSZ-1);
 159         buf = (void *)addr;
 160         debug_printf(4, "buf: %p\n", buf);
 161         debug_printf(4, "unaligned: %p\n", &unaligned_buf[0]);
 162 }
 163
 164 struct card_seq_num seq;
 165
 166 /*
 167  * The real manager does this so we might
 168  * as well, too.
 169  */
 170 void zero_card_files(void)
 171 {
 172         write_to(REQM, buf, BUFSZ);
 173         write_to(REQC, buf, BUFSZ);
 174         write_to(RSPM, buf, BUFSZ);
 175         write_to(RSPC, buf, BUFSZ);
 176
 177         read_from(REQM);
 178         read_from(REQC);
 179         read_from(RSPM);
 180         read_from(RSPC);
 181 }
 182
 183 char lower(char c)
 184 {
 185         if ((c >= 'A') && (c <= 'Z'))
 186                 c += ('a' - 'A');
 187         return c;
 188 }
 189
 190 int atoh(char c)
 191 {
 192         char lc = lower(c);
 193         if ((c >= '0') && (c <= '9'))
 194                 return c - '0';
 195         else if ((c >= 'a') && (c <= 'z'))
 196                 return (c - 'a') + 10;
 197         debug_printf(5, "non-hex character: '%c'/'%c'\n", c, lc);
 198         return -1;
 199 }
 200
 201 int atoo(char o)
 202 {
 203         if ((o >= '0') && (o <= '7'))
 204                 return atoh(o);
 205         return -1;
 206 }
 207
 208 int octal_esc_to_chr(char *input) {
 209         int i=0;
 210         int ret = 0;
 211         int len = strlen(input);
 212
 213         //intf("%s('%s')\n", __func__, input);
 214         if (input[0] != '\\')
 215                 return -1;
 216         if (len < 4)
 217                 return -1;
 218
 219         for (i=1; i < len ; i++) {
 220                 if (i > 3)
 221                         break;
 222                 int tmp = atoo(input[i]);
 223                 //intf("tmp: %d\n", tmp);
 224                 if (tmp < 0)
 225                         return tmp;
 226                 ret <<= 3;
 227                 ret += tmp;
 228         }
 229         return ret;
 230 }
 231
 232 char *replace_escapes(char *str)
 233 {
 234         int i;
 235         int output = 0;
 236         debug_printf(4, "%s(%s)\n", __func__, str);
 237         for (i=0; i < strlen(str); i++) {
 238                 int esc = octal_esc_to_chr(&str[i]);
 239                 if (esc >= 0) {
 240                         str[output++] = esc;
 241                         i += 3;
 242                         continue;
 243                 }
 244                 str[output++] = str[i];
 245         }
 246         str[output] = '\0';
 247         debug_printf(4, "replaced escapes in: '%s' bytes of output: %d\n", str, output);
 248         return str;
 249 }
 250
 251 #define LINEBUFSZ 1024
 252 char *locate_eyefi_mount(void)
 253 {
 254         char line[LINEBUFSZ];
 255         FILE *mounts = fopen("/proc/mounts", "r");
 256
 257         char dev[LINEBUFSZ];
 258         char mnt[LINEBUFSZ];
 259         char fs[LINEBUFSZ];
 260         char opt[LINEBUFSZ];
 261         int foo;
 262         int bar;
 263
 264         if (strlen(eyefi_mount))
 265                 return &eyefi_mount[0];
 266
 267         while (fgets(&line[0], 1023, mounts)) {
 268                 int read;
 269                 read = sscanf(&line[0], "%s %s %s %s %d %d",
 270                                 &dev[0], &mnt[0], &fs[0], &opt[0],
 271                                 &foo, &bar);
 272                 // only look at fat filesystems:
 273                 if (strcmp(fs, "msdos") && strcmp(fs, "vfat")) {
 274                         debug_printf(2, "fs at '%s' is not fat, skipping...\n", mnt);
 275                         continue;
 276                 }
 277                 // Linux's /proc/mounts has spaces like this \040
 278                 replace_escapes(&mnt[0]);
 279                 char *file = eyefi_file_on(REQM, &mnt[0]);
 280                 debug_printf(2, "looking for EyeFi file here: '%s'\n", file);
 281
 282                 struct stat statbuf;
 283                 int statret;
 284                 statret = stat(file, &statbuf);
 285                 free(file);
 286                 if (statret) {
 287                         debug_printf(2, "fs at: %s is not an Eye-Fi card, skipping...\n",
 288                                         eyefi_mount);
 289                         continue;
 290                 }
 291                 strcpy(&eyefi_mount[0], &mnt[0]);
 292                 debug_printf(1, "located EyeFi card at: '%s'\n", eyefi_mount);
 293                 break;
 294         }
 295         fclose(mounts);
 296         if (strlen(eyefi_mount))
 297                 return &eyefi_mount[0];
 298         return NULL;
 299 }
 300
 301 void init_card()
 302 {
 303         char *mnt;
 304         if (buf != NULL)
 305                 return;
 306
 307         debug_printf(2, "Initializing card...\n");
 308         mnt = locate_eyefi_mount();
 309         if (mnt == NULL) {
 310                 debug_printf(1, "unable to locate Eye-Fi card\n");
 311                 if (debug_level < 5)
 312                         debug_printf(0, "please run with '-d5' option and report the output\n");
 313                 else {
 314                         debug_printf(0, "----------------------------------------------\n");
 315                         debug_printf(0, "Debug information:\n");
 316                         system("cat /proc/mounts >&2");
 317                 }
 318                 exit(1);
 319         }
 320
 321         align_buf();
 322         zero_card_files();
 323         seq = read_seq_from(RSPC);
 324         if (seq.seq == 0)
 325                 seq.seq = 0x1234;
 326         debug_printf(2, "Done initializing card...\n");
 327 }
 328
 329 static char *eyefi_file(enum eyefi_file file)
 330 {
 331         init_card();
 332         return eyefi_file_on(file, &eyefi_mount[0]);
 333 }
 334
 335 void open_error(char *file)
 336 {
 337         fprintf(stderr, "unable to open '%s'\n", file);
 338         fprintf(stderr, "Is the Eye-Fi card inserted and mounted at: %s ?\n", eyefi_mount);
 339         fprintf(stderr, "Do you have write permissions to it?\n");
 340         fprintf(stderr, "debug information:\n");
 341         if (debug_level > 0)
 342                 system("cat /proc/mounts >&2");
 343         if (debug_level > 1)
 344                 perror("bad open");
 345         exit(1);
 346 }
 347
 348 void read_from(enum eyefi_file __file)
 349 {
 350         u8 c;
 351         int i;
 352         int ret, retcntl;
 353         int fd;
 354         int zeros = 0;
 355         char *file = eyefi_file(__file);
 356
 357         init_card();
 358
 359         fd = open(file, O_RDONLY);
 360         if (fd < 0)
 361                 open_error(file);
 362         retcntl = fcntl(fd, F_SETFL, O_DIRECT);
 363         if (retcntl < 0) {
 364                 perror("bad fcntl");
 365                 exit(1);
 366         }
 367         ret = read(fd, buf, BUFSZ);
 368         if (debug_level > 3)
 369                 dumpbuf(buf, 128);
 370         if (ret < 0) {
 371                 perror("bad read");
 372                 exit(1);
 373         }
 374         debug_printf(3, "read '%s': bytes: %d fcntl: %d\n", file, ret, retcntl);
 375         for (i=0; i < BUFSZ; i++) {
 376                 c = ((char *)buf)[i];
 377                 if (c == '\0') {
 378                         zeros++;
 379                         continue;
 380                 }
 381         }
 382         //if (zeros)
 383         //      printf(" zeros: %d", zeros);
 384         //fsync(fd);
 385         free(file);
 386         close(fd);
 387 }
 388
 389 void write_to(enum eyefi_file __file, void *stuff, int len)
 390 {
 391         int ret;
 392         int fd;
 393         char *file;
 394
 395         init_card();
 396         file = eyefi_file(__file);
 397         if (len == -1)
 398                 len = strlen(stuff);
 399
 400         if (debug_level > 3) {
 401                 debug_printf(3, "%s('%s', ..., %d)\n", __func__, file, len);
 402                 dumpbuf(stuff, len);
 403         }
 404         memset(buf, 0, BUFSZ);
 405         memcpy(buf, stuff, len);
 406         fd = open(file, O_RDWR|O_DIRECT|O_CREAT, 0600);
 407         //ret = lseek(fd, 0, SEEK_SET);
 408         if (fd < 0)
 409                 open_error(file);
 410         if (debug_level > 3)
 411                 dumpbuf(buf, 128);
 412         ret = write(fd, buf, BUFSZ);
 413         //fsync(fd);
 414         close(fd);
 415         debug_printf(3, "wrote %d bytes to '%s' (string was %d bytes)\n", ret, file, len);
 416         if (ret < 0)
 417                 exit(ret);
 418         free(file);
 419 }
 420
 421 /*
 422  * Most of the eyefi strings are pascal-style with
 423  * a length byte preceeding content.  (Did pascal
 424  * have just a byte for length or more??)
 425  */
 426 struct pascal_string {
 427         u8 length;
 428         u8 value[32];
 429 } __attribute__((packed));
 430
 431 void print_pascal_string(struct pascal_string *str)
 432 {
 433         int i;
 434         for (i = 0; i < str->length; i++)
 435                 printf("%c", str->value[i]);
 436 }
 437
 438 /*
 439  * The 'o' command has several sub-commands:
 440  */
 441 enum card_info_subcommand {
 442         MAC_ADDRESS   = 1,
 443         FIRMWARE_INFO = 2,
 444         CARD_KEY      = 3,
 445         API_URL       = 4,
 446         UNKNOWN1      = 5, // Chris says these are
 447         UNKNOWN2      = 6, // checksums
 448         LOG_LEN       = 7,
 449 };
 450
 451 struct card_info_req {
 452         u8 o;
 453         u8 subcommand;
 454 } __attribute__((packed));
 455
 456 struct card_info_rsp_key {
 457         struct pascal_string key;
 458 };
 459
 460 #define MAC_BYTES 6
 461 struct mac_address {
 462         u8 length;
 463         u8 mac[MAC_BYTES];
 464 } __attribute__((packed));
 465
 466 struct card_info_api_url {
 467         struct pascal_string key;
 468 };
 469
 470 struct card_info_log_len {
 471         u8 len;
 472         be32 val;
 473 } __attribute__((packed));
 474
 475 #define write_struct(file, s) write_to((file), s, sizeof(*(s)))
 476
 477 void print_mac(struct mac_address *mac)
 478 {
 479         int i;
 480         for (i=0; i < MAC_BYTES-1; i++) {
 481                 printf("%02x:", mac->mac[i]);
 482         }
 483         printf("%02x\n", mac->mac[i]);
 484 }
 485
 486 void inc_seq(void)
 487 {
 488         //u32 tmpseq = be32_to_u32(seq.seq);
 489         //seq.seq = u32_to_be32(tmpseq+1);
 490         seq.seq++;
 491         write_struct(REQC, &seq);
 492 }
 493
 494 u32 current_seq(void)
 495 {
 496         return seq.seq;
 497 }
 498
 499 void wait_for_response(void)
 500 {
 501         int i;
 502         debug_printf(3, "waiting for response...\n");
 503         inc_seq();
 504         for (i = 0; i < 50; i++) {
 505                 struct card_seq_num cardseq = read_seq_from(RSPC);
 506                 u32 rsp = cardseq.seq;
 507                 debug_printf(3, "read rsp code: %lx, looking for: %lx raw: %lx\n", rsp, current_seq(),
 508                                 cardseq.seq);
 509                 if (rsp == current_seq())
 510                         break;
 511                 usleep(300000);
 512         }
 513         debug_printf(3, "got good seq, reading RSPM...\n");
 514         read_from(RSPM);
 515         debug_printf(3, "done reading RSPM\n");
 516 }
 517 struct byte_response {
 518         u8 response;
 519 };
 520
 521 enum net_type {
 522         UNSECURED,
 523         WEP,
 524         WPA,
 525         WPA2
 526 };
 527
 528 #define ESSID_LEN 32
 529 struct scanned_net {
 530         char essid[ESSID_LEN];
 531         signed char strength;
 532         u8 type;
 533 } __attribute__((packed));
 534
 535 struct scanned_net_list {
 536         u8 nr;
 537         struct scanned_net nets[100];
 538 } __attribute__((packed));
 539
 540 struct configured_net {
 541         char essid[ESSID_LEN];
 542 } __attribute__((packed));
 543
 544 struct configured_net_list {
 545         u8 nr;
 546         struct configured_net nets[100];
 547 } __attribute__((packed));
 548
 549 char *net_test_states[] = {
 550         "not scanning",
 551         "locating network",
 552         "verifying network key",
 553         "waiting for DHCP",
 554         "testing connection to Eye-Fi server",
 555         "success",
 556 };
 557
 558 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
 559
 560 char *net_test_state_name(u8 state)
 561 {
 562         int size = ARRAY_SIZE(net_test_states);
 563         if (state >= size)
 564                 return "unknown";
 565         return net_test_states[state];
 566 }
 567
 568 char *net_types[] = {
 569         "No security",
 570         "WEP",
 571         "WPA",
 572         "unknown1",
 573         "WPA2",
 574 };
 575
 576 char *net_type_name(u8 type)
 577 {
 578         int size = ARRAY_SIZE(net_types);
 579         if (type >= size)
 580                 return "unknown";
 581         return net_types[type];
 582 }
 583
 584 #define WPA_KEY_BYTES 32
 585 struct wpa_key {
 586         u8 key[WPA_KEY_BYTES];
 587 } __attribute((packed));
 588
 589 #define WEP_KEY_BYTES 32
 590 struct wep_key {
 591         u8 key[WEP_KEY_BYTES];
 592 } __attribute((packed));
 593
 594 struct network_key {
 595         u8 len;
 596         union {
 597                 struct wpa_key wpa;
 598                 struct wep_key wep;
 599         };
 600 } __attribute((packed));
 601
 602 #define KEY_LEN 32
 603 struct net_request {
 604         char req;
 605         u8 essid_len;
 606         char essid[ESSID_LEN];
 607         struct network_key key;
 608 } __attribute((packed));
 609
 610 /*
 611  * Take a string like "0ab1" and make it
 612  * a series of bytes: { 0x0a, 0xb1 }
 613  *
 614  * @len is the strlen() of the ascii
 615  *
 616  * Destroys the original string.
 617  */
 618 char *convert_ascii_to_hex(char *ascii, int len)
 619 {
 620         int i;
 621         if (len%2) {
 622                 fprintf(stderr, "%s() must be even number of bytes: %d\n",
 623                 __func__, len);
 624                 exit(2);
 625         }
 626         for (i=0; i < len; i+=2) {
 627                 int high = atoh(ascii[i]);
 628                 int low  = atoh(ascii[i+1]);
 629                 u8 byte = (high<<4 | low);
 630                 if (high < 0 || low < 0)
 631                         return NULL;
 632                 debug_printf(6, "high: %02x low: %02x, both: %02x\n", high, low, byte);
 633                 ascii[i/2] = byte;
 634         }
 635         for (i=len/2; i < len; i++)
 636                 ascii[i] = '\0';
 637         return &ascii[0];
 638 }
 639
 640 #define PASSPHRASE_PROG "wpa_passphrase"
 641
 642 struct wpa_key *make_wpa_key(char *essid, char *pass)
 643 {
 644         struct wpa_key *key = malloc(sizeof(*key));
 645
 646         if (strlen(pass) == WPA_KEY_BYTES*2) {
 647                 char *hex_pass;
 648                 debug_printf(2, "Interpreting password as hex WPA key\n");
 649                 hex_pass = convert_ascii_to_hex(pass, WPA_KEY_BYTES*2);
 650                 if (!hex_pass)
 651                         return NULL;
 652                 memcpy(&key->key[0], pass, WPA_KEY_BYTES);
 653         } else {
 654                 debug_printf(2, "Interpreting password as ASCII WPA key\n");
 655                 pbkdf2_sha1(pass, essid, strlen(essid), 4096,
 656                             &key->key[0], WPA_KEY_BYTES);
 657         }
 658         return key;
 659 }
 660
 661 void card_info_cmd(enum card_info_subcommand cmd)
 662 {
 663         struct card_info_req cir;
 664         cir.o = 'o';
 665         cir.subcommand = cmd;
 666
 667         write_struct(REQM, &cir);
 668         wait_for_response();
 669 }
 670
 671 u32 fetch_log_length(void)
 672 {
 673         card_info_cmd(LOG_LEN);
 674         struct card_info_log_len *loglen = buf;
 675         return be32_to_u32(loglen->val);
 676 }
 677
 678 void print_log_len(void)
 679 {
 680         u32 len = fetch_log_length();
 681         printf("log len: %08lx\n", len);
 682 }
 683
 684 void print_card_mac(void)
 685 {
 686         debug_printf(2, "%s()\n", __func__);
 687         card_info_cmd(MAC_ADDRESS);
 688         struct mac_address *mac = buf;
 689         assert(mac->length == MAC_BYTES);
 690         printf("card mac address: ");
 691         print_mac(mac);
 692 }
 693
 694 void print_card_key(void)
 695 {
 696         debug_printf(2, "%s()\n", __func__);
 697         card_info_cmd(CARD_KEY);
 698         struct card_info_rsp_key *foo = buf;
 699         printf("card key (len: %d): '", foo->key.length);
 700         print_pascal_string(&foo->key);
 701         printf("'\n");
 702 }
 703
 704 struct noarg_request {
 705         u8 req;
 706 };
 707
 708 void issue_noarg_command(u8 cmd)
 709 {
 710         struct noarg_request req;
 711         req.req = cmd;
 712         write_struct(REQM, &req);
 713         wait_for_response();
 714 }
 715
 716 void scan_print_nets(void)
 717 {
 718         int i;
 719
 720         debug_printf(2, "%s()\n", __func__);
 721         issue_noarg_command('g');
 722         struct scanned_net_list *scanned = buf;
 723         if (scanned->nr == 0) {
 724                 printf("unable to detect any wireless networks\n");
 725                 return;
 726         }
 727         printf("Scanned wireless networks:\n");
 728         for (i=0; i < scanned->nr; i++) {
 729                 struct scanned_net *net = &scanned->nets[i];
 730                 printf("'%s' type(%d): %s, strength: %d\n", net->essid,
 731                                 net->type,
 732                                 net_type_name(net->type),
 733                                 net->strength);
 734         }
 735 }
 736
 737 void print_configured_nets(void)
 738 {
 739         int i;
 740         struct configured_net_list *configured;
 741
 742         debug_printf(2, "%s()\n", __func__);
 743         issue_noarg_command('l');
 744         configured = buf;
 745         if (configured->nr == 0) {
 746                 printf("No wireless networks configured on card\n");
 747                 return;
 748         }
 749         printf("configured wireless networks:\n");
 750         for (i=0; i < configured->nr; i++) {
 751                 struct configured_net *net = &configured->nets[i];
 752                 printf("'%s'\n", net->essid);
 753         }
 754 }
 755
 756 void reboot_card(void)
 757 {
 758         debug_printf(2, "%s()\n", __func__);
 759         issue_noarg_command('b');
 760 }
 761
 762 void copy_wep_key(struct wep_key *dst, struct wep_key *src)
 763 {
 764         memcpy(&dst->key, &src->key, sizeof(*dst));
 765 }
 766
 767 void copy_wpa_key(struct wpa_key *dst, struct wpa_key *src)
 768 {
 769         memcpy(&dst->key, &src->key, sizeof(*dst));
 770 }
 771
 772 void network_action(char cmd, char *essid, char *wpa_ascii)
 773 {
 774         struct net_request nr;
 775         memset(&nr, 0, sizeof(nr));
 776
 777         nr.req = cmd;
 778         strcpy(&nr.essid[0], essid);
 779         nr.essid_len = strlen(essid);
 780         struct wpa_key *wpakey;
 781         if (wpa_ascii) {
 782                 wpakey = make_wpa_key(essid, wpa_ascii);
 783                 nr.key.len = sizeof(*wpakey);
 784                 copy_wpa_key(&nr.key.wpa, wpakey);
 785         }
 786         write_struct(REQM, &nr);
 787         wait_for_response();
 788 }
 789
 790 void add_network(char *essid, char *wpa_ascii)
 791 {
 792         debug_printf(2, "%s()\n", __func__);
 793         network_action('a', essid, wpa_ascii);
 794 }
 795
 796 void remove_network(char *essid)
 797 {
 798         debug_printf(2, "%s()\n", __func__);
 799         network_action('d', essid, NULL);
 800 }
 801
 802 int try_connection_to(char *essid, char *wpa_ascii)
 803 {
 804         int i;
 805         int ret = -1;
 806
 807         char *type = net_type_name(WPA);
 808         if (!wpa_ascii)
 809                 type = net_type_name(UNSECURED);
 810         printf("trying to connect to %s network: '%s'", type, essid);
 811         if (wpa_ascii)
 812                 printf(" with passphrase: '%s'", wpa_ascii);
 813         fflush(NULL);
 814
 815         // test network
 816         network_action('t', essid, wpa_ascii);
 817         u8 last_rsp = -1;
 818
 819         char rsp = '\0';
 820         for (i=0; i < 200; i++) {
 821                 struct byte_response *r;
 822                 issue_noarg_command('s');
 823                 r = buf;
 824                 rsp = r->response;
 825                 char *state = net_test_state_name(rsp);
 826                 if (rsp == last_rsp) {
 827                         printf(".");
 828                         fflush(NULL);;
 829                 } else {
 830                         if (rsp)
 831                                 printf("\nTesting connecion to '%s' (%d): %s", essid, rsp, state);
 832                         last_rsp = rsp;
 833                 }
 834
 835                 if (!strcmp("success", state)) {
 836                         ret = 0;
 837                         break;
 838                 }
 839                 if (!strcmp("not scanning", state))
 840                         break;
 841                 if (!strcmp("unknown", state))
 842                         break;
 843         }
 844         printf("\n");
 845         if (!ret) {
 846                 printf("Succeeded connecting to: '%s'\n", essid);
 847         } else {
 848                 printf("Unable to connect to: '%s' (final state: %d/'%s')\n", essid,
 849                                 rsp, net_test_state_name(rsp));
 850         }
 851         return ret;
 852 }
 853
 854 struct fetch_log_cmd {
 855         char m;
 856         be32 offset;
 857 } __attribute__((packed));
 858
 859 /*
 860  * When you ask for the log at offset 0x0, you
 861  * get back 8 bytes of offsets into the rest of
 862  * the data
 863  */
 864 struct first_log_response {
 865         be32 log_end;
 866         be32 log_start;
 867         u8 data[EYEFI_BUF_SIZE-8];
 868 } __attribute__((packed));
 869
 870 struct rest_log_response {
 871         u8 data[EYEFI_BUF_SIZE];
 872 } __attribute__((packed));
 873
 874 unsigned char *get_log_at_offset(u32 offset)
 875 {
 876         struct fetch_log_cmd cmd;
 877         cmd.m = 'm';
 878         cmd.offset = u32_to_be32(offset);
 879
 880         debug_printf(2, "getting log at offset: %08lx\n", offset);
 881         write_struct(REQM, &cmd);
 882         wait_for_response();
 883         return buf;
 884 }
 885
 886 int get_log(void)
 887 {
 888         int total_bytes = 0;
 889         int i;
 890         u32 log_start;
 891         u32 log_end;
 892         u32 log_size = fetch_log_length();
 893         char *resbuf = malloc(log_size);
 894
 895         int nr_bufs_per_log = log_size/EYEFI_BUF_SIZE;
 896         for (i = 0; i < log_size/EYEFI_BUF_SIZE; i++) {
 897                 debug_printf(1, "fetching EyeFi card log part %d/%d...",
 898                                 i+1, nr_bufs_per_log);
 899                 fflush(NULL);
 900                 get_log_at_offset(EYEFI_BUF_SIZE*i);
 901                 debug_printf(1, "done\n");
 902                 u32 log_size;
 903                 u8 *log_data;
 904                 if (i == 0) {
 905                         struct first_log_response *log = buf;
 906                         log_end = be32_to_u32(log->log_end);
 907                         log_start = be32_to_u32(log->log_start);
 908                         debug_printf(2, "log end:   0x%04lx\n", log_end);
 909                         debug_printf(2, "log start: 0x%04lx\n", log_start);
 910                         log_data = &log->data[0];
 911                         log_size = ARRAY_SIZE(log->data);
 912                 } else {
 913                         struct rest_log_response *log = buf;
 914                         log_data = &log->data[0];
 915                         log_size = ARRAY_SIZE(log->data);
 916                 }
 917                 debug_printf(3, "writing %ld bytes to resbuf[%d]\n",
 918                                 log_size, total_bytes);
 919                 memcpy(&resbuf[total_bytes], log_data, log_size);
 920                 total_bytes += log_size;
 921         }
 922         // The last byte *should* be a null, and the
 923         // official software does not print it.
 924         for (i = 0; i < total_bytes-1; i++) {
 925                 int offset = (log_start+i)%total_bytes;
 926                 char c = resbuf[offset];
 927                 // the official software converts UNIX to DOS-style
 928                 // line breaks, so we'll do the same
 929                 if (c == '\n')
 930                         printf("%c", '\r');
 931                 printf("%c", c);
 932         }
 933         printf("\n");
 934         // just some simple sanity checking to make sure what
 935         // we are fetching looks valid
 936         int null_bytes_left = 20;
 937         if (resbuf[log_end] != 0) {
 938                 debug_printf(2, "error: unexpected last byte (%ld/0x%lx) of log: %02x\n",
 939                                 log_end, log_end, resbuf[log_end]);
 940                 for (i=0; i<log_size; i++) {
 941                         if (resbuf[i])
 942                                 continue;
 943                         if (null_bytes_left <= 0)
 944                                 continue;
 945                         null_bytes_left--;
 946                         debug_printf(2, "null byte %d\n", i);
 947                 }
 948         }
 949         free(resbuf);
 950         return 0;
 951 }
 952
 953 void usage(void)
 954 {
 955         printf("Usage:\n");
 956         printf("  eyefitest [OPTIONS]\n");
 957         printf("  -a ESSID      add network (implies test unless --force)\n");
 958         printf("  -t ESSID      test network\n");
 959         printf("  -p KEY        set WPA key for add/test\n");
 960         printf("  -r ESSID      remove network\n");
 961         printf("  -s            scan for networks\n");
 962         printf("  -c            list configured networks\n");
 963         printf("  -b            reboot card\n");
 964         printf("  -d level      set debugging level (default: 1)\n");
 965         printf("  -k            print card unique key\n");
 966         printf("  -l            dump card log\n");
 967         printf("  -m            print card mac\n");
 968         exit(4);
 969 }
 970
 971 int main(int argc, char **argv)
 972 {
 973         if (argc == 1)
 974                 usage();
 975
 976         debug_printf(3, "%s starting...\n", argv[0]);
 977
 978         //static int passed_wep = 0;
 979         //static int passed_wpa = 0;
 980         static int force = 0;
 981         static struct option long_options[] = {
 982                 //{"wep", 'x', &passed_wep, 1},
 983                 //{"wpa", 'y', &passed_wpa, 1},
 984                 {"force", 0, &force, 1},
 985                 {"help", 'h', NULL, 1},
 986         };
 987
 988         int option_index;
 989         char c;
 990         char *essid = NULL;
 991         char *passwd = NULL;
 992         char network_action = 0;
 993         debug_printf(3, "about to parse arguments\n");
 994         while ((c = getopt_long_only(argc, argv, "a:bcd:klmp:r:st:",
 995                         &long_options[0], &option_index)) != -1) {
 996                 debug_printf(3, "argument: '%c' %d optarg: '%s'\n", c, c, optarg);
 997                 switch (c) {
 998                 case 0:
 999                         // was a long argument
1000                         break;
1001                 case 'a':
1002                 case 't':
1003                 case 'r':
1004                         essid = optarg;
1005                         network_action = c;
1006                         break;
1007                 case 'b':
1008                         reboot_card();
1009                         break;
1010                 case 'c':
1011                         print_configured_nets();
1012                         break;
1013                 case 'd':
1014                         debug_level = atoi(optarg);
1015                         fprintf(stderr, "set debug level to: %d\n", debug_level);
1016                         break;
1017                 case 'k':
1018                         print_card_key();
1019                         break;
1020                 case 'l':
1021                         get_log();
1022                         break;
1023                 case 'm':
1024                         print_card_mac();
1025                         break;
1026                 case 'p':
1027                         passwd = optarg;
1028                         break;
1029                 case 's':
1030                         scan_print_nets();
1031                         break;
1032                 case 'h':
1033                 default:
1034                         usage();
1035                         break;
1036                 }
1037         }
1038         debug_printf(3, "after arguments essid: '%s' passwd: '%s'\n", essid, passwd);
1039         if (network_action && essid) {
1040                 int ret = 0;
1041                 init_card();
1042                 switch (network_action) {
1043                 case 't':
1044                         ret = try_connection_to(essid, passwd);
1045                         break;
1046                 case 'a':
1047                         if (!force) {
1048                                 ret = try_connection_to(essid, passwd);
1049                         } else {
1050                                 debug_printf(1, "forced: skipping network test\n");
1051                         }
1052                         if (ret) {
1053                                 printf("Error connecting to network '%s', not adding.\n", essid);
1054                                 printf("use --force to override\n");
1055                                 break;
1056                         }
1057                         add_network(essid, passwd);
1058                         break;
1059                 case 'r':
1060                         remove_network(essid);
1061                         break;
1062                 }
1063         }
1064         return 0;
1065 }
1066
1067