public override int ioClose()
{
if (ioctl != null)
{
ioctl.ioClose();
}
return(base.ioClose());
}
public virtual void closeVirtualFile()
{
if (vFileOpen)
{
if (vFile != null)
{
vFile.ioClose();
vFile = null;
}
vFileOpen = false;
}
}
private IVirtualFile ioOpenPatchedFile(string fileName, int flags, int mode, IList <PatchInfo> patches)
{
IVirtualFile vFile = base.ioOpen(fileName, flags, mode);
if (vFile == null)
{
return(null);
}
sbyte[] buffer = Utilities.readCompleteFile(vFile);
vFile.ioClose();
if (buffer == null)
{
return(null);
}
foreach (PatchInfo patch in patches)
{
patch.apply(buffer);
}
return(new ByteArrayVirtualFile(buffer));
}
public virtual int ioClose(IVirtualFile file)
{
return(file.ioClose());
}
public virtual int hleKernelLoadExec(PspString filename, int argSize, int argAddr)
{
string name = filename.String;
// The PSP is replacing a loadexec of disc0:/PSP_GAME/SYSDIR/BOOT.BIN with EBOOT.BIN
if (name.Equals(unencryptedBootPath))
{
Console.WriteLine(string.Format("sceKernelLoadExec '{0}' replaced by '{1}'", name, encryptedBootPath));
name = encryptedBootPath;
}
ByteBuffer moduleBuffer = null;
IVirtualFile vFile = Modules.IoFileMgrForUserModule.getVirtualFile(name, IoFileMgrForUser.PSP_O_RDONLY, 0);
UmdIsoReader iso = null;
if (vFile is XmbIsoVirtualFile)
{
try
{
IVirtualFile vFileLoadExec = ((XmbIsoVirtualFile)vFile).ioReadForLoadExec();
if (vFileLoadExec != null)
{
iso = ((XmbIsoVirtualFile)vFile).IsoReader;
vFile.ioClose();
vFile = vFileLoadExec;
}
}
catch (IOException e)
{
Console.WriteLine("hleKernelLoadExec", e);
}
}
if (vFile != null)
{
sbyte[] moduleBytes = Utilities.readCompleteFile(vFile);
vFile.ioClose();
if (moduleBytes != null)
{
moduleBuffer = ByteBuffer.wrap(moduleBytes);
}
}
else
{
SeekableDataInput moduleInput = Modules.IoFileMgrForUserModule.getFile(name, IoFileMgrForUser.PSP_O_RDONLY);
if (moduleInput != null)
{
try
{
sbyte[] moduleBytes = new sbyte[(int)moduleInput.Length()];
moduleInput.readFully(moduleBytes);
moduleInput.Dispose();
moduleBuffer = ByteBuffer.wrap(moduleBytes);
}
catch (IOException e)
{
Console.WriteLine(string.Format("sceKernelLoadExec - Error while loading module '{0}'", name), e);
return(ERROR_KERNEL_PROHIBIT_LOADEXEC_DEVICE);
}
}
}
return(hleKernelLoadExec(moduleBuffer, argSize, argAddr, name, iso));
}
private sbyte[] getCompressedPrxFile(string dirName, string fileName)
{
string proxyFileName;
if (string.ReferenceEquals(dirName, null) || dirName.Length == 0)
{
proxyFileName = fileName;
}
else
{
proxyFileName = dirName + "/" + fileName;
}
IVirtualFile vFileUncompressed = base.ioOpen(proxyFileName, PSP_O_RDONLY, 0);
if (vFileUncompressed == null)
{
return(null);
}
sbyte[] bufferUncompressed = Utilities.readCompleteFile(vFileUncompressed);
vFileUncompressed.ioClose();
if (bufferUncompressed == null)
{
return(null);
}
int headerMagic = Utilities.readUnaligned32(bufferUncompressed, 0);
if (headerMagic != Elf32Header.ELF_MAGIC)
{
return(bufferUncompressed);
}
int lengthUncompressed = bufferUncompressed.Length;
System.IO.MemoryStream osCompressed = new System.IO.MemoryStream(PSP_HEADER_SIZE + 9 + lengthUncompressed);
try
{
writePspHeader(osCompressed, bufferUncompressed, fileName);
// loadcore.prx and sysmem.prx need to be compressed using KL4E.
// KL4E supports a version where the data is not compressed.
// Use this simple version as we have no real KL4E compressor.
if (isKl4eCompression(fileName))
{
writeString(osCompressed, "KL4E", 4);
write8(osCompressed, 0x80); // Flag indicating that the rest of the data is uncompressed
write32(osCompressed, endianSwap32(lengthUncompressed));
writeBytes(osCompressed, bufferUncompressed, lengthUncompressed);
}
else
{
GZIPOutputStream os = new GZIPOutputStream(osCompressed);
os.write(bufferUncompressed, 0, lengthUncompressed);
os.close();
}
}
catch (IOException)
{
}
sbyte[] bytes = osCompressed.toByteArray();
fixPspSizeInHeader(bytes);
return(bytes);
}
public virtual int ioClose()
{
return(vFile.ioClose());
}
public XmbIsoVirtualFile(string umdFilename) : base(null)
{
this.umdFilename = umdFilename;
umdName = System.IO.Path.GetFileName(umdFilename);
File cacheDirectory = new File(CacheDirectory);
bool createCacheFiles = !cacheDirectory.Directory;
if (createCacheFiles)
{
cacheDirectory.mkdirs();
}
try
{
UmdIsoReader iso = new UmdIsoReader(umdFilename);
IVirtualFileSystem vfs = new UmdIsoVirtualFileSystem(iso);
sections = new PbpSection[umdFilenames.Length + 1];
sections[0] = new PbpSection();
sections[0].index = 0;
sections[0].offset = 0;
sections[0].size = 0x28;
sections[0].availableInContents = true;
int offset = 0x28;
SceIoStat stat = new SceIoStat();
for (int i = 0; i < umdFilenames.Length; i++)
{
PbpSection section = new PbpSection();
section.index = i + 1;
section.offset = offset;
section.umdFilename = umdFilenames[i];
if (vfs.ioGetstat(section.umdFilename, stat) >= 0)
{
section.size = (int)stat.size;
if (log.TraceEnabled)
{
log.trace(string.Format("{0}: mapping {1} at offset 0x{2:X}, size 0x{3:X}", umdFilename, umdFilenames[i], section.offset, section.size));
}
}
string cacheFileName = getCacheFileName(section);
File cacheFile = new File(cacheFileName);
// Create only cache files for PARAM.SFO and ICON0.PNG
if (createCacheFiles && i < 2)
{
IVirtualFile vFile = vfs.ioOpen(section.umdFilename, IoFileMgrForUser.PSP_O_RDONLY, 0);
if (vFile != null)
{
section.size = (int)vFile.Length();
sbyte[] buffer = new sbyte[section.size];
int Length = vFile.ioRead(buffer, 0, buffer.Length);
vFile.ioClose();
System.IO.Stream os = new System.IO.FileStream(cacheFile, System.IO.FileMode.Create, System.IO.FileAccess.Write);
os.Write(buffer, 0, Length);
os.Close();
}
}
if (cacheFile.canRead())
{
section.cacheFile = cacheFile;
}
sections[section.index] = section;
offset += section.size;
}
totalLength = offset;
contents = new sbyte[offset];
ByteBuffer buffer = ByteBuffer.wrap(contents).order(ByteOrder.LITTLE_ENDIAN);
buffer.putInt(PBP.PBP_MAGIC);
buffer.putInt(0x10000); // version
for (int i = 1; i < sections.Length; i++)
{
buffer.putInt(sections[i].offset);
}
int endSectionOffset = sections[sections.Length - 1].offset + sections[sections.Length - 1].size;
for (int i = sections.Length; i <= 8; i++)
{
buffer.putInt(endSectionOffset);
}
if (log.TraceEnabled)
{
log.trace(string.Format("{0}: PBP header :{1}", umdFilename, Utilities.getMemoryDump(contents, sections[0].offset, sections[0].size)));
}
vfs.ioExit();
}
catch (FileNotFoundException e)
{
Console.WriteLine("XmbIsoVirtualFile", e);
}
catch (IOException e)
{
Console.WriteLine("XmbIsoVirtualFile", e);
}
}
protected internal virtual void readSection(PbpSection section)
{
if (section.size > 0)
{
try
{
if (section.cacheFile != null)
{
//if (log.DebugEnabled)
{
Console.WriteLine(string.Format("XmbIsoVirtualFile.readSection from Cache {0}", section.cacheFile));
}
System.IO.Stream @is = new System.IO.FileStream(section.cacheFile, System.IO.FileMode.Open, System.IO.FileAccess.Read);
@is.Read(contents, section.offset, section.size);
@is.Close();
}
else
{
//if (log.DebugEnabled)
{
Console.WriteLine(string.Format("XmbIsoVirtualFile.readSection from UMD {0}", section.umdFilename));
}
UmdIsoReader iso = new UmdIsoReader(umdFilename);
IVirtualFileSystem vfs = new UmdIsoVirtualFileSystem(iso);
IVirtualFile vFile = vfs.ioOpen(section.umdFilename, IoFileMgrForUser.PSP_O_RDONLY, 0);
if (vFile != null)
{
vFile.ioRead(contents, section.offset, section.size);
vFile.ioClose();
}
vfs.ioExit();
}
}
catch (IOException e)
{
Console.WriteLine("readSection", e);
}
// PARAM.SFO?
if (section.index == 1)
{
// Patch the CATEGORY in the PARAM.SFO:
// the VSH is checking that the CATEGORY value is starting
// with 'M' (meaning MemoryStick) and not 'U' (UMD).
// Change the first letter 'U' into 'M'.
int offset = section.offset;
int keyTableOffset = readUnaligned32(contents, offset + 8) + offset;
int valueTableOffset = readUnaligned32(contents, offset + 12) + offset;
int numberKeys = readUnaligned32(contents, offset + 16);
for (int i = 0; i < numberKeys; i++)
{
int keyOffset = readUnaligned16(contents, offset + 20 + i * 16);
string key = Utilities.readStringZ(contents, keyTableOffset + keyOffset);
if ("CATEGORY".Equals(key))
{
int valueOffset = readUnaligned32(contents, offset + 20 + i * 16 + 12);
char valueFirstChar = (char)contents[valueTableOffset + valueOffset];
// Change the first letter 'U' into 'M'.
if (valueFirstChar == 'U')
{
contents[valueTableOffset + valueOffset] = (sbyte)'M';
}
break;
}
}
}
}
section.availableInContents = true;
}
public virtual bool loadAndRun()
{
if (!enableReboot)
{
return(false);
}
Memory mem = Memory.Instance;
StringBuilder localFileName = new StringBuilder();
IVirtualFileSystem vfs = Modules.IoFileMgrForUserModule.getVirtualFileSystem(rebootFileName, localFileName);
if (vfs == null)
{
return(false);
}
IVirtualFile vFile = vfs.ioOpen(localFileName.ToString(), IoFileMgrForUser.PSP_O_RDONLY, 0);
if (vFile == null)
{
return(false);
}
int rebootFileLength = (int)vFile.Length();
if (rebootFileLength <= 0)
{
return(false);
}
SceModule rebootModule = new SceModule(true);
rebootModule.modname = Name;
rebootModule.pspfilename = rebootFileName;
rebootModule.baseAddress = rebootBaseAddress;
rebootModule.text_addr = rebootBaseAddress;
rebootModule.text_size = rebootFileLength;
rebootModule.data_size = 0;
rebootModule.bss_size = 0x26B80;
const bool fromSyscall = false;
Emulator.Instance.initNewPsp(fromSyscall);
Emulator.Instance.ModuleLoaded = true;
HLEModuleManager.Instance.startModules(fromSyscall);
Modules.ThreadManForUserModule.Initialise(rebootModule, rebootModule.baseAddress, 0, rebootModule.pspfilename, -1, 0, fromSyscall);
int rebootMemSize = rebootModule.text_size + rebootModule.data_size + rebootModule.bss_size;
SysMemInfo rebootMemInfo = Modules.SysMemUserForUserModule.malloc(VSHELL_PARTITION_ID, "reboot", PSP_SMEM_Addr, rebootMemSize, rebootModule.text_addr);
if (rebootMemInfo == null)
{
return(false);
}
TPointer rebootBinAddr = new TPointer(mem, rebootBaseAddress);
int readLength = vFile.ioRead(rebootBinAddr, rebootFileLength);
vFile.ioClose();
if (readLength != rebootFileLength)
{
return(false);
}
markMMIO();
addFunctionNames(rebootModule);
SysMemInfo rebootParamInfo = Modules.SysMemUserForUserModule.malloc(VSHELL_PARTITION_ID, "reboot-parameters", PSP_SMEM_Addr, 0x10000, rebootParamAddress);
TPointer sceLoadCoreBootInfoAddr = new TPointer(mem, rebootParamInfo.addr);
SceLoadCoreBootInfo sceLoadCoreBootInfo = new SceLoadCoreBootInfo();
sceLoadCoreBootInfoAddr.clear(0x1000 + 0x1C000 + 0x380);
TPointer startAddr = new TPointer(sceLoadCoreBootInfoAddr, 0x1000);
TPointer sceKernelLoadExecVSHParamAddr = new TPointer(startAddr, 0x1C000);
TPointer loadModeStringAddr = new TPointer(sceKernelLoadExecVSHParamAddr, 48);
loadModeStringAddr.StringZ = "vsh";
SceKernelLoadExecVSHParam sceKernelLoadExecVSHParam = new SceKernelLoadExecVSHParam();
sceKernelLoadExecVSHParamAddr.setValue32(48);
sceKernelLoadExecVSHParam.flags = 0x10000;
sceKernelLoadExecVSHParam.keyAddr = loadModeStringAddr;
sceKernelLoadExecVSHParam.write(sceKernelLoadExecVSHParamAddr);
sceLoadCoreBootInfo.memBase = MemoryMap.START_KERNEL;
sceLoadCoreBootInfo.memSize = MemoryMap.SIZE_RAM;
sceLoadCoreBootInfo.startAddr = startAddr;
sceLoadCoreBootInfo.endAddr = new TPointer(sceKernelLoadExecVSHParamAddr, 0x380);
sceLoadCoreBootInfo.modProtId = -1;
sceLoadCoreBootInfo.modArgProtId = -1;
sceLoadCoreBootInfo.model = Model.Model;
sceLoadCoreBootInfo.dipswLo = Modules.KDebugForKernelModule.sceKernelDipswLow32();
sceLoadCoreBootInfo.dipswHi = Modules.KDebugForKernelModule.sceKernelDipswHigh32();
sceLoadCoreBootInfo.unknown72 = MemoryMap.END_USERSPACE | unchecked ((int)0x80000000); // Must be larger than 0x89000000 + size of pspbtcnf.bin file
sceLoadCoreBootInfo.cpTime = Modules.KDebugForKernelModule.sceKernelDipswCpTime();
sceLoadCoreBootInfo.write(sceLoadCoreBootInfoAddr);
SceKernelThreadInfo rootThread = Modules.ThreadManForUserModule.getRootThread(null);
if (rootThread != null)
{
rootThread.cpuContext._a0 = sceLoadCoreBootInfoAddr.Address;
rootThread.cpuContext._a1 = sceKernelLoadExecVSHParamAddr.Address;
rootThread.cpuContext._a2 = SCE_INIT_APITYPE_KERNEL_REBOOT;
rootThread.cpuContext._a3 = Modules.SysMemForKernelModule.sceKernelGetInitialRandomValue();
}
// This will set the Log4j MDC values for the root thread
Emulator.Scheduler.addAction(new SetLog4jMDC());
//if (log.DebugEnabled)
{
Console.WriteLine(string.Format("sceReboot arg0={0}, arg1={1}", sceLoadCoreBootInfoAddr, sceKernelLoadExecVSHParamAddr));
}
return(true);
}