public TreeConnectAndXResponseExtended(byte[] buffer, int offset, bool isUnicode) : base(buffer, offset, isUnicode)
{
int parametersOffset = 4;
OptionalSupport = (OptionalSupportFlags)LittleEndianReader.ReadUInt16(this.SMBParameters, ref parametersOffset);
MaximalShareAccessRights = new AccessMask(this.SMBParameters, ref parametersOffset);
GuestMaximalShareAccessRights = new AccessMask(this.SMBParameters, ref parametersOffset);
int dataOffset = 0;
string serviceString = ByteReader.ReadNullTerminatedAnsiString(this.SMBData, ref dataOffset);
NativeFileSystem = SMB1Helper.ReadSMBString(this.SMBData, ref dataOffset, isUnicode);
Service = ServiceNameHelper.GetServiceName(serviceString);
}
public FaultPDU(byte[] buffer) : base(buffer)
{
int offset = RPCPDU.CommonFieldsLength;
AllocationHint = LittleEndianReader.ReadUInt32(buffer, ref offset);
ContextID = LittleEndianReader.ReadUInt16(buffer, ref offset);
CancelCount = ByteReader.ReadByte(buffer, ref offset);
Reserved = ByteReader.ReadByte(buffer, ref offset);
Status = LittleEndianReader.ReadUInt32(buffer, ref offset);
Reserved2 = LittleEndianReader.ReadUInt32(buffer, ref offset);
int dataLength = FragmentLength - AuthLength - offset;
Data = ByteReader.ReadBytes(buffer, ref offset, dataLength);
AuthVerifier = ByteReader.ReadBytes(buffer, offset, AuthLength);
}
public FindFileDirectoryInfo(byte[] buffer, int offset, bool isUnicode) : base()
{
NextEntryOffset = LittleEndianReader.ReadUInt32(buffer, ref offset);
FileIndex = LittleEndianReader.ReadUInt32(buffer, ref offset);
CreationTime = FileTimeHelper.ReadNullableFileTime(buffer, ref offset);
LastAccessTime = FileTimeHelper.ReadNullableFileTime(buffer, ref offset);
LastWriteTime = FileTimeHelper.ReadNullableFileTime(buffer, ref offset);
LastAttrChangeTime = FileTimeHelper.ReadNullableFileTime(buffer, ref offset);
EndOfFile = LittleEndianReader.ReadInt64(buffer, ref offset);
AllocationSize = LittleEndianReader.ReadInt64(buffer, ref offset);
ExtFileAttributes = (ExtendedFileAttributes)LittleEndianReader.ReadUInt32(buffer, ref offset);
uint fileNameLength = LittleEndianReader.ReadUInt32(buffer, ref offset);
FileName = SMB1Helper.ReadFixedLengthString(buffer, ref offset, isUnicode, (int)fileNameLength);
}
public SMB1Command(byte[] buffer, int offset)
{
byte wordCount = ByteReader.ReadByte(buffer, ref offset);
if (CommandName == CommandName.SMB_COM_NT_CREATE_ANDX && wordCount == NTCreateAndXResponseExtended.DeclaredParametersLength / 2)
{
// [MS-SMB] Section 2.2.4.9.2 and Note <49>:
// Windows-based SMB servers send 50 (0x32) words in the extended response although they set the WordCount field to 0x2A.
wordCount = NTCreateAndXResponseExtended.ParametersLength / 2;
}
SMBParameters = ByteReader.ReadBytes(buffer, ref offset, wordCount * 2);
ushort byteCount = LittleEndianReader.ReadUInt16(buffer, ref offset);
SMBData = ByteReader.ReadBytes(buffer, ref offset, byteCount);
}
public RequestPDU(byte[] buffer, int offset) : base(buffer, offset)
{
offset += CommonFieldsLength;
AllocationHint = LittleEndianReader.ReadUInt32(buffer, ref offset);
ContextID = LittleEndianReader.ReadUInt16(buffer, ref offset);
OpNum = LittleEndianReader.ReadUInt16(buffer, ref offset);
if ((Flags & PacketFlags.ObjectUUID) > 0)
{
ObjectGuid = LittleEndianReader.ReadGuid(buffer, ref offset);
}
int dataLength = FragmentLength - AuthLength - offset;
Data = ByteReader.ReadBytes(buffer, ref offset, dataLength);
AuthVerifier = ByteReader.ReadBytes(buffer, offset, AuthLength);
}
public BindAckPDU(byte[] buffer, int offset) : base(buffer, offset)
{
int startOffset = offset;
offset += CommonFieldsLength;
MaxTransmitFragmentSize = LittleEndianReader.ReadUInt16(buffer, ref offset);
MaxReceiveFragmentSize = LittleEndianReader.ReadUInt16(buffer, ref offset);
AssociationGroupID = LittleEndianReader.ReadUInt32(buffer, ref offset);
SecondaryAddress = RPCHelper.ReadPortAddress(buffer, ref offset);
int padding = (4 - ((offset - startOffset) % 4)) % 4;
offset += padding;
ResultList = new ResultList(buffer, offset);
offset += ResultList.Length;
AuthVerifier = ByteReader.ReadBytes(buffer, offset, AuthLength);
}
public FindInfoStandard(byte[] buffer, ref int offset, bool isUnicode, bool returnResumeKeys) : base(returnResumeKeys)
{
if (returnResumeKeys)
{
ResumeKey = LittleEndianReader.ReadUInt32(buffer, ref offset);
}
CreationDateTime = SMBHelper.ReadSMBDateTime(buffer, ref offset);
LastAccessDateTime = SMBHelper.ReadSMBDateTime(buffer, ref offset);
LastWriteDateTime = SMBHelper.ReadSMBDateTime(buffer, ref offset);
FileDataSize = LittleEndianReader.ReadUInt32(buffer, ref offset);
AllocationSize = LittleEndianReader.ReadUInt32(buffer, ref offset);
Attributes = (FileAttributes)LittleEndianReader.ReadUInt16(buffer, ref offset);
byte fileNameLength = ByteReader.ReadByte(buffer, ref offset);
FileName = SMBHelper.ReadSMBString(buffer, ref offset, isUnicode);
}
public void OnDataArrival(ENetPacket *packet, Channel channel)
{
var data = new byte[(int)packet->dataLength];
Marshal.Copy(packet->data, data, 0, data.Length);
if ((int)packet->dataLength >= 8 && Encrypt)
{
data = LoLServer.BlowFish.Decrypt(data);
}
LittleEndianReader reader = new LittleEndianReader(data);
Message message = ProtocolManager.BuildMessage(this, channel, data);
ProtocolManager.HandleMessage(message, this);
}
public MovementDataNormal(LittleEndianReader reader)
{
byte bitfield = reader.ReadByte();
byte size = (byte)(bitfield >> 1);
HasTeleportID = (bitfield & 1) != 0;
if (size >= 2)
{
TeleportNetID = reader.ReadUInt();
if (HasTeleportID)
{
TeleportID = reader.ReadByte();
}
Waypoints = reader.ReadCompressedWaypoints(size / 2u);
}
}
public static void ApplyUsaProtection(byte[] buffer, int offset)
{
MultiSectorHeader multiSectorHeader = new MultiSectorHeader(buffer, offset + 0x00);
int position = offset + multiSectorHeader.UpdateSequenceArrayOffset;
ushort updateSequenceNumber = LittleEndianReader.ReadUInt16(buffer, ref position);
for (int index = 0; index < multiSectorHeader.UpdateSequenceArraySize - 1; index++)
{
// Read in the bytes that are replaced by the USN
byte[] endOfSectorBytes = ByteReader.ReadBytes(buffer, offset + (BytesPerStride * (index + 1)) - 2, 2);
// Relocate the bytes that are replaced by the USN
ByteWriter.WriteBytes(buffer, ref position, endOfSectorBytes);
// Write the USN
LittleEndianWriter.WriteUInt16(buffer, offset + (BytesPerStride * (index + 1)) - 2, updateSequenceNumber);
}
}
// ExtendedException Structure:
// http://msdn.microsoft.com/en-us/library/ee159855%28v=exchg.80%29
public void ReadExtendedException(byte[] buffer, ref int offset, uint writerVersion2)
{
if (writerVersion2 >= AppointmentRecurrencePatternStructure.Outlook2007VersionSignature)
{
// Change highlight structure:
// http://msdn.microsoft.com/en-us/library/ee202316%28v=exchg.80%29
uint changeHighlightSize = LittleEndianReader.ReadUInt32(buffer, ref offset);
if (changeHighlightSize < 4)
{
throw new InvalidRecurrencePatternException("Invalid ChangeHighlightSize");
}
uint changeHighlightValue = LittleEndianReader.ReadUInt32(buffer, ref offset);
offset += (int)changeHighlightSize - 4;
}
uint reservedBlockEE1Size = LittleEndianReader.ReadUInt32(buffer, ref offset);
offset += (int)reservedBlockEE1Size;
if (HasModifiedSubject || HasModifiedLocation)
{
DateTime extensionNewStartDT = DateTimeHelper.ReadDateTimeFromMinutes(buffer, ref offset);
DateTime extensionNewEndDT = DateTimeHelper.ReadDateTimeFromMinutes(buffer, ref offset);
DateTime extensionOriginalStartDT = DateTimeHelper.ReadDateTimeFromMinutes(buffer, ref offset);
if (extensionNewStartDT != NewStartDT ||
extensionNewEndDT != NewEndDT ||
extensionOriginalStartDT != OriginalStartDT)
{
throw new InvalidRecurrencePatternException("Extension timestamp mismatch");
}
if (HasModifiedSubject)
{
ushort numberOfCharacters = LittleEndianReader.ReadUInt16(buffer, ref offset);
Subject = ByteReader.ReadUTF16String(buffer, ref offset, numberOfCharacters);
}
if (HasModifiedLocation)
{
ushort numberOfCharacters = LittleEndianReader.ReadUInt16(buffer, ref offset);
Location = ByteReader.ReadUTF16String(buffer, ref offset, numberOfCharacters);
}
uint reservedBlockEE2Size = LittleEndianReader.ReadUInt32(buffer, ref offset);
offset += (int)reservedBlockEE2Size;
}
}
public override void Deserialize(LittleEndianReader reader)
{
byte itemCount = reader.ReadByte();
Items = new ItemData[itemCount];
for (int i = 0; i < itemCount; i++)
{
var item = new ItemData();
item.Deserialize(reader);
Items[i] = item;
}
bool hasShield = reader.ReadBool();
if (hasShield)
{
ShieldValues = new ShieldValues();
ShieldValues.Deserialize(reader);
}
int countCharStack = reader.ReadInt();
CharacterDataStack = new CharacterStackData[countCharStack];
for (int i = 0; i < countCharStack; i++)
{
var data = new CharacterStackData();
data.Deserialize(reader);
CharacterDataStack[i] = data;
}
LookAtNetId = reader.ReadUInt();
LookAtType = (LookAtType)reader.ReadByte();
LookAtPosition = Core.Extensions.DeserializeVector3(reader);
int numOfBuffCount = reader.ReadInt();
for (int i = 0; i < numOfBuffCount; i++)
{
byte slot = reader.ReadByte();
int count = reader.ReadInt();
BuffCount.Add(new KeyValuePair <byte, int>(slot, count));
}
UnknownIsHero = reader.ReadBool();
}
public override void ReadPatternTypeSpecific(byte[] buffer, ref int offset)
{
// we start reading from offset 22
if (PatternType == PatternType.Month) // i.e. the 23th of every month
{
DayOfMonth = LittleEndianReader.ReadUInt32(buffer, ref offset);
}
else if (PatternType == PatternType.MonthNth) // i.e. the fourth monday of every month
{
DayOfWeek = (OutlookDayOfWeek)LittleEndianReader.ReadUInt32(buffer, ref offset);
DayOccurenceNumber = (DayOccurenceNumber)LittleEndianReader.ReadUInt32(buffer, ref offset);
}
else
{
throw new InvalidRecurrencePatternException("Invalid Pattern Type");
}
}
public FindInfoQueryExtendedAttributesFromList(byte[] buffer, ref int offset, bool isUnicode, bool returnResumeKeys) : base(returnResumeKeys)
{
if (returnResumeKeys)
{
ResumeKey = LittleEndianReader.ReadUInt32(buffer, ref offset);
}
CreationDateTime = SMBHelper.ReadSMBDateTime(buffer, ref offset);
LastAccessDateTime = SMBHelper.ReadSMBDateTime(buffer, ref offset);
LastWriteDateTime = SMBHelper.ReadSMBDateTime(buffer, ref offset);
FileDataSize = LittleEndianReader.ReadUInt32(buffer, ref offset);
AllocationSize = LittleEndianReader.ReadUInt32(buffer, ref offset);
Attributes = (FileAttributes)LittleEndianReader.ReadUInt16(buffer, ref offset);
ExtendedAttributeList = new FullExtendedAttributeList(buffer, offset);
byte fileNameLength = ByteReader.ReadByte(buffer, ref offset);
FileName = SMBHelper.ReadFixedLengthString(buffer, ref offset, isUnicode, fileNameLength);
}
public static MovementData ReadMovementData(this LittleEndianReader reader, MovementDataType type)
{
switch (type)
{
case MovementDataType.Stop:
return(new MovementDataStop(reader));
case MovementDataType.Normal:
return(new MovementDataNormal(reader));
case MovementDataType.WithSpeed:
return(new MovementDataWithSpeed(reader));
default:
return(new MovementDataNone(reader));
}
}
public NTCreateAndXResponse(byte[] buffer, int offset) : base(buffer, offset)
{
int parametersOffset = 4;
OpLockLevel = (OpLockLevel)ByteReader.ReadByte(SMBParameters, ref parametersOffset);
FID = LittleEndianReader.ReadUInt16(SMBParameters, ref parametersOffset);
CreateDisposition = (CreateDisposition)LittleEndianReader.ReadUInt32(SMBParameters, ref parametersOffset);
CreateTime = SMB1Helper.ReadNullableFileTime(SMBParameters, ref parametersOffset);
LastAccessTime = SMB1Helper.ReadNullableFileTime(SMBParameters, ref parametersOffset);
LastWriteTime = SMB1Helper.ReadNullableFileTime(SMBParameters, ref parametersOffset);
LastChangeTime = SMB1Helper.ReadNullableFileTime(SMBParameters, ref parametersOffset);
ExtFileAttributes = (ExtendedFileAttributes)LittleEndianReader.ReadUInt32(SMBParameters, ref parametersOffset);
AllocationSize = LittleEndianReader.ReadInt64(SMBParameters, ref parametersOffset);
EndOfFile = LittleEndianReader.ReadInt64(SMBParameters, ref parametersOffset);
ResourceType = (ResourceType)LittleEndianReader.ReadUInt16(SMBParameters, ref parametersOffset);
NMPipeStatus = NamedPipeStatus.Read(SMBParameters, ref parametersOffset);
Directory = (ByteReader.ReadByte(SMBParameters, ref parametersOffset) > 0);
}
public override void Deserialize(LittleEndianReader reader)
{
this.playerId = reader.ReadInt();
this.botNetId = reader.ReadInt();
this.isBotMessage = reader.ReadByte();
this.channel = (ChatChannelType)reader.ReadInt();
this.unk1 = reader.ReadInt();
this.length = reader.ReadInt();
this.unk2 = reader.ReadBytes(32);
var bytes = new List <byte>();
for (var i = 0; i < length; i++)
{
bytes.Add(reader.ReadByte());
}
this.content = Encoding.UTF8.GetString(bytes.ToArray());
}
public static GridPosition[] ReadCompressedWaypoints(this LittleEndianReader reader, uint size)
{
var data = new List <GridPosition>();
BitArray flags;
if (size >= 2)
{
byte[] flagsBuffer = reader.ReadBytes((int)((size - 2) / 4 + 1));
flags = new BitArray(flagsBuffer);
}
else
{
flags = new BitArray(new byte[1]);
}
short lastX = reader.ReadShort();
short lastZ = reader.ReadShort();
data.Add(new GridPosition(lastX, lastZ));
for (int i = 1, flag = 0; i < size; i++)
{
if (flags[flag])
{
lastX += reader.ReadSByte();
}
else
{
lastX = reader.ReadShort();
}
flag++;
if (flags[flag])
{
lastZ += reader.ReadSByte();
}
else
{
lastZ = reader.ReadShort();
}
flag++;
data.Add(new GridPosition(lastX, lastZ));
}
return(data.ToArray());
}
public QueryFileAllInfo(byte[] buffer, int offset)
{
CreationTime = FileTimeHelper.ReadNullableFileTime(buffer, ref offset);
LastAccessTime = FileTimeHelper.ReadNullableFileTime(buffer, ref offset);
LastWriteTime = FileTimeHelper.ReadNullableFileTime(buffer, ref offset);
LastChangeTime = FileTimeHelper.ReadNullableFileTime(buffer, ref offset);
ExtFileAttributes = (ExtendedFileAttributes)LittleEndianReader.ReadUInt32(buffer, ref offset);
Reserved1 = LittleEndianReader.ReadUInt32(buffer, ref offset);
AllocationSize = LittleEndianReader.ReadInt64(buffer, ref offset);
EndOfFile = LittleEndianReader.ReadInt64(buffer, ref offset);
NumberOfLinks = LittleEndianReader.ReadUInt32(buffer, ref offset);
DeletePending = (ByteReader.ReadByte(buffer, ref offset) > 0);
Directory = (ByteReader.ReadByte(buffer, ref offset) > 0);
Reserved2 = LittleEndianReader.ReadUInt16(buffer, ref offset);
EaSize = LittleEndianReader.ReadUInt32(buffer, ref offset);
uint fileNameLength = LittleEndianReader.ReadUInt32(buffer, ref offset);
FileName = ByteReader.ReadUTF16String(buffer, ref offset, (int)(fileNameLength / 2));
}
public override void ReadPatternTypeSpecific(byte[] buffer, ref int offset)
{
// we start reading from offset 22
if (PatternType == PatternType.Day)
{
}
else if (PatternType == PatternType.Week) // EveryWeekday
{
DaysOfWeekFlags DaysOfWeek = (DaysOfWeekFlags)LittleEndianReader.ReadUInt32(buffer, ref offset);
if (DaysOfWeek != DateTimeHelper.Weekdays)
{
throw new InvalidRecurrencePatternException("Invalid DaysOfWeek for Daily Recurrence Pattern");
}
}
else
{
throw new InvalidRecurrencePatternException("Invalid Pattern Type");
}
}
public static IChangeSpellData ReadChangeSpellData(this LittleEndianReader reader)
{
IChangeSpellData data;
ChangeSlotSpellDataType type = (ChangeSlotSpellDataType)reader.ReadByte();
switch (type)
{
case ChangeSlotSpellDataType.TargetingType:
data = new ChangeSpellDataTargetingType();
break;
case ChangeSlotSpellDataType.SpellName:
data = new ChangeSpellDataSpellName();
break;
case ChangeSlotSpellDataType.Range:
data = new ChangeSpellDataRange();
break;
case ChangeSlotSpellDataType.MaxGrowthRange:
data = new ChangeSpellDataMaxGrowthRange();
break;
case ChangeSlotSpellDataType.RangeDisplay:
data = new ChangeSpellDataRangeDisplay();
break;
case ChangeSlotSpellDataType.IconIndex:
data = new ChangeSpellDataIconIndex();
break;
case ChangeSlotSpellDataType.OffsetTarget:
data = new ChangeSpellDataOffsetTarget();
break;
default:
data = new ChangeSpellDataUnknown();
break;
}
data.Deserialize(reader);
return(data);
}
public NTTransactSecondaryRequest(byte[] buffer, int offset) : base(buffer, offset, false)
{
int readOffset = 0;
Reserved1 = ByteReader.ReadBytes(this.SMBParameters, ref readOffset, 3);
TotalParameterCount = LittleEndianReader.ReadUInt32(this.SMBParameters, ref readOffset);
TotalDataCount = LittleEndianReader.ReadUInt32(this.SMBParameters, ref readOffset);
uint parameterCount = LittleEndianReader.ReadUInt32(this.SMBParameters, ref readOffset);
uint parameterOffset = LittleEndianReader.ReadUInt32(this.SMBParameters, ref readOffset);
ParameterDisplacement = LittleEndianReader.ReadUInt32(this.SMBParameters, ref readOffset);
uint dataCount = LittleEndianReader.ReadUInt32(this.SMBParameters, ref readOffset);
uint dataOffset = LittleEndianReader.ReadUInt32(this.SMBParameters, ref readOffset);
DataDisplacement = LittleEndianReader.ReadUInt32(this.SMBParameters, ref readOffset);
Reserved2 = ByteReader.ReadByte(this.SMBParameters, ref readOffset);
TransParameters = ByteReader.ReadBytes(buffer, (int)parameterOffset, (int)parameterCount);
TransData = ByteReader.ReadBytes(buffer, (int)dataOffset, (int)dataCount);
}
public NTTransactResponse(byte[] buffer, int offset) : base(buffer, offset, false)
{
int readOffset = 0;
Reserved1 = ByteReader.ReadBytes(this.SMBParameters, ref readOffset, 3);
TotalParameterCount = LittleEndianReader.ReadUInt32(this.SMBParameters, ref readOffset);
TotalDataCount = LittleEndianReader.ReadUInt32(this.SMBParameters, ref readOffset);
uint parameterCount = LittleEndianReader.ReadUInt32(this.SMBParameters, ref readOffset);
uint parameterOffset = LittleEndianReader.ReadUInt32(this.SMBParameters, ref readOffset);
uint parameterDisplacement = LittleEndianReader.ReadUInt32(this.SMBParameters, ref readOffset);
uint dataCount = LittleEndianReader.ReadUInt32(this.SMBParameters, ref readOffset);
uint dataOffset = LittleEndianReader.ReadUInt32(this.SMBParameters, ref readOffset);
uint dataDisplacement = LittleEndianReader.ReadUInt32(this.SMBParameters, ref readOffset);
byte setupCount = ByteReader.ReadByte(this.SMBParameters, ref readOffset);
Setup = ByteReader.ReadBytes(this.SMBParameters, ref offset, setupCount * 2);
TransParameters = ByteReader.ReadBytes(buffer, (int)parameterOffset, (int)parameterCount);
TransData = ByteReader.ReadBytes(buffer, (int)dataOffset, (int)dataCount);
}
public TimeZoneDefinitionStructure(byte[] buffer)
{
int offset = 0;
MajorVersion = ByteReader.ReadByte(buffer, ref offset);
MinorVersion = ByteReader.ReadByte(buffer, ref offset);
ushort cbHeader = LittleEndianReader.ReadUInt16(buffer, ref offset);
Reserved = LittleEndianReader.ReadUInt16(buffer, ref offset);
ushort cchKeyName = LittleEndianReader.ReadUInt16(buffer, ref offset);
KeyName = ByteReader.ReadUTF16String(buffer, ref offset, cchKeyName);
ushort cRules = LittleEndianReader.ReadUInt16(buffer, ref offset);
TZRules = new TimeZoneRuleStructure[cRules];
for (int index = 0; index < cRules; index++)
{
TZRules[index] = new TimeZoneRuleStructure(buffer, offset);
offset += TimeZoneRuleStructure.Length;
}
}
/// <remarks>
/// The USN will be written at the end of each 512-byte stride, even if the device has more (or less) than 512 bytes per sector.
/// https://docs.microsoft.com/en-us/windows/desktop/DevNotes/multi-sector-header
/// </remarks>
public static void RevertUsaProtection(byte[] buffer, int offset)
{
MultiSectorHeader multiSectorHeader = new MultiSectorHeader(buffer, offset + 0x00);
int position = offset + multiSectorHeader.UpdateSequenceArrayOffset;
uint updateSequenceNumber = LittleEndianReader.ReadUInt16(buffer, ref position);
// First do validation check - make sure the USN matches on all sectors)
for (int index = 0; index < multiSectorHeader.UpdateSequenceArraySize - 1; ++index)
{
if (updateSequenceNumber != LittleEndianConverter.ToUInt16(buffer, offset + (BytesPerStride * (index + 1)) - 2))
{
throw new InvalidDataException("Corrupt multi-sector transfer, USN does not match MultiSectorHeader");
}
}
for (int index = 0; index < multiSectorHeader.UpdateSequenceArraySize - 1; index++)
{
byte[] endOfSectorBytes = ByteReader.ReadBytes(buffer, ref position, 2);
ByteWriter.WriteBytes(buffer, offset + (BytesPerStride * (index + 1)) - 2, endOfSectorBytes);
}
}
public DirtyPageEntry(byte[] buffer, int offset, uint majorVersion)
{
m_majorVersion = majorVersion;
AllocatedOrNextFree = LittleEndianReader.ReadUInt32(buffer, ref offset);
TargetAttributeOffset = LittleEndianReader.ReadUInt32(buffer, ref offset);
LengthOfTransfer = LittleEndianReader.ReadUInt32(buffer, ref offset);
uint lcnsToFollow = LittleEndianReader.ReadUInt32(buffer, ref offset);
if (majorVersion == 0)
{
Reserved = LittleEndianReader.ReadUInt32(buffer, ref offset);
}
VCN = (long)LittleEndianReader.ReadUInt64(buffer, ref offset);
OldestLsn = LittleEndianReader.ReadUInt64(buffer, ref offset);
for (int index = 0; index < lcnsToFollow; index++)
{
long lcn = (long)LittleEndianReader.ReadUInt64(buffer, ref offset);
LCNsForPage.Add(lcn);
}
}
public FindFileBothDirectoryInfo(byte[] buffer, ref int offset, bool isUnicode) : base(false)
{
NextEntryOffset = LittleEndianReader.ReadUInt32(buffer, ref offset);
FileIndex = LittleEndianReader.ReadUInt32(buffer, ref offset);
CreationTime = FileTimeHelper.ReadNullableFileTime(buffer, ref offset);
LastAccessTime = FileTimeHelper.ReadNullableFileTime(buffer, ref offset);
LastWriteTime = FileTimeHelper.ReadNullableFileTime(buffer, ref offset);
LastChangeTime = FileTimeHelper.ReadNullableFileTime(buffer, ref offset);
EndOfFile = LittleEndianReader.ReadInt64(buffer, ref offset);
AllocationSize = LittleEndianReader.ReadInt64(buffer, ref offset);
ExtFileAttributes = (ExtendedFileAttributes)LittleEndianReader.ReadUInt32(buffer, ref offset);
uint fileNameLength = LittleEndianReader.ReadUInt32(buffer, ref offset);
EASize = LittleEndianReader.ReadUInt32(buffer, ref offset);
byte shortNameLength = ByteReader.ReadByte(buffer, ref offset);
Reserved = ByteReader.ReadByte(buffer, ref offset);
ShortName = ByteReader.ReadUTF16String(buffer, ref offset, 12);
ShortName = ShortName.Substring(0, shortNameLength);
FileName = SMB1Helper.ReadFixedLengthString(buffer, ref offset, isUnicode, (int)fileNameLength);
}
public OpenAndXRequest(byte[] buffer, int offset, bool isUnicode) : base(buffer, offset, isUnicode)
{
int parametersOffset = 4;
Flags = (OpenFlags)LittleEndianReader.ReadUInt16(this.SMBParameters, ref parametersOffset);
AccessMode = AccessModeOptions.Read(this.SMBParameters, ref parametersOffset);
SearchAttrs = (SMBFileAttributes)LittleEndianReader.ReadUInt16(this.SMBParameters, ref parametersOffset);
FileAttrs = (SMBFileAttributes)LittleEndianReader.ReadUInt16(this.SMBParameters, ref parametersOffset);
CreationTime = UTimeHelper.ReadNullableUTime(this.SMBParameters, ref parametersOffset);
OpenMode = OpenMode.Read(this.SMBParameters, ref parametersOffset);
AllocationSize = LittleEndianReader.ReadUInt32(this.SMBParameters, ref parametersOffset);
Timeout = LittleEndianReader.ReadUInt32(this.SMBParameters, ref parametersOffset);
Reserved = LittleEndianReader.ReadUInt32(this.SMBParameters, ref parametersOffset);
int dataOffset = 0;
if (isUnicode)
{
dataOffset = 1; // 1 byte padding for 2 byte alignment
}
FileName = SMB1Helper.ReadSMBString(this.SMBData, dataOffset, isUnicode);
}
public NTCreateAndXResponseExtended(byte[] buffer, int offset) : base(buffer, offset, false)
{
int parametersOffset = 4;
OpLockLevel = (OpLockLevel)ByteReader.ReadByte(this.SMBParameters, ref parametersOffset);
FID = LittleEndianReader.ReadUInt16(this.SMBParameters, ref parametersOffset);
CreateDisposition = (CreateDisposition)LittleEndianReader.ReadUInt32(this.SMBParameters, ref parametersOffset);
CreateTime = FileTimeHelper.ReadNullableFileTime(this.SMBParameters, ref parametersOffset);
LastAccessTime = FileTimeHelper.ReadNullableFileTime(this.SMBParameters, ref parametersOffset);
LastWriteTime = FileTimeHelper.ReadNullableFileTime(this.SMBParameters, ref parametersOffset);
LastChangeTime = FileTimeHelper.ReadNullableFileTime(this.SMBParameters, ref parametersOffset);
ExtFileAttributes = (ExtendedFileAttributes)LittleEndianReader.ReadUInt32(this.SMBParameters, ref parametersOffset);
AllocationSize = LittleEndianReader.ReadInt64(this.SMBParameters, ref parametersOffset);
EndOfFile = LittleEndianReader.ReadInt64(this.SMBParameters, ref parametersOffset);
ResourceType = (ResourceType)LittleEndianReader.ReadUInt16(this.SMBParameters, ref parametersOffset);
NMPipeStatus_or_FileStatusFlags = LittleEndianReader.ReadUInt16(this.SMBParameters, ref parametersOffset);
Directory = (ByteReader.ReadByte(this.SMBParameters, ref parametersOffset) > 0);
VolumeGuid = LittleEndianReader.ReadGuid(this.SMBParameters, ref parametersOffset);
FileID = LittleEndianReader.ReadUInt64(this.SMBParameters, ref parametersOffset);
MaximalAccessRights = (AccessMask)LittleEndianReader.ReadUInt32(this.SMBParameters, ref parametersOffset);
GuestMaximalAccessRights = (AccessMask)LittleEndianReader.ReadUInt32(this.SMBParameters, ref parametersOffset);
}
public TreeConnectAndXRequest(byte[] buffer, int offset, bool isUnicode) : base(buffer, offset)
{
int parametersOffset = 4;
Flags = (TreeConnectFlags)LittleEndianReader.ReadUInt16(SMBParameters, ref parametersOffset);
ushort passwordLength = LittleEndianReader.ReadUInt16(SMBParameters, ref parametersOffset);
int dataOffset = 0;
Password = ByteReader.ReadBytes(SMBData, ref dataOffset, passwordLength);
if (isUnicode)
{
// wordCount is 1 byte
int padding = (1 + passwordLength) % 2;
dataOffset += padding;
}
Path = SMB1Helper.ReadSMBString(SMBData, ref dataOffset, isUnicode);
// Should be read as OEM string but it doesn't really matter
string serviceString = ByteReader.ReadNullTerminatedAnsiString(SMBData, ref dataOffset);
Service = ServiceNameHelper.GetServiceName(serviceString);
}