public override void Serialize(LittleEndianWriter writer)
{
int syncId = Environment.TickCount;
writer.WriteInt(syncId); // syncID
writer.WriteByte((byte)1); // updating 1 unit
uint masterMask = 0;
for (var i = 0; i < 6; i++)
{
for (var j = 0; j < 32; j++)
{
var rep = values[i, j];
if (rep == null || (!rep.Changed && partial))
{
continue;
}
masterMask |= 1u << i;
break;
}
}
writer.WriteByte((byte)masterMask);
writer.WriteUInt((uint)actorNetId);
for (var i = 0; i < 6; i++)
{
uint fieldMask = 0;
var stream = new MemoryStream();
var w = new LittleEndianWriter(stream);
for (var j = 0; j < 32; j++)
{
var rep = values[i, j];
if (rep == null || (!rep.Changed && partial))
{
continue;
}
fieldMask |= 1u << j;
if (rep.IsFloat)
{
var source = BitConverter.GetBytes(rep.Value);
if (source[0] >= 0xFE)
{
w.WriteByte((byte)0xFE);
}
w.WriteBytes(source);
}
else
{
uint num = rep.Value;
while (num >= 0x80)
{
w.WriteByte((byte)(num | 0x80));
num >>= 7;
}
w.WriteByte((byte)num);
}
}
var data = stream.ToArray();
if (data.Length > 0)
{
writer.WriteUInt(fieldMask);
writer.WriteByte((byte)data.Length);
writer.WriteBytes(data);
}
}
}
public override void Serialize(LittleEndianWriter writer)
{
writer.WriteByte((byte)attackType);
targetPosition.Serialize(writer);
writer.WriteUInt(targetNetId);
}
public override void Serialize(LittleEndianWriter writer)
{
writer.WriteUInt(projectileNetId);
}
public override byte[] GetParameters(bool isUnicode)
{
byte[] parameters = new byte[ParametersLength];
LittleEndianWriter.WriteUInt16(parameters, 0, InformationLevel);
return(parameters);
}
public void WriteBytes(byte[] buffer, int offset)
{
LittleEndianWriter.WriteUInt32(buffer, offset + 0x00, BitmapOffset);
LittleEndianWriter.WriteUInt32(buffer, offset + 0x04, NumberOfBits);
}
public void WriteBytes(byte[] buffer, int offset)
{
LittleEndianWriter.WriteUInt16(buffer, offset + 0, (ushort)Result);
LittleEndianWriter.WriteUInt16(buffer, offset + 2, (ushort)Reason);
TransferSyntax.WriteBytes(buffer, offset + 4);
}
public override void Serialize(LittleEndianWriter writer)
{
writer.WriteByte(newLevel);
writer.WriteShort(skillPoints);
}
public override byte[] GetBytes()
{
byte[] buffer = new byte[Length];
LittleEndianWriter.WriteInt64(buffer, 0, AllocationSize);
return(buffer);
}
public override void WriteBytes(byte[] buffer, int offset)
{
LittleEndianWriter.WriteUInt32(buffer, offset + 0, dwRowID);
LittleEndianWriter.WriteUInt32(buffer, offset + 4, dwRowIndex);
}
public override void WriteBytes(byte[] buffer, int offset)
{
LittleEndianWriter.WriteInt64(buffer, offset, AllocationSize);
}
public override void WriteBytes(byte[] buffer, int offset)
{
LittleEndianWriter.WriteUInt32(buffer, offset + 0, (uint)AccessFlags);
}
public override void Serialize(LittleEndianWriter writer)
{
writer.WriteByte(buffSlot);
writer.WriteUInt(buffNameHash);
writer.WriteFloat(runTimeRemove);
}
/// <summary>
/// Get file record end marker
/// </summary>
public static byte[] GetEndMarker()
{
byte[] buffer = new byte[4];
LittleEndianWriter.WriteUInt32(buffer, 0, 0xFFFFFFFF);
return(buffer);
}
public override byte[] GetBytes()
{
byte[] buffer = new byte[Length];
LittleEndianWriter.WriteInt64(buffer, 0, EndOfFile);
return(buffer);
}
public override void WriteBytes(byte[] buffer, int offset)
{
LittleEndianWriter.WriteUInt32(buffer, offset + 0, nidParent.Value);
LittleEndianWriter.WriteUInt32(buffer, offset + 4, nidMsg.Value);
}
public override void Serialize(LittleEndianWriter writer)
{
writer.WriteByte(undefined);
}
public static void WriteBufferPointer(byte[] buffer, int offset, ushort bufferLength, uint bufferOffset)
{
LittleEndianWriter.WriteUInt16(buffer, offset, bufferLength);
LittleEndianWriter.WriteUInt16(buffer, offset + 2, bufferLength);
LittleEndianWriter.WriteUInt32(buffer, offset + 4, bufferOffset);
}
public override void WriteBytes(byte[] buffer, int offset)
{
LittleEndianWriter.WriteUInt32(buffer, offset, (uint)FileMode);
}
public void WriteBytes(byte[] buffer, int offset)
{
LittleEndianWriter.WriteUInt16(buffer, offset + 0x00, OpenAttributeOffset);
LittleEndianWriter.WriteUInt16(buffer, offset + 0x02, (ushort)(Name.Length * 2));
ByteWriter.WriteUTF16String(buffer, offset + 0x04, Name + "\0");
}
public override byte[] GetParameters(bool isUnicode)
{
byte[] parameters = new byte[2];
LittleEndianWriter.WriteUInt16(parameters, 0, EaErrorOffset);
return(parameters);
}
public override byte[] GetSetup()
{
byte[] setup = new byte[SetupLength];
LittleEndianWriter.WriteUInt16(setup, 0, TransactionDataSize);
return(setup);
}
public override void Serialize(LittleEndianWriter writer)
{
writer.WriteUInt(killerNetId);
writer.WriteInt(0); // unks
}
public override void WriteCommandBytes(byte[] buffer, int offset)
{
LittleEndianWriter.WriteUInt16(buffer, offset + 0, StructureSize);
LittleEndianWriter.WriteUInt16(buffer, offset + 2, Reserved);
}
public void WriteBytes(byte[] buffer, int offset)
{
LittleEndianWriter.WriteGuidBytes(buffer, offset + 0, InterfaceUUID);
LittleEndianWriter.WriteUInt32(buffer, offset + 16, InterfaceVersion);
}
public override void WriteBytes(byte[] buffer, int offset)
{
LittleEndianWriter.WriteUInt32(buffer, offset + 0, (uint)DeviceType);
LittleEndianWriter.WriteUInt32(buffer, offset + 4, (uint)Characteristics);
}
public void WriteBytes(byte[] buffer, int offset)
{
ByteWriter.WriteBytes(buffer, offset, key);
LittleEndianWriter.WriteUInt32(buffer, offset + key.Length, hidNextLevel.Value);
}
public override void Serialize(LittleEndianWriter writer)
{
writer.WriteByte(slot);
writer.WriteShort(remaining);
}
public override void WriteBytes(byte[] buffer, int offset)
{
base.WriteBytes(buffer, offset);
LittleEndianWriter.WriteUInt32(buffer, offset + 8, DataOffset);
LittleEndianWriter.WriteUInt32(buffer, offset + 12, DataSize);
}
public override void WriteBytes(byte[] buffer, int offset)
{
LittleEndianWriter.WriteUInt32(buffer, offset + 0, AlignmentRequirement);
}
/// <param name="segmentLength">This refers to the maximum length of FileRecord as defined in the Volume's BootRecord</param>
public byte[] GetBytes(int segmentLength, int bytesPerCluster, ushort minorNTFSVersion)
{
int strideCount = segmentLength / MultiSectorHelper.BytesPerStride;
ushort updateSequenceArraySize = (ushort)(1 + strideCount);
ushort updateSequenceArrayOffset;
if (minorNTFSVersion == 0)
{
updateSequenceArrayOffset = NTFS30UpdateSequenceArrayOffset;
}
else
{
updateSequenceArrayOffset = NTFS31UpdateSequenceArrayOffset;
}
ushort firstAttributeOffset = GetFirstAttributeOffset(segmentLength, minorNTFSVersion);
byte[] buffer = new byte[segmentLength];
ByteWriter.WriteAnsiString(buffer, 0, Signature, 4);
LittleEndianWriter.WriteUInt16(buffer, 0x04, updateSequenceArrayOffset);
LittleEndianWriter.WriteUInt16(buffer, 0x06, updateSequenceArraySize);
LittleEndianWriter.WriteUInt64(buffer, 0x08, LogFileSequenceNumber);
LittleEndianWriter.WriteUInt16(buffer, 0x10, SequenceNumber);
LittleEndianWriter.WriteUInt16(buffer, 0x12, HardLinkCount);
LittleEndianWriter.WriteUInt16(buffer, 0x14, firstAttributeOffset);
LittleEndianWriter.WriteUInt16(buffer, 0x16, (ushort)m_flags);
LittleEndianWriter.WriteInt32(buffer, 0x1C, segmentLength);
LittleEndianWriter.WriteUInt64(buffer, 0x20, BaseFileRecordSegmentNumber);
LittleEndianWriter.WriteUInt16(buffer, 0x28, NextAttributeId);
if (minorNTFSVersion == 1)
{
LittleEndianWriter.WriteUInt32(buffer, 0x2C, MftSegmentNumberXP);
}
// write attributes
int position = firstAttributeOffset;
foreach (AttributeRecord attribute in m_immediateAttributes)
{
byte[] attributeBytes = attribute.GetBytes(bytesPerCluster);
ByteWriter.WriteBytes(buffer, position, attributeBytes);
position += attributeBytes.Length;
}
byte[] marker = GetEndMarker();
ByteWriter.WriteBytes(buffer, position, marker);
position += marker.Length;
position += 4; // record (length) is aligned to 8-byte boundary
uint segmentRealSize = (uint)position;
LittleEndianWriter.WriteUInt32(buffer, 0x18, segmentRealSize);
// write UpdateSequenceNumber and UpdateSequenceReplacementData
List <byte[]> updateSequenceReplacementData = MultiSectorHelper.EncodeSegmentBuffer(buffer, 0, segmentLength, UpdateSequenceNumber);
position = updateSequenceArrayOffset;
LittleEndianWriter.WriteUInt16(buffer, position, UpdateSequenceNumber);
position += 2;
foreach (byte[] endOfSectorBytes in updateSequenceReplacementData)
{
ByteWriter.WriteBytes(buffer, position, endOfSectorBytes);
position += 2;
}
return(buffer);
}
