root/modules/file_shelter.c

DEFINITIONS

1. _run
2. _module_can_unload
3. _module_exit_alt
4. crc32_for_byte
5. crc32
6. read_file_f
7. read_file_o
8. compute_file_crc_f
9. compute_file_crc_o
10. write_file_f
11. write_file_o
12. read_file
13. write_file
14. compute_file_crc
15. strcasecmp
16. mkdir_if_not_exist
17. is_parent
18. is_current
19. fs_readdir
20. process_dir
21. wordpad
22. is_valid_stptr
23. iswhitelisted
24. get_next_object
25. get_object_name
26. get_object_data
27. fproc_totalsize
28. dproc_count
29. dproc_store
30. fproc_store
31. alloc_storage
32. restore
33. can_boot_from_fat32
34. gui_fileshelter_kbd_process
35. basic_module_init
36. gui_fileshelter_menu_kbd_process
37. gui_fileshelter_draw

   1 #include "camera_info.h"
   2 #include "gui.h"
   3 #include "gui_draw.h"
   4 #include "meminfo.h"
   5 #include "module_load.h"
   6 #include "simple_module.h"
   7 #include "clock.h"
   8 #include "console.h"
   9 #include "conf.h"
  10 #include "sd_card.h"
  11 #include "cachebit.h"
  12 #include "exmem.h"
  13 #include "time.h"
  14 #include "dirent.h"
  15 #include "ctype.h"
  17 #define FSCRC_CALC 1 // 1 = file crc check immediately after writing, 0 = no check
  19 #define MAX_PATH_LEN    100
  21 // =========  MODULE INIT =================
  23 static int running = 0;
  24 static char osdbuf[128];
  26 extern int basic_module_init();
  28 /***************** BEGIN OF AUXILARY PART *********************
  29   ATTENTION: DO NOT REMOVE OR CHANGE SIGNATURES IN THIS SECTION
  30  **************************************************************/
  32 int _run()
  33 {
basic_module_init();
  36     return 0;
  37 }
  39 int _module_can_unload()
  40 {
  41     return (running==0);
  42 }
  44 int _module_exit_alt()
  45 {
  46     //running = 0;
  47     return 0;
  48 }
  50 /******************** Module Information structure ******************/
libsimple_sym _librun =
  53 {
  54     {
  55          0, 0, _module_can_unload, _module_exit_alt, _run
  56     }
  57 };
ModuleInfo _module_info =
  60 {
MODULEINFO_V1_MAGICNUM,
  62     sizeof(ModuleInfo),
  63     {1,0},      // Module version
ANY_CHDK_BRANCH, 0, OPT_ARCHITECTURE,           // Requirements of CHDK version
ANY_PLATFORM_ALLOWED,       // Specify platform dependency
  68     (int32_t)"CHDK backup & restore",
MTYPE_TOOL,                 // Temporary file shelter for CHDK files
  71     &_librun.base,
CONF_VERSION,               // CONF version
CAM_SCREEN_VERSION,         // CAM SCREEN version
ANY_VERSION,                // CAM SENSOR version
ANY_VERSION,                // CAM INFO version
  78     0,
  79 };
  81 /*************** END OF AUXILARY PART *******************/
  82 //-------------------------------------------------------------------
  83 // From public domain crc32 code
  84 //-------------------------------------------------------------------
  86 unsigned long crc32_for_byte(unsigned long r) {
  87     unsigned long j;
  88     for (j = 0; j < 8; j++) {
r = (r & 1? 0: (unsigned long)0xEDB88320) ^ r >> 1;
  90     }
  91     return r ^ (unsigned long)0xFF000000;
  92 }
  94 void crc32(const void *data, unsigned long n_bytes, unsigned long* crc) {
  95     static unsigned long ct[0x100] = {0};
  96     unsigned long i;
  97     if (!ct[0]) {
  98         for (i = 0; i < 0x100; i++) {
ct[i] = crc32_for_byte(i);
 100         }
 101     }
 102     for (i = 0; i < n_bytes; i++) {
 103         *crc = ct[(unsigned char)*crc ^ ((unsigned char*)data)[i]] ^ *crc >> 8;
 104     }
 105 }
 107 //-------------------------------------------------------------------
 108 // file operation wrappers, allows switching between open/fopen
 109 // if required on a camera
 110 //-------------------------------------------------------------------
 111 static int use_open_rather_than_fopen = 1;
 113 int read_file_f(char *fn, void *buf, int size)
 114 {
 115     int ret = -1;
FILE *fd = fopen(fn, "r+b");
 117     if (fd) {
ret = fread(buf, 1, size, fd);
fclose(fd);
 120         if (ret == size) {
ret = 0;
 122         }
 123         else {
ret = 1;
 125         }
 126     }
 127     return ret;
 128 }
 130 int read_file_o(char *fn, void *buf, int size)
 131 {
 132     int ret = -1;
 133     int fd = open(fn, O_RDONLY, 0777);
 134     if (fd >= 0) {
ret = read(fd, buf, size);
close(fd);
 137         if (ret == size) {
ret = 0;
 139         }
 140         else {
ret = 1;
 142         }
 143     }
 144     return ret;
 145 }
 147 int compute_file_crc_f(char *fn, void *buf, int size, int bufsize, unsigned long *crc)
 148 {
 149     int ret = 0;
 150     if (!fn || !buf || !crc || !bufsize) {
 151         return -1;
 152     }
FILE *fd = fopen(fn, "r+b");
 154     if (fd) {
 155         long chunk = bufsize<size?bufsize:size;
 156         while (1) {
 157             long r = fread(buf, 1, chunk, fd);
 158             if (r != chunk) {
 159                 if (r != size) {
ret = 1;
 161                     break;
 162                 }
 163             }
crc32(buf, r, crc);
size -= r;
 166             if (size <= 0) {
 167                 break;
 168             }
 169         }
fclose(fd);
 171     }
 172     return ret;
 173 }
 175 int compute_file_crc_o(char *fn, void *buf, int size, int bufsize, unsigned long *crc)
 176 {
 177     int ret = 0;
 178     if (!fn || !buf || !crc || !bufsize) {
 179         return -1;
 180     }
 181     int fd = open(fn, O_RDONLY, 0777);
 182     if (fd >= 0) {
 183         long chunk = bufsize<size?bufsize:size;
 184         while (1) {
 185             long r = read(fd, buf, chunk);
 186             if (r != chunk) {
 187                 if (r != size) {
ret = 1;
 189                     break;
 190                 }
 191             }
crc32(buf, r, crc);
size -= r;
 194             if (size <= 0) {
 195                 break;
 196             }
 197         }
close(fd);
 199     }
 200     return ret;
 201 }
 203 int write_file_f(char *fn, void *buf, int size)
 204 {
 205     int ret = -1;
FILE *fd = fopen(fn, "w+b");
 207     if (fd) {
ret = fwrite(buf, 1, size, fd);
fclose(fd);
 210         if (ret == size) {
ret = 0;
 212         }
 213         else {
ret = 1;
 215         }
 216     }
 217     return ret;
 218 }
 220 int write_file_o(char *fn, void *buf, int size)
 221 {
 222     int ret = -1;
 223     int fd = open(fn, O_WRONLY|O_CREAT|O_TRUNC, 0777);
 224     if (fd >= 0) {
ret = write(fd, buf, size);
close(fd);
 227         if (ret == size) {
ret = 0;
 229         }
 230         else {
ret = 1;
 232         }
 233     }
 234     return ret;
 235 }
 237 // reads size amount of bytes from file to buf
 238 // returns nonzero in case of error
 239 int read_file(char *fn, void *buf, int size)
 240 {
 241     if (use_open_rather_than_fopen) {
 242         return read_file_o(fn, buf, size);
 243     }
 244     return read_file_f(fn, buf, size);
 245 }
 247 // writes size amount of bytes from buf to file
 248 // returns nonzero in case of error
 249 int write_file(char *fn, void *buf, int size)
 250 {
 251     if (use_open_rather_than_fopen) {
 252         return write_file_o(fn, buf, size);
 253     }
 254     return write_file_f(fn, buf, size);
 255 }
 257 // computes crc of file
 258 // returns nonzero in case of error
 259 int compute_file_crc(char *fn, void *buf, int size, int bufsize, unsigned long *crc)
 260 {
 261     if (use_open_rather_than_fopen) {
 262         return compute_file_crc_o(fn, buf, size, bufsize, crc);
 263     }
 264     return compute_file_crc_f(fn, buf, size, bufsize, crc);
 265 }
 267 //-------------------------------------------------------------------
 268 // From glibc
 269 //-------------------------------------------------------------------
 271 int strcasecmp(const char *s1, const char *s2)
 272 {
 273   const unsigned char *p1 = (const unsigned char *) s1;
 274   const unsigned char *p2 = (const unsigned char *) s2;
 275   int result;
 276   if (p1 == p2)
 277     return 0;
 278   while ((result = tolower(*p1) - tolower(*p2++)) == 0)
 279     if (*p1++ == '\0')
 280       break;
 281   return result;
 282 }
 284 //-------------------------------------------------------------------
 285 // Following is to avoid another export from CHDK core
 286 //-------------------------------------------------------------------
 288 long mkdir_if_not_exist(const char *dirname)
 289 {
 290     // Check if directory exists and create it if it does not.
 291     if (stat(dirname,0) != 0) return mkdir(dirname);
 292     return 0;   // Success
 293 }
 295 //-------------------------------------------------------------------
 296 // Modified routines from gui_fselect.c
 297 //-------------------------------------------------------------------
 298 // Structure to hold info about a file or directory
 299 typedef struct
 300 {
 301     struct dirent   *de;
 302     unsigned long   size;
 303     unsigned long   mtime;
 304     unsigned char   deleted;        // deleted entry?
 305     unsigned char   isdir;          // directory?
 306     unsigned char   isparent;       // parent directory (..)?
 307     unsigned char   iscurrent;      // current directory (.)?
 308     unsigned char   isvalid;        // stat() call succeeded
 309     unsigned char   ishidden;       // hidden attribute?
 310 } fs_dirent;
 312 static int is_parent(const char *name)  { return (strcmp(name, "..") == 0); }
 313 static int is_current(const char *name)  { return (strcmp(name, ".") == 0); }
 315 // Custom readdir - populates extra info about the file or directory
 316 // Uses stat() after calling readdir() - we don't currently get this
 317 // extra data from the firmware function.
 318 static int fs_readdir(DIR *d, fs_dirent *de, const char* path)
 319 {
 320     char pbuf[MAX_PATH_LEN];
de->de = readdir(d);
de->size = 0;
de->mtime = 0;
de->deleted  = 0;
de->isparent = 0;
de->iscurrent = 0;
de->isdir = 0;
de->isvalid = 0;
de->ishidden = 0;
 332     if (de->de)
 333     {
 334         if (de->de->d_name[0] == 0xE5)
 335         {
de->deleted = 1;
 337         }
 338         else
 339         {
de->isparent  = is_parent(de->de->d_name);
de->iscurrent = is_current(de->de->d_name);
sprintf(pbuf, "%s%s%s", path, path[strlen(path)-1]=='/'?"":"/", de->de->d_name);
 344             struct stat st;
 345             if (de->isparent || de->iscurrent)
 346             {
de->isdir = 1;
de->isvalid = 1;
 349             }
 350             else if (stat(pbuf, &st) == 0)
 351             {
de->size  = st.st_size;
de->mtime = st.st_mtime;
de->isvalid = 1;
de->isdir = ((st.st_attrib & DOS_ATTR_DIRECTORY) != 0);
de->ishidden = ((st.st_attrib & DOS_ATTR_HIDDEN) != 0);
 357             }
 358         }
 360         return 1;
 361     }
 363     return 0;
 364 }
 366 // Process contents of named directory
 367 //  - for sub directories, process recursively if required (up to 'nested' levels deep)
 368 //  - for files, call 'file_process' function
 369 // Once file & directory processing done, call 'dir_process' function on input path
 370 static void process_dir(const char *parent, const char *name, int nested, void (*file_process)(const char *path, const char *file, fs_dirent *de), void (*dir_process)(const char *path, fs_dirent *de))
 371 {
DIR         *d;
fs_dirent   de;
 375     // Get full name
 376     char *path;
 377     if (name)
 378     {
path = malloc(strlen(parent) + strlen(name) + 2);
sprintf(path, "%s%s%s", parent, parent[strlen(parent)-1]=='/'?"":"/", name);
 381     }
 382     else
 383     {
path = (char*)parent;
 385     }
 387     // Open directory
d = opendir_chdk(path,OPENDIR_FL_CHDK_LFN);
 390     if (d)
 391     {
 392         // let caller get the dir name first
 393         if (dir_process)
dir_process(path, &de);
 396         // Process contents
 397         while (fs_readdir(d, &de, path))
 398         {
 399             if (!de.deleted)
 400             {
 401                 // Sub directory? Process recursively (but only 'nested' level deep)
 402                 if (de.isdir)
 403                 {
 404                     if (!de.isparent && !de.iscurrent && nested)
process_dir(path, de.de->d_name, nested-1, file_process, dir_process);
 406                 }
 407                 else if (file_process)
 408                 {
file_process(path, de.de->d_name, &de);
 410                 }
 411             }
 412         }
closedir(d);
 415     }
 417     if (name)
free(path);
 419 }
 422 //-------------------------------------------------------------------
 423 /*
 424  * File storage in memory
 425  * fs_fheader struct
 426  * file name (padded up to word boundary)
 427  * file content (padded up to word boundary)
 428  *
 429  * above repeated for each directory and its files, invalid magic means end of chain
 430  * directory is stored first to ease restoration
 431  */
 433 #define FMAGIC 0x004c4946 // FIL
 434 #define DMAGIC 0x00524944 // DIR
 436 enum rstatus {
 437     RS_OK = 0,
RS_NAMELONG,
RS_CRC,
RS_FERR,
 441 };
 443 // restore status
 444 const char *rsshumanL[] = {
 445     "OK",
 446     "Files not backed up",
 447     "Stored files corrupted",
 448     "Stored files corrupted",
 449     "Storage area corrupted",
 450     "A/CHDK exists, aborting",
 451 };
 453 // following struct needs to be an integer number of words
 454 typedef struct
 455 {
 456     unsigned long   magic;      // "FIL" for file, "DIR" for directory
 457     unsigned long   size;       // file size
 458     unsigned long   mtime;      // modification timestamp
 459     unsigned long   nlen;       // name length
 460     unsigned long   crc;        // crc32 of file data
 461     unsigned long   status;     // result code when restoring
 462 } fs_fheader;
 464 //-------------------------------------------------------------------
 466 const char *wl1[] = {"DISKBOOT.BIN", "PS.FIR", "PS.FI2", 0};
 467 static void *whitelist = 0;
 468 static unsigned storageneed = 0;
 469 static unsigned filecount = 0;
 470 static unsigned failcount = 0;
 471 static unsigned dircount = 0;
 472 static unsigned tfilecount = 0;
 473 static unsigned tdircount = 0;
 474 static unsigned fileprocd = 0;
 475 static unsigned dirprocd = 0;
 476 static void *starea = 0; // start of allocated exmem area
 477 static unsigned stmax = 0; // size of allocated exmem area
 478 static void *tmpbuf = 0; // temporary buffer (for crc check of files written)
 479 const unsigned tmpsiz = 32768; // temporary buffer size
 480 static void *storptr = 0;
 481 static unsigned long stcrc = 0; // crc of whole storage area
 483 unsigned wordpad(unsigned u)
 484 {
 485     return (u + 3) & 0xfffffffc;
 486 }
 488 // returns nonzero if pointer is inside the storage area
 489 int is_valid_stptr(void *p)
 490 {
 491     if (p>starea+stmax-sizeof(fs_fheader) || p<starea) {
 492         return 0;
 493     }
 494     return 1;
 495 }
 497 // checks whether name is allowed
 498 // returns nonzero if it is on whitelist
 499 // also returns nonzero if whitelist is NULL
 500 int iswhitelisted(const char *name)
 501 {
 502     if (whitelist == 0) {
 503         return 1;
 504     }
 505     char **wl = whitelist;
 506     char *s = *wl;
 507     while (s) {
 508         if (strcasecmp(name, s) == 0) {
 509             return 1;
 510         }
s = *(++wl);
 512     }
 513     return 0;
 514 }
 516 // moves *currptr from current, valid stored file/dir to the next (existing or not)
 517 // returns nonzero in case of success
 518 // if magic is nonzero, the next object with requested magic is searched
 519 int get_next_object(unsigned long magic, void **currptr)
 520 {
 521     char *p = *currptr;
 522     if (!is_valid_stptr(p)) {
 523         return 0;
 524     }
fs_fheader *fh = (void*)p;
 526     while (fh->magic==FMAGIC || fh->magic==DMAGIC) {
p += sizeof(fs_fheader) + wordpad(fh->nlen) + wordpad(fh->size);
 528         if (!is_valid_stptr(p)) {
 529             break;
 530         }
fh = (void*)p;
 532         if (!magic || fh->magic == magic) {
 533             *currptr = (void*)p;
 534             return 1;
 535         }
 536     }
 537     return 0;
 538 }
 540 // returns pointer to current object's name or NULL when invalid
 541 char *get_object_name(void *p)
 542 {
 543     if (!is_valid_stptr(p)) {
 544         return 0;
 545     }
fs_fheader *fh = p;
p += sizeof(fs_fheader);
 548     if (!is_valid_stptr(p) || !is_valid_stptr(p+fh->nlen)) {
 549         return 0;
 550     }
 551     return (char*)p;
 552 }
 554 // returns pointer to current object's data or NULL when invalid
 555 char *get_object_data(void *p)
 556 {
 557     if (!is_valid_stptr(p)) {
 558         return 0;
 559     }
fs_fheader *fh = p;
p += sizeof(fs_fheader) + wordpad(fh->nlen);
 562     if (!is_valid_stptr(p) || !is_valid_stptr(p+fh->size)) {
 563         return 0;
 564     }
 565     return (char*)p;
 566 }
 568 // callback function for process_dir, counts files and their sizes
 569 void fproc_totalsize(const char *path, const char *file, fs_dirent *de)
 570 {
 571     if (whitelist && !iswhitelisted(file)) return;
storageneed += wordpad(de->size);
storageneed += wordpad(strlen(path) + 1 + strlen(file) + 1);
storageneed += sizeof(fs_fheader);
filecount += 1;
 576 }
 578 // callback function for process_dir, counts directories
 579 void dproc_count(const char *path, __attribute__ ((unused))fs_dirent *de)
 580 {
 581     if (whitelist && !iswhitelisted(path)) return;
storageneed += wordpad(strlen(path) + 1);
storageneed += sizeof(fs_fheader);
dircount += 1;
 585 }
 587 // callback function for process_dir, stores directories
 588 void dproc_store(const char *path, fs_dirent *de)
 589 {
 590     if (whitelist && !iswhitelisted(path)) return;
fs_fheader *fh = storptr;
fh->magic = DMAGIC;
fh->size = 0;
fh->mtime = de->mtime;
fh->nlen = strlen(path) + 1;
fh->crc = 0;
storptr += sizeof(fs_fheader);
strcpy(storptr, path);
storptr += wordpad(fh->nlen);
dirprocd++;
 601 }
 603 // callback function for process_dir, stores files
 604 void fproc_store(const char *path, const char *file, fs_dirent *de)
 605 {
 606     if (whitelist && !iswhitelisted(file)) return;
fs_fheader *fh = storptr;
fh->magic = FMAGIC;
fh->size = de->size;
fh->mtime = de->mtime;
fh->nlen = strlen(path) + 1 + strlen(file) + 1;
fh->crc = 0;
storptr += sizeof(fs_fheader);
sprintf(storptr, "%s%s%s", path, path[strlen(path)-1]=='/'?"":"/", file);
 615     char *name = storptr;
storptr += wordpad(fh->nlen);
 618     if ( read_file(name, storptr, fh->size) ) {
failcount++;
storptr -= sizeof(fs_fheader);
storptr -= wordpad(fh->nlen);
console_add_line(file);
 623     }
 624     else {
crc32(storptr, fh->size, &fh->crc); // fh->crc is set to zero prior to this
storptr += wordpad(fh->size);
fileprocd++;
 628     }
 629 }
 631 // attempts to allocate an exmem area that is large enough to backup files
 632 // uses exmem types that are unlikely to be used and are widely available
 633 // uses globals
 634 void alloc_storage()
 635 {
 636     const char *exmemtypes[] = {"EXMEM_FIRMUP", "EXMEM_FAMODE", 0};
 637     const unsigned cushion = 128; // extra data to allocate (for eventual cached use)
 638     unsigned n, i;
exmem_alloc_info ai;
storageneed += sizeof(fs_fheader); // for the last entry
storageneed += tmpsiz; // for temp buffer
starea = 0;
i = 0;
 644     while (exmemtypes[i]) {
 645         for (n=0; n<exmem_type_count; n++) {
 646             if (strncmp(exmemtypes[i],get_exmem_type_name(n),strlen(exmemtypes[i]))==0) {
get_exmem_type_status(n, &ai);
 648                 if (!ai.len) {
starea = exmem_alloc_uncached(n, storageneed+cushion, 0);
get_exmem_type_status(n, &ai);
 651                     if (ai.len-cushion < storageneed) {
starea = 0;
exmem_free_uncached(n);
 654                         char buf[64];
sprintf(buf,"%s need %x got %x",exmemtypes[i],storageneed,ai.len);
console_add_line(buf);
 657                     }
 658 #if 1
 659                     else {
 660                         char buf[64];
sprintf(buf,"%s adr %x",exmemtypes[i],starea);
console_add_line(buf);
 663                     }
 664 #endif
 665                 }
 666                 break;
 667             }
 668         }
 669         if (starea) {
starea += cushion/2; // leave a safety border on both start and end of allocation
stmax = storageneed - tmpsiz;
tmpbuf = starea + stmax;
storptr = starea;
 674             break;
 675         }
i++;
 677     }
 678 }
 680 // restores stored files to directory 'dest'
 681 // test: 0 - write to card, 1 - check only
 682 // returns 0 for OK
 683 int restore(const char *dest, int test)
 684 {
 685     char buf[256];
 686     int ret = 0;
 687     if (!starea) {
 688         return 1;
 689     }
 690     if (!test && strlen(dest)>2) mkdir_if_not_exist(dest);
storptr = starea;
 692     if (!is_valid_stptr(storptr)) {
 693         return 2;
 694     }
fs_fheader *fh = storptr;
 696     while (1) {
 697         if (fh->magic==DMAGIC) {
 698             char *lastdir = get_object_name(storptr);
lastdir += 2; // chop off A/
 700             if (strlen(dest)+1+strlen(lastdir) > 255) {
fh->status = RS_NAMELONG;
ret |= 0x40000000;
 703                 if (!get_next_object(0, &storptr)) {
 704                     break;
 705                 }
 706                 continue;
 707             }
sprintf(buf,"%s/%s",dest,lastdir);
 709             if (!test) {
ret |= mkdir_if_not_exist(buf)?0x20000000:0;
 711                 if (stat(buf,0) == 0) {
tdircount--;
 713                 }
 714             }
 715             else {
msleep(10);
tdircount--;
 718             }
 719         }
 720         else if (fh->magic==FMAGIC) {
 721             if (strlen(dest)+1+fh->nlen-2 > 255) {
fh->status = RS_NAMELONG;
ret |= 0x40000000;
 724                 if (!get_next_object(0, &storptr)) {
 725                     break;
 726                 }
 727                 continue;
 728             }
 729             unsigned long crc = 0;
 730             char *fn = get_object_name(storptr);
 731             if (fn) {
fn +=2; // chop off A/
 733             }
 734             else {
 735                 return ret + 3;
 736             }
 737             char *fd = get_object_data(storptr);
 738             if (fd) {
crc32(fd, fh->size, &crc); // crc is set to zero prior to this
 740                 if (crc != fh->crc) {
fh->status = RS_CRC;
ret |= 0x10000000;
 743                     if (!get_next_object(0, &storptr)) {
 744                         break;
 745                     }
 746                     continue;
 747                 }
 748             }
sprintf(buf,"%s/%s",dest,fn);
 750             if (!test) {
 752                 if ( write_file(buf, fd, fh->size) ) {
console_add_line(fn);
fh->status = RS_FERR;
ret |= 0x08000000;
 756                 }
 757                 else {
 758 #if (FSCRC_CALC == 1)
crc = 0;
 760                     if ( compute_file_crc(buf, tmpbuf, fh->size, tmpsiz, &crc) ) {
console_add_line(fn);
fh->status = RS_FERR;
ret |= 0x04000000;
 764                     }
 765                     else {
 766                         if ( fh->crc != crc) {
console_add_line(fn);
fh->status = RS_FERR;
ret |= 0x02000000;
 770                         }
 771                         else {
 772                             struct utimbuf t;
t.actime = t.modtime = fh->mtime;
utime(buf, &t);
tfilecount--;
 776                         }
 777                     }
 778 #else // (FSCRC_CALC != 1)
 779                     struct utimbuf t;
t.actime = t.modtime = fh->mtime;
utime(buf, &t);
tfilecount--;
 783 #endif
 784                 }
 786             }
 787             else {
msleep(10);
tfilecount--;
 790             }
 791         }
 792         else {
 793             break;
 794         }
 796         // advance pointer, error out if impossible
 797         if (!get_next_object(0, &storptr)) {
ret += 4;
 799             break;
 800         }
fh = storptr;
 802     }
 803     return ret;
 804 }
 806 //-------------------------------------------------------------------
 808 int can_boot_from_fat32()
 809 {
 810     if (conf.platformid > 0x3222) { // r47+
 811         return 1;
 812     }
 813     return 0;
 814 }
 816 //-------------------------------------------------------------------
 818 char *help1[] = {
 819     "Utility for temporarily storing CHDK",
 820     "system files in RAM, allowing to format",
 821     "card via Canon menu.",
 822     "Usage:",
 823     "1. Start this utility, press SET to backup",
 824     "2. Leave the utility, format card in Canon",
 825     "   menu. Do NOT switch off the camera.",
 826     "3. Start this utility again, press SET",
 827     "4. Make card bootable via CHDK menu",
 828     "5. Restart camera before starting to shoot",
 829     "IMPORTANT",
 830     "Do not format card if you get errors.",
 831     "Only the following files are stored:",
 832     "- Everything in CHDK directory.",
 833     "- DISKBOOT.BIN, PS.FIR, PS.FI2",
 834     "WARNING",
 835 //    "Do NOT use this on partitioned cards!",
 836 //    "Cards larger than 32GB will lose autoboot!",
 837 //    "Cards larger than 2GB will lose autoboot",
 838 //    "on cameras released prior to 2011 !",
 839     "Excessive amount of data in CHDK direcory",
 840     "may cause a crash while making backup!",
 841     "Do not use this on mission critical files!",
 842 };
 844 char *help_partwarn = "Do NOT format, card will lose partitions!";
 845 char *help_bootwarn = "Card will lose autoboot if formatted!";
 847 //-------------------------------------------------------------------
 850 /*************** GUI MODULE *******************/
 852 #include "gui_mbox.h"
 853 #include "keyboard.h"
 855 void gui_fileshelter_menu_kbd_process();
 856 int gui_fileshelter_kbd_process();
 857 void gui_fileshelter_draw();
