#include <pspkernel.h> // Librería básica para el funcionamiento
#include <pspdebug.h> // Librería con funciones de Debug (iniciar y escribir en la pantalla)
#include <psppower.h>
#include <string.h>
#include <pspdisplay.h>
#include <pspctrl.h> // Librería de control de los controles
#include <pspumd.h> // Librería de control de discos UMD y de los drivers
#include <psploadexec.h>
#include <psploadexec_kernel.h>
 
#include <colors.h> // Sample definitions of colors for Debug functions
 
#include <ioutilities.h> // IoUtilities Lib by dj51_Shura
 
PSP_MODULE_INFO("UMD ISO Dumper", 0, 1, 0);
PSP_MAIN_THREAD_ATTR(THREAD_ATTR_USER | THREAD_ATTR_VFPU);
 
#define printf pspDebugScreenPrintf
#define TextColor pspDebugScreenSetTextColor
 
int menu() {
	pspDebugScreenClear();
	TextColor(blue); printf("\n UMD ISO Dumper - dj51_Shura\n\n\n");
	TextColor(white);
	printf(" > Press X to dump the inserted UMD\n\n");
	printf(" > Press O to salir");
	return 0;
}
 
void salir() {
	sceUmdDeactivate(1,"disc0:");
	TextColor(white); printf("\n\n\n Exiting in 3 seconds...");
	sceKernelDelayThread(3 * 1000 * 1000);
	sceKernelExitGame();
}
 
