diff options
Diffstat (limited to 'apps/plugins/tagcache/tagcache.c')
| -rw-r--r-- | apps/plugins/tagcache/tagcache.c | 583 |
1 files changed, 511 insertions, 72 deletions
diff --git a/apps/plugins/tagcache/tagcache.c b/apps/plugins/tagcache/tagcache.c index 55ca2e2695..cce9efbed9 100644 --- a/apps/plugins/tagcache/tagcache.c +++ b/apps/plugins/tagcache/tagcache.c @@ -22,16 +22,19 @@ /*Plugin Includes*/ #include "plugin.h" +#include "errno.h" + /* Redefinitons of ANSI C functions. */ #include "lib/wrappers.h" #include "lib/helper.h" static void thread_create(void); -static void thread(void); /* the thread running it all */ +static void thread(void); /* the thread running commit*/ static void allocate_tempbuf(void); static void free_tempbuf(void); static bool do_timed_yield(void); static void _log(const char *fmt, ...); +static bool logdump(bool append); /*Aliases*/ #if 0 #ifdef ROCKBOX_HAS_LOGF @@ -41,7 +44,6 @@ static void _log(const char *fmt, ...); #endif #endif - #define logf _log #define sleep rb->sleep #define qsort rb->qsort @@ -49,6 +51,7 @@ static void _log(const char *fmt, ...); #define write(x,y,z) rb->write(x,y,z) #define ftruncate rb->ftruncate #define remove rb->remove +#define rename rb->rename #define vsnprintf rb->vsnprintf #define mkdir rb->mkdir @@ -60,20 +63,26 @@ static void _log(const char *fmt, ...); #define current_tick (*rb->current_tick) #define crc_32(x,y,z) rb->crc_32(x,y,z) +#define plugin_get_buffer rb->plugin_get_buffer - -#if !defined(SIMULATOR) && !defined(APPLICATION) - -#define errno (*rb->__errno()) -#endif -#define ENOENT 2 /* No such file or directory */ -#define EEXIST 17 /* File exists */ #define MAX_LOG_SIZE 16384 #define EV_EXIT MAKE_SYS_EVENT(SYS_EVENT_CLS_PRIVATE, 0xFF) -#define EV_ACTION MAKE_SYS_EVENT(SYS_EVENT_CLS_PRIVATE, 0x02) #define EV_STARTUP MAKE_SYS_EVENT(SYS_EVENT_CLS_PRIVATE, 0x01) +#define BACKUP_DIRECTORY PLUGIN_APPS_DATA_DIR "/db_commit" + +#define RC_SUCCESS 0 +#define RC_USER_CANCEL 2 + +enum fcpy_op_flags +{ + FCPY_MOVE = 0x00, /* Is a move operation (default) */ + FCPY_COPY = 0x01, /* Is a copy operation */ + FCPY_OVERWRITE = 0x02, /* Overwrite destination */ + FCPY_EXDEV = 0x04, /* Actually copy/move across volumes */ +}; + /* communication to the worker thread */ static struct { @@ -85,6 +94,23 @@ static struct long last_useraction_tick; } gThread; +/* status of db and commit */ +static struct +{ + long last_check; + bool do_commit; + bool auto_commit; + bool commit_ready; + bool db_exists; + bool have_backup; + bool bu_exists; +} gStatus; + +static unsigned char logbuffer[MAX_LOG_SIZE + 1]; +static int log_font_h = -1; +static int logindex; +static bool logwrap; +static bool logenabled = true; /*Support Fns*/ /* open but with a builtin printf for assembling the path */ @@ -103,8 +129,6 @@ int open_pathfmt(char *buf, size_t size, int oflag, const char *pathfmt, ...) static void sleep_yield(void) { - rb->queue_remove_from_head(&gThread.queue, EV_ACTION); - rb->queue_post(&gThread.queue, EV_ACTION, 0); sleep(1); #undef yield rb->yield(); @@ -159,18 +183,10 @@ bool user_check_tag(int index_type, char* build_idx_buf) /* paste the whole tagcache.c file */ #include "../tagcache.c" -static bool logdump(bool append); -static unsigned char logbuffer[MAX_LOG_SIZE + 1]; -static int log_font_h = -1; -static int logindex; -static bool logwrap; -static bool logenabled = true; - static void check_logindex(void) { if(logindex >= MAX_LOG_SIZE) { - /* wrap */ logdump(true); //logwrap = true; logindex = 0; @@ -196,7 +212,6 @@ static void _log(const char *fmt, ...) return; } - #ifdef USB_ENABLE_SERIAL int old_logindex = logindex; #endif @@ -291,13 +306,11 @@ static bool logdisplay(void) /* if negative, will be set 0 to zero later */ } - rb->lcd_clear_display(); if(gThread.user_index < 0 || gThread.user_index >= MAX_LOG_SIZE) gThread.user_index = 0; - if(logwrap) i = logindex; else @@ -373,7 +386,7 @@ static bool logdump(bool append) /* nothing is logged just yet */ return false; } - if (!append) + if (append) { flags = O_CREAT|O_WRONLY|O_APPEND; } @@ -431,7 +444,6 @@ static bool do_timed_yield(void) static long wakeup_tick = 0; if (TIME_AFTER(current_tick, wakeup_tick)) { - yield(); wakeup_tick = current_tick + (HZ/5); @@ -440,6 +452,402 @@ static bool do_timed_yield(void) return false; } +/* copy/move a file */ +static int fcpy(const char *src, const char *target, + unsigned int flags, bool (*poll_cancel)(const char *)) +{ + int rc = -1; + + while (!(flags & (FCPY_COPY | FCPY_EXDEV))) { + if ((flags & FCPY_OVERWRITE) || !file_exists(target)) { + /* Rename and possibly overwrite the file */ + if (poll_cancel && poll_cancel(src)) { + rc = RC_USER_CANCEL; + } else { + rc = rename(src, target); + } + + #ifdef HAVE_MULTIVOLUME + if (rc < 0 && errno == EXDEV) { + /* Failed because cross volume rename doesn't work; force + a move instead */ + flags |= FCPY_EXDEV; + break; + } + #endif /* HAVE_MULTIVOLUME */ + } + + return rc; + } + + /* See if we can get the plugin buffer for the file copy buffer */ + size_t buffersize; + char *buffer = (char *) plugin_get_buffer(&buffersize); + if (buffer == NULL || buffersize < 512) { + /* Not large enough, try for a disk sector worth of stack + instead */ + buffersize = 512; + buffer = (char *)alloca(buffersize); + } + + if (buffer == NULL) { + return -1; + } + + buffersize &= ~0x1ff; /* Round buffer size to multiple of sector + size */ + + int src_fd = open(src, O_RDONLY); + if (src_fd >= 0) { + int oflag = O_WRONLY|O_CREAT; + + if (!(flags & FCPY_OVERWRITE)) { + oflag |= O_EXCL; + } + + int target_fd = open(target, oflag, 0666); + if (target_fd >= 0) { + off_t total_size = 0; + off_t next_cancel_test = 0; /* No excessive button polling */ + + rc = RC_SUCCESS; + + while (rc == RC_SUCCESS) { + if (total_size >= next_cancel_test) { + next_cancel_test = total_size + 0x10000; + if (poll_cancel && poll_cancel(src)) { + rc = RC_USER_CANCEL; + break; + } + } + + ssize_t bytesread = read(src_fd, buffer, buffersize); + if (bytesread <= 0) { + if (bytesread < 0) { + rc = -1; + } + /* else eof on buffer boundary; nothing to write */ + break; + } + + ssize_t byteswritten = write(target_fd, buffer, bytesread); + if (byteswritten < bytesread) { + /* Some I/O error */ + rc = -1; + break; + } + + total_size += byteswritten; + + if (bytesread < (ssize_t)buffersize) { + /* EOF with trailing bytes */ + break; + } + } + + if (rc == RC_SUCCESS) { + /* If overwriting, set the correct length if original was + longer */ + rc = ftruncate(target_fd, total_size); + } + + close(target_fd); + + if (rc != RC_SUCCESS) { + /* Copy failed. Cleanup. */ + remove(target); + } + } + + close(src_fd); + } + + if (rc == RC_SUCCESS && !(flags & FCPY_COPY)) { + /* Remove the source file */ + rc = remove(src); + } + + return rc; +} + +static bool backup_restore_tagcache(bool backup) +{ + struct master_header tcmh; + char path[MAX_PATH]; + char bu_path[MAX_PATH]; + int fd; + int rc; + + if (backup) + { + if (!rb->dir_exists(BACKUP_DIRECTORY)) + mkdir(BACKUP_DIRECTORY); + snprintf(path, sizeof(path), "%s/"TAGCACHE_FILE_MASTER, tc_stat.db_path); + snprintf(bu_path, sizeof(bu_path), "%s/"TAGCACHE_FILE_MASTER, BACKUP_DIRECTORY); + } + else + { + if (!rb->dir_exists(BACKUP_DIRECTORY)) + return false; + snprintf(path, sizeof(path), "%s/"TAGCACHE_FILE_MASTER, BACKUP_DIRECTORY); + snprintf(bu_path, sizeof(bu_path), "%s/"TAGCACHE_FILE_MASTER, tc_stat.db_path); + } + + fd = open(path, O_RDONLY, 0666); + + if (fd >= 0) + { + rc = read(fd, &tcmh, sizeof(struct master_header)); + close(fd); + if (rc != sizeof(struct master_header)) + { + logf("master file read failed"); + return false; + } + int entries = tcmh.tch.entry_count; + + logf("master file %d entries", entries); + if (backup) + logf("backup db to %s", BACKUP_DIRECTORY); + else + logf("restore db to %s", tc_stat.db_path); + + if (entries > 0) + { + logf("%s", path); + fcpy(path, bu_path, FCPY_COPY|FCPY_OVERWRITE, NULL); + + for (int i = 0; i < TAG_COUNT; i++) + { + if (TAGCACHE_IS_NUMERIC(i)) + continue; + snprintf(path, sizeof(path), + "%s/"TAGCACHE_FILE_INDEX, tc_stat.db_path, i); + + snprintf(bu_path, sizeof(bu_path), + "%s/"TAGCACHE_FILE_INDEX, BACKUP_DIRECTORY, i); + /* Note: above we swapped paths in the snprintf call here we swap variables */ + if (backup) + { + logf("%s", path); + if (fcpy(path, bu_path, FCPY_COPY|FCPY_OVERWRITE, NULL) < 0) + goto failed; + gStatus.have_backup = true; + } + else + { + logf("%s", bu_path); + if (fcpy(bu_path, path, FCPY_COPY|FCPY_OVERWRITE, NULL) < 0) + goto failed; + } + } + } + return true; + } +failed: + if (backup) + { + logf("failed backup"); + } + + return false; +} + +/* asks the user if they wish to quit */ +static bool confirm_quit(void) +{ + const struct text_message prompt = + { (const char*[]) {"Are you sure?", "This will abort commit."}, 2}; + enum yesno_res response = rb->gui_syncyesno_run(&prompt, NULL, NULL); + return (response == YESNO_YES); +} + +/* asks the user if they wish to backup/restore */ +static bool prompt_backup_restore(bool backup) +{ + const struct text_message bu_prompt = { (const char*[]) {"Backup database?"}, 1}; + const struct text_message re_prompt = + { (const char*[]) {"Error committing,", "Restore database?"}, 2}; + enum yesno_res response = + rb->gui_syncyesno_run(backup ? &bu_prompt:&re_prompt, NULL, NULL); + if(response == YESNO_YES) + return backup_restore_tagcache(backup); + return true; +} + +static const char* list_get_name_cb(int selected_item, void* data, + char* buf, size_t buf_len) +{ + (void) data; + (void) buf; + (void) buf_len; + + /* buf supplied isn't used so lets use it for a filename buffer */ + if (TIME_AFTER(current_tick, gStatus.last_check)) + { + snprintf(buf, buf_len, "%s/"TAGCACHE_FILE_NOCOMMIT, tc_stat.db_path); + gStatus.auto_commit = !file_exists(buf); + snprintf(buf, buf_len, "%s/"TAGCACHE_FILE_TEMP, tc_stat.db_path); + gStatus.commit_ready = file_exists(buf); + snprintf(buf, buf_len, "%s/"TAGCACHE_FILE_MASTER, tc_stat.db_path); + gStatus.db_exists = file_exists(buf); + snprintf(buf, buf_len, "%s/"TAGCACHE_FILE_MASTER, BACKUP_DIRECTORY); + gStatus.bu_exists = file_exists(buf); + gStatus.last_check = current_tick + HZ; + buf[0] = '\0'; + } + + switch(selected_item) + { + + case 0: /* exit */ + return ID2P(LANG_MENU_QUIT); + case 1: /*sep*/ + return ID2P(VOICE_BLANK); + case 2: /*backup*/ + if (!gStatus.db_exists) + return ID2P(VOICE_BLANK); + return "Backup"; + case 3: /*restore*/ + if (!gStatus.bu_exists) + return ID2P(VOICE_BLANK); + return "Restore"; + case 4: /*sep*/ + return ID2P(VOICE_BLANK); + case 5: /*auto commit*/ + if (gStatus.auto_commit) + return "Disable auto commit"; + else + return "Enable auto commit"; + case 6: /*destroy*/ + if (gStatus.db_exists) + return "Delete database"; + /*fall through*/ + case 7: /*sep*/ + return ID2P(VOICE_BLANK); + case 8: /*commit*/ + if (gStatus.commit_ready) + return "Commit"; + else + return "Nothing to commit"; + default: + return "?"; + } +} + +static int list_voice_cb(int list_index, void* data) +{ + #define MAX_MENU_NAME 32 + if (!rb->global_settings->talk_menu) + return -1; + else + { + char buf[MAX_MENU_NAME]; + const char* name = list_get_name_cb(list_index, data, buf, sizeof(buf)); + long id = P2ID((const unsigned char *)name); + if(id>=0) + rb->talk_id(id, true); + else + rb->talk_spell(name, true); + } + return 0; +} + +static int commit_menu(void) +{ + struct gui_synclist lists; + bool exit = false; + int button,i; + int selection, ret = 0; + + rb->gui_synclist_init(&lists,list_get_name_cb,0, false, 1, NULL); + rb->gui_synclist_set_icon_callback(&lists, NULL); + rb->gui_synclist_set_nb_items(&lists, 9); + rb->gui_synclist_select_item(&lists, 0); + + while (!exit) + { + rb->gui_synclist_draw(&lists); + button = rb->get_action(CONTEXT_LIST,TIMEOUT_BLOCK); + if (rb->gui_synclist_do_button(&lists, &button)) + continue; + selection = rb->gui_synclist_get_sel_pos(&lists); + + if (button == ACTION_STD_CANCEL) + return 0; + else if (button == ACTION_STD_OK) + { + switch(selection) + { + case 0: /* exit */ + exit = true; + break; + case 1: /*sep*/ + continue; + case 2: /*backup*/ + if (!gStatus.db_exists) + break; + if (!backup_restore_tagcache(true)) + rb->splash(HZ, "Backup failed!"); + else + { + rb->splash(HZ, "Backup success!"); + gStatus.bu_exists = true; + } + break; + case 3: /*restore*/ + if (!gStatus.bu_exists) + break; + if (!backup_restore_tagcache(false)) + rb->splash(HZ, "Restore failed!"); + else + rb->splash(HZ, "Restore success!"); + break; + case 4: /*sep*/ + continue; + case 5: /*auto commit*/ + { + /* build_idx_buf supplied by tagcache.c isn't being used + * so lets use it for a filename buffer */ + snprintf(build_idx_buf, build_idx_bufsz, + "%s/" TAGCACHE_FILE_NOCOMMIT, tc_stat.db_path); + if(gStatus.auto_commit) + close(open(build_idx_buf, O_WRONLY | O_CREAT | O_TRUNC, 0666)); + else + remove(build_idx_buf); + gStatus.auto_commit = !file_exists(build_idx_buf); + break; + } + case 6: /*destroy*/ + { + if (!gStatus.db_exists) + break; + const struct text_message prompt = + { (const char*[]) {"Are you sure?", "This will destroy database."}, 2}; + if (rb->gui_syncyesno_run(&prompt, NULL, NULL) == YESNO_YES) + remove_files(); + break; + } + case 7: /*sep*/ + continue; + case 8: /*commit*/ + if (gStatus.commit_ready) + { + gStatus.do_commit = true; + exit = true; + } + break; + + case MENU_ATTACHED_USB: + return PLUGIN_USB_CONNECTED; + default: + return 0; + } + } + } /*while*/ + return ret; +} + /*-----------------------------------------------------------------------------*/ /******* plugin_start ******* */ /*-----------------------------------------------------------------------------*/ @@ -451,6 +859,8 @@ enum plugin_status plugin_start(const void* parameter) /* Turn off backlight timeout */ backlight_ignore_timeout(); + memset(&gThread, 0, sizeof(gThread)); + memset(&gStatus, 0, sizeof(gStatus)); memset(&tc_stat, 0, sizeof(struct tagcache_stat)); memset(¤t_tcmh, 0, sizeof(struct master_header)); filenametag_fd = -1; @@ -459,62 +869,32 @@ enum plugin_status plugin_start(const void* parameter) if (!rb->dir_exists(tc_stat.db_path)) /* on fail use default DB path */ strlcpy(tc_stat.db_path, ROCKBOX_DIR, sizeof(tc_stat.db_path)); tc_stat.initialized = true; + tc_stat.commit_step = -1; - memset(&gThread, 0, sizeof(gThread)); logf("started"); - logdump(false); + int result = commit_menu(); + + if (!gStatus.do_commit) + { + /* Turn on backlight timeout (revert to settings) */ + backlight_use_settings(); + return PLUGIN_OK; + } + + logdump(false); + allocate_tempbuf(); + if (gStatus.db_exists && !gStatus.have_backup && !prompt_backup_restore(true)) + rb->splash(HZ, "Backup failed!"); thread_create(); gThread.user_index = 0; logdisplay(); /* get something on the screen while user waits */ - allocate_tempbuf(); - - commit(); - - if (tc_stat.ready) - rb->tagcache_commit_finalize(); - - free_tempbuf(); - - logdump(true); - gThread.user_index++; - logdisplay(); - rb->thread_wait(gThread.id); - rb->queue_delete(&gThread.queue); - - /* Turn on backlight timeout (revert to settings) */ - backlight_use_settings(); - return PLUGIN_OK; -} - -/****************** main thread + helper ******************/ -static void thread(void) -{ - struct queue_event ev; while (!gThread.exiting) { - rb->queue_wait_w_tmo(&gThread.queue, &ev, 1); - switch (ev.id) - { - case SYS_USB_CONNECTED: - rb->usb_acknowledge(SYS_USB_CONNECTED_ACK); - logenabled = false; - break; - case SYS_USB_DISCONNECTED: - logenabled = true; - /*fall through*/ - case EV_STARTUP: - logf("Thread Started"); - break; - case EV_EXIT: - return; - default: - break; - } logdisplay(); - int action = rb->get_action(CONTEXT_STD, HZ/10); + int action = rb->get_action(CONTEXT_STD, HZ/20); switch( action ) { @@ -536,8 +916,15 @@ static void thread(void) break; case SYS_POWEROFF: case ACTION_STD_CANCEL: - gThread.exiting = true; - return; + if (tc_stat.commit_step >= 0 && !tc_stat.ready) + { + if (!confirm_quit()) + break; + tc_stat.commit_delayed = true; /* Cancel the commit */ + } + rb->queue_remove_from_head(&gThread.queue, EV_EXIT); + rb->queue_post(&gThread.queue, EV_EXIT, 0); + break; #ifdef HAVE_TOUCHSCREEN case ACTION_TOUCHSCREEN: { @@ -561,8 +948,60 @@ static void thread(void) default: break; } + yield(); + } + + rb->thread_wait(gThread.id); + rb->queue_delete(&gThread.queue); + free_tempbuf(); + + if (tc_stat.commit_delayed || !tc_stat.ready) + { + remove_files(); + if (gStatus.bu_exists && !prompt_backup_restore(false)) + rb->splash(HZ, "Restore failed!"); + } + + if (tc_stat.ready) + rb->tagcache_commit_finalize(); + /* Turn on backlight timeout (revert to settings) */ + backlight_use_settings(); + return PLUGIN_OK; +} +/****************** main thread + helper ******************/ +static void thread(void) +{ + struct queue_event ev; + while (!gThread.exiting) + { + rb->queue_wait_w_tmo(&gThread.queue, &ev, 1); + switch (ev.id) + { + case SYS_USB_CONNECTED: + rb->usb_acknowledge(SYS_USB_CONNECTED_ACK); + logenabled = false; + break; + case SYS_USB_DISCONNECTED: + logenabled = true; + /*fall through*/ + case EV_STARTUP: + logf("Thread Started"); + cpu_boost(true); + if (commit()) + tc_stat.ready = true; + cpu_boost(false); + logdump(true); + gThread.user_index++; + logdisplay(); + break; + case EV_EXIT: + gThread.exiting = true; + return; + default: + break; + } yield(); } } |