/// <summary> /// TRANS2_SET_FS_INFORMATION Request. /// </summary> /// <param name="messageId">This is used to associate a response with a request.</param> /// <param name="sessionId"> /// Set this value to 0 to request a new session setup, or set this value to a previously established session /// identifier to request reauthenticate to an existing session. /// </param> /// <param name="treeId"> /// This field identifies the subdirectory (or tree) (also referred as a share in this document) on the /// server that the client is accessing. /// </param> /// <param name="isSigned"> /// Indicate whether the SUT has message signing enabled or required. /// </param> /// <param name="isUsePassthrough"> /// Indicate whether adding SMB_INFO_PASSTHROUGH in InformationLevel field of the request. /// </param> /// <param name="isRequireDisconnectTreeFlags">Indicate whether flags set to Disconnect_TID.</param> /// <param name="isRequireNoResponseFlags">Indicate whether flags set to NO_RESPONSE.</param> /// <param name="informationLevel">This can be used to query information from the server.</param> /// <param name="fid">The file identifier.</param> /// <param name="otherBits">If it contains other bits.</param> /// <param name="reserved">The reserved int value.</param> public void Trans2SetFsInfoRequest( int messageId, int sessionId, int treeId, bool isSigned, bool isUsePassthrough, bool isRequireDisconnectTreeFlags, bool isRequireNoResponseFlags, InformationLevel informationLevel, int fid, bool otherBits, int reserved) { #region Create Packet SmbTrans2SetFsInformationRequestPacket smbPacket = new SmbTrans2SetFsInformationRequestPacket(); ushort uid = (ushort)this.uId[(uint)sessionId]; ushort fileId = (ushort)this.fId[(uint)fid]; NamespaceCifs.Trans2SmbParametersFlags transactOptions = NamespaceCifs.Trans2SmbParametersFlags.NONE; if (isRequireDisconnectTreeFlags && isRequireNoResponseFlags) { transactOptions = NamespaceCifs.Trans2SmbParametersFlags.DISCONNECT_TID | NamespaceCifs.Trans2SmbParametersFlags.NO_RESPONSE; } if (isRequireDisconnectTreeFlags && !isRequireNoResponseFlags) { transactOptions = NamespaceCifs.Trans2SmbParametersFlags.DISCONNECT_TID; } if (!isRequireDisconnectTreeFlags && isRequireNoResponseFlags) { transactOptions = NamespaceCifs.Trans2SmbParametersFlags.NO_RESPONSE; } if (!isRequireDisconnectTreeFlags && !isRequireNoResponseFlags) { transactOptions = NamespaceCifs.Trans2SmbParametersFlags.NONE; } ushort level = this.informationLevelBytes[(ushort)informationLevel]; if (isUsePassthrough) { level += InformationLevelPathThrouth; } // FILE_FS_CONTROL_INFORMATION data NamespaceFscc.FileFsControlInformation fileFsControlInformation = new NamespaceFscc.FileFsControlInformation(); fileFsControlInformation.DefaultQuotaLimit = uint.MinValue; fileFsControlInformation.DefaultQuotaThreshold = uint.MinValue; fileFsControlInformation.FileSystemControlFlags = NamespaceFscc.FileSystemControlFlags_Values.FILE_VC_LOG_QUOTA_LIMIT; fileFsControlInformation.FreeSpaceStartFiltering = uint.MinValue; fileFsControlInformation.FreeSpaceStopFiltering = uint.MinValue; fileFsControlInformation.FreeSpaceThreshold = uint.MinValue; NamespaceFscc.FsccFileFsControlInformationRequestPacket fsControlPacket = new NamespaceFscc.FsccFileFsControlInformationRequestPacket(); fsControlPacket.Payload = fileFsControlInformation; byte[] data = new byte[DataCount]; data = fsControlPacket.ToBytes(); smbPacket = this.smbClientStack.CreateTrans2SetFileSystemInformationRequest( fileId, transactOptions, (NamespaceCifs.QueryFSInformationLevel)level, data); NamespaceCifs.SMB_COM_TRANSACTION2_Request_SMB_Parameters smbParameters = smbPacket.SmbParameters; smbParameters.DataCount = DataCount; smbPacket.SmbParameters = smbParameters; if (isSigned) { NamespaceCifs.CifsClientPerConnection connection = this.smbClientStack.Context.GetConnection(ConnectionId); NamespaceCifs.CifsClientPerSession session = this.smbClientStack.Context.GetSession(ConnectionId, uid); smbPacket.Sign(connection.ClientNextSendSequenceNumber, session.SessionKey); } #endregion #region Send and Receive ExpectPacket this.smbClientStack.SendPacket(smbPacket); StackPacket response = this.smbClientStack.ExpectPacket(this.timeout); NamespaceCifs.SmbPacket smbPacketResponse = (NamespaceCifs.SmbPacket)response; this.QueryUidTable(smbPacketResponse); this.QueryTidTable(smbPacketResponse); VerifyTransport(smbPacketResponse); VerifyCommonMessageSyntax(smbPacketResponse); if (response.GetType() == typeof(SmbErrorResponsePacket)) { SmbErrorResponsePacket smbErrorResponsePacket = response as SmbErrorResponsePacket; NamespaceCifs.SmbHeader smbErrorHeader = smbErrorResponsePacket.SmbHeader; if (smbErrorHeader.Status == (uint)MessageStatus.StatusInvalidInfoClass) { smbErrorHeader.Status = (uint)MessageStatus.NotSupported; } //Workaround temp code (SetFsInfo Unknown Error TDQ) if (informationLevel == InformationLevel.FileFsControlInformaiton && !bool.Parse(Site.Properties["IsTDQ33016Fixed"])) { this.ErrorResponse(smbErrorHeader.Mid + this.addMidMark, MessageStatus.AccessDenied); } else { this.ErrorResponse(smbErrorHeader.Mid + this.addMidMark, (MessageStatus)smbErrorHeader.Status); } } else { SmbTrans2SetFsInformationResponsePacket smbTrans2SetFsInformationPacket = response as SmbTrans2SetFsInformationResponsePacket; NamespaceCifs.SmbHeader trans2SetFsInformationResponseHeader = smbTrans2SetFsInformationPacket.SmbHeader; if (this.Trans2SetFsInfoResponse != null) { this.Trans2SetFsInfoResponse( trans2SetFsInformationResponseHeader.Mid + this.addMidMark, this.QueryUidTable(smbPacketResponse), this.QueryTidTable(smbPacketResponse), (smbPacketResponse).IsSignRequired, (MessageStatus)trans2SetFsInformationResponseHeader.Status); } else { this.Trans2SetFsInfoResponseAdditional( trans2SetFsInformationResponseHeader.Mid + this.addMidMark, this.QueryUidTable(smbPacketResponse), this.QueryTidTable(smbPacketResponse), (smbPacketResponse).IsSignRequired, (MessageStatus)trans2SetFsInformationResponseHeader.Status); } } #endregion }
/// <summary> /// Verify data type FileFsControlInformation /// </summary> /// <param name="fileFsControlInformation"> FileFsControlInformation type data </param> /// <param name="freeSpaceThreshold"> A 64-bit signed integer that contains the minimum amount of free disk space in bytes that is required for the indexing service to continue to filter documents and merge word lists. </param> /// <param name="freeSpaceStopFiltering"> A 64-bit signed integer that contains the minimum amount of free disk space in bytes that is required for the content indexing service to continue filtering. </param> /// <param name="defaultQuotaLimit"> A 64-bit signed integer that contains the default per-user disk quota limit in bytes for the volume. </param> public void VerifyDataTypeFileFsControlInformationForOld( FileFsControlInformation fileFsControlInformation, // long freeSpaceThreshold, long defaultQuotaLimit) { Site.DefaultProtocolDocShortName = "MS-FSCC"; // // Add the debug information // Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSCC_R1720 "); // // Verify requirement 1720 // Site.CaptureRequirementIfAreEqual<Type>( typeof(FileFsControlInformation), fileFsControlInformation.GetType(), 1720, @"The message[FileFsControlInformation] contains a FILE_FS_CONTROL_INFORMATION data element."); // // Add the debug information // Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSCC_R1734 Actual DefaultQuotaLimit: {0}, Expected DefaultQuotaLimit: {1}.", fileFsControlInformation.DefaultQuotaLimit, defaultQuotaLimit); // // Verify requirement 1734 // // Verify the type and the value of the DefaultQuotaLimit bool isVerifyR1734 = ( fileFsControlInformation.DefaultQuotaLimit.GetType() == typeof(Int64) && fileFsControlInformation.DefaultQuotaLimit == (ulong)defaultQuotaLimit); Site.CaptureRequirementIfIsTrue( isVerifyR1734, 1734, @"[In FILE_FS_CONTROL_INFORMATION]DefaultQuotaLimit (8 bytes): A 64-bit signed integer that contains the default per-user disk quota limit in bytes for the volume."); // // Add the debug information // Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSCC_R1736 actual FileSystemControlFlags is : {0}", fileFsControlInformation.FileSystemControlFlags); // // Verify requirement 1736 // // Verify the type of FileSystemControlFlags // And for the value of it, we'll verify in the next rs Site.CaptureRequirementIfAreEqual<Type>( typeof(FileSystemControlFlags_Values), fileFsControlInformation.FileSystemControlFlags.GetType(), 1736, @"[In FILE_FS_CONTROL_INFORMATION]FileSystemControlFlags (4 bytes): A 32-bit unsigned integer that contains a bitmask of flags that control quota enforcement and logging of user-related quota events on the volume."); // // Add the debug information // Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSCC_R1737 Actual FileSystemControlFlags: {0}.", fileFsControlInformation.FileSystemControlFlags); // // Verify requirement 1737 // // As the type of the FileSystemControlFlags is verified above, we didn't here again // Verify the valid value of FileSystemControlFlags const uint FileSystemControlFlagsBitUsed = ( 0x00000008 | 0x00000020 | 0x00000010 | 0x00000080 | 0x00000040 | 0x00000002 | 0x00000001 | 0x00000100 | 0x00000200); // FileSystemControlFlagsBitUnUsed contains the bit that FileSystemControlFlags unused const uint fileSystemControlFlagsBitUnUsed = ~FileSystemControlFlagsBitUsed; bool isVerifyR1737 = ( ((uint)fileFsControlInformation.FileSystemControlFlags & fileSystemControlFlagsBitUnUsed) == 0x00000000); Site.CaptureRequirementIfIsTrue( isVerifyR1737, 1737, @"[In FILE_FS_CONTROL_INFORMATION]FileSystemControlFlags (4 bytes): The following bit flags [FILE_VC_CONTENT_INDEX_DISABLED 0x00000008, FILE_VC_LOG_QUOTA_LIMIT 0x00000020, FILE_VC_LOG_QUOTA_THRESHOLD 0x00000010, FILE_VC_LOG_VOLUME_LIMIT 0x00000080, FILE_VC_LOG_VOLUME_THRESHOLD 0x00000040, FILE_VC_QUOTA_ENFORCE 0x00000002, FILE_VC_QUOTA_TRACK 0x00000001, FILE_VC_QUOTAS_INCOMPLETE 0x00000100, FILE_VC_QUOTAS_REBUILDING 0x00000200] are valid in any combination."); // // Add the debug information // Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSCC_R1739 the FileSystemControlFlags is {0}", fileFsControlInformation.FileSystemControlFlags); // // Verify requirement 1739 // const uint bitUsed_r1739 = (uint)FileSystemControlFlags_Values.FILE_VC_CONTENT_INDEX_DISABLED | (uint)FileSystemControlFlags_Values.FILE_VC_LOG_QUOTA_LIMIT | (uint)FileSystemControlFlags_Values.FILE_VC_LOG_QUOTA_THRESHOLD | (uint)FileSystemControlFlags_Values.FILE_VC_LOG_VOLUME_LIMIT | (uint)FileSystemControlFlags_Values.FILE_VC_LOG_VOLUME_THRESHOLD | (uint)FileSystemControlFlags_Values.FILE_VC_QUOTA_ENFORCE | (uint)FileSystemControlFlags_Values.FILE_VC_QUOTA_TRACK | (uint)FileSystemControlFlags_Values.FILE_VC_QUOTAS_INCOMPLETE | (uint)FileSystemControlFlags_Values.FILE_VC_QUOTAS_REBUILDING; const uint bitUnUsed_r1739 = ~bitUsed_r1739; Site.CaptureRequirementIfAreEqual<uint>( 0x00000000, bitUnUsed_r1739 & (uint)fileFsControlInformation.FileSystemControlFlags, 1739, @"[In FILE_FS_CONTROL_INFORMATION]FileSystemControlFlags (4 bytes): Bits not defined in the following table[FILE_VC_CONTENT_INDEX_DISABLED 0x00000008, FILE_VC_LOG_QUOTA_LIMIT 0x00000020, FILE_VC_LOG_QUOTA_THRESHOLD 0x00000010, FILE_VC_LOG_VOLUME_LIMIT 0x00000080, FILE_VC_LOG_VOLUME_THRESHOLD 0x00000040, FILE_VC_QUOTA_ENFORCE 0x00000002, FILE_VC_QUOTA_TRACK 0x00000001, FILE_VC_QUOTAS_INCOMPLETE 0x00000100, FILE_VC_QUOTAS_REBUILDING 0x00000200] MUST be ignored.<83><84>"); Site.DefaultProtocolDocShortName = Site.Properties["ProtocolShortName"]; }
/// <summary> /// Verify the message syntax in FILE_FS_CONTROL_INFORMATION /// </summary> /// <param name="fileFsControlInformation">A FileFsControlInformation type structure.</param> /// <param name="defaultPerUserDiskQuatoLimit">The default per-user disk quota limit in bytes for the volume.</param> /// <param name="deaultPerUserDiskQuotaWarningThreshold">the default per-user disk quota warning threshold /// in bytes for the volume</param> /// <param name="minAmountOfFreeDiskSpaceForStartFiltering">minimum amount of free disk space in bytes that is /// required for the operating system's content indexing service to begin document filtering.</param> /// <param name="minAmountOfFreeDiskSpaceForStopFiltering">the minimum amount of free disk space in bytes that /// is required for the content indexing service to continue filtering</param> /// <param name="minAmountOfFreeDiskSpaceForThreshold">the minimum amount of free disk space in bytes that is /// required for the indexing service to continue to filter documents and merge word lists.</param> public void VerifyMessageSyntaxFileFsControlInformation( FileFsControlInformation fileFsControlInformation, long deaultPerUserDiskQuotaWarningThreshold, long minAmountOfFreeDiskSpaceForStartFiltering, long minAmountOfFreeDiskSpaceForStopFiltering, long minAmountOfFreeDiskSpaceForThreshold) { Site.DefaultProtocolDocShortName = "MS-FSCC"; // // Add the debug information // Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSCC_R1720"); // // Verify MS-FSCC requirement: MS-FSCC_R1720 // // If FILE_FS_CONTROL_INFORMATION is not null in the message then means the message contains it, // so can capture this requirement just by verifying this field is not null Site.CaptureRequirementIfIsNotNull( fileFsControlInformation, 1720, @"The message[FileFsControlInformation] contains a FILE_FS_CONTROL_INFORMATION data element."); // // Add the debug information // Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSCC_R1735,the value of DefaultQuotaLimit is {0}", fileFsControlInformation.DefaultQuotaLimit); // // Verify MS-FSCC requirement: MS-FSCC_R1735 // bool isVerifyR1735 = (Marshal.SizeOf(fileFsControlInformation.DefaultQuotaLimit) == 8) && ((fileFsControlInformation.DefaultQuotaLimit >= 0) || (fileFsControlInformation.DefaultQuotaLimit == 0xFFFFFFFFFFFFFFFF)); Site.CaptureRequirementIfIsTrue( isVerifyR1735, 1735, @"[In FILE_FS_CONTROL_INFORMATION]DefaultQuotaLimit (8 bytes): This field MUST be set to a 64-bit integer value greater than or equal to 0 to set a default disk quota limit per user for this volume, or to (-1) to specify that no default quota limit per user is set."); // // Add the debug information // Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSCC_R1732,the value of DefaultQuotaThreshold is {0}", fileFsControlInformation.DefaultQuotaThreshold); // // Verify MS-FSCC requirement: MS-FSCC_R1732 // bool isVerifyR1732 = (Marshal.SizeOf(fileFsControlInformation.DefaultQuotaThreshold) == 8) && (fileFsControlInformation.DefaultQuotaThreshold == (ulong)deaultPerUserDiskQuotaWarningThreshold); Site.CaptureRequirementIfIsTrue( isVerifyR1732, 1732, @"[In FILE_FS_CONTROL_INFORMATION]DefaultQuotaThreshold (8 bytes): A 64-bit signed integer that contains the default per-user disk quota warning threshold in bytes for the volume."); // // Add the debug information // Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSCC_R1733,the value of DefaultQuotaThreshold is {0}", fileFsControlInformation.DefaultQuotaThreshold); // // Verify MS-FSCC requirement: MS-FSCC_R1733 // bool isVerifyR1733 = (Marshal.SizeOf(fileFsControlInformation.DefaultQuotaThreshold) == 8) && (fileFsControlInformation.DefaultQuotaThreshold >= 0 || fileFsControlInformation.DefaultQuotaThreshold == 0xFFFFFFFFFFFFFFFF); Site.CaptureRequirementIfIsTrue( isVerifyR1733, 1733, @"[In FILE_FS_CONTROL_INFORMATION]DefaultQuotaThreshold (8 bytes): This field MUST be set to a 64-bit integer value greater than or equal to 0 to set a default quota warning threshold per user for this volume, or to (-1) to specify that no default quota warning threshold per user is set."); // // Add the debug information // Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSCC_R1723,the value of FreeSpaceStartFiltering is {0}", fileFsControlInformation.FreeSpaceStartFiltering); // // Verify MS-FSCC requirement: MS-FSCC_R1723 // bool isVerifyR1723 = (Marshal.SizeOf(fileFsControlInformation.FreeSpaceStartFiltering) == 8) && (fileFsControlInformation.FreeSpaceStartFiltering == minAmountOfFreeDiskSpaceForStartFiltering); Site.CaptureRequirementIfIsTrue( isVerifyR1723, 1723, @"[In FILE_FS_CONTROL_INFORMATION]FreeSpaceStartFiltering (8 bytes): A 64-bit signed integer that contains the minimum amount of free disk space in bytes that is required for the operating system's content indexing service to begin document filtering."); // // Verify requirement MS-FSCC_R1724 and MS-FSCC_R1975 // string isR1724Implementated = Site.Properties.Get("SHOULDMAY.IsR1724Implementated"); bool isR1975Satisfied = (fileFsControlInformation.FreeSpaceStartFiltering == 0); if (isWindows) { // // Add the debug information // Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSCC_R1975,the value of FreeSpaceStartFiltering is {0}", fileFsControlInformation.FreeSpaceStartFiltering); // // Verify MS-FSCC requirement: MS-FSCC_R1975 // Site.CaptureRequirementIfIsTrue( isR1975Satisfied, 1975, @"<80> Section 2.5.2: Windows sets this value[FreeSpaceStartFiltering] to 0."); if (null == isR1724Implementated) { Site.Properties.Add("SHOULDMAY.IsR1724Implementated", Boolean.TrueString); isR1724Implementated = Boolean.TrueString; } } if (null != isR1724Implementated) { bool implement = Boolean.Parse(isR1724Implementated); bool isSatisfied = isR1975Satisfied; // // Add the debug information // Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSCC_R1724,the value of FreeSpaceStartFiltering is {0}", fileFsControlInformation.FreeSpaceStartFiltering); // // Verify MS-FSCC requirement: MS-FSCC_R1724 // Site.CaptureRequirementIfAreEqual<Boolean>( implement, isSatisfied, 1724, String.Format(@"[In FILE_FS_CONTROL_INFORMATION]FreeSpaceStartFiltering (8 bytes): This value SHOULD be set to 0.<80> This requirement is {0} implement", implement ? "" : "not")); } // // Add the debug information // Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSCC_R1729,the value of FreeSpaceStopFiltering is {0}", fileFsControlInformation.FreeSpaceStopFiltering); // // Verify MS-FSCC requirement: MS-FSCC_R1729 // bool isVerifyR1729 = (Marshal.SizeOf(fileFsControlInformation.FreeSpaceStopFiltering) == 8) && (fileFsControlInformation.FreeSpaceStopFiltering == minAmountOfFreeDiskSpaceForStopFiltering); Site.CaptureRequirementIfIsTrue( isVerifyR1729, 1729, @"[In FILE_FS_CONTROL_INFORMATION]FreeSpaceStopFiltering (8 bytes): A 64-bit signed integer that contains the minimum amount of free disk space in bytes that is required for the content indexing service to continue filtering."); // // Verify requirement MS-FSCC_R1730 and MS-FSCC_R1977 // string isR1730Implementated = Site.Properties.Get("SHOULDMAY.IsR1730Implementated"); bool isR1977Satisfied = (fileFsControlInformation.FreeSpaceStopFiltering == 0); if (isWindows) { // // Add the debug information // Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSCC_R1977,the value of FreeSpaceStopFiltering is{0}", fileFsControlInformation.FreeSpaceStopFiltering); // // Verify MS-FSCC requirement: MS-FSCC_R1977 // Site.CaptureRequirementIfIsTrue( isR1977Satisfied, 1977, @"<82> Section 2.5.2: Windows sets this value[FreeSpaceStopFiltering] to 0."); if (null == isR1730Implementated) { Site.Properties.Add("SHOULDMAY.IsR1730Implementated", Boolean.TrueString); isR1730Implementated = Boolean.TrueString; } } if (null != isR1730Implementated) { bool implement = Boolean.Parse(isR1730Implementated); bool isSatisfied = isR1977Satisfied; // // Add the debug information // Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSCC_R1730,the value of FreeSpaceStopFiltering is{0}", fileFsControlInformation.FreeSpaceStopFiltering); // // Verify MS-FSCC requirement: MS-FSCC_R1730 // Site.CaptureRequirementIfAreEqual<Boolean>( implement, isSatisfied, 1730, String.Format(@"[In FILE_FS_CONTROL_INFORMATION]FreeSpaceStopFiltering (8 bytes): This value SHOULD be set to 0.<82> This requirement is {0} implement", implement ? "" : "not")); } // // Add the debug information // Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSCC_R1726,the value of FreeSpaceThreshold is {0}", fileFsControlInformation.FreeSpaceThreshold); // // Verify MS-FSCC requirement: MS-FSCC_R1726 // bool isVerifyR1726 = (Marshal.SizeOf(fileFsControlInformation.FreeSpaceThreshold) == 8) && (fileFsControlInformation.FreeSpaceThreshold == minAmountOfFreeDiskSpaceForThreshold); Site.CaptureRequirementIfIsTrue( isVerifyR1726, 1726, @"[In FILE_FS_CONTROL_INFORMATION]FreeSpaceThreshold (8 bytes): A 64-bit signed integer that contains the minimum amount of free disk space in bytes that is required for the indexing service to continue to filter documents and merge word lists."); // // Verify requirement MS-FSCC_R1727 and MS-FSCC_R1976 // string isR1727Implementated = Site.Properties.Get("SHOULDMAY.IsR1727Implementated"); bool isR1976Satisfied = (fileFsControlInformation.FreeSpaceThreshold == 0); if (isWindows) { // // Add the debug information // Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSCC_R1976,the value of FreeSpaceThreshold is {0}", fileFsControlInformation.FreeSpaceThreshold); // // Verify MS-FSCC requirement: MS-FSCC_R1976 // Site.CaptureRequirementIfIsTrue( isR1976Satisfied, 1976, @"<81> Section 2.5.2: Windows sets this value[FreeSpaceThreshold] to 0."); if (null == isR1727Implementated) { Site.Properties.Add("SHOULDMAY.IsR1727Implementated", Boolean.TrueString); isR1727Implementated = Boolean.TrueString; } } if (null != isR1727Implementated) { bool implement = Boolean.Parse(isR1727Implementated); bool isSatisfied = isR1976Satisfied; // // Add the debug information // Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSCC_R1727,the value of FreeSpaceThreshold is {0}", fileFsControlInformation.FreeSpaceThreshold); // // Verify MS-FSCC requirement: MS-FSCC_R1727 // Site.CaptureRequirementIfAreEqual<Boolean>( implement, isSatisfied, 1727, String.Format(@"[In FILE_FS_CONTROL_INFORMATION]FreeSpaceThreshold (8 bytes): This value SHOULD be set to 0.<81> This requirement is {0} implement", implement ? "" : "not")); } Site.DefaultProtocolDocShortName = Site.Properties["ProtocolShortName"]; }
/// <summary> /// Verify the FileFsControlInformation fields /// </summary> /// <param name="info">the instance of FileFsControlInformation</param> public void VerifyDataTypeFileFsControlInformation(FileFsControlInformation info) { Site.DefaultProtocolDocShortName = "MS-FSCC"; if (bool.Parse(Site.Properties["SUT.Platform.OS.isWindows"])) { // // Add the debug information // Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSCC_R1976"); // // Verify MS-FSCC requirement: MS-FSCC_R1976 // Site.CaptureRequirementIfAreEqual<long>( 0, info.FreeSpaceThreshold, 1976, @"<81> Section 2.5.2: Windows sets this value[FreeSpaceThreshold] to 0."); // // Add the debug information // Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSCC_R1977"); // // Verify MS-FSCC requirement: MS-FSCC_R1977 // Site.CaptureRequirementIfAreEqual<long>( 0, info.FreeSpaceStopFiltering, 1977, @"<82> Section 2.5.2: Windows sets this value[FreeSpaceStopFiltering] to 0."); // the bit flags combination uint bitsCombination = ((uint)FileSystemControlFlags_Values.FILE_VC_CONTENT_INDEX_DISABLED | (uint)FileSystemControlFlags_Values.FILE_VC_LOG_QUOTA_LIMIT | (uint)FileSystemControlFlags_Values.FILE_VC_LOG_QUOTA_THRESHOLD | (uint)FileSystemControlFlags_Values.FILE_VC_LOG_VOLUME_LIMIT | (uint)FileSystemControlFlags_Values.FILE_VC_LOG_VOLUME_THRESHOLD | (uint)FileSystemControlFlags_Values.FILE_VC_QUOTA_ENFORCE | (uint)FileSystemControlFlags_Values.FILE_VC_QUOTA_TRACK | (uint)FileSystemControlFlags_Values.FILE_VC_QUOTAS_INCOMPLETE | (uint)FileSystemControlFlags_Values.FILE_VC_QUOTAS_REBUILDING); // FileSystemControlFlags is set to any other bit except all above if (((uint)info.FileSystemControlFlags & ~bitsCombination) == 0) { // // Add the debug information // Site.Log.Add(LogEntryKind.Debug, "Verify MS-FSCC_R1978"); // // Verify MS-FSCC requirement: MS-FSCC_R1978 // Site.CaptureRequirementIfAreEqual<uint>( 0, (uint)info.FileSystemControlFlags, 1978, @"<83> Section 2.5.2: Windows sets flags not defined below[[FILE_VC_CONTENT_INDEX_DISABLED 0x00000008, FILE_VC_LOG_QUOTA_LIMIT 0x00000020, FILE_VC_LOG_QUOTA_THRESHOLD 0x00000010, FILE_VC_LOG_VOLUME_LIMIT 0x00000080, FILE_VC_LOG_VOLUME_THRESHOLD 0x00000040, FILE_VC_QUOTA_ENFORCE 0x00000002, FILE_VC_QUOTA_TRACK 0x00000001, FILE_VC_QUOTAS_INCOMPLETE 0x00000100, FILE_VC_QUOTAS_REBUILDING 0x00000200] to zero."); } } Site.DefaultProtocolDocShortName = Site.Properties["ProtocolShortName"]; }