int main() {
 
	pspDebugScreenInit();
 
	menu();
 
	scePowerSetClockFrequency(333, 333, 166);
 
	sceKernelDelayThread(1000 * 1000);
 
	int i = sceUmdGetDriveStat();
 
	int current_state = 0;
 
	char gameID = "";
 
	if(i == PSP_UMD_NOT_PRESENT) { // Si no hay disco insertado...
		printf("\n\n\n   Waiting for UMD inserted...\n");
		current_state = 0;
	}
	if(i == PSP_UMD_PRESENT) { // En caso de que sí lo haya...
		current_state = 1;
		printf("\n\n\n   UMD disc inserted. Mounting it to filesystem...\n");
		int mount = sceUmdActivate(1, "disc0:");
		if(mount >= 0) {
			printf("   UMD mounted succesfully\n");
			sceUmdWaitDriveStat(PSP_UMD_READY); // Esperamos a que esté listo para la cocción ;-)
			int fd = sceIoOpen("disc0:/UMD_DATA.BIN", PSP_O_RDONLY, 0777);
			if(fd >= 0) {
				char game_id[11];
				sceIoRead(fd, game_id, 10);
				game_id[10] = 0;
				sceIoClose(fd);
				TextColor(grey); printf("   Detected game ID: %s\n\n", game_id); TextColor(white);
				gameID = game_id;
			} else {
				TextColor(red); printf("   Cannot read data from UMD_DATA.BIN!");
				sceKernelDelayThread(1 * 1000 * 1000);
				salir();
			}
			printf("   UMD disc ready. Press X now to dump it\n\n");
		} else{
			TextColor(red); printf("   Cannot mount UMD!");
			sceKernelDelayThread(1 * 1000 * 1000);
			salir();
		}
	}
 
	SceCtrlData paddata;
	sceCtrlSetSamplingCycle(0);
	sceCtrlSetSamplingMode(PSP_CTRL_MODE_DIGITAL);
 
	while(1) {
		sceCtrlReadBufferPositive(&paddata, 1);
 
		if(paddata.Buttons != 0) {
			if(current_state == 1) {
				if(paddata.Buttons & PSP_CTRL_CROSS) {
					printf("   Dumping UMD disc to memory stick... please wait...\n\n");
					char cur_dir = "ms0:/PSP/GAME/" && gameID && "/";
					int copyi = sceIoCopyFile("disc0:/UMD_DATA.BIN", cur_dir && "UMD_DATA.BIN", 1);
					if(copyi == 1) {
						TextColor(white); printf("    - Copied disc0:/UMD_DATA.BIN succesfully!\n");
					} else {
						TextColor(red); printf("    - Error while copying disc0:/UMD_DATA.BIN!");
					}
					copyi = sceIoCopyFile("disc0:/PSP_GAME/SYSDIR/EBOOT.BIN", cur_dir && "PSP_GAME/SYSDIR/EBOOT.BIN", 1);
					if(copyi == 1) {
						TextColor(white); printf("    - Copied disc0:/PSP_GAME/SYSDIR/EBOOT.BIN succesfully!\n");
					} else {
						TextColor(red); printf("    - Error while copying disc0:/PSP_GAME/SYSDIR/EBOOT.BIN!");
					}
					copyi = sceIoCopyFile("disc0:/PSP_GAME/SYSDIR/BOOT.BIN", cur_dir && "PSP_GAME/SYSDIR/BOOT.BIN", 1);
					if(copyi == 1) {
						TextColor(white); printf("    - Copied disc0:/PSP_GAME/SYSDIR/BOOT.BIN succesfully!\n");
					} else {
						TextColor(red); printf("    - Error while copying disc0:/PSP_GAME/SYSDIR/BOOT.BIN!");
					}
					copyi = sceIoCopyFile("disc0:/PSP_GAME/USRDIR/BOOT.BIN", cur_dir && "PSP_GAME/USRDIR/BOOT.BIN", 1);
					if(copyi == 1) {
						TextColor(white); printf("    - Copied disc0:/PSP_GAME/USRDIR/BOOT.BIN succesfully!\n");
					} else {
						TextColor(red); printf("    - Error while copying disc0:/PSP_GAME/USRDIR/BOOT.BIN!");
					}
					copyi = sceIoCopyFile("disc0:/PSP_GAME/PARAM.SFO", cur_dir && "PSP_GAME/PARAM.SFO", 1);
					if(copyi == 1) {
						TextColor(white); printf("    - Copied disc0:/PSP_GAME/PARAM.SFO succesfully!\n");
					} else {
						TextColor(red); printf("    - Error while copying disc0:/PSP_GAME/PARAM.SFO!");
					}
					copyi = sceIoCopyFile("disc0:/PSP_GAME/ICON0.PNG", cur_dir && "PSP_GAME/ICON0.PNG", 1);
					if(copyi == 1) {
						TextColor(white); printf("    - Copied disc0:/PSP_GAME/ICON0.PNG succesfully!\n");
					} else {
						TextColor(red); printf("    - Error while copying disc0:/PSP_GAME/ICON0.PNG!");
					}
					copyi = sceIoCopyFile("disc0:/PSP_GAME/ICON1.PMF", cur_dir && "PSP_GAME/ICON1.PMF", 1);
					if(copyi == 1) {
						TextColor(white); printf("    - Copied disc0:/PSP_GAME/ICON1.PMF succesfully!\n");
					} else {
						TextColor(red); printf("    - Error while copying disc0:/PSP_GAME/ICON1.PMF!");
					}
					copyi = sceIoCopyFile("disc0:/PSP_GAME/PIC0.PNG", cur_dir && "PSP_GAME/PIC0.PNG", 1);
					if(copyi == 1) {
						TextColor(white); printf("    - Copied disc0:/PSP_GAME/PIC0.PNG succesfully!\n");
					} else {
						TextColor(red); printf("    - Error while copying disc0:/PSP_GAME/PIC0.PNG!");
					}
					copyi = sceIoCopyFile("disc0:/PSP_GAME/PIC1.PNG", cur_dir && "PSP_GAME/PIC1.PNG", 1);
					if(copyi == 1) {
						TextColor(white); printf("    - Copied disc0:/PSP_GAME/PIC1.PNG succesfully!\n");
					} else {
						TextColor(red); printf("    - Error while copying disc0:/PSP_GAME/PIC1.PNG!");
					}
					copyi = sceIoCopyFile("disc0:/PSP_GAME/SND0.AT3", cur_dir && "PSP_GAME/SND0.AT3", 1);
					if(copyi == 1) {
						TextColor(white); printf("    - Copied disc0:/PSP_GAME/SND0.AT3 succesfully!\n");
					} else {
						TextColor(red); printf("    - Error while copying disc0:/PSP_GAME/SND0.AT3!");
					}
 
					TextColor(blue); printf("\n\n\n   All done. Exiting...");
					salir();
				}
			}
			if(current_state == 0) { // Si teníamos que la última vez que se checkeó no había UMD insertado...
				int i = sceUmdGetDriveStat();
				if(i == PSP_UMD_PRESENT) { // En caso de que sí lo haya...
					current_state = 1;
					printf("   UMD disc inserted. Initing...\n");
					int mount = sceUmdActivate(1, "disc0:");
					if(mount >= 0) {
						printf("   UMD mounted succesfully\n");
						sceUmdWaitDriveStat(PSP_UMD_READY); // Esperamos a que esté listo para la cocción ;-)
						printf("   UMD disc ready. Press X now to dump\n\n");
					} else{
						TextColor(blue); printf("   Cannot mount UMD!");
						sceKernelDelayThread(1 * 1000 * 1000);
						salir();
					}
				}
			}
			if(current_state == 1) { // Si teníamos que la última vez que se checkeó había un UMD insertado...
				int i = sceUmdGetDriveStat();
				if(i == PSP_UMD_NOT_PRESENT) { // En caso de que esta vez, no lo haya...
					current_state = 0;
					printf("   UMD disc extracted!\n");
					sceUmdDeactivate(1, "disc0:");
				}
			}
		}
 
		if(paddata.Buttons & PSP_CTRL_CIRCLE) {
			salir();
		}
 
	}
 
}

