/// </summary>
/// <param name="fileId">The fileid for the directory. </param>
/// <param name="treeId">The treeId for the directory. </param>
/// <param name="sessionId">The sessionId for the directory. </param>
/// <param name="searchPattern">A Unicode string containing the file name pattern to match. </param>
/// <param name="fileInfoClass">The FileInfoClass to query. </param>
/// <param name="returnSingleEntry">A boolean indicating whether the return single entry for query.</param>
/// <param name="restartScan">A boolean indicating whether the enumeration should be restarted.</param>
/// <param name="isOutBufferSizeLess">True: if OutputBufferSize is less than the size needed to return a single entry</param>
/// of section 3.1.5.5.4</param>
/// <returns>An NTSTATUS code that specifies the result</returns>
private MessageStatus QueryDirectory(
FILEID fileId,
uint treeId,
ulong sessionId,
string searchPattern = "*",
FileInfoClass fileinfoClass = FileInfoClass.FILE_ID_BOTH_DIR_INFORMATION,
bool returnSingleEntry = false,
bool restartScan = false,
bool isOutPutBufferNotEnough = false
)
{
BaseTestSite.Log.Add(LogEntryKind.TestStep, $"Query a directory information with fileid {fileId}");
MessageStatus status = this.fsaAdapter.QueryDirectoryInfo(
fileId,
treeId,
sessionId,
searchPattern,
FileInfoClass.FILE_ID_BOTH_DIR_INFORMATION,
returnSingleEntry,
restartScan,
isOutPutBufferNotEnough);
BaseTestSite.Log.Add(LogEntryKind.TestStep, $"Query directory with search pattern {searchPattern} and return with status {status}. ");
return(status);
}
private void OpenFile(
Smb2FunctionalClient client,
Guid clientGuid,
string fileName,
bool isPersistentHandle,
out Guid createGuid,
out uint treeId,
out FILEID fileId,
ResponseChecker <CREATE_Response> responseChecker = null)
{
// connect to share
ConnectToShare(
client,
clientGuid,
out treeId);
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Connect to share '{0}' on scaleout server '{1}'", testConfig.BasicFileShare, testConfig.SutComputerName);
#region Construct Create Context
List <Smb2CreateContextRequest> createContextList = new List <Smb2CreateContextRequest>();
createGuid = Guid.Empty;
if (isPersistentHandle)
{
// durable handle request context
createGuid = Guid.NewGuid();
createContextList.Add(new Smb2CreateDurableHandleRequestV2()
{
CreateGuid = createGuid,
Flags = CREATE_DURABLE_HANDLE_REQUEST_V2_Flags.DHANDLE_FLAG_PERSISTENT,
Timeout = 0 // default
});
}
#endregion
// open file
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Create Open with file name '{0}'", fileName);
Smb2CreateContextResponse[] createContextResponses;
client.Create(
treeId,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId,
out createContextResponses,
createContexts: createContextList.ToArray <Smb2CreateContextRequest>(),
checker: responseChecker
);
#region check whether Persistent Handle is created successfully with current status
if (isPersistentHandle)
{
BaseTestSite.Assert.IsTrue(
CheckDurableCreateContextResponse(createContextResponses),
"Create Response should contain Smb2CreateDurableHandleResponseV2.");
}
#endregion
}
public void Smb2Write(uint treeId, FILEID fileId, ulong offset, byte[] input)
{
Packet_Header packetHeader;
WRITE_Response response;
uint status = Write(
0,
RequestAndConsumeCredit(),
signingRequired ? Packet_Header_Flags_Values.FLAGS_SIGNED : Packet_Header_Flags_Values.NONE,
GetMessageId(),
sessionId,
treeId,
offset,
fileId,
Channel_Values.CHANNEL_NONE,
WRITE_Request_Flags_Values.None,
new byte[0],
input,
out packetHeader,
out response
);
UpdateCredit(packetHeader);
if (status != Smb2Status.STATUS_SUCCESS)
{
throw new InvalidOperationException(String.Format("Write failed with {0:X08}.", status));
}
}
public void IoCtl(uint treeId, CtlCode_Values ctlCode, FILEID fileId, IOCTL_Request_Flags_Values flag, out byte[] input, out byte[] output)
{
Packet_Header packetHeader;
IOCTL_Response response;
uint status = IoCtl(
0,
RequestAndConsumeCredit(),
signingRequired ? Packet_Header_Flags_Values.FLAGS_SIGNED : Packet_Header_Flags_Values.NONE,
GetMessageId(),
sessionId,
treeId,
ctlCode,
fileId,
0,
null,
4096,
flag,
out input,
out output,
out packetHeader,
out response
);
UpdateCredit(packetHeader);
if (status != Smb2Status.STATUS_SUCCESS)
{
throw new InvalidOperationException(String.Format("IoCtl failed with {0:X08}.", status));
}
}
private void OpenFile(out uint treeId, out FILEID fileId)
{
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"Open the file by sending the following requests: NEGOTIATE; SESSION_SETUP; TREE_CONNECT; CREATE.");
client.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress);
client.Negotiate(
TestConfig.RequestDialects,
TestConfig.IsSMB1NegotiateEnabled,
checker: (Packet_Header header, NEGOTIATE_Response response) =>
{
BaseTestSite.Assert.AreEqual(
Smb2Status.STATUS_SUCCESS,
header.Status,
"Negotiate should succeed, actually server returns {0}.", Smb2Status.GetStatusCode(header.Status));
});
client.SessionSetup(
TestConfig.DefaultSecurityPackage,
TestConfig.SutComputerName,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken);
client.TreeConnect(Smb2Utility.GetUncPath(TestConfig.SutComputerName, TestConfig.BasicFileShare), out treeId);
Smb2CreateContextResponse[] serverCreateContexts;
client.Create(
treeId,
string.Format("BVT_EnumerateSnapShots_{0}.txt", Guid.NewGuid()),
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId,
out serverCreateContexts);
}
/// <summary>
/// Create directory
/// </summary>
/// <param name="dirName">Direcotry name</param>
/// <param name="fileId">The fileid of the created directory</param>
/// <param name="treeId">The treeId of the created directory</param>
/// <param name="sessionId">The sessionId of the created directory</param>
/// <returns>An NTSTATUS code that specifies the result</returns>
private MessageStatus CreateDirectory(
string dirName,
out FILEID fileId,
out uint treeId,
out ulong sessionId)
{
BaseTestSite.Log.Add(LogEntryKind.TestStep, $"Create a directory with name: {dirName}");
MessageStatus status = MessageStatus.SUCCESS;
status = this.fsaAdapter.CreateFile(
dirName,
FileAttribute.DIRECTORY,
CreateOptions.DIRECTORY_FILE,
(FileAccess.GENERIC_READ | FileAccess.GENERIC_WRITE),
(ShareAccess.FILE_SHARE_READ | ShareAccess.FILE_SHARE_WRITE),
CreateDisposition.OPEN_IF,
out fileId,
out treeId,
out sessionId
);
BaseTestSite.Log.Add(LogEntryKind.TestStep, $"Create directory and return with status {status}");
return(status);
}
public void OplockBreakAcknowledgementRequest(OplockVolatilePortion volatilePortion, OplockPersistentPortion persistentPortion, OplockLevel_Values oplockLevel)
{
bool volatilePortionFound = volatilePortion == OplockVolatilePortion.VolatilePortionFound;
bool persistentMatchesDurableFileId = persistentPortion == OplockPersistentPortion.PersistentMatchesDurableFileId;
FILEID fileIdRequest = fileId;
if (!volatilePortionFound)
{
fileIdRequest.Volatile = FILEID.Invalid.Volatile;
}
if (!persistentMatchesDurableFileId)
{
fileIdRequest.Persistent = FILEID.Invalid.Persistent;
}
OPLOCK_BREAK_Response?oplockBreakResponse = null;
uint status = testClient.OplockAcknowledgement(
treeId,
fileIdRequest,
(OPLOCK_BREAK_Acknowledgment_OplockLevel_Values)oplockLevel,
(header, response) => oplockBreakResponse = response);
OplockBreakResponse((ModelSmb2Status)status, oplockBreakResponse.Value.OplockLevel, oplockLevelOnOpen);
}
public void SMBDRead(uint treeId, FILEID fileId, Channel_Values channel, out byte[] buffer, uint offset, uint length, RDMAEndian endian)
{
NtStatus status;
SmbdBufferDescriptorV1 descriptor;
status = smbdClient.RegisterBuffer(
(uint)length,
SmbdBufferReadWrite.RDMA_WRITE_PERMISSION_FOR_READ_FILE,
endianMap[endian],
out descriptor
);
if (status != NtStatus.STATUS_SUCCESS)
{
throw new InvalidOperationException("SMBD register buffer failed!");
}
byte[] channelInfo = TypeMarshal.ToBytes(descriptor);
Packet_Header packetHeader;
READ_Response response;
status = (NtStatus)Read(
0,
RequestAndConsumeCredit(),
signingRequired ? Packet_Header_Flags_Values.FLAGS_SIGNED : Packet_Header_Flags_Values.NONE,
GetMessageId(),
sessionId,
treeId,
length,
offset,
fileId,
length,
channel,
0,
channelInfo,
out buffer,
out packetHeader,
out response
);
UpdateCredit(packetHeader);
if (status != NtStatus.STATUS_SUCCESS)
{
throw new InvalidOperationException("Read through SMBD failed!");
}
buffer = new byte[length];
status = smbdClient.ReadRegisteredBuffer(buffer, descriptor);
if (status != NtStatus.STATUS_SUCCESS)
{
throw new InvalidOperationException("SMBD write buffer failed!");
}
}
private void ClientTearDown(Smb2FunctionalClient client, uint treeId, FILEID fileId)
{
status = client.Close(treeId, fileId);
status = client.TreeDisconnect(treeId);
status = client.LogOff();
}
private void TearDownClient(Smb2FunctionalClient client, uint clientTreeId, FILEID clientFileId)
{
if (ClientTreeConnectSessionExists(clientTreeId))
{
client.Close(clientTreeId, clientFileId);
client.TreeDisconnect(clientTreeId);
client.LogOff();
}
}
private void DisconnectToShare(uint treeId, FILEID fileId)
{
if (fileId.Persistent != 0 || fileId.Volatile != 0)
{
client.Close(treeId, fileId);
}
client.TreeDisconnect(treeId);
client.LogOff();
client.Disconnect();
}
private void SendIoctlPayload(
Smb2Client client,
CtlCode_Values code,
byte[] payload,
Packet_Header_Flags_Values headerFlags,
ulong messageId,
uint treeId,
ulong sessionId,
FILEID fileId)
{
if (client == null)
{
throw new InvalidOperationException("The transport is not connected.");
}
if (payload == null)
{
throw new ArgumentNullException("payload");
}
var request = new Smb2IOCtlRequestPacket();
request.Header.CreditCharge = 1;
request.Header.Command = Smb2Command.IOCTL;
request.Header.CreditRequestResponse = 1;
request.Header.Flags = headerFlags;
request.Header.MessageId = messageId;
request.Header.TreeId = treeId;
request.Header.SessionId = sessionId;
request.PayLoad.CtlCode = code;
if (code == CtlCode_Values.FSCTL_DFS_GET_REFERRALS || code == CtlCode_Values.FSCTL_DFS_GET_REFERRALS_EX)
{
request.PayLoad.FileId = FILEID.Invalid;
}
else
{
request.PayLoad.FileId = fileId;
}
if (payload.Length > 0)
{
request.PayLoad.InputOffset = request.BufferOffset;
request.PayLoad.InputCount = (ushort)payload.Length;
request.Buffer = payload;
}
request.PayLoad.MaxInputResponse = 0;
request.PayLoad.MaxOutputResponse = 4096;
request.PayLoad.Flags = IOCTL_Request_Flags_Values.SMB2_0_IOCTL_IS_FSCTL;
ioctlRequestMessageIds.Enqueue(request.Header.MessageId);
client.SendPacket(request);
}
protected override void TestInitialize()
{
base.TestInitialize();
smb2client = null;
//The SMB2 server MUST reserve -1 for invalid FileId
fileId = FILEID.Invalid;
// The SMB2 server MUST reserve -1 for invalid TreeId.
treeId = 0xFFFF;
}
private void PrepareFileForTrimming(out uint treeId, out FILEID fileId)
{
#region Check Applicability
TestConfig.CheckDialect(DialectRevision.Smb30);
TestConfig.CheckIOCTL(CtlCode_Values.FSCTL_FILE_LEVEL_TRIM);
#endregion
string uncSharePath = Smb2Utility.GetUncPath(TestConfig.SutComputerName, TestConfig.BasicFileShare);
string fileName = GetTestFileName(uncSharePath);
string contentWrite = Smb2Utility.CreateRandomString(TestConfig.WriteBufferLengthInKb);
smb2Functionalclient.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress);
uint status = smb2Functionalclient.Negotiate(
TestConfig.RequestDialects,
TestConfig.IsSMB1NegotiateEnabled,
checker: (Packet_Header header, NEGOTIATE_Response response) =>
{
BaseTestSite.Assert.AreEqual(
Smb2Status.STATUS_SUCCESS,
header.Status,
"CREATE should succeed, actually server returns {0}.", Smb2Status.GetStatusCode(header.Status));
TestConfig.CheckNegotiateDialect(DialectRevision.Smb30, response);
});
status = smb2Functionalclient.SessionSetup(
TestConfig.DefaultSecurityPackage,
TestConfig.SutComputerName,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken);
status = smb2Functionalclient.TreeConnect(uncSharePath, out treeId);
Smb2CreateContextResponse[] serverCreateContexts;
status = smb2Functionalclient.Create(
treeId,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId,
out serverCreateContexts);
status = smb2Functionalclient.Write(treeId, fileId, contentWrite);
status = smb2Functionalclient.Close(treeId, fileId);
status = smb2Functionalclient.Create(
treeId,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId,
out serverCreateContexts);
}
private void OpenFileAndResilientRequest(
Smb2FunctionalClient client,
Guid clientGuid,
string fileName,
uint timeoutInMilliSeconds,
out FILEID fileId)
{
uint treeId;
// connect to share
ConnectToShare(
client,
clientGuid,
out treeId);
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Connect to share '{0}' on server '{1}'", testConfig.BasicFileShare, testConfig.SutComputerName);
// open file
Smb2CreateContextResponse[] createContextResponse;
client.Create(
treeId,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId,
out createContextResponse
);
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Create Open with file name '{0}'", fileName);
// resiliency request
Packet_Header ioCtlHeader;
IOCTL_Response ioCtlResponse;
byte[] inputInResponse;
byte[] outputInResponse;
client.ResiliencyRequest(
treeId,
fileId,
timeoutInMilliSeconds,
(uint)Marshal.SizeOf(typeof(NETWORK_RESILIENCY_Request)),
out ioCtlHeader,
out ioCtlResponse,
out inputInResponse,
out outputInResponse
);
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Resiliency request with timeout {0} milliseconds", timeoutInMilliSeconds);
}
private void QueryDirectory(
FILEID dirFileId,
uint treeId,
ulong sessionId,
FileInfoClass fileInfoClass,
out byte[] outputBuffer,
string searchPattern = "*"
)
{
MessageStatus status = this.fsaAdapter.QueryDirectory(dirFileId, treeId, sessionId, searchPattern, fileInfoClass, false, true, out outputBuffer);
BaseTestSite.Assert.AreEqual(MessageStatus.SUCCESS, status, "Query directory should succeed.");
}
private void ReadFromAlternativeChannel(
IPAddress serverIp,
IPAddress clientIp,
uint lengthRead,
uint treeId,
FILEID fileId,
out string contentRead)
{
ReadFromAlternativeChannel(
TestConfig.RequestDialects,
DialectRevision.Smb30,
serverIp, clientIp, lengthRead, treeId, fileId,
out contentRead);
}
private void WriteFromMainChannel(
IPAddress serverIp,
IPAddress clientIp,
string contentWrite,
bool isNicRedundantOnServer,
out uint treeId,
out FILEID fileId)
{
WriteFromMainChannel(
TestConfig.RequestDialects,
DialectRevision.Smb30,
serverIp, clientIp, contentWrite, isNicRedundantOnServer,
out treeId, out fileId);
}
public override void Reset()
{
if (testClientBeforeDisconnection != null)
{
testClientBeforeDisconnection.Disconnect();
}
if (testClientAfterDisconnection != null)
{
testClientAfterDisconnection.Disconnect();
}
fileIdBeforDisconnection = FILEID.Zero;
base.Reset();
}
public uint Create(
uint treeId,
string fileName,
CreateOptions_Values createOptions,
out FILEID fileId,
out Smb2CreateContextResponse[] serverCreateContexts,
RequestedOplockLevel_Values requestedOplockLevel_Values = RequestedOplockLevel_Values.OPLOCK_LEVEL_NONE,
Smb2CreateContextRequest[] createContexts = null,
Packet_Header_Flags_Values headerFlag = Packet_Header_Flags_Values.FLAGS_SIGNED,
AccessMask accessMask = AccessMask.GENERIC_READ | AccessMask.GENERIC_WRITE,
ShareAccess_Values shareAccess = ShareAccess_Values.FILE_SHARE_READ | ShareAccess_Values.FILE_SHARE_WRITE | ShareAccess_Values.FILE_SHARE_DELETE,
ResponseChecker <CREATE_Response> checker = null,
ushort creditRequest = 64)
{
Packet_Header header;
CREATE_Response createResponse;
uint status = client.Create(
1,
creditRequest,
headerFlag,
messageId++,
sessionId,
treeId,
fileName,
accessMask,
shareAccess,
createOptions,
CreateDisposition_Values.FILE_OPEN_IF,
File_Attributes.NONE,
ImpersonationLevel_Values.Impersonation,
SecurityFlags_Values.NONE,
requestedOplockLevel_Values,
createContexts,
out fileId,
out serverCreateContexts,
out header,
out createResponse);
InnerResponseChecker(checker, header, createResponse);
grantedCredit = header.CreditRequestResponse;
return(status);
}
protected override void TestInitialize()
{
base.TestInitialize();
testConfig = new SqosTestConfig(BaseTestSite);
BaseTestSite.DefaultProtocolDocShortName = "MS-SQOS";
BaseTestSite.Log.Add(LogEntryKind.Debug, "SecurityPackage for authentication: " + TestConfig.DefaultSecurityPackage);
client = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
treeId = 0;
fileId = FILEID.Zero;
#region Check Applicability
TestConfig.CheckIOCTL(CtlCode_Values.FSCTL_STORAGE_QOS_CONTROL);
#endregion
}
private void ReconnectResilientHandle(
Smb2FunctionalClient client,
Guid clientGuid,
string fileName,
FILEID fileId,
NtStatus expectedReconnectStatus,
string message)
{
uint treeId;
ConnectToShare(
client,
clientGuid,
out treeId);
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Reconnect to resilient handle");
Smb2CreateContextResponse[] createContextResponse;
uint status = client.Create(
treeId,
fileName,
CreateOptions_Values.NONE,
out fileId,
out createContextResponse,
createContexts: new Smb2CreateContextRequest[]
{
new Smb2CreateDurableHandleReconnect()
{
Data = fileId
}
},
checker: (header, response) =>
{
// do nothing, skip the exception
}
);
BaseTestSite.Assert.AreEqual <NtStatus>(
expectedReconnectStatus,
(NtStatus)status,
message);
}
public override void Reset()
{
if (testClientBeforeDisconnection != null)
{
testClientBeforeDisconnection.Disconnect();
}
if (testClientAfterDisconnection != null)
{
testClientAfterDisconnection.Disconnect();
}
fileIdBeforDisconnection = FILEID.Zero;
// Add test file to collection, to delete it in Reset() of base;
AddTestFileName(sharePath, fileName);
base.Reset();
}
private void PrepareTestFile(string content, out uint treeId, out FILEID fileId)
{
client.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Start the client by sending the following requests: NEGOTIATE; SESSION_SETUP; TREE_CONNECT");
client.Negotiate(
TestConfig.RequestDialects,
TestConfig.IsSMB1NegotiateEnabled,
checker: (Packet_Header header, NEGOTIATE_Response response) =>
{
BaseTestSite.Assert.AreEqual(
Smb2Status.STATUS_SUCCESS,
header.Status,
"NEGOTIATE should succeed.");
TestConfig.CheckNegotiateDialect(DialectRevision.Smb30, response);
});
client.SessionSetup(
TestConfig.DefaultSecurityPackage,
TestConfig.SutComputerName,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken);
string uncSharePath = Smb2Utility.GetUncPath(TestConfig.SutComputerName, TestConfig.BasicFileShare);
client.TreeConnect(uncSharePath, out treeId);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client writes to the file.");
Smb2CreateContextResponse[] serverCreateContexts;
client.Create(
treeId,
GetTestFileName(uncSharePath),
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId,
out serverCreateContexts);
client.Write(treeId, fileId, content);
// Flush written content to backend storage to avoid cache.
client.Flush(treeId, fileId);
}
private void CreateDirectory(
string dirName,
out FILEID fileId,
out uint treeId,
out ulong sessionId)
{
MessageStatus status = this.fsaAdapter.CreateFile(
dirName,
FileAttribute.DIRECTORY,
CreateOptions.DIRECTORY_FILE,
(FileAccess.GENERIC_READ | FileAccess.GENERIC_WRITE),
(ShareAccess.FILE_SHARE_READ | ShareAccess.FILE_SHARE_WRITE),
CreateDisposition.CREATE,
out fileId,
out treeId,
out sessionId
);
BaseTestSite.Assert.AreEqual(MessageStatus.SUCCESS, status, "Create directory should succeed.");
}
public void CreateRandomFile(uint treeId, out FILEID fileId)
{
Packet_Header packetHeader;
CREATE_Response response;
string fileName = string.Format("{0}.txt", Guid.NewGuid());
Smb2CreateContextResponse[] createContextResponse;
uint status = Create(
0,
RequestAndConsumeCredit(),
signingRequired ? Packet_Header_Flags_Values.FLAGS_SIGNED : Packet_Header_Flags_Values.NONE,
GetMessageId(),
sessionId,
treeId,
fileName,
AccessMask.GENERIC_READ | AccessMask.GENERIC_WRITE,
ShareAccess_Values.NONE,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
CreateDisposition_Values.FILE_CREATE,
File_Attributes.FILE_ATTRIBUTE_NORMAL,
ImpersonationLevel_Values.Impersonation,
SecurityFlags_Values.NONE,
RequestedOplockLevel_Values.OPLOCK_LEVEL_NONE,
null,
out fileId,
out createContextResponse,
out packetHeader,
out response
);
UpdateCredit(packetHeader);
if (status != Smb2Status.STATUS_SUCCESS)
{
throw new InvalidOperationException(String.Format("Create failed with {0:X08}.", status));
}
}
/// <summary>
/// Create operation for Open operation
/// </summary>
private uint OpenCreate(
Smb2FunctionalClient client,
uint treeIdAfterDisconnection,
string fileName,
out FILEID fileIdAfterDisconnection,
out Smb2CreateContextResponse[] serverCreateContexts,
RequestedOplockLevel_Values requestedOplocklevel,
Smb2CreateContextRequest[] openContext)
{
return(client.Create(
treeIdAfterDisconnection,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileIdAfterDisconnection,
out serverCreateContexts,
requestedOplocklevel,
openContext,
shareAccess: ShareAccess_Values.NONE,
checker: (header, response) =>
{
}));
}
/// <summary>
/// Create operation for PrepareOpen operation
/// </summary>
private void PrepareOpenCreate(
Smb2FunctionalClient client,
uint treeIdBeforeDisconnection,
string fileName,
out FILEID fileIdBeforDisconnection,
out Smb2CreateContextResponse[] serverCreateContexts,
RequestedOplockLevel_Values requestedOplocklevel,
Smb2CreateContextRequest[] prepareContext)
{
client.Create(
treeIdBeforeDisconnection,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileIdBeforDisconnection,
out serverCreateContexts,
requestedOplocklevel,
prepareContext,
shareAccess: ShareAccess_Values.NONE,
checker: (HASH_HEADER, response) =>
{
});
}
/// <summary>
/// Reset all member variables before running next test case
/// </summary>
public override void Reset()
{
if (firstClient != null)
{
firstClient.Disconnect();
firstClient = null;
}
if (secondClient != null)
{
secondClient.Disconnect();
secondClient = null;
}
fileName = null;
leaseBreakState = LeaseBreakState.NoLeaseBreak;
treeId1 = 0;
treeId2 = 0;
fileId1 = FILEID.Zero;
fileId2 = FILEID.Zero;
base.Reset();
}
public uint Close(uint treeId, FILEID fileId, ResponseChecker <CLOSE_Response> checker = null, ushort creditRequest = 1)
{
Packet_Header header;
CLOSE_Response closeResponse;
uint status = client.Close(
1,
creditRequest,
Packet_Header_Flags_Values.FLAGS_SIGNED,
messageId++,
sessionId,
treeId,
fileId,
Flags_Values.NONE,
out header,
out closeResponse);
InnerResponseChecker(checker, header, closeResponse);
grantedCredit = header.CreditRequestResponse;
return(status);
}