gui_handler GUI_MODE_FILESHELTER = 
 860 /*GUI_MODE_FILESHELTER*/   { GUI_MODE_MODULE, gui_fileshelter_draw, gui_fileshelter_kbd_process, gui_fileshelter_menu_kbd_process, 0, 0 };
 862 static unsigned int cardsize;
 863 static int canfat32boot;
 864 static int partcount;
 865 static int noformatyet;
 867 static int fileshelter_mode = 0;
 868 static unsigned disph = 0, dispw = 0, helph = 0;
 869 static unsigned restore_status;
 870 static unsigned scrolly;
 871 static int fileshelter_redraw;
gui_handler *fileshelter_old_guimode;
 874 int gui_fileshelter_kbd_process()
 875 {
 876     switch (kbd_get_autoclicked_key())
 877     {
 878     case KEY_SET:
 879         if (starea) {
 880             if (stat("A/CHDK",0) != 0) {
 881                 // CHDK dir not found, assuming formatted card
 882                 unsigned long crc = 0;
tfilecount = filecount;
tdircount = dircount;
fileshelter_redraw = 8;
msleep(100); // give the display a chance to update
crc32(starea, stmax, &crc);
 888                 if (crc == stcrc) {
fileshelter_redraw = 5;
restore_status = restore("A",0);
fileshelter_redraw = 3;
 892                 }
 893                 else {
restore_status = 4;
fileshelter_redraw = 3;
 896                 }
 897             }
 898             else {
 899                 // CHDK dir present, doing a test run only
 900                 unsigned long crc = 0;
tfilecount = filecount;
tdircount = dircount;
fileshelter_redraw = 8;
msleep(100); // give the display a chance to update
crc32(starea, stmax, &crc);
 906                 if (crc == stcrc) {
fileshelter_redraw = 11;
restore_status = restore("A",1);
fileshelter_redraw = 10;
 910                 }
 911                 else {
restore_status = 4;
fileshelter_redraw = 10;
 914                 }
 915             }
 916         }
 917         else {
fileshelter_redraw = 6;
storageneed = 0;
filecount = 0;
dircount = 0;
whitelist = wl1;
process_dir("A/", 0, 0, fproc_totalsize, dproc_count);
whitelist = 0;
process_dir("A/CHDK", 0, 999, fproc_totalsize, dproc_count);
alloc_storage();
 927             if (starea) {
fileshelter_redraw = 7;
failcount = 0;
fileprocd = 0;
dirprocd = 0;
whitelist = wl1;
process_dir("A/", 0, 0, fproc_store, dproc_store);
whitelist = 0;
process_dir("A/CHDK", 0, 999, fproc_store, dproc_store);
fs_fheader *fh = storptr;
fh->magic = 0;
stcrc = 0;
crc32(starea, stmax, &stcrc);
 940             }
fileshelter_redraw = 1;
 942         }
 943         break;
 944     case KEY_DOWN:
 945         if (scrolly < sizeof(help1)/sizeof(char*)-1) {
scrolly++;
 947         }
 948         else {
scrolly = 0;
 950         }
fileshelter_redraw = 4;
 952         break;
 953     case KEY_UP:
 954         if (scrolly > 0) {
scrolly--;
 956         }
 957         else {
scrolly = sizeof(help1)/sizeof(char*)-1;
 959         }
fileshelter_redraw = 4;
 961         break;
 962     case KEY_SHOOT_HALF:
fileshelter_mode = fileshelter_mode==0?1:0;
 964 #if 0
 965         if (fileshelter_mode) {
use_open_rather_than_fopen = 0;
 967         }
 968         else {
use_open_rather_than_fopen = 1;
 970         }
 971 #endif
fileshelter_redraw = 2;
 973         break;
 974     }
 975     return 0;
 976 }
 978 //-------------------------------------------------------------------
 980 int basic_module_init()
 981 {
 982     if (!running) {
running = 1;
disph = camera_screen.height / FONT_HEIGHT;
dispw = camera_screen.width / FONT_WIDTH;
helph = camera_screen.height / FONT_HEIGHT - 5;
noformatyet = 1;
 988     }
 989     else {
noformatyet = stat("A/CHDK",0)?0:1;
 991     }
scrolly = 0;
cardsize = GetTotalCardSpaceKb();
partcount = get_part_count();
canfat32boot = can_boot_from_fat32();
fileshelter_redraw = 2;
fileshelter_old_guimode = gui_set_mode(&GUI_MODE_FILESHELTER);
1000     return 1;
1001 }
1003 void gui_fileshelter_menu_kbd_process()
1004 {
1005     if (!starea) {
running = 0;
1007     }
gui_set_mode(fileshelter_old_guimode);
1010 }
1012 void gui_fileshelter_draw()
1013 {
1014     static int selfupdate = 0;
1015     static int warnshown = 0;
1017     int fredraw = fileshelter_redraw;
fileshelter_redraw = 0;
1020     if (fredraw || selfupdate) {
1022         if (fredraw == 2)
1023         {
draw_rectangle(camera_screen.disp_left, 0, camera_screen.disp_right, camera_screen.height-1, MAKE_COLOR(COLOR_BLACK, COLOR_BLACK), RECT_BORDER0|DRAW_FILLED);
draw_string(camera_screen.disp_left, 0, "CHDK backup & restore utility", MAKE_COLOR(COLOR_WHITE, COLOR_BLACK));
draw_string(camera_screen.disp_left, FONT_HEIGHT, !starea?"SET-backup  MENU-exit \x18\x19-help":noformatyet?"SET-check   MENU-exit \x18\x19-help":"SET-restore MENU-exit \x18\x19-help", MAKE_COLOR(COLOR_BLACK, COLOR_WHITE));
1028 #if 0
1029             if (fileshelter_mode) { // meant to be temporary
draw_char(camera_screen.disp_left+FONT_WIDTH*30, 0, '*', MAKE_COLOR(COLOR_BLACK, COLOR_BLUE));
1031             }
1032             else {
draw_char(camera_screen.disp_left+FONT_WIDTH*30, 0, ' ', MAKE_COLOR(COLOR_BLACK, COLOR_BLUE));
1034             }
1035 #endif
fredraw = 4;
selfupdate = 0;
1039         }
1040         if (fredraw == 3)
1041         {
draw_rectangle(camera_screen.disp_left, FONT_HEIGHT*2, camera_screen.disp_right, FONT_HEIGHT*5-1, MAKE_COLOR(COLOR_BLACK, COLOR_BLACK), RECT_BORDER0|DRAW_FILLED);
1043             if (tfilecount || tdircount) {
sprintf(osdbuf, "Not restored: %u files, %u dirs", tfilecount, tdircount);
1045                 if (sizeof(osdbuf)>dispw) osdbuf[dispw] = 0;
draw_string(camera_screen.disp_left, 2*FONT_HEIGHT, osdbuf, MAKE_COLOR(COLOR_BLACK, COLOR_YELLOW));
1047             }
1048             unsigned rssl = restore_status & 0xff;
1049             char *hrsm = "???";
1050             if (rssl < sizeof(rsshumanL)/sizeof(char*)) {
hrsm = (char*)rsshumanL[rssl];
1052             }
sprintf(osdbuf, restore_status?"Restore status: %08x":"Restore status:", restore_status);
draw_string(camera_screen.disp_left, 3*FONT_HEIGHT, osdbuf, MAKE_COLOR(COLOR_BLACK, restore_status?COLOR_RED:COLOR_GREEN));
sprintf(osdbuf, "%s", hrsm);
draw_string(camera_screen.disp_left, 4*FONT_HEIGHT, osdbuf, MAKE_COLOR(COLOR_BLACK, restore_status?COLOR_RED:COLOR_GREEN));
selfupdate = 0;
1058         }
1059         if (fredraw == 10)
1060         {
draw_rectangle(camera_screen.disp_left, FONT_HEIGHT*2, camera_screen.disp_right, FONT_HEIGHT*5-1, MAKE_COLOR(COLOR_BLACK, COLOR_BLACK), RECT_BORDER0|DRAW_FILLED);
1062             if (tfilecount || tdircount) {
sprintf(osdbuf, "Failed: %u files, %u dirs", tfilecount, tdircount);
1064                 if (sizeof(osdbuf)>dispw) osdbuf[dispw] = 0;
draw_string(camera_screen.disp_left, 2*FONT_HEIGHT, osdbuf, MAKE_COLOR(COLOR_BLACK, COLOR_YELLOW));
1066             }
1067             unsigned rssl = restore_status & 0xff;
1068             char *hrsm = "???";
1069             if (rssl < sizeof(rsshumanL)/sizeof(char*)) {
hrsm = (char*)rsshumanL[rssl];
1071             }
sprintf(osdbuf, restore_status?"Test status: %08x":"Test status:", restore_status);
draw_string(camera_screen.disp_left, 3*FONT_HEIGHT, osdbuf, MAKE_COLOR(COLOR_BLACK, restore_status?COLOR_RED:COLOR_GREEN));
sprintf(osdbuf, "%s", hrsm);
draw_string(camera_screen.disp_left, 4*FONT_HEIGHT, osdbuf, MAKE_COLOR(COLOR_BLACK, restore_status?COLOR_RED:COLOR_GREEN));
selfupdate = 0;
1077         }
1078         if (fredraw == 1)
1079         {
draw_rectangle(camera_screen.disp_left, FONT_HEIGHT*2, camera_screen.disp_right, FONT_HEIGHT*5-1, MAKE_COLOR(COLOR_BLACK, COLOR_BLACK), RECT_BORDER0|DRAW_FILLED);
sprintf(osdbuf, "%u files, %u dirs, total %u bytes", filecount, dircount, storageneed);
draw_string(camera_screen.disp_left, 2*FONT_HEIGHT, osdbuf, MAKE_COLOR(COLOR_BLACK, COLOR_WHITE));
1083             if (starea && !failcount) {
draw_string(camera_screen.disp_left, 3*FONT_HEIGHT, "Backup successful", MAKE_COLOR(COLOR_BLACK, COLOR_GREEN));
1085             }
1086             else if (failcount) {
sprintf(osdbuf, "Backup failed to store %u file(s)", failcount);
draw_string(camera_screen.disp_left, 3*FONT_HEIGHT, osdbuf, MAKE_COLOR(COLOR_BLACK, COLOR_YELLOW));
draw_string(camera_screen.disp_left, 4*FONT_HEIGHT, "See CHDK console for filename(s)", MAKE_COLOR(COLOR_BLACK, COLOR_YELLOW));
1090             }
1091             else if (!starea) {
draw_string(camera_screen.disp_left, 3*FONT_HEIGHT, "Backup failed - insufficient memory", MAKE_COLOR(COLOR_BLACK, COLOR_RED));
1093             }
1094             else {
draw_string(camera_screen.disp_left, 3*FONT_HEIGHT, "Backup failed", MAKE_COLOR(COLOR_BLACK, COLOR_RED));
1096             }
selfupdate = 0;
1098         }
1099         if (fredraw == 4)
1100         {
draw_rectangle(camera_screen.disp_left, FONT_HEIGHT*5, camera_screen.disp_right, camera_screen.height-1, MAKE_COLOR(COLOR_BLACK, COLOR_BLACK), RECT_BORDER0|DRAW_FILLED);
1102             unsigned y;
1103             for (y=0; y<helph; y++) {
1104                 if (scrolly+y < sizeof(help1)/sizeof(char*)) {
draw_string(camera_screen.disp_left, (5+y)*FONT_HEIGHT, help1[scrolly+y], MAKE_COLOR(COLOR_BLACK, COLOR_GREY));
1106                 }
1107             }
1108             if (!warnshown) {
warnshown = 1;
fredraw = 9;
1111             }
selfupdate = 0;
1113         }
1114         if (fredraw == 5)
1115         {
draw_rectangle(camera_screen.disp_left, FONT_HEIGHT*2, camera_screen.disp_right, FONT_HEIGHT*5-1, MAKE_COLOR(COLOR_BLACK, COLOR_BLACK), RECT_BORDER0|DRAW_FILLED);
draw_string(camera_screen.disp_left, 2*FONT_HEIGHT, "Restoring ...", MAKE_COLOR(COLOR_BLACK, COLOR_GREEN));
selfupdate = 5;
1119         }
1120         if (fredraw == 11)
1121         {
draw_rectangle(camera_screen.disp_left, FONT_HEIGHT*2, camera_screen.disp_right, FONT_HEIGHT*5-1, MAKE_COLOR(COLOR_BLACK, COLOR_BLACK), RECT_BORDER0|DRAW_FILLED);
draw_string(camera_screen.disp_left, 2*FONT_HEIGHT, "Testing ...", MAKE_COLOR(COLOR_BLACK, COLOR_GREEN));
selfupdate = 5;
1125         }
1126         if (fredraw == 6)
1127         {
draw_rectangle(camera_screen.disp_left, FONT_HEIGHT*2, camera_screen.disp_right, FONT_HEIGHT*5-1, MAKE_COLOR(COLOR_BLACK, COLOR_BLACK), RECT_BORDER0|DRAW_FILLED);
draw_string(camera_screen.disp_left, 2*FONT_HEIGHT, "Counting ...", MAKE_COLOR(COLOR_BLACK, COLOR_GREEN));
selfupdate = 6;
1131         }
1132         if (fredraw == 7)
1133         {
draw_rectangle(camera_screen.disp_left, FONT_HEIGHT*2, camera_screen.disp_right, FONT_HEIGHT*5-1, MAKE_COLOR(COLOR_BLACK, COLOR_BLACK), RECT_BORDER0|DRAW_FILLED);
draw_string(camera_screen.disp_left, 2*FONT_HEIGHT, "Backing up ...", MAKE_COLOR(COLOR_BLACK, COLOR_GREEN));
selfupdate = 7;
1137         }
1138         if (fredraw == 8)
1139         {
draw_rectangle(camera_screen.disp_left, FONT_HEIGHT*2, camera_screen.disp_right, FONT_HEIGHT*5-1, MAKE_COLOR(COLOR_BLACK, COLOR_BLACK), RECT_BORDER0|DRAW_FILLED);
draw_string(camera_screen.disp_left, 2*FONT_HEIGHT, "Verifying integrity ...", MAKE_COLOR(COLOR_BLACK, COLOR_GREEN));
selfupdate = 6;
1143         }
1144         if (fredraw == 9)
1145         {
draw_rectangle(camera_screen.disp_left, FONT_HEIGHT*2, camera_screen.disp_right, FONT_HEIGHT*5-1, MAKE_COLOR(COLOR_BLACK, COLOR_BLACK), RECT_BORDER0|DRAW_FILLED);
1148             // draw card related warnings if any
1149             if (canfat32boot && cardsize>32*1024*1024) {
draw_string(camera_screen.disp_left, 2*FONT_HEIGHT, help_bootwarn, MAKE_COLOR(COLOR_BLACK, COLOR_RED));
1151             }
1152             else if (!canfat32boot && cardsize>2*1024*1024) {
draw_string(camera_screen.disp_left, 2*FONT_HEIGHT, help_bootwarn, MAKE_COLOR(COLOR_BLACK, COLOR_RED));
1154             }
1155             if (partcount > 1) {
draw_string(camera_screen.disp_left, 3*FONT_HEIGHT, help_partwarn, MAKE_COLOR(COLOR_BLACK, COLOR_RED));
1157             }
1159         }
1161         if (selfupdate == 5) {
1162             static unsigned fc=0,dc=0;
1163             if ((tfilecount!=fc) || (tdircount!=dc)) {
sprintf(osdbuf, "Remaining: %u files, %u dirs       ", tfilecount, tdircount);
1165                 if (sizeof(osdbuf)>dispw) osdbuf[dispw] = 0;
draw_string(camera_screen.disp_left, 3*FONT_HEIGHT, osdbuf, MAKE_COLOR(COLOR_BLACK, COLOR_GREEN));
1167             }
fc = tfilecount;
dc = tdircount;
1170         }
1171         else if (selfupdate == 6) {
1172             static int phase = 0;
1173             const char *pc = "/-\\|";
draw_char(camera_screen.disp_left, 3*FONT_HEIGHT, pc[phase&3], MAKE_COLOR(COLOR_BLACK, COLOR_GREEN));
phase++;
1176         }
1177         else if (selfupdate == 7) {
1178             static unsigned fc=0,dc=0;
1179             if ((fileprocd!=fc) || (dirprocd!=dc)) {
sprintf(osdbuf, "Remaining: %u files, %u dirs       ", filecount-fileprocd, dircount-dirprocd);
1181                 if (sizeof(osdbuf)>dispw) osdbuf[dispw] = 0;
draw_string(camera_screen.disp_left, 3*FONT_HEIGHT, osdbuf, MAKE_COLOR(COLOR_BLACK, COLOR_GREEN));
1183             }
fc = fileprocd;
dc = dirprocd;
1186         }
1188     }
1190 }