/*
	*** dj51_Shura Io Utilites Library ***
 
	OpenSourceCode Proyect, GPLv3 License
 
	--------------------------------------------------------------------------------------------------------------
 
	My own library for Io operations simplified functions.
 
	Use at your own risk. ;-) xD
 
	--- Functions documentation ---
 
		sceIoCopyFile(#1, #2, #3)
 
			--- Copy a file
 
			#1 ::: Const Char * sourcefile			The path of the file to be copied
			#2 ::: Const Char * destpath			The path to copy the file to
			#3 ::: Int * overwrite					If 1 then overwrites any file, if 0 and the file already exists, stop
 
			>>> Returns
					0 on error
					1 on success
 
		sceIoCopyDirectory(#1, #2, #3)
 
			--- Copy a directory (recursive)
 
			#1 ::: Const Char * sourcepath			The path of the file to be copied
			#2 ::: Const Char * destpath			The path to copy the file to
			#3 ::: Int * overwrite					If receives 1, and a directory exists in the same path as 'destpath', then removes the existing directory and continue copying.
 
			>>> Returns
					0 on error
					1 on success
 
		sceIoInitFlash0()
 
			--- Assigns the flash0 device in read/write access
 
			>>> Returns
					0 on error
					1 on success
 
		sceIosceIoFileExists(#1)
 
			--- Checks if a file exists
 
			#1 ::: Const Char * sourcefile			The path of the file to be checked
 
			>>> Returns
					0 if the file doesn't exists
					1 if the file exists
 
		sceIosceIoDirectoryExists(#1)
 
			--- Checks if a directory exists
 
			#1 ::: Const Char * sourcepath			The path of the directory to be checked
 
			>>> Returns
					0 if the directory doesn't exists
					1 if the directory exists
 
		sceIoReadChars(#1, #2)
 
			--- Reads the indicated number of chars from a file (or a line), using the Standard IO Library (stdio.h)
 
			#1 ::: Const Char * fileToRead			The path of the file to be readed
			#2 ::: Int * numberOfChars				The number of chars to read
 
			>>> Returns
					0 if the file doesn't exists, or if the file cannot be closed
					-1 on some errors, like 'end of stream' ('EOF')
					The unsigned char converted to an int if the file can be readed successfully
 
		sceIoPutChar(#1, #2, #3)
 
			--- Puts a char to a file, depend of the arguments
 
			#1 ::: Const Char * fileToWrite			The path of the file to	write
			#2 ::: Int * character					The unsigned char converted to int, to write to the file
			#3 ::: Int * append						Whether to append or overwrite any existing file. Passing 1, the char will be writed at end of the file. Passing 0, the function will overwrite the file if it exists.
 
			>>> Returns
					0 on some errors
					-1 if the function cannot write to the file
					1 if success
 
		sceIoReadLineText(#1)
 
			--- Reads a line from a text file, and returns it
 
			#1 ::: Const Char * fileToRead			The path of the file to be readed
 
			>>> Returns
					0 if the file doesn't exists
					-1 on some errors, like 'end of stream' ('EOF')
					The text readed, as a const char
*/
 
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <pspiofilemgr.h>
#include <pspiofilemgr_kernel.h>
#include <pspiofilemgr_dirent.h>
#include <pspiofilemgr_fcntl.h>
#include <pspiofilemgr_stat.h>
 
