自学教程：C++ tifiles_critical函数代码示例

/** * 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;}

TIEXPORT2 int TICALL tifiles_cert_field_next(const uint8_t **data, uint32_t *length){	int ret;	const uint8_t * contents;	uint32_t field_size;	// Initial sanity checks.	if (data == NULL)	{		tifiles_critical("%s: data is NULL", __FUNCTION__);		return ERR_INVALID_PARAM;	}	if (length == NULL)	{		tifiles_critical("%s: length is NULL", __FUNCTION__);		return ERR_INVALID_PARAM;	}	ret = tifiles_cert_field_get(*data, *length, NULL, &contents, &field_size);	if (!ret)	{		*length -= contents + field_size - *data;		*data = contents + field_size;	}	return ret;}

/*  Write a string of 'n' chars max (NULL padded) to a file  - s [in]: a string  - f [in]: a file descriptor  - [out]: -1 if error, 0 otherwise.*/int fwrite_n_chars(FILE * f, unsigned int n, const char *s){	unsigned int i;	unsigned int l;	l = strlen(s);	if (l > n)	{		tifiles_critical("string passed to 'fwrite_n_chars' is too long (>n chars)./n");		tifiles_critical( "s = %s, len(s) = %u/n", s, l);		tifiles_hexdump((uint8_t *)s, (l < n) ? n : l);		return -1;	}	for (i = 0; i < l; i++)	{		if (fputc(s[i], f) == EOF)		{			return -1;		}	}	for (i = l; i < n; i++)	{		if (fputc(0x00, f) == EOF)		{			return -1;		}	}	return 0;}

/** * tifiles_content_delete_regular: * * Free the whole content of a #FileContent structure. * * Return value: none. **/TIEXPORT2 int TICALL tifiles_content_delete_regular(FileContent *content){	int i;	if (content != NULL)	{		for (i = 0; i < content->num_entries; i++) 		{			VarEntry *entry = content->entries[i];			if(entry != NULL)			{				g_free(entry->data);				g_free(entry);			}			else			{				tifiles_critical("tifiles_content_delete_regular(content with NULL entry)");			}		}		g_free(content->entries);		g_free(content);	}	else	{		tifiles_critical("%s(NULL)", __FUNCTION__);	}	return 0;}

TIEXPORT2 int TICALL tifiles_cert_field_find(const uint8_t *data, uint32_t length, uint16_t field_type, const uint8_t **contents, uint32_t *field_size){	int ret = 0;	uint16_t ft;	// Initial sanity checks.	if (data == NULL)	{		tifiles_critical("%s: data is NULL", __FUNCTION__);		return ERR_INVALID_PARAM;	}	if (length < 2)	{		tifiles_critical("%s: length is too small to contain a valid cert field", __FUNCTION__);		return ERR_INVALID_PARAM;	}	// Mask out the size indication, it is harmful for finding a field.	field_type &= 0xFFF0;	ft = 0xFFFF;	while (!ret && ft != field_type)	{		ret = tifiles_cert_field_get(data, length, &ft, contents, field_size);		ft &= 0xFFF0;		if (!ret)		{			ret = tifiles_cert_field_next(&data, &length);		}	}	return ret;}

/*  Write a string of 'n' chars max (SPC padded) to a file  - s [in]: a string  - f [in]: a file descriptor  - [out]: -1 if error, 0 otherwise.*/int fwrite_n_chars2(FILE * f, int n, const char *s){	int i;	int l = n;	l = strlen(s);	if (l > n)	{		tifiles_critical("string passed in 'write_string8' is too long (>n chars)./n");		tifiles_critical( "s = %s, len(s) = %i/n", s, l);		hexdump((uint8_t *) s, (l < 9) ? 9 : l);		return -1;	}	for (i = 0; i < l; i++)	{		if(fputc(s[i], f) == EOF)		{			return -1;		}	}	for (i = l; i < n; i++)	{		if(fputc(0x20, f) == EOF)		{			return -1;		}	}	return 0;}

/** * tnsp_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 tnsp_file_read_flash(const char *filename, FlashContent *content){	FILE *f;	int c;	if (!tifiles_file_is_tno(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/n", filename);		return ERR_FILE_OPEN;	}	content->model = CALC_NSPIRE;	for(c = 0; c != ' '; c=fgetc(f));	content->revision_major = fgetc(f);	fgetc(f);	content->revision_minor = fgetc(f);	fgetc(f);	for(c = 0; c != ' '; c=fgetc(f));	if (fscanf(f, "%i", &(content->data_length)) < 1)	{		goto tfrf;	}	rewind(f);	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;	}	content->next = NULL;	if(fread(content->data_part, 1, content->data_length, f) < content->data_length) goto tfrf;	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;}

/** * tnsp_content_display_flash: * @content: a FlashContent structure. * * Display fields of a FlashContent structure. * * Return value: an error code, 0 otherwise. **/int tnsp_content_display_flash(FlashContent *content){	FlashContent *ptr = content;    if (content == NULL)    {        tifiles_critical("%s(NULL)", __FUNCTION__);        return ERR_INVALID_FILE;    }    tifiles_info("Signature:      %s",	    tifiles_calctype2signature(ptr->model));    tifiles_info("Revision:       %i.%i",	    ptr->revision_major, ptr->revision_minor);    tifiles_info("Flags:          %02X", ptr->flags);    tifiles_info("Object type:    %02X", ptr->object_type);    tifiles_info("Date:           %02X/%02X/%02X%02X",	    ptr->revision_day, ptr->revision_month,	    ptr->revision_year & 0xff, (ptr->revision_year & 0xff00) >> 8);    tifiles_info("Name:           %s", ptr->name);    tifiles_info("Device type:    %s",	    ptr->device_type == DEVICE_TYPE_89 ? "ti89" : "ti92+");    tifiles_info("Data type:      OS data");    tifiles_info("Length:         %08X (%i)", ptr->data_length,	    ptr->data_length);    tifiles_info("");  return 0;}

/** * ti9x_content_display_regular: * @content: a Ti9xRegular structure. * * Display fields of a Ti9xRegular structure. * * Return value: an error code, 0 otherwise. **/int ti9x_content_display_regular(Ti9xRegular *content){	int i;	char trans[17];	if (content == NULL)	{		tifiles_critical("%s(NULL)", __FUNCTION__);		return ERR_INVALID_FILE;	}	tifiles_info("Signature:         %s", tifiles_calctype2signature(content->model));	tifiles_info("Comment:           %s", content->comment);	tifiles_info("Default folder:    %s", content->default_folder);	tifiles_info("Number of entries: %i", content->num_entries);	for (i = 0; i < content->num_entries; i++) 	{		if (content->entries[i] != NULL)		{			tifiles_info("Entry #%i", i);			tifiles_info("  folder:    %s", content->entries[i]->folder);			tifiles_info("  name:      %s", ticonv_varname_to_utf8_s(content->model, content->entries[i]->name,  trans, content->entries[i]->type));			tifiles_info("  type:      %02X (%s)", content->entries[i]->type, tifiles_vartype2string(content->model, content->entries[i]->type));			tifiles_info("  attr:      %s", tifiles_attribute_to_string(content->entries[i]->attr));			tifiles_info("  length:    %04X (%i)", content->entries[i]->size, content->entries[i]->size);		}	}	tifiles_info("Checksum:    %04X (%i) ", content->checksum, content->checksum);	return 0;}

/** * tifiles_signature2calctype: * @s: a TI file signature like "**TI89**". * * Returns the calculator model contained in the signature. * * Return value: a calculator model. **/TIEXPORT2 CalcModel TICALL tifiles_signature2calctype(const char *s){  if (s != NULL)  {    if (!g_ascii_strcasecmp(s, "**TI73**"))      return CALC_TI73;    else if (!g_ascii_strcasecmp(s, "**TI82**"))      return CALC_TI82;    else if (!g_ascii_strcasecmp(s, "**TI83**"))      return CALC_TI83;    else if (!g_ascii_strcasecmp(s, "**TI83F*"))      return CALC_TI83P;    else if (!g_ascii_strcasecmp(s, "**TI85**"))      return CALC_TI85;    else if (!g_ascii_strcasecmp(s, "**TI86**"))      return CALC_TI86;    else if (!g_ascii_strcasecmp(s, "**TI89**"))      return CALC_TI89;    else if (!g_ascii_strcasecmp(s, "**TI92**"))      return CALC_TI92;    else if (!g_ascii_strcasecmp(s, "**TI92P*"))      return CALC_TI92P;    else if (!g_ascii_strcasecmp(s, "**V200**"))      return CALC_V200;  }  tifiles_critical("%s: invalid signature.", __FUNCTION__);  return CALC_NONE;}

/** * tifiles_build_fullname: * @model: a calculator model. * @full_name: the buffer where to store the result. * @fldname: the name of folder or "". * @varname: the name of variable * * Build the complete path from folder name and variable name. * Not all of calculators supports folder. * * Return value: a full path as string like 'fldname/varname'. **/TIEXPORT2 char* TICALL tifiles_build_fullname(CalcModel model, char *full_name, const char *fldname, const char *varname){	if (full_name == NULL || fldname == NULL || varname == NULL)	{		tifiles_critical("%s: an argument is NULL", __FUNCTION__);		return NULL;	}	if (tifiles_has_folder(model)) 	{		if (fldname[0] == 0)		{			sprintf(full_name, "%s//%s", fldname, varname);		}		else		{			strcpy(full_name, varname);		}	}	else	{		strcpy(full_name, varname);	}	return full_name;}

/** * tifiles_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. * * Return value: an error code, 0 otherwise. **/TIEXPORT2 int tifiles_file_read_flash(const char *filename, FlashContent *content){	if (filename == NULL || content == NULL)	{		tifiles_critical("%s: an argument is NULL", __FUNCTION__);		return ERR_INVALID_FILE;	}#if !defined(DISABLE_TI8X)	if (tifiles_calc_is_ti8x(tifiles_file_get_model(filename)))		return ti8x_file_read_flash(filename, content);	else #endif#if !defined(DISABLE_TI9X)	if (tifiles_calc_is_ti9x(tifiles_file_get_model(filename)) || tifiles_file_is_tib(filename))		return ti9x_file_read_flash(filename, content);	else#endif	if(content->model == CALC_NSPIRE)		return tnsp_file_read_flash(filename, content);	else		return ERR_BAD_CALC;	return 0;}

/** * tifiles_file_display_regular: * @content: the file content to show. * * Display file content information. * * Return value: an error code, 0 otherwise. **/TIEXPORT2 int TICALL tifiles_file_display_regular(FileContent *content){	if (content == NULL)	{		tifiles_critical("%s(NULL)", __FUNCTION__);		return ERR_INVALID_FILE;	}#if !defined(DISABLE_TI8X)	if (tifiles_calc_is_ti8x(content->model))		return ti8x_content_display_regular(content);	else #endif#if !defined(DISABLE_TI9X)	if (tifiles_calc_is_ti9x(content->model))		return ti9x_content_display_regular(content);	else#endif	if(content->model == CALC_NSPIRE)		return tnsp_content_display_regular(content);	else		return ERR_BAD_CALC;	return 0;}

/** * tifiles_file_write_regular: * @filename: name of single/group file where to write or NULL. * @content: the file content to write. * @real_fname: pointer address or NULL. Must be freed if needed when no longer needed. * * Write one (or several) variable(s) into a single (group) file. If filename is set to NULL, * the function build a filename from varname and allocates resulting filename in %real_fname. * %filename and %real_filename can be NULL but not both ! * * %real_filename must be freed when no longer used. * * Return value: an error code, 0 otherwise. **/TIEXPORT2 int tifiles_file_write_regular(const char *filename, FileContent *content, char **real_fname){	if (content == NULL || (filename == NULL && real_fname == NULL))	{		tifiles_critical("%s: an argument is NULL", __FUNCTION__);		return ERR_INVALID_FILE;	}#if !defined(DISABLE_TI8X)	if (tifiles_calc_is_ti8x(content->model))		return ti8x_file_write_regular(filename, (Ti8xRegular *)content, real_fname);	else #endif#if !defined(DISABLE_TI9X)	if (tifiles_calc_is_ti9x(content->model))		return ti9x_file_write_regular(filename, (Ti9xRegular *)content, real_fname);	else#endif	if(content->model == CALC_NSPIRE)		return tnsp_file_write_regular(filename, (FileContent *)content, real_fname);	else		return ERR_BAD_CALC;	return 0;}

/** * tifiles_build_fullname: * @model: a calculator model. * @full_name: the buffer where to store the result. * @fldname: the name of folder or "". * @varname: the name of variable * * Build the complete path from folder name and variable name. * Not all of calculators supports folder. * * Return value: a full path as string like 'fldname/varname'. **/char* TICALL tifiles_build_fullname(CalcModel model, char *full_name,				  const char *fldname, const char *varname){	if (full_name == NULL || fldname == NULL || varname == NULL)	{		tifiles_critical("%s: an argument is NULL", __FUNCTION__);		return NULL;	}	if (tifiles_has_folder(model)) 	{		if (strcmp(fldname, "")) 		{			strcpy(full_name, fldname);			strcat(full_name, "//");			strcat(full_name, varname);		}		else		{			strcpy(full_name, varname);		}	}	else	{		strcpy(full_name, varname);	}	return full_name;}

/** * tifiles_content_dup_regular: * * Allocates and copies a new #FileContent structure. * * Return value: none. **/TIEXPORT2 FileContent* TICALL tifiles_content_dup_regular(FileContent *content){	FileContent *dup = NULL;	int i;	if (content != NULL)	{		dup = tifiles_content_create_regular(content->model);		if (dup != NULL)		{			memcpy(dup, content, sizeof(FileContent));			dup->entries = tifiles_ve_create_array(content->num_entries);			if (dup->entries != NULL)			{				for (i = 0; i < content->num_entries; i++) 					dup->entries[i] = tifiles_ve_dup(content->entries[i]);			}		}	}	else	{		tifiles_critical("%s(NULL)", __FUNCTION__);	}	return dup;}

/** * tnsp_content_display_flash: * @content: a FlashContent structure. * * Display fields of a FlashContent structure. * * Return value: an error code, 0 otherwise. **/int tnsp_content_display_flash(FlashContent *content){	FlashContent *ptr = content;	if (content == NULL)	{		tifiles_critical("%s(NULL)", __FUNCTION__);		return ERR_INVALID_FILE;	}	for (ptr = content; ptr != NULL; ptr = ptr->next)	{		tifiles_info("FlashContent for TI-Nspire: %p", ptr);		tifiles_info("Model:           %02X (%u)", ptr->model, ptr->model);		tifiles_info("Signature:       %s", tifiles_calctype2signature(ptr->model));		tifiles_info("model_dst:       %02X (%u)", ptr->model_dst, ptr->model_dst);		tifiles_info("Revision:        %u.%u", ptr->revision_major, ptr->revision_minor);		tifiles_info("Flags:           %02X", ptr->flags);		tifiles_info("Object type:     %02X", ptr->object_type);		tifiles_info("Date:            %02X/%02X/%02X%02X", ptr->revision_day, ptr->revision_month, ptr->revision_year & 0xff, (ptr->revision_year & 0xff00) >> 8);		tifiles_info("Name:            %s", ptr->name);		tifiles_info("Data type:       OS data");		tifiles_info("Length:          %08X (%i)", ptr->data_length, ptr->data_length);		tifiles_info("Data part:       %p", ptr->data_part);		tifiles_info("Next:            %p", ptr->next);	}	return 0;}

/** * tifiles_group_del_file: * @src_filename: the file to remove from group file * @dst_filename: the group file * * Search for entry and remove it from file. * * Return value: 0 if successful, an error code otherwise. **/TIEXPORT2 int TICALL tifiles_group_del_file(VarEntry *entry, const char *dst_filename){	CalcModel dst_model;	FileContent* dst_content = NULL;	int ret = 0;	if (entry == NULL || dst_filename == NULL)	{		tifiles_critical("%s: an argument is NULL", __FUNCTION__);		return ERR_INVALID_FILE;	}	// src can be single/group file and dst must be group file	if(!tifiles_file_is_group(dst_filename))		return -1;	dst_model = tifiles_file_get_model(dst_filename);	dst_content = tifiles_content_create_regular(dst_model);	ret = tifiles_file_read_regular(dst_filename, dst_content);	if(ret) goto tgdf;	tifiles_content_del_entry(dst_content, entry);	tifiles_file_display_regular(dst_content);	ret = tifiles_file_write_regular(dst_filename, dst_content, NULL);	if(ret) goto tgdf;tgdf:	tifiles_content_delete_regular(dst_content);	return ret;}

/** * tifiles_ungroup_file: * @src_filename: full path of file to ungroup. * @dst_filenames: NULL or the address of a pointer where to store a NULL-terminated  * array of strings which contain the list of ungrouped files. * * Ungroup a TI 'group' file into several files. Resulting files have the * same name as the variable stored within group file. * Beware: there is no existence check; files may be overwritten ! * * %dst_filenames must be freed when no longer used. * * Return value: an error code if unsuccessful, 0 otherwise. **/TIEXPORT2 int TICALL tifiles_ungroup_file(const char *src_filename, char ***dst_filenames){	FileContent *src = NULL;	FileContent **ptr, **dst = NULL;	char *real_name, **p;	int i, n;	int ret;	if (src_filename == NULL)	{		tifiles_critical("%s: an argument is NULL", __FUNCTION__);		return ERR_INVALID_FILE;	}	if(tifiles_file_get_model(src_filename) == CALC_NSPIRE)		return ERR_BAD_CALC;	// read group file	src = tifiles_content_create_regular(CALC_NONE);	ret = tifiles_file_read_regular(src_filename, src);	if(ret) goto tuf;	// ungroup structure	ret = tifiles_ungroup_content(src, &dst);	if(ret) goto tuf;	// count number of structures and allocates array of strings	for(ptr = dst, n = 0; *ptr != NULL; ptr++, n++);	if(dst_filenames != NULL)		*dst_filenames = (char **)g_malloc((n + 1) * sizeof(char *));	// store each structure content to file	for (ptr = dst, i = 0; *ptr != NULL; ptr++, i++)	{		ret = tifiles_file_write_regular(NULL, *ptr, &real_name);		if(ret) goto tuf;		if(dst_filenames != NULL)			*dst_filenames[i] = real_name;		else			g_free(real_name);	}	// release allocated memory	tifiles_content_delete_regular(src);	tifiles_content_delete_group(dst);	return 0;tuf:	if(dst_filenames != NULL)	{		for(p = *dst_filenames; *p; p++)			g_free(*p);		g_free(p);	}	tifiles_content_delete_regular(src);	tifiles_content_delete_group(dst);	return ret;}

/** * tifiles_content_del_entry: * @content: a file content (single/group only). * @ve: the entry to remove * * Search for entry name and remove it from file content (not tested !). * * Return value: the number of entries or -1 if not found. **/TIEXPORT2 int TICALL tifiles_content_del_entry(FileContent *content, VarEntry *ve){	int i, j;	if (content != NULL)	{		if (ve == NULL)		{			tifiles_critical("%s: deleting NULL VarEntry ???", __FUNCTION__);			return content->num_entries;		}		// Search for entry		for(i = 0; i < content->num_entries; i++)		{			VarEntry *s = content->entries[i];			if(!strcmp(s->folder, ve->folder) && !strcmp(s->name, ve->name))				break;		}		// Not found ? Exit !		if(i == content->num_entries)			return -1;		// Release		tifiles_ve_delete(content->entries[i]);		// And shift		for(j = i; j < content->num_entries; j++)			content->entries[j] = content->entries[j+1];		content->entries[j] = NULL;		// And resize		content->entries = tifiles_ve_resize_array(content->entries, content->num_entries - 1);		content->num_entries--;		return content->num_entries;	}	else	{		tifiles_critical("%s: content is NULL", __FUNCTION__);		return 0;	}}

/** * tifiles_string2vartype: * @model: a calculator model. * @s: a type as string (like "REAL"). * * Returns the type of variable. * * Return value: a type ID. **/TIEXPORT2 uint8_t TICALL tifiles_string2vartype(CalcModel model, const char *s){  if (s == NULL)  {    tifiles_critical("%s: invalid string !", __FUNCTION__);    return 0;  }  switch (model)   {#ifndef DISABLE_TI8X  case CALC_TI73:    return ti73_type2byte(s);  case CALC_TI82:    return ti82_type2byte(s);  case CALC_TI83:    return ti83_type2byte(s);  case CALC_TI83P:  case CALC_TI84P:  case CALC_TI84P_USB:    return ti83p_type2byte(s);  case CALC_TI85:    return ti85_type2byte(s);  case CALC_TI86:    return ti86_type2byte(s);#endif#ifndef DISABLE_TI9X  case CALC_TI89:  case CALC_TI89T:  case CALC_TI89T_USB:    return ti89_type2byte(s);  case CALC_TI92:    return ti92_type2byte(s);  case CALC_TI92P:    return ti92p_type2byte(s);  case CALC_V200:    return v200_type2byte(s);  case CALC_NSPIRE:    return nsp_type2byte(s);#endif  default:    tifiles_critical("%s: invalid model argument.", __FUNCTION__);    return 0;  }}

TIEXPORT2 int TICALL tifiles_cert_field_find_path(const uint8_t *data, uint32_t length, const uint16_t *field_path, uint16_t field_path_len, const uint8_t **contents, uint32_t *field_size){	int ret = 0;	// Initial sanity checks.	if (data == NULL)	{		tifiles_critical("%s: data is NULL", __FUNCTION__);		return ERR_INVALID_PARAM;	}	if (field_path == NULL)	{		tifiles_critical("%s: field_path is NULL", __FUNCTION__);		return ERR_INVALID_PARAM;	}	if (length < 2)	{		tifiles_critical("%s: length is too small to contain a valid cert field", __FUNCTION__);		return ERR_INVALID_PARAM;	}	if (field_path_len == 0)	{		tifiles_warning("%s: field path is empty", __FUNCTION__);		return ERR_INVALID_PARAM;	}	while (field_path_len != 0 && !ret)	{		ret = tifiles_cert_field_find(data, length, *field_path, &data, &length);		//tifiles_warning("%p/t%u", data, length);		field_path++;		field_path_len--;		if (contents != NULL)		{			*contents = data;		}		if (field_size != NULL)		{			*field_size = length;		}	}	return ret;}

/** * ti9x_file_write_backup: * @filename: name of backup file where to write. * @content: the file content to write. * * Write content to a backup file. * * Return value: an error code, 0 otherwise. **/int ti9x_file_write_backup(const char *filename, Ti9xBackup *content){	FILE *f;	if (filename == NULL || content == NULL)	{		tifiles_critical("%s: an argument is NULL", __FUNCTION__);		return ERR_INVALID_FILE;	}	f = g_fopen(filename, "wb");	if (f == NULL) 	{		tifiles_info("Unable to open this file: %s", filename);		return ERR_FILE_OPEN;	}	if (fwrite_8_chars(f, tifiles_calctype2signature(content->model)) < 0) goto tfwb;	if (fwrite(fsignature, 1, 2, f) < 2) goto tfwb;	if (fwrite_8_chars(f, "") < 0) goto tfwb;	if (fwrite_n_bytes(f, 40, (uint8_t *)content->comment) < 0) goto tfwb;	if (fwrite_word(f, 1) < 0) goto tfwb;	if (fwrite_long(f, 0x52) < 0) goto tfwb;	if (fwrite_8_chars(f, content->rom_version) < 0) goto tfwb;	if (fwrite_word(f, content->type) < 0) goto tfwb;	if (fwrite_word(f, 0) < 0) goto tfwb;	if (fwrite_long(f, content->data_length + 0x52 + 2) < 0) goto tfwb;	if (fwrite_word(f, 0x5aa5) < 0) goto tfwb;	if (fwrite(content->data_part, 1, content->data_length, f) < content->data_length) goto tfwb;	content->checksum = tifiles_checksum(content->data_part, content->data_length);	if (fwrite_word(f, content->checksum) < 0) goto tfwb;	fclose(f);	return 0;tfwb:	// release on exit	tifiles_critical("%s: error writing file %s", __FUNCTION__, filename);	fclose(f);	return ERR_FILE_IO;}

/** * tifiles_content_dup_flash: * * Allocates and copies a new FlashContent structure. * * Return value: none. **/TIEXPORT2 FlashContent* TICALL tifiles_content_dup_flash(FlashContent *content){	FlashContent *dup = NULL;	FlashContent *p, *q;	if (content != NULL)	{		dup = tifiles_content_create_flash(content->model);		if (dup != NULL)		{			for(p = content, q = dup; p; p = p->next, q = q->next)			{				memcpy(q, p, sizeof(FlashContent));				// TI9x part				if(tifiles_calc_is_ti9x(content->model))				{					if(p->data_part)					{						q->data_part = (uint8_t *)g_malloc0(p->data_length+1);						memcpy(q->data_part, p->data_part, p->data_length+1);					}				}				// TI8x part				if(tifiles_calc_is_ti8x(content->model))				{					int i;					// copy pages					q->pages = tifiles_fp_create_array(p->num_pages);					for(i = 0; i < content->num_pages; i++)					{						q->pages[i] = (FlashPage *)g_malloc0(sizeof(FlashPage));						memcpy(q->pages[i], p->pages[i], sizeof(FlashPage));						q->pages[i]->data = (uint8_t *) g_malloc0(p->pages[i]->size);						memcpy(q->pages[i]->data, p->pages[i]->data, p->pages[i]->size);					}				}				if(p->next)					q->next = tifiles_content_create_flash(p->model);			}		}	}	else	{		tifiles_critical("%s(NULL)", __FUNCTION__);	}	return dup;}

/** * tnsp_file_write_regular: * @filename: name of file where to write or NULL. * @content: the file content to write. * @real_filename: pointer address or NULL. Must be freed if needed when no longer needed. * * Write one variable into a single file. If filename is set to NULL, * the function build a filename from varname and allocates resulting filename in %real_fname. * %filename and %real_filename can be NULL but not both ! * * %real_filename must be freed when no longer used. * * Return value: an error code, 0 otherwise. **/int tnsp_file_write_regular(const char *fname, FileContent *content, char **real_fname){	FILE *f;	char *filename = NULL;	VarEntry *entry;	if (content->entries == NULL || content->entries[0] == NULL)	{		tifiles_warning("%s: skipping content with NULL content->entries or content->entries[0]", __FUNCTION__);		return ERR_FILE_IO;	}	if (fname != NULL) 	{		filename = g_strdup(fname);		if (filename == NULL)		{			return ERR_MALLOC;		}	}	else	{		filename = tifiles_build_filename(content->model_dst, content->entries[0]);		if (real_fname != NULL)		{			*real_fname = g_strdup(filename);		}	}	f = g_fopen(filename, "wb");	if (f == NULL) 	{		tifiles_info( "Unable to open this file: %s", filename);		g_free(filename);		return ERR_FILE_OPEN;	}	entry = content->entries[0];	if(fwrite(entry->data, 1, entry->size, f) < entry->size)	{		goto tfwr;	}	g_free(filename);	fclose(f);	return 0;tfwr:  // release on exit	tifiles_critical("%s: error writing file %s", __FUNCTION__, filename);	g_free(filename);	fclose(f);	return ERR_FILE_IO;}

/** * tifiles_content_add_entry: * @content: a file content (single/group only). * @ve: the entry to add * * Adds the entry to the file content and updates internal structures. * Beware: the entry is not duplicated. * * Return value: the number of entries. **/TIEXPORT2 int TICALL tifiles_content_add_entry(FileContent *content, VarEntry *ve){	if (content != NULL)	{		content->entries = tifiles_ve_resize_array(content->entries, content->num_entries + 1);		if (ve == NULL)		{			tifiles_critical("%s: adding NULL VarEntry ???", __FUNCTION__);		}		content->entries[content->num_entries] = ve;		content->num_entries++;		return content->num_entries;	}	else	{		tifiles_critical("%s: content is NULL", __FUNCTION__);	}	return 0;}

/** * tifiles_group_files: * @src_filenames: a NULL-terminated array of strings (list of files to group). * @dst_filename: the filename where to store the group. * * Group several TI files into a single one (group file). * * Return value: an error code if unsuccessful, 0 otherwise. **/TIEXPORT2 int TICALL tifiles_group_files(char **src_filenames, const char *dst_filename){	int i, n;	FileContent **src = NULL;	FileContent *dst = NULL;	int ret = 0;	if (src_filenames == NULL || dst_filename == NULL)	{		tifiles_critical("%s: an argument is NULL", __FUNCTION__);		return ERR_INVALID_FILE;	}	if(tifiles_file_get_model(src_filenames[0]) == CALC_NSPIRE)		return ERR_BAD_CALC;	// counter number of files to group	for (n = 0; src_filenames[n] != NULL; n++);	// allocate space for that	src = (FileContent **)g_malloc0((n + 1) * sizeof(FileContent *));	if (src == NULL)		return ERR_MALLOC;	// allocate each structure and load file content	for (i = 0; i < n; i++)	{		src[i] = (FileContent *)g_malloc0(sizeof(FileContent));		if (src[i] == NULL)			return ERR_MALLOC;		ret = tifiles_file_read_regular(src_filenames[i], src[i]);		if(ret) goto tgf;	}	src[i] = NULL;	// group the array of structures	ret = tifiles_group_contents(src, &dst);	if(ret) goto tgf;	// write grouped file	ret = tifiles_file_write_regular(dst_filename, dst, NULL);	if(ret) goto tgf;	// release allocated memorytgf:	tifiles_content_delete_group(src);	tifiles_content_delete_regular(dst);	return 0;}

/** * tifiles_get_varname: * @full_name: a calculator path such as 'fldname/varname'. * * Returns the name of the variable. * * Return value: varname as string. It should not be modified (static). **/char *TICALL tifiles_get_varname(const char *full_name){	if (full_name != NULL)	{		char *bs = strchr(full_name, '//');		if (bs == NULL)			return (char *) full_name;		else			return (++bs);	}	tifiles_critical("%s(NULL)", __FUNCTION__);	return NULL;}

/** * tifiles_group_contents: * @src_contents: a pointer on an array of #FileContent structures. The array must be NULL-terminated. * @dst_content: the address of a pointer. This pointer will see the allocated group file. * * Must be freed when no longer needed as well as the content of each #FileContent structure * (use #tifiles_content_delete_regular as usual). * * Group several #FileContent structures into a single one. * * Return value: an error code if unsuccessful, 0 otherwise. **/TIEXPORT2 int TICALL tifiles_group_contents(FileContent **src_contents, FileContent **dst_content){	FileContent *dst;	int i, j, n;	if (src_contents == NULL || dst_content == NULL)	{		tifiles_critical("%s: an argument is NULL", __FUNCTION__);		return ERR_INVALID_FILE;	}	for (n = 0; src_contents[n] != NULL; n++)	{		if(src_contents[n]->model == CALC_NSPIRE)		{			return ERR_BAD_CALC;		}	}	dst = (FileContent *)g_malloc0(sizeof(FileContent));	if (dst == NULL)		return ERR_MALLOC;	if (n > 0)	{		memcpy(dst, src_contents[0], sizeof(FileContent));	}	dst->num_entries = n;	dst->entries = g_malloc0((n + 1) * sizeof(VarEntry*));	if (dst->entries == NULL)	{		free(dst);		return ERR_MALLOC;	}	for (i = 0; i < n; i++)	{		FileContent *src = src_contents[i];		for(j = 0; j < src->num_entries; j++)			dst->entries[i] = tifiles_ve_dup(src->entries[j]);	}	*dst_content = dst;	return 0;}

/** * tifiles_build_filename: * @model: a calculator model. * @ve: a #VarEntry structure. * * Build a valid filename from folder name, variable name and variable type. * Example: real number x on TI89 in the 'main' folder will give 'main.x.89e'. * Note: this function is useable with FLASH apps, too (but you have to fill the #VarEntry structure yourself). * * Return value: a newly allocated string which must be freed when no longer used. **/TIEXPORT2 char* TICALL tifiles_build_filename(CalcModel model, const VarEntry *ve){	char *filename;	if (ve == NULL)	{		tifiles_critical("%s: an argument is NULL", __FUNCTION__);		return NULL;	}	if(tifiles_calc_is_ti8x(model) || !strcmp(ve->folder, "") || 		(ve->type == tifiles_flash_type(model)))	{		char *part2;		const char *part3;		char *tmp;		part2 = ticonv_varname_to_filename(model, ve->name, ve->type);		part3 = tifiles_vartype2fext(model, ve->type);		tmp = g_strconcat(part2, ".", part3, NULL);		g_free(part2);		filename = g_strdup(tmp);		g_free(tmp);	}	else	{		char *part1;		char *part2;		const char *part3;		char *tmp;		part1 = ticonv_varname_to_filename(model, ve->folder, -1);		part2 = ticonv_varname_to_filename(model, ve->name, ve->type);		part3 = tifiles_vartype2fext(model, ve->type);		tmp = g_strconcat(part1, ".", part2, ".", part3, NULL);		g_free(part1);		g_free(part2);		filename = strdup(tmp);		g_free(tmp);	}	return filename;}