/** * tifiles_file_is_os: * @filename: a filename as string. * * Check whether file is a FLASH OS file (tib or XXu) * * Return value: a boolean value. **/ TIEXPORT2 int TICALL tifiles_file_is_os(const char *filename) { int i; char *e = tifiles_fext_get(filename); if (!strcmp(e, "")) return 0; if (!tifiles_file_is_ti(filename)) return 0; if(tifiles_file_is_tib(filename)) return !0; if(tifiles_file_is_tno(filename)) return !0; for (i = 1; i < CALC_MAX + 1; i++) { if (!g_ascii_strcasecmp(e, FLASH_OS_FILE_EXT[i])) return !0; } return 0; }
/** * tnsp_file_read_regular: * @filename: name of file to open. * @content: where to store the file content. * * Load the file into a FileContent structure. * * Structure content must be freed with #tifiles_content_delete_regular when * no longer used. If error occurs, the structure content is released for you. * * Return value: an error code, 0 otherwise. **/ int tnsp_file_read_regular(const char *filename, FileContent *content) { FILE *f; if (!tifiles_file_is_regular(filename)) { return ERR_INVALID_FILE; } if (content == NULL) { tifiles_critical("%s: an argument is NULL", __FUNCTION__); 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; } content->model = CALC_NSPIRE; content->model_dst = content->model; content->entries = g_malloc0((content->num_entries + 1) * sizeof(VarEntry*)); { VarEntry *entry = content->entries[0] = g_malloc0(sizeof(VarEntry)); gchar *basename = g_path_get_basename(filename); gchar *ext = tifiles_fext_get(basename); entry->type = tifiles_fext2vartype(content->model, ext); if(ext) *(ext-1) = '\0'; strcpy(entry->folder, ""); strcpy(entry->name, basename); g_free(basename); entry->attr = ATTRB_NONE; fseek(f, 0, SEEK_END); entry->size = (uint32_t)ftell(f); fseek(f, 0, SEEK_SET); entry->data = (uint8_t *)g_malloc0(entry->size); if(fread(entry->data, 1, entry->size, f) < entry->size) goto tffr; } content->num_entries++; fclose(f); return 0; tffr: // release on exit tifiles_critical("%s: error reading / understanding file %s", __FUNCTION__, filename); fclose(f); tifiles_content_delete_regular(content); return ERR_FILE_IO; }
/** * tifiles_file_is_ti: * @filename: a filename as string. * * Check whether file is a TI file by checking the signature. * * Return value: a boolean value. **/ TIEXPORT2 int TICALL tifiles_file_is_ti(const char *filename) { // bug: check that file is not a FIFO if (!is_regfile(filename)) return 0; if(tifiles_file_has_ti_header(filename)) return !0; if(tifiles_file_has_tib_header(filename)) return !0; if(tifiles_file_has_tig_header(filename)) return !0; if(tifiles_file_has_tno_header(filename)) return !0; { char *e = tifiles_fext_get(filename); if (!strcmp(e, "")) return 0; if(!g_ascii_strcasecmp(e, "tns")) return !0; } return 0; }
static int tifiles_file_has_tig_header(const char *filename) { FILE *f; char str[5]; char *e = tifiles_fext_get(filename); if (!strcmp(e, "")) return 0; if(g_ascii_strcasecmp(e, "tig")) return 0; f = g_fopen(filename, "rb"); if(f == NULL) return 0; fread_n_chars(f, strlen(TIG_SIGNATURE), str); str[strlen(TIG_SIGNATURE)] = '\0'; if(!strcmp(str, TIG_SIGNATURE) || !strcmp(str, TIG_SIGNATURE2)) { fclose(f); return !0; } fclose(f); return 0; }
/** * tifiles_file_get_model: * @filename: a filename as string. * * Returns the calculator model targetted for this file. * * Return value: a model taken in #CalcModel. **/ TIEXPORT2 CalcModel TICALL tifiles_file_get_model(const char *filename) { char *ext = tifiles_fext_get(filename); int type = CALC_NONE; char str[4]; if (!strcmp(ext, "")) return CALC_NONE; strncpy(str, ext, 2); str[2] = '\0'; if (!g_ascii_strcasecmp(str, "73")) type = CALC_TI73; else if (!g_ascii_strcasecmp(str, "82")) type = CALC_TI82; else if (!g_ascii_strcasecmp(str, "83")) type = CALC_TI83; else if (!g_ascii_strcasecmp(str, "8x")) type = CALC_TI83P; else if (!g_ascii_strcasecmp(str, "85")) type = CALC_TI85; else if (!g_ascii_strcasecmp(str, "86")) type = CALC_TI86; else if (!g_ascii_strcasecmp(str, "89")) type = CALC_TI89; else if (!g_ascii_strcasecmp(str, "92")) type = CALC_TI92; else if (!g_ascii_strcasecmp(str, "9X")) type = CALC_TI92P; else if (!g_ascii_strcasecmp(str, "V2")) type = CALC_V200; //else if (!g_ascii_strcasecmp(str, "tib")) //type = CALC_TI89; // consider .tib as TI89 else if (!g_ascii_strcasecmp(str, "tn") || !g_ascii_strcasecmp(str, "tc")) type = CALC_NSPIRE; else type = CALC_NONE; return type; }
// Recv TIGroup TILP_EXPORT void on_tilp_button7_clicked(GtkButton* button, gpointer user_data) { char* src_filename; const char *dst_filename; const char *dst_filename2; int ret; int mode = TIG_ALL; ret = backup_box(_("Backup"), _("Data to backup:"), &mode); if(ret != BUTTON1) return; if (tilp_calc_recv_tigroup(mode) != 0) return; src_filename = g_strconcat(g_get_tmp_dir(), G_DIR_SEPARATOR_S, TMPFILE_TIGROUP, NULL); dst_filename = create_fsel(local.cwdir, "backup", "*.tig", TRUE); if(!dst_filename) { g_free(src_filename); return; } if (!strcmp(tifiles_fext_get(dst_filename), "")) dst_filename2 = g_strconcat(dst_filename, ".tig", NULL); else dst_filename2 = g_strdup(dst_filename); //g_free((void *)dst_filename); if (dst_filename2) { tilp_file_move_with_check(src_filename, dst_filename2); } g_free(src_filename); g_free((void *)dst_filename2); tilp_dirlist_local(); clist_refresh(); labels_refresh(); }
TIEXPORT2 int TICALL tifiles_file_has_tno_header(const char *filename) { FILE *f; char str[128]; char *e = tifiles_fext_get(filename); int ret = 0; if (!strcmp(e, "")) { return ret; } if(g_ascii_strcasecmp(e, "tno") && g_ascii_strcasecmp(e, "tnc") && g_ascii_strcasecmp(e, "tco") && g_ascii_strcasecmp(e, "tcc")) { return ret; } f = g_fopen(filename, "rb"); if(f == NULL) { return ret; } if (fread_n_chars(f, 63, str) == 0) { if ( !strncmp(str, TNO_SIGNATURE, 14) || !strncmp(str, TNC_SIGNATURE, 14) || !strncmp(str, TNO_NOSAMPLES_SIGNATURE, 24) || !strncmp(str, TCO_SIGNATURE, 14) || !strncmp(str, TCC_SIGNATURE, 14) ) { ret = !0; } } fclose(f); return ret; }
// Backup TILP_EXPORT void on_tilp_button3b_clicked(GtkButton* button, gpointer user_data) { char* src_filename; const char *dst_filename; const char *dst_filename2; char *ext; if (tilp_calc_recv_backup() != 0) return; src_filename = g_strconcat(g_get_tmp_dir(), G_DIR_SEPARATOR_S, TMPFILE_BACKUP, NULL); ext = g_strconcat("*.", tifiles_fext_of_backup(options.calc_model), NULL); dst_filename = create_fsel(local.cwdir, "backup", ext, TRUE); g_free(ext); if (!dst_filename) { g_free(src_filename); return; } if (!strcmp(tifiles_fext_get(dst_filename), "")) dst_filename2 = g_strconcat(dst_filename, ".", tifiles_fext_of_backup(options.calc_model), NULL); else dst_filename2 = g_strdup(dst_filename); //g_free((void *)dst_filename); if (dst_filename2) { tilp_file_move_with_check(src_filename, dst_filename2); } g_free(src_filename); g_free((void *)dst_filename2); tilp_dirlist_local(); clist_refresh(); labels_refresh(); }
static int save_group(void) { char* src_filename; const char *dst_filename; const char *dst_filename2; char *ext; src_filename = g_strconcat(g_get_tmp_dir(), G_DIR_SEPARATOR_S, TMPFILE_GROUP, ".", tifiles_fext_of_group(options.calc_model), NULL); ext = g_strconcat("*.", tifiles_fext_of_group(options.calc_model), NULL); dst_filename = create_fsel(local.cwdir, "group", ext, TRUE); g_free(ext); if (!dst_filename) { g_free(src_filename); return -1; } if (!strcmp(tifiles_fext_get(dst_filename), "")) dst_filename2 = g_strconcat(dst_filename, ".", tifiles_fext_of_group(options.calc_model), NULL); else dst_filename2 = g_strdup(dst_filename); //g_free((void *)dst_filename); if (dst_filename2) { tilp_file_move_with_check(src_filename, dst_filename2); } g_free(src_filename); g_free((void *)dst_filename2); tilp_dirlist_local(); clist_refresh(); labels_refresh(); return 0; }
TILP_EXPORT void on_rom_dump1_activate(GtkMenuItem* menuitem, gpointer user_data) { char* src_filename; const char *dst_filename; const char *dst_filename2; char filename[128]; if (tilp_calc_rom_dump()) return; src_filename = g_strconcat(g_get_tmp_dir(), G_DIR_SEPARATOR_S, TMPFILE_ROMDUMP, NULL); sprintf(filename, "dump%s", tifiles_model_to_string(options.calc_model)); dst_filename = create_fsel(local.cwdir, filename, "*.rom", TRUE); if (!dst_filename) { g_free(src_filename); return; } if (!strcmp(tifiles_fext_get(dst_filename), "")) dst_filename2 = g_strconcat(dst_filename, ".", "rom", NULL); else dst_filename2 = g_strdup(dst_filename); //g_free((void *)dst_filename); if (dst_filename2) { tilp_file_move_with_check(src_filename, dst_filename2); } g_free(src_filename); g_free((void *)dst_filename2); tilp_dirlist_local(); clist_refresh(); labels_refresh(); }
/** * 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; }
/** * tifiles_file_get_icon: * @filename: a filename as string. * * Returns the type of file (function, program, ...). * * Return value: a string like "Assembly Program" (non localized). **/ TIEXPORT2 const char *TICALL tifiles_file_get_icon(const char *filename) { char *ext; ext = tifiles_fext_get(filename); if (!strcmp(ext, "")) return ""; if (!g_ascii_strcasecmp(ext, "tib")) return "OS upgrade"; if (!g_ascii_strcasecmp(ext, "tno") || !g_ascii_strcasecmp(ext, "tnc") || !g_ascii_strcasecmp(ext, "tco") || !g_ascii_strcasecmp(ext, "tcc")) return "OS upgrade"; if (!tifiles_file_is_ti(filename)) return ""; if(tifiles_file_is_tigroup(filename)) return "TiGroup"; if (tifiles_file_is_group(filename)) { switch (tifiles_file_get_model(filename)) { case CALC_TI89: case CALC_TI89T: case CALC_TI89T_USB: case CALC_TI92P: case CALC_V200: return "Group/Backup"; default: return "Group"; } } switch (tifiles_file_get_model(filename)) { #ifndef DISABLE_TI8X case CALC_TI73: return ti73_byte2icon(ti73_fext2byte(ext)); case CALC_TI82: return ti82_byte2icon(ti82_fext2byte(ext)); case CALC_TI83: return ti83_byte2icon(ti83_fext2byte(ext)); case CALC_TI83P: case CALC_TI84P: case CALC_TI84P_USB: return ti83p_byte2icon(ti83p_fext2byte(ext)); case CALC_TI85: return ti85_byte2icon(ti85_fext2byte(ext)); case CALC_TI86: return ti86_byte2icon(ti86_fext2byte(ext)); #endif #ifndef DISABLE_TI9X case CALC_TI89: case CALC_TI89T: case CALC_TI89T_USB: return ti89_byte2icon(ti89_fext2byte(ext)); case CALC_TI92: return ti92_byte2icon(ti92_fext2byte(ext)); case CALC_TI92P: return ti92p_byte2icon(ti92p_fext2byte(ext)); case CALC_V200: return v200_byte2icon(v200_fext2byte(ext)); #endif case CALC_NSPIRE: return nsp_byte2icon(nsp_fext2byte(ext)); case CALC_NONE: default: return ""; break; } return ""; }
/* Preload TI variables belonging with the selection */ void tilp_local_contents_load(void) { GList *ptr; int err; // TIGroups if (local.selection5 != NULL) { for(ptr = local.selection5; ptr; ptr = ptr->next) { FileEntry *fe5 = ptr->data; if(tifiles_file_is_tigroup(fe5->name)) { TigContent *content = NULL; FileContent **p, **contents1 = NULL; FlashContent **q, **contents2 = NULL; content = tifiles_content_create_tigroup(options.calc_model, 0); err = tifiles_file_read_tigroup(fe5->name, content); if(err) { tilp_err(err); continue; } err = tifiles_untigroup_content(content, &contents1, &contents2); if(err) { tilp_err(err); tifiles_content_delete_tigroup(content); continue; } tifiles_content_delete_tigroup(content); for(p = contents1; *p; p++) { FileEntry *fe1 = g_memdup(ptr->data, sizeof(FileEntry)); fe1->name = g_memdup(fe1->name, strlen(fe1->name)+1); fe1->content1 = *p; //g_free(fe1->name); //fe1->name = tifiles_build_filename(options.calc_model, (*p)->entries[0]); local.selection1 = g_list_append(local.selection1, fe1); } for(q = contents2; *q; q++) { FileEntry *fe3 = g_memdup(ptr->data, sizeof(FileEntry)); fe3->name = g_memdup(fe3->name, strlen(fe3->name)+1); fe3->content2 = *q; /* { VarEntry ve; g_free(fe3->name); strcpy(ve.name, (*q)->name); ve.type = (*q)->data_type; fe3->name = tifiles_build_filename(options.calc_model, &ve); }*/ local.selection3 = g_list_append(local.selection3, fe3); } } } } // Variables if (local.selection0 != NULL) { for(ptr = local.selection0; ptr; ptr = ptr->next) { FileEntry *fe0 = ptr->data; if(!g_ascii_strcasecmp(tifiles_fext_get(fe0->name), "8xidl")) continue; // doesn't send this pseudo-variable if(tifiles_file_is_single(fe0->name)) { FileEntry *fe1 = g_memdup(ptr->data, sizeof(FileEntry)); fe1->content1 = tifiles_content_create_regular(options.calc_model); err = tifiles_file_read_regular(fe1->name, fe1->content1); if(err) { // The content is already deleted by the subroutines of tifiles_file_read_regular. //tifiles_content_delete_regular(fe1->content1); g_free(fe1); continue; } local.selection1 = g_list_append(local.selection1, fe1); } else if(tifiles_file_is_group(fe0->name)) { // explode group files so that we have 1 VarEntry per item (skip/retry/cancel) FileContent **p, **dst = NULL; FileContent *src = NULL; src = tifiles_content_create_regular(options.calc_model); err = tifiles_file_read_regular(fe0->name, src); if(err) { // The content is already deleted by the subroutines of tifiles_file_read_regular. //tifiles_content_delete_regular(src); continue; } err = tifiles_ungroup_content(src, &dst); if(err) { tifiles_content_delete_regular(src); continue; } for(p = dst; *p; p++) { FileEntry *fe = g_memdup(ptr->data, sizeof(FileEntry)); fe->content1 = *p; local.selection1 = g_list_append(local.selection1, fe); } tifiles_content_delete_regular(src); } } } // Applications if(local.selection2 != NULL) { for(ptr = local.selection2; ptr; ptr = ptr->next) { FileEntry *fe2 = ptr->data; if(tifiles_file_is_app(fe2->name) || tifiles_file_test(fe2->name, TIFILE_OS, options.calc_model)) { FileEntry *fe3 = g_memdup(ptr->data, sizeof(FileEntry)); fe3->content2 = tifiles_content_create_flash(options.calc_model); err = tifiles_file_read_flash(fe2->name, fe3->content2); if(err) { tifiles_content_delete_flash(fe3->content2); g_free(fe3); continue; } local.selection3 = g_list_append(local.selection3, fe3); } } } // Reparse variables and change target folder if (local.selection1) { // replaced "" folder by "main" if(!tifiles_has_folder(options.calc_model)) return; for(ptr = local.selection1; ptr; ptr = ptr->next) { FileEntry *fe = ptr->data; FileContent *fc = fe->content1; unsigned int i; if(fc == NULL) continue; for(i = 0; i < fc->num_entries; i++) { VarEntry *ve = (fc->entries)[i]; if(!strcmp(ve->folder , "")) strcpy(ve->folder, "main"); } } } }
// 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; }
/** * tnsp_file_read_regular: * @filename: name of file to open. * @content: where to store the file content. * * Load the file into a FileContent structure. * * Structure content must be freed with #tifiles_content_delete_regular when * no longer used. If error occurs, the structure content is released for you. * * Return value: an error code, 0 otherwise. **/ int tnsp_file_read_regular(const char *filename, FileContent *content) { FILE *f; int ret = ERR_FILE_IO; if (content == NULL) { tifiles_critical("%s: an argument is NULL", __FUNCTION__); return ERR_INVALID_FILE; } if (!tifiles_file_is_regular(filename)) { ret = ERR_INVALID_FILE; goto tfrr2; } f = g_fopen(filename, "rb"); if (f == NULL) { tifiles_info( "Unable to open this file: %s", filename); ret = ERR_FILE_OPEN; goto tfrr2; } content->model = CALC_NSPIRE; content->model_dst = content->model; content->entries = g_malloc0((content->num_entries + 1) * sizeof(VarEntry*)); { long cur_pos; VarEntry *entry = content->entries[0] = g_malloc0(sizeof(VarEntry)); gchar *basename = g_path_get_basename(filename); gchar *ext = tifiles_fext_get(basename); entry->type = tifiles_fext2vartype(content->model, ext); if (ext && ext[0]) *(ext-1) = '\0'; entry->folder[0] = 0; strncpy(entry->name, basename, sizeof(entry->name) - 1); entry->name[sizeof(entry->name) - 1] = 0; g_free(basename); entry->attr = ATTRB_NONE; if (fseek(f, 0, SEEK_END) < 0) goto tfrr; cur_pos = ftell(f); if (cur_pos < 0) goto tfrr; if (fseek(f, 0, SEEK_SET) < 0) goto tfrr; // The Nspire series' members have at best 128 MB of Flash (TODO: modify this code if this no longer holds). // Regular files larger than that size are insane. if (cur_pos >= (128L << 20)) { ret = ERR_INVALID_FILE; goto tfrr; } entry->size = (uint32_t)cur_pos; entry->data = (uint8_t *)g_malloc0(entry->size); if(fread(entry->data, 1, entry->size, f) < entry->size) goto tfrr; } content->num_entries++; fclose(f); return 0; tfrr: // release on exit tifiles_critical("%s: error reading / understanding file %s", __FUNCTION__, filename); fclose(f); tfrr2: tifiles_content_delete_regular(content); return ret; }
/** * tifiles_fext_dup: * @filename: a filename as string. * * Returns a copy of file extension part. * * Return value: a file extension without dot as string (like "89g"). * Need to be freed when no longer needed. **/ TIEXPORT2 char *TICALL tifiles_fext_dup(const char *filename) { return g_strdup(tifiles_fext_get(filename)); }
// Helper function for get_dirlist, it does the bulk of the work. static int enumerate_folder(CalcHandle* handle, GNode** vars, const char * folder_name) { int ret; ticalcs_info("enumerate_folder<%s>\n", folder_name); do { char varname[VARNAME_MAX]; ret = nsp_cmd_s_dir_enum_init(handle, folder_name); if (ret) { break; } ret = nsp_cmd_r_dir_enum_init(handle); if (ret) { break; } for (;;) { VarEntry *fe; GNode *node; char *ext; uint32_t varsize; uint8_t vartype; ret = nsp_cmd_s_dir_enum_next(handle); if (ret) { break; } ret = nsp_cmd_r_dir_enum_next(handle, varname, &varsize, &vartype); if (ret == ERR_EOT) { ret = 0; break; } else if (ret != 0) { break; } fe = tifiles_ve_create(); ticalcs_strlcpy(fe->folder, folder_name + 1, sizeof(fe->folder)); // Skip leading / fe->size = varsize; fe->type = vartype; fe->attr = ATTRB_NONE; ext = tifiles_fext_get(varname); // Just a sanity check if (ext) { // Did the file name have any non-empty extension ? if (*ext) { // Do we know about this file type ? if (fe->type < NSP_MAXTYPES) { // Then we can remove the exension. *(ext-1) = '\0'; } // else don't remove the extension. } // else there is no extension to remove. } ticalcs_strlcpy(fe->name, varname, sizeof(fe->name)); node = dirlist_create_append_node(fe, vars); if (!node) { ret = ERR_MALLOC; break; } ticalcs_info(_("Name: %s | Type: %8s | Attr: %i | Size: %08X"), fe->name, tifiles_vartype2string(handle->model, fe->type), fe->attr, fe->size); } while (!ret) { int i; ret = nsp_cmd_s_dir_enum_done(handle); if (ret) { break; } ret = nsp_cmd_r_dir_enum_done(handle); if (ret) { break; } // Enumerate elements of root folder. for (i = 0; i < (int)g_node_n_children(*vars); i++) { char new_folder_name[FLDNAME_MAX]; const char * separator_if_any; GNode * folder = g_node_nth_child(*vars, i); uint8_t vartype = ((VarEntry *)(folder->data))->type; // Don't recurse into regular files (type 0, TNS or e.g. themes.csv on OS 3.0+). if (vartype == 0) { ticalcs_info(_("Not enumerating documents in %s because it's not a folder\n"), ((VarEntry *)(folder->data))->name); continue; } // Prevent names from starting with "//". if (strcmp(folder_name, "/")) { separator_if_any = "/"; } else { separator_if_any = ""; } ticalcs_slprintf(new_folder_name, sizeof(new_folder_name), "%s%s%s", folder_name, separator_if_any, ((VarEntry *)(folder->data))->name); ticalcs_info(_("Directory listing in <%s>...\n"), new_folder_name); ret = enumerate_folder(handle, &folder, new_folder_name); if (ret) { break; } } break; } } while (0); return ret; }
static int get_dirlist (CalcHandle* handle, GNode** vars, GNode** apps) { TreeInfo *ti; int err; GNode *root, *folder = NULL; char varname[VARNAME_MAX]; uint32_t varsize; uint8_t vartype; int i; (*apps) = g_node_new(NULL); ti = (TreeInfo *)g_malloc(sizeof(TreeInfo)); ti->model = handle->model; ti->type = APP_NODE_NAME; (*apps)->data = ti; (*vars) = g_node_new(NULL); ti = (TreeInfo *)g_malloc(sizeof(TreeInfo)); ti->model = handle->model; ti->type = VAR_NODE_NAME; (*vars)->data = ti; root = g_node_new(NULL); g_node_append(*apps, root); TRYF(nsp_session_open(handle, SID_FILE_MGMT)); TRYF(nsp_cmd_s_dir_attributes(handle, "/")); TRYF(nsp_cmd_r_dir_attributes(handle, NULL, NULL, NULL)); TRYF(nsp_session_close(handle)); TRYF(nsp_session_open(handle, SID_FILE_MGMT)); TRYF(nsp_cmd_s_dir_enum_init(handle, "/")); TRYF(nsp_cmd_r_dir_enum_init(handle)); for(;;) { VarEntry *fe; GNode *node; TRYF(nsp_cmd_s_dir_enum_next(handle)); err = nsp_cmd_r_dir_enum_next(handle, varname, &varsize, &vartype); if (err == ERR_EOT) break; else if (err != 0) return err; fe = tifiles_ve_create(); strcpy(fe->folder, varname); strcpy(fe->name, varname); fe->size = varsize; fe->type = vartype; fe->attr = ATTRB_NONE; node = g_node_new(fe); folder = g_node_append(*vars, node); ticalcs_info(_("Name: %s | Type: %8s | Attr: %i | Size: %08X"), fe->name, tifiles_vartype2string(handle->model, fe->type), fe->attr, fe->size); } TRYF(nsp_cmd_s_dir_enum_done(handle)); TRYF(nsp_cmd_r_dir_enum_done(handle)); for(i = 0; i < (int)g_node_n_children(*vars); i++) { char *folder_name; char *u1, *u2; folder = g_node_nth_child(*vars, i); folder_name = ((VarEntry *) (folder->data))->name; vartype = ((VarEntry *) (folder->data))->type; // Skip entries whose type is 0 (TNS), for example themes.csv on OS 3.0+. if (vartype == 0) { ticalcs_info(_("Not enumerating documents in %s because it's not a folder"), folder_name); continue; } ticalcs_info(_("Directory listing in <%s>..."), folder_name); TRYF(nsp_cmd_s_dir_enum_init(handle, folder_name)); TRYF(nsp_cmd_r_dir_enum_init(handle)); for(;;) { VarEntry *ve = tifiles_ve_create(); GNode *node; char *ext; TRYF(nsp_cmd_s_dir_enum_next(handle)); err = nsp_cmd_r_dir_enum_next(handle, varname, &varsize, &vartype); if (err == ERR_EOT) break; else if (err != 0) return err; ext = tifiles_fext_get(varname); strcpy(ve->folder, folder_name); ve->size = varsize; ve->type = tifiles_fext2vartype(handle->model, ext); ve->attr = ATTRB_NONE; // Just a sanity check if (ext) { // Did the file name have any non-empty extension ? if (*ext) { // Do we know about this file type ? if (ve->type < NSP_MAXTYPES) { // Then we can remove the exension. *(ext-1) = '\0'; } // else don't remove the extension. } // else there is no extension to remove. } strcpy(ve->name, varname); node = g_node_new(ve); g_node_append(folder, node); ticalcs_info(_("Name: %8s | Type: %8s | Attr: %i | Size: %08X"), ve->name, tifiles_vartype2string(handle->model, ve->type), ve->attr, ve->size); u1 = ticonv_varname_to_utf8(handle->model, ((VarEntry *) (folder->data))->name, -1); u2 = ticonv_varname_to_utf8(handle->model, ve->name, ve->type); g_snprintf(update_->text, sizeof(update_->text), _("Parsing %s/%s"), u1, u2); g_free(u1); g_free(u2); update_label(); } TRYF(nsp_cmd_s_dir_enum_done(handle)); TRYF(nsp_cmd_r_dir_enum_done(handle)); } TRYF(nsp_session_close(handle)); return 0; }