int sceIoInitFlash0() {
	int una = sceIoUnassign("flash0");
	int a = sceIoAssign("flash0", "lflash0:0,0", "flashfat0:", IOASSIGN_RDWR, NULL, 0);
	if(una >= 0) {
		if(a >= 0) {
			return 1;
		} else {
			return 0;
		}
	} else {
		return 0;
	}
}
 
int sceIoFileExists(const char * filepath) {
SceUID temp = sceIoOpen(filepath, PSP_O_RDONLY, 0777); 
if(temp >= 0) {
	sceIoClose(temp);
	return 1;
}
	return 0;
}
 
int sceIoDirectoryExists(const char * sourcepath) {
	SceUID temp = sceIoDopen(sourcepath);
	if(temp >= 0) {
		sceIoDclose(temp);
		return 1;
	} else {
		return 0;
	}
}
 
int sceIoCopyFile(const char * srcfile, const char * destfile, int * overwrite) {
	int fdsrc, fddest, bytes_readed = -1;
	char buffer[1024*3];
	int bufsize = sizeof(buffer);
 
	if(sceIoFileExists(srcfile) == 0) {
		return 0;
	}
	if((sceIoFileExists(destfile) == 1) && (overwrite == 0)) {
		return 0;
	}
 
	fdsrc = sceIoOpen(srcfile, PSP_O_RDONLY, 0777); // Opens the source file for read access permission
	if(fdsrc < 0) return 0; // If 'fdsrc' is not a valid file descriptor, then return 0 and exit function
 
	fddest = sceIoOpen(destfile, PSP_O_WRONLY | PSP_O_CREAT | PSP_O_TRUNC, 0777); // Opens the dest file for write access permission. Creates it if it doesn't exists
	if(fddest < 0) { sceIoClose(fdsrc); return 0; } // If 'fddest' is not a valid file descriptor, then closes the opened file descriptor of the source file and return 0 for exit the function
 
	bytes_readed = sceIoRead(fdsrc, buffer, bufsize);
	while(bytes_readed > 0) {
		sceIoWrite(fddest, buffer, bytes_readed);
		bytes_readed = sceIoRead(fdsrc, buffer, bufsize);
	}
	sceIoClose(fddest);
	sceIoClose(fdsrc);
	return 1;
}
 
int sceIoCopyDirectory(const char * sourcepath, const char * destpath, int * overwrite) {
	int dfdsrc, dfddest, bytes_readed = -1;
 
	dfdsrc = sceIoDopen(sourcepath); // Assign the directory descriptor to the int 'dfd_src'
	if(dfdsrc < 0) return 0; // If 'dfd_src' is not a valid directory descriptor, then returns 0 and exit function
 
	int check = sceIoDirectoryExists(destpath); // Assign the directory check to the int 'check'
	if(check == 0) { // If the 'destpath' folder doesn't exists...
		sceIoMkdir(destpath, 0777); // Create a folder
	} else if(check == 1 && overwrite == 0) {
		return 0;
	} else if(check == 1 && overwrite == 1) {
		sceIoRmdir(destpath);
	}
 
	dfddest = sceIoDopen(destpath);
	if(dfddest < 0) {sceIoDclose(dfdsrc); return 0;} // If 'dfddest' is not a valid directory descriptor, then closes the opened directory descriptor of the source directory and return 0 for exit the function
 
	SceIoDirent ent;
	memset(&ent, 0, sizeof(SceIoDirent));
 
	bytes_readed = sceIoDread(dfdsrc, &ent);
 
	while(bytes_readed > 0) {
		sceIoWrite(dfddest, ent.d_private, bytes_readed);
		bytes_readed = sceIoDread(dfdsrc, &ent);
	}
 
	sceIoDclose(dfdsrc);
	sceIoDclose(dfddest);
 
	return 1;
 
}
 
int sceIoReadChars(const char * fileToRead, int * numberOfChars) {
	int check = sceIoFileExists(fileToRead);
	if(check == 0) return 0;
 
	FILE* FileOpen = fopen(fileToRead, "r");
	const char text = fgets(&text, numberOfChars, FileOpen);
	int FileClose = fclose(FileOpen);
 
	if(text == NULL) return -1;
 
	if(FileClose != 0) return 0;
 
	return text;
}
 
int sceIoPutChar(const char * fileToWrite, int * character, int * append) {
	FILE * FileOpen;
	if(append == 0) {
		FileOpen = fopen(fileToWrite, "w");
	} else if(append == 1) {
		FileOpen = fopen(fileToWrite, "a");
	} else {
		return 0;
	}
	int text = fputc(character, FileOpen);
	int FileClose = fclose(FileOpen);
 
	if(text == "EOF") return -1;
 
	if(FileClose != 0) return 0;
 
	return 1;
}
 
/*int sceIoReadLineText(const char * fileToRead) {
	int check = sceIoFileExists(fileToRead);
	if(check == 0) return 0;
 
	FILE* FileOpen = fopen(fileToRead, "r");
 
	const char text;
	fgets(&text, 1000000, FileOpen);
 
	if(text == NULL) return -1;
 
	return text;
}*/
 
/*int sceIoRead
istream& get(char*, int len, char = '\n');
*/
 
int sceIoReadAllText(const char * fileToRead) {
	int fd = sceIoOpen(fileToRead, PSP_O_RDONLY, 0777);
	if (fd < 0) { // Si el descriptor de archivo no es válido...
		return 0;
	}
 
	const char text;
 
	sceIoRead(fd, &text, 64*1024); // Guardamos los caracteres leídos en la variable 'text' en forma de string o const char...
	sceIoClose(fd); // Cerramos el descriptor para acabar int
 
	return text; // Acabamos devolviendo el texto (o, mejor dicho, los caracteres) leído...
}
 
int sceIoWriteAllText(const char * fileToWrite, const char * text, int * overwrite, int * append) {
	int check = sceIoFileExists(fileToWrite);
	if((check == 1) && (overwrite == 0) && (append == 0)) {
		return 0;
	}
 
	char TextToWrite = text;
 
	if((check == 1) && (overwrite == 1) && (append == 1)) {
		const char FileText = sceIoReadAllText(fileToWrite);
		if(FileText == 0) {
			return 0;
		} else {
			TextToWrite = FileText & TextToWrite;
		}
	}
 
	if((check == 1) && (overwrite == 1) && (append = 0)) {
		int RemoveFile = sceIoRemove(fileToWrite);
		if(RemoveFile < 0) {
			return 0;
		}
	}
 
 
	int fd = sceIoOpen(fileToWrite, PSP_O_WRONLY | PSP_O_CREAT, 0777);
	if (fd < 0) { // Si el descriptor de archivo no es válido...
		return 0;
	}
 
	sceIoWrite(fd, TextToWrite, 64*1024);
 
	return 1;
 
}

TARGET = UMD_ISO_Dumper
OBJS = main.o
 
CFLAGS = -O2 -G0 -Wall
CXXFLAGS = $(CFLAGS) -fno-exceptions -fno-rtti
ASFLAGS = $(CFLAGS)
 
EXTRA_TARGETS = EBOOT.PBP
PSP_EBOOT_TITLE = UMD ISO Dumper
PSP_EBOOT_ICON = ICON0.PNG
PSP_EBOOT_PIC1 = PIC1.PNG
 
 
STDLIBS= -lpspsdk -lpspctrl -lpspumd -lpsppower
LIBS=$(STDLIBS)
 
PSPSDK=$(shell psp-config --pspsdk-path)
include $(PSPSDK)/lib/build.mak