public static CharacterCreateRequest Unmarshal(MessageEventArgs args)
{
var reader = new SpanReader(args.Message.Payload.Span);
var slot = reader.ReadByte();
var c = new Character();
c.Level = 1;
c.Name = reader.ReadDaocString();
reader.Skip(4); // 0x18 0x00 0x00 0x00 - DoL notes say this is an array length
c.Customization = reader.Read <Customizations>();
reader.Skip(9);
var operation = reader.ReadByte(); // 1
var custType = reader.ReadByte(); // 0
reader.Skip(2); // ???
c.LocationDescription = reader.ReadDaocString(); // empty
reader.ReadDaocString(); // class description; redundant and empty
reader.ReadDaocString(); // race description; redundant and empty
reader.Skip(1); // ???
c.Classification = reader.Read <Classification>();
c.Model = reader.ReadUInt16LittleEndian(); // 12352
c.Region = reader.ReadUInt16LittleEndian(); // byte? 27
reader.Skip(4);
c.Stats = reader.Read <Stats>();
c.Equipment = reader.Read <Equipment>(); // empty
; // 4 bytes left
return(new CharacterCreateRequest(slot, c));
}
public int ExtractHuffmanPart(ref SpanReader sr, out Span <byte> outEntryData)
{
byte entryDataLength = sr.Span[sr.Position];
outEntryData = new byte[entryDataLength];
int basePos = sr.Position;
if (entryDataLength != 0)
{
int totalCount = 0;
for (int i = 0; i < entryDataLength; i++)
{
int current = totalCount / 8; // >> 3
if (totalCount < 0 && (totalCount & 7) != 0)
{
current++;
}
sr.Position = basePos + current + 1;
// Bury this and never look at it. Mystic PD shit.
uint val = 0;
val += !sr.IsEndOfSpan ? sr.ReadByte() : 0u;
val += !sr.IsEndOfSpan ? sr.ReadByte() * 0x100u : 0u;
val += !sr.IsEndOfSpan ? sr.ReadByte() * 0x10000u : 0u;
val += !sr.IsEndOfSpan ? sr.ReadByte() * 0x1000000u : 0u;
val >>= totalCount - (current * 8);
Span <byte> b = outEntryData.Slice(i);
totalCount += (int)ProcessHuffmanCode(val, ref b);
}
}
sr.Position = basePos;
return(entryDataLength);
}
private static void RewriteMessageLocalized(ReadOnlySpan <byte> input, CircularBuffer <byte> output, out int length)
{
var isAffix = input[0] == 0xCC;
var reader = new SpanReader(input);
reader.Seek(3, SeekOrigin.Current);
var serial = (Serial)reader.ReadUInt32();
var graphic = reader.ReadInt16();
var type = (MessageType)reader.ReadByte();
var hue = reader.ReadInt16();
var font = reader.ReadInt16();
var label = reader.ReadInt32();
var flags = isAffix ? (AffixType)reader.ReadByte() : AffixType.System;
var name = reader.ReadAscii(30);
var affix = isAffix ? reader.ReadAscii() : string.Empty;
var args = isAffix ? reader.ReadBigUni() : reader.ReadLittleUni();
if (!ZhConfig.Messaging.Cliloc.ContainsKey(label))
{
length = NetworkCompression.Compress(input, output);
return;
}
var text = ClilocList.Translate(label, args);
if (isAffix)
{
text = flags switch
{
AffixType.Append => $"{text}{affix}",
AffixType.Prepend => $"{affix}{text}",
_ => $"{text}{affix}"
};
if ((flags & AffixType.System) != 0)
{
type = MessageType.System;
}
}
var buffer = stackalloc byte[GetMaxMessageLength(text)].InitializePacket();
var pLength = CreateMessage(
buffer,
serial,
graphic,
type,
hue,
font,
true,
null,
name,
text
);
buffer = buffer.SliceToLength(pLength);
length = NetworkCompression.Compress(buffer, output);
}
}
public void Read(ref SpanReader r)
{
ID = Encoding.ASCII.GetString(r.ReadBytes(8));
Version = r.ReadByte();
OutputChannelCount = r.ReadByte();
PreSkip = r.ReadUShort();
InputSampleRate = r.ReadUInt32();
OutputGain = r.ReadShort();
ChannelMappingFamily = r.ReadByte();
}
public static ulong DecodeBitsAndAdvance(ref SpanReader sr)
{
ulong value = sr.ReadByte();
ulong mask = 0x80;
while ((value & mask) != 0)
{
value = ((value - mask) << 8) | (sr.ReadByte());
mask <<= 7;
}
return(value);
}
public static Entry ReadEntryFromBuffer(ref SpanReader sr)
{
Entry entry = null;
VolumeEntryType type = (VolumeEntryType)sr.ReadByte();
if (type == VolumeEntryType.CompressedFile)
{
entry = new CompressedFileEntry();
((CompressedFileEntry)entry).EntryType = type;
((CompressedFileEntry)entry).PageOffset = sr.ReadInt32();
((CompressedFileEntry)entry).ModifiedDate = sr.ReadDateTimeT();
((CompressedFileEntry)entry).CompressedSize = sr.ReadInt32();
((CompressedFileEntry)entry).Size = sr.ReadInt32();
}
else if (type == VolumeEntryType.File)
{
entry = new FileEntry();
((FileEntry)entry).EntryType = type;
((FileEntry)entry).PageOffset = sr.ReadInt32();
((FileEntry)entry).ModifiedDate = sr.ReadDateTimeT();
((FileEntry)entry).Size = sr.ReadInt32();
((FileEntry)entry).EntryType = type;
}
else if (type == VolumeEntryType.Directory)
{
entry = new DirEntry();
((DirEntry)entry).EntryType = type;
((DirEntry)entry).NodeID = sr.ReadInt32();
}
return(entry);
}
private static void RewriteUnicodeMessage(ReadOnlySpan <byte> input, CircularBuffer <byte> output, out int length)
{
var reader = new SpanReader(input);
reader.Seek(3, SeekOrigin.Current);
var serial = reader.ReadUInt32();
var graphic = reader.ReadInt16();
var type = (MessageType)reader.ReadByte();
var hue = reader.ReadInt16();
var font = reader.ReadInt16();
var lang = reader.ReadAscii(4);
var name = reader.ReadAscii(30);
var text = reader.ReadBigUni();
var buffer = stackalloc byte[GetMaxMessageLength(text)].InitializePacket();
var pLength = CreateMessage(
buffer,
serial,
graphic,
type,
hue,
font,
true,
null,
name,
text
);
buffer = buffer.SliceToLength(pLength);
length = NetworkCompression.Compress(buffer, output);
}
public static RegionRequest Unmarshall(MessageEventArgs args)
{
var reader = new SpanReader(args.Message.Payload.Span);
var slot = reader.ReadByte();
return(new RegionRequest(slot));
}
public void Deserialize(ref SpanReader sr)
{
Flags = (EntryKeyFlags)sr.ReadByte();
NameIndex = (uint)CryptoUtils.DecodeBitsAndAdvance(ref sr);
FileExtensionIndex = Flags.HasFlag(EntryKeyFlags.File) ? (uint)CryptoUtils.DecodeBitsAndAdvance(ref sr) : 0;
EntryIndex = (uint)CryptoUtils.DecodeBitsAndAdvance(ref sr);
}
public static AdhocFile ReadFromFile(string path)
{
var bytes = File.ReadAllBytes(path);
var sr = new SpanReader(bytes, encoding: Encoding.UTF8);
string magic = sr.ReadStringRaw(4);
if (!magic.Equals(MAGIC))
{
throw new Exception("Invalid MAGIC, doesn't match ADCH.");
}
byte version = (byte)int.Parse(sr.ReadStringRaw(3));
sr.ReadByte();
var adc = new AdhocFile(version);
if (adc.Version >= 9)
{
adc.ParseStringTable(ref sr);
}
adc.ParentCode = new AdhocCode();
adc.ParentCode.Deserialize(adc, ref sr);
return(adc);
}
public static GameOpenRequest Unmarshall(MessageEventArgs args)
{
var reader = new SpanReader(args.Message.Payload.Span);
byte confirmUdp = reader.ReadByte();
return(new GameOpenRequest(confirmUdp));
}
public static ushort ReadByteAtOffset(ref SpanReader sr, uint offset)
{
int curPos = sr.Position;
sr.Position += (int)offset;
ushort val = sr.ReadByte();
sr.Position = curPos;
return(val);
}
public void Deserialize(ref SpanReader sr)
{
Flags = (FileInfoFlags)sr.ReadByte();
FileIndex = (uint)DecodeBitsAndAdvance(ref sr);
CompressedSize = (uint)DecodeBitsAndAdvance(ref sr);
UncompressedSize = Flags.HasFlag(FileInfoFlags.Compressed) ? (uint)DecodeBitsAndAdvance(ref sr) : CompressedSize;
SegmentIndex = (uint)DecodeBitsAndAdvance(ref sr);
}
public virtual void Parse(Span <byte> span)
{
var spanReader = new SpanReader(span);
TrackNumber = spanReader.ReadVInt().Value;
TimeCode = spanReader.ReadShort(true); // EBML integer datatypes are big-endian
Flags = spanReader.ReadByte();
IsInvisible = (Flags & InvisibleBit) == InvisibleBit;
Lacing = (Lacing)(Flags & LacingBits);
if (Lacing != Lacing.No)
{
NumFrames = spanReader.ReadByte();
if (Lacing != Lacing.FixedSize)
{
LaceCodedSizeOfEachFrame = spanReader.ReadByte();
}
}
Data = span.Slice(spanReader.Position).ToArray();
}
//[Test]
//public void LevelDbGetValueFromMissingKey()
//{
// using var db = new Database(new DirectoryInfo(@"C:\Development\Other\bedrock-server-1.14.1.4\worlds\BedrockGeneratedLevel\db"));
// db.Open();
// int x = 15;
// int z = 6;
// Log.Warn("Looking for version");
// var versionKey = BitConverter.GetBytes(x).Concat(BitConverter.GetBytes(z)).Concat(new byte[] {0x76}).ToArray();
// var version = db.Get(versionKey);
// Assert.AreEqual(15, version.First());
// Log.Warn("Looking for key");
// Assert.NotNull(db.Get(BitConverter.GetBytes(x).Concat(BitConverter.GetBytes(z)).Concat(new byte[] {0x2f, 0}).ToArray()));
// Assert.NotNull(db.Get(BitConverter.GetBytes(x).Concat(BitConverter.GetBytes(z)).Concat(new byte[] {0x2f, 1}).ToArray()));
// Assert.NotNull(db.Get(BitConverter.GetBytes(x).Concat(BitConverter.GetBytes(z)).Concat(new byte[] {0x2f, 2}).ToArray()));
// Assert.NotNull(db.Get(BitConverter.GetBytes(x).Concat(BitConverter.GetBytes(z)).Concat(new byte[] {0x2f, 3}).ToArray()));
// Assert.NotNull(db.Get(BitConverter.GetBytes(x).Concat(BitConverter.GetBytes(z)).Concat(new byte[] {0x2f, 4}).ToArray()));
// Assert.NotNull(db.Get(BitConverter.GetBytes(x).Concat(BitConverter.GetBytes(z)).Concat(new byte[] {0x2f, 5}).ToArray()));
// Assert.Null(db.Get(BitConverter.GetBytes(x).Concat(BitConverter.GetBytes(z)).Concat(new byte[] {0x2f, 6}).ToArray()));
// Assert.Null(db.Get(BitConverter.GetBytes(x).Concat(BitConverter.GetBytes(z)).Concat(new byte[] {0x2f, 7}).ToArray()));
// Assert.Null(db.Get(BitConverter.GetBytes(x).Concat(BitConverter.GetBytes(z)).Concat(new byte[] {0x2f, 8}).ToArray())); // Fail??
// Assert.Null(db.Get(BitConverter.GetBytes(x).Concat(BitConverter.GetBytes(z)).Concat(new byte[] {0x2f, 9}).ToArray()));
// Assert.Null(db.Get(BitConverter.GetBytes(x).Concat(BitConverter.GetBytes(z)).Concat(new byte[] {0x2f, 10}).ToArray()));
// Assert.Null(db.Get(BitConverter.GetBytes(x).Concat(BitConverter.GetBytes(z)).Concat(new byte[] {0x2f, 11}).ToArray()));
// Assert.Null(db.Get(BitConverter.GetBytes(x).Concat(BitConverter.GetBytes(z)).Concat(new byte[] {0x2f, 12}).ToArray()));
// Assert.Null(db.Get(BitConverter.GetBytes(x).Concat(BitConverter.GetBytes(z)).Concat(new byte[] {0x2f, 13}).ToArray()));
// Assert.Null(db.Get(BitConverter.GetBytes(x).Concat(BitConverter.GetBytes(z)).Concat(new byte[] {0x2f, 14}).ToArray()));
// Assert.Null(db.Get(BitConverter.GetBytes(x).Concat(BitConverter.GetBytes(z)).Concat(new byte[] {0x2f, 15}).ToArray()));
//}
private void ParseChunk(ReadOnlySpan <byte> data)
{
var reader = new SpanReader(data);
var version = reader.ReadByte();
Assert.AreEqual(8, version); // new palette-based chunk format
var storageSize = reader.ReadByte();
for (int i = 0; i < storageSize; i++)
{
var bitsPerBlock = reader.ReadByte() >> 1;
Assert.AreEqual(4, bitsPerBlock);
int numberOfBytes = 4096 / (32 / bitsPerBlock) * 4;
var blockData = reader.Read(numberOfBytes);
Assert.AreEqual(4096 / 2, blockData.Length);
int paletteSize = reader.ReadInt32();
Assert.AreEqual(12, paletteSize);
for (int j = 0; j < paletteSize; j++)
{
NbtFile file = new NbtFile();
file.BigEndian = false;
file.UseVarInt = false;
var buffer = data.Slice(reader.Position).ToArray();
int numberOfBytesRead = (int)file.LoadFromStream(new MemoryStream(buffer), NbtCompression.None);
reader.Position += numberOfBytesRead;
Console.WriteLine(file.RootTag);
Assert.NotZero(numberOfBytesRead);
}
}
}
public (SpecDBRowData Row, bool ReadAll) ReadRow(Span <byte> rowData, Endian endian)
{
var sr = new SpanReader(rowData, endian);
var row = new SpecDBRowData();
foreach (var columnMeta in Columns)
{
switch (columnMeta.ColumnType)
{
case DBColumnType.Bool:
row.ColumnData.Add(new DBBool(sr.ReadBoolean())); break;
case DBColumnType.Byte:
row.ColumnData.Add(new DBByte(sr.ReadByte())); break;
case DBColumnType.SByte:
row.ColumnData.Add(new DBSByte(sr.ReadSByte())); break;
case DBColumnType.Short:
row.ColumnData.Add(new DBShort(sr.ReadInt16())); break;
case DBColumnType.UShort:
row.ColumnData.Add(new DBUShort(sr.ReadUInt16())); break;
case DBColumnType.Int:
row.ColumnData.Add(new DBInt(sr.ReadInt32())); break;
case DBColumnType.UInt:
row.ColumnData.Add(new DBUInt(sr.ReadUInt32())); break;
case DBColumnType.Long:
row.ColumnData.Add(new DBLong(sr.ReadInt64())); break;
case DBColumnType.Float:
row.ColumnData.Add(new DBFloat(sr.ReadSingle())); break;
case DBColumnType.String:
row.ColumnData.Add(new DBString(sr.ReadInt32(), columnMeta.StringFileName)); break;
default:
break;
}
}
return(row, sr.IsEndOfSpan);
}
private List <KeyValuePair <byte[], ResultCacheEntry> > DecodeBatch(ReadOnlySpan <byte> data)
{
SpanReader batchReader = new SpanReader(data);
var sequenceNumber = batchReader.ReadInt64();
var operationCount = batchReader.ReadInt32();
var result = new List <KeyValuePair <byte[], ResultCacheEntry> >(operationCount);
for (int i = 0; i < operationCount; i++)
{
byte operationCode = batchReader.ReadByte();
var keyLength = batchReader.ReadVarLong();
var currentKey = batchReader.Read(keyLength);
if (operationCode == (int)OperationType.Put) // Put
{
ulong valueLength = batchReader.ReadVarLong();
var currentVal = batchReader.Read(valueLength);
result.Add(new KeyValuePair <byte[], ResultCacheEntry>(currentKey.ToArray(), new ResultCacheEntry
{
Sequence = sequenceNumber,
ResultState = ResultState.Exist,
Data = currentVal.ToArray()
}));
}
else if (operationCode == (int)OperationType.Delete) // Delete
{
// says return "not found" in this case. Need to investigate since I believe there can multiple records with same key in this case.
result.Add(new KeyValuePair <byte[], ResultCacheEntry>(currentKey.ToArray(), new ResultCacheEntry
{
Sequence = sequenceNumber,
ResultState = ResultState.Deleted
}));
}
else
{
// unknown recType
}
}
return(result);
}
public void ReadIDIMapOffsets(SpecDB specDb)
{
//if (TableName.Equals("CAR_NAME_"))
// TableName += specDb.LocaleName;
var buffer = File.ReadAllBytes(Path.Combine(specDb.FolderName, TableName) + ".idi");
SpanReader sr = new SpanReader(buffer);
var magic = sr.ReadStringRaw(4);
if (magic != "GTID")
{
throw new InvalidDataException("IDI Table had invalid magic.");
}
Endian endian = sr.ReadByte() != 0 ? Endian.Little : Endian.Big;
IDI = new IDI(buffer, endian);
sr.Endian = endian;
sr.Position = 0x0C;
TableID = sr.ReadInt32();
}
private List <KeyValuePair <byte[], ResultCacheEntry> > DecodeBatch(ReadOnlySpan <byte> data)
{
var batchReader = new SpanReader(data);
long sequenceNumber = (long)batchReader.ReadUInt64();
int operationCount = (int)batchReader.ReadUInt32();
var result = new List <KeyValuePair <byte[], ResultCacheEntry> >(operationCount);
for (int i = 0; i < operationCount; i++)
{
byte operationCode = batchReader.ReadByte();
ReadOnlySpan <byte> currentKey = batchReader.ReadLengthPrefixedBytes();
if (operationCode == (int)OperationType.Value) // Put
{
ReadOnlySpan <byte> currentVal = batchReader.ReadLengthPrefixedBytes();
result.Add(new KeyValuePair <byte[], ResultCacheEntry>(currentKey.ToArray(), new ResultCacheEntry
{
Sequence = sequenceNumber,
ResultState = ResultState.Exist,
Data = currentVal.ToArray()
}));
}
else if (operationCode == (int)OperationType.Delete) // Delete
{
// says return "not found" in this case. Need to investigate since I believe there can multiple records with same key in this case.
result.Add(new KeyValuePair <byte[], ResultCacheEntry>(currentKey.ToArray(), new ResultCacheEntry
{
Sequence = sequenceNumber,
ResultState = ResultState.Deleted
}));
}
}
return(result);
}
public object Parse(byte[] filterBlock)
{
var reader = new SpanReader(filterBlock);
if (reader.Length < 5)
{
return(null);
}
reader.Seek(-1, SeekOrigin.End);
_baseLg = reader.ReadByte();
reader.Seek(-5, SeekOrigin.End);
_startOffsetArray = reader.ReadInt32();
if (_startOffsetArray > reader.Length - 5)
{
return(null);
}
_filterBlock = filterBlock;
return(null);
}
public override void Deserialize(AdhocFile parent, ref SpanReader sr)
{
State = (AdhocRunState)sr.ReadByte();
}
public void LevelDbWriteUserDataTest()
{
// Plan
var operations = new KeyValuePair <byte[], MemCache.ResultCacheEntry> [3];
for (int i = 0; i < 3; i++)
{
byte[] key = TestUtils.FillArrayWithRandomBytes(20);
var entry = new MemCache.ResultCacheEntry();
entry.ResultState = ResultState.Exist;
entry.Sequence = 10;
entry.Data = TestUtils.FillArrayWithRandomBytes(32768); // 32KB is maz size for a block, not that it matters for this
operations[i] = new KeyValuePair <byte[], MemCache.ResultCacheEntry>(key, entry);
}
MemCache memCache = new MemCache();
// Do
ReadOnlySpan <byte> result = memCache.EncodeBatch(operations);
// Check
SpanReader reader = new SpanReader(result);
Assert.AreEqual(10, reader.ReadInt64(), "Sequence number");
Assert.AreEqual(3, reader.ReadInt32(), "Operations count");
for (int i = 0; i < 3; i++)
{
var expectedKey = operations[i].Key;
var expectedData = operations[i].Value.Data;
Assert.AreEqual(1, reader.ReadByte(), "Operations type PUT");
var keyLen = reader.ReadVarLong();
Assert.AreEqual(expectedKey.Length, keyLen, "Key len");
Assert.AreEqual(expectedKey, reader.Read(keyLen).ToArray(), "Key");
var dataLen = reader.ReadVarLong();
Assert.AreEqual(expectedData.Length, dataLen, "Data len");
Assert.AreEqual(expectedData, reader.Read(dataLen).ToArray(), "Data");
}
// test encoding complete blocks
var stream = new MemoryStream();
LogWriter writer = new LogWriter(stream);
writer.WriteData(result);
Assert.Less(0, stream.Length);
stream.Position = 0;
// Roundtrip test by making sure i can read blocks I've encoded myself.
LogReader logReader = new LogReader(stream);
logReader.Open();
MemCache memCache2 = new MemCache();
memCache2.Load(logReader);
var cache = memCache2._resultCache;
Assert.AreEqual(3, cache.Count);
int j = 0;
foreach (var entry in cache)
{
var expectedKey = operations[j].Key;
var expectedData = operations[j].Value.Data;
Assert.AreEqual(ResultState.Exist, entry.Value.ResultState, "Value exists");
Assert.AreEqual(expectedKey.Length, entry.Key.Length, "Key len");
Assert.AreEqual(expectedKey, entry.Key, "Key");
Assert.AreEqual(expectedData.Length, entry.Value.Data.Length, "Data len");
Assert.AreEqual(expectedData, entry.Value.Data, "Data");
j++;
}
}
public override void Deserialize(AdhocFile parent, ref SpanReader sr)
{
offset = sr.Position;
Value = sr.ReadByte() != 0;
}
public void LevelDbReadLogTest()
{
// https://github.com/google/leveldb/blob/master/doc/log_format.md
DirectoryInfo directory = TestUtils.GetTestDirectory();
LogReader logReader = new LogReader(new FileInfo(Path.Combine(directory.FullName, "000047.log")));
BytewiseComparator comparator = new BytewiseComparator();
bool found = false;
while (true)
{
ReadOnlySpan <byte> data = logReader.ReadData();
if (logReader.Eof)
{
break;
}
var dataReader = new SpanReader(data);
long sequenceNumber = dataReader.ReadInt64();
long size = dataReader.ReadInt32();
while (!dataReader.Eof)
{
byte recType = dataReader.ReadByte();
ulong v1 = dataReader.ReadVarLong();
var currentKey = dataReader.Read(v1);
//CurrentKey = f5 ff ff ff eb ff ff ff 36
if (comparator.Compare(new byte[] { 0xf5, 0xff, 0xff, 0xff, 0xeb, 0xff, 0xff, 0xff, 0x36 }, currentKey) == 0)
{
Assert.False(found);
found = true;
}
ulong v2 = 0;
ReadOnlySpan <byte> currentVal = ReadOnlySpan <byte> .Empty;
switch (recType)
{
case 1: // value
{
if (recType == 1)
{
v2 = dataReader.ReadVarLong();
currentVal = dataReader.Read(v2);
}
break;
}
case 0: // delete
{
//Assert.Fail("Unexpected delete key");
break;
}
default:
throw new Exception("Unknown record format");
}
if (Log.IsDebugEnabled)
{
Log.Debug($"RecType={recType}, Sequence={sequenceNumber}, Size={size}, v1={v1}, v2={v2}\nCurrentKey={currentKey.HexDump(currentKey.Length, false, false)}\nCurrentVal=\n{currentVal.HexDump(cutAfterFive: true)} ");
}
}
}
Assert.True(found);
}