protected void WriteToMemory()
{
foreach (var sectionHeader in SectionHeadersWithFlag(Elf.SectionHeader.FlagsSet.Allocate))
{
var sectionHeaderFileStream = FileStream.SliceWithLength(sectionHeader.Offset, sectionHeader.Size);
var sectionHeaderMemoryStream =
MemoryStream.SliceWithLength(sectionHeader.Address + BaseAddress, sectionHeader.Size);
Console.WriteLine("WriteToMemory('{0:X}') : 0x{1:X} : {2} : {3}",
GetStringFromStringTable(sectionHeader.Name), sectionHeader.Address, sectionHeader.Type,
sectionHeader.Size);
Console.WriteLine(" 0x{0:X} - 0x{1:X}", sectionHeader.Address + BaseAddress, sectionHeader.Size);
switch (sectionHeader.Type)
{
case Elf.SectionHeader.TypeEnum.ProgramBits:
//Console.WriteLine(SectionHeaderFileStream.ReadAll().ToHexString());
sectionHeaderMemoryStream.WriteStream(sectionHeaderFileStream);
break;
case Elf.SectionHeader.TypeEnum.NoBits:
sectionHeaderMemoryStream.WriteByteRepeated(0, sectionHeader.Size);
break;
default:
break;
}
}
}
public String Detect(Stream Stream)
{
var StartMagic = Stream.SliceWithLength(0, 4).ReadAllContentsAsString(Encoding.ASCII);
Console.WriteLine(StartMagic);
if (StartMagic == '\0' + "PBP")
{
return("Pbp");
}
if (StartMagic == '\0' + "PSF")
{
return("Psf");
}
if (StartMagic == '\x7F' + "ELF")
{
return("Elf");
}
if (StartMagic == "CISO")
{
return("Cso");
}
if (StartMagic == "DAX" + '\0')
{
return("Dax");
}
if (Stream.SliceWithLength(0x8000, 6).ReadAllContentsAsString() == '\x01' + "CD001")
{
return("Iso");
}
return("Unknown");
}
public SE3 Load(Stream Stream)
{
var Header = Stream.ReadStruct <HeaderStruct>();
if (Header.Magic != 0x53453320)
{
throw(new Exception("Not a SE3 File"));
}
var NameStream = Stream.SliceWithLength(0x10, Header.NameSize);
var ELBP = NameStream.ReadStruct <uint_be>();
var NameCount = (uint)NameStream.ReadStruct <uint_be>();
Entries = new List <SE3Entry>();
EntriesWithName = new Dictionary <string, SE3Entry>();
for (int n = 0; n < NameCount; n++)
{
var Entry = new SE3Entry()
{
Name = NameStream.ReadStringz(0x30),
};
Entries.Add(Entry);
EntriesWithName[Entry.Name] = Entry;
}
_LoadData(Stream.SliceWithLength(Header.DataStart));
return(this);
}
public Psf Load(Stream stream)
{
EntryDictionary = new Dictionary <string, object>();
Header = stream.ReadStruct <HeaderStruct>();
Entries = stream.ReadStructVector <EntryStruct>(Header.NumberOfPairs);
KeysStream = stream.SliceWithLength(Header.KeyTable);
ValuesStream = stream.SliceWithLength(Header.ValueTable);
foreach (var entry in Entries)
{
var key = KeysStream.ReadStringzAt(entry.KeyOffset);
var valueStream = ValuesStream.SliceWithLength(entry.ValueOffset, entry.ValueSize);
switch (entry.DataType)
{
case DataType.Binary:
EntryDictionary[key] = valueStream.ReadAll();
break;
case DataType.Int:
EntryDictionary[key] = valueStream.ReadStruct <int>();
break;
case DataType.Text:
EntryDictionary[key] = valueStream.ReadStringz(-1, Encoding.UTF8);
break;
default: throw new NotImplementedException();
}
}
return(this);
}
/// <summary>
///
/// </summary>
/// <param name="Stream"></param>
/// <param name="ToRead"></param>
/// <param name="AlignTo4"></param>
/// <returns></returns>
static public int CountStringzBytes(this Stream Stream, int ToRead = -1, bool AlignTo4 = false, int AlignPosition = 0, bool KeepStreamPosition = true)
{
if (AlignTo4 == true)
{
throw(new NotImplementedException());
}
if (KeepStreamPosition)
{
Stream = Stream.SliceWithLength(Stream.Position);
}
if (Stream.Eof())
{
return(0);
}
bool ContinueReading = false;
if (ToRead == -1)
{
ToRead = 0x100;
ContinueReading = true;
}
var StartPosition = Stream.Position;
var Bytes = Stream.ReadBytesUpTo(ToRead);
int ZeroIndex = Array.IndexOf(Bytes, (byte)0x00);
if (ZeroIndex == -1)
{
if (ContinueReading)
{
return(Bytes.Length + CountStringzBytes(Stream, ToRead, AlignTo4, KeepStreamPosition: false));
}
else
{
return(Bytes.Length);
}
}
else
{
if (AlignTo4)
{
var Bytes2 = Stream.SliceWithLength(StartPosition + ZeroIndex, 5).ReadBytesUpTo(5);
int n = 0;
for (; n < Bytes2.Length; n++)
{
if (Bytes2[n] != 0)
{
break;
}
}
return(ZeroIndex + n);
}
else
{
return(ZeroIndex + 1);
}
}
}
public TXM Load(Stream TXMStream, Stream TXVStream)
{
this.TXVStream = TXVStream;
if (!IsValid(TXMStream.Slice().ReadBytesUpTo(0x100)))
{
throw(new Exception("Invalid TXM!"));
}
this.ImageVersion = TXMStream.Slice().ReadStruct <ImageVersionStruct>();
if (ImageVersion.Version == 1)
{
this.Surface2DEntriesByName = new Dictionary <string, Surface2DEntryInfo>();
this.Surface2DEntries = new Surface2DEntryInfo[0];
this.Surface3DEntriesByName = new Dictionary <string, Surface3DEntryInfo>();
this.Surface3DEntries = new Surface3DEntryInfo[0];
Console.Error.WriteLine("Not Implemented TXM V1!!!!!!!");
}
else
{
this.ImageHeader = TXMStream.ReadStruct <ImageHeaderStructV2>();
this.Surface2DEntriesByName = new Dictionary <string, Surface2DEntryInfo>();
this.Surface2DEntries = new Surface2DEntryInfo[ImageHeader.Surface2DCount];
for (int n = 0; n < ImageHeader.Surface2DCount; n++)
{
var ImageEntry = TXMStream.ReadStruct <Surface2DInfoStructV2>();
var Name = TXMStream.SliceWithLength(TXMStream.Position + Marshal.OffsetOf(typeof(Surface2DInfoStructV2), "StringOffset").ToInt32() - sizeof(Surface2DInfoStructV2) + ImageEntry.StringOffset).ReadStringz();
var Entry = new Surface2DEntryInfo(this, n, ImageEntry, Name);
this.Surface2DEntries[n] = Entry;
this.Surface2DEntriesByName[Name] = Entry;
}
this.Surface3DEntriesByName = new Dictionary <string, Surface3DEntryInfo>();
this.Surface3DEntries = new Surface3DEntryInfo[ImageHeader.Surface3DCount];
if (this.ImageHeader.VersionInfo.Version != 1)
{
for (int n = 0; n < ImageHeader.Surface3DCount; n++)
{
var ImageEntry = TXMStream.ReadStruct <Surface3DInfoStructV2>();
var Name = TXMStream.SliceWithLength(TXMStream.Position + Marshal.OffsetOf(typeof(Surface3DInfoStructV2), "StringOffset").ToInt32() - sizeof(Surface3DInfoStructV2) + ImageEntry.StringOffset).ReadStringz();
var Entry = new Surface3DEntryInfo(this, n, ImageEntry, Name);
this.Surface3DEntries[n] = Entry;
this.Surface3DEntriesByName[Entry.Name] = Entry;
}
}
}
return(this);
}
protected void ExtractSvo(string SvoPath)
{
//try
//{
using (var _SvoStream = File.OpenRead(SvoPath))
{
Stream SvoStream = _SvoStream;
int Compressed = TalesCompression.DetectVersion(SvoStream.Slice().ReadBytes(16), SvoStream.Length);
if (Compressed >= 0)
{
SvoStream = TalesCompression.DecompressStream(SvoStream);
}
if (SvoStream.SliceWithLength().ReadString(7) == "TO8SCEL")
{
var TO8SCEL = new TO8SCEL(SvoStream);
foreach (var Entry in TO8SCEL)
{
Console.WriteLine("{0} ... Start: {1}, End: {2}, Length: {3}", Entry.Index, Entry.EntryStruct.Offset, Entry.EntryStruct.Offset + Entry.EntryStruct.LengthCompressed, Entry.EntryStruct.LengthCompressed);
}
}
else
{
var FPS4 = new FPS4(SvoStream);
Console.WriteLine("{0}", FPS4);
foreach (var Entry in FPS4)
{
Console.WriteLine("{0} ... Start: {1}, End: {2}, Length: {3}", Entry.Name, Entry.EntryStruct.Offset, Entry.EntryStruct.Offset + Entry.EntryStruct.LengthReal, Entry.EntryStruct.LengthReal);
}
}
}
}
public void LoadSectionsTo(Stream MemoryStream)
{
Console.WriteLine("{0:X}", ExeStream.Length);
//400-1600 -> 82000400-820015E4
//PeStream.SliceWithLength(0).CopyToFast(MemoryStream.SliceWithLength(0x82000000));
//return;
//var BaseMemoryStream = MemoryStream.SliceWithLength(PeOptionalHeader.ImageBase);
File.WriteAllBytes(@"C:\projects\csharp\cs360emu\test.bin", ExeStream.ReadAll());
foreach (var ImageSectionHeader in ImageSectionHeaderList)
{
Console.WriteLine("-------------------------------------------------");
Console.WriteLine(ImageSectionHeader.ToStringDefault());
var FileSlice = ExeStream.SliceWithLength(ImageSectionHeader.PointerToRawData, ImageSectionHeader.SizeOfRawData);
var MemorySlice = MemoryStream.SliceWithLength(ImageSectionHeader.VirtualAddress + PeOptionalHeader.ImageBase, ImageSectionHeader.VirtualSize);
Console.WriteLine("Segment: {0:X}-{1:X} -> {2:X}-{3:X}", FileSlice.SliceLow, FileSlice.SliceHigh, MemorySlice.SliceLow, MemorySlice.SliceHigh);
var Data = FileSlice.ReadAll(true);
//Console.WriteLine(BitConverter.ToString(Data));
MemorySlice.WriteBytes(Data);
//FileSlice.Position = 0;
//MemorySlice.Position = 0;
//FileSlice.CopyToFast(MemorySlice);
}
}
public String Detect(Stream Stream)
{
var StartMagic = Stream.SliceWithLength(0, 4).ReadAllContentsAsString(Encoding.ASCII);
Console.WriteLine(StartMagic);
if (StartMagic == '\0' + "PBP") return "Pbp";
if (StartMagic == '\0' + "PSF") return "Psf";
if (StartMagic == '\x7F' + "ELF") return "Elf";
if (StartMagic == "CISO") return "Cso";
if (StartMagic == "DAX" + '\0') return "Dax";
if (Stream.SliceWithLength(0x8000, 6).ReadAllContentsAsString() == '\x01' + "CD001") return "Iso";
return "Unknown";
}
/// <summary>
/// </summary>
/// <param name="stream"></param>
/// <param name="toRead"></param>
/// <param name="alignTo4"></param>
/// <param name="alignPosition"></param>
/// <param name="keepStreamPosition"></param>
/// <returns></returns>
public static int CountStringzBytes(this Stream stream, int toRead = -1, bool alignTo4 = false,
int alignPosition = 0, bool keepStreamPosition = true)
{
if (keepStreamPosition)
{
stream = stream.SliceWithLength(stream.Position);
}
if (stream.Eof())
{
return(0);
}
var continueReading = false;
if (toRead == -1)
{
toRead = 0x100;
continueReading = true;
}
var startPosition = stream.Position;
var bytes = stream.ReadBytesUpTo(toRead);
var zeroIndex = Array.IndexOf(bytes, (byte)0x00);
if (zeroIndex == -1)
{
if (continueReading)
{
return(bytes.Length + CountStringzBytes(stream, toRead, alignTo4, keepStreamPosition: false));
}
return(bytes.Length);
}
if (alignTo4)
{
var bytes2 = stream.SliceWithLength(startPosition + zeroIndex, 5).ReadBytesUpTo(5);
var n = 0;
for (; n < bytes2.Length; n++)
{
if (bytes2[n] != 0)
{
break;
}
}
return(zeroIndex + n);
}
return(zeroIndex + 1);
}
public SubType DetectSubType(Stream Stream)
{
var StartMagic = Stream.SliceWithLength(0, 4).ReadAllContentsAsString(Encoding.ASCII);
//Console.WriteLine(StartMagic);
if (StartMagic == '\0' + "PBP") return SubType.Pbp;
if (StartMagic == '\0' + "PSF") return SubType.Psf;
if (StartMagic == '\x7F' + "ELF") return SubType.Elf;
if (StartMagic == "~PSP") return SubType.EncryptedElf;
if (StartMagic == "CISO") return SubType.Cso;
if (StartMagic == "DAX" + '\0') return SubType.Dax;
if (Stream.SliceWithLength(0x8000, 6).ReadAllContentsAsString() == '\x01' + "CD001") return SubType.Iso;
return SubType.Unknown;
}
/// <summary>
/// Function that writtes all the mappings into another stream.
/// Useful for patching a file or memory.
/// </summary>
/// <param name="targetStream">Stream to write the mapped contents to</param>
public void WriteSegmentsToStream(Stream targetStream)
{
foreach (var streamEntry in _StreamEntries)
{
var sourceSliceStream = streamEntry.Stream.SliceWithLength(0, streamEntry.Length);
var targetSliceStream = targetStream.SliceWithLength(streamEntry.Position, streamEntry.Length);
sourceSliceStream.CopyToFast(targetSliceStream);
}
}
/// <summary>
/// Function that writtes all the mappings into another stream.
/// Useful for patching a file or memory.
/// </summary>
/// <param name="TargetStream">Stream to write the mapped contents to</param>
public void WriteSegmentsToStream(Stream TargetStream)
{
foreach (var StreamEntry in _StreamEntries)
{
var SourceSliceStream = StreamEntry.Stream.SliceWithLength(0, StreamEntry.Length);
var TargetSliceStream = TargetStream.SliceWithLength(StreamEntry.Position, StreamEntry.Length);
SourceSliceStream.CopyToFast(TargetSliceStream);
}
}
private void _LoadData(Stream Stream)
{
var Unk0 = Stream.ReadStruct <uint_be>();
var Unk1 = Stream.ReadStruct <uint_be>();
var Unk2 = Stream.ReadStruct <uint_be>();
var Count = (uint)Stream.ReadStruct <uint_be>();
var DataStart = Stream.ReadStruct <uint_be>();
var Unk4 = Stream.ReadStruct <uint_be>();
var Unk5 = Stream.ReadStruct <uint_be>();
var DataStream = Stream.SliceWithLength(DataStart);
for (int n = 0; n < Count; n++)
{
var Offset = Stream.ReadStruct <uint_be>();
var Header = Stream.SliceWithLength(Offset).ReadStruct <XMAEntryHeaderStruct>();
Entries[n].Header = Header;
Entries[n].DataStream = DataStream.SliceWithLength(Header.DataStart, Header.DataLength);
}
}
public Psf Load(Stream Stream)
{
EntryDictionary = new Dictionary<string, object>();
Header = Stream.ReadStruct<HeaderStruct>();
Entries = Stream.ReadStructVector<EntryStruct>(Header.NumberOfPairs);
KeysStream = Stream.SliceWithLength(Header.KeyTable);
ValuesStream = Stream.SliceWithLength(Header.ValueTable);
foreach (var Entry in Entries)
{
var Key = KeysStream.ReadStringzAt(Entry.KeyOffset);
var ValueStream = ValuesStream.SliceWithLength(Entry.ValueOffset, Entry.ValueSize);;
switch (Entry.DataType)
{
case DataType.Binary: EntryDictionary[Key] = ValueStream.ReadAll(); break;
case DataType.Int: EntryDictionary[Key] = ValueStream.ReadStruct<int>(); break;
case DataType.Text: EntryDictionary[Key] = ValueStream.ReadStringz(-1, Encoding.UTF8); break;
default: throw(new NotImplementedException());
}
}
return this;
}
public SubType DetectSubType(Stream stream)
{
var startMagic = stream.SliceWithLength(0, 4).ReadAllContentsAsString(Encoding.ASCII);
//Console.WriteLine(StartMagic);
if (startMagic == "\u0000PBP")
{
return(SubType.Pbp);
}
if (startMagic == "\u0000PSF")
{
return(SubType.Psf);
}
if (startMagic == "\u007FELF")
{
return(SubType.Elf);
}
if (startMagic == "~PSP")
{
return(SubType.EncryptedElf);
}
if (startMagic == "CISO")
{
return(SubType.Cso);
}
if (startMagic == "DAX\u0000")
{
return(SubType.Dax);
}
if (stream.SliceWithLength(0x8000, 6).ReadAllContentsAsString() == "\u0001CD001")
{
return(SubType.Iso);
}
return(SubType.Unknown);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public IEnumerable <ushort> GetIplOffsets()
{
var stream = Stream.SliceWithLength(NandReader.BytesPerBlock * 4);
while (true)
{
var result = stream.ReadStruct <ushort>();
if (result == 0)
{
break;
}
yield return(result);
}
}
public Pmf Load(Stream Stream)
{
Header = Stream.ReadStruct<HeaderStruct>();
var Chunk = ReadChunk(Stream.SliceWithLength(0x50));
InfoHeader = Chunk.Stream.ReadStruct<InfoHeaderStruct>();
/*
Console.WriteLine("0x{0:X}", (ulong)InfoHeader.FirstTimestamp);
Console.WriteLine("0x{0:X}", (ulong)InfoHeader.LastTimestamp);
Console.WriteLine("{0}", (ulong)InfoHeader.Width);
Console.WriteLine("{0}", (ulong)InfoHeader.Height);
*/
return this;
}
public Pe LoadHeader(Stream _ExeStream)
{
ExeStream = _ExeStream;
DosExe = new DosExe().LoadHeader(ExeStream);
PeStream = ExeStream.SliceWithLength(DosExe.Header.OffsetToPEHeader);
PeHeader = PeStream.ReadStruct<PeHeaderStruct>();
OptionalHeaderStream = PeStream.ReadStream(PeHeader.SizeOfOptionalHeader);
PeOptionalHeader = OptionalHeaderStream.ReadStruct<PeOptionalHeaderStruct>();
ImageSectionHeaderList = new ImageSectionHeader[PeHeader.NumSections];
for (int n = 0; n < PeHeader.NumSections; n++)
{
ImageSectionHeaderList[n] = PeStream.ReadStruct<ImageSectionHeader>();
}
return this;
}
public virtual void Load(Stream FileStream, string Name)
{
FileStream = new MemoryStream(FileStream.ReadAll());
this.FileStream = FileStream;
this.Header = FileStream.ReadStruct<Elf.HeaderStruct>();
if (this.Header.Magic != Elf.HeaderStruct.MagicEnum.ExpectedValue)
{
throw(new InvalidProgramException("Not an ELF File '" + Name + "'"));
}
if (this.Header.Machine != Elf.HeaderStruct.MachineEnum.ALLEGREX)
{
throw (new InvalidProgramException("Invalid Elf.Header.Machine"));
}
this.ProgramHeaders = FileStream.ReadStructVectorAt<Elf.ProgramHeader>(Header.ProgramHeaderOffset, Header.ProgramHeaderCount, Header.ProgramHeaderEntrySize);
this.SectionHeaders = FileStream.ReadStructVectorAt<Elf.SectionHeader>(Header.SectionHeaderOffset, Header.SectionHeaderCount, Header.SectionHeaderEntrySize);
this.NamesSectionHeader = this.SectionHeaders[Header.SectionHeaderStringTable];
this.StringTable = FileStream.SliceWithLength(this.NamesSectionHeader.Offset, this.NamesSectionHeader.Size).ReadAll();
this.SectionHeadersByName = new Dictionary<string, Elf.SectionHeader>();
foreach (var SectionHeader in this.SectionHeaders)
{
var SectionHeaderName = GetStringFromStringTable(SectionHeader.Name);
this.SectionHeadersByName[SectionHeaderName] = SectionHeader;
}
Console.WriteLine("ProgramHeaders:{0}", this.ProgramHeaders.Length);
foreach (var ProgramHeader in ProgramHeaders)
{
Console.WriteLine("{0}", ProgramHeader.ToStringDefault());
}
Console.WriteLine("SectionHeaders:{0}", this.SectionHeaders.Length);
foreach (var SectionHeader in SectionHeaders)
{
Console.WriteLine("{0}:{1}", GetStringFromStringTable(SectionHeader.Name), SectionHeader.ToStringDefault());
}
if (NeedsRelocation && this.ProgramHeaders.Length > 1)
{
//throw (new NotImplementedException("Not implemented several ProgramHeaders yet using relocation"));
}
}
virtual public void Load(Stream FileStream)
{
FileStream = new MemoryStream(FileStream.ReadAll());
this.FileStream = FileStream;
this.Header = FileStream.ReadStruct <Elf.HeaderStruct>();
if (this.Header.Magic != Elf.HeaderStruct.MagicEnum.ExpectedValue)
{
throw(new InvalidProgramException("Not an ELF File"));
}
if (this.Header.Machine != Elf.HeaderStruct.MachineEnum.ALLEGREX)
{
throw (new InvalidProgramException("Invalid Elf.Header.Machine"));
}
this.ProgramHeaders = FileStream.ReadStructVectorAt <Elf.ProgramHeader>(Header.ProgramHeaderOffset, Header.ProgramHeaderCount, Header.ProgramHeaderEntrySize);
this.SectionHeaders = FileStream.ReadStructVectorAt <Elf.SectionHeader>(Header.SectionHeaderOffset, Header.SectionHeaderCount, Header.SectionHeaderEntrySize);
this.NamesSectionHeader = this.SectionHeaders[Header.SectionHeaderStringTable];
this.StringTable = FileStream.SliceWithLength(this.NamesSectionHeader.Offset, this.NamesSectionHeader.Size).ReadAll();
this.SectionHeadersByName = new Dictionary <string, Elf.SectionHeader>();
foreach (var SectionHeader in this.SectionHeaders)
{
var SectionHeaderName = GetStringFromStringTable(SectionHeader.Name);
this.SectionHeadersByName[SectionHeaderName] = SectionHeader;
}
Console.WriteLine("ProgramHeaders:{0}", this.ProgramHeaders.Length);
foreach (var ProgramHeader in ProgramHeaders)
{
Console.WriteLine("{0}", ProgramHeader.ToStringDefault());
}
Console.WriteLine("SectionHeaders:{0}", this.SectionHeaders.Length);
foreach (var SectionHeader in SectionHeaders)
{
Console.WriteLine("{0}:{1}", GetStringFromStringTable(SectionHeader.Name), SectionHeader.ToStringDefault());
}
if (NeedsRelocation && this.ProgramHeaders.Length > 1)
{
//throw (new NotImplementedException("Not implemented several ProgramHeaders yet using relocation"));
}
}
public Pmf Load(Stream Stream)
{
this.Stream = Stream;
Header = Stream.ReadStruct <HeaderStruct>();
var Chunk = ReadChunk(Stream.SliceWithLength(0x50));
InfoHeader = Chunk.Stream.ReadStruct <InfoHeaderStruct>();
/*
* Console.WriteLine("0x{0:X}", (ulong)InfoHeader.FirstTimestamp);
* Console.WriteLine("0x{0:X}", (ulong)InfoHeader.LastTimestamp);
* Console.WriteLine("{0}", (ulong)InfoHeader.Width);
* Console.WriteLine("{0}", (ulong)InfoHeader.Height);
*/
return(this);
}
public Stream Open()
{
return(SliceStream.SliceWithLength());
}
public HleModuleGuest LoadModule(Stream fileStream, Stream memoryStream, MemoryPartition memoryPartition,
HleModuleManager moduleManager, string gameTitle, string moduleName, bool isMainModule)
{
HleModuleGuest = InjectContext.NewInstance <HleModuleGuest>();
ElfLoader = new ElfLoader();
ModuleManager = moduleManager;
var magic = fileStream.SliceWithLength(0, 4).ReadString(4);
_logger.Info("Magic: '{0}'", magic);
if (magic == "~PSP")
{
try
{
var decryptedData = new EncryptedPrx().Decrypt(fileStream.ReadAll(), true);
File.WriteAllBytes("last_decoded_prx.bin", decryptedData);
fileStream = new MemoryStream(decryptedData);
}
catch (Exception exception)
{
_logger.Error(exception);
throw;
}
}
ElfLoader.Load(fileStream, moduleName);
ElfConfig.InfoExeHasRelocation = ElfLoader.NeedsRelocation;
if (ElfLoader.NeedsRelocation)
{
var dummyPartition = memoryPartition.Allocate(0x4000, Name: "Dummy");
BaseAddress = memoryPartition.ChildPartitions.OrderByDescending(partition => partition.Size).First()
.Low;
_logger.Info("BASE ADDRESS (Try ): 0x{0:X}", BaseAddress);
BaseAddress = MathUtils.NextAligned(BaseAddress, 0x1000);
_logger.Info("BASE ADDRESS (Aligned): 0x{0:X}", BaseAddress);
}
else
{
BaseAddress = 0;
}
ElfConfig.RelocatedBaseAddress = BaseAddress;
ElfConfig.GameTitle = gameTitle;
ElfLoader.AllocateAndWrite(memoryStream, memoryPartition, BaseAddress);
LoadModuleInfo();
if (ElfLoader.NeedsRelocation)
{
RelocateFromHeaders();
}
LoadModuleInfo();
//Console.WriteLine(this.ModuleInfo.ToStringDefault());
HleModuleGuest.InitInfo = new InitInfoStruct()
{
Pc = ElfLoader.Header.EntryPoint + BaseAddress,
Gp = HleModuleGuest.ModuleInfo.Gp,
};
UpdateModuleImports();
UpdateModuleExports();
moduleManager.LoadedGuestModules.Add(HleModuleGuest);
return(HleModuleGuest);
}
public HleModuleGuest LoadModule(Stream FileStream, Stream MemoryStream, MemoryPartition MemoryPartition, HleModuleManager ModuleManager, String GameTitle, string ModuleName, bool IsMainModule)
{
this.HleModuleGuest = new HleModuleGuest(PspEmulatorContext);
this.ElfLoader = new ElfLoader();
this.ModuleManager = ModuleManager;
var Magic = FileStream.SliceWithLength(0, 4).ReadString(4);
Logger.Info("Magic: '{0}'", Magic);
if (Magic == "~PSP")
{
try
{
var DecryptedData = new EncryptedPrx().Decrypt(FileStream.ReadAll(), true);
File.WriteAllBytes("last_decoded_prx.bin", DecryptedData);
FileStream = new MemoryStream(DecryptedData);
}
catch (Exception Exception)
{
Logger.Error(Exception);
throw (Exception);
}
}
this.ElfLoader.Load(FileStream, ModuleName);
PspEmulatorContext.PspConfig.InfoExeHasRelocation = this.ElfLoader.NeedsRelocation;
if (this.ElfLoader.NeedsRelocation)
{
var DummyPartition = MemoryPartition.Allocate(
0x4000,
Name: "Dummy"
);
BaseAddress = MemoryPartition.ChildPartitions.OrderByDescending(Partition => Partition.Size).First().Low;
Logger.Info("BASE ADDRESS (Try ): 0x{0:X}", BaseAddress);
BaseAddress = MathUtils.NextAligned(BaseAddress, 0x1000);
Logger.Info("BASE ADDRESS (Aligned): 0x{0:X}", BaseAddress);
}
else
{
BaseAddress = 0;
}
PspEmulatorContext.PspConfig.RelocatedBaseAddress = BaseAddress;
PspEmulatorContext.PspConfig.GameTitle = GameTitle;
this.ElfLoader.AllocateAndWrite(MemoryStream, MemoryPartition, BaseAddress);
if (this.ElfLoader.NeedsRelocation)
{
RelocateFromHeaders();
}
if (!ElfLoader.SectionHeadersByName.ContainsKey(".rodata.sceModuleInfo"))
{
throw(new Exception("Can't find segment '.rodata.sceModuleInfo'"));
}
HleModuleGuest.ModuleInfo = ElfLoader.SectionHeaderFileStream(ElfLoader.SectionHeadersByName[".rodata.sceModuleInfo"]).ReadStruct<ElfPsp.ModuleInfo>(); ;
//Console.WriteLine(this.ModuleInfo.ToStringDefault());
HleModuleGuest.InitInfo = new InitInfoStruct()
{
PC = ElfLoader.Header.EntryPoint + BaseAddress,
GP = HleModuleGuest.ModuleInfo.GP + BaseAddress,
};
UpdateModuleImports();
UpdateModuleExports();
ModuleManager.LoadedGuestModules.Add(HleModuleGuest);
return HleModuleGuest;
}
public void HandleTexts(Action <TextEntry> ActionTextEntry, Action <StringInfo> ActionStringInfo, bool HandleType1 = true)
{
uint TextId = 0;
int Lang = 0;
int TextType = -1;
var Text1 = new StringInfo[] { };
var Text2 = new StringInfo[] { };
var Stack = new List <dynamic>();
bool LastSeparator = true;
foreach (var Instruction in ReadInstructions())
{
//Console.WriteLine("{0:X8}: {1}", Instruction.InstructionPosition, Instruction);
switch (Instruction.Opcode)
{
case Opcode.UNK_0E:
switch (Instruction.InstructionData & 0xFFFF)
{
case 0x07: Lang = 1; break;
case 0x83: Lang = 2; break;
}
break;
case Opcode.PUSH:
{
var PushInstruction = (PushInstructionNode)Instruction;
if (PushInstruction.ParameterType == ValueType.String)
{
var StringInfo = new StringInfo(this, PushInstruction.IntValue, CodeStream.SliceWithLength(PushInstruction.InstructionPosition + 4, 4));
ActionStringInfo(StringInfo);
if (new[] { 1, 2 }.Contains(Lang))
{
if (Lang == 1)
{
Text1 = new[] { StringInfo }
}
;
if (Lang == 2)
{
Text2 = new[] { StringInfo }
}
;
}
else
{
//ActionStringInfo(StringInfo);
}
}
else
{
//Console.WriteLine("{0}", PushInstruction.ValueToPush.Value);
Stack.Add(PushInstruction.ValueToPush.Value);
}
Lang = 0;
}
break;
case Opcode.FUNCTION_START:
{
// Separator
//Console.WriteLine("------------------------------------");
if (!LastSeparator)
{
ActionTextEntry(null);
LastSeparator = true;
}
}
break;
case Opcode.CALL:
{
var CallInstruction = (CallInstructionNode)Instruction;
int TextFunc = 0;
if ((CallInstruction.FunctionType == FunctionType.Native) && (CallInstruction.NativeFunction == 1))
{
TextFunc = 1;
}
//if ((CallInstruction.FunctionType == FunctionType.Script) && ((new uint[] { 12, 0x12e30, }).Contains(CallInstruction.ScriptFunction))) TextFunc = 2;
bool AddEntry = true;
if (TextFunc > 0)
{
if (Text1.Length > 0 || Text2.Length > 0)
{
if (Stack.Count > 0)
{
if (TextFunc == 1)
{
//Console.WriteLine("TEXT![1]");
if (!HandleType1)
{
continue;
}
//Console.WriteLine("TEXT![1]");
TextId = 0;
try
{
var TextIdStr = String.Format("{0}", Stack[0]);
//Console.WriteLine("TEXT![1] : {0}", TextIdStr);
TextId = uint.Parse(TextIdStr);
}
catch
{
}
if (TextId < 00010001)
{
//Console.WriteLine("{0}", Stack.Implode(","));
//continue;
AddEntry = false;
}
//Console.WriteLine("TEXT![3]");
}
if (AddEntry)
{
ActionTextEntry(new TextEntry()
{
TextType = TextType,
Id = TextId,
Id2 = TextId,
Original = Text1,
Translated = Text2,
});
LastSeparator = false;
}
}
//Console.WriteLine("############ AddText {0:D8}:('{1}', '{2}')", Stack[0], Text1.EscapeString(), Text2.EscapeString());
}
}
Text1 = new StringInfo[0];
Text2 = new StringInfo[0];
TextType = -1;
Stack.Clear();
}
break;
case Opcode.PUSH_ARRAY:
{
var PushArrayInstruction = (PushArrayInstructionNode)Instruction;
// Dialog. Using PTR1.
if (PushArrayInstruction.ArrayNumberOfElements == 6)
{
var E = PushArrayInstruction.Elements.Cast <string>().ToArray();
var IE = PushArrayInstruction.IntElements;
TextType = IE[0];
int Unk = IE[1];
//Console.WriteLine("Dialog {0}, {1}, {2}", E[0], E[1], E[2]);
//Console.WriteLine("Dialog {0}, {1}, {2}", E[3], E[4], E[5]);
TextId = PushArrayInstruction.ArrayPointer + this.Header.TextStart;
Text1 = new[] {
new StringInfo(this, IE[2], TextStream.SliceWithLength(PushArrayInstruction.ArrayPointer + 4 * 2, 4)),
new StringInfo(this, IE[3], TextStream.SliceWithLength(PushArrayInstruction.ArrayPointer + 4 * 3, 4)),
};
Text2 = new[] {
new StringInfo(this, IE[4], TextStream.SliceWithLength(PushArrayInstruction.ArrayPointer + 4 * 4, 4)),
new StringInfo(this, IE[5], TextStream.SliceWithLength(PushArrayInstruction.ArrayPointer + 4 * 5, 4)),
};
ActionTextEntry(new TextEntry()
{
TextType = TextType,
Id = TextId,
Id2 = PushArrayInstruction.ArrayPointer,
Id3 = PushArrayInstruction.InstructionPosition,
Original = Text1,
Translated = Text2,
});
LastSeparator = false;
Text1 = new StringInfo[0];
Text2 = new StringInfo[0];
TextType = -1;
Stack.Clear();
/*
* if (TextType != 0)
* {
* Console.WriteLine(TextType);
* Console.WriteLine("{0}", Text1.Implode("."));
* Console.WriteLine("{0}", Text2.Implode(","));
* }
*/
//Console.ReadKey();
}
}
break;
}
}
}
public Stream LoadChunk(Stream Stream, uint Offset)
{
return ReadChunkIncludingTheSize(Stream.SliceWithLength(Offset));
}
public void Load(Stream DatStream, Stream DavStream)
{
if (DavStream == null)
{
DavStream = DatStream;
}
this.DatStream = DatStream;
this.DavStream = DavStream;
Header = DatStream.ReadStruct <HeaderStruct>();
var Magic = Encoding.ASCII.GetString(Header.Magic);
if (Magic != "FPS4")
{
throw (new Exception(String.Format("Invalid Magic '{0}'", Magic)));
}
if (Header.FilePos != 0)
{
DatStream.Position = Header.FilePos;
OriginalFilePath = DatStream.ReadStringz(0x100, Encoding.GetEncoding("Shift-JIS"));
}
else
{
OriginalFilePath = "";
}
//Console.WriteLine("{0:X8}", Stream.Position);
if (Header.ListCount > 10000)
{
throw (new Exception("List too big (" + Header.ListCount + ")"));
}
bool UseIndices = false;
foreach (var Pass in new[] { false, true })
{
DatStream.Position = Header.ListStart;
for (uint n = 0; n < Header.ListCount; n++)
{
var EntryOffset = DatStream.Position;
var EntryStream = DatStream.ReadStream(Header.EntrySizeof);
var EntryStruct = default(EntryStruct);
var ExtraEntrySizeof = Header.EntrySizeof - 0x0C;
var IndexName = String.Format("{0}", n);
var Name = "";
uint MappedFileIndex = 0;
uint StringOffset = 0;
// @TODO: EntryFormat probably is a bitfield
// or a composed enum + bit field
// I don't know the bit mapping.
switch ((int)Header.EntryFormat)
{
case 0x8D:
EntryStruct.Offset = EntryStream.ReadStruct <uint_be>();
EntryStruct.LengthReal = EntryStruct.LengthSectorAligned = EntryStream.ReadStruct <uint_be>();
Name = EntryStream.ReadStringz(0x20);
MappedFileIndex = EntryStream.ReadStruct <uint_be>();
break;
case 0x47:
{
EntryStruct = EntryStream.ReadStruct <EntryStruct>();
StringOffset = EntryStream.ReadStruct <uint_be>();
if (StringOffset != 0)
{
var NameStream = DatStream.SliceWithLength(StringOffset, 0x1000);
Name = NameStream.ReadStringz();
//File.WriteAllBytes("c:/temp/name" + StringOffset + ".bin", NameStream.Slice().ReadAll());
//Console.WriteLine("{0:X8}: '{1}'", StringOffset, Name);
}
else
{
if (EntryStruct.LengthReal == 0)
{
continue;
}
}
}
break;
case 0x4F:
{
EntryStruct = EntryStream.ReadStruct <EntryStruct>();
Name = EntryStream.ReadStringz(0x20);
MappedFileIndex = EntryStream.ReadStruct <uint_be>();
}
break;
default:
{
EntryStruct = EntryStream.ReadStruct <EntryStruct>();
Name = EntryStream.ReadStringz(ExtraEntrySizeof);
switch (ExtraEntrySizeof)
{
case 0:
{
}
break;
case 4:
{
StringOffset = EntryStream.ReadStruct <uint>();
// Pointer to string name.
if (StringOffset != 0)
{
throw (new NotImplementedException());
}
}
break;
default:
{
EntryStream.Position = EntryStream.Length - ExtraEntrySizeof; // (0xC para common.svo y btl.svo, en los otros no sé) --- Apaño temporal
Name = EntryStream.ReadStringz(ExtraEntrySizeof);
}
break;
}
//Console.WriteLine("OFF:{0:X8}", EntryOffset);
//Console.WriteLine("STR:{0}", EntryStruct.ToStringDefault());
//Console.WriteLine("NAM'{0}'({1})", Name, Name.Length);
}
break;
}
//Console.WriteLine("Name: {0}", Name);
if (n == Header.ListCount - 1)
{
// Ignore last element with an empty name.
if (Name.Length == 0 && EntryStruct.LengthReal == 0)
{
continue;
}
}
if (IndexName.Length == 0)
{
IndexName = String.Format("{0}", n);
}
if (Name.Length == 0)
{
UseIndices = true;
}
if (UseIndices)
{
Name = IndexName;
}
//Console.WriteLine("Name: '{0}'", Encoding.UTF8.GetBytes(Name).ToStringArray());
if (Entries.ContainsKey(Name))
{
//Console.Error.WriteLine("Warning: Name '{0}' already contained", Name);
Name = n + "." + Name;
}
if (Pass)
{
var Entry = new Entry(this, EntryStruct, Name);
Entry.MappedFileIndex = MappedFileIndex;
Entry.Index = n;
Entries[Name] = Entry;
}
}
}
}
public Xex LoadHeader(Stream XexStream)
{
Header = XexStream.ReadStruct<HeaderStruct>();
var OptionalHeaders = XexStream.ReadStructVector<OptionalHeader>(Header.OptionalHeaderCount);
Console.WriteLine("{0:X}", XexStream.Position);
InfoList = new Dictionary<OptionalHeader.Ids, ulong>();
foreach (var OptionalHeader in OptionalHeaders)
{
//Console.WriteLine("{0}: 0x{1:X}", OptionalHeader.Id, (uint)OptionalHeader.Data);
//InfoList[OptionalHeader.Id] = OptionalHeader.Data;
InfoList.Add(OptionalHeader.Id, OptionalHeader.Data);
switch (OptionalHeader.Id)
{
case Xex.OptionalHeader.Ids.OriginalPEName:
this.OriginalPeName = LoadChunk(XexStream, OptionalHeader.Data).ReadStringz(Encoding: Encoding.UTF8);
break;
case Xex.OptionalHeader.Ids.LANKey:
this.LanKey = XexStream.SliceWithLength(OptionalHeader.Data, 0x10).ReadAll();
break;
case Xex.OptionalHeader.Ids.DefaultStackSize:
this.DefaultStackSize = OptionalHeader.Data;
break;
case Xex.OptionalHeader.Ids.ChecksumTimestamp:
this.ChecksumTimestamp = XexStream.SliceWithLength(OptionalHeader.Data).ReadStruct<ChecksumTimestampStruct>();
break;
case Xex.OptionalHeader.Ids.ImageBaseAddress:
this.ImageBaseAddress = OptionalHeader.Data;
break;
case Xex.OptionalHeader.Ids.EntryPoint:
this.EntryPoint = OptionalHeader.Data;
break;
case Xex.OptionalHeader.Ids.StaticLibraries:
this.StaticLibs = LoadChunk(XexStream, OptionalHeader.Data).ReadStructVectorUntilTheEndOfStream<StaticLib>();
foreach (var StaticLib in StaticLibs)
{
Console.WriteLine("StaticLib: {0}", StaticLib.ToStringDefault());
}
break;
case Xex.OptionalHeader.Ids.ImportLibraries:
{
var ImportLibrariesStream = LoadChunk(XexStream, OptionalHeader.Data);
var TextLength = (uint)ImportLibrariesStream.ReadStruct<uint_be>();
var LibraryCount = (uint)ImportLibrariesStream.ReadStruct<uint_be>();
var TextStream = ImportLibrariesStream.ReadStream(TextLength);
var LibraryNames = new String[LibraryCount];
for (int n = 0; n < LibraryCount; n++)
{
LibraryNames[n] = TextStream.ReadStringz(AllowEndOfStream: false);
Console.WriteLine("ImportLib: {0}", LibraryNames[n]);
}
var ChunkUnk1 = ReadChunkIncludingTheSize(ImportLibrariesStream);
var ImportAddressList = ReadChunkIncludingTheSize(ImportLibrariesStream);
Console.Error.WriteLine("@TODO: Xex.OptionalHeader.Ids.ImportLibraries");
}
break;
case Xex.OptionalHeader.Ids.TLSInfo:
{
this.TLSInfo = XexStream.SliceWithLength(OptionalHeader.Data).ReadStruct<TLSInfoStruct>();
}
break;
default:
Console.WriteLine("{0}: 0x{1:X}", OptionalHeader.Id, (uint)OptionalHeader.Data);
break;
}
}
PeStream = XexStream.SliceWithLength(Header.PeDataOffset);
Pe = new Pe().LoadHeader(PeStream);
Console.WriteLine("SecurityInfoOffset: {0:X}", (uint)Header.SecurityInfoOffset);
var SecurityStream = LoadChunk(XexStream, Header.SecurityInfoOffset);
var NumberOfSections = (ushort)SecurityStream.ReadStruct<ushort_be>();
Console.WriteLine("NumberOfSections: {0:X}", NumberOfSections);
return this;
}
/// <summary>
/// Function that writtes all the mappings into another stream.
/// Useful for patching a file or memory.
/// </summary>
/// <param name="TargetStream">Stream to write the mapped contents to</param>
public void WriteSegmentsToStream(Stream TargetStream)
{
foreach (var StreamEntry in _StreamEntries)
{
var SourceSliceStream = StreamEntry.Stream.SliceWithLength(0, StreamEntry.Length);
var TargetSliceStream = TargetStream.SliceWithLength(StreamEntry.Position, StreamEntry.Length);
SourceSliceStream.CopyToFast(TargetSliceStream);
}
}
