public static CaesarContainer DeserializeContainer(string json)
{
CaesarContainer container = JsonConvert.DeserializeObject <CaesarContainer>(json);
// at this point, the container needs to restore its internal object references before it is fully usable
CTFLanguage language = container.CaesarCTFHeader.CtfLanguages[0];
foreach (ECU ecu in container.CaesarECUs)
{
ecu.Restore(language, container);
}
return(container);
}
static void RunLibraryTest()
{
// debug: step through files to observe potential faults, missing bitflags etc.
List <string> paths = new List <string>();
string basePath = @"";
LoadFilePaths(basePath + @"Data05.00.00\", paths);
LoadFilePaths(basePath + @"CBF VAN\", paths);
foreach (string file in paths)
{
Console.WriteLine(file);
CaesarContainer container = new CaesarContainer(File.ReadAllBytes(file));
//Console.ReadKey();
}
}
public void Restore(CTFLanguage language, CaesarContainer parentContainer)
{
Language = language;
ParentContainer = parentContainer;
foreach (VCDomain vc in GlobalVCDs)
{
vc.Restore(language, this);
}
foreach (DTC dtc in GlobalDTCs)
{
dtc.Restore(language, this);
}
foreach (DiagService ds in GlobalDiagServices)
{
ds.Restore(language, this);
}
foreach (DiagService ds in GlobalEnvironmentContexts)
{
ds.Restore(language, this);
}
foreach (DiagPresentation pres in GlobalPresentations)
{
pres.Restore(language);
}
foreach (DiagPresentation pres in GlobalInternalPresentations)
{
pres.Restore(language);
}
foreach (ECUInterface iface in ECUInterfaces)
{
iface.Restore(language);
}
foreach (ECUInterfaceSubtype iface in ECUInterfaceSubtypes)
{
iface.Restore(language);
}
foreach (ECUVariant variant in ECUVariants)
{
variant.Restore(language, this);
}
}
public ECU(BinaryReader reader, CTFLanguage language, CFFHeader header, long baseAddress, CaesarContainer parentContainer)
{
ParentContainer = parentContainer;
BaseAddress = baseAddress;
// Read 32+16 bits
ulong ecuBitFlags = reader.ReadUInt32();
// after exhausting the 32 bits, load these additional 16 bits
ulong ecuBitFlagsExtended = reader.ReadUInt16();
// Console.WriteLine($"ECU bitflags: {ecuBitFlags:X}");
// advancing forward to ecuBase + 10
int ecuHdrIdk1 = reader.ReadInt32(); // no idea
// Console.WriteLine($"Skipping: {ecuHdrIdk1:X8}");
Qualifier = CaesarReader.ReadBitflagStringWithReader(ref ecuBitFlags, reader, BaseAddress);
EcuName_CTF = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader, -1);
EcuDescription_CTF = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader, -1);
EcuXmlVersion = CaesarReader.ReadBitflagStringWithReader(ref ecuBitFlags, reader, BaseAddress);
InterfaceBlockCount = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader);
InterfaceTableOffset = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader);
SubinterfacesCount = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader);
SubinterfacesOffset = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader);
EcuClassName = CaesarReader.ReadBitflagStringWithReader(ref ecuBitFlags, reader, BaseAddress);
UnkStr7 = CaesarReader.ReadBitflagStringWithReader(ref ecuBitFlags, reader, BaseAddress);
UnkStr8 = CaesarReader.ReadBitflagStringWithReader(ref ecuBitFlags, reader, BaseAddress);
int dataBufferOffsetRelativeToFile = header.StringPoolSize + StubHeader.StubHeaderSize + header.CffHeaderSize + 4;
// Console.WriteLine($"{nameof(dataBufferOffsetRelativeToFile)} : 0x{dataBufferOffsetRelativeToFile:X}");
IgnitionRequired = CaesarReader.ReadBitflagInt16(ref ecuBitFlags, reader);
Unk2 = CaesarReader.ReadBitflagInt16(ref ecuBitFlags, reader);
UnkBlockCount = CaesarReader.ReadBitflagInt16(ref ecuBitFlags, reader);
UnkBlockOffset = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader);
EcuSgmlSource = CaesarReader.ReadBitflagInt16(ref ecuBitFlags, reader);
Unk6RelativeOffset = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader);
EcuVariant_BlockOffset = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader) + dataBufferOffsetRelativeToFile;
EcuVariant_EntryCount = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader);
EcuVariant_EntrySize = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader);
EcuVariant_BlockSize = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader);
DiagJob_BlockOffset = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader) + dataBufferOffsetRelativeToFile;
DiagJob_EntryCount = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader);
DiagJob_EntrySize = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader);
DiagJob_BlockSize = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader);
Dtc_BlockOffset = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader) + dataBufferOffsetRelativeToFile;
Dtc_EntryCount = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader);
Dtc_EntrySize = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader);
Dtc_BlockSize = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader);
Env_BlockOffset = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader) + dataBufferOffsetRelativeToFile;
Env_EntryCount = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader);
Env_EntrySize = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader);
// bitflags will be exhausted at this point, load the extended bitflags
ecuBitFlags = ecuBitFlagsExtended;
Env_BlockSize = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader);
VcDomain_BlockOffset = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader) + dataBufferOffsetRelativeToFile;
VcDomain_EntryCount = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader);
VcDomain_EntrySize = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader);
VcDomain_BlockSize = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader);
Presentations_BlockOffset = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader) + dataBufferOffsetRelativeToFile;
Presentations_EntryCount = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader);
Presentations_EntrySize = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader);
Presentations_BlockSize = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader);
Info_BlockOffset = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader) + dataBufferOffsetRelativeToFile;
Info_EntryCount = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader);
Info_EntrySize = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader);
Info_BlockSize = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader);
Unk_BlockOffset = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader) + dataBufferOffsetRelativeToFile;
Unk_EntryCount = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader);
Unk_EntrySize = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader);
Unk_BlockSize = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader);
Unk39 = CaesarReader.ReadBitflagInt32(ref ecuBitFlags, reader);
// read ecu's supported interfaces and subtypes
// try to read interface block from the interface buffer table
// this address is relative to the definitions block
long interfaceTableAddress = BaseAddress + InterfaceTableOffset;
// Console.WriteLine($"Interface table address: {interfaceTableAddress:X}, given offset: {interfaceTableOffset:X}");
ECUInterfaces = new List <ECUInterface>();
for (int interfaceBufferIndex = 0; interfaceBufferIndex < InterfaceBlockCount; interfaceBufferIndex++)
{
// Console.WriteLine($"Parsing interface {interfaceBufferIndex + 1}/{interfaceBlockCount}");
// find our interface block offset
reader.BaseStream.Seek(interfaceTableAddress + (interfaceBufferIndex * 4), SeekOrigin.Begin);
// seek to the actual block (ambiguity: is this relative to the interface table or the current array?)
int interfaceBlockOffset = reader.ReadInt32();
long ecuInterfaceBaseAddress = interfaceTableAddress + interfaceBlockOffset;
ECUInterface ecuInterface = new ECUInterface(reader, ecuInterfaceBaseAddress);
ECUInterfaces.Add(ecuInterface);
}
// try to read interface subtype block from the interface buffer table
// this address is relative to the definitions block
ECUInterfaceSubtypes = new List <ECUInterfaceSubtype>();
long ctTableAddress = BaseAddress + SubinterfacesOffset;
// Console.WriteLine($"Interface subtype table address: {ctTableAddress:X}, given offset: {ecuChildTypesOffset:X}");
for (int ctBufferIndex = 0; ctBufferIndex < SubinterfacesCount; ctBufferIndex++)
{
// Console.WriteLine($"Parsing interface subtype {ctBufferIndex + 1}/{ecuNumberOfEcuChildTypes}");
// find our ct block offset
reader.BaseStream.Seek(ctTableAddress + (ctBufferIndex * 4), SeekOrigin.Begin);
// seek to the actual block (ambiguity: is this relative to the ct table or the current array?)
int actualBlockOffset = reader.ReadInt32();
long ctBaseAddress = ctTableAddress + actualBlockOffset;
ECUInterfaceSubtype ecuInterfaceSubtype = new ECUInterfaceSubtype(reader, ctBaseAddress, ctBufferIndex);
ECUInterfaceSubtypes.Add(ecuInterfaceSubtype);
}
CreateDiagServices(reader, language);
CreateEcuVariants(reader, language);
CreatePresentations(reader, language);
ECUDescriptionTranslated = language.GetString(EcuDescription_CTF);
}
public static byte[] SerializeCompressedContainer(CaesarContainer container)
{
return(Deflate(Encoding.UTF8.GetBytes(SerializeContainer(container))));
}
public static string SerializeContainer(CaesarContainer container)
{
return(JsonConvert.SerializeObject(container));
}
