public void TraditionalTestCase_IgnoreFields_CopyChunk_05() { #region Connect to the specified server smbClientStack.Connect(serverName, serverPort, ipVersion, bufferSize); #endregion #region Send the Negotiate request // Create a SMB_COM_NEGOTIATE request. SmbNegotiateRequestPacket negotiateRequest = smbClientStack.CreateNegotiateRequest( StackSmb.SignState.NONE, new string[] { DialectNameString.PCNET1, DialectNameString.LANMAN10, DialectNameString.WFW10, DialectNameString.LANMAN12, DialectNameString.LANMAN21, DialectNameString.NTLANMAN }); // Send the SMB_COM_NEGOTIATE request and expect the response in timeout milliseconds. smbClientStack.SendPacket(negotiateRequest); StackPacket response = smbClientStack.ExpectPacket(timeout); // Check whether server return a response. Site.Assert.IsNotNull( response, "SMB_COM_NEGOTIATE response should not be null."); // Check whether server returns a SMB_COM_NEGOTIATE response. Site.Assert.IsInstanceOfType( response, typeof(SmbNegotiateResponsePacket), "SMB_COM_NEGOTIATE response should be received."); // Check the response validity by verifying the Status field in the SMB Header packet. SmbNegotiateResponsePacket negotiateResponse = (SmbNegotiateResponsePacket)response; Site.Assert.AreEqual<uint>( (uint)SmbStatus.STATUS_SUCCESS, negotiateRequest.SmbHeader.Status, "SMB_COM_NEGOTIATE response status should be SUCCESS."); #endregion #region Send the first SMB_COM_SESSION_SETUP_ANDX Request SmbSecurityPackage smbSecurityPackage = (SmbSecurityPackage)Enum.Parse( typeof(SmbSecurityPackage), Site.Properties["SmbSecurityPackageType"] as string, true); // Create the first SMB_COM_SESSION_SETUP_ANDX request. SmbSessionSetupAndxRequestPacket sessionSetupAndxRequest = smbClientStack.CreateFirstSessionSetupRequest( smbSecurityPackage, serverName, domainName, userName, password); // Send the first SMB_COM_SESSION_SETUP_ANDX request and expect the response in timeout milliseconds. smbClientStack.SendPacket(sessionSetupAndxRequest); response = smbClientStack.ExpectPacket(timeout); // Check whether server return a response. Site.Assert.IsNotNull( response, "SMB_COM_SESSION_SETUP_ANDX response should not be null."); // Check whether server returns a the SMB_COM_SESSION_SETUP_ANDX response. Site.Assert.IsInstanceOfType( response, typeof(SmbSessionSetupAndxResponsePacket), "SMB_COM_SESSION_SETUP_ANDX response should be received."); // Check the response validity by verifying the Status field in the SMB Header packet. // If SMB SecurityPackage type is NTLM, the expected SUCCESS response status is STATUS_MORE_PROCESSING_REQUIRED, // else if SMB SecurityPackage type is Kerberos, the expected SUCCESS response status is STATUS_SUCCESS. SmbSessionSetupAndxResponsePacket sessionSetupResponse = (SmbSessionSetupAndxResponsePacket)response; Site.Assert.IsTrue( (int)sessionSetupResponse.SmbHeader.Status == (int)SmbStatus.STATUS_MORE_PROCESSING_REQUIRED || (int)sessionSetupResponse.SmbHeader.Status == (int)SmbStatus.STATUS_SUCCESS, "SMB_COM_SESSION_SETUP_ANDX response status should be SUCCESS."); #endregion #region Send the second SMB_COM_SESSION_SETUP_ANDX request // Create the second SMB_COM_SESSION_SETUP_ANDX request. ushort sessionUid = sessionSetupResponse.SmbHeader.Uid; if ((int)sessionSetupResponse.SmbHeader.Status == (int)SmbStatus.STATUS_MORE_PROCESSING_REQUIRED) { SmbSessionSetupAndxRequestPacket secondSessionSetupRequest = smbClientStack.CreateSecondSessionSetupRequest(sessionUid, smbSecurityPackage); // Send the second SMB_COM_SESSION_SETUP_ANDX request and expect the response in timeout milliseconds. smbClientStack.SendPacket(secondSessionSetupRequest); response = smbClientStack.ExpectPacket(timeout); // Check whether server return a response. Site.Assert.IsNotNull( response, "SMB_COM_SESSION_SETUP_ANDX response should not be null."); // Check whether server returns a the SMB_COM_SESSION_SETUP_ANDX response. Site.Assert.IsInstanceOfType( response, typeof(SmbSessionSetupAndxResponsePacket), "SMB_COM_SESSION_SETUP_ANDX response should be received."); // Check the response validity by verifying the Status field in the SMB Header packet. sessionSetupResponse = (SmbSessionSetupAndxResponsePacket)response; Site.Assert.AreEqual<uint>( (uint)SmbStatus.STATUS_SUCCESS, sessionSetupResponse.SmbHeader.Status, "SMB_COM_SESSION_SETUP_ANDX response status should be SUCCESS."); } #endregion #region Send the SMB_COM_TREE_CONNECT_ANDX request string path = Site.Properties["SutNtfsShare1FullName"]; SmbTreeConnectAndxRequestPacket treeconnectRequest = smbClientStack.CreateTreeConnectRequest(sessionUid, path); smbClientStack.SendPacket(treeconnectRequest); response = smbClientStack.ExpectPacket(timeout); SmbTreeConnectAndxResponsePacket treeConnectResponse = (SmbTreeConnectAndxResponsePacket)response; #endregion #region Send the NT_CREATE_ANDX request ushort treeId = treeConnectResponse.SmbHeader.Tid; string fileName = Site.Properties["SutShareTest1"]; smbClientStack.Capability.Flag |= SmbHeader_Flags_Values.OPLOCK; SmbNtCreateAndxRequestPacket createRequest = smbClientStack.CreateCreateRequest( treeId, fileName, StackCifs.NtTransactDesiredAccess.FILE_READ_DATA | StackCifs.NtTransactDesiredAccess.FILE_READ_EA | StackCifs.NtTransactDesiredAccess.FILE_READ_ATTRIBUTES | StackCifs.NtTransactDesiredAccess.FILE_WRITE_DATA, StackCifs.SMB_EXT_FILE_ATTR.NONE, StackCifs.NtTransactShareAccess.FILE_SHARE_READ | StackCifs.NtTransactShareAccess.FILE_SHARE_DELETE, StackCifs.NtTransactCreateDisposition.FILE_OPEN_IF, NtTransactCreateOptions.FILE_OPEN_REPARSE_POINT | NtTransactCreateOptions.FILE_SEQUENTIAL_ONLY | NtTransactCreateOptions.FILE_NON_DIRECTORY_FILE, StackCifs.NtTransactImpersonationLevel.SEC_ANONYMOUS, CreateFlags.NT_CREATE_REQUEST_OPLOCK); smbClientStack.SendPacket(createRequest); response = smbClientStack.ExpectPacket(timeout); #endregion #region Send the NT_CREATE_ANDX request SmbNtCreateAndxResponsePacket createResponse = (SmbNtCreateAndxResponsePacket)response; ushort fileId1 = createResponse.SmbParameters.FID; uint offset = uint.Parse(Site.Properties["SmbTransportWriteOffset"].ToString()); byte[] writeData = new byte[17000]; for (int i = 0; i < writeData.Length; i++) { writeData[i] = (byte)'a'; } SmbWriteAndxRequestPacket writeRequest = smbClientStack.CreateWriteRequest(fileId1, offset, writeData); smbClientStack.SendPacket(writeRequest); response = smbClientStack.ExpectPacket(timeout); #endregion #region Send the WRITE_ANDX request SmbWriteAndxResponsePacket writeAndxResponsePacket = response as SmbWriteAndxResponsePacket; string fileName2 = Site.Properties["SutShareTest2"]; SmbNtCreateAndxRequestPacket createSecondRequest = smbClientStack.CreateCreateRequest( treeId, fileName2, StackCifs.NtTransactDesiredAccess.FILE_READ_DATA | StackCifs.NtTransactDesiredAccess.FILE_WRITE_DATA | StackCifs.NtTransactDesiredAccess.FILE_APPEND_DATA, StackCifs.SMB_EXT_FILE_ATTR.NONE, StackCifs.NtTransactShareAccess.FILE_SHARE_WRITE | StackCifs.NtTransactShareAccess.FILE_SHARE_DELETE, StackCifs.NtTransactCreateDisposition.FILE_OPEN_IF, NtTransactCreateOptions.FILE_OPEN_REPARSE_POINT | NtTransactCreateOptions.FILE_SEQUENTIAL_ONLY | NtTransactCreateOptions.FILE_NON_DIRECTORY_FILE, StackCifs.NtTransactImpersonationLevel.SEC_ANONYMOUS, CreateFlags.NT_CREATE_REQUEST_OPBATCH); smbClientStack.SendPacket(createSecondRequest); response = smbClientStack.ExpectPacket(timeout); #endregion #region Send the NT_CREATE_ANDX SmbNtCreateAndxResponsePacket createSecondResponse = (SmbNtCreateAndxResponsePacket)response; ushort fileId2 = createSecondResponse.SmbParameters.FID; SmbNtTransFsctlSrvRequestResumeKeyRequestPacket nTTransIOCtlRequestResumeKeyRequest = smbClientStack.CreateNTTransIOCtlRequestResumeKeyRequest(fileId1, true, 0); StackCifs.SmbHeader smbHeader = nTTransIOCtlRequestResumeKeyRequest.SmbHeader; smbHeader.Uid = sessionUid; smbHeader.Tid = treeId; nTTransIOCtlRequestResumeKeyRequest.SmbHeader = smbHeader; smbClientStack.SendPacket(nTTransIOCtlRequestResumeKeyRequest); response = smbClientStack.ExpectPacket(timeout); SmbNtTransFsctlSrvRequestResumeKeyResponsePacket nTTransIOCtlRequestResumeKeyResponse = (SmbNtTransFsctlSrvRequestResumeKeyResponsePacket)response; #endregion #region Send the NT_TRANS_IO_CTL request bool isFsctl = true; byte isFlags = (byte)0; byte[] copychunkResumeKey = nTTransIOCtlRequestResumeKeyResponse.NtTransData.ResumeKey; nTTransIOCtlRequestResumeKeyRequest = smbClientStack.CreateNTTransIOCtlRequestResumeKeyRequest(fileId1, true, 0); smbHeader = nTTransIOCtlRequestResumeKeyRequest.SmbHeader; smbHeader.Uid = sessionUid; smbHeader.Tid = treeId; nTTransIOCtlRequestResumeKeyRequest.SmbHeader = smbHeader; smbClientStack.SendPacket(nTTransIOCtlRequestResumeKeyRequest); response = smbClientStack.ExpectPacket(timeout); #endregion #region Capture requirement r9074 nTTransIOCtlRequestResumeKeyResponse = (SmbNtTransFsctlSrvRequestResumeKeyResponsePacket)response; byte[] copychunkResumeKey2 = nTTransIOCtlRequestResumeKeyResponse.NtTransData.ResumeKey; // Compare copychunkResumeKey and copychunkResumeKey2, if same, capture 9074 // // Add the debug information // Site.Log.Add(LogEntryKind.Debug, "Verify MS-SMB_R9074"); // // Verify MS-SMB requirement: MS-SMB_R9074 // bool isVerifyR9074 = CompareArrayEquals(copychunkResumeKey, copychunkResumeKey2); Site.CaptureRequirementIfIsTrue( isVerifyR9074, 9074, @"[In Copychunk Resume Key Generation] The generation of Copychunk Resume Keys MUST satisfy the following constraints:The Copychunk Resume Key MUST remain valid for the lifetime of the open file on the server."); #endregion #region Send the NT_TRANSACT_COPY_CHUNK_List request NT_TRANSACT_COPY_CHUNK_List list = new NT_TRANSACT_COPY_CHUNK_List(); list.Length = (uint)64; list.SourceOffset = (ulong)0; list.DestinationOffset = (ulong)0; SmbNtTransFsctlSrvCopyChunkRequestPacket nTTransIOCtlCopyChunkRequest = smbClientStack.CreateNTTransIOCtlCopyChunkRequest(fileId2, isFsctl, isFlags, copychunkResumeKey, list); smbClientStack.SendPacket(nTTransIOCtlCopyChunkRequest); response = smbClientStack.ExpectPacket(timeout); #endregion #region Send the NT_TRANSACT_COPY_CHUNK_Request_NT_Trans_Data request SmbNtTransFsctlSrvCopyChunkResponsePacket nTTransIOCtlCopyChunkResponse1 = (SmbNtTransFsctlSrvCopyChunkResponsePacket)response; list.Length = (uint)64; list.SourceOffset = (ulong)0; list.DestinationOffset = (ulong)0; list.Reserved = 0xFFFF; nTTransIOCtlCopyChunkRequest = smbClientStack.CreateNTTransIOCtlCopyChunkRequest(fileId2, isFsctl, isFlags, copychunkResumeKey, list); NT_TRANSACT_COPY_CHUNK_Request_NT_Trans_Data TransData = nTTransIOCtlCopyChunkRequest.NtTransData; TransData.Unused = 0xFFFF; nTTransIOCtlCopyChunkRequest.NtTransData = TransData; smbClientStack.SendPacket(nTTransIOCtlCopyChunkRequest); response = smbClientStack.ExpectPacket(timeout); #endregion #region Capture requirements R109390 SmbNtTransFsctlSrvCopyChunkResponsePacket nTTransIOCtlCopyChunkResponse2 = (SmbNtTransFsctlSrvCopyChunkResponsePacket)response; // Compare 2 copy chunckResponse // // Add the debug information // Site.Log.Add(LogEntryKind.Debug, "Verify MS-SMB_R109390"); // // Verify MS-SMB requirement: MS-SMB_R109390 // bool isVerifyR109390 = VerifyResponse(nTTransIOCtlCopyChunkResponse1, nTTransIOCtlCopyChunkResponse2); Site.CaptureRequirementIfIsTrue( isVerifyR109390, 109390, @"[In Client Request Extensions]Reserved (4 bytes): reply is the same whether zero or non-zero is used this field."); // // Add the debug information // Site.Log.Add(LogEntryKind.Debug, "Verify MS-SMB_R109396"); // // Verify MS-SMB requirement: MS-SMB_R109396 // bool isVerifyR109396 = VerifyResponse(nTTransIOCtlCopyChunkResponse1, nTTransIOCtlCopyChunkResponse2); Site.CaptureRequirementIfIsTrue( isVerifyR109396, 109396, @"[In SRV_COPYCHUNK]Reserved (4 bytes): reply is the same whether zero or non-zero is used in this field."); #endregion #region Send the SMB_NT_TRANS_FSCTL_SRV request request nTTransIOCtlRequestResumeKeyRequest = smbClientStack.CreateNTTransIOCtlRequestResumeKeyRequest(fileId2, true, 0); smbHeader = nTTransIOCtlRequestResumeKeyRequest.SmbHeader; smbHeader.Uid = sessionUid; smbHeader.Tid = treeId; nTTransIOCtlRequestResumeKeyRequest.SmbHeader = smbHeader; smbClientStack.SendPacket(nTTransIOCtlRequestResumeKeyRequest); response = smbClientStack.ExpectPacket(timeout); #endregion #region Capture reuqirements R9073 nTTransIOCtlRequestResumeKeyResponse = (SmbNtTransFsctlSrvRequestResumeKeyResponsePacket)response; byte[] copychunkResumeKey3 = nTTransIOCtlRequestResumeKeyResponse.NtTransData.ResumeKey; // // Add the comment information for debugging // Site.Log.Add( LogEntryKind.Comment, @"Verify MS-SMB_R9073"); // // Verify MS-SMB requirement: MS-SMB_R9073 // bool isVerifyR9073 = CompareArrayEquals(copychunkResumeKey, copychunkResumeKey3); Site.CaptureRequirementIfIsFalse( isVerifyR9073, 9073, @"[In Copychunk Resume Key Generation] The generation of Copychunk Resume Keys MUST satisfy the following constraints: The Copychunk Resume Key MUST be unique on the SMB server for a given open file on a server."); #endregion #region Disconnect the tree, session and connection. // TreeDisconnect SmbTreeDisconnectRequestPacket treeDisconnectRequest = smbClientStack.CreateTreeDisconnectRequest(treeId); smbClientStack.SendPacket(treeDisconnectRequest); response = smbClientStack.ExpectPacket(timeout); // Check whether server return a response. Site.Assert.IsNotNull( response, "SMB_COM_TREE_DISCONNECT response should not be null."); Site.Assert.IsInstanceOfType( response, typeof(SmbTreeDisconnectResponsePacket), "SMB_COM_TREE_DISCONNECT response should be received."); // Check the response validity by verifying the Status field in the SMB Header packet. SmbTreeDisconnectResponsePacket treeDisconnectResponse = (SmbTreeDisconnectResponsePacket)response; Site.Assert.AreEqual<uint>( (uint)SmbStatus.STATUS_SUCCESS, treeDisconnectResponse.SmbHeader.Status, "SMB_COM_TREE_DISCONNECT response status should be SUCCESS."); // LogOff SmbLogoffAndxRequestPacket logoffRequest = smbClientStack.CreateLogoffRequest(sessionUid); smbClientStack.SendPacket(logoffRequest); response = smbClientStack.ExpectPacket(timeout); // Check whether server return a response. Site.Assert.IsNotNull( response, "SMB_COM_LOGOFF_ANDX response should not be null."); Site.Assert.IsInstanceOfType( response, typeof(SmbLogoffAndxResponsePacket), "SMB_COM_LOGOFF_ANDX response should be received."); // Check the response validity by verifying the Status field in the SMB Header packet. SmbLogoffAndxResponsePacket logoffResponse = (SmbLogoffAndxResponsePacket)response; Site.Assert.AreEqual<uint>( (uint)SmbStatus.STATUS_SUCCESS, logoffResponse.SmbHeader.Status, "SMB_COM_LOGOFF_ANDX response status should be SUCCESS."); // Disconnect smbClientStack.Disconnect(); Site.Assert.IsFalse( smbClientStack.IsDataAvailable, "SmbClient should not receive any packet after Disconnect method is called."); #endregion }
/// <summary> /// Create NTTransIOCtlCopyChunk request for client to copy chunk to server file. /// </summary> /// <param name = "messageId">the id of message, used to identity the request and the server response. </param> /// <param name = "sessionUid">the valid session id, must be response by server of the session setup request. </param> /// <param name = "treeId">the valid tree connect id, must be response by server of the tree connect. </param> /// <param name = "flags"> /// The Flags field contains individual flags, as specified in [CIFS] sections 2.4.2 and 3.1.1. /// </param> /// <param name = "flags2"> /// The Flags2 field contains individual bit flags that, depending on the negotiated SMB dialect, indicate /// various client and server capabilities. /// </param> /// <param name = "fileId">the valid file id to operation on, response by server. </param> /// <param name = "isFsctl"> /// This field is TRUE if the command is a file system control command and the FID is a file system control /// device. Otherwise, the command is a device control command and FID is an I/O device. /// </param> /// <param name = "isFlags"> /// If bit 0 is set, the command is to be applied to a share root handle. The share MUST be a Distributed File /// System (DFS) type /// </param> /// <param name = "copychunkResumeKey"> /// A 24-byte resume key generated by the SMB server that can be subsequently used by the client to uniquely /// identify the open source file in a FSCTL_SRV_COPYCHUNK request. /// </param> /// <param name = "list"> /// A concatenated list of copychunk blocks. This field is as specified in section 2.2.14.7.3.1. /// </param> /// <returns>a nt transaction rename request packet </returns> /// <exception cref = "ArgumentNullException">list must not be null </exception> /// <exception cref = "ArgumentException"> /// The number of entries in the copychunk list. MUST NOT be 0. /// </exception> private SmbNtTransFsctlSrvCopyChunkRequestPacket CreateNTTransIOCtlCopyChunkRequest( ushort messageId, ushort sessionUid, ushort treeId, SmbHeader_Flags_Values flags, SmbHeader_Flags2_Values flags2, ushort fileId, bool isFsctl, byte isFlags, byte[] copychunkResumeKey, NT_TRANSACT_COPY_CHUNK_List[] list) { if (list == null) { throw new ArgumentNullException("list"); } if (list.Length == 0) { throw new ArgumentException( "The number of entries in the copychunk list. MUST NOT be 0.", "list"); } SmbNtTransFsctlSrvCopyChunkRequestPacket request = new SmbNtTransFsctlSrvCopyChunkRequestPacket( this.cifsClient.CreateNtTransactIoctlRequest( messageId, sessionUid, treeId, (SmbFlags)flags, (SmbFlags2)flags2, this.capability.MaxSetupCount, this.capability.MaxParameterCount, this.capability.MaxDataCount, (uint)NtTransFunctionCode.FSCTL_SRV_COPYCHUNK, fileId, isFsctl, isFlags, null)); // update the copy chunk trans data. NT_TRANSACT_COPY_CHUNK_Request_NT_Trans_Data ntTransData = request.NtTransData; ntTransData.CopyChunkResumeKey = copychunkResumeKey; ntTransData.ChunkCount = (uint)list.Length; ntTransData.List = list; request.NtTransData = ntTransData; request.UpdateCountAndOffset(); return request; }
/// <summary> /// NT_TRANSACT_IOCTL Client Request. /// </summary> /// <param name="messageId">Message ID used to identify the message.</param> /// <param name="sessionId">Session ID used to identify the session.</param> /// <param name="treeId">Tree ID used to identify the tree connection.</param> /// <param name="isSigned"> /// Indicate whether the SUT has message signing enabled or required. /// </param> /// <param name="fid">The file identifier.</param> /// <param name="copychunkResumeKeysize">The server resume key for a source file.</param> /// <param name="sourceOffset">The offset in the source file to copy from.</param> /// <param name="targetOffset">The offset in the target file to copy to.</param> /// <param name="length">The number of bytes to copy from the source file to the target file.</param> public void FsctlSrvCopyChunkRequest( int messageId, int sessionId, int treeId, bool isSigned, int fid, string copychunkResumeKeysize, int sourceOffset, int targetOffset, int length) { #region Create Packet SmbNtTransFsctlSrvCopyChunkRequestPacket smbPacket = new SmbNtTransFsctlSrvCopyChunkRequestPacket(); ushort uid = (ushort)this.uId[(uint)sessionId]; byte[] copyChunkResumeKey = null; if (copychunkResumeKeysize == CopyChunkResumeKey) { copyChunkResumeKey = SmbAdapter.resumeKey; } else { copyChunkResumeKey = new byte[24]; for (int i = 0; i < 24; i++) { copyChunkResumeKey[i] = 0x10; } } byte isFlags = byte.MinValue; NT_TRANSACT_COPY_CHUNK_List list = new NT_TRANSACT_COPY_CHUNK_List(); list.Length = (uint)this.copyWordCount; list.SourceOffset = (ulong)sourceOffset; list.DestinationOffset = (ulong)targetOffset; smbPacket = this.smbClientStack.CreateNTTransIOCtlCopyChunkRequest( (ushort)this.fId[(uint)fid], true, isFlags, copyChunkResumeKey, list); 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; this.ErrorResponse(smbErrorHeader.Mid + this.addMidMark, (MessageStatus)smbErrorHeader.Status); } else { SmbNtTransFsctlSrvCopyChunkResponsePacket smbFsctlSrvCopyChunkPacket = response as SmbNtTransFsctlSrvCopyChunkResponsePacket; NamespaceCifs.SmbHeader ntTransFsctlSrvCopyChunkResponseHeader = smbFsctlSrvCopyChunkPacket.SmbHeader; VerifyMessageSyntaxFsctlSrvCopychunkResponse(smbFsctlSrvCopyChunkPacket); this.FsctlSrvCopyChunkResponse( ntTransFsctlSrvCopyChunkResponseHeader.Mid + this.addMidMark, this.QueryUidTable(smbPacketResponse), this.QueryTidTable(smbPacketResponse), (smbPacketResponse).IsSignRequired, (MessageStatus)ntTransFsctlSrvCopyChunkResponseHeader.Status); } #endregion }