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();
}
int ti68k_is_a_tib_file(const char *filename)
{
int ret1 = tifiles_file_is_flash(filename);
int ret2 = tifiles_file_is_tib (filename);
return ret1 || ret2;
}
int gfm_tifiles_group(const char **filenames, int type)
{
char **ptr;
gchar *input;
gchar *target = NULL;
gchar *dirname = g_path_get_dirname(filenames[0]);
// gchar *basename = g_path_get_basename(filenames[0]);
int err = 0;
// Check for selection consistency
for(ptr = (char **)filenames; *ptr; ptr++)
{
if(tifiles_file_is_group(*ptr) || tifiles_file_is_tigroup(*ptr))
{
msgbox_one(MSGBOX_ERROR, _("Group files are not allowed in selection."));
return -1;
}
if(tifiles_file_is_flash(*ptr) && type != TIFILE_TIGROUP)
{
msgbox_one(MSGBOX_ERROR, _("FLASH files are not allowed in group files."));
return -1;
}
}
// Ask for group name
input = msgbox_input(_("Group files"), "group", _("Group name: "));
if(input == NULL)
return -1;
// And group
if(type == TIFILE_GROUP)
{
target = g_strconcat(dirname, G_DIR_SEPARATOR_S, input, ".",
tifiles_fext_of_group(tifiles_file_get_model(filenames[0])), NULL);
g_free(input);
err = tifiles_group_files((char **)filenames, target);
}
else if(type == TIFILE_TIGROUP)
{
target = g_strconcat(dirname, G_DIR_SEPARATOR_S, input, ".tig", NULL);
g_free(input);
err = tifiles_tigroup_files((char **)filenames, target);
}
if(err)
{
gchar *str;
tifiles_error_get(err, &str);
msgbox_one(MSGBOX_ERROR, str);
g_free(str);
}
g_free(target);
return 0;
}
/**
* 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);
}
/**
* ti9x_file_read_flash:
* @filename: name of flash file to open.
* @content: where to store the file content.
*
* Load the flash file into a #FlashContent structure.
*
* Structure content must be freed with #tifiles_content_delete_flash 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_flash(const char *filename, Ti9xFlash *head)
{
FILE *f;
Ti9xFlash *content = head;
long cur_pos = 0;
int tib = 0;
char signature[9];
int ret = ERR_FILE_IO;
if (head == NULL)
{
tifiles_critical("%s: an argument is NULL", __FUNCTION__);
return ERR_INVALID_FILE;
}
if (!tifiles_file_is_flash(filename) && !tifiles_file_is_tib(filename))
{
ret = ERR_INVALID_FILE;
goto tfrf2;
}
// detect file type (old or new format)
tib = tifiles_file_is_tib(filename);
f = g_fopen(filename, "rb");
if (f == NULL)
{
tifiles_info("Unable to open this file: %s", filename);
ret = ERR_FILE_OPEN;
goto tfrf2;
}
if (fseek(f, 0, SEEK_END)) goto tfrf;
cur_pos = ftell(f);
if (cur_pos < 0) goto tfrf;
if (fseek(f, 0, SEEK_SET)) goto tfrf;
// The TI-68k series' members have at best 4 MB of Flash.
// TIB files larger than that size are insane.
if (cur_pos >= (4L << 20))
{
ret = ERR_INVALID_FILE;
goto tfrf;
}
if (tib)
{
// tib is an old format but mainly used by developers
memset(content, 0, sizeof(Ti9xFlash));
content->data_length = (uint32_t)cur_pos;
strncpy(content->name, "basecode", sizeof(content->name) - 1);
content->name[sizeof(content->name) - 1] = 0;
content->data_type = 0x23; // FLASH os
content->data_part = (uint8_t *)g_malloc0(content->data_length);
if (content->data_part == NULL)
{
ret = ERR_MALLOC;
goto tfrf;
}
if (fread(content->data_part, 1, content->data_length, f) < content->data_length) goto tfrf;
switch(content->data_part[8])
{
case 1: content->device_type = DEVICE_TYPE_92P; break; // TI92+
case 3: content->device_type = DEVICE_TYPE_89; break; // TI89
// value added by the TI community according to HWID parameter
// doesn't have any 'legal' existence.
case 8: content->device_type = DEVICE_TYPE_92P; break; // V200PLT
case 9: content->device_type = DEVICE_TYPE_89; break; // Titanium
}
content->next = NULL;
}
else
{
for (content = head;; content = content->next)
{
if (fread_8_chars(f, signature) < 0) goto tfrf;
content->model = tifiles_file_get_model(filename);
if (fread_byte(f, &(content->revision_major)) < 0) goto tfrf;
if (fread_byte(f, &(content->revision_minor)) < 0) goto tfrf;
if (fread_byte(f, &(content->flags)) < 0) goto tfrf;
if (fread_byte(f, &(content->object_type)) < 0) goto tfrf;
if (fread_byte(f, &(content->revision_day)) < 0) goto tfrf;
if (fread_byte(f, &(content->revision_month)) < 0) goto tfrf;
if (fread_word(f, &(content->revision_year)) < 0) goto tfrf;
if (fskip(f, 1) < 0) goto tfrf;
if (fread_8_chars(f, content->name) < 0) goto tfrf;
if (fskip(f, 23) < 0) goto tfrf;
if (fread_byte(f, &(content->device_type)) < 0) goto tfrf;
if (fread_byte(f, &(content->data_type)) < 0) goto tfrf;
if (fskip(f, 23) < 0) goto tfrf;
if (fread_byte(f, &(content->hw_id)) < 0) goto tfrf;
if (fread_long(f, &(content->data_length)) < 0) goto tfrf;
if (content->data_type != TI89_LICENSE && !check_device_type(content->device_type))
{
ret = ERR_INVALID_FILE;
goto tfrf;
}
if (!check_data_type(content->data_type))
{
ret = ERR_INVALID_FILE;
goto tfrf;
}
// TODO: modify this code if TI ever makes a TI-eZ80 model with more than 4 MB of Flash memory...
if (content->data_length > 4U * 1024 * 1024 - 65536U)
{
// Data length larger than Flash memory size - boot code sector size doesn't look right.
ret = ERR_INVALID_FILE;
goto tfrf;
}
content->data_part = (uint8_t *)g_malloc0(content->data_length);
if (content->data_part == NULL)
{
ret = ERR_MALLOC;
goto tfrf;
}
if (fread(content->data_part, 1, content->data_length, f) < content->data_length) goto tfrf;
if ( (content->data_type == TI83p_AMS && content->data_part[0] != 0x80)
|| (content->data_type == TI83p_APPL && content->data_part[0] != 0x81))
{
ret = ERR_INVALID_FILE;
goto tfrf;
}
content->next = NULL;
// check for end of file
if (fread_8_chars(f, signature) < 0)
{
break;
}
if (strcmp(signature, "**TIFL**") || feof(f))
{
break;
}
if (fseek(f, -8, SEEK_CUR)) goto tfrf;
content->next = (Ti9xFlash *)g_malloc0(sizeof(Ti9xFlash));
if (content->next == NULL)
{
ret = ERR_MALLOC;
goto tfrf;
}
}
}
fclose(f);
return 0;
tfrf: // release on exit
tifiles_critical("%s: error reading / understanding file %s", __FUNCTION__, filename);
fclose(f);
tfrf2:
tifiles_content_delete_flash(content);
return ret;
}
// Used for sending vars
// Note: user_data is a string:
// - such as "<FLASH>" for sending var into FLASH (ti83+/84+/89/92+/v200)
// - such as "" for sending var in the default folder
// - such as "foo" for sending var in the 'foo' folder
// - unused for sending FLASH files
void on_tilp_send(const gchar *user_data)
{
gchar *target;
FileEntry *f;
int ret1 = -1;
int ret2 = -1;
if (local.selection0 == NULL && local.selection2 == NULL && local.selection5 == NULL)
return;
tilp_local_contents_load();
// send apps
if(local.selection3 || (local.selection5 && local.selection3))
{
f = (FileEntry *) local.selection3->data;
// send os upgrades
if(tifiles_file_is_flash(f->name) || tifiles_file_is_tigroup(f->name))
{
if(tifiles_file_test(f->name, TIFILE_OS, options.calc_model))
{
if (tilp_calc_send_os(f->name) != 0)
return;
}
else if(tifiles_file_is_app(f->name))
{
ret1 = tilp_calc_send_app();
if(!ret1)
{
// update dirlist (caching, avoid to request dirlist again)
tilp_local_update_applist();
ctree_refresh();
labels_refresh();
}
}
}
}
// send vars
if(local.selection1 || (local.selection5 && local.selection1))
{
// note: dst_folder must be a copy b/c the user_data
// pointer is no longer valid after dirlist_remote
target = g_strdup(user_data);
// change target folder
if(strcmp(target, "") && strcmp(target, "<FLASH>"))
tilp_local_change_folder(target);
// and wait for action
if (display_action_dbox(target) == BUTTON2)
{
g_free(target);
tilp_local_contents_unload();
return;
}
// needed: avoid box locking/flickering !
GTK_REFRESH();
ret2 = tilp_calc_send_var();
if(!ret2)
{
// update dirlist (caching, avoid to request dirlist again)
tilp_local_update_varlist();
ctree_refresh();
labels_refresh();
}
g_free(target);
}
tilp_local_contents_unload();
}
// 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_flash:
* @filename: name of flash file to open.
* @content: where to store the file content.
*
* Load the flash file into a #FlashContent structure.
*
* Structure content must be freed with #tifiles_content_delete_flash 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_flash(const char *filename, Ti9xFlash *head)
{
FILE *f;
Ti9xFlash *content = head;
int tib = 0;
char signature[9];
if (!tifiles_file_is_flash(filename) && !tifiles_file_is_tib(filename))
{
return ERR_INVALID_FILE;
}
if (head == NULL)
{
tifiles_critical("%s: an argument is NULL", __FUNCTION__);
return ERR_INVALID_FILE;
}
// detect file type (old or new format)
tib = tifiles_file_is_tib(filename);
f = g_fopen(filename, "rb");
if (f == NULL)
{
tifiles_info("Unable to open this file: %s\n", filename);
return ERR_FILE_OPEN;
}
if (tib)
{ // tib is an old format but mainly used by developers
memset(content, 0, sizeof(Ti9xFlash));
if(fseek(f, 0, SEEK_END)) goto tfrf;
content->data_length = (uint32_t) ftell(f);
if(fseek(f, 0, SEEK_SET)) goto tfrf;
strcpy(content->name, "basecode");
content->data_type = 0x23; // FLASH os
content->data_part = (uint8_t *)g_malloc0(content->data_length);
if (content->data_part == NULL)
{
fclose(f);
return ERR_MALLOC;
}
if(fread(content->data_part, 1, content->data_length, f) < content->data_length) goto tfrf;
switch(content->data_part[8])
{
case 1: content->device_type = DEVICE_TYPE_92P; break; // TI92+
case 3: content->device_type = DEVICE_TYPE_89; break; // TI89
// value added by the TI community according to HWID parameter
// doesn't have any 'legal' existence.
case 8: content->device_type = DEVICE_TYPE_92P; break; // V200PLT
case 9: content->device_type = DEVICE_TYPE_89; break; // Titanium
}
content->next = NULL;
}
else
{
for (content = head;; content = content->next)
{
if(fread_8_chars(f, signature) < 0) goto tfrf;
content->model = tifiles_file_get_model(filename);
if(fread_byte(f, &(content->revision_major)) < 0) goto tfrf;
if(fread_byte(f, &(content->revision_minor)) < 0) goto tfrf;
if(fread_byte(f, &(content->flags)) < 0) goto tfrf;
if(fread_byte(f, &(content->object_type)) < 0) goto tfrf;
if(fread_byte(f, &(content->revision_day)) < 0) goto tfrf;
if(fread_byte(f, &(content->revision_month)) < 0) goto tfrf;
if(fread_word(f, &(content->revision_year)) < 0) goto tfrf;
if(fskip(f, 1) < 0) goto tfrf;
if(fread_8_chars(f, content->name) < 0) goto tfrf;
if(fskip(f, 23) < 0) goto tfrf;
if(fread_byte(f, &(content->device_type)) < 0) goto tfrf;
if(fread_byte(f, &(content->data_type)) < 0) goto tfrf;
if(fskip(f, 23) < 0) goto tfrf;
if(fread_byte(f, &(content->hw_id)) < 0) goto tfrf;
if(fread_long(f, &(content->data_length)) < 0) goto tfrf;
if(content->data_type != TI89_LICENSE && !check_device_type(content->device_type))
{
return ERR_INVALID_FILE;
}
if(!check_data_type(content->data_type))
{
return ERR_INVALID_FILE;
}
content->data_part = (uint8_t *)g_malloc0(content->data_length);
if (content->data_part == NULL)
{
fclose(f);
tifiles_content_delete_flash(content);
return ERR_MALLOC;
}
if(fread(content->data_part, 1, content->data_length, f) < content->data_length) goto tfrf;
content->next = NULL;
// check for end of file
if(fread_8_chars(f, signature) < 0)
{
break;
}
if(strcmp(signature, "**TIFL**") || feof(f))
{
break;
}
if(fseek(f, -8, SEEK_CUR)) goto tfrf;
content->next = (Ti9xFlash *)g_malloc0(sizeof(Ti9xFlash));
if (content->next == NULL)
{
fclose(f);
tifiles_content_delete_flash(content);
return ERR_MALLOC;
}
}
}
fclose(f);
return 0;
tfrf: // release on exit
tifiles_critical("%s: error reading / understanding file %s", __FUNCTION__, filename);
fclose(f);
tifiles_content_delete_flash(content);
return ERR_FILE_IO;
}
