usbloadergx/source/mload/fatffs_util.c

/*   
	From Custom IOS Module (FAT)
	
	Copyright (C) 2009 Waninkoko.
	Copyright (C) 2010 Hermes.

	This program is free software; you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation; either version 2 of the License, or
	(at your option) any later version.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with this program; if not, write to the Free Software
	Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/


#include "fatffs_util.h"

#include <string.h>

#include <sys/dir.h>
#include <sys/stat.h>
#include <stdio.h>
#include <malloc.h>

extern u32 nand_mode;

s32 FAT_DeleteDir(const char *dirpath)
{
	DIR_ITER *dir;

	s32 ret;

	/* Open directory */
	dir = diropen(dirpath);
	if (!dir)
		return -1;

	/* Read entries */
	for (;;) {
		char   filename[256], newpath[256];
		struct stat filestat;

		/* Read entry */
		if (dirnext(dir, filename, &filestat))
			break;

		/* Non valid entry */
		if (filename[0]=='.')
			continue;

		/* Generate entry path */
		strcpy(newpath, dirpath);
		strcat(newpath, "/");
		strcat(newpath, filename);

		/* Delete directory contents */
		if (filestat.st_mode & S_IFDIR)
			FAT_DeleteDir(newpath);

		/* Delete object */
		ret = remove(newpath);

		/* Error */
		if (ret != 0)
			break;
	}

	/* Close directory */
	dirclose(dir);

	return 0;
}

static int global_error=0;

static char temp_read_buffer[16384] ATTRIBUTE_ALIGN(32);

s32 _FFS_to_FAT_Copy(const char *ffsdirpath, const char *fatdirpath)
{
int n;
u32 blocks, ionodes;
int pos=0;
char *list;
s32 ret;

u32 ionodes_temp;

	if(ISFS_GetUsage(ffsdirpath, &blocks, &ionodes)) {global_error=-1;return -1;}


	list= memalign(32, ionodes*13);

	if(!list) {global_error=-2;return -2;}

	if(ISFS_ReadDir(ffsdirpath, list , &ionodes)) {free(list);global_error=-3;return -3;}

	if(ionodes) mkdir(fatdirpath, S_IRWXO | S_IRWXG | S_IRWXU);


	/* Read entries */
	for (n=0;n<ionodes;n++) {
		char  * filename;
		char newffspath[256], newfatpath[256];

		/* Read entry */
		filename=&list[pos];
		pos+=strlen(&list[pos])+1;

		/* Non valid entry */
		if (filename[0]=='.')
			continue;

		/* Generate entry path */
		strcpy(newffspath, ffsdirpath);
		strcat(newffspath, "/");
		strcat(newffspath, filename);

		strcpy(newfatpath, fatdirpath);
		strcat(newfatpath, "/");
		strcat(newfatpath, filename);

		ret=ISFS_ReadDir(newffspath, NULL, &ionodes_temp);
		if(ret==0) // it is a directory
			{
			
			_FFS_to_FAT_Copy(newffspath, newfatpath);

			if(global_error) {free(list);return global_error;}
			}

		else // copy the file
			{
			int fd;
			FILE *fp;
			fd=ISFS_Open(newffspath, ISFS_OPEN_READ);
			if(fd<0) 
				{
				global_error=-4;
				free(list);return global_error;
				}
			else
				{
				int len;
				fp=fopen(newfatpath,"w");
				if(!fd) {ISFS_Close(fd);global_error=-5;free(list);return global_error;}

				len= ISFS_Seek(fd, 0, 2);
				//if(len<0) {ISFS_Close(fd);global_error=-6;free(list);return global_error;}
		        ISFS_Seek(fd, 0, 0);
				
				while(len>0)
					{
					ret=len; if(len>16384) ret=16384;
					if(ISFS_Read(fd, temp_read_buffer, ret)!=ret)
						{
						global_error=-7;
						break;
						}
					if(fwrite(temp_read_buffer, 1, ret, fp)!=ret)
						{
						global_error=-8;
						break;
						}
					len-=ret;
					}
				
				fclose(fp);
				ISFS_Close(fd);

				if(global_error) {free(list);return global_error;}
				}
			}	

	}

	free(list);
	return 0;
}

s32 FFS_to_FAT_Copy(const char *ffsdirpath, const char *fatdirpath)
{
u32 blocks, ionodes;
int ret;

char create_dir[256];

 ISFS_Initialize();

 ret=ISFS_GetUsage(ffsdirpath, &blocks, &ionodes);

 if(ret==0) 
	{
	int n=0;

	// creating the path directory

	strcpy(create_dir, fatdirpath);

	while(create_dir[n]!=0 && create_dir[n]!='/') n++;

	if(create_dir[n]=='/') n++;

	while(create_dir[n]!=0)
		{
		if(create_dir[n]=='/')
			{
			create_dir[n]=0;
			mkdir(create_dir, S_IRWXO | S_IRWXG | S_IRWXU);
			create_dir[n]='/';
			}
		n++;
		}
	global_error=0;
	// copy files
    _FFS_to_FAT_Copy(ffsdirpath, fatdirpath);

	ret=global_error=0;
	}
 else ret=-101;

 ISFS_Deinitialize();


return ret;
	
}

static char temp_cad[512];

void create_FAT_FFS_Directory(struct discHdr *header)
{

char device[2][4]={
	"sd:",
	"ud:"
};


if(!header) return;

	sprintf((char *) temp_cad,"%s/nand%c", &device[(nand_mode & 2)!=0][0], (nand_mode & 0xc) ? 49+((nand_mode>>2) & 3) : '\0');

	sprintf((char *) temp_cad+32,"%2.2x%2.2x%2.2x%2.2x", header->id[0], header->id[1], header->id[2], header->id[3]);


	sprintf((char *) temp_cad+64,"%s/title/00010000/%s", temp_cad, temp_cad+32);
	sprintf((char *) temp_cad+128,"%s/title/00010004/%s", temp_cad, temp_cad+32);
	sprintf((char *) temp_cad+256,"/title/00010000/%s", temp_cad+32);
	sprintf((char *) temp_cad+384,"/title/00010004/%s", temp_cad+32);


}

int test_FAT_game(char * directory)
{
DIR_ITER * dir=NULL;

	dir= diropen(directory);
	
	if(dir) {dirclose(dir);return 1;}

return 0;
}


char *get_FAT_directory1(void)
{
	return temp_cad+64;
}

char *get_FAT_directory2(void)
{
	return temp_cad+128;
}

char *get_FFS_directory1(void)
{
	return temp_cad+256;
}

char *get_FFS_directory2(void)
{
	return temp_cad+384;
}