public static MessageObject CreateNewMessage(PSTFile file, FolderItemTypeName folderItemType, NodeID parentNodeID, Guid searchKey) { // [MS-PST] The following properties must be present in any valid Message object PC: PropertyContext pc = PropertyContext.CreateNewPropertyContext(file); pc.SetStringProperty(PropertyID.PidTagMessageClass, GetMessageClass(folderItemType)); pc.SetInt32Property(PropertyID.PidTagMessageFlags, 0); pc.SetInt32Property(PropertyID.PidTagMessageStatus, 0); pc.SetDateTimeProperty(PropertyID.PidTagCreationTime, DateTime.UtcNow); pc.SetDateTimeProperty(PropertyID.PidTagLastModificationTime, DateTime.UtcNow); pc.SetDateTimeProperty(PropertyID.PidTagClientSubmitTime, DateTime.UtcNow); pc.SetDateTimeProperty(PropertyID.PidTagMessageDeliveryTime, DateTime.UtcNow); byte[] conversationIndex = ConversationIndexHeader.GenerateNewConversationIndex().GetBytes(); pc.SetBytesProperty(PropertyID.PidTagConversationIndex, conversationIndex); // PidTagSearchKey is apparently a GUID pc.SetBytesProperty(PropertyID.PidTagSearchKey, LittleEndianConverter.GetBytes(searchKey)); pc.SaveChanges(); NodeID pcNodeID = file.Header.AllocateNextNodeID(NodeTypeName.NID_TYPE_NORMAL_MESSAGE); file.NodeBTree.InsertNodeEntry(pcNodeID, pc.DataTree, pc.SubnodeBTree, parentNodeID); // NOTE: According to [MS-PST], A Recipient Table MUST exist for any Message object, // However, in practice even outlook itself does not always create it. PSTNode pcNode = new PSTNode(file, pcNodeID, pc.DataTree, pc.SubnodeBTree); MessageObject message = new MessageObject(pcNode); return(message); }
public override void Write(EndianReader stream) { stream.Write(Type); stream.Write((ushort)Nodes.Count); byte[] data; switch (stream.Endian) { case Endianness.BigEndian: data = BigEndianConverter.GetBytes(ID); break; case Endianness.LittleEndian: data = LittleEndianConverter.GetBytes(ID); break; default: throw new NotImplementedException(); } stream.Write(data, 0, 2); stream.Write(data, 2, 2); foreach (Node node in Nodes) { node.Write(stream); } }
public byte[] GetBytes() { byte[] buffer = new byte[BytesPerSector]; Array.Copy(Jump, 0, buffer, 0x00, 3); Array.Copy(ASCIIEncoding.ASCII.GetBytes(OEMID), 0, buffer, 0x03, Math.Min(8, OEMID.Length)); Array.Copy(LittleEndianConverter.GetBytes(BytesPerSector), 0, buffer, 0x0B, 2); buffer[0x0D] = SectorsPerCluster; buffer[0x15] = MediaDescriptor; Array.Copy(LittleEndianConverter.GetBytes(SectorsPerTrack), 0, buffer, 0x18, 2); Array.Copy(LittleEndianConverter.GetBytes(NumberOfHeads), 0, buffer, 0x1A, 2); Array.Copy(LittleEndianConverter.GetBytes(NumberOfHiddenSectors), 0, buffer, 0x1C, 4); buffer[0x24] = PhysicalDriveNumber; buffer[0x26] = ExtendedBootSignature; Array.Copy(LittleEndianConverter.GetBytes(TotalSectors), 0, buffer, 0x28, 8); Array.Copy(LittleEndianConverter.GetBytes(MftStartLCN), 0, buffer, 0x30, 8); Array.Copy(LittleEndianConverter.GetBytes(MftMirrorStartLCN), 0, buffer, 0x38, 8); buffer[0x40] = (byte)RawClustersPerFileRecordSegment; buffer[0x44] = (byte)RawClustersPerIndexBlock; Array.Copy(LittleEndianConverter.GetBytes(VolumeSerialNumber), 0, buffer, 0x48, 8); Array.Copy(LittleEndianConverter.GetBytes(Checksum), 0, buffer, 0x50, 4); Array.Copy(Code, 0, buffer, 0x54, Code.Length); return(buffer); }
public void SetDateTimeProperty(PropertyID propertyID, DateTime value) { // We write as UTC to avoid conversion when using ToFileTimeUtc() value = DateTime.SpecifyKind(value, DateTimeKind.Utc); byte[] propertyBytes = LittleEndianConverter.GetBytes(value.ToFileTimeUtc()); SetExternalProperty(propertyID, PropertyTypeName.PtypTime, propertyBytes); }
public void Save(byte[] buffer, int offset) { Debug.Assert(buffer.Length - offset >= GetSaveLength()); LittleEndianConverter.GetBytes(buffer, offset, ContentLength); LittleEndianConverter.GetBytes(buffer, offset + 4, ContentOffset); }
public PropertyContextRecord GetRecordByPropertyID(PropertyID propertyID) { byte[] key = LittleEndianConverter.GetBytes((ushort)propertyID); PropertyContextRecord record = FindRecord(key); return(record); }
public void SetInt64Property(int rowIndex, PropertyID propertyID, long value) { int columnIndex = GetColumnIndexByPropertyTag(propertyID, PropertyTypeName.PtypInteger64); byte[] cellBytes = LittleEndianConverter.GetBytes(value); SetPropertyValue(rowIndex, columnIndex, cellBytes); }
/// <param name="cellBytes">If property is external, byte[0] means empty data item</param> public void SetPropertyValue(int rowIndex, int columnIndex, byte[] propertyBytes) { TableColumnDescriptor columnDescriptor = m_tcInfo.rgTCOLDESC[columnIndex]; if (columnDescriptor.IsStoredExternally) { byte[] cellBytes = GetInternalCellBytes(rowIndex, columnIndex); HeapOrNodeID heapOrNodeID; if (cellBytes != null) { heapOrNodeID = new HeapOrNodeID(cellBytes); } else { heapOrNodeID = new HeapOrNodeID(HeapID.EmptyHeapID); } HeapOrNodeID newHeapOrNodeID = NodeStorageHelper.StoreExternalProperty(this.File, m_heap, ref m_subnodeBTree, heapOrNodeID, propertyBytes); // we call SetInternalCellBytes even when oldHeapID.Value == newHeapID.Value, // this will make sure the CEB will be updated SetInternalCellBytes(rowIndex, columnIndex, LittleEndianConverter.GetBytes(newHeapOrNodeID.Value)); } else { SetInternalCellBytes(rowIndex, columnIndex, propertyBytes); } }
public static bool TestCrc16Ccitt_1() { byte[] buffer = new byte[] { 0x06 }; byte[] checksum = new byte[] { 0x4E, 0x95 }; byte[] result = LittleEndianConverter.GetBytes(Crc16Ccitt.ComputeChecksum(buffer)); return(ByteUtils.AreByteArraysEqual(checksum, result)); }
public static bool TestCrc16Ccitt_2() { byte[] buffer = new byte[] { 0x0d, 0x0f, 0x50, 0x42, 0x4c, 0x5f, 0x44, 0x6c, 0x6f, 0x61, 0x64, 0x56, 0x45, 0x52, 0x31, 0x2e, 0x30 }; byte[] checksum = new byte[] { 0x37, 0x41 }; byte[] result = LittleEndianConverter.GetBytes(Crc16Ccitt.ComputeChecksum(buffer)); return(ByteUtils.AreByteArraysEqual(checksum, result)); }
public void AddRecipient(PSTFile file, string displayName, string emailAddress, bool isOrganizer) { // http://social.msdn.microsoft.com/Forums/en-US/os_binaryfile/thread/a5f9c653-40f5-4638-85d3-00c54607d984/ // dwRowID must be > 0: uint rowID = (uint)RowCount + 1; // good enough for now int rowIndex = AddRow(rowID); SetStringProperty(rowIndex, PropertyID.PidTagDisplayName, displayName); SetStringProperty(rowIndex, PropertyID.PidTagAddressType, "SMTP"); SetStringProperty(rowIndex, PropertyID.PidTagEmailAddress, emailAddress); SetBytesProperty(rowIndex, PropertyID.PidTagSearchKey, LittleEndianConverter.GetBytes(Guid.NewGuid())); SetInt32Property(rowIndex, PropertyID.PidTagRecipientType, (int)RecipientType.To); SetInt32Property(rowIndex, PropertyID.PidTagObjectType, (int)ObjectType.MailUser); SetInt32Property(rowIndex, PropertyID.PidTagDisplayType, 0); SetStringProperty(rowIndex, PropertyID.PidTagRecipientDisplayName, displayName); int recipientFlags = (int)RecipientFlags.SendableAttendee; if (isOrganizer) { recipientFlags |= (int)RecipientFlags.MeetingOrganizer; } SetInt32Property(rowIndex, PropertyID.PidTagRecipientFlags, recipientFlags); SetInt32Property(rowIndex, PropertyID.PidTagRecipientTrackStatus, 0); byte[] recipientEntryID = RecipientEntryID.GetEntryID(displayName, emailAddress).GetBytes(); SetBytesProperty(rowIndex, PropertyID.PidTagEntryId, recipientEntryID); SetBytesProperty(rowIndex, PropertyID.PidTagRecipientEntryId, recipientEntryID); SetInt32Property(rowIndex, PropertyID.PidTagLtpRowId, (int)rowID); SetInt32Property(rowIndex, PropertyID.PidTagLtpRowVer, (int)file.Header.AllocateNextUniqueID()); }
public void WriteKey(int key) { Stream.Position = 0; Key = key; this.key = key; Stream.Write(LittleEndianConverter.GetBytes(key), 0, 4); Offset = 0; }
public void Save(byte[] stream, int offset) { if (stream.Length - offset < 8) { throw new Exception("Error!\n"); } LittleEndianConverter.GetBytes(stream, offset, ValueLength); LittleEndianConverter.GetBytes(stream, offset + 4, ValueOffset); }
private void DeleteLastRowFromRowIndex() { uint rowID = m_rowIndex[m_rowIndex.Count - 1].dwRowID; m_rowIndex.RemoveAt(m_rowIndex.Count - 1); BTreeOnHeap <TableContextRowID> bTreeOnHeap = new BTreeOnHeap <TableContextRowID>(m_heap, m_tcInfo.hidRowIndex); bTreeOnHeap.RemoveRecord(LittleEndianConverter.GetBytes(rowID)); }
public void SetDateTimeProperty(int rowIndex, PropertyID propertyID, DateTime value) { if (value.Kind != DateTimeKind.Utc) { throw new InvalidPropertyException("DateTime must be in UTC"); } int columnIndex = GetColumnIndexByPropertyTag(propertyID, PropertyTypeName.PtypTime); byte[] cellBytes = LittleEndianConverter.GetBytes(value.ToFileTimeUtc()); SetPropertyValue(rowIndex, columnIndex, cellBytes); }
public byte[] GetBytes() { byte[] sequenceBytes = AVPairUtils.GetAVPairSequenceBytes(AVPairs); byte[] timeBytes = LittleEndianConverter.GetBytes((ulong)Time.ToFileTimeUtc()); byte[] buffer = new byte[28 + sequenceBytes.Length]; ByteWriter.WriteByte(buffer, 0, ResponseVersion); ByteWriter.WriteByte(buffer, 1, ResponseVersionHigh); ByteWriter.WriteBytes(buffer, 8, timeBytes); ByteWriter.WriteBytes(buffer, 16, ClientChallenge, 8); ByteWriter.WriteBytes(buffer, 28, sequenceBytes); return(buffer); }
public void TestUInt() { uint[] specials = new uint[] { uint.MinValue, 1, uint.MaxValue }; foreach (uint special in specials) { byte[] buffA = new byte[4]; LittleEndianConverter.GetBytes(buffA, 0, special); byte[] buffB = BitConverter.GetBytes(special); Assert.IsTrue(buffA.SequenceEqual(buffB)); } }
public void TestShort() { short[] specials = new short[] { short.MinValue, -1, 0, 1, short.MaxValue }; foreach (short special in specials) { byte[] buffA = new byte[2]; LittleEndianConverter.GetBytes(buffA, 0, special); byte[] buffB = BitConverter.GetBytes(special); Assert.IsTrue(buffA.SequenceEqual(buffB)); } }
public void TestULong() { ulong[] specials = new ulong[] { ulong.MinValue, 1, ulong.MaxValue }; foreach (ulong special in specials) { byte[] buffA = new byte[8]; LittleEndianConverter.GetBytes(buffA, 0, special); byte[] buffB = BitConverter.GetBytes(special); Assert.IsTrue(buffA.SequenceEqual(buffB)); } }
public static ModifiedAppointmentInstance CreateNewModifiedInstance(PSTFile file, SubnodeBTree attachmentSubnodeBTree) { PropertyContext pc = PropertyContext.CreateNewPropertyContext(file); pc.SetStringProperty(PropertyID.PidTagMessageClass, RecurringAppointmentExceptionMessageClass); pc.SetDateTimeProperty(PropertyID.PidTagCreationTime, DateTime.UtcNow); pc.SetDateTimeProperty(PropertyID.PidTagLastModificationTime, DateTime.UtcNow); // PidTagSearchKey is apparently a GUID pc.SetBytesProperty(PropertyID.PidTagSearchKey, LittleEndianConverter.GetBytes(Guid.NewGuid())); pc.SaveChanges(); NodeID subnodeID = file.Header.AllocateNextNodeID(NodeTypeName.NID_TYPE_NORMAL_MESSAGE); attachmentSubnodeBTree.InsertSubnodeEntry(subnodeID, pc.DataTree, pc.SubnodeBTree); Subnode subnode = new Subnode(file, subnodeID, pc.DataTree, pc.SubnodeBTree); return(new ModifiedAppointmentInstance(subnode)); }
public Nullable <float> GetFloat32Property(PropertyID propertyID) { PropertyContextRecord record = GetRecordByPropertyID(propertyID); if (record != null) { if (record.wPropType == PropertyTypeName.PtypFloating32) { byte[] bytes = LittleEndianConverter.GetBytes(record.dwValueHnid); return(LittleEndianConverter.ToFloat32(bytes, 0)); } else { throw new InvalidPropertyException("Unexpected PC data type found"); } } else { return(null); } }
public virtual void Save(byte[] buffer, int offset) { throw new NotImplementedException(); // Debug.Assert(buffer.Length - offset >= GetSaveLength()); // Debug.Assert(offset >= 0); LittleEndianConverter.GetBytes(buffer, offset, (uint)Type); if (Type == AttributeType.EndOfAttributes) { return; } LittleEndianConverter.GetBytes(buffer, offset + 4, TotalLength); LittleEndianConverter.GetBytes(buffer, offset + 8, (byte)NonResidentFlag); LittleEndianConverter.GetBytes(buffer, offset + 9, NameLength); LittleEndianConverter.GetBytes(buffer, offset + 10, OffsetToName); LittleEndianConverter.GetBytes(buffer, offset + 12, (ushort)Flags); LittleEndianConverter.GetBytes(buffer, offset + 14, Id); if (NameLength != 0) { byte[] stringData = Encoding.Unicode.GetBytes(AttributeName); // Debug.Assert(NameLength * 2 == stringData.Length); Array.Copy(stringData, 0, buffer, offset + OffsetToName, stringData.Length); } // Header if (NonResidentFlag == ResidentFlag.NonResident) { NonResidentHeader.Save(buffer, offset + 16); } else if (NonResidentFlag == ResidentFlag.Resident) { ResidentHeader.Save(buffer, offset + 16); } }
public override void Save(byte[] buffer, int offset) { base.Save(buffer, offset); LittleEndianConverter.GetBytes(buffer, offset, CreationTime); LittleEndianConverter.GetBytes(buffer, offset + 8, ModifiedTime); LittleEndianConverter.GetBytes(buffer, offset + 16, MFTChangeTime); LittleEndianConverter.GetBytes(buffer, offset + 24, AccessTime); LittleEndianConverter.GetBytes(buffer, offset + 32, (int)DosPermissions); LittleEndianConverter.GetBytes(buffer, offset + 36, MaxNumberVersions); LittleEndianConverter.GetBytes(buffer, offset + 40, VersionNumber); LittleEndianConverter.GetBytes(buffer, offset + 44, ClassId); if (OwnerId != 0 || SecurityId != 0 || QuotaCharge != 0 || USN != 0) { LittleEndianConverter.GetBytes(buffer, offset + 48, OwnerId); LittleEndianConverter.GetBytes(buffer, offset + 52, SecurityId); LittleEndianConverter.GetBytes(buffer, offset + 56, QuotaCharge); LittleEndianConverter.GetBytes(buffer, offset + 64, USN); } }
public static List <byte[]> EncodeSegmentBuffer(byte[] buffer, int offset, int segmentLength, ushort updateSequenceNumber) { int numberOfStrides = segmentLength / BytesPerStride; List <byte[]> updateSequenceReplacementData = new List <byte[]>(); // Read in the bytes that are replaced by the USN for (int i = 0; i < numberOfStrides; i++) { byte[] endOfSectorBytes = new byte[2]; endOfSectorBytes[0] = buffer[offset + (BytesPerStride * (i + 1)) - 2]; endOfSectorBytes[1] = buffer[offset + (BytesPerStride * (i + 1)) - 2]; updateSequenceReplacementData.Add(endOfSectorBytes); } // Overwrite the bytes that are replaced with the USN for (int i = 0; i < updateSequenceReplacementData.Count; i++) { Array.Copy(LittleEndianConverter.GetBytes(updateSequenceNumber), 0, buffer, offset + (BytesPerStride * (i + 1)) - 2, 2); } return(updateSequenceReplacementData); }
public override void Save(byte[] buffer, int offset) { base.Save(buffer, offset); LittleEndianConverter.GetBytes(buffer, offset, TimeCreated); LittleEndianConverter.GetBytes(buffer, offset + 8, TimeModified); LittleEndianConverter.GetBytes(buffer, offset + 16, TimeMftModified); LittleEndianConverter.GetBytes(buffer, offset + 24, TimeAccessed); LittleEndianConverter.GetBytes(buffer, offset + 32, (int)DosPermissions); LittleEndianConverter.GetBytes(buffer, offset + 36, MaxmiumVersions); LittleEndianConverter.GetBytes(buffer, offset + 40, VersionNumber); LittleEndianConverter.GetBytes(buffer, offset + 44, ClassId); // TODO: Get the actual NTFS Version in here to check against if (OwnerId != 0 || SecurityId != 0 || QuotaCharged != 0 || USN != 0) { LittleEndianConverter.GetBytes(buffer, offset + 48, OwnerId); LittleEndianConverter.GetBytes(buffer, offset + 52, SecurityId); LittleEndianConverter.GetBytes(buffer, offset + 56, QuotaCharged); LittleEndianConverter.GetBytes(buffer, offset + 64, USN); } }
public void Save(byte[] buffer, int offset) { Debug.Assert(buffer.Length - offset >= GetSaveLength()); LittleEndianConverter.GetBytes(buffer, offset, StartingVCN); LittleEndianConverter.GetBytes(buffer, offset + 8, EndingVCN); LittleEndianConverter.GetBytes(buffer, offset + 16, ListOffset); LittleEndianConverter.GetBytes(buffer, offset + 18, CompressionUnitSize); LittleEndianConverter.GetBytes(buffer, offset + 24, ContentSizeAllocated); LittleEndianConverter.GetBytes(buffer, offset + 32, ContentSize); LittleEndianConverter.GetBytes(buffer, offset + 40, ContentSizeInitialized); if (CompressionUnitSize != 0) { LittleEndianConverter.GetBytes(buffer, offset + 48, ContentSizeCompressed); } if (Fragments != null) { int pointer = ContentSizeCompressed != 0 ? 56 : 48; DataFragment.Save(buffer, pointer, Fragments); } }
public override byte[] GetSetup() { return(LittleEndianConverter.GetBytes((ushort)SubcommandName)); }
/// <summary> /// Get file record end marker /// </summary> public static byte[] GetEndMarker() { byte[] buffer = new byte[4]; Array.Copy(LittleEndianConverter.GetBytes(0xFFFFFFFF), buffer, 4); return(buffer); }
public override byte[] GetParameters(bool isUnicode) { return(LittleEndianConverter.GetBytes((ushort)PipeState)); }
internal static SMB2Command GetQueryInfoResponse(QueryInfoRequest request, ISMBShare share, SMB2ConnectionState state) { SMB2Session session = state.GetSession(request.Header.SessionID); if (request.InfoType == InfoType.File) { OpenFileObject openFile = session.GetOpenFileObject(request.FileId); if (openFile == null) { state.LogToServer(Severity.Verbose, "GetFileInformation failed. Invalid FileId. (SessionID: {0}, TreeID: {1}, FileId: {2})", request.Header.SessionID, request.Header.TreeID, request.FileId.Volatile); return(new ErrorResponse(request.CommandName, NTStatus.STATUS_FILE_CLOSED)); } if (share is FileSystemShare) { if (!((FileSystemShare)share).HasReadAccess(session.SecurityContext, openFile.Path)) { state.LogToServer(Severity.Verbose, "GetFileInformation on '{0}{1}' failed. User '{2}' was denied access.", share.Name, openFile.Path, session.UserName); return(new ErrorResponse(request.CommandName, NTStatus.STATUS_ACCESS_DENIED)); } } FileInformation fileInformation; NTStatus queryStatus = share.FileStore.GetFileInformation(out fileInformation, openFile.Handle, request.FileInformationClass); if (queryStatus != NTStatus.STATUS_SUCCESS) { state.LogToServer(Severity.Verbose, "GetFileInformation on '{0}{1}' failed. Information class: {2}, NTStatus: {3}. (FileId: {4})", share.Name, openFile.Path, request.FileInformationClass, queryStatus, request.FileId.Volatile); return(new ErrorResponse(request.CommandName, queryStatus)); } state.LogToServer(Severity.Information, "GetFileInformation on '{0}{1}' succeeded. Information class: {2}. (FileId: {3})", share.Name, openFile.Path, request.FileInformationClass, request.FileId.Volatile); QueryInfoResponse response = new QueryInfoResponse(); response.SetFileInformation(fileInformation); return(response); } else if (request.InfoType == InfoType.FileSystem) { if (share is FileSystemShare) { if (!((FileSystemShare)share).HasReadAccess(session.SecurityContext, @"\")) { state.LogToServer(Severity.Verbose, "GetFileSystemInformation on '{0}' failed. User '{1}' was denied access.", share.Name, session.UserName); return(new ErrorResponse(request.CommandName, NTStatus.STATUS_ACCESS_DENIED)); } FileSystemInformation fileSystemInformation; NTStatus queryStatus = share.FileStore.GetFileSystemInformation(out fileSystemInformation, request.FileSystemInformationClass); if (queryStatus != NTStatus.STATUS_SUCCESS) { state.LogToServer(Severity.Verbose, "GetFileSystemInformation on '{0}' failed. Information class: {1}, NTStatus: {2}", share.Name, request.FileSystemInformationClass, queryStatus); return(new ErrorResponse(request.CommandName, queryStatus)); } state.LogToServer(Severity.Information, "GetFileSystemInformation on '{0}' succeeded. Information class: {1}", share.Name, request.FileSystemInformationClass); QueryInfoResponse response = new QueryInfoResponse(); response.SetFileSystemInformation(fileSystemInformation); return(response); } } else if (request.InfoType == InfoType.Security) { OpenFileObject openFile = session.GetOpenFileObject(request.FileId); if (openFile == null) { state.LogToServer(Severity.Verbose, "GetSecurityInformation failed. Invalid FileId. (SessionID: {0}, TreeID: {1}, FileId: {2})", request.Header.SessionID, request.Header.TreeID, request.FileId.Volatile); return(new ErrorResponse(request.CommandName, NTStatus.STATUS_FILE_CLOSED)); } if (share is FileSystemShare) { if (!((FileSystemShare)share).HasReadAccess(session.SecurityContext, openFile.Path)) { state.LogToServer(Severity.Verbose, "GetSecurityInformation on '{0}{1}' failed. User '{2}' was denied access.", share.Name, openFile.Path, session.UserName); return(new ErrorResponse(request.CommandName, NTStatus.STATUS_ACCESS_DENIED)); } } SecurityDescriptor securityDescriptor; NTStatus queryStatus = share.FileStore.GetSecurityInformation(out securityDescriptor, openFile.Handle, request.SecurityInformation); if (queryStatus != NTStatus.STATUS_SUCCESS) { state.LogToServer(Severity.Verbose, "GetSecurityInformation on '{0}{1}' failed. Security information: 0x{2}, NTStatus: {3}. (FileId: {4})", share.Name, openFile.Path, request.SecurityInformation.ToString("X"), queryStatus, request.FileId.Volatile); return(new ErrorResponse(request.CommandName, queryStatus)); } if (securityDescriptor.Length > request.OutputBufferLength) { state.LogToServer(Severity.Information, "GetSecurityInformation on '{0}{1}' failed. Security information: 0x{2}, NTStatus: STATUS_BUFFER_TOO_SMALL. (FileId: {3})", share.Name, openFile.Path, request.SecurityInformation.ToString("X"), request.FileId.Volatile); byte[] errorData = LittleEndianConverter.GetBytes((uint)securityDescriptor.Length); return(new ErrorResponse(request.CommandName, NTStatus.STATUS_BUFFER_TOO_SMALL, errorData)); } state.LogToServer(Severity.Information, "GetSecurityInformation on '{0}{1}' succeeded. Security information: 0x{2}. (FileId: {3})", share.Name, openFile.Path, request.SecurityInformation.ToString("X"), request.FileId.Volatile); QueryInfoResponse response = new QueryInfoResponse(); response.SetSecurityInformation(securityDescriptor); return(response); } return(new ErrorResponse(request.CommandName, NTStatus.STATUS_NOT_SUPPORTED)); }