private void CheckCreateContextResponsesExistence(Smb2CreateContextResponse[] createContextResponse, bool shouldExist, params BaseResponseChecker[] checkers)
{
foreach (var checker in checkers)
{
bool found = false;
if (createContextResponse != null)
{
foreach (var response in createContextResponse)
{
if (response.GetType() == checker.ResponseType)
{
checker.Check(response);
found = true;
break;
}
}
}
if (shouldExist && !found)
{
BaseTestSite.Assert.Fail("The expected response {0} does not exist.", checker.ResponseType);
}
if (!shouldExist && found)
{
BaseTestSite.Assert.Fail("The response {0} should not exist.", checker.ResponseType);
}
}
}
public override void Check(Smb2CreateContextResponse response)
{
base.Check(response);
Smb2CreateDurableHandleResponseV2 durableHandleResponse = response as Smb2CreateDurableHandleResponseV2;
TestSite.Assert.AreEqual(flag, durableHandleResponse.Flags, "Flag in the response is expected to be {0}. The actual value is {1}.", flag, durableHandleResponse.Flags);
if (timeout != uint.MaxValue)
{
TestSite.Assert.AreEqual(timeout, durableHandleResponse.Timeout, "Timeout in the response is expected to be {0}. The actual value is {1}.", timeout, durableHandleResponse.Timeout);
}
}
public override void Check(Smb2CreateContextResponse response)
{
base.Check(response);
Smb2CreateResponseLease leaseResponse = response as Smb2CreateResponseLease;
TestSite.Assert.AreEqual(leaseKey, leaseResponse.LeaseKey, "LeaseKey in the response is expected to be {0}. The actual value is {1}.", leaseKey, leaseResponse.LeaseKey);
TestSite.Assert.AreEqual(leaseState, leaseResponse.LeaseState, "LeaseState in the response is expected to be {0}. The actual value is {1}.", leaseState, leaseResponse.LeaseState);
TestSite.Assert.AreEqual(leaseFlag, leaseResponse.LeaseFlags, "LeaseFlag in the response is expected to be {0}. The actual value is {1}.", leaseFlag, leaseResponse.LeaseFlags);
TestSite.CaptureRequirementIfAreEqual <ulong>(0, leaseResponse.LeaseDuration,
RequirementCategory.MUST_BE_ZERO.Id,
RequirementCategory.MUST_BE_ZERO.Description);
}
private bool CheckOpenDeviceContext(Smb2CreateContextResponse[] servercreatecontexts, RSVD_PROTOCOL_VERSION expectVersion)
{
if (servercreatecontexts == null)
{
if (expectVersion == RSVD_PROTOCOL_VERSION.RSVD_PROTOCOL_VERSION_1)
{
// <10> Section 3.2.5.1: Windows Server 2012 R2 without [MSKB-3025091] doesn't return SVHDX_OPEN_DEVICE_CONTEXT_RESPONSE.
// So if the open device context returns success, but without SVHDX_OPEN_DEVICE_CONTEXT_RESPONSE, the SUT may still support RSVD version 1.
return true;
}
else
{
return false;
}
}
foreach (var context in servercreatecontexts)
{
Type type = context.GetType();
if (type.Name == "Smb2CreateSvhdxOpenDeviceContextResponse")
{
Smb2CreateSvhdxOpenDeviceContextResponse openDeviceContext = context as Smb2CreateSvhdxOpenDeviceContextResponse;
if ((openDeviceContext != null) && (openDeviceContext.Version == (uint)expectVersion))
{
return true;
}
}
if (type.Name == "Smb2CreateSvhdxOpenDeviceContextResponseV2")
{
Smb2CreateSvhdxOpenDeviceContextResponseV2 openDeviceContext = context as Smb2CreateSvhdxOpenDeviceContextResponseV2;
if ((openDeviceContext != null) && (openDeviceContext.Version == (uint)expectVersion))
{
return true;
}
}
}
return false;
}
/// <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>
/// Create a file with create context
/// </summary>
/// <param name="fileName">Name of the file</param>
/// <param name="desiredAccess">The desired access</param>
/// <param name="shareAccess">Sharing mode for the open</param>
/// <param name="impersonationLevel">The impersonation level</param>
/// <param name="fileAttribute">The file attribute, this field is only valid when create file.</param>
/// <param name="createDisposition">Defines the action the server MUST take if the file that is specified in the name field already exists</param>
/// <param name="createOption">Specifies the options to be applied when creating or opening the file</param>
/// <param name="contextRequest">Create contexts to be sent in the create request</param>
/// <param name="status">Status of the response packet</param>
/// <param name="serverCreateContexts">Create contexts to be received in the create response</param>
/// <param name="contextResponse">Create response payload to be received in the create response</param>
public void Create(
string fileName,
FsFileDesiredAccess desiredAccess,
ShareAccess_Values shareAccess,
FsImpersonationLevel impersonationLevel,
FsFileAttribute fileAttribute,
FsCreateDisposition createDisposition,
FsCreateOption createOption,
Smb2CreateContextRequest[] contextRequest,
out uint status,
out Smb2CreateContextResponse[] serverCreateContexts,
out CREATE_Response createResponse)
{
if (createOption.HasFlag(FsCreateOption.FILE_DIRECTORY_FILE))
{
throw new ArgumentException("createOption can not contain FILE_DIRECTORY_FILE when creating file.");
}
Packet_Header header;
status = client.Create(
1,
1,
headerFlags,
messageId++,
sessionId,
treeId,
fileName,
(AccessMask)desiredAccess,
shareAccess,
(CreateOptions_Values)createOption,
(CreateDisposition_Values)createDisposition,
(File_Attributes)fileAttribute,
(ImpersonationLevel_Values)impersonationLevel,
SecurityFlags_Values.NONE,
RequestedOplockLevel_Values.OPLOCK_LEVEL_NONE,
contextRequest,
out fileId,
out serverCreateContexts,
out header,
out createResponse);
}
/// <summary>
/// Check server response. Return the abstracted context type of response.
/// </summary>
private void CheckResponseContexts(
Smb2CreateContextResponse[] serverCreateContexts,
out DurableHandleResponseContext durableHandleResponseContext,
out LeaseResponseContext leaseResponseContext)
{
durableHandleResponseContext = DurableHandleResponseContext.NONE;
leaseResponseContext = LeaseResponseContext.NONE;
if (serverCreateContexts != null)
{
foreach (Smb2CreateContextResponse response in serverCreateContexts)
{
if (response is Smb2CreateDurableHandleResponse)
{
durableHandleResponseContext = DurableHandleResponseContext.SMB2_CREATE_DURABLE_HANDLE_RESPONSE;
}
else if (response is Smb2CreateDurableHandleResponseV2)
{
durableHandleResponseContext = DurableHandleResponseContext.SMB2_CREATE_DURABLE_HANDLE_RESPONSE_V2;
if ((response as Smb2CreateDurableHandleResponseV2).Flags.HasFlag(CREATE_DURABLE_HANDLE_RESPONSE_V2_Flags.DHANDLE_FLAG_PERSISTENT))
durableHandleResponseContext = DurableHandleResponseContext.SMB2_CREATE_DURABLE_HANDLE_RESPONSE_V2_WITH_PERSISTENT;
}
else if (response is Smb2CreateResponseLease)
{
leaseResponseContext = LeaseResponseContext.SMB2_CREATE_RESPONSE_LEASE;
}
else if (response is Smb2CreateResponseLeaseV2)
{
leaseResponseContext = LeaseResponseContext.SMB2_CREATE_RESPONSE_LEASE_V2;
}
}
}
}
/// <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) =>
{
});
}
private bool CheckDurableCreateContextResponse(Smb2CreateContextResponse[] createContextResponses)
{
// check whether Persistent Handle is created successfully
foreach (Smb2CreateContextResponse contextResponse in createContextResponses)
{
Smb2CreateDurableHandleResponseV2 durableHandleResponse = contextResponse as Smb2CreateDurableHandleResponseV2;
if (durableHandleResponse != null)
{
BaseTestSite.Assert.IsTrue(
durableHandleResponse.Flags.HasFlag(CREATE_DURABLE_HANDLE_RESPONSE_V2_Flags.DHANDLE_FLAG_PERSISTENT),
"Flags in Smb2CreateDurableHandleResponseV2 should be Persistent flag");
return true;
}
}
return false;
}
private void CheckOpenDeviceContext(Smb2CreateContextResponse[] servercreatecontexts)
{
// <9> Section 3.2.5.1: Windows Server 2012 R2 without [MSKB-3025091] doesn't return SVHDX_OPEN_DEVICE_CONTEXT_RESPONSE.
if (TestConfig.Platform == Platform.WindowsServer2012R2)
return;
foreach (var context in servercreatecontexts)
{
Type type = context.GetType();
if (type.Name == "Smb2CreateSvhdxOpenDeviceContext")
{
Smb2CreateSvhdxOpenDeviceContextResponse openDeviceContext = context as Smb2CreateSvhdxOpenDeviceContextResponse;
VerifyFieldInResponse("ServerVersion", TestConfig.ServerServiceVersion, openDeviceContext.Version);
}
if (type.Name == "Smb2CreateSvhdxOpenDeviceContextResponseV2")
{
Smb2CreateSvhdxOpenDeviceContextResponseV2 openDeviceContext = context as Smb2CreateSvhdxOpenDeviceContextResponseV2;
VerifyFieldInResponse("ServerVersion", TestConfig.ServerServiceVersion, openDeviceContext.Version);
VerifyFieldInResponse("SectorSize", TestConfig.PhysicalSectorSize, openDeviceContext.PhysicalSectorSize);
VerifyFieldInResponse("VirtualSize", TestConfig.VirtualSize, openDeviceContext.VirtualSize);
}
}
}
public void SendRequestContext(Smb2CreateContextRequest client1RequestLease, Smb2CreateContextRequest client2RequestLease, out Smb2CreateContextResponse client1ResponseLease,
out Smb2CreateContextResponse client2ResponseLease, bool isBothClientDirectory = false, bool isClient1ParentDirectory = false, bool expectServerBreakNotification = false)
{
string client1FileName;
string client2FileName;
GenerateFileNames(isBothClientDirectory, isClient1ParentDirectory, out client1FileName, out client2FileName);
#region Add Event Handler
client1.Smb2Client.LeaseBreakNotificationReceived += new Action <Packet_Header, LEASE_BREAK_Notification_Packet>(OnLeaseBreakNotificationReceived);
clientToAckLeaseBreak = client1;
#endregion
#region Client1 (LeaseOpen) Open a File with Lease RWH or Directory with RH
BaseTestSite.Log.Add(LogEntryKind.TestStep,
"Start the first client to create a file by sending the following requests: 1. NEGOTIATE; 2. SESSION_SETUP; 3. TREE_CONNECT; 4. CREATE (with LeaseV2 context)");
SetupClientConnection(client1, out client1TreeId);
Smb2CreateContextResponse[] createContextResponse;
client1.Create(client1TreeId, client1FileName, isBothClientDirectory || isClient1ParentDirectory ? CreateOptions_Values.FILE_DIRECTORY_FILE : CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out client1FileId, out createContextResponse, RequestedOplockLevel_Values.OPLOCK_LEVEL_LEASE,
new Smb2CreateContextRequest[]
{
client1RequestLease
},
checker: (Packet_Header header, CREATE_Response response) =>
{
if (response.OplockLevel != OplockLevel_Values.OPLOCK_LEVEL_LEASE)
{
BaseTestSite.Assume.Inconclusive("Server OPLOCK Level is: {0}, expected: {1} indicating support for leasing.", response.OplockLevel, OplockLevel_Values.OPLOCK_LEVEL_LEASE);
}
}
);
#endregion
// Get response lease for Client1 (LeaseOpen)
client1ResponseLease = (createContextResponse != null) ? createContextResponse.First() : new Smb2CreateResponseLease();
#region Start a second client (OperationOpen) to request lease by using the same lease key with the first client
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Start a second client to create the same file with the first client by sending the following requests: 1. NEGOTIATE; 2. SESSION_SETUP; 3. TREE_CONNECT; 4. CREATE");
SetupClientConnection(client2, out client2TreeId);
client2.Create(client2TreeId, client2FileName, isBothClientDirectory ? CreateOptions_Values.FILE_DIRECTORY_FILE : CreateOptions_Values.FILE_NON_DIRECTORY_FILE, out client2FileId, out createContextResponse, RequestedOplockLevel_Values.OPLOCK_LEVEL_LEASE,
new Smb2CreateContextRequest[]
{
client2RequestLease
},
checker: (Packet_Header header, CREATE_Response response) =>
{
if (response.OplockLevel != OplockLevel_Values.OPLOCK_LEVEL_LEASE)
{
BaseTestSite.Assume.Inconclusive("Server OPLOCK Level is: {0}, expected: {1} indicating support for leasing.", response.OplockLevel, OplockLevel_Values.OPLOCK_LEVEL_LEASE);
}
}
);
#endregion
// Check whether server will send out lease break notification or not
CheckBreakNotification(expectServerBreakNotification);
// Get response lease for Client2 (OperationOpen)
client2ResponseLease = createContextResponse.First();
}
private ReplayModelDurableHandle ConvertHandle(Smb2CreateContextResponse[] serverCreateContexts)
{
ReplayModelDurableHandle responseHandle = ReplayModelDurableHandle.NormalHandle;
if (serverCreateContexts != null)
{
foreach (var context in serverCreateContexts)
{
if (context is Smb2CreateDurableHandleResponse)
{
responseHandle = ReplayModelDurableHandle.DurableHandleV1;
break;
}
else if (context is Smb2CreateDurableHandleResponseV2)
{
Smb2CreateDurableHandleResponseV2 handleV2 = context as Smb2CreateDurableHandleResponseV2;
if (handleV2.Flags == CREATE_DURABLE_HANDLE_RESPONSE_V2_Flags.DHANDLE_FLAG_PERSISTENT)
{
responseHandle = ReplayModelDurableHandle.DurableHandleV2Persistent;
}
else
{
responseHandle = ReplayModelDurableHandle.DurableHandleV2;
}
break;
}
}
}
return responseHandle;
}
public override void Check(Smb2CreateContextResponse response)
{
base.Check(response);
Smb2CreateResponseLeaseV2 leaseResponse = response as Smb2CreateResponseLeaseV2;
TestSite.Assert.AreEqual(leaseKey, leaseResponse.LeaseKey, "LeaseKey in the response is expected to be {0}. The actual value is {1}.", leaseKey, leaseResponse.LeaseKey);
TestSite.Assert.AreEqual(leaseState, leaseResponse.LeaseState, "LeaseState in the response is expected to be {0}. The actual value is {1}.", leaseState, leaseResponse.LeaseState);
TestSite.Assert.AreEqual(leaseFlag, leaseResponse.Flags, "LeaseFlag in the response is expected to be {0}. The actual value is {1}.", leaseFlag, leaseResponse.Flags);
if (parentLeaseKey != default(Guid))
{
TestSite.Assert.AreEqual(parentLeaseKey, leaseResponse.ParentLeaseKey,
"ParentLeaseKey in the response is expected to be {0}. The actual value is {1}.",
parentLeaseKey, leaseResponse.ParentLeaseKey);
}
TestSite.CaptureRequirementIfAreEqual<ulong>(0, leaseResponse.LeaseDuration,
RequirementCategory.MUST_BE_ZERO.Id,
RequirementCategory.MUST_BE_ZERO.Description);
}
private void CheckOpenDeviceContext(Smb2CreateContextResponse[] servercreatecontexts)
{
foreach (var context in servercreatecontexts)
{
Type type = context.GetType();
if (type.Name == "Smb2CreateSvhdxOpenDeviceContext")
{
Smb2CreateSvhdxOpenDeviceContextResponse openDeviceContext = context as Smb2CreateSvhdxOpenDeviceContextResponse;
VerifyFieldInResponse("ServerVersion", TestConfig.ServerServiceVersion, openDeviceContext.Version);
}
if (type.Name == "Smb2CreateSvhdxOpenDeviceContextResponseV2")
{
Smb2CreateSvhdxOpenDeviceContextResponseV2 openDeviceContext = context as Smb2CreateSvhdxOpenDeviceContextResponseV2;
VerifyFieldInResponse("ServerVersion", TestConfig.ServerServiceVersion, openDeviceContext.Version);
VerifyFieldInResponse("SectorSize", TestConfig.PhysicalSectorSize, openDeviceContext.PhysicalSectorSize);
VerifyFieldInResponse("VirtualSize", TestConfig.VirtualSize, openDeviceContext.VirtualSize);
}
}
}
protected void CheckCreateContextResponsesNotExist(Smb2CreateContextResponse[] createContextResponse, params BaseResponseChecker[] checkers)
{
CheckCreateContextResponsesExistence(createContextResponse, false, checkers);
}
private static bool ContainDurableHandleResponse(Smb2CreateContextResponse[] createContextResponses)
{
if (createContextResponses != null)
{
foreach (Smb2CreateContextResponse createContextResponse in createContextResponses)
{
Smb2CreateDurableHandleResponse durableHandleResponse = createContextResponse as Smb2CreateDurableHandleResponse;
if (durableHandleResponse != null)
{
return true;
}
}
}
return false;
}
public virtual void Check(Smb2CreateContextResponse response)
{
TestSite.Assume.AreEqual(ResponseType, response.GetType(),
"The response type should be {0}. The actual value is {1}.", ResponseType, response.GetType());
}
public virtual void Check(Smb2CreateContextResponse response)
{
TestSite.Assume.AreEqual(ResponseType, response.GetType(),
"The response type should be {0}. The actual value is {1}.", ResponseType, response.GetType());
}
public override void Check(Smb2CreateContextResponse response)
{
base.Check(response);
Smb2CreateDurableHandleResponseV2 durableHandleResponse = response as Smb2CreateDurableHandleResponseV2;
TestSite.Assert.AreEqual(flag, durableHandleResponse.Flags, "Flag in the response is expected to be {0}. The actual value is {1}.", flag, durableHandleResponse.Flags);
if (timeout != uint.MaxValue)
{
TestSite.Assert.AreEqual(timeout, durableHandleResponse.Timeout, "Timeout in the response is expected to be {0}. The actual value is {1}.", timeout, durableHandleResponse.Timeout);
}
}
