4 * Copyright (C) 2008 Dave Hansen <dave@sr71.net>
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.
11 #include "eyefi-config.h"
13 int eyefi_debug_level = 1;
15 int eyefi_printf(const char *fmt, ...)
21 r = vprintf(fmt, args);
27 static char *eyefi_file_name(enum eyefi_file file)
30 case REQC: return "reqc";
31 case REQM: return "reqm";
32 case RSPC: return "rspc";
33 case RSPM: return "rspm";
39 char *eyefi_file_on(enum eyefi_file file, char *mnt)
41 char *filename = eyefi_file_name(file);
42 char *full = malloc(PATHNAME_MAX);
47 sprintf(&full[0], "%s/EyeFi/%s", mnt, filename);
48 debug_printf(4, "eyefile nr: %d on '%s' is: '%s'\n", file, mnt, &full[0]);
53 * This lets us get away with a static allocation
54 * for the buffer. We make it size*2 so that we're
55 * guaranteed to be able to get a "size" buffer
56 * aligned inside of the larger one.
58 static char unaligned_buf[EYEFI_BUF_SIZE*2];
59 static void *eyefi_buf;
61 void *eyefi_response(void)
66 void dumpbuf(const char *buffer, int bytesToWrite)
69 static char linebuf[500];
71 for (i=0; i < bytesToWrite; i += 16) {
72 char *tmpbuf = &linebuf[0];
73 unsigned long sum = 0;
75 #define lprintf(args...) do { \
76 tmpbuf += sprintf(tmpbuf, ## args);\
79 lprintf("[%03d]: ", i);
80 for (j=0; j < 16; j++) {
81 u8 c = ((unsigned char *)buffer)[i+j];
82 lprintf("%02x ", (unsigned int)c);
86 for (j=0; j < 16; j++) {
87 u8 c = ((unsigned char *)buffer)[i+j];
88 if (c >= 'a' && c <= 'z')
90 else if (c >= 'A' && c <= 'Z')
92 else if (c >= '0' && c <= '9')
94 else if (c >= 0x20 && c <= 127)
102 printf("%s", linebuf);
108 void read_from(enum eyefi_file);
109 void write_to(enum eyefi_file, void *, int);
111 struct card_seq_num eyefi_seq;
112 struct card_seq_num read_seq_from(enum eyefi_file file)
114 struct card_seq_num *ret;
121 * For O_DIRECT writes to files, we need
122 * to be 512 byte aligned on Linux, I think.
123 * So, just align this to something big
124 * and be done with it. FIXME :)
126 * This probably isn't necessary on chdk,
127 * since I don't think it buffers I/O at
132 unsigned long addr = (unsigned long)&unaligned_buf[EYEFI_BUF_SIZE];
133 addr &= ~(EYEFI_BUF_SIZE-1);
134 eyefi_buf = (void *)addr;
135 debug_printf(4, "buf: %p\n", eyefi_buf);
136 debug_printf(4, "unaligned: %p\n", &unaligned_buf[0]);
140 * The real manager does this so we might
143 void zero_card_files(void)
145 char zbuf[EYEFI_BUF_SIZE];
147 memset(&zbuf[0], 0, EYEFI_BUF_SIZE);
148 //write_to(REQM, zbuf, EYEFI_BUF_SIZE);
149 write_to(REQC, zbuf, EYEFI_BUF_SIZE);
150 write_to(RSPM, zbuf, EYEFI_BUF_SIZE);
151 write_to(RSPC, zbuf, EYEFI_BUF_SIZE);
162 if (eyefi_buf != NULL)
165 debug_printf(2, "Initializing card...\n");
166 mnt = locate_eyefi_mount();
172 eyefi_seq = read_seq_from(RSPC);
173 if (eyefi_seq.seq == 0)
174 eyefi_seq.seq = 0x1234;
176 debug_printf(2, "Done initializing card...\n");
177 debug_printf(2, "seq was: %04x\n", eyefi_seq.seq);
180 static char *eyefi_file(enum eyefi_file file)
183 return eyefi_file_on(file, locate_eyefi_mount());
186 void read_from(enum eyefi_file __file)
190 char *file = eyefi_file(__file);
195 fd = open(file, O_RDONLY);
197 open_error(file, fd);
199 ret = read(fd, eyefi_buf, EYEFI_BUF_SIZE);
200 if (eyefi_debug_level > 3)
201 dumpbuf(eyefi_buf, 128);
204 perror("bad read, retrying...");
208 debug_printf(4, "read '%s': bytes: %d\n", file, ret);
210 * There was a time when I was carefully recording how each response
211 * looked, and I counted the zeros in each response. I don't care
216 for (i=0; i < EYEFI_BUF_SIZE; i++) {
217 c = ((char *)eyefi_buf)[i];
229 void write_to(enum eyefi_file __file, void *stuff, int len)
239 file = eyefi_file(__file);
243 if (eyefi_debug_level > 3) {
244 debug_printf(3, "%s('%s', ..., %d)\n", __func__, file, len);
247 memset(eyefi_buf, 0, EYEFI_BUF_SIZE);
248 memcpy(eyefi_buf, stuff, len);
249 fd = open(file, O_RDWR|O_CREAT, 0600);
251 open_error(file, fd);
252 if (eyefi_debug_level > 3)
253 dumpbuf(eyefi_buf, 128);
254 ret = write(fd, eyefi_buf, EYEFI_BUF_SIZE);
256 open_error(file, ret);
259 open_error(file, ret);
261 debug_printf(3, "wrote %d bytes to '%s' (string was %d bytes)\n", ret, file, len);
263 fprintf(stderr, "error writing to '%s': ", file);
270 #define write_struct(file, s) write_to((file), s, sizeof(*(s)))
275 * Oddly enough, the sequence number appears
276 * to be of normal endianness.
278 //u32 tmpseq = be32_to_u32(seq.seq);
279 //seq.seq = u32_to_be32(tmpseq+1);
281 write_struct(REQC, &eyefi_seq);
284 u32 eyefi_current_seq(void)
286 return eyefi_seq.seq;
289 int wait_for_response(void)
294 debug_printf(3, "waiting for response...\n");
296 for (i = 0; i < 50; i++) {
297 struct card_seq_num cardseq = read_seq_from(RSPC);
298 debug_printf(3, "read rsp code: %x, looking for: %x raw: %x\n", rsp, eyefi_current_seq(),
301 if (rsp == eyefi_current_seq()) {
305 if (eyefi_debug_level > 4) {
307 debug_printf(1, "command issued was: '%c'\n", ((char *)eyefi_buf)[0]);
312 debug_printf(1, "never saw card seq response\n");
315 debug_printf(3, "got good seq (%d), reading RSPM...\n", rsp);
317 debug_printf(3, "done reading RSPM\n");
321 char *net_test_states[] = {
324 "verifying network key",
326 "testing connection to Eye-Fi server",
330 char *net_test_state_name(u8 state)
332 int size = ARRAY_SIZE(net_test_states);
335 return net_test_states[state];
338 const char *net_types[] = {
345 const char net_type_unknown[] = "unknown";
347 const char *net_type_name(u8 type)
349 int size = ARRAY_SIZE(net_types);
350 debug_printf(3, "%s(%d): '%s' size: %d\n", __func__, type, net_types[type], size);
352 return net_type_unknown;
353 return net_types[type];
356 static char lower(char c)
358 if ((c >= 'A') && (c <= 'Z'))
366 if ((c >= '0') && (c <= '9'))
368 else if ((lc >= 'a') && (lc <= 'z'))
369 return (lc - 'a') + 10;
370 debug_printf(5, "non-hex character: '%c'/'%c'\n", c, lc);
375 * Take a string like "0ab1" and make it
376 * a series of bytes: { 0x0a, 0xb1 }
378 * @len is the strlen() of the ascii
380 * Destroys the original string.
382 char *convert_ascii_to_hex(char *ascii, int len)
386 fprintf(stderr, "%s() must be even number of bytes: %d\n",
390 for (i=0; i < len; i+=2) {
391 int high = atoh(ascii[i]);
392 int low = atoh(ascii[i+1]);
393 u8 byte = (high<<4 | low);
394 if (high < 0 || low < 0) {
395 fprintf(stderr, "unable to parse hex string: '%s'\n", ascii);
398 debug_printf(6, "high: %02x low: %02x, both: %02x\n", high, low, byte);
401 for (i=len/2; i < len; i++)
406 int make_network_key(struct network_key *key, char *essid, char *pass)
408 char tmp[WPA_KEY_BYTES+WEP_KEY_BYTES];
409 int pass_len = strlen(pass);
411 memset(key, 0, sizeof(*key));
413 strcpy(&tmp[0], pass);
414 eyefi_printf(" interpreting passphrase as ");
416 case WPA_KEY_BYTES*2:
417 eyefi_printf("hex WPA");
418 hex_pass = convert_ascii_to_hex(tmp, pass_len);
421 key->len = pass_len/2;
422 memcpy(&key->wpa.key[0], hex_pass, key->len);
424 case WEP_KEY_BYTES*2:
425 case WEP_40_KEY_BYTES*2:
426 eyefi_printf("hex WEP");
427 hex_pass = convert_ascii_to_hex(tmp, strlen(pass));
430 key->len = pass_len/2;
431 memcpy(&key->wep.key[0], hex_pass, key->len);
434 eyefi_printf("ASCII WPA");
435 pbkdf2_sha1(pass, essid, strlen(essid), 4096,
436 &key->wpa.key[0], WPA_KEY_BYTES);
437 key->len = WPA_KEY_BYTES;
440 eyefi_printf(" key (%d bytes)\n", key->len);
441 assert(key->len != 0);
445 int card_info_cmd(enum card_info_subcommand cmd)
447 struct card_info_req cir;
449 cir.subcommand = cmd;
451 write_struct(REQM, &cir);
452 return wait_for_response();
455 u32 fetch_log_length(void)
457 debug_printf(3, "%s()\n", __func__);
458 card_info_cmd(LOG_LEN);
459 struct card_info_log_len *loglen = eyefi_buf;
460 return be32_to_u32(loglen->val);
463 struct card_firmware_info *fetch_card_firmware_info(void)
465 debug_printf(2, "%s()\n", __func__);
466 card_info_cmd(FIRMWARE_INFO);
467 return (struct card_firmware_info *)eyefi_buf;
471 void wlan_disable(int do_disable)
474 * This is complete voodoo to me. I've only ever seen
475 * a single example of this, so it's hard to figure out
476 * the structure at all.
478 char new_cmd[] = {'O', 0x0a, do_disable};
479 write_to(REQM, &new_cmd[0], 3);
483 int wlan_enabled(void)
485 struct var_byte_response *rsp;
486 card_info_cmd(WLAN_ENABLED);
488 return rsp->responses[0].response;
504 void scan_print_nets(void);
513 printf("WLAN enabled: %d\n", wlan_enabled());
515 printf("WLAN enabled: %d\n", wlan_enabled());
517 printf("WLAN enabled: %d\n", wlan_enabled());
519 for (i = 10; i <= 13; i++) {
522 printf("UNKNOWN %d result:\n", i);
523 dumpbuf(eyefi_buf, 64);
524 printf("WLAN enabled: %d\n", wlan_enabled());
529 printf("UNKNOWN %d result:\n", i);
530 dumpbuf(eyefi_buf, 64);
532 printf("WLAN enabled: %d\n", wlan_enabled());
534 printf("WLAN enabled: %d\n", wlan_enabled());
535 for (i = 10; i <= 13; i++) {
538 printf("UNKNOWN %d result:\n", i);
539 dumpbuf(eyefi_buf, 64);
540 printf("WLAN enabled: %d\n", wlan_enabled());
544 printf("UNKNOWN %d result:\n", i);
545 dumpbuf(eyefi_buf, 64);
549 printf("o3 result:\n");
550 dumpbuf(eyefi_buf, 64);
552 memset(&zbuf[0], 0, EYEFI_BUF_SIZE);
556 write_to(REQM, &zbuf[0], 16384);
557 printf("o2 written\n");
558 printf("seq: %x\n", (int)eyefi_seq.seq);
561 for (i=0; i < 4; i++) {
563 printf("RSPC %d:\n", i);
564 dumpbuf(eyefi_buf, 64);
570 dumpbuf(eyefi_buf, 64);
572 memset(&zbuf[0], 0, EYEFI_BUF_SIZE);
573 write_to(RSPM, zbuf, EYEFI_BUF_SIZE);
574 write_to(REQM, zbuf, EYEFI_BUF_SIZE);
576 fdin = open("/home/dave/projects/eyefi/EYEFIFWU.BIN.2.0001", O_RDONLY);
578 fdout = open("/media/EYE-FI/EYEFIFWU.BIN", O_WRONLY|O_CREAT);
580 if (fdin <= 0 || fdout <= 0)
583 i = read(fdin, &fwbuf[0], 524288);
587 i = write(fdout, &fwbuf[0], 524288);
595 dumpbuf(eyefi_buf, 64);
598 printf("after reboot:\n");
599 dumpbuf(eyefi_buf, 64);
603 dumpbuf(eyefi_buf, 64);
607 dumpbuf(eyefi_buf, 64);
609 memset(&zbuf[0], 0, EYEFI_BUF_SIZE);
610 write_to(RSPM, zbuf, EYEFI_BUF_SIZE);
611 write_to(REQM, zbuf, EYEFI_BUF_SIZE);
615 dumpbuf(eyefi_buf, 64);
618 strcpy(tb.name, "www.sr71.net/");
619 tb.l1 = strlen(tb.name);
620 for (i = 0; i < 10; i++) {
623 write_struct(RSPM, &z);
624 write_struct(REQM, &tb);
626 printf("buffer after O %d:\n", i);
627 dumpbuf(eyefi_buf, 64);
628 printf("----------------\n");
629 write_struct(REQM, &tb);
631 printf("card info(%d):\n", i);
632 dumpbuf(eyefi_buf, 64);
633 printf("-----------\n");
637 strcpy(tb.name, "/public/eyefi/servname");
638 strcpy(tb.name, "/config/networks.xml");
639 //tb.len = strlen(tb.name);
641 for (c = 'O'; c <= 'O'; c++) {
643 write_struct(REQM, &tb);
645 printf("dumping buffer:\n");
646 dumpbuf(eyefi_buf, 64);
647 printf("buffer dump done\n");
651 struct card_info_rsp_key *fetch_card_key(void)
653 struct card_info_rsp_key *key;
655 debug_printf(2, "%s()\n", __func__);
656 card_info_cmd(CARD_KEY);
661 int issue_noarg_command(u8 cmd)
663 struct noarg_request req;
664 debug_printf(4, "%s() cmd: %d\n", __func__, cmd);
666 write_struct(REQM, &req);
667 return wait_for_response();
670 struct scanned_net_list *scan_nets(void)
672 struct scanned_net_list *scanned;
674 debug_printf(2, "%s()\n", __func__);
675 issue_noarg_command('g');
676 scanned = eyefi_response();
680 struct configured_net_list *fetch_configured_nets(void)
682 struct configured_net_list *configured;
684 debug_printf(2, "%s()\n", __func__);
685 issue_noarg_command('l');
686 configured = eyefi_buf;
690 void reboot_card(void)
692 debug_printf(2, "%s()\n", __func__);
693 debug_printf(1, "rebooting card...");
694 issue_noarg_command('b');
695 debug_printf(1, "done\n");
698 int network_action(char cmd, char *essid, char *ascii_password)
700 struct net_request nr;
701 memset(&nr, 0, sizeof(nr));
704 strcpy(&nr.essid[0], essid);
705 nr.essid_len = strlen(essid);
707 if (ascii_password) {
708 int ret = make_network_key(&nr.key, essid, ascii_password);
712 write_struct(REQM, &nr);
713 return wait_for_response();
716 void add_network(char *essid, char *ascii_password)
718 debug_printf(2, "%s('%s', '%s')\n", __func__, essid, ascii_password);
719 network_action('a', essid, ascii_password);
722 void remove_network(char *essid)
724 debug_printf(2, "%s()\n", __func__);
725 network_action('d', essid, NULL);
728 int get_log_at_offset(u32 offset)
730 struct fetch_log_cmd cmd;
732 cmd.offset = u32_to_be32(offset);
734 debug_printf(2, "getting log at offset: %08x\n", offset);
735 write_struct(REQM, &cmd);
736 return wait_for_response();
739 void add_log_piece(u8 *log, int log_len, u8 *piece, int piece_pos, int piece_size)
741 debug_printf(2, "%s(%p, %d, %p, %d, %d)\n", __func__, log, log_len, piece, piece_pos, piece_size);
742 if (piece_pos + piece_size > log_len) {
743 int overflow_by = (piece_pos + piece_size) - log_len;
744 int piece_overrun_pos = piece_size - overflow_by;
745 piece_size -= overflow_by;
746 memcpy(&log[0], &piece[piece_overrun_pos], overflow_by);
747 debug_printf(2, "writing %d bytes to logbuf[0] from piece[%d]\n",
748 overflow_by, piece_overrun_pos);
750 debug_printf(2, "writing %d bytes to logbuf[%d]\n", piece_size, piece_pos);
751 memcpy(&log[piece_pos], piece, piece_size);
754 int get_log_into(u8 *resbuf)
761 u32 __log_size = fetch_log_length();
762 int log_pieces = __log_size/EYEFI_BUF_SIZE;
767 /* There are 8 bytes of header in the first log entry
768 * to specify where the log starts and ends */
769 u32 log_size = __log_size - 8;
771 for (i = 0; i < log_pieces; i++) {
772 debug_printf(1, "fetching EyeFi card log part %d/%d...",
775 ret = get_log_at_offset(EYEFI_BUF_SIZE*i);
776 debug_printf(1, "done\n");
780 struct first_log_response *log = eyefi_buf;
781 log_end = log_size - be32_to_u32(log->log_end);
782 log_start = log_size - be32_to_u32(log->log_start);
783 debug_printf(2, "log end: 0x%04x\n", log_end);
784 debug_printf(2, "log start: 0x%04x\n", log_start);
785 log_piece = &log->data[0];
786 log_piece_size = ARRAY_SIZE(log->data);
788 struct rest_log_response *log = eyefi_buf;
789 log_piece = &log->data[0];
790 log_piece_size = ARRAY_SIZE(log->data);
792 add_log_piece(resbuf, log_size, log_piece, log_start, log_piece_size);
793 total_bytes += log_piece_size;
794 log_start += log_piece_size;
795 log_start = log_start % log_size;