void fs_send_file(const gchar *filename) { int err; // set pbar title if(tifiles_file_is_flash(filename)) { create_pbar_(FNCT_SEND_APP, _("Sending app(s)")); } else if(tifiles_file_is_group(filename)) { create_pbar_(FNCT_SEND_VAR, _("Sending var(s)")); } else if(tifiles_file_is_backup(filename)) { create_pbar_(FNCT_SEND_BACKUP, _("Restoring")); } else if(tifiles_file_is_single(filename)) { create_pbar_(FNCT_SEND_VAR, _("Sending var(s)")); } else if(tifiles_file_is_tigroup(filename)) { create_pbar_type5(_("Restoring")); } // note that core is currently not bkpt-interruptible when // transferring file GTK_REFRESH(); err = ti68k_linkport_send_file(filename); handle_error(); destroy_pbar(); }
/** * tifiles_file_is_single: * @filename: a filename as string. * * Check whether file is a single TI file (like program, function, ...). * * Return value: a boolean value. **/ TIEXPORT2 int TICALL tifiles_file_is_single(const char *filename) { if (!tifiles_file_is_ti(filename)) return 0; if (!tifiles_file_is_group(filename) && !tifiles_file_is_backup(filename) && !tifiles_file_is_flash(filename) && !tifiles_file_is_tigroup(filename)) return !0; return 0; }
/** * tifiles_file_get_class: * @filename: a filename as string. * * Returns the file class (single, group, backup, flash). * * Return value: a value in #FileClass. **/ TIEXPORT2 FileClass TICALL tifiles_file_get_class(const char *filename) { if (tifiles_file_is_single(filename)) return TIFILE_SINGLE; else if (tifiles_file_is_group(filename)) return TIFILE_GROUP; else if (tifiles_file_is_backup(filename)) return TIFILE_BACKUP; else if (tifiles_file_is_flash(filename)) return TIFILE_FLASH; else if (tifiles_file_is_tigroup(filename)) return TIFILE_TIGROUP; else return 0; }
/** * ti9x_file_display: * @filename: a TI file. * * Determine file class and display internal content. * * Return value: an error code, 0 otherwise. **/ int ti9x_file_display(const char *filename) { Ti9xRegular *content1; Ti9xBackup *content2; Ti9xFlash *content3; int ret; // the testing order is important: regular before backup (due to TI89/92+) if (tifiles_file_is_flash(filename) || tifiles_file_is_tib(filename)) { content3 = tifiles_content_create_flash(CALC_TI92); ret = ti9x_file_read_flash(filename, content3); if (!ret) { ti9x_content_display_flash(content3); tifiles_content_delete_flash(content3); } } else if (tifiles_file_is_regular(filename)) { content1 = tifiles_content_create_regular(CALC_TI92); ret = ti9x_file_read_regular(filename, content1); if (!ret) { tifiles_file_display_regular(content1); tifiles_content_delete_regular(content1); } } else if (tifiles_file_is_backup(filename)) { content2 = tifiles_content_create_backup(CALC_TI92); ret = ti9x_file_read_backup(filename, content2); if (!ret) { ti9x_content_display_backup(content2); tifiles_content_delete_backup(content2); } } else { tifiles_info("Unknown file type !"); return ERR_BAD_FILE; } return ret; }
void tilp_local_selection_add(const char* filename) { FileEntry* fe = g_malloc0(sizeof(FileEntry)); fe->name = g_strdup(filename); if(tifiles_file_is_regular(fe->name)) local.selection0 = g_list_prepend(local.selection0, fe); else if(tifiles_file_is_flash(fe->name)) local.selection2 = g_list_prepend(local.selection2, fe); else if(tifiles_file_is_backup(fe->name)) local.selection4 = g_list_prepend(local.selection4, fe); else if(tifiles_file_is_tigroup(fe->name)) local.selection5 = g_list_prepend(local.selection5, fe); }
// Restore TILP_EXPORT void on_tilp_button4_clicked(GtkButton* button, gpointer user_data) { const char *filename; char *ext; int mode = TIG_ALL | TIG_BACKUP; ext = g_strconcat("*.", tifiles_fext_of_backup(options.calc_model), ";*.tig", NULL); filename = create_fsel(local.cwdir, NULL, ext, FALSE); g_free(ext); if(filename) { if(tifiles_file_is_tigroup(filename)) { int ret = backup_box(_("Restore"), _("Data to restore:"), &mode); if(ret != BUTTON1) return; tilp_calc_send_tigroup(filename, mode | TIG_BACKUP); } else if(tifiles_file_is_backup(filename)) tilp_calc_send_backup(filename); } }
/** * ti9x_file_read_backup: * @filename: name of backup file to open. * @content: where to store the file content. * * Load the backup file into a Ti9xBackup structure. * * Structure content must be freed with #tifiles_content_delete_backup when * no longer used. If error occurs, the structure content is released for you. * * Return value: an error code, 0 otherwise. **/ int ti9x_file_read_backup(const char *filename, Ti9xBackup *content) { FILE *f; long cur_pos = 0; uint32_t file_size; char signature[9]; uint16_t sum; int ret = ERR_FILE_IO; if (content == NULL) { tifiles_critical("%s: an argument is NULL", __FUNCTION__); return ERR_INVALID_FILE; } if (!tifiles_file_is_backup(filename)) { ret = ERR_INVALID_FILE; goto tfrb2; } f = g_fopen(filename, "rb"); if (f == NULL) { tifiles_info( "Unable to open this file: %s", filename); ret = ERR_FILE_OPEN; goto tfrb2; } // Get file size, then rewind. if (fseek(f, 0, SEEK_END) < 0) goto tfrb; cur_pos = ftell(f); if (cur_pos < 0) goto tfrb; if (fseek(f, 0, SEEK_SET) < 0) goto tfrb; // The TI-68k series' members have at best 4 MB of Flash (TODO: modify this code if this no longer holds). // Backup files larger than that size are highly dubious, files larger than twice that size are insane. if (cur_pos >= (8L << 20)) { ret = ERR_INVALID_FILE; goto tfrb; } if (fread_8_chars(f, signature) < 0) goto tfrb; content->model = tifiles_signature2calctype(signature); if (content->model == CALC_NONE) { ret = ERR_INVALID_FILE; } if (fread_word(f, NULL) < 0) goto tfrb; if (fread_8_chars(f, NULL) < 0) goto tfrb; if (fread_n_chars(f, 40, content->comment) < 0) goto tfrb; if (fread_word(f, NULL) < 0) goto tfrb; if (fread_long(f, NULL) < 0) goto tfrb; if (fread_8_chars(f, content->rom_version) < 0) goto tfrb; if (fread_byte(f, &(content->type)) < 0) goto tfrb; if (fread_byte(f, NULL) < 0) goto tfrb; if (fread_word(f, NULL) < 0) goto tfrb; if (fread_long(f, &file_size) < 0) goto tfrb; if (file_size > (uint32_t)cur_pos) { ret = ERR_INVALID_FILE; goto tfrb; } content->data_length = file_size - 0x52 - 2; if (fread_word(f, NULL) < 0) goto tfrb; content->data_part = (uint8_t *)g_malloc0(content->data_length); if (content->data_part == NULL) { ret = ERR_MALLOC; goto tfrb; } if (fread(content->data_part, 1, content->data_length, f) < content->data_length) goto tfrb; if (fread_word(f, &(content->checksum)) < 0) goto tfrb; sum = tifiles_checksum(content->data_part, content->data_length); #if defined(CHECKSUM_ENABLED) if (sum != content->checksum) { ret = ERR_FILE_CHECKSUM; goto tfrb; } #endif fclose(f); return 0; tfrb: // release on exit tifiles_critical("%s: error reading / understanding file %s", __FUNCTION__, filename); fclose(f); tfrb2: tifiles_content_delete_backup(content); return ret; }
/** * tifiles_file_test: * @filename: a filename as string. * @type: type to check * @target: hand-held model or CALC_NONE for no filtering * * Check whether #filename is a TI file of type #type useable on a #target model. * This function is a generic one which overwrap and extends the tifiles_file_is_* * functions. * * This is a powerful function which allows checking of a specific file type for * a given target. * * Return value: a boolean value. **/ TIEXPORT2 int TICALL tifiles_file_test(const char *filename, FileClass type, CalcModel target) { char *e = tifiles_fext_get(filename); if (!tifiles_file_is_ti(filename)) return 0; if (!strcmp(e, "")) return 0; if(target > CALC_MAX) { tifiles_critical("tifiles_file_test: invalid target argument! This is a bug."); return 0; } if(type & TIFILE_SINGLE) { if(target && !g_ascii_strncasecmp(e, GROUP_FILE_EXT[target], 2)) return !0; else return tifiles_file_is_single(filename); } if(type & TIFILE_GROUP) { if(target && !g_ascii_strcasecmp(e, GROUP_FILE_EXT[target])) return !0; else return tifiles_file_is_group(filename); } if(type & TIFILE_REGULAR) { return tifiles_file_test(filename, TIFILE_SINGLE, target) || tifiles_file_test(filename, TIFILE_GROUP, target); } if(type & TIFILE_BACKUP) { if(target && !g_ascii_strcasecmp(e, BACKUP_FILE_EXT[target])) return !0; else return tifiles_file_is_backup(filename); } if(type & TIFILE_OS) { if(target && !g_ascii_strcasecmp(e, FLASH_OS_FILE_EXT[target])) return !0; else if(target && tifiles_file_is_tib(filename)) { FILE *f; uint8_t data[16]; f = g_fopen(filename, "rb"); if(f == NULL) return 0; fread_n_chars(f, 16, (char *)data); fclose(f); switch(data[8]) { case 1: if(target != CALC_TI92P) return 0; case 3: if(target != CALC_TI89) return 0; case 8: if(target != CALC_V200) return 0; case 9: if(target != CALC_TI89T) return 0; } return !0; } else return tifiles_file_is_os(filename); } if(type & TIFILE_APP) { if(target && !g_ascii_strcasecmp(e, FLASH_APP_FILE_EXT[target])) return !0; else return tifiles_file_is_app(filename); } if(type & TIFILE_FLASH) { return tifiles_file_test(filename, TIFILE_OS, target) || tifiles_file_test(filename, TIFILE_APP, target); } if(type & TIFILE_TIGROUP) { if(target) { // No easy/light way for this part: we have to load the whole file // and to parse the TigEntry structures. TigContent *content; int ret, ok=0; int k; if(!tifiles_file_has_tig_header(filename)) return 0; content = tifiles_content_create_tigroup(CALC_NONE, 0); ret = tifiles_file_read_tigroup(filename, content); if(ret) return 0; for (k = 0; k < content->n_apps; k++) { TigEntry *te = content->app_entries[k]; if(tifiles_calc_are_compat(te->content.regular->model, target)) ok++; } for (k = 0; k < content->n_vars; k++) { TigEntry *te = content->var_entries[k]; if(tifiles_calc_are_compat(te->content.regular->model, target)) ok++; } tifiles_content_delete_tigroup(content); return ok; } else return tifiles_file_is_tigroup(filename); } return 0; }
// The main function int main(int argc, char **argv) { char *msg = NULL; char buffer[256]; int i; int ret; // init library tifiles_library_init(); // test tifiles.c printf("Library version : <%s>\n", tifiles_version_get()); printf("--\n"); // test error.c tifiles_error_get(515, &msg); printf("Error message: <%s>\n", msg); #ifndef __WIN32__ free(msg); #endif printf("--\n"); // test type2str.c printf("tifiles_string_to_model: <%i> <%i>\n", CALC_TI92, tifiles_string_to_model(tifiles_model_to_string(CALC_TI92))); printf("tifiles_string_to_attribute: <%i> <%i>\n", ATTRB_LOCKED, tifiles_string_to_attribute(tifiles_attribute_to_string(ATTRB_LOCKED))); printf("tifiles_string_to_class: <%i> <%i>\n", TIFILE_SINGLE, tifiles_string_to_class(tifiles_class_to_string(TIFILE_SINGLE))); printf("--\n"); // test filetypes.c for(i = CALC_TI73; i <= CALC_V200; i++) { printf("%s (%i) ", tifiles_fext_of_group(i), i); } printf("\n"); for(i = CALC_TI73; i <= CALC_V200; i++) { printf("%s ", tifiles_fext_of_backup(i)); } printf("\n"); for(i = CALC_TI73; i <= CALC_V200; i++) { printf("%s ", tifiles_fext_of_flash_os(i)); } printf("\n"); for(i = CALC_TI73; i <= CALC_V200; i++) { printf("%s ", tifiles_fext_of_flash_app(i)); } printf("\n"); printf("--\n"); printf("<%s> <%s>\n", "foo.bar", tifiles_fext_get("foo.bar")); ret = tifiles_file_is_ti(PATH("misc/str.92s")); printf("tifiles_file_is_ti: %i\n", ret); ret = tifiles_file_is_single(PATH("misc/str.92s")); printf("tifiles_file_is_single: %i\n", ret); ret = tifiles_file_is_group(PATH("misc/group.92g")); printf("tifiles_file_is_group: %i\n", ret); ret = tifiles_file_is_regular(PATH("misc/str.92s")); printf("tifiles_file_is_regular: %i\n", ret); ret = tifiles_file_is_regular(PATH("misc/group.92g")); printf("tifiles_file_is_regular: %i\n", ret); ret = tifiles_file_is_backup(PATH("misc/backup.83b")); printf("tifiles_file_is_backup: %i\n", ret); ret = tifiles_file_is_flash(PATH("misc/ticabfra.89k")); printf("tifiles_file_is_flash: %i\n", ret); ret = tifiles_file_is_flash(PATH("misc/TI73_OS160.73U")); printf("tifiles_file_is_flash: %i\n", ret); ret = tifiles_file_is_tib(PATH("misc/ams100.tib")); printf("tifiles_file_is_tib: %i\n", ret); ret = tifiles_file_is_tigroup(PATH("misc/test.tig")); printf("tifiles_file_is_tigroup: %i\n", ret); printf("--\n"); // test typesxx.c printf("tifiles_file_get_model: %s\n", tifiles_model_to_string(tifiles_file_get_model(PATH("misc/str.92s")))); printf("tifiles_file_get_class: %s\n", tifiles_class_to_string(tifiles_file_get_class(PATH("misc/group.92g")))); printf("tifiles_file_get_type: %s\n", tifiles_file_get_type(PATH("misc/TI73_OS160.73U"))); printf("tifiles_file_get_icon: %s\n", tifiles_file_get_icon(PATH("misc/str.92s"))); printf("--\n"); // test misc.c printf("tifiles_calc_is_ti8x: %i\n", tifiles_calc_is_ti8x(CALC_TI83)); printf("tifiles_calc_is_ti9x: %i\n", tifiles_calc_is_ti9x(CALC_TI89)); printf("tifiles_has_folder: %i\n", tifiles_has_folder(CALC_TI92)); printf("tifiles_is_flash: %i\n", tifiles_is_flash(CALC_TI73)); printf("tifiles_get_varname: <%s>\n", tifiles_get_varname("fld\\var")); printf("tifiles_get_fldname: <%s>\n", tifiles_get_fldname("fld\\var")); tifiles_build_fullname(CALC_TI89, buffer, "fld", "var"); printf("tifiles_build_fullname: <%s>\n", buffer); printf("--\n"); // test filesxx.c & grouped.c do { // TI73 support change_dir(PATH("ti73")); ret = test_ti73_backup_support(); if (ret) break; ret = test_ti73_regular_support(); if (ret) break; ret = test_ti73_group_support(); if (ret) break; ret = test_ti73_ungroup_support(); if (ret) break; // TI82 support change_dir(PATH("ti82")); ret = test_ti82_backup_support(); if (ret) break; ret = test_ti82_regular_support(); if (ret) break; ret = test_ti82_group_support(); if (ret) break; ret = test_ti82_ungroup_support(); if (ret) break; // TI83 support change_dir(PATH("ti83")); ret = test_ti83_backup_support(); if (ret) break; ret = test_ti83_regular_support(); if (ret) break; ret = test_ti83_group_support(); if (ret) break; ret = test_ti83_ungroup_support(); if (ret) break; // TI84+ support change_dir(PATH("ti84p")); ret = test_ti84p_regular_support(); if (ret) break; ret = test_ti84p_group_support(); if (ret) break; ret = test_ti84p_ungroup_support(); if (ret) break; ret = test_ti84p_flash_support(); if (ret) break; // TI85 support change_dir(PATH("ti85")); ret = test_ti85_regular_support(); if (ret) break; // TI86 support change_dir(PATH("ti86")); ret = test_ti86_backup_support(); if (ret) break; ret = test_ti86_regular_support(); if (ret) break; ret = test_ti86_group_support(); if (ret) break; ret = test_ti86_ungroup_support(); if (ret) break; // TI89 support change_dir(PATH("ti89")); ret = test_ti89_regular_support(); if (ret) break; ret = test_ti89_flash_support(); if (ret) break; ret = test_v200_regular_support(); if (ret) break; // TI92 support change_dir(PATH("ti92")); ret = test_ti92_backup_support(); if (ret) break; ret = test_ti92_regular_support(); if (ret) break; ret = test_ti92_group_support(); if (ret) break; ret = test_ti92_ungroup_support(); if (ret) break; // TIXX certificates change_dir(PATH("certs")); ret = test_ti8x_cert_support(); if (ret) break; ret = test_ti9x_cert_support(); if (ret) break; // Add/Del files change_dir(PATH("misc")); ret = test_ti8x_group_merge(); if (ret) break; change_dir(PATH("tig")); ret = test_tigroup(); } while(0); // end of test tifiles_library_exit(); return ret; }
/** * ti9x_file_read_backup: * @filename: name of backup file to open. * @content: where to store the file content. * * Load the backup file into a Ti9xBackup structure. * * Structure content must be freed with #tifiles_content_delete_backup when * no longer used. If error occurs, the structure content is released for you. * * Return value: an error code, 0 otherwise. **/ int ti9x_file_read_backup(const char *filename, Ti9xBackup *content) { FILE *f; uint32_t file_size; char signature[9]; uint16_t sum; if (!tifiles_file_is_backup(filename)) { return ERR_INVALID_FILE; } f = g_fopen(filename, "rb"); if (f == NULL) { tifiles_info( "Unable to open this file: %s", filename); return ERR_FILE_OPEN; } if (content == NULL) { tifiles_critical("%s: an argument is NULL", __FUNCTION__); return ERR_INVALID_FILE; } if(fread_8_chars(f, signature) < 0) goto tfrb; content->model = tifiles_signature2calctype(signature); if (content->model == CALC_NONE) { return ERR_INVALID_FILE; } if(fread_word(f, NULL) < 0) goto tfrb; if(fread_8_chars(f, NULL) < 0) goto tfrb; if(fread_n_chars(f, 40, content->comment) < 0) goto tfrb; if(fread_word(f, NULL) < 0) goto tfrb; if(fread_long(f, NULL) < 0) goto tfrb; if(fread_8_chars(f, content->rom_version) < 0) goto tfrb; if(fread_byte(f, &(content->type)) < 0) goto tfrb; if(fread_byte(f, NULL) < 0) goto tfrb; if(fread_word(f, NULL) < 0) goto tfrb; if(fread_long(f, &file_size) < 0) goto tfrb; content->data_length = file_size - 0x52 - 2; if(fread_word(f, NULL) < 0) goto tfrb; content->data_part = (uint8_t *)g_malloc0(content->data_length); if (content->data_part == NULL) { fclose(f); tifiles_content_delete_backup(content); return ERR_MALLOC; } if(fread(content->data_part, 1, content->data_length, f) < content->data_length) goto tfrb; if(fread_word(f, &(content->checksum)) < 0) goto tfrb; sum = tifiles_checksum(content->data_part, content->data_length); #if defined(CHECKSUM_ENABLED) if(sum != content->checksum) { fclose(f); tifiles_content_delete_backup(content); return ERR_FILE_CHECKSUM; } #endif fclose(f); return 0; tfrb: // release on exit tifiles_critical("%s: error reading / understanding file %s", __FUNCTION__, filename); fclose(f); tifiles_content_delete_backup(content); return ERR_FILE_IO; }