public void BVT_SMB2Basic_CancelRegisteredChangeNotify()
{
uint status;
string testDirectory = CreateTestDirectory(TestConfig.SutComputerName, TestConfig.BasicFileShare);
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Test directory \"{0}\" was created on share \"{1}\"", testDirectory, TestConfig.BasicFileShare);
client1 = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
client1.Smb2Client.ChangeNotifyResponseReceived += new Action<FILE_NOTIFY_INFORMATION[],Packet_Header,CHANGE_NOTIFY_Response>(OnChangeNotifyResponseReceived);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Start a client to create a file by sending the following requests: NEGOTIATE; SESSION_SETUP; TREE_CONNECT; CREATE");
client1.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress);
status = client1.Negotiate(TestConfig.RequestDialects, TestConfig.IsSMB1NegotiateEnabled);
status = client1.SessionSetup(
TestConfig.DefaultSecurityPackage,
TestConfig.SutComputerName,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken);
uint treeId1;
status = client1.TreeConnect(uncSharePath, out treeId1);
Smb2CreateContextResponse[] serverCreateContexts;
FILEID fileId1;
status = client1.Create(
treeId1,
testDirectory,
CreateOptions_Values.FILE_DIRECTORY_FILE,
out fileId1,
out serverCreateContexts);
BaseTestSite.Log.Add(
LogEntryKind.Comment,
"Client starts to register CHANGE_NOTIFY on directory \"{0}\"", testDirectory);
client1.ChangeNotify(treeId1, fileId1, CompletionFilter_Values.FILE_NOTIFY_CHANGE_LAST_ACCESS);
BaseTestSite.Log.Add(
LogEntryKind.Comment,
"Client starts to cancel the registered CHANGE_NOTIFY on directory \"{0}\"", testDirectory);
client1.Cancel();
BaseTestSite.Assert.IsTrue(
changeNotificationReceived.WaitOne(TestConfig.WaitTimeoutInMilliseconds),
"Change notification should be received within {0} milliseconds", TestConfig.WaitTimeoutInMilliseconds);
BaseTestSite.Assert.AreNotEqual(
Smb2Status.STATUS_SUCCESS,
receivedChangeNotifyHeader.Status, "CHANGE_NOTIFY is not expected to success after cancel, actually server returns {0}.",
Smb2Status.GetStatusCode(receivedChangeNotifyHeader.Status));
BaseTestSite.CaptureRequirementIfAreEqual(
Smb2Status.STATUS_CANCELLED,
receivedChangeNotifyHeader.Status,
RequirementCategory.STATUS_CANCELLED.Id,
RequirementCategory.STATUS_CANCELLED.Description);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Tear down the client by sending the following requests: CLOSE; TREE_DISCONNECT; LOG_OFF");
client1.Close(treeId1, fileId1);
client1.TreeDisconnect(treeId1);
client1.LogOff();
}
private void AppInstanceIdTest(
bool sameAppInstanceId,
bool containCreateDurableContext,
uint expectedCreateResponseStatus,
uint expectedInitialOpenStatusAfterReopen)
{
string content = Smb2Utility.CreateRandomString(TestConfig.WriteBufferLengthInKb);
#region Client 1 Connect to Server
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Start the first client by sending the following requests: NEGOTIATE; SESSION_SETUP; TREE_CONNECT");
clientForInitialOpen = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
clientForInitialOpen.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress, TestConfig.ClientNic1IPAddress);
clientForInitialOpen.Negotiate(TestConfig.RequestDialects, TestConfig.IsSMB1NegotiateEnabled);
clientForInitialOpen.SessionSetup(
TestConfig.DefaultSecurityPackage,
TestConfig.SutComputerName,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken);
uint treeIdForInitialOpen;
clientForInitialOpen.TreeConnect(sharePath, out treeIdForInitialOpen);
Guid appInstanceId = Guid.NewGuid();
FILEID fileIdForInitialOpen;
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"The first client sends CREATE request for exclusive open with SMB2_CREATE_APP_INSTANCE_ID create context.");
Smb2CreateContextResponse[] serverCreateContexts;
Smb2CreateContextRequest[] createContextsRequestForInitialOpen = null;
if (containCreateDurableContext)
{
BaseTestSite.Log.Add(LogEntryKind.TestStep, "SMB2_CREATE_DURABLE_HANDLE_REQUEST_V2 create context is also included in the CREATE request.");
createContextsRequestForInitialOpen = new Smb2CreateContextRequest[] {
new Smb2CreateDurableHandleRequestV2
{
CreateGuid = Guid.NewGuid()
},
new Smb2CreateAppInstanceId
{
AppInstanceId = appInstanceId
}
};
}
else
{
BaseTestSite.Log.Add(LogEntryKind.TestStep, "SMB2_CREATE_DURABLE_HANDLE_REQUEST_V2 create context is not included in the CREATE request.");
createContextsRequestForInitialOpen = new Smb2CreateContextRequest[] {
new Smb2CreateAppInstanceId
{
AppInstanceId = appInstanceId
}
};
}
clientForInitialOpen.Create(
treeIdForInitialOpen,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileIdForInitialOpen,
out serverCreateContexts,
RequestedOplockLevel_Values.OPLOCK_LEVEL_NONE,
createContextsRequestForInitialOpen,
shareAccess: ShareAccess_Values.NONE);
#endregion
#region Client 2 Connect to Server
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Start the second client by sending the following requests: NEGOTIATE; SESSION-SETUP; TREE_CONNECT");
clientForReOpen = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
clientForReOpen.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress, TestConfig.ClientNic2IPAddress);
clientForReOpen.Negotiate(TestConfig.RequestDialects, TestConfig.IsSMB1NegotiateEnabled);
clientForReOpen.SessionSetup(
TestConfig.DefaultSecurityPackage,
TestConfig.SutComputerName,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken);
uint treeIdForReOpen;
clientForReOpen.TreeConnect(sharePath, out treeIdForReOpen);
FILEID fileIdForReOpen;
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"The second client sends CREATE request for exclusive open with the {0} SMB2_CREATE_APP_INSTANCE_ID of the first client.", sameAppInstanceId ? "same" : "different");
Smb2CreateContextRequest[] createContextsRequestForReOpen = null;
if (containCreateDurableContext)
{
BaseTestSite.Log.Add(LogEntryKind.TestStep, "SMB2_CREATE_DURABLE_HANDLE_REQUEST_V2 create context is also included in the CREATE request.");
createContextsRequestForReOpen = new Smb2CreateContextRequest[] {
new Smb2CreateDurableHandleRequestV2
{
CreateGuid = Guid.NewGuid()
},
new Smb2CreateAppInstanceId
{
AppInstanceId = sameAppInstanceId ? appInstanceId : Guid.NewGuid()
}
};
}
else
{
BaseTestSite.Log.Add(LogEntryKind.TestStep, "SMB2_CREATE_DURABLE_HANDLE_REQUEST_V2 create context is not included in the CREATE request.");
createContextsRequestForReOpen = new Smb2CreateContextRequest[] {
new Smb2CreateAppInstanceId
{
AppInstanceId = sameAppInstanceId ? appInstanceId : Guid.NewGuid()
}
};
}
clientForReOpen.Create(
treeIdForReOpen,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileIdForReOpen,
out serverCreateContexts,
RequestedOplockLevel_Values.OPLOCK_LEVEL_NONE,
createContextsRequestForReOpen,
shareAccess: ShareAccess_Values.NONE,
checker: (header, response) =>
{
BaseTestSite.Assert.AreEqual(
expectedCreateResponseStatus,
header.Status,
(expectedCreateResponseStatus == Smb2Status.STATUS_SUCCESS ? //non-Windows should also success
"The open will be closed. Create should succeed. Actually server returns with {0}."
: "The open cannot be closed. Create should not succeed. Actually server returns with {0}."),
Smb2Status.GetStatusCode(header.Status));
});
BaseTestSite.Log.Add(LogEntryKind.TestStep, "The first client sends another WRITE request.");
clientForInitialOpen.Write(treeIdForInitialOpen, fileIdForInitialOpen, content,
checker: (header, response) =>
{
if (TestConfig.Platform == Platform.NonWindows)
{
BaseTestSite.Assert.AreNotEqual(
Smb2Status.STATUS_SUCCESS,
header.Status,
"The initial open is closed. Write should not succeed. Actually server returns with {0}.",
Smb2Status.GetStatusCode(header.Status));
}
else
{
BaseTestSite.Assert.AreEqual(
expectedInitialOpenStatusAfterReopen,
header.Status,
(expectedInitialOpenStatusAfterReopen == Smb2Status.STATUS_SUCCESS ?
"The initial open is not closed. Write should succeed. Actually server returns with {0}."
: "The initial open is closed. Write should not succeed. Actually server returns with {0}."),
Smb2Status.GetStatusCode(header.Status));
}
if (sameAppInstanceId && expectedCreateResponseStatus != Smb2Status.STATUS_SHARING_VIOLATION)
{
if (TestConfig.Platform != Platform.NonWindows) //not check the specific error code for non-Windows
{
BaseTestSite.CaptureRequirementIfAreEqual(
Smb2Status.STATUS_FILE_CLOSED,
header.Status,
RequirementCategory.STATUS_FILE_CLOSED.Id,
RequirementCategory.STATUS_FILE_CLOSED.Description);
}
}
});
if (expectedCreateResponseStatus == Smb2Status.STATUS_SUCCESS)
{
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Tear down the second client by sending the following requests: CLOSE; TREE_DISCONNECT; LOG_OFF; DISCONNECT");
clientForReOpen.Close(treeIdForReOpen, fileIdForReOpen);
}
clientForReOpen.TreeDisconnect(treeIdForReOpen);
clientForReOpen.LogOff();
clientForReOpen.Disconnect();
if (expectedInitialOpenStatusAfterReopen == Smb2Status.STATUS_SUCCESS)
{
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Tear down the first client by sending the following requests: CLOSE; TREE_DISCONNECT; LOG_OFF");
clientForInitialOpen.Close(treeIdForInitialOpen, fileIdForInitialOpen);
}
clientForInitialOpen.TreeDisconnect(treeIdForInitialOpen);
clientForInitialOpen.LogOff();
#endregion
}
/// <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 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);
}
private void FileOperation(OplockFileOperation fileOperation, string fileName)
{
Site.Log.Add(LogEntryKind.Debug, "File operation on same file from another client");
Smb2FunctionalClient clientForAnotherOpen = new Smb2FunctionalClient(testConfig.Timeout, testConfig, this.Site);
clientForAnotherOpen.ConnectToServer(testConfig.UnderlyingTransport, testConfig.SutComputerName, testConfig.SutIPAddress, testConfig.ClientNic1IPAddress);
clientForAnotherOpen.Negotiate(new DialectRevision[]{negotiatedDialect}, testConfig.IsSMB1NegotiateEnabled);
clientForAnotherOpen.SessionSetup(
testConfig.DefaultSecurityPackage,
server,
testConfig.AccountCredential,
testConfig.UseServerGssToken);
uint treeIdForAnotherOpen;
clientForAnotherOpen.TreeConnect(
uncSharePath,
out treeIdForAnotherOpen);
FILEID fileIdForAnotherOpen;
Smb2CreateContextResponse[] serverCreateContexts;
clientForAnotherOpen.Create(
treeIdForAnotherOpen,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileIdForAnotherOpen,
out serverCreateContexts);
if (fileOperation == OplockFileOperation.WriteFromAnotherOpen)
{
string writeContent = Smb2Utility.CreateRandomString(1);
clientForAnotherOpen.Write(treeIdForAnotherOpen, fileIdForAnotherOpen, writeContent);
}
}
protected void CreateNewFile(string sharePath, string fileName)
{
Smb2FunctionalClient clientAdmin;
clientAdmin = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
clientAdmin.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress);
uint treeId;
ConnectToShare(clientAdmin, TestConfig.AccountCredential, sharePath, out treeId);
FILEID fileId;
Smb2CreateContextResponse[] createContextResponses;
clientAdmin.Create(
treeId,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId,
out createContextResponses,
accessMask: AccessMask.FILE_READ_DATA | AccessMask.FILE_WRITE_DATA |
AccessMask.FILE_APPEND_DATA | AccessMask.FILE_READ_EA |
AccessMask.FILE_WRITE_EA | AccessMask.READ_CONTROL |
AccessMask.WRITE_DAC | AccessMask.FILE_READ_ATTRIBUTES |
AccessMask.FILE_WRITE_ATTRIBUTES | AccessMask.SYNCHRONIZE,
shareAccess: ShareAccess_Values.NONE,
createDisposition: CreateDisposition_Values.FILE_CREATE);
clientAdmin.Close(treeId, fileId);
clientAdmin.TreeDisconnect(treeId);
clientAdmin.Disconnect();
}
public void ReconnectSharedVHDWithoutDeviceContext()
{
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"1. Client opens a shared virtual disk file with SMB2 create contexts " +
"SVHDX_OPEN_DEVICE_CONTEXT and SMB2_CREATE_DURABLE_HANDLE_REQUEST_V2 (persistent bit is set). ");
Smb2FunctionalClient clientBeforeDisconnect = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
uint treeId;
Guid clientGuid = Guid.NewGuid();
ConnectToShare(clientBeforeDisconnect, clientGuid, TestConfig.FullPathShareContainingSharedVHD, out treeId);
Guid createGuid = Guid.NewGuid();
Guid initiatorId = Guid.NewGuid();
Smb2CreateContextResponse[] serverCreateContexts;
FILEID fileIdBeforeDisconnect;
clientBeforeDisconnect.Create
(treeId,
TestConfig.NameOfSharedVHDX + fileNameSuffix,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileIdBeforeDisconnect,
out serverCreateContexts,
RequestedOplockLevel_Values.OPLOCK_LEVEL_NONE,
new Smb2CreateContextRequest[]
{
new Smb2CreateSvhdxOpenDeviceContext
{
Version = (uint)RSVD_PROTOCOL_VERSION.RSVD_PROTOCOL_VERSION_1,
OriginatorFlags = (uint)OriginatorFlag.SVHDX_ORIGINATOR_PVHDPARSER,
InitiatorHostName = TestConfig.InitiatorHostName,
InitiatorHostNameLength = (ushort)(TestConfig.InitiatorHostName.Length * 2), // InitiatorHostName is a null-terminated Unicode UTF-16 string
InitiatorId = initiatorId
},
new Smb2CreateDurableHandleRequestV2
{
CreateGuid = createGuid,
Flags = CREATE_DURABLE_HANDLE_REQUEST_V2_Flags.DHANDLE_FLAG_PERSISTENT
}
});
bool persistentHandleReturned = false;
if (serverCreateContexts != null && serverCreateContexts[0] is Smb2CreateDurableHandleResponseV2)
{
var durableResponse = serverCreateContexts[0] as Smb2CreateDurableHandleResponseV2;
if (durableResponse.Flags.HasFlag(CREATE_DURABLE_HANDLE_RESPONSE_V2_Flags.DHANDLE_FLAG_PERSISTENT))
{
persistentHandleReturned = true;
}
}
BaseTestSite.Assert.IsTrue(persistentHandleReturned, "Server should return a persistent handle.");
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"2. Client disconnects from the server.");
clientBeforeDisconnect.Disconnect();
Smb2FunctionalClient clientAfterDisconnect = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
ConnectToShare(clientAfterDisconnect, clientGuid, TestConfig.FullPathShareContainingSharedVHD, out treeId);
FILEID fileIdAfterDisconnect;
uint status = clientAfterDisconnect.Create
(treeId,
TestConfig.NameOfSharedVHDX + fileNameSuffix,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileIdAfterDisconnect,
out serverCreateContexts,
RequestedOplockLevel_Values.OPLOCK_LEVEL_NONE,
new Smb2CreateContextRequest[]
{
new Smb2CreateDurableHandleReconnectV2
{
CreateGuid = createGuid,
Flags = CREATE_DURABLE_HANDLE_RECONNECT_V2_Flags.DHANDLE_FLAG_PERSISTENT,
FileId = new FILEID { Persistent = fileIdBeforeDisconnect.Persistent }
}
},
checker: (header, response) => { });
BaseTestSite.Assert.AreEqual(
(uint)Smb2Status.STATUS_SUCCESS,
status,
"3. Client reconnects the persistent handle without create context SVHDX_OPEN_DEVICE_CONTEXT and expects success. Actual status is: {0}",
GetStatus(status));
clientAfterDisconnect.Close(treeId, fileIdAfterDisconnect);
clientAfterDisconnect.TreeDisconnect(treeId);
clientAfterDisconnect.LogOff();
clientAfterDisconnect.Disconnect();
}
public void BVT_Replay_ReplayCreate()
{
///1. mainChannelClient opens a file
///2. mainChannelClient loses connection.
///3. ChannelSequence is increased by 1.
///4. alternativeChannelClient opens the same file with replay flag set.
#region Check Applicability
TestConfig.CheckDialect(DialectRevision.Smb30);
TestConfig.CheckCapabilities(NEGOTIATE_Response_Capabilities_Values.GLOBAL_CAP_MULTI_CHANNEL);
TestConfig.CheckCreateContext(CreateContextTypeValue.SMB2_CREATE_DURABLE_HANDLE_REQUEST_V2);
// According to TD, server must support signing when it supports multichannel.
// 3.3.5.5 Receiving an SMB2 SESSION_SETUP Request
// 4. If Connection.Dialect belongs to the SMB 3.x dialect family, IsMultiChannelCapable is TRUE, and the SMB2_SESSION_FLAG_BINDING bit is
// set in the Flags field of the request, the server MUST perform the following:
// If the SMB2_FLAGS_SIGNED bit is not set in the Flags field in the header, the server MUST fail the request with error STATUS_INVALID_PARAMETER.
TestConfig.CheckSigning();
#endregion
Guid durableHandleGuid = Guid.NewGuid();
Guid clientGuid = Guid.NewGuid();
Capabilities_Values capabilityValue = Capabilities_Values.GLOBAL_CAP_MULTI_CHANNEL;
#region MainChannelClient Finish Session Setup and AlternativeChannelClient Establish Another Channel
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"Start a client from main channel by sending the following requests: NEGOTIATE; SESSION_SETUP");
mainChannelClient.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress);
mainChannelClient.Negotiate(
TestConfig.RequestDialects,
TestConfig.IsSMB1NegotiateEnabled,
capabilityValue: capabilityValue,
clientGuid: clientGuid,
checker: ReplayNegotiateResponseChecker);
mainChannelClient.SessionSetup(TestConfig.DefaultSecurityPackage, TestConfig.SutComputerName, TestConfig.AccountCredential, false);
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"Start another client from alternative channel by sending the following requests: NEGOTIATE SESSION_SETUP");
alternativeChannelClient.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutAlternativeIPAddress);
alternativeChannelClient.Negotiate(
TestConfig.RequestDialects,
TestConfig.IsSMB1NegotiateEnabled,
capabilityValue: capabilityValue,
clientGuid: clientGuid,
checker: ReplayNegotiateResponseChecker);
alternativeChannelClient.AlternativeChannelSessionSetup(mainChannelClient, TestConfig.DefaultSecurityPackage, TestConfig.SutComputerName, TestConfig.AccountCredential, false);
#endregion
#region MainChannelClient Create a File with DurableHandleV1 and BatchOpLock
uint treeId;
BaseTestSite.Log.Add(LogEntryKind.TestStep, "The main channel client sends TREE_CONNECT request.");
mainChannelClient.TreeConnect(sharePath, out treeId);
FILEID fileId;
Smb2CreateContextResponse[] createContextResponse;
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"The main channel client sends CREATE request with SMB2_CREATE_DURABLE_HANDLE_REQUEST_V2 create context.");
mainChannelClient.Create(treeId, fileName, CreateOptions_Values.FILE_NON_DIRECTORY_FILE, out fileId, out createContextResponse,
RequestedOplockLevel_Values.OPLOCK_LEVEL_BATCH,
new Smb2CreateContextRequest[]
{
new Smb2CreateDurableHandleRequestV2
{
CreateGuid = durableHandleGuid
}
});
CheckCreateContextResponses(createContextResponse, new DefaultDurableHandleV2ResponseChecker(BaseTestSite, 0, uint.MaxValue));
#endregion
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Tear down the main channel client by sending DISCONNECT request.");
mainChannelClient.Disconnect();
alternativeChannelClient.SessionChannelSequence++;
#region AlternativeChannelClient Opens the Previously Created File with Replay Flag Set
FILEID alternativeFileId;
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"The alternative client sends CREATE request with replay flag set and SMB2_CREATE_DURABLE_HANDLE_REQUEST_V2 to open the same file with the main channel client.");
alternativeChannelClient.Create(treeId, fileName, CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
Packet_Header_Flags_Values.FLAGS_REPLAY_OPERATION | (testConfig.SendSignedRequest ? Packet_Header_Flags_Values.FLAGS_SIGNED : Packet_Header_Flags_Values.NONE),
out alternativeFileId,
out createContextResponse,
RequestedOplockLevel_Values.OPLOCK_LEVEL_BATCH,
new Smb2CreateContextRequest[]
{
new Smb2CreateDurableHandleRequestV2
{
CreateGuid = durableHandleGuid
}
});
CheckCreateContextResponses(createContextResponse, new DefaultDurableHandleV2ResponseChecker(BaseTestSite, 0, uint.MaxValue));
#endregion
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Tear down the alternative channel client by sending the following requests: TREE_DISCONNECT; LOG_OFF");
alternativeChannelClient.TreeDisconnect(treeId);
alternativeChannelClient.LogOff();
}
public void BVT_Replay_WriteWithInvalidChannelSequence()
{
///1. mainChannelClient opens a file and write to it.
///2. mainChannelClient loses connection.
///3. ChannelSequence is set to 0x8000 which exceeds the max value.
///4. alternativeChannelClient opens the same file and try to write to it.
///5. Server should fail the write request with STATUS_FILE_NOT_AVAILABLE.
#region Check Applicability
TestConfig.CheckDialect(DialectRevision.Smb30);
TestConfig.CheckCapabilities(NEGOTIATE_Response_Capabilities_Values.GLOBAL_CAP_MULTI_CHANNEL);
TestConfig.CheckCreateContext(CreateContextTypeValue.SMB2_CREATE_DURABLE_HANDLE_REQUEST_V2);
// According to TD, server must support signing when it supports multichannel.
// 3.3.5.5 Receiving an SMB2 SESSION_SETUP Request
// 4. If Connection.Dialect belongs to the SMB 3.x dialect family, IsMultiChannelCapable is TRUE, and the SMB2_SESSION_FLAG_BINDING bit is
// set in the Flags field of the request, the server MUST perform the following:
// If the SMB2_FLAGS_SIGNED bit is not set in the Flags field in the header, the server MUST fail the request with error STATUS_INVALID_PARAMETER.
TestConfig.CheckSigning();
#endregion
Guid clientGuid = Guid.NewGuid();
Capabilities_Values capabilityValue = Capabilities_Values.GLOBAL_CAP_MULTI_CHANNEL;
channelSequence = 0;
#region MainChannelClient Create a File
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"Start a client from main channel by sending the following requests: NEGOTIATE; SESSION_SETUP; TREE_CONNECT; CREATE.");
mainChannelClient.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress);
mainChannelClient.Negotiate(
TestConfig.RequestDialects,
TestConfig.IsSMB1NegotiateEnabled,
capabilityValue: capabilityValue,
clientGuid: clientGuid,
checker: ReplayNegotiateResponseChecker);
mainChannelClient.SessionSetup(TestConfig.DefaultSecurityPackage, TestConfig.SutComputerName, TestConfig.AccountCredential, false);
mainChannelClient.SessionChannelSequence = channelSequence;
uint treeId;
mainChannelClient.TreeConnect(sharePath, out treeId);
FILEID fileId;
Smb2CreateContextResponse[] createContextResponse;
mainChannelClient.Create(treeId, fileName, CreateOptions_Values.FILE_NON_DIRECTORY_FILE, out fileId, out createContextResponse,
RequestedOplockLevel_Values.OPLOCK_LEVEL_BATCH,
new Smb2CreateContextRequest[]
{
new Smb2CreateDurableHandleRequestV2
{
CreateGuid = Guid.NewGuid()
}
});
CheckCreateContextResponses(createContextResponse, new DefaultDurableHandleV2ResponseChecker(BaseTestSite, 0, uint.MaxValue));
#endregion
#region alternativeChannelClient Opens the Previously Created File
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Start a client from alternative channel by sending NEGOTIATE request.");
alternativeChannelClient.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutAlternativeIPAddress);
alternativeChannelClient.Negotiate(
TestConfig.RequestDialects,
TestConfig.IsSMB1NegotiateEnabled,
capabilityValue: capabilityValue,
clientGuid: clientGuid,
checker: ReplayNegotiateResponseChecker);
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"The alternative client sends SESSION_SETUP request binding the previous session created by the main channel client.");
alternativeChannelClient.AlternativeChannelSessionSetup(mainChannelClient, TestConfig.DefaultSecurityPackage, TestConfig.SutComputerName, TestConfig.AccountCredential, false);
alternativeChannelClient.SessionChannelSequence = channelSequence;
#endregion
BaseTestSite.Log.Add(LogEntryKind.TestStep, "The main channel client sends WRITE request to write content to file.");
mainChannelClient.Write(treeId, fileId, " ");
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Tear down the main channel client by sending DISCONNECT request.");
mainChannelClient.Disconnect();
//Network Disconnection Increase the Channel Sequence
//Server MUST fail SMB2 WRITE, SET_INFO, and IOCTL requests with STATUS_FILE_NOT_AVAILABLE
//if the difference between the ChannelSequence in the header and Open.ChannelSequence is greater than 0x7FFF
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Set the channel sequence of the alternative channel client to an invalid value.");
alternativeChannelClient.SessionChannelSequence = 0x8000;
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"The alternative client sends WRITE request to write content to the file created by the main channel client.");
alternativeChannelClient.Write(treeId,
fileId,
" ",
checker: (header, response) =>
{
BaseTestSite.Assert.AreEqual(
Smb2Status.STATUS_FILE_NOT_AVAILABLE,
header.Status,
"Server MUST fail the {0} request with STATUS_FILE_NOT_AVAILABLE if the difference between the ChannelSequence in the header and Open.ChannelSequence is greater than 0x7FFF. " +
"Actually server returns {1}.",
header.Command,
Smb2Status.GetStatusCode(header.Status));
},
isReplay: true);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Tear down the alternative channel client by sending TREE_DISCONNECT and LOG_OFF requests.");
alternativeChannelClient.TreeDisconnect(treeId);
alternativeChannelClient.LogOff();
}
public void TreeMgmt_SMB311_TREE_CONNECT_EXTENSION_PRESENT()
{
#region Check Applicability
TestConfig.CheckPlatform(Platform.WindowsServer2019);
TestConfig.CheckDialect(DialectRevision.Smb311);
#endregion
Smb2FunctionalClient client = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Start a client by sending the following requests: CONNECT; NEGOTIATE; SESSION_SETUP");
client.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress);
client.Negotiate(TestConfig.RequestDialects, TestConfig.IsSMB1NegotiateEnabled);
//Use domain credential to do session setup (e.g. contoso.com\administrator)
client.SessionSetup(
TestConfig.DefaultSecurityPackage,
TestConfig.SutComputerName,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken);
string infraSharePath = string.Format(@"\\{0}\{1}", TestConfig.ClusteredInfrastructureFileServerName, TestConfig.InfrastructureRootShare);
uint treeId;
string domainName = TestConfig.DriverComputerName;
string userName = TestConfig.UserName;
string password = TestConfig.UserPassword;
const int LOGON32_PROVIDER_DEFAULT = 0;
const int LOGON32_LOGON_INTERACTIVE = 2; //This parameter causes LogonUser to create a primary token.
SafeTokenHandle safeTokenHandle; // Call LogonUser to obtain a handle to an access token.
bool returnValue = LogonUser(userName, domainName, password,
LOGON32_LOGON_INTERACTIVE, LOGON32_PROVIDER_DEFAULT,
out safeTokenHandle);
if (false == returnValue)
{
int ret = Marshal.GetLastWin32Error();
throw new System.ComponentModel.Win32Exception(ret);
}
using (safeTokenHandle)
{
using (WindowsIdentity identity = new WindowsIdentity(safeTokenHandle.DangerousGetHandle()))
{
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client sends TREE_CONNECT request with extension context and expects success");
//Use another local account(e.g. local\administrator) as an idenity passed in tree connect extension
client.TreeConnect(
infraSharePath,
out treeId,
(header, response) =>
{
BaseTestSite.Assert.AreEqual(
Smb2Status.STATUS_SUCCESS,
header.Status,
"{0} should be successful, actually server returns {1}.", header.Command, Smb2Status.GetStatusCode(header.Status));
BaseTestSite.Assert.IsTrue(
response.ShareFlags.HasFlag(ShareFlags_Values.SHAREFLAG_IDENTITY_REMOTING),
"The share should support identity remoting, actually server returns {0}.", response.ShareFlags.ToString());
},
TreeConnect_Flags.SMB2_SHAREFLAG_EXTENSION_PRESENT,
identity);
FILEID fileId;
Smb2CreateContextResponse[] serverCreateContexts;
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client impersonates another log in user to send CREATE request and expects success.");
client.Create(
treeId,
GetTestFileName(infraSharePath),
CreateOptions_Values.FILE_DIRECTORY_FILE,
out fileId,
out serverCreateContexts,
checker: (header, response) =>
{
BaseTestSite.Assert.AreEqual(
Smb2Status.STATUS_SUCCESS,
header.Status,
"{0} should be successful, actually server returns {1}.", header.Command, Smb2Status.GetStatusCode(header.Status));
}
);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Tear down the client by sending the following requests: CLOSE; TREE_DISCONNECT; LOG_OFF");
client.Close(treeId, fileId);
}
}
client.TreeDisconnect(treeId);
client.LogOff();
}
public void TreeMgmt_SMB311_TREE_CONNECT_EXTENSION_PRESENT()
{
#region Check Applicability
TestConfig.CheckPlatform(Platform.WindowsServer2019);
TestConfig.CheckDialect(DialectRevision.Smb311);
#endregion
Smb2FunctionalClient client = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Start a client by sending the following requests: CONNECT; NEGOTIATE; SESSION_SETUP");
client.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress);
client.Negotiate(TestConfig.RequestDialects, TestConfig.IsSMB1NegotiateEnabled);
//Use domain credential to do session setup (e.g. contoso.com\administrator)
client.SessionSetup(
TestConfig.DefaultSecurityPackage,
TestConfig.SutComputerName,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken);
string infraSharePath = string.Format(@"\\{0}\{1}", TestConfig.ClusteredInfrastructureFileServerName, TestConfig.InfrastructureRootShare);
uint treeId;
string domainName = TestConfig.DomainName;
string domainAdmin = TestConfig.UserName;
string domainAdminPassword = TestConfig.UserPassword;
string anotherUserName = TestConfig.NonAdminUserName;
_WindowsIdentity identity = _WindowsIdentity.GetFromDomain(domainName, domainAdmin, domainAdminPassword, anotherUserName);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client sends TREE_CONNECT request with extension context and expects success");
//Use another domain account(e.g. contoso\nonadmin) as an idenity passed in tree connect extension
client.TreeConnect(
infraSharePath,
out treeId,
(header, response) =>
{
BaseTestSite.Assert.AreEqual(
Smb2Status.STATUS_SUCCESS,
header.Status,
"{0} should be successful, actually server returns {1}.", header.Command, Smb2Status.GetStatusCode(header.Status));
BaseTestSite.Assert.IsTrue(
response.ShareFlags.HasFlag(ShareFlags_Values.SHAREFLAG_IDENTITY_REMOTING),
"The share should support identity remoting, actually server returns {0}.", response.ShareFlags.ToString());
},
TreeConnect_Flags.SMB2_SHAREFLAG_EXTENSION_PRESENT,
identity);
FILEID fileId;
Smb2CreateContextResponse[] serverCreateContexts;
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client impersonates another log in user to send CREATE request and expects success.");
client.Create(
treeId,
GetTestFileName(infraSharePath),
CreateOptions_Values.FILE_DIRECTORY_FILE,
out fileId,
out serverCreateContexts,
checker: (header, response) =>
{
BaseTestSite.Assert.AreEqual(
Smb2Status.STATUS_SUCCESS,
header.Status,
"{0} should be successful, actually server returns {1}.", header.Command, Smb2Status.GetStatusCode(header.Status));
}
);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Tear down the client by sending the following requests: CLOSE; TREE_DISCONNECT; LOG_OFF");
client.Close(treeId, fileId);
client.TreeDisconnect(treeId);
client.LogOff();
}
/// <summary>
/// Read and write file within byte lock range when the file is locked or unlocked
/// </summary>
/// <param name="isLocked">Set true to indicate that byte lock range is taken on the file</param>
private void ValidateByteLockRangeFromAnotherClient(bool isLocked)
{
uint status = 0;
Smb2FunctionalClient client = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
client = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
client.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress, TestConfig.ClientNic2IPAddress);
status = client.Negotiate(
TestConfig.RequestDialects,
TestConfig.IsSMB1NegotiateEnabled);
status = client.SessionSetup(
TestConfig.DefaultSecurityPackage,
TestConfig.SutComputerName,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken);
uint treeId;
status = client.TreeConnect(uncSharePath, out treeId);
Smb2CreateContextResponse[] serverCreateContexts;
FILEID fileId;
status = client.Create(
treeId,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId,
out serverCreateContexts);
string data;
Random random = new Random();
uint offset = (uint)random.Next(0, TestConfig.WriteBufferLengthInKb * 1024 - 1);
uint length = (uint)random.Next(0, (int)(TestConfig.WriteBufferLengthInKb * 1024 - offset));
status = client.Read(treeId, fileId, offset, length, out data);
status = client.Write(treeId, fileId, contentWrite, checker: (header, response) => { });
if (isLocked)
{
BaseTestSite.Assert.AreNotEqual(
Smb2Status.STATUS_SUCCESS,
status,
"Write content to locked range of file from different client is not expected to success");
BaseTestSite.CaptureRequirementIfAreEqual(
Smb2Status.STATUS_FILE_LOCK_CONFLICT,
status,
RequirementCategory.STATUS_FILE_LOCK_CONFLICT.Id,
RequirementCategory.STATUS_FILE_LOCK_CONFLICT.Description);
}
else
{
BaseTestSite.Assert.AreEqual(
Smb2Status.STATUS_SUCCESS,
status,
"Write content in file should succeed, actual status is {0}", Smb2Status.GetStatusCode(status));
}
status = client.Close(treeId, fileId);
status = client.TreeDisconnect(treeId);
status = client.LogOff();
client.Disconnect();
}
private void DirecotryLeasing(
DialectRevision[] requestDialect,
DialectRevision expectedDialect,
LeaseStateValues leaseState,
LeaseBreakAckType leaseBreakAckType = LeaseBreakAckType.None)
{
#region Check Applicability
TestConfig.CheckDialect(DialectRevision.Smb30);
TestConfig.CheckCapabilities(NEGOTIATE_Response_Capabilities_Values.GLOBAL_CAP_DIRECTORY_LEASING);
TestConfig.CheckCreateContext(CreateContextTypeValue.SMB2_CREATE_REQUEST_LEASE_V2);
#endregion
BaseTestSite.Log.Add(
LogEntryKind.Comment,
@"Start to create a directory on share \\{0}\{1} with lease state {2}",
TestConfig.SutComputerName, TestConfig.BasicFileShare, leaseState);
string testDirectory = CreateTestDirectory(TestConfig.SutComputerName, TestConfig.BasicFileShare);
client.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress);
#region Negotiate
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Start the client by sending the following requests: NEGOTIATE; SESSION_SETUP; TREE_CONNECT");
Capabilities_Values capabilities = Capabilities_Values.GLOBAL_CAP_DFS | Capabilities_Values.GLOBAL_CAP_DIRECTORY_LEASING | Capabilities_Values.GLOBAL_CAP_LARGE_MTU | Capabilities_Values.GLOBAL_CAP_LEASING | Capabilities_Values.GLOBAL_CAP_MULTI_CHANNEL | Capabilities_Values.GLOBAL_CAP_PERSISTENT_HANDLES;
status = client.Negotiate(
requestDialect,
TestConfig.IsSMB1NegotiateEnabled,
capabilityValue: capabilities,
checker: (Packet_Header header, NEGOTIATE_Response response) =>
{
BaseTestSite.Assert.AreEqual(
Smb2Status.STATUS_SUCCESS,
header.Status,
"Negotiation should succeed, actually server returns {0}.", Smb2Status.GetStatusCode(header.Status));
TestConfig.CheckNegotiateDialect(expectedDialect, response);
if (expectedDialect >= DialectRevision.Smb30)
{
TestConfig.CheckNegotiateCapabilities(NEGOTIATE_Response_Capabilities_Values.GLOBAL_CAP_DIRECTORY_LEASING, response);
}
});
#endregion
#region SESSION_SETUP
status = client.SessionSetup(
TestConfig.DefaultSecurityPackage,
TestConfig.SutComputerName,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken);
#endregion
#region TREE_CONNECT to share
string uncSharePath = Smb2Utility.GetUncPath(TestConfig.SutComputerName, TestConfig.BasicFileShare);
uint treeId;
status = client.TreeConnect(uncSharePath, out treeId);
#endregion
#region CREATE
FILEID fileId;
Smb2CreateContextResponse[] serverCreateContexts;
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"Client sends CREATE request for the directory with the LeaseState set to {0} in SMB2_CREATE_REQUEST_LEASE_V2.", leaseState);
status = client.Create(
treeId,
testDirectory,
CreateOptions_Values.FILE_DIRECTORY_FILE,
out fileId,
out serverCreateContexts,
RequestedOplockLevel_Values.OPLOCK_LEVEL_LEASE,
new Smb2CreateContextRequest[]
{
new Smb2CreateRequestLeaseV2
{
LeaseKey = Guid.NewGuid(),
LeaseState = leaseState
}
},
checker: (Packet_Header header, CREATE_Response response) =>
{
BaseTestSite.Assert.AreEqual(
Smb2Status.STATUS_SUCCESS,
header.Status,
"CREATE should succeed, actually server returns {0}.", Smb2Status.GetStatusCode(header.Status));
if (expectedDialect == DialectRevision.Smb2002 || expectedDialect == DialectRevision.Smb21)
{
BaseTestSite.Assert.AreEqual(
OplockLevel_Values.OPLOCK_LEVEL_NONE,
response.OplockLevel,
"The expected oplock level is OPLOCK_LEVEL_NONE.");
}
});
#endregion
if (expectedDialect >= DialectRevision.Smb30)
{
// Break the lease with creating another file in the directory
sutProtocolController.CreateFile(Path.Combine(Smb2Utility.GetUncPath(TestConfig.SutComputerName, TestConfig.BasicFileShare), testDirectory), CurrentTestCaseName, string.Empty);
// Wait until LEASE_BREAK_Notification is received
BaseTestSite.Assert.IsTrue(
// Wait for notification arrival
notificationReceived.WaitOne(TestConfig.WaitTimeoutInMilliseconds),
"LeaseBreakNotification should be raised.");
if (receivedLeaseBreakNotify.Flags == LEASE_BREAK_Notification_Packet_Flags_Values.SMB2_NOTIFY_BREAK_LEASE_FLAG_ACK_REQUIRED)
{
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Server requires an LEASE_BREAK_ACK on this LEASE_BREAK_NOTIFY");
#region LEASE_BREAK_ACK
switch (leaseBreakAckType)
{
case LeaseBreakAckType.None:
status = client.LeaseBreakAcknowledgment(treeId, receivedLeaseBreakNotify.LeaseKey, receivedLeaseBreakNotify.NewLeaseState);
break;
case LeaseBreakAckType.InvalidLeaseState:
LeaseStateValues newLeaseState = LeaseStateValues.SMB2_LEASE_WRITE_CACHING;
BaseTestSite.Log.Add(
LogEntryKind.Comment,
"Client attempts to send LEASE_BREAK_ACK with an invalid LeaseState {0} on this LEASE_BREAK_NOTIFY", newLeaseState);
status = client.LeaseBreakAcknowledgment(
treeId,
receivedLeaseBreakNotify.LeaseKey,
newLeaseState,
checker: (header, response) =>
{
BaseTestSite.Assert.AreNotEqual(
Smb2Status.STATUS_SUCCESS,
header.Status,
"LEASE_BREAK_ACK with invalid LeaseState is not expected to SUCCESS, actually server returns {0}.", Smb2Status.GetStatusCode(header.Status));
BaseTestSite.CaptureRequirementIfAreEqual(
Smb2Status.STATUS_REQUEST_NOT_ACCEPTED,
header.Status,
RequirementCategory.STATUS_REQUEST_NOT_ACCEPTED.Id,
RequirementCategory.STATUS_REQUEST_NOT_ACCEPTED.Description);
});
break;
case LeaseBreakAckType.InvalidLeaseKey:
Guid invalidLeaseKey = Guid.NewGuid();
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Client attempts to send LEASE_BREAK_ACK with an invalid LeaseKey {0} on this LEASE_BREAK_NOTIFY", invalidLeaseKey);
status = client.LeaseBreakAcknowledgment(
treeId,
invalidLeaseKey,
receivedLeaseBreakNotify.NewLeaseState,
checker: (header, response) =>
{
BaseTestSite.Assert.AreNotEqual(
Smb2Status.STATUS_SUCCESS,
header.Status,
"LEASE_BREAK_ACK with invalid LeaseKey is not expected to SUCCESS, actually server returns {0}.", Smb2Status.GetStatusCode(header.Status));
BaseTestSite.CaptureRequirementIfAreEqual(
Smb2Status.STATUS_OBJECT_NAME_NOT_FOUND,
header.Status,
RequirementCategory.STATUS_OBJECT_NAME_NOT_FOUND.Id,
RequirementCategory.STATUS_OBJECT_NAME_NOT_FOUND.Description);
});
break;
case LeaseBreakAckType.InvalidClientGuid:
BaseTestSite.Log.Add(LogEntryKind.Debug, "Initialize a new different client to attempts to send LEASE_BREAK_ACK");
Smb2FunctionalClient newClient = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
newClient.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress);
#region Negotiate
status = newClient.Negotiate(
requestDialect,
TestConfig.IsSMB1NegotiateEnabled,
capabilityValue: Capabilities_Values.GLOBAL_CAP_DFS | Capabilities_Values.GLOBAL_CAP_DIRECTORY_LEASING | Capabilities_Values.GLOBAL_CAP_LARGE_MTU | Capabilities_Values.GLOBAL_CAP_LEASING | Capabilities_Values.GLOBAL_CAP_MULTI_CHANNEL | Capabilities_Values.GLOBAL_CAP_PERSISTENT_HANDLES);
#endregion
#region SESSION_SETUP
status = newClient.SessionSetup(
TestConfig.DefaultSecurityPackage,
TestConfig.SutComputerName,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken);
#endregion
#region TREE_CONNECT to share
uint newTreeId;
status = newClient.TreeConnect(uncSharePath, out newTreeId);
#endregion
status = newClient.LeaseBreakAcknowledgment(
newTreeId,
receivedLeaseBreakNotify.LeaseKey,
receivedLeaseBreakNotify.NewLeaseState,
checker: (header, response) =>
{
BaseTestSite.Assert.AreNotEqual(
Smb2Status.STATUS_SUCCESS,
header.Status,
"LEASE_BREAK_ACK is not expected to SUCCESS when the open is closed, actually server returns {0}.", Smb2Status.GetStatusCode(header.Status));
BaseTestSite.CaptureRequirementIfAreEqual(
Smb2Status.STATUS_OBJECT_NAME_NOT_FOUND,
header.Status,
RequirementCategory.STATUS_OBJECT_NAME_NOT_FOUND.Id,
RequirementCategory.STATUS_OBJECT_NAME_NOT_FOUND.Description);
});
status = newClient.TreeDisconnect(newTreeId);
status = newClient.LogOff();
BaseTestSite.Log.Add(
LogEntryKind.Comment,
"Initialize a new different client to attempts to send LEASE_BREAK_ACK");
break;
default:
throw new InvalidOperationException("Unexpected LeaseBreakAckType " + leaseBreakAckType);
}
#endregion
}
else
{
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Server does not require an LEASE_BREAK_ACK on this LEASE_BREAK_NOTIFY");
}
}
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Tear down the client by sending the following requests: TREE_DISCONNECT; LOG_OFF");
#region TREE_DISCONNECT
status = client.TreeDisconnect(treeId);
#endregion
#region LOGOFF
status = client.LogOff();
#endregion
BaseTestSite.Log.Add(
LogEntryKind.Comment,
@"Complete creating a directory on share \\{0}\{1} with lease state {2}",
TestConfig.SutComputerName, TestConfig.BasicFileShare, leaseState);
}
/// <summary>
/// Operations after Negotiate, from Session Setup to Log off.
/// </summary>
private void PostNegotiateOperations(EnableEncryptionType enableEncryptionType, bool connectEncryptedShare)
{
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client sends SESSION_SETUP request and expects response.");
client.SessionSetup(
TestConfig.DefaultSecurityPackage,
TestConfig.SutComputerName,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken);
if (enableEncryptionType == EnableEncryptionType.EnableEncryptionPerSession)
{
// After calling this method, client will send encrypted message after session setup
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client enables global encryption.");
client.EnableSessionSigningAndEncryption(enableSigning: false, enableEncryption: true);
}
string uncSharepath =
Smb2Utility.GetUncPath(TestConfig.SutComputerName, connectEncryptedShare ? TestConfig.EncryptedFileShare : TestConfig.BasicFileShare);
uint treeId;
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client sends TREE_CONNECT to share: {0}", uncSharepath);
client.TreeConnect(
uncSharepath,
out treeId,
(Packet_Header header, TREE_CONNECT_Response response) =>
{
BaseTestSite.Assert.AreEqual(
Smb2Status.STATUS_SUCCESS,
header.Status,
"TreeConnect should succeed, actually server returns {0}.", Smb2Status.GetStatusCode(header.Status));
if (connectEncryptedShare)
{
BaseTestSite.Assert.AreEqual(
ShareFlags_Values.SHAREFLAG_ENCRYPT_DATA,
ShareFlags_Values.SHAREFLAG_ENCRYPT_DATA & response.ShareFlags,
"Server should set SMB2_SHAREFLAG_ENCRYPT_DATA for ShareFlags field in TREE_CONNECT response");
}
else
{
BaseTestSite.Assert.AreNotEqual(
ShareFlags_Values.SHAREFLAG_ENCRYPT_DATA,
ShareFlags_Values.SHAREFLAG_ENCRYPT_DATA & response.ShareFlags,
"Server should not set SMB2_SHAREFLAG_ENCRYPT_DATA for ShareFlags field in TREE_CONNECT response");
}
});
if (enableEncryptionType == EnableEncryptionType.EnableEncryptionPerShare)
{
// After calling this method, client will send encrypted message after tree connect.
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client enables per share encryption: TreeId=0x{0:x}", treeId);
client.SetTreeEncryption(treeId, true);
}
FILEID fileId;
Smb2CreateContextResponse[] serverCreateContexts;
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client sends encrypted CREATE request and expects success.");
client.Create(
treeId,
GetTestFileName(uncSharepath),
CreateOptions_Values.FILE_NON_DIRECTORY_FILE | CreateOptions_Values.FILE_DELETE_ON_CLOSE,
out fileId,
out serverCreateContexts);
string content = Smb2Utility.CreateRandomString(TestConfig.WriteBufferLengthInKb);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client sends encrpyted WRITE request and expects success.");
client.Write(treeId, fileId, content);
string actualContent;
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client sends encrypted READ request and expects success.");
client.Read(treeId, fileId, 0, (uint)content.Length, out actualContent);
BaseTestSite.Assert.IsTrue(
content.Equals(actualContent),
"File content read should be identical to that has been written.");
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Tear down the client by sending the following requests: CLOSE; TREE_DISCONNECT; LOG_OFF");
client.Close(treeId, fileId);
client.TreeDisconnect(treeId);
client.LogOff();
}
protected bool AccessShare(AccountCredential user, string sharePath)
{
bool accessSucceed = true;
Smb2FunctionalClient client = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
client.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress);
try
{
BaseTestSite.Log.Add(LogEntryKind.Debug, "Client sends NEGOTIATE message.");
client.Negotiate(TestConfig.RequestDialects, TestConfig.IsSMB1NegotiateEnabled);
BaseTestSite.Log.Add(LogEntryKind.Debug, "Client sends SESSION_SETUP message using account: {0}@{1}.", user.AccountName, user.DomainName);
client.SessionSetup(TestConfig.DefaultSecurityPackage, TestConfig.SutComputerName, user, false);
uint treeId;
BaseTestSite.Log.Add(LogEntryKind.Debug, "Client sends TREE_CONNECT message to access share: {0}.", sharePath);
client.TreeConnect(sharePath, out treeId, checker: (header, response) =>
{
if (header.Status == Smb2Status.STATUS_SUCCESS)
{
BaseTestSite.Log.Add(LogEntryKind.Debug, "Access succeeded in TREE_CONNECT phase.");
accessSucceed = true;
}
else if (header.Status == Smb2Status.STATUS_ACCESS_DENIED)
{
BaseTestSite.Log.Add(LogEntryKind.Debug, "Access denied in TREE_CONNECT phase.");
accessSucceed = false;
}
else
{
BaseTestSite.Assert.Fail("Unexpected error code in TREE_CONNECT response: {0}", Smb2Status.GetStatusCode(header.Status));
}
});
if (!accessSucceed)
{
client.LogOff();
return(false);
}
FILEID fileId;
Smb2CreateContextResponse[] createContexResponse;
BaseTestSite.Log.Add(LogEntryKind.Debug, "Client sends CREATE request.");
uint status = client.Create(
treeId,
null,
CreateOptions_Values.FILE_DIRECTORY_FILE,
out fileId,
out createContexResponse,
accessMask: AccessMask.FILE_READ_DATA | AccessMask.FILE_READ_ATTRIBUTES,
createDisposition: CreateDisposition_Values.FILE_OPEN,
checker: (header, response) =>
{
if (header.Status == Smb2Status.STATUS_SUCCESS)
{
BaseTestSite.Log.Add(LogEntryKind.Debug, "Access succeeded in CREATE phase.");
accessSucceed = true;
}
else if (header.Status == Smb2Status.STATUS_ACCESS_DENIED)
{
BaseTestSite.Log.Add(LogEntryKind.Debug, "Access denied in CREATE phase.");
accessSucceed = false;
}
else
{
BaseTestSite.Assert.Fail("Unexpected error code in CREATE response: {0}", Smb2Status.GetStatusCode(header.Status));
}
});
if (status == Smb2Status.STATUS_SUCCESS)
{
BaseTestSite.Log.Add(LogEntryKind.Debug, "Tear down the client by sending the following requests: CLOSE; TREE_DISCONNECT; LOG_OFF.");
client.Close(treeId, fileId);
}
client.TreeDisconnect(treeId);
client.LogOff();
}
finally
{
client.Disconnect();
}
return(accessSucceed);
}
public void BVT_CopyOffload()
{
BaseTestSite.Log.Add(LogEntryKind.TestStep,
"1. Create a file with specified length {0} as the source of offload copy.",
TestConfig.WriteBufferLengthInKb * 1024);
string content = Smb2Utility.CreateRandomString(TestConfig.WriteBufferLengthInKb);
string fileName = Guid.NewGuid().ToString();
uint treeId;
FILEID fileIdSrc;
PrepareTestFile(fileName, content, out treeId, out fileIdSrc);
BaseTestSite.Log.Add(LogEntryKind.TestStep,
"2. Client sends IOCTL request with FSCTL_OFFLOAD_READ to ask server to generate the token of the content for offload copy.");
STORAGE_OFFLOAD_TOKEN token;
ulong fileOffsetToRead = 0; //FileOffset should be aligned to logical sector boundary on the volume, e.g. 512 bytes
ulong copyLengthToRead = (ulong)TestConfig.WriteBufferLengthInKb * 1024; //CopyLength should be aligned to logical sector boundary on the volume, e.g. 512 bytes
ulong transferLength;
// Request hardware to generate a token that represents a range of file to be copied
client.OffloadRead(
treeId,
fileIdSrc,
fileOffsetToRead,
copyLengthToRead,
out transferLength,
out token);
BaseTestSite.Log.Add(LogEntryKind.Debug, "Transfer length during OFFLOAD_READ is {0}", transferLength);
BaseTestSite.Assert.AreEqual(copyLengthToRead, transferLength,
"Transfer length {0} should be equal to copy length {1}", transferLength, copyLengthToRead);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "3. Create another file as the destination of offload copy.");
FILEID fileIdDest;
Smb2CreateContextResponse[] serverCreateContexts;
client.Create(
treeId,
Guid.NewGuid().ToString(),
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileIdDest,
out serverCreateContexts);
// Bug 8016334
// The destination file of CopyOffload Write should not be zero, it should be at least 512 bytes, which is the sector size.
client.Write(treeId, fileIdDest, Smb2Utility.CreateRandomStringInByte(512));
client.Flush(treeId, fileIdDest);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "4. Client sends IOCTL request with FSCTL_OFFLOAD_WRITE to ask server to copy the content from source to destination.");
ulong fileOffsetToWrite = 0; //FileOffset should be aligned to logical sector boundary on the volume, e.g. 512 bytes
ulong copyLengthToWrite = transferLength; //CopyLength should be aligned to logical sector boundary on the volume, e.g. 512 bytes
ulong transferOffset = 0; //TransferOffset should be aligned to logical sector boundary on the volume, e.g. 512 bytes
// Request hardware to write a range of file which is represented by the generated token
// and length/offset to another place (a different file or different offset of the same file)
client.OffloadWrite(
treeId,
fileIdDest,
fileOffsetToWrite,
copyLengthToWrite,
transferOffset,
token);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "5. Compare the content of section 1 with the content of section 2.");
string readContent;
// Read the content that was just offload copied
client.Read(
treeId,
fileIdDest,
fileOffsetToWrite,
(uint)copyLengthToWrite,
out readContent);
BaseTestSite.Assert.IsTrue(
readContent.Equals(content),
"File content read should equal to original");
BaseTestSite.Log.Add(LogEntryKind.TestStep, "6. Tear down the client by sending the following requests: CLOSE; TREE_DISCONNECT; LOG_OFF.");
client.Close(treeId, fileIdSrc);
client.Close(treeId, fileIdDest);
client.TreeDisconnect(treeId);
client.LogOff();
}
/// <summary>
/// Attempt to trigger LeaseBreakNotification from a separate client
/// </summary>
/// <param name="client">Client to trigger LeaseBreakNotification</param>
/// <param name="requestDialect">Negotiate dialects</param>
/// <param name="serverName">Name of file server to access</param>
/// <param name="isDirectory">True value indicating to open a directory, false for a file</param>
/// <param name="requestedLeaseState">LeaseState when open the directory or file</param>
/// <param name="accessMask">AccessMask when open the directory or file</param>
private void TriggerBreakFromClient(
Smb2FunctionalClient client,
DialectRevision[] requestDialect,
string serverName,
bool isDirectory,
LeaseStateValues requestedLeaseState,
AccessMask accessMask)
{
BaseTestSite.Log.Add(LogEntryKind.Debug, "AfterFailover: Attempt to access same file/directory to trigger LeaseBreakNotification from a separate client with LeaseState {0} and AccessMask {1}", requestedLeaseState, accessMask);
#region Negotiate
status = client.Negotiate(
requestDialect,
TestConfig.IsSMB1NegotiateEnabled,
capabilityValue: Capabilities_Values.GLOBAL_CAP_DFS | Capabilities_Values.GLOBAL_CAP_DIRECTORY_LEASING | Capabilities_Values.GLOBAL_CAP_LARGE_MTU | Capabilities_Values.GLOBAL_CAP_LEASING | Capabilities_Values.GLOBAL_CAP_MULTI_CHANNEL | Capabilities_Values.GLOBAL_CAP_PERSISTENT_HANDLES,
checker: (Packet_Header header, NEGOTIATE_Response response) =>
{
TestConfig.CheckNegotiateDialect(DialectRevision.Smb30, response);
});
#endregion
#region SESSION_SETUP
status = client.SessionSetup(
TestConfig.DefaultSecurityPackage,
serverName,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken);
#endregion
#region TREE_CONNECT to share
uint treeId;
status = client.TreeConnect(uncSharePath, out treeId);
#endregion
#region CREATE
Smb2CreateContextResponse[] serverCreateContexts;
FILEID fileId;
status = client.Create(
treeId, // To break lease on directory, create a new child item
isDirectory ? testDirectory + @"\child.txt" : fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId,
out serverCreateContexts,
RequestedOplockLevel_Values.OPLOCK_LEVEL_LEASE,
new Smb2CreateContextRequest[]
{
new Smb2CreateRequestLeaseV2
{
LeaseKey = Guid.NewGuid(),
LeaseState = requestedLeaseState
}
},
accessMask: accessMask,
shareAccess: ShareAccess_Values.NONE,
checker: (header, response) => { });
#endregion
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"AfterFailover: Finish triggering a LeaseBreakNotification from a separate client.");
}
private void TestAsymmetricShare(DialectRevision requestMaxDialect, string serverName, bool isAsymmetricShare)
{
int ret = 0;
uint callId = 0;
Guid clientGuid = Guid.NewGuid();
WITNESS_INTERFACE_INFO registerInterface;
string shareName = isAsymmetricShare ? TestConfig.AsymmetricShare : TestConfig.BasicFileShare;
#region Get the file server to access it through SMB2
IPAddress currentAccessIp = SWNTestUtility.GetCurrentAccessIP(serverName);
BaseTestSite.Assert.IsNotNull(currentAccessIp, "IP address of the file server should NOT be empty");
BaseTestSite.Log.Add(LogEntryKind.Debug, "Got the IP {0} to access the file server", currentAccessIp.ToString());
#endregion
#region Connect to the asymmetric share
uncSharePath = Smb2Utility.GetUncPath(serverName, shareName);
string content = Smb2Utility.CreateRandomString(TestConfig.WriteBufferLengthInKb);
testDirectory = CreateTestDirectory(uncSharePath);
string file = Path.Combine(testDirectory, Guid.NewGuid().ToString());
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Start the client by sending the following requests: NEGOTIATE; SESSION_SETUP");
smb2Client = new Smb2FunctionalClient(TestConfig.FailoverTimeout, TestConfig, BaseTestSite);
smb2Client.ConnectToServerOverTCP(currentAccessIp);
smb2Client.Negotiate(
Smb2Utility.GetDialects(requestMaxDialect),
TestConfig.IsSMB1NegotiateEnabled,
capabilityValue: Capabilities_Values.GLOBAL_CAP_DFS | Capabilities_Values.GLOBAL_CAP_DIRECTORY_LEASING | Capabilities_Values.GLOBAL_CAP_LARGE_MTU | Capabilities_Values.GLOBAL_CAP_LEASING | Capabilities_Values.GLOBAL_CAP_MULTI_CHANNEL | Capabilities_Values.GLOBAL_CAP_PERSISTENT_HANDLES,
clientGuid: clientGuid,
checker: (Packet_Header header, NEGOTIATE_Response response) =>
{
BaseTestSite.Assert.AreEqual(Smb2Status.STATUS_SUCCESS, header.Status, "Negotiate should succeed.");
BaseTestSite.Assert.AreEqual(
requestMaxDialect,
response.DialectRevision,
"The server is expected to use dialect {0}. Actual dialect is {1}",
requestMaxDialect,
response.DialectRevision);
});
smb2Client.SessionSetup(
TestConfig.DefaultSecurityPackage,
serverName,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken);
uint treeId = 0;
Share_Capabilities_Values shareCapabilities = Share_Capabilities_Values.NONE;
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client sends TREE_CONNECT request to the {0} on the {1}", shareName, serverName);
DoUntilSucceed(
() => smb2Client.TreeConnect(uncSharePath, out treeId, (header, response) => { shareCapabilities = response.Capabilities; }),
TestConfig.FailoverTimeout,
"Retry TreeConnect until succeed within timeout span");
if (requestMaxDialect == DialectRevision.Smb302 && isAsymmetricShare)
{
BaseTestSite.Assert.IsTrue(shareCapabilities.HasFlag(Share_Capabilities_Values.SHARE_CAP_ASYMMETRIC),
"The capabilities of the share should contain SHARE_CAP_ASYMMETRIC. The actual capabilities is {0}.", shareCapabilities);
}
else
{
BaseTestSite.Assert.IsFalse(shareCapabilities.HasFlag(Share_Capabilities_Values.SHARE_CAP_ASYMMETRIC),
"The capabilities of the share should not contain SHARE_CAP_ASYMMETRIC. The actual capabilities is {0}.", shareCapabilities);
#region Disconnect current SMB2 connection
smb2Client.TreeDisconnect(treeId);
smb2Client.LogOff();
smb2Client.Disconnect();
#endregion
return;
}
FILEID fileId;
Smb2CreateContextResponse[] serverCreateContexts;
Guid createGuid = Guid.NewGuid();
Guid leaseKey = Guid.NewGuid();
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client writes to the file.");
smb2Client.Create(
treeId,
file,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE | CreateOptions_Values.FILE_DELETE_ON_CLOSE,
out fileId,
out serverCreateContexts,
RequestedOplockLevel_Values.OPLOCK_LEVEL_NONE);
smb2Client.Write(treeId, fileId, content);
string readContent;
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client reads from the file.");
smb2Client.Read(treeId, fileId, 0, (uint)content.Length, out readContent);
BaseTestSite.Assert.IsTrue(
content.Equals(readContent),
"Content read should be identical to that written.");
#endregion
#region Get register interface
DoUntilSucceed(() => SWNTestUtility.BindServer(swnClientForInterface, currentAccessIp,
TestConfig.DomainName, TestConfig.UserName, TestConfig.UserPassword, TestConfig.DefaultSecurityPackage,
TestConfig.DefaultRpceAuthenticationLevel, TestConfig.Timeout, serverName), TestConfig.FailoverTimeout,
"Retry BindServer until succeed within timeout span");
WITNESS_INTERFACE_LIST interfaceList = new WITNESS_INTERFACE_LIST();
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client calls WitnessrGetInterfaceList.");
DoUntilSucceed(() =>
{
ret = swnClientForInterface.WitnessrGetInterfaceList(out interfaceList);
BaseTestSite.Assert.AreEqual <SwnErrorCode>(SwnErrorCode.ERROR_SUCCESS, (SwnErrorCode)ret, "WitnessrGetInterfaceList returns with result code = 0x{0:x8}", ret);
return(SWNTestUtility.VerifyInterfaceList(interfaceList, TestConfig.Platform));
}, TestConfig.FailoverTimeout, "Retry to call WitnessrGetInterfaceList until succeed within timeout span");
swnClientForInterface.SwnUnbind(TestConfig.Timeout);
SWNTestUtility.GetRegisterInterface(interfaceList, out registerInterface);
#endregion
#region Get SHARE_MOVE_NOTIFICATION
DoUntilSucceed(() => SWNTestUtility.BindServer(swnClientForWitness,
(registerInterface.Flags & (uint)SwnNodeFlagsValue.IPv4) != 0 ? new IPAddress(registerInterface.IPV4) : SWNTestUtility.ConvertIPV6(registerInterface.IPV6),
TestConfig.DomainName, TestConfig.UserName, TestConfig.UserPassword, TestConfig.DefaultSecurityPackage,
TestConfig.DefaultRpceAuthenticationLevel, TestConfig.Timeout, serverName), TestConfig.FailoverTimeout,
"Retry BindServer until succeed within timeout span");
string clientName = TestConfig.WitnessClientName;
BaseTestSite.Log.Add(LogEntryKind.Debug, "Register witness:");
BaseTestSite.Log.Add(LogEntryKind.Debug, "\tNetName: {0}", serverName);
BaseTestSite.Log.Add(LogEntryKind.Debug, "\tIPAddress: {0}", currentAccessIp.ToString());
BaseTestSite.Log.Add(LogEntryKind.Debug, "\tClient Name: {0}", clientName);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client calls WitnessrRegisterEx.");
ret = swnClientForWitness.WitnessrRegisterEx(SwnVersion.SWN_VERSION_2,
serverName,
shareName,
currentAccessIp.ToString(),
clientName,
WitnessrRegisterExFlagsValue.WITNESS_REGISTER_IP_NOTIFICATION,
120,
out pContext);
BaseTestSite.Assert.AreEqual <SwnErrorCode>(SwnErrorCode.ERROR_SUCCESS, (SwnErrorCode)ret, "WitnessrRegisterEx returns with result code = 0x{0:x8}", ret);
BaseTestSite.Assert.IsNotNull(pContext, "Expect pContext is not null.");
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client calls WitnessrAsyncNotify.");
callId = swnClientForWitness.WitnessrAsyncNotify(pContext);
BaseTestSite.Assert.AreNotEqual <uint>(0, callId, "WitnessrAsyncNotify returns callId = {0}", callId);
// NOTICE
// This comment is for current Windows Cluster test environment.
// Current test environment has only two nodes and both they are optimum nodes.
// So whatever the server name is, SHARE_MOVE_NOTIFICATION notification will be recieved.
// The configuration items 'OptimumNodeOfAsymmetricShare' and 'NonOptimumNodeOfAsymmetricShare' are assigned the same default value.
// The code in if block will be executed all the time.
if (serverName == TestConfig.NonOptimumNodeOfAsymmetricShare)
{
#region Expect that SHARE_MOVE_NOTIFICATION notification will be received when the client connects to the asymmetric share on the non-optimum share
RESP_ASYNC_NOTIFY respNotify;
ret = swnClientForWitness.ExpectWitnessrAsyncNotify(callId, out respNotify);
BaseTestSite.Assert.AreEqual <SwnErrorCode>(SwnErrorCode.ERROR_SUCCESS, (SwnErrorCode)ret, "WitnessrAsyncNotify returns with result code = 0x{0:x8}", ret);
SWNTestUtility.PrintNotification(respNotify);
SWNTestUtility.VerifyClientMoveShareMoveAndIpChange(respNotify, SwnMessageType.SHARE_MOVE_NOTIFICATION, (uint)SwnIPAddrInfoFlags.IPADDR_V4, TestConfig.Platform);
#region Get the new IpAddr
IPADDR_INFO_LIST ipAddrInfoList;
SwnUtility.ParseIPAddrInfoList(respNotify, out ipAddrInfoList);
currentAccessIp = (ipAddrInfoList.IPAddrList[0].Flags & (uint)SwnNodeFlagsValue.IPv4) != 0 ? new IPAddress(ipAddrInfoList.IPAddrList[0].IPV4) : SWNTestUtility.ConvertIPV6(ipAddrInfoList.IPAddrList[0].IPV6);
#endregion
#region Unregister SWN Witness
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client calls WitnessrUnRegister.");
ret = swnClientForWitness.WitnessrUnRegister(pContext);
BaseTestSite.Assert.AreEqual <SwnErrorCode>(SwnErrorCode.ERROR_SUCCESS, (SwnErrorCode)ret, "WitnessrUnRegister returns with result code = 0x{0:x8}", ret);
pContext = IntPtr.Zero;
swnClientForWitness.SwnUnbind(TestConfig.Timeout);
#endregion
#region Disconnect current SMB2 connection
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Tear down the client by sending the following requests: TREE_DISCONNECT; LOG_OFF; DISCONNECT.");
smb2Client.TreeDisconnect(treeId);
smb2Client.LogOff();
smb2Client.Disconnect();
#endregion
#endregion
}
else
{
#region Expect that no SHARE_MOVE_NOTIFICATION notification will be received when the client connects to the asymmetric share on the optimum share
bool isNotificationReceived = false;
try
{
RESP_ASYNC_NOTIFY respNotify;
ret = swnClientForWitness.ExpectWitnessrAsyncNotify(callId, out respNotify);
isNotificationReceived = true;
}
catch (TimeoutException)
{
isNotificationReceived = false;
}
#region Disconnect current SMB2 connection
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Tear down the second client by sending the following requests: TREE_DISCONNECT; LOG_OFF; DISCONNECT");
smb2Client.TreeDisconnect(treeId);
smb2Client.LogOff();
smb2Client.Disconnect();
#endregion
#region Unregister SWN Witness
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client calls WitnessrUnRegister.");
ret = swnClientForWitness.WitnessrUnRegister(pContext);
BaseTestSite.Assert.AreEqual <SwnErrorCode>(SwnErrorCode.ERROR_SUCCESS, (SwnErrorCode)ret, "WitnessrUnRegister returns with result code = 0x{0:x8}", ret);
pContext = IntPtr.Zero;
swnClientForWitness.SwnUnbind(TestConfig.Timeout);
#endregion
BaseTestSite.Assert.IsFalse(isNotificationReceived, "Expect that no notification will be received when the client has connected to asymmetric share on the optimum node.");
#endregion
return;
}
#endregion
#region Connect to the share on the optimum node
smb2Client = new Smb2FunctionalClient(TestConfig.FailoverTimeout, TestConfig, BaseTestSite);
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"Got the IP {0} to access the file server", currentAccessIp.ToString());
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Start a client by sending the following requests: NEGOTIATE; SESSION_SETUP");
smb2Client.ConnectToServerOverTCP(currentAccessIp);
smb2Client.Negotiate(
TestConfig.RequestDialects,
TestConfig.IsSMB1NegotiateEnabled,
capabilityValue: Capabilities_Values.GLOBAL_CAP_DFS | Capabilities_Values.GLOBAL_CAP_DIRECTORY_LEASING | Capabilities_Values.GLOBAL_CAP_LARGE_MTU | Capabilities_Values.GLOBAL_CAP_LEASING | Capabilities_Values.GLOBAL_CAP_MULTI_CHANNEL | Capabilities_Values.GLOBAL_CAP_PERSISTENT_HANDLES,
clientGuid: clientGuid,
checker: (Packet_Header header, NEGOTIATE_Response response) =>
{
BaseTestSite.Assert.AreEqual(Smb2Status.STATUS_SUCCESS, header.Status, "Negotiate should succeed.");
});
smb2Client.SessionSetup(
TestConfig.DefaultSecurityPackage,
serverName,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken);
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"Client sends TREE_CONNECT and wait for a response until timeout.");
DoUntilSucceed(
() => smb2Client.TreeConnect(uncSharePath, out treeId, (header, response) => { }),
TestConfig.FailoverTimeout,
"Retry TreeConnect until succeed within timeout span");
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client writes to the file.");
smb2Client.Create(
treeId,
file,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE | CreateOptions_Values.FILE_DELETE_ON_CLOSE,
out fileId,
out serverCreateContexts,
RequestedOplockLevel_Values.OPLOCK_LEVEL_NONE);
smb2Client.Write(treeId, fileId, content);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client reads from the file.");
smb2Client.Read(treeId, fileId, 0, (uint)content.Length, out readContent);
BaseTestSite.Assert.IsTrue(
content.Equals(readContent),
"Content read should be identical to that written.");
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Tear down the client by sending the following requests: TREE_DISCONNECT; LOG_OFF; DISCONNECT.");
smb2Client.TreeDisconnect(treeId);
smb2Client.LogOff();
smb2Client.Disconnect();
#endregion
}
protected void SetSecurityDescriptor(string sharePath, string fileName, _SECURITY_DESCRIPTOR sd, SET_INFO_Request_AdditionalInformation_Values securityAttributesToApply)
{
Smb2FunctionalClient clientAdmin;
clientAdmin = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
clientAdmin.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress);
uint treeId;
ConnectToShare(clientAdmin, TestConfig.AccountCredential, sharePath, out treeId);
FILEID fileId;
Smb2CreateContextResponse[] createContextResponses;
clientAdmin.Create(treeId,
fileName,
fileName == null ? CreateOptions_Values.FILE_DIRECTORY_FILE : CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId,
out createContextResponses,
accessMask: AccessMask.READ_CONTROL | AccessMask.WRITE_DAC | AccessMask.FILE_READ_ATTRIBUTES | AccessMask.WRITE_OWNER | AccessMask.ACCESS_SYSTEM_SECURITY,
shareAccess: ShareAccess_Values.FILE_SHARE_DELETE | ShareAccess_Values.FILE_SHARE_READ | ShareAccess_Values.FILE_SHARE_WRITE,
createDisposition: CreateDisposition_Values.FILE_OPEN);
clientAdmin.SetSecurityDescriptor(treeId, fileId, securityAttributesToApply, sd);
clientAdmin.Close(treeId, fileId);
clientAdmin.TreeDisconnect(treeId);
clientAdmin.Disconnect();
}
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();
}
public void BVT_SMB2Basic_QueryAndSet_FileInfo()
{
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Starts a client by sending the following requests: NEGOTIATE; SESSION_SETUP; TREE_CONNECT.");
client1 = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
client1.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress);
client1.Negotiate(TestConfig.RequestDialects, TestConfig.IsSMB1NegotiateEnabled);
client1.SessionSetup(
TestConfig.DefaultSecurityPackage,
TestConfig.SutComputerName,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken);
uint treeId1;
client1.TreeConnect(uncSharePath, out treeId1);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client sends CREATE request with desired access set to GENERIC_READ and GENERIC_WRITE to create a file.");
Smb2CreateContextResponse[] serverCreateContexts;
CREATE_Response? createResponse = null;
string fileName = Guid.NewGuid().ToString() + ".txt";
FILEID fileId1;
client1.Create(
treeId1,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId1,
out serverCreateContexts,
accessMask: AccessMask.GENERIC_READ | AccessMask.GENERIC_WRITE,
checker: (Packet_Header header, CREATE_Response response) =>
{
BaseTestSite.Assert.AreEqual(
Smb2Status.STATUS_SUCCESS,
header.Status,
"CREATE should succeed, actually server returns {0}.", Smb2Status.GetStatusCode(header.Status));
BaseTestSite.Log.Add(LogEntryKind.TestStep,
"FileBasicInformation in CREATE response: \r\nCreationTime: {0}\r\nLastAccessTime:{1}\r\nLastWriteTime: {2}\r\nChangeTime: {3}\r\nFileAttributes: {4}",
Smb2Utility.ConvertToDateTimeUtc(response.CreationTime).ToString("MM/dd/yyy hh:mm:ss.ffffff"),
Smb2Utility.ConvertToDateTimeUtc(response.LastAccessTime).ToString("MM/dd/yyy hh:mm:ss.ffffff"),
Smb2Utility.ConvertToDateTimeUtc(response.LastWriteTime).ToString("MM/dd/yyy hh:mm:ss.ffffff"),
Smb2Utility.ConvertToDateTimeUtc(response.ChangeTime).ToString("MM/dd/yyy hh:mm:ss.ffffff"),
response.FileAttributes);
createResponse = response;
});
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client sends QUERY_INFO request to query file attributes.");
byte[] outputBuffer;
client1.QueryFileAttributes(
treeId1,
(byte)FileInformationClasses.FileBasicInformation,
QUERY_INFO_Request_Flags_Values.SL_RESTART_SCAN,
fileId1,
new byte[0] { },
out outputBuffer);
FileBasicInformation fileBasicInfo = TypeMarshal.ToStruct<FileBasicInformation>(outputBuffer);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "FileBasicInformation in QUERY_INFO response: \r\nCreationTime: {0}\r\nLastAccessTime:{1}\r\nLastWriteTime: {2}\r\nChangeTime: {3}\r\nFileAttributes: {4}",
Smb2Utility.ConvertToDateTimeUtc(fileBasicInfo.CreationTime).ToString("MM/dd/yyy hh:mm:ss.ffffff"),
Smb2Utility.ConvertToDateTimeUtc(fileBasicInfo.LastAccessTime).ToString("MM/dd/yyy hh:mm:ss.ffffff"),
Smb2Utility.ConvertToDateTimeUtc(fileBasicInfo.LastWriteTime).ToString("MM/dd/yyy hh:mm:ss.ffffff"),
Smb2Utility.ConvertToDateTimeUtc(fileBasicInfo.ChangeTime).ToString("MM/dd/yyy hh:mm:ss.ffffff"),
fileBasicInfo.FileAttributes);
BaseTestSite.Assert.AreEqual(createResponse.Value.CreationTime, fileBasicInfo.CreationTime, "CreationTime received in QUERY_INFO response should be identical with that got in CREATE response");
BaseTestSite.Assert.AreEqual(createResponse.Value.LastAccessTime, fileBasicInfo.LastAccessTime, "LastAccessTime received in QUERY_INFO response should be identical with that got in CREATE response");
BaseTestSite.Assert.AreEqual(createResponse.Value.LastWriteTime, fileBasicInfo.LastWriteTime, "LastWriteTime received in QUERY_INFO response should be identical with that got in CREATE response");
BaseTestSite.Assert.AreEqual(createResponse.Value.ChangeTime, fileBasicInfo.ChangeTime, "ChangeTime received in QUERY_INFO response should be identical with that got in CREATE response");
BaseTestSite.Assert.AreEqual(createResponse.Value.FileAttributes, fileBasicInfo.FileAttributes, "FileAttributes received in QUERY_INFO response should be identical with that got in CREATE response");
FileBasicInformation fileBasicInfoToSet = fileBasicInfo;
DateTime dateTimeToSet = DateTime.UtcNow;
fileBasicInfoToSet.LastAccessTime = Smb2Utility.ConvertToFileTime(dateTimeToSet);
byte[] inputBuffer;
inputBuffer = TypeMarshal.ToBytes<FileBasicInformation>(fileBasicInfoToSet);
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"Client sends SetFileAttributes request to set LastAccessTime for the file to {0}", dateTimeToSet.ToString("MM/dd/yyy hh:mm:ss.ffffff"));
client1.SetFileAttributes(
treeId1,
(byte)FileInformationClasses.FileBasicInformation,
fileId1,
inputBuffer);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client sends QUERY request to query file attributes.");
client1.QueryFileAttributes(
treeId1,
(byte)FileInformationClasses.FileBasicInformation,
QUERY_INFO_Request_Flags_Values.SL_RESTART_SCAN,
fileId1,
new byte[0] { },
out outputBuffer);
fileBasicInfo = TypeMarshal.ToStruct<FileBasicInformation>(outputBuffer);
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"LastAccessTime in QUERY_INFO response after SET_INFO {0}",
Smb2Utility.ConvertToDateTimeUtc(fileBasicInfo.LastAccessTime).ToString("MM/dd/yyy hh:mm:ss.ffffff"));
BaseTestSite.Assert.AreNotEqual(
createResponse.Value.LastAccessTime,
fileBasicInfo.LastAccessTime,
"LastAccessTime (dwHighDateTime:{0}, dwLowDateTime:{1}) after SET_INFO should not be equal to the value (dwHighDateTime:{2}, dwLowDateTime:{3}) before SET_INFO",
fileBasicInfo.LastAccessTime.dwHighDateTime, fileBasicInfo.LastAccessTime.dwLowDateTime, createResponse.Value.LastAccessTime.dwHighDateTime, createResponse.Value.LastAccessTime.dwLowDateTime);
BaseTestSite.Assert.AreEqual(
fileBasicInfoToSet.LastAccessTime,
fileBasicInfo.LastAccessTime,
"LastAccessTime (dwHighDateTime:{0}, dwLowDateTime:{1}) queried after SET_INFO should be equal to the desired value (dwHighDateTime:{2}, dwLowDateTime:{3})",
fileBasicInfo.LastAccessTime.dwHighDateTime, fileBasicInfo.LastAccessTime.dwLowDateTime, fileBasicInfoToSet.LastAccessTime.dwHighDateTime, fileBasicInfoToSet.LastAccessTime.dwLowDateTime);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Tear down the client by sending the following requests: CLOSE; TREE_DISCONNECT; LOG_OFF");
client1.Close(treeId1, fileId1);
client1.TreeDisconnect(treeId1);
client1.LogOff();
}
public void PersistentHandle_ReOpenFromDiffClient()
{
/// 1. A client requests a persistent handle and succeeds
/// 2. The client disconnects from the server
/// 3. Another client (different client guid) opens the same file
/// 4. The expected result of the second OPEN is STATUS_FILE_NOT_AVAILABLE according to section 3.3.5.9:
/// If Connection.Dialect belongs to the SMB 3.x dialect family and the request does not contain SMB2_CREATE_DURABLE_HANDLE_RECONNECT
/// Create Context or SMB2_CREATE_DURABLE_HANDLE_RECONNECT_V2 Create Context, the server MUST look up an existing open in the GlobalOpenTable
/// where Open.FileName matches the file name in the Buffer field of the request.
/// If an Open entry is found, and if all the following conditions are satisfied, the server SHOULD fail the request with STATUS_FILE_NOT_AVAILABLE.
/// Open.IsPersistent is TRUE
/// Open.Connection is NULL
#region Check Applicability
TestConfig.CheckDialect(DialectRevision.Smb30);
TestConfig.CheckCapabilities(NEGOTIATE_Response_Capabilities_Values.GLOBAL_CAP_PERSISTENT_HANDLES);
#endregion
Smb2FunctionalClient clientBeforeDisconnection = new Smb2FunctionalClient(testConfig.Timeout, testConfig, this.Site);
durableHandleUncSharePath = Smb2Utility.GetUncPath(testConfig.CAShareServerName, testConfig.CAShareName);
// It will cost 3 minutes to delete this file, so do not add it to testFiles to skip auto-clean.
string fileName = CurrentTestCaseName + "_" + Guid.NewGuid().ToString();
BaseTestSite.Log.Add(LogEntryKind.TestStep, "1. A client requests a persistent handle and succeeds");
uint treeIdBeforeDisconnection;
Connect(DialectRevision.Smb30, clientBeforeDisconnection, Guid.NewGuid(), testConfig.AccountCredential, ConnectShareType.CAShare, out treeIdBeforeDisconnection, null);
FILEID fileIdBeforeDisconnection;
Smb2CreateContextResponse[] serverCreateContexts = null;
status = clientBeforeDisconnection.Create(
treeIdBeforeDisconnection,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileIdBeforeDisconnection,
out serverCreateContexts,
RequestedOplockLevel_Values.OPLOCK_LEVEL_NONE,
new Smb2CreateContextRequest[] {
new Smb2CreateDurableHandleRequestV2
{
CreateGuid = Guid.NewGuid(),
Flags = CREATE_DURABLE_HANDLE_REQUEST_V2_Flags.DHANDLE_FLAG_PERSISTENT,
}
},
shareAccess: ShareAccess_Values.NONE,
checker: (header, response) =>
{
BaseTestSite.Assert.AreEqual(
Smb2Status.STATUS_SUCCESS,
header.Status,
"{0} should be successful, actually server returns {1}.", header.Command, Smb2Status.GetStatusCode(header.Status));
CheckCreateContextResponses(serverCreateContexts, new DefaultDurableHandleV2ResponseChecker(BaseTestSite, CREATE_DURABLE_HANDLE_RESPONSE_V2_Flags.DHANDLE_FLAG_PERSISTENT, uint.MaxValue));
});
// Disconnect
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"2. The client disconnects from the server");
clientBeforeDisconnection.Disconnect();
//If an Open entry is found, and if all the following conditions are satisfied, the server SHOULD<276> fail the request with STATUS_FILE_NOT_AVAILABLE.
// Open.IsPersistent is TRUE
// Open.Connection is NULL
//<276> Section 3.3.5.9: If Open.ClientGuid is not equal to the ClientGuid of the connection that received this request, Open.Lease.LeaseState is equal to RWH, or Open.OplockLevel is equal to SMB2_OPLOCK_LEVEL_BATCH,
// Windows-based servers will attempt to break the lease/oplock and return STATUS_PENDING to process the create request asynchronously. Otherwise, if Open.Lease.LeaseState does not include SMB2_LEASE_HANDLE_CACHING and
// Open.OplockLevel is not equal to SMB2_OPLOCK_LEVEL_BATCH, Windows-based servers return STATUS_FILE_NOT_AVAILABLE.
// Open from another client
Smb2FunctionalClient anotherClient = new Smb2FunctionalClient(testConfig.Timeout, testConfig, this.Site);
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"3. Open the same file from different client (different client guid), the expected result of OPEN is STATUS_FILE_NOT_AVAILABLE");
uint treeIdAfterDisconnection;
Connect(DialectRevision.Smb30, anotherClient, Guid.NewGuid(), testConfig.AccountCredential, ConnectShareType.CAShare, out treeIdAfterDisconnection, null);
FILEID fileIdAfterDisconnection;
status = anotherClient.Create(
treeIdAfterDisconnection,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileIdAfterDisconnection,
out serverCreateContexts,
RequestedOplockLevel_Values.OPLOCK_LEVEL_NONE,
new Smb2CreateContextRequest[] {
new Smb2CreateDurableHandleRequestV2
{
CreateGuid = Guid.NewGuid(),
Flags = CREATE_DURABLE_HANDLE_REQUEST_V2_Flags.DHANDLE_FLAG_PERSISTENT,
}
},
shareAccess: ShareAccess_Values.NONE,
checker: (header, response) =>
{
if (TestConfig.Platform == Platform.NonWindows)
{
BaseTestSite.Assert.AreNotEqual(
Smb2Status.STATUS_SUCCESS,
header.Status,
"The server SHOULD fail the request with STATUS_FILE_NOT_AVAILABLE.");
}
else
{
BaseTestSite.Assert.AreEqual(
Smb2Status.STATUS_FILE_NOT_AVAILABLE,
header.Status,
"The server SHOULD fail the request with STATUS_FILE_NOT_AVAILABLE.");
}
});
}
/// <summary>
/// Read content after failover
/// </summary>
/// <param name="server">File server name.</param>
/// <param name="serverAccessIp">File server access IP.</param>
/// <param name="uncSharePath">The share path to read the file.</param>
/// <param name="file">The file name for reading content.</param>
/// <param name="content">The content to read.</param>
/// <param name="clientGuid">Smb2 client Guid.</param>
/// <param name="createGuid">The Guid for smb2 create request.</param>
/// <returns></returns>
protected bool ReadContentAfterFailover(string server,
IPAddress serverAccessIp,
string uncSharePath,
string file,
string content,
Guid clientGuid,
Guid createGuid)
{
uint status;
BaseTestSite.Assert.AreNotEqual(
null,
serverAccessIp,
"Access IP to the file server should not be empty");
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Got IP {0} to access the file server", serverAccessIp.ToString());
Smb2FunctionalClient afterFailover = new Smb2FunctionalClient(TestConfig.FailoverTimeout, TestConfig, BaseTestSite);
DoUntilSucceed(() => afterFailover.ConnectToServer(TestConfig.UnderlyingTransport, server, serverAccessIp), TestConfig.FailoverTimeout,
"Retry to connect to server until succeed within timeout span");
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client sends NEGOTIATE request with the same clientguid of previous client.");
status = afterFailover.Negotiate(
TestConfig.RequestDialects,
TestConfig.IsSMB1NegotiateEnabled,
capabilityValue: Capabilities_Values.GLOBAL_CAP_DFS | Capabilities_Values.GLOBAL_CAP_DIRECTORY_LEASING | Capabilities_Values.GLOBAL_CAP_LARGE_MTU | Capabilities_Values.GLOBAL_CAP_LEASING | Capabilities_Values.GLOBAL_CAP_MULTI_CHANNEL | Capabilities_Values.GLOBAL_CAP_PERSISTENT_HANDLES,
clientGuid: clientGuid);
if (status != Smb2Status.STATUS_SUCCESS)
{
BaseTestSite.Log.Add(LogEntryKind.Warning, "Negotiate failed with {0}.", Smb2Status.GetStatusCode(status));
return false;
}
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client sends SESSION_SETUP request with the same SESSION_ID of previous client.");
status = afterFailover.ReconnectSessionSetup(
beforeFailover,
TestConfig.DefaultSecurityPackage,
server,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken);
if (status != Smb2Status.STATUS_SUCCESS)
{
BaseTestSite.Log.Add(LogEntryKind.Warning, "ReconnectSessionSetup failed with {0}.", Smb2Status.GetStatusCode(status));
return false;
}
// Retry TreeConnect because network path may not be available immediately
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client retries TREE_CONNECT to {0} until succeed or timeout in {1} because network path may not be available immediately.", uncSharePath, TestConfig.FailoverTimeout);
uint treeId = 0;
status = afterFailover.TreeConnect(uncSharePath, out treeId, (header, response) => { });
if (status != Smb2Status.STATUS_SUCCESS)
{
BaseTestSite.Log.Add(LogEntryKind.Warning, "TreeConnect failed with {0}.", Smb2Status.GetStatusCode(status));
return false;
}
// Retry Create because file may not be available immediately
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client retries to send CREATE request with SMB2_CREATE_DURABLE_HANDLE_RECONNECT_V2 context with PERSISTENT flag set until succeed or timeout in {0}.", TestConfig.FailoverTimeout);
FILEID fileId = new FILEID();
Smb2CreateContextResponse[] serverCreateContexts;
status = DoUntilSucceed(
() => afterFailover.Create(
treeId,
file,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId,
out serverCreateContexts,
RequestedOplockLevel_Values.OPLOCK_LEVEL_NONE,
new Smb2CreateContextRequest[] {
new Smb2CreateDurableHandleReconnectV2
{
FileId = new FILEID { Persistent = fileId.Persistent },
CreateGuid = createGuid,
Flags = CREATE_DURABLE_HANDLE_RECONNECT_V2_Flags.DHANDLE_FLAG_PERSISTENT
},
},
checker: (header, response) => { }),
TestConfig.FailoverTimeout,
"Retry Create until succeed within timeout span");
if (status != Smb2Status.STATUS_SUCCESS)
{
BaseTestSite.Log.Add(LogEntryKind.Warning, "Create failed with {0}.", Smb2Status.GetStatusCode(status));
return false;
}
string readContent;
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client sends READ request to read content.");
status = afterFailover.Read(treeId, fileId, 0, (uint)content.Length, out readContent);
if (status != Smb2Status.STATUS_SUCCESS)
{
BaseTestSite.Log.Add(LogEntryKind.Warning, "Read failed with {0}.", Smb2Status.GetStatusCode(status));
return false;
}
BaseTestSite.Assert.IsTrue(
content.Equals(readContent),
"Content read after failover should be identical to that written before failover");
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Tear down the client by sending the following requests: CLOSE; TREE_DISCONNECT; LOG_OFF");
status = afterFailover.Close(treeId, fileId);
status = afterFailover.TreeDisconnect(treeId);
status = afterFailover.LogOff();
afterFailover.Disconnect();
return true;
}
public void BVT_SetGetIntegrityInfo()
{
#region Check Applicability
TestConfig.CheckDialect(DialectRevision.Smb30);
TestConfig.CheckIOCTL(CtlCode_Values.FSCTL_SET_INTEGRITY_INFORMATION, CtlCode_Values.FSCTL_GET_INTEGRITY_INFORMATION);
#endregion
client.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client creates a file by sending the following requests: NEGOTIATE; SESSION_SETUP; TREE_CONNECT; CREATE");
status = client.Negotiate(
TestConfig.RequestDialects,
TestConfig.IsSMB1NegotiateEnabled,
checker: (Packet_Header header, NEGOTIATE_Response response) =>
{
BaseTestSite.Assert.AreEqual(
Smb2Status.STATUS_SUCCESS,
header.Status,
"Negotiation should succeed, actually server returns {0}.", Smb2Status.GetStatusCode(header.Status));
TestConfig.CheckNegotiateDialect(DialectRevision.Smb30, response);
});
status = client.SessionSetup(
TestConfig.DefaultSecurityPackage,
TestConfig.SutComputerName,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken);
uint treeId;
string uncSharePath = Smb2Utility.GetUncPath(TestConfig.SutComputerName, TestConfig.FileShareSupportingIntegrityInfo);
status = client.TreeConnect(uncSharePath, out treeId);
FILEID fileId;
Smb2CreateContextResponse[] serverCreateContexts;
status = client.Create(
treeId,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId,
out serverCreateContexts);
FSCTL_GET_INTEGRITY_INFO_OUTPUT getIntegrityInfo;
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client sends IOCTL request with FSCTL_GET_INTEGRITY_INFORMATION.");
status = client.GetIntegrityInfo(treeId, fileId, out getIntegrityInfo);
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Integrity info returned in FSCTL_GET_INTEGRITY_INFO request: ChecksumAlgorithm {0}, Flags {1}, ChecksumChunkSizeInBytes {2}, ClusterSizeInBytes {3}",
getIntegrityInfo.ChecksumAlgorithm, getIntegrityInfo.Flags, getIntegrityInfo.ChecksumChunkSizeInBytes, getIntegrityInfo.ClusterSizeInBytes);
FSCTL_SET_INTEGRIY_INFO_INPUT setIntegrityInfo;
setIntegrityInfo.ChecksumAlgorithm = FSCTL_SET_INTEGRITY_INFO_INPUT_CHECKSUMALGORITHM.CHECKSUM_TYPE_CRC64;
setIntegrityInfo.Flags = FSCTL_SET_INTEGRITY_INFO_INPUT_FLAGS.FSCTL_INTEGRITY_FLAG_CHECKSUM_ENFORCEMENT_OFF;
setIntegrityInfo.Reserved = FSCTL_SET_INTEGRITY_INFO_INPUT_RESERVED.V1;
byte[] buffer = TypeMarshal.ToBytes <FSCTL_SET_INTEGRIY_INFO_INPUT>(setIntegrityInfo);
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Attempt to set integrity info with ChecksumAlgrithm {0}, Flags {1}",
setIntegrityInfo.ChecksumAlgorithm, setIntegrityInfo.Flags);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client sends IOCTL request with FSCTL_SET_INTEGRITY_INFORMATION after changed the value of the following fields in FSCTL_SET_INTEGRIY_INFO_INPUT: ChecksumAlgorithm, Flags, Reserved.");
status = client.SetIntegrityInfo(treeId, fileId, buffer);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client sends IOCTL request with FSCTL_GET_INTEGRITY_INFORMATION.");
status = client.GetIntegrityInfo(treeId, fileId, out getIntegrityInfo);
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Current ChecksumAlgorithm is " + getIntegrityInfo.ChecksumAlgorithm);
BaseTestSite.Assert.AreEqual(
(ushort)setIntegrityInfo.ChecksumAlgorithm,
(ushort)getIntegrityInfo.ChecksumAlgorithm,
"ChecksumAlgorithm field after set should be {0}, actual value is {1}", setIntegrityInfo.ChecksumAlgorithm, getIntegrityInfo.ChecksumAlgorithm);
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Current Flags is " + getIntegrityInfo.Flags);
BaseTestSite.Assert.AreEqual(
(uint)setIntegrityInfo.Flags,
(uint)getIntegrityInfo.Flags,
"Flags field after set should be {0}, actual value is {1}", setIntegrityInfo.Flags, getIntegrityInfo.Flags);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Tear down the client by sending the following requests: CLOSE; TREE_DISCONNECT; LOG_OFF.");
status = client.Close(treeId, fileId);
status = client.TreeDisconnect(treeId);
status = client.LogOff();
}
private void CreateFile(string uncShare, string fileName, int lengthInByte)
{
Site.Log.Add(
LogEntryKind.Debug,
"Create file {0} in share {1}", fileName, uncShare);
Smb2FunctionalClient client = new Smb2FunctionalClient(testConfig.Timeout, testConfig, this.Site);
client.ConnectToServer(testConfig.UnderlyingTransport, testConfig.SutComputerName, testConfig.SutIPAddress);
client.CreditGoal = 32;
client.Negotiate(
new DialectRevision[] { ModelUtility.GetDialectRevision(config.MaxSmbVersionSupported) },
testConfig.IsSMB1NegotiateEnabled,
capabilityValue: Capabilities_Values.GLOBAL_CAP_LARGE_MTU);
client.SessionSetup(
testConfig.DefaultSecurityPackage,
testConfig.SutComputerName,
testConfig.AccountCredential,
testConfig.UseServerGssToken);
uint tId;
client.TreeConnect(
uncShare,
out tId);
Smb2CreateContextResponse[] serverCreateContexts;
FILEID fId;
client.Create(
tId,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fId,
out serverCreateContexts);
string content;
if (isMultiCreditSupportedOnConnection)
{
content = Smb2Utility.CreateRandomStringInByte(lengthInByte);
client.Write(tId, fId, content);
}
else
{
// Write several times if server does not support multi credit
int writeTimes = lengthInByte / (64 * 1024);
int rest = lengthInByte % (64 * 1024);
ulong offset = 0;
for (int time = 0; time < writeTimes; time++)
{
content = Smb2Utility.CreateRandomString(64);
client.Write(tId, fId, content, offset);
offset += 64 * 1024;
}
if (rest != 0)
{
content = Smb2Utility.CreateRandomStringInByte(rest);
client.Write(tId, fId, content, offset);
}
}
client.Close(tId, fId);
client.TreeDisconnect(tId);
client.LogOff();
client.Disconnect();
Site.Log.Add(
LogEntryKind.Debug,
"Create file {0} in share {1}", fileName, uncShare);
}
private void CreateFile(string uncShare, string fileName, int lengthInByte)
{
Site.Log.Add(
LogEntryKind.Debug,
"Create file {0} in share {1}", fileName, uncShare);
Smb2FunctionalClient client = new Smb2FunctionalClient(testConfig.Timeout, testConfig, this.Site);
client.ConnectToServer(testConfig.UnderlyingTransport, testConfig.SutComputerName, testConfig.SutIPAddress);
client.CreditGoal = 32;
client.Negotiate(
new DialectRevision[] { ModelUtility.GetDialectRevision(config.MaxSmbVersionSupported) },
testConfig.IsSMB1NegotiateEnabled,
capabilityValue: Capabilities_Values.GLOBAL_CAP_LARGE_MTU);
client.SessionSetup(
testConfig.DefaultSecurityPackage,
testConfig.SutComputerName,
testConfig.AccountCredential,
testConfig.UseServerGssToken);
uint tId;
client.TreeConnect(
uncShare,
out tId);
Smb2CreateContextResponse[] serverCreateContexts;
FILEID fId;
client.Create(
tId,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fId,
out serverCreateContexts);
string content;
if (isMultiCreditSupportedOnConnection)
{
content = Smb2Utility.CreateRandomStringInByte(lengthInByte);
client.Write(tId, fId, content);
}
else
{
// Write several times if server does not support multi credit
int writeTimes = lengthInByte / (64 * 1024);
int rest = lengthInByte % (64 * 1024);
ulong offset = 0;
for (int time = 0; time < writeTimes; time++)
{
content = Smb2Utility.CreateRandomString(64);
client.Write(tId, fId, content, offset);
offset += 64 * 1024;
}
if (rest != 0)
{
content = Smb2Utility.CreateRandomStringInByte(rest);
client.Write(tId, fId, content, offset);
}
}
client.Close(tId, fId);
client.TreeDisconnect(tId);
client.LogOff();
client.Disconnect();
Site.Log.Add(
LogEntryKind.Debug,
"Create file {0} in share {1}", fileName, uncShare);
}
/// <summary>
/// Create an open from client, this include NEGOTIATE and SESSION_SETUP with server, TREE_CONNECT to the share and CREATE an open to file/directory
/// </summary>
/// <param name="client">Client used to take the operation</param>
/// <param name="clientGuid">Client GUID for negotiation</param>
/// <param name="targetName">File/directory name for the open</param>
/// <param name="isDirectory">Set true if create open to a directory, set false if create open to a file</param>
/// <param name="accessMask">Desired access when create the open</param>
/// <param name="treeId">Out param for tree id used to connect to the share</param>
/// <param name="fileId">Out param for file id that is associated with the open</param>
/// <param name="shareAccess">Optional param for share access when create the open</param>
/// <returns>Status value returned from CREATE request</returns>
private uint CreateOpenFromClient(Smb2FunctionalClient client, Guid clientGuid, string targetName, bool isDirectory, LeaseStateValues requestLeaseState, AccessMask accessMask, out uint treeId, out FILEID fileId, ShareAccess_Values shareAccess = ShareAccess_Values.FILE_SHARE_DELETE | ShareAccess_Values.FILE_SHARE_READ | ShareAccess_Values.FILE_SHARE_WRITE)
{
#region Negotiate
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"Client {0} sends NEGOTIATE request with the following capabilities: Capabilities_Values.GLOBAL_CAP_DFS | Capabilities_Values.GLOBAL_CAP_DIRECTORY_LEASING | Capabilities_Values.GLOBAL_CAP_LARGE_MTU | Capabilities_Values.GLOBAL_CAP_LEASING | Capabilities_Values.GLOBAL_CAP_MULTI_CHANNEL | Capabilities_Values.GLOBAL_CAP_PERSISTENT_HANDLES.", clientGuid.ToString());
client.Negotiate(
TestConfig.RequestDialects,
TestConfig.IsSMB1NegotiateEnabled,
capabilityValue: Capabilities_Values.GLOBAL_CAP_DFS | Capabilities_Values.GLOBAL_CAP_DIRECTORY_LEASING | Capabilities_Values.GLOBAL_CAP_LARGE_MTU | Capabilities_Values.GLOBAL_CAP_LEASING | Capabilities_Values.GLOBAL_CAP_MULTI_CHANNEL | Capabilities_Values.GLOBAL_CAP_PERSISTENT_HANDLES,
clientGuid: clientGuid,
checker: (Packet_Header header, NEGOTIATE_Response response) =>
{
BaseTestSite.Assert.AreEqual(
Smb2Status.STATUS_SUCCESS,
header.Status,
"Negotiation is expected success, actually server returns {0}", Smb2Status.GetStatusCode(header.Status));
TestConfig.CheckNegotiateDialect(DialectRevision.Smb30, response);
TestConfig.CheckNegotiateCapabilities(NEGOTIATE_Response_Capabilities_Values.GLOBAL_CAP_DIRECTORY_LEASING, response);
});
#endregion
#region SESSION_SETUP
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client {0} sends SESSION_SETUP request.", clientGuid.ToString());
status = client.SessionSetup(
TestConfig.DefaultSecurityPackage,
TestConfig.SutComputerName,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken);
#endregion
#region TREE_CONNECT to share
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client {0} sends TREE_CONNECT request.", clientGuid.ToString());
status = client.TreeConnect(uncSharePath, out treeId);
#endregion
#region CREATE
Smb2CreateContextResponse[] serverCreateContexts;
CreateOptions_Values createOptions;
if (isDirectory)
{
createOptions = CreateOptions_Values.FILE_DIRECTORY_FILE;
}
else
{
createOptions = CreateOptions_Values.FILE_NON_DIRECTORY_FILE;
}
// Include FILE_DELETE_ON_CLOSE if accessMask has DELETE
if ((accessMask & AccessMask.DELETE) == AccessMask.DELETE)
{
createOptions = createOptions | CreateOptions_Values.FILE_DELETE_ON_CLOSE;
}
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"Client {0} sends CREATE request with the lease state in SMB2_CREATE_REQUEST_LEASE_V2 set to {1}.", clientGuid.ToString(), requestLeaseState);
status = client.Create(
treeId,
targetName,
createOptions,
out fileId,
out serverCreateContexts,
RequestedOplockLevel_Values.OPLOCK_LEVEL_LEASE,
new Smb2CreateContextRequest[]
{
new Smb2CreateRequestLeaseV2
{
LeaseKey = clientGuid,
LeaseState = requestLeaseState
}
},
accessMask: accessMask,
shareAccess: shareAccess,
checker: (header, response) => { });
return status;
#endregion
}
public void SetupConnection(ModelDialectRevision clientMaxDialect)
{
testClient = new Smb2FunctionalClient(testConfig.Timeout, testConfig, this.Site);
testClient.ConnectToServer(testConfig.UnderlyingTransport, testConfig.SutComputerName, testConfig.SutIPAddress);
testClient.RequestSent += new Action <Packet_Header>(PrintSequenceWindow);
DialectRevision[] dialects = Smb2Utility.GetDialects(ModelUtility.GetDialectRevision(clientMaxDialect));
uint status;
NEGOTIATE_Response?negotiateResponse = null;
status = testClient.Negotiate(
dialects,
testConfig.IsSMB1NegotiateEnabled,
capabilityValue: Capabilities_Values.GLOBAL_CAP_LARGE_MTU,
checker: (header, response) =>
{
Site.Assert.AreEqual(
Smb2Status.STATUS_SUCCESS,
header.Status,
"{0} should succeed", header.Command);
// The server MUST grant the client at least 1 credit when responding to SMB2 NEGOTIATE.
Site.Assert.IsTrue(
header.CreditRequestResponse >= 1,
"The server MUST grant the client at least 1 credit when responding to SMB2 NEGOTIATE");
negotiateResponse = response;
});
Site.Log.Add(
LogEntryKind.Debug,
"The maximum size, in bytes, of Length in READ/WRITE that server will accept on the connection is {0}",
testClient.MaxBufferSize);
Site.Assert.AreEqual(
ModelUtility.GetDialectRevision(clientMaxDialect),
negotiateResponse.Value.DialectRevision,
"DialectRevision {0} is expected", ModelUtility.GetDialectRevision(clientMaxDialect));
negotiateDialect = negotiateResponse.Value.DialectRevision;
if ((negotiateDialect == DialectRevision.Smb21 || ModelUtility.IsSmb3xFamily(negotiateDialect))
// In case server does not support multicredit even implement Smb21 or Smb30
&& testConfig.IsMultiCreditSupported)
{
isMultiCreditSupportedOnConnection = true;
}
else
{
isMultiCreditSupportedOnConnection = false;
}
status = testClient.SessionSetup(
testConfig.DefaultSecurityPackage,
testConfig.SutComputerName,
testConfig.AccountCredential,
testConfig.UseServerGssToken);
status = testClient.TreeConnect(
uncSharePath,
out treeId);
Smb2CreateContextResponse[] serverCreateContexts;
fileName = Guid.NewGuid().ToString();
status = testClient.Create(
treeId,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId,
out serverCreateContexts);
}
/// <summary>
/// Read and write file within byte lock range when the file is locked or unlocked
/// </summary>
/// <param name="isLocked">Set true to indicate that byte lock range is taken on the file</param>
/// <param name="serverName">Name of file server to access</param>
/// <param name="targetFileName">Target file name to read and write</param>
private void ValidateByteLockRangeFromAnotherClient(bool isLocked, string serverName, string targetFileName)
{
uint status = 0;
Smb2FunctionalClient client = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
client = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
client.ConnectToServer(TestConfig.UnderlyingTransport, serverName, currentAccessIp);
status = client.Negotiate(TestConfig.RequestDialects, TestConfig.IsSMB1NegotiateEnabled);
status = client.SessionSetup(
TestConfig.DefaultSecurityPackage,
serverName,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken);
uint treeId;
status = client.TreeConnect(uncSharePath, out treeId);
Smb2CreateContextResponse[] serverCreateContexts;
FILEID fileId;
status = client.Create(
treeId,
targetFileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId,
out serverCreateContexts);
string data;
Random random = new Random();
uint offset = (uint)random.Next(0, TestConfig.WriteBufferLengthInKb * 1024 - 1);
uint length = (uint)random.Next(0, (int)(TestConfig.WriteBufferLengthInKb * 1024 - offset));
status = client.Read(treeId, fileId, offset, length, out data);
status = client.Write(treeId, fileId, contentWrite, checker: (header, response) => { });
if (isLocked)
{
BaseTestSite.Assert.AreNotEqual(
Smb2Status.STATUS_SUCCESS,
status,
"Write content to locked range of file from different client is not expected to success");
BaseTestSite.CaptureRequirementIfAreEqual(
Smb2Status.STATUS_FILE_LOCK_CONFLICT,
status,
RequirementCategory.STATUS_FILE_LOCK_CONFLICT.Id,
RequirementCategory.STATUS_FILE_LOCK_CONFLICT.Description);
}
else
{
BaseTestSite.Assert.AreEqual(
Smb2Status.STATUS_SUCCESS,
status,
"Write content in file should succeed, actual status is {0}", Smb2Status.GetStatusCode(status));
}
}
private bool CheckIfOpenClosed(ModelDialectRevision dialect, CreateType createType)
{
if (createType == CreateType.ReconnectDurable)
{
/// prepareClient is disconnected, so
/// Reconnect to the share and try to get the open, if the durable open can be reconnected, then it's not closed.
Smb2FunctionalClient reconnectClient = new Smb2FunctionalClient(testConfig.Timeout, testConfig, this.Site);
uint treeId;
ConnectToShare(
dialect,
reconnectClient,
this.connection_ClientGuid,
testConfig.BasicFileShare,
out treeId);
FILEID fileId;
Smb2CreateContextResponse[] createContextResponse;
uint status = reconnectClient.Create(
treeId,
this.fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId,
out createContextResponse,
createContexts: CreateContexts(AppInstanceIdType.NoAppInstanceId, createType, false),
shareAccess:ShareAccess_Values.NONE,
checker: (header, response) => {});
Site.Log.Add(LogEntryKind.Debug, "CheckIfOpenClosed: status of reconnectClient.Create is " + Smb2Status.GetStatusCode(status));
reconnectClient.Close(treeId, fileId, (header, response) => { });
reconnectClient.Disconnect();
return !(status == Smb2Status.STATUS_SUCCESS);
}
else
{
/// Write (using the FileID got from the create response of PrepareOpen) to check if the Open is closed.
uint status = prepareClient.Write(this.treeConnect_TreeId, this.open_FileId, "AppInstanceId", checker: (header, response) => { });
Site.Log.Add(LogEntryKind.Debug, "CheckIfOpenClosed: status of Write is " + Smb2Status.GetStatusCode(status));
prepareClient.Close(this.treeConnect_TreeId, this.open_FileId, (header, response) => { });
return status == Smb2Status.STATUS_FILE_CLOSED;
}
}
public void DurableHandleV1_Reconnect_AfterServerDisconnect()
{
/// 1. Client requests a durable handle with LeaseV1 context
/// 2. Client sends Negotiate request after the Create operation to trigger server terminates the connection
/// 3. Client reconnects the durable handle with LeaseV1 context, and expects success.
#region Check Applicability
TestConfig.CheckDialect(DialectRevision.Smb21);
TestConfig.CheckCapabilities(NEGOTIATE_Response_Capabilities_Values.GLOBAL_CAP_LEASING);
TestConfig.CheckCreateContext(CreateContextTypeValue.SMB2_CREATE_DURABLE_HANDLE_REQUEST, CreateContextTypeValue.SMB2_CREATE_DURABLE_HANDLE_RECONNECT, CreateContextTypeValue.SMB2_CREATE_REQUEST_LEASE);
#endregion
string content = Smb2Utility.CreateRandomString(testConfig.WriteBufferLengthInKb);
durableHandleUncSharePath = Smb2Utility.GetUncPath(testConfig.SutComputerName, testConfig.BasicFileShare);
string fileName = GetTestFileName(durableHandleUncSharePath);
#region client connect to server
BaseTestSite.Log.Add(
LogEntryKind.Comment,
"Client connects to server and opens file with a durable handle");
uint treeIdBeforeDisconnection;
Connect(DialectRevision.Smb21, clientBeforeDisconnection, clientGuid, testConfig.AccountCredential, ConnectShareType.BasicShareWithoutAssert, out treeIdBeforeDisconnection, null);
Guid leaseKey = Guid.NewGuid();
LeaseStateValues leaseState = LeaseStateValues.SMB2_LEASE_READ_CACHING | LeaseStateValues.SMB2_LEASE_HANDLE_CACHING | LeaseStateValues.SMB2_LEASE_WRITE_CACHING;
FILEID fileIdBeforeDisconnection;
Smb2CreateContextResponse[] serverCreateContexts = null;
clientBeforeDisconnection.Create(
treeIdBeforeDisconnection,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileIdBeforeDisconnection,
out serverCreateContexts,
RequestedOplockLevel_Values.OPLOCK_LEVEL_LEASE,
new Smb2CreateContextRequest[] {
new Smb2CreateDurableHandleRequest
{
DurableRequest = Guid.Empty,
},
new Smb2CreateRequestLease
{
LeaseKey = leaseKey,
LeaseState = leaseState,
}
},
shareAccess: ShareAccess_Values.NONE,
checker: (header, response) =>
{
BaseTestSite.Assert.AreEqual(
Smb2Status.STATUS_SUCCESS,
header.Status,
"{0} should be successful, actually server returns {1}.", header.Command, Smb2Status.GetStatusCode(header.Status));
CheckCreateContextResponses(serverCreateContexts, new DefaultDurableHandleResponseChecker(BaseTestSite));
});
clientBeforeDisconnection.Write(treeIdBeforeDisconnection, fileIdBeforeDisconnection, content);
#endregion
/// Send negotiate after create to make server disconnect the connection
TriggerServerTerminateConnection();
#region client reconnect to server
BaseTestSite.Log.Add(
LogEntryKind.Comment,
"Client opens the same file and reconnects the durable handle");
uint treeIdAfterDisconnection;
Connect(DialectRevision.Smb21, clientAfterDisconnection, clientGuid, testConfig.AccountCredential, ConnectShareType.BasicShareWithoutAssert, out treeIdAfterDisconnection, clientBeforeDisconnection);
FILEID fileIdAfterDisconnection;
clientAfterDisconnection.Create(
treeIdAfterDisconnection,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileIdAfterDisconnection,
out serverCreateContexts,
RequestedOplockLevel_Values.OPLOCK_LEVEL_LEASE,
new Smb2CreateContextRequest[] {
new Smb2CreateDurableHandleReconnect
{
Data = new FILEID {
Persistent = fileIdBeforeDisconnection.Persistent
}
},
new Smb2CreateRequestLease
{
LeaseKey = leaseKey,
LeaseState = leaseState,
}
},
shareAccess: ShareAccess_Values.NONE);
string readContent;
clientAfterDisconnection.Read(treeIdAfterDisconnection, fileIdAfterDisconnection, 0, (uint)content.Length, out readContent);
BaseTestSite.Assert.IsTrue(
content.Equals(readContent),
"The written content is expected to be equal to read content.");
clientAfterDisconnection.Close(treeIdAfterDisconnection, fileIdAfterDisconnection);
clientAfterDisconnection.TreeDisconnect(treeIdAfterDisconnection);
clientAfterDisconnection.LogOff();
clientAfterDisconnection.Disconnect();
#endregion
}
public void OpenRequest(
ClientGuidType clientGuidType,
PathNameType pathNameType,
CreateType createType,
ShareType shareType,
AppInstanceIdType appInstanceIdType)
{
Smb2FunctionalClient testClient = new Smb2FunctionalClient(testConfig.Timeout, testConfig, this.Site);
uint treeId;
string share;
switch (shareType)
{
case ShareType.SameShare:
share = testConfig.BasicFileShare;
break;
case ShareType.DifferentShareSameLocal:
share = testConfig.SameWithSMBBasic;
break;
case ShareType.DifferentShareDifferentLocal:
share = testConfig.DifferentFromSMBBasic;
cleanFileInDifferentShare = true;
break;
default:
throw new ArgumentException("shareType");
}
ConnectToShare(
clientDialect,
testClient,
clientGuidType == ClientGuidType.SameClientGuid ? this.connection_ClientGuid : Guid.NewGuid(),
share,
out treeId);
FILEID fileId;
Smb2CreateContextResponse[] createContextResponse;
uint status;
string fileNameInOpen;
if (pathNameType == PathNameType.SamePathName)
{
fileNameInOpen = fileName;
}
else
{
fileNameInOpen = fileName + different;
cleanFileWithDifferentName = true;
}
status = testClient.Create(
treeId,
fileNameInOpen,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId,
out createContextResponse,
createContexts: CreateContexts(appInstanceIdType, createType, false),
shareAccess: ShareAccess_Values.NONE,
checker: (header, response) => { });
// The file is not created, no need to delete.
if (status != Smb2Status.STATUS_SUCCESS)
{
cleanFileInDifferentShare = false;
cleanFileWithDifferentName = false;
}
testClient.Disconnect();
testClient = null;
// Check if the Open is closed.
// If status is success, and fileId is the same with the previous one, then the Open is not closed.
// Otherwise, use some other way to check if the Open is closed.
bool ifClosed;
if (status == Smb2Status.STATUS_SUCCESS && fileId.Persistent == this.open_FileId.Persistent)
ifClosed = false;
else
ifClosed = CheckIfOpenClosed(clientDialect, createType);
this.OpenResponse(ifClosed ? OpenStatus.OpenClosed : OpenStatus.OpenNotClosed);
}
/// <summary>
/// Do operation to the file from the first client
/// </summary>
private void RequestFromFirstClient(RequestType requestFromFirstClient)
{
Smb2CreateContextResponse[] contexts;
switch (requestFromFirstClient)
{
case RequestType.ExclusiveLock:
firstClient.Create(
treeId1,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId1,
out contexts,
RequestedOplockLevel_Values.OPLOCK_LEVEL_NONE);
firstClient.Lock(
treeId1,
0,
fileId1,
new LOCK_ELEMENT[]
{
new LOCK_ELEMENT
{
Offset = 0,
Length = DEFAULT_WRITE_BUFFER_SIZE_IN_KB * 1024,
Flags = LOCK_ELEMENT_Flags_Values.LOCKFLAG_EXCLUSIVE_LOCK | LOCK_ELEMENT_Flags_Values.LOCKFLAG_FAIL_IMMEDIATELY
}
});
break;
case RequestType.Lease:
if (!testConfig.IsLeasingSupported)
{
// skip this case if leasing is not supported
Site.Assert.Inconclusive("This test case is applicable only when leasing is supported.");
}
firstClient.Create(
treeId1,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId1,
out contexts,
RequestedOplockLevel_Values.OPLOCK_LEVEL_LEASE,
new Smb2CreateContextRequest[]
{
new Smb2CreateRequestLease
{
LeaseKey = Guid.NewGuid(),
// [MS-SMB2] 3.3.5.9.8
// If Connection.Dialect belongs to the SMB 3.x dialect family, TreeConnect.Share.Type includes STYPE_CLUSTER_SOFS,
// and if LeaseState includes SMB2_LEASE_READ_CACHING, the server MUST set LeaseState to SMB2_LEASE_READ_CACHING,
// otherwise set LeaseState to SMB2_LEASE_NONE.
// The share.type includes STYPE_CLUSTER_SOFS, so only READ_CACHING could be granted even the client applied for other lease.
// So the client only applies READ_CACHING here.
LeaseState = LeaseStateValues.SMB2_LEASE_READ_CACHING
}
});
break;
case RequestType.UncommitedDelete:
case RequestType.Delete:
firstClient.Create(
treeId1,
fileName,
CreateOptions_Values.FILE_DELETE_ON_CLOSE | CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId1,
out contexts,
RequestedOplockLevel_Values.OPLOCK_LEVEL_NONE);
// Close to delete the file
firstClient.Close(treeId1, fileId1);
break;
case RequestType.Write:
firstClient.Create(
treeId1,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId1,
out contexts,
RequestedOplockLevel_Values.OPLOCK_LEVEL_NONE);
firstClient.Write(treeId1, fileId1, Smb2Utility.CreateRandomString(DEFAULT_WRITE_BUFFER_SIZE_IN_KB));
break;
case RequestType.Read:
firstClient.Create(
treeId1,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId1,
out contexts,
RequestedOplockLevel_Values.OPLOCK_LEVEL_NONE);
byte[] data;
firstClient.Read(treeId1, fileId1, 0, (uint)DEFAULT_WRITE_BUFFER_SIZE_IN_KB * 1024, out data);
break;
default:
break;
}
}
public void ReconnectSharedVHDWithoutDeviceContext()
{
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"1. Client opens a shared virtual disk file with SMB2 create contexts " +
"SVHDX_OPEN_DEVICE_CONTEXT and SMB2_CREATE_DURABLE_HANDLE_REQUEST_V2 (persistent bit is set). ");
clientBeforeDisconnect = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
Guid clientGuid = Guid.NewGuid();
ConnectToShare(clientBeforeDisconnect, clientGuid, TestConfig.FullPathShareContainingSharedVHD, out treeIdBeforeDisconnect);
Guid createGuid = Guid.NewGuid();
Guid initiatorId = Guid.NewGuid();
Smb2CreateContextResponse[] serverCreateContexts;
clientBeforeDisconnect.Create
(treeIdBeforeDisconnect,
TestConfig.NameOfSharedVHDX + fileNameSuffix,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileIdBeforeDisconnect,
out serverCreateContexts,
RequestedOplockLevel_Values.OPLOCK_LEVEL_NONE,
new Smb2CreateContextRequest[]
{
new Smb2CreateSvhdxOpenDeviceContext
{
Version = (uint)RSVD_PROTOCOL_VERSION.RSVD_PROTOCOL_VERSION_1,
OriginatorFlags = (uint)OriginatorFlag.SVHDX_ORIGINATOR_PVHDPARSER,
InitiatorHostName = TestConfig.InitiatorHostName,
InitiatorHostNameLength = (ushort)(TestConfig.InitiatorHostName.Length * 2), // InitiatorHostName is a null-terminated Unicode UTF-16 string
InitiatorId = initiatorId
},
new Smb2CreateDurableHandleRequestV2
{
CreateGuid = createGuid,
Flags = CREATE_DURABLE_HANDLE_REQUEST_V2_Flags.DHANDLE_FLAG_PERSISTENT
}
});
bool persistentHandleReturned = false;
if (serverCreateContexts != null && serverCreateContexts[0] is Smb2CreateDurableHandleResponseV2)
{
var durableResponse = serverCreateContexts[0] as Smb2CreateDurableHandleResponseV2;
if (durableResponse.Flags.HasFlag(CREATE_DURABLE_HANDLE_RESPONSE_V2_Flags.DHANDLE_FLAG_PERSISTENT))
{
persistentHandleReturned = true;
}
}
BaseTestSite.Assert.IsTrue(persistentHandleReturned, "Server should return a persistent handle.");
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"2. Client disconnects from the server.");
clientBeforeDisconnect.Disconnect();
clientAfterDisconnect = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
ConnectToShare(clientAfterDisconnect, clientGuid, TestConfig.FullPathShareContainingSharedVHD, out treeIdAfterDisconnect);
uint status = clientAfterDisconnect.Create
(treeIdAfterDisconnect,
TestConfig.NameOfSharedVHDX + fileNameSuffix,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileIdAfterDisconnect,
out serverCreateContexts,
RequestedOplockLevel_Values.OPLOCK_LEVEL_NONE,
new Smb2CreateContextRequest[]
{
new Smb2CreateDurableHandleReconnectV2
{
CreateGuid = createGuid,
Flags = CREATE_DURABLE_HANDLE_RECONNECT_V2_Flags.DHANDLE_FLAG_PERSISTENT,
FileId = new FILEID {
Persistent = fileIdBeforeDisconnect.Persistent
}
}
},
checker: (header, response) => { });
BaseTestSite.Assert.AreEqual(
(uint)Smb2Status.STATUS_SUCCESS,
status,
"3. Client reconnects the persistent handle without create context SVHDX_OPEN_DEVICE_CONTEXT and expects success. Actual status is: {0}",
GetStatus(status));
}
private void OpenFile(
Smb2FunctionalClient client,
Guid clientGuid,
string fileName,
bool isPersistentHandle,
out Guid createGuid,
out uint treeId,
out FILEID fileId)
{
// 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
Smb2CreateContextResponse[] createContextResponses;
client.Create(
treeId,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId,
out createContextResponses,
createContexts: createContextList.ToArray<Smb2CreateContextRequest>()
);
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Create Open with file name '{0}'", fileName);
#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 OpenRequest(
ClientGuidType clientGuidType,
PathNameType pathNameType,
CreateType createType,
ShareType shareType,
AppInstanceIdType appInstanceIdType)
{
Smb2FunctionalClient testClient = new Smb2FunctionalClient(testConfig.Timeout, testConfig, this.Site);
uint treeId;
string share;
switch (shareType)
{
case ShareType.SameShare:
share = testConfig.BasicFileShare;
break;
case ShareType.DifferentShareSameLocal:
share = testConfig.SameWithSMBBasic;
break;
case ShareType.DifferentShareDifferentLocal:
share = testConfig.DifferentFromSMBBasic;
cleanFileInDifferentShare = true;
break;
default:
throw new ArgumentException("shareType");
}
ConnectToShare(
clientDialect,
testClient,
clientGuidType == ClientGuidType.SameClientGuid ? this.connection_ClientGuid : Guid.NewGuid(),
share,
out treeId);
FILEID fileId;
Smb2CreateContextResponse[] createContextResponse;
uint status;
string fileNameInOpen;
if (pathNameType == PathNameType.SamePathName)
{
fileNameInOpen = fileName;
}
else
{
fileNameInOpen = fileName + different;
cleanFileWithDifferentName = true;
}
status = testClient.Create(
treeId,
fileNameInOpen,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId,
out createContextResponse,
createContexts: CreateContexts(appInstanceIdType, createType, false),
shareAccess: ShareAccess_Values.NONE,
checker: (header, response) => { });
// The file is not created, no need to delete.
if (status != Smb2Status.STATUS_SUCCESS)
{
cleanFileInDifferentShare = false;
cleanFileWithDifferentName = false;
}
testClient.Disconnect();
testClient = null;
// Check if the Open is closed.
// If status is success, and fileId is the same with the previous one, then the Open is not closed.
// Otherwise, use some other way to check if the Open is closed.
bool ifClosed;
if (status == Smb2Status.STATUS_SUCCESS && fileId.Persistent == this.open_FileId.Persistent)
{
ifClosed = false;
}
else
{
ifClosed = CheckIfOpenClosed(clientDialect, createType);
}
this.OpenResponse(ifClosed ? OpenStatus.OpenClosed : OpenStatus.OpenNotClosed);
}
protected void DeleteExistingFile(string sharePath, string fileName)
{
Smb2FunctionalClient clientAdmin;
clientAdmin = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
clientAdmin.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress);
uint treeId;
ConnectToShare(clientAdmin, TestConfig.AccountCredential, sharePath, out treeId);
FILEID fileId;
Smb2CreateContextResponse[] createContextResponses;
clientAdmin.Create(
treeId,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE | CreateOptions_Values.FILE_DELETE_ON_CLOSE,
out fileId,
out createContextResponses,
accessMask: AccessMask.FILE_READ_ATTRIBUTES | AccessMask.DELETE,
shareAccess: ShareAccess_Values.FILE_SHARE_DELETE,
createDisposition: CreateDisposition_Values.FILE_OPEN);
clientAdmin.Close(treeId, fileId);
clientAdmin.TreeDisconnect(treeId);
clientAdmin.Disconnect();
}
public void BVT_OpLockBreak()
{
#region Add Event Handler
client1.Smb2Client.OplockBreakNotificationReceived += new Action <Packet_Header, OPLOCK_BREAK_Notification_Packet>(OnOpLockBreakNotificationReceived);
#endregion
#region Client1 Open a File with BatchOpLock
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Start the first client by sending the following requests: NEGOTIATE; SESSION_SETUP; TREE_CONNECT.");
client1.Negotiate(TestConfig.RequestDialects, TestConfig.IsSMB1NegotiateEnabled);
client1.SessionSetup(TestConfig.DefaultSecurityPackage, TestConfig.SutComputerName, TestConfig.AccountCredential, false);
client1.TreeConnect(sharePath, out treeId);
Smb2CreateContextResponse[] createContextResponse;
BaseTestSite.Log.Add(LogEntryKind.TestStep, "The first client sends CREATE request with BatchOplock.");
client1.Create(treeId, fileName, CreateOptions_Values.FILE_NON_DIRECTORY_FILE, out fileId, out createContextResponse, RequestedOplockLevel_Values.OPLOCK_LEVEL_BATCH,
checker: (header, response) =>
{
BaseTestSite.Assert.AreEqual(
Smb2Status.STATUS_SUCCESS,
header.Status,
"{0} should be successful, actually server returns {1}.", header.Command, Smb2Status.GetStatusCode(header.Status));
if (response.OplockLevel == OplockLevel_Values.OPLOCK_LEVEL_NONE)
{
BaseTestSite.Assert.Inconclusive("OpLock request not succeeded.");
}
});
#endregion
#region Oplock Break
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Start the second client by sending the following requests: NEGOTIATE; SESSION_SETUP; TREE_CONNECT.");
client2.Negotiate(TestConfig.RequestDialects, TestConfig.IsSMB1NegotiateEnabled);
client2.SessionSetup(TestConfig.DefaultSecurityPackage, TestConfig.SutComputerName, TestConfig.AccountCredential, false);
uint client2TreeId;
client2.TreeConnect(sharePath, out client2TreeId);
FILEID client2FileId;
ulong createRequestId;
BaseTestSite.Log.Add(LogEntryKind.TestStep, "The second client sends CREATE request on the same file with the first client.");
client2.CreateRequest(client2TreeId, fileName, CreateOptions_Values.FILE_NON_DIRECTORY_FILE, out createRequestId);
BaseTestSite.Assert.IsTrue(OpLockNotificationReceived.WaitOne(TestConfig.WaitTimeoutInMilliseconds),
"The expected OPLOCK_BREAK_NOTIFY should be received within {0} milliseconds", TestConfig.WaitTimeoutInMilliseconds);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "The first client sends OPLOCK_ACKNOWLEDGEMENT request after received OPLOCK_BREAK_NOTIFICATION response from server.");
OplockBreakAcknowledgment(client1);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "The second client sends CREATE response");
client2.CreateResponse(createRequestId, out client2FileId, out createContextResponse);
#endregion
#region Tear Down Clients
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Tear down the first client by sending CLOSE, TREE_DISCONNECT, and LOG_OFF.");
client1.Close(treeId, fileId);
client1.TreeDisconnect(treeId);
client1.LogOff();
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Tear down the second client by sending CLOSE, TREE_DISCONNECT, and LOG_OFF.");
client2.Close(client2TreeId, client2FileId);
client2.TreeDisconnect(client2TreeId);
client2.LogOff();
#endregion
}
protected bool AccessShare(AccountCredential user, string sharePath)
{
bool accessSucceed = true;
Smb2FunctionalClient client = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
client.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress);
try
{
BaseTestSite.Log.Add(LogEntryKind.Debug, "Client sends NEGOTIATE message.");
client.Negotiate(TestConfig.RequestDialects, TestConfig.IsSMB1NegotiateEnabled);
BaseTestSite.Log.Add(LogEntryKind.Debug, "Client sends SESSION_SETUP message using account: {0}@{1}.", user.AccountName, user.DomainName);
client.SessionSetup(TestConfig.DefaultSecurityPackage, TestConfig.SutComputerName, user, false);
uint treeId;
BaseTestSite.Log.Add(LogEntryKind.Debug, "Client sends TREE_CONNECT message to access share: {0}.", sharePath);
client.TreeConnect(sharePath, out treeId, checker: (header, response) =>
{
if (header.Status == Smb2Status.STATUS_SUCCESS)
{
BaseTestSite.Log.Add(LogEntryKind.Debug, "Access succeeded in TREE_CONNECT phase.");
accessSucceed = true;
}
else if (header.Status == Smb2Status.STATUS_ACCESS_DENIED)
{
BaseTestSite.Log.Add(LogEntryKind.Debug, "Access denied in TREE_CONNECT phase.");
accessSucceed = false;
}
else
{
BaseTestSite.Assert.Fail("Unexpected error code in TREE_CONNECT response: {0}", Smb2Status.GetStatusCode(header.Status));
}
});
if (!accessSucceed)
{
client.LogOff();
return false;
}
FILEID fileId;
Smb2CreateContextResponse[] createContexResponse;
BaseTestSite.Log.Add(LogEntryKind.Debug, "Client sends CREATE request.");
uint status = client.Create(
treeId,
null,
CreateOptions_Values.FILE_DIRECTORY_FILE,
out fileId,
out createContexResponse,
accessMask: AccessMask.FILE_READ_DATA | AccessMask.FILE_READ_ATTRIBUTES,
createDisposition: CreateDisposition_Values.FILE_OPEN,
checker: (header, response) =>
{
if (header.Status == Smb2Status.STATUS_SUCCESS)
{
BaseTestSite.Log.Add(LogEntryKind.Debug, "Access succeeded in CREATE phase.");
accessSucceed = true;
}
else if (header.Status == Smb2Status.STATUS_ACCESS_DENIED)
{
BaseTestSite.Log.Add(LogEntryKind.Debug, "Access denied in CREATE phase.");
accessSucceed = false;
}
else
{
BaseTestSite.Assert.Fail("Unexpected error code in CREATE response: {0}", Smb2Status.GetStatusCode(header.Status));
}
});
if (status == Smb2Status.STATUS_SUCCESS)
{
BaseTestSite.Log.Add(LogEntryKind.Debug, "Tear down the client by sending the following requests: CLOSE; TREE_DISCONNECT; LOG_OFF.");
client.Close(treeId, fileId);
}
client.TreeDisconnect(treeId);
client.LogOff();
}
finally
{
client.Disconnect();
}
return accessSucceed;
}
// [MS-SMB2] 3.3.5.9 Receiving an SMB2 CREATE Request
// If the request received has SMB2_FLAGS_DFS_OPERATIONS set in the Flags field of the SMB2 header, and TreeConnect.Share.IsDfs is TRUE, the server MUST verify the value of IsDfsCapable:
// If IsDfsCapable is TRUE, the server MUST invoke the interface defined in [MS-DFSC] section 3.2.4.1 to normalize the path name by supplying the target path name.
// [MS-DFSC] 3.2.4.1 Handling a Path Normalization Request
// As specified in [MS-SMB2] section 3.3.5.9 and [MS-SMB] section 3.3.5.5, the SMB server invokes the DFS server to normalize the path name.
// When DFS server matches the path name against DFS metadata:
// If the path matches or contains a DFS link, the DFS server MUST respond to the path normalization request with STATUS_PATH_NOT_COVERED,
// indicating to the client to resolve the path by using a DFS link referral request.
// Otherwise, the DFS server MUST change the path name to a path relative to the root of the namespace and return STATUS_SUCCESS.
private void PathNormalize(bool containDFSLink)
{
smb2client = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
smb2client.ConnectToServerOverTCP(TestConfig.SutIPAddress);
smb2client.Negotiate(TestConfig.RequestDialects, TestConfig.IsSMB1NegotiateEnabled);
smb2client.SessionSetup(TestConfig.DefaultSecurityPackage,
TestConfig.SutComputerName,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken);
string dfsRootShare = Smb2Utility.GetUncPath(TestConfig.SutComputerName, TestConfig.StandaloneNamespace);
smb2client.TreeConnect(dfsRootShare, out treeId);
Smb2CreateContextResponse[] contextResp;
// [MS-SMB2] 2.2.13 SMB2 CREATE Request
// If SMB2_FLAGS_DFS_OPERATIONS is set in the Flags field of the SMB2 header,
// the file name can be prefixed with DFS link information that will be removed during DFS name normalization as specified in section 3.3.5.9.
string filaName = dfsRootShare + @"\";
filaName += containDFSLink ? (TestConfig.DFSLink + @"\") : "";
filaName += "PathNormalization_" + Guid.NewGuid();
if (containDFSLink)
{
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client sends SMB2 create request to open a file in a DFS path contains DFS Link.");
}
else
{
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client sends SMB2 create request to open a file in a DFS path does not contain DFS Link.");
}
uint status = smb2client.Create(
treeId,
filaName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
Packet_Header_Flags_Values.FLAGS_DFS_OPERATIONS | Packet_Header_Flags_Values.FLAGS_SIGNED,
out fileId,
out contextResp,
checker: (header, response) =>
{
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Verify server response.");
if (containDFSLink)
{
BaseTestSite.Assert.AreEqual(
(uint)NtStatus.STATUS_PATH_NOT_COVERED,
header.Status,
"DFS server matches the path name against DFS metadata. If the path matches or contains a DFS link, " +
"the DFS server MUST respond to the path normalization request with STATUS_PATH_NOT_COVERED, indicating to the client to resolve the path by using a DFS link referral request");
}
else
{
BaseTestSite.Assert.AreEqual(
Smb2Status.STATUS_SUCCESS,
header.Status,
"The DFS server MUST change the path name to a path relative to the root of the namespace and return STATUS_SUCCESS, actual status is {0}", Smb2Status.GetStatusCode(header.Status));
}
});
}
public void BVT_SMB2Basic_LockAndUnLock()
{
uint status;
string content = Smb2Utility.CreateRandomString(TestConfig.WriteBufferLengthInKb);
#region From client1 lock a byte range and try to write content to the file within the range
BaseTestSite.Log.Add(
LogEntryKind.Comment,
"From client1 locks a byte range and try to write content to the file within the range.");
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"Start client1 to create a file with sending the following requests: NEGOTIATE; SESSION_SETUP; TREE_CONNECT; CREATE.");
client1 = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
client1.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress);
status = client1.Negotiate(TestConfig.RequestDialects, TestConfig.IsSMB1NegotiateEnabled);
status = client1.SessionSetup(
TestConfig.DefaultSecurityPackage,
TestConfig.SutComputerName,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken);
uint treeId1;
status = client1.TreeConnect(uncSharePath, out treeId1);
Smb2CreateContextResponse[] serverCreateContexts;
FILEID fileId1;
string fileName = Guid.NewGuid().ToString() + ".txt";
status = client1.Create(
treeId1,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId1,
out serverCreateContexts);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client1 writes content to the file created.");
status = client1.Write(treeId1, fileId1, content);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Tear down client1 by sending CLOSE request.");
client1.Close(treeId1, fileId1);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client1 sends CREATE request.");
status = client1.Create(
treeId1,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId1,
out serverCreateContexts);
//Construct LOCK_ELEMENT
LOCK_ELEMENT[] locks = new LOCK_ELEMENT[1];
uint lockSequence = 0;
locks[0].Offset = 0;
locks[0].Length = (ulong)TestConfig.WriteBufferLengthInKb * 1024;
locks[0].Flags = LOCK_ELEMENT_Flags_Values.LOCKFLAG_SHARED_LOCK;
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"Client1 starts to lock a byte range for file \"{0}\" with parameters offset:{1}, length:{2}, flags: {3})",
fileName, locks[0].Offset, locks[0].Length, locks[0].Flags.ToString());
status = client1.Lock(treeId1, lockSequence++, fileId1, locks);
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"Client1 sends WRITE request to write content to the locking range");
status = client1.Write(
treeId1,
fileId1,
content,
checker: (header, response) =>
{
BaseTestSite.Assert.AreNotEqual(
Smb2Status.STATUS_SUCCESS,
header.Status,
"All opens MUST NOT be allowed to write within the range when SMB2_LOCKFLAG_SHARED_LOCK set, actually server returns {0}.", Smb2Status.GetStatusCode(header.Status));
BaseTestSite.CaptureRequirementIfAreEqual(
Smb2Status.STATUS_FILE_LOCK_CONFLICT,
header.Status,
RequirementCategory.STATUS_FILE_LOCK_CONFLICT.Id,
RequirementCategory.STATUS_FILE_LOCK_CONFLICT.Description);
});
#endregion
#region From client2 to read and write the locking range of the same file after lock
BaseTestSite.Log.Add(
LogEntryKind.Comment,
"From client2 to read and take shared lock on the locking range of the same file after lock");
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"Start client2 to create a file with sending the following requests: NEGOTIATE; SESSION_SETUP; TREE_CONNECT; CREATE.");
client2 = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
client2.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress);
status = client2.Negotiate(TestConfig.RequestDialects, TestConfig.IsSMB1NegotiateEnabled);
status = client2.SessionSetup(
TestConfig.DefaultSecurityPackage,
TestConfig.SutComputerName,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken);
uint treeId2;
status = client2.TreeConnect(uncSharePath, out treeId2);
FILEID fileId2;
status = client2.Create(
treeId2,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId2,
out serverCreateContexts);
string data;
Random random = new Random();
uint offset = (uint)random.Next(0, TestConfig.WriteBufferLengthInKb * 1024 - 1);
uint length = (uint)random.Next(0, (int)(TestConfig.WriteBufferLengthInKb * 1024 - offset));
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"Client2 sends READ request to read a random area in the locking range of file \"{0}\" with offset: {1}, length: {2}",
fileName, offset, length);
status = client2.Read(treeId2, fileId2, offset, length, out data);
//Construct LOCK_ELEMENT
LOCK_ELEMENT[] locksFromOtherOpen = new LOCK_ELEMENT[1];
locksFromOtherOpen[0].Offset = offset;
locksFromOtherOpen[0].Length = (ulong)length;
locksFromOtherOpen[0].Flags = LOCK_ELEMENT_Flags_Values.LOCKFLAG_SHARED_LOCK;
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"Client2 attempts to take a shared lock on random range of file \"{0}\" with parameters offset:{1}, length:{2}, flags: {3})",
fileName, locksFromOtherOpen[0].Offset, locksFromOtherOpen[0].Length, locksFromOtherOpen[0].Flags.ToString());
status = client2.Lock(treeId2, lockSequence++, fileId2, locksFromOtherOpen);
locksFromOtherOpen[0].Flags = LOCK_ELEMENT_Flags_Values.LOCKFLAG_UNLOCK;
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"Client2 attempts to unlock the range");
status = client2.Lock(treeId2, lockSequence++, fileId2, locksFromOtherOpen);
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"Client2 sends WRITE request to write a random area in the locking range of file \"{0}\" after lock", fileName);
status = client2.Write(
treeId2,
fileId2,
content,
offset,
checker: (header, response) =>
{
BaseTestSite.Assert.AreNotEqual(
Smb2Status.STATUS_SUCCESS,
header.Status,
"All opens MUST NOT be allowed to write within the range when SMB2_LOCKFLAG_SHARED_LOCK set, actually server returns {0}.", Smb2Status.GetStatusCode(header.Status));
BaseTestSite.CaptureRequirementIfAreEqual(
Smb2Status.STATUS_FILE_LOCK_CONFLICT,
header.Status,
RequirementCategory.STATUS_FILE_LOCK_CONFLICT.Id,
RequirementCategory.STATUS_FILE_LOCK_CONFLICT.Description);
});
#endregion
#region From client1 unlock the range
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"Client1 unlocks the range");
locks[0].Flags = LOCK_ELEMENT_Flags_Values.LOCKFLAG_UNLOCK;
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Client1 attempts to unlock the range");
status = client1.Lock(treeId1, lockSequence++, fileId1, locks);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Tear down client1 by sending the following requests: CLOSE; TREE_DISCONNECT; LOG_OFF");
client1.Close(treeId1, fileId1);
client1.TreeDisconnect(treeId1);
client1.LogOff();
#endregion
#region From client2 write content to the previous locking range after unlock
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"Client2 sends WRITE request to write content to the previous locking range after unlock");
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Client2 attempts to write a random area in the locking range of file \"{0}\" after unlock", fileName);
status = client2.Write(treeId2, fileId2, content, offset);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Tear down client2 by sending the following requests: CLOSE; TREE_DISCONNECT; LOG_OFF");
client2.Close(treeId2, fileId2);
client2.TreeDisconnect(treeId2);
client2.LogOff();
#endregion
}
public void TestFileLeasing(Smb2CreateContextRequest leaseContext)
{
#region Add Event Handler
client1.Smb2Client.LeaseBreakNotificationReceived += new Action <Packet_Header, LEASE_BREAK_Notification_Packet>(base.OnLeaseBreakNotificationReceived);
clientToAckLeaseBreak = client1;
#endregion
#region Client1 Open a File with Lease RWH
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 context: {0})",
leaseContext is Smb2CreateRequestLease ? "LeaseV1" : "LeaseV2");
client1.Negotiate(TestConfig.RequestDialects, TestConfig.IsSMB1NegotiateEnabled);
client1.SessionSetup(TestConfig.DefaultSecurityPackage, TestConfig.SutComputerName, TestConfig.AccountCredential, false);
uint client1TreeId;
client1.TreeConnect(sharePath, out client1TreeId);
FILEID client1FileId;
Smb2CreateContextResponse[] createContextResponse;
client1.Create(client1TreeId, fileName, CreateOptions_Values.FILE_NON_DIRECTORY_FILE, out client1FileId, out createContextResponse, RequestedOplockLevel_Values.OPLOCK_LEVEL_LEASE,
new Smb2CreateContextRequest[]
{
leaseContext
}
);
#endregion
#region Check Response Contexts
if (leaseContext is Smb2CreateRequestLease)
{
Smb2CreateRequestLease leaseRequest = leaseContext as Smb2CreateRequestLease;
CheckCreateContextResponses(createContextResponse, new DefaultLeaseResponseChecker(BaseTestSite, leaseRequest.LeaseKey, leaseRequest.LeaseState, LeaseFlagsValues.NONE));
}
else if (leaseContext is Smb2CreateRequestLeaseV2)
{
Smb2CreateRequestLeaseV2 leaseRequest = leaseContext as Smb2CreateRequestLeaseV2;
CheckCreateContextResponses(createContextResponse, new DefaultLeaseV2ResponseChecker(BaseTestSite, leaseRequest.LeaseKey, leaseRequest.LeaseState, LeaseFlagsValues.NONE));
}
#endregion
// Create a task to invoke CheckBreakNotification
var checkBreakNotificationTask = Task.Run(() => CheckBreakNotification(client1TreeId));
#region Lease Break RWH => RH
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");
expectedNewLeaseState = LeaseStateValues.SMB2_LEASE_READ_CACHING | LeaseStateValues.SMB2_LEASE_HANDLE_CACHING;
client2.Negotiate(TestConfig.RequestDialects, TestConfig.IsSMB1NegotiateEnabled);
client2.SessionSetup(TestConfig.DefaultSecurityPackage, TestConfig.SutComputerName, TestConfig.AccountCredential, false);
uint client2TreeId;
client2.TreeConnect(sharePath, out client2TreeId);
FILEID client2FileId;
client2.Create(client2TreeId, fileName, CreateOptions_Values.FILE_NON_DIRECTORY_FILE, out client2FileId, out createContextResponse);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "The first client sends LEASE_BREAK_ACKNOWLEDGEMENT request to break lease state to RH after receiving LEASE_BREAK_NOTIFICATION response from server.");
#endregion
#region Lease BreakRH => NONE
BaseTestSite.Log.Add(LogEntryKind.TestStep, "The second client sends WRITE request.");
expectedNewLeaseState = LeaseStateValues.SMB2_LEASE_NONE;
byte[] data = { 0 };
client2.Write(client2TreeId, client2FileId, data);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "The first client sends LEASE_BREAK_ACKNOWLEDGEMENT request to break lease state to NONE after receiving LEASE_BREAK_NOTIFICATION response from server.");
#endregion
#region Tear Down Clients
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Tear down the first client by sending the following requests: 1. CLOSE; 2. TREE_DISCONNECT; 3. LOG_OFF");
client1.Close(client1TreeId, client1FileId);
client1.TreeDisconnect(client1TreeId);
client1.LogOff();
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Tear down the second client by sending the following requests: 1. CLOSE; 2. TREE_DISCONNECT; 3. LOG_OFF");
client2.Close(client2TreeId, client2FileId);
client2.TreeDisconnect(client2TreeId);
client2.LogOff();
#endregion
checkBreakNotificationTask.Wait(TestConfig.WaitTimeoutInMilliseconds);
}
public void InvalidCreateRequestStructureSize()
{
uint status;
client1 = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, this.Site);
client1.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress);
status = client1.Negotiate(
TestConfig.RequestDialects,
TestConfig.IsSMB1NegotiateEnabled);
status = client1.SessionSetup(
TestConfig.DefaultSecurityPackage,
TestConfig.SutComputerName,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken);
uint treeId;
status = client1.TreeConnect(uncSharePath, out treeId);
string fileName = "BVT_SMB2Basic_InvalidCreateRequestStructureSize" + Guid.NewGuid();
FILEID fileID;
Smb2CreateContextResponse[] serverCreateContexts;
// [MS-SMB2] Section 2.2.13 SMB2 CREATE Request
// StructureSize (2 bytes): The client MUST set this field to 57, indicating the size of the request structure, not including the header.
// The client MUST set it to this value regardless of how long Buffer[] actually is in the request being sent.
// So set the StuctureSize to 58 here to make "the size of the SMB2 CREATE Request is less than specified in the StructureSize field".
client1.BeforeSendingPacket(ReplacePacketByStructureSize);
status = client1.Create(
treeId,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileID,
out serverCreateContexts,
checker: (header, response) => { });
BaseTestSite.Assert.AreEqual(
Smb2Status.STATUS_INVALID_PARAMETER,
status,
"The size of the SMB2 CREATE Request (excluding the SMB2 header) is less than specified in the StructureSize field, then the request MUST be failed with STATUS_ INVALID_PARAMETER");
client1.TreeDisconnect(treeId);
client1.LogOff();
}
private void CreateTestFile(CompressionAlgorithm[] compressionAlgorithms, bool enableEncryption, out uint treeId, out FILEID fileId)
{
var capabilities = Capabilities_Values.NONE;
if (enableEncryption)
{
capabilities |= Capabilities_Values.GLOBAL_CAP_ENCRYPTION;
}
EncryptionAlgorithm[] encryptionAlgorithms = null;
if (enableEncryption)
{
encryptionAlgorithms = new EncryptionAlgorithm[] { EncryptionAlgorithm.ENCRYPTION_AES128_CCM, EncryptionAlgorithm.ENCRYPTION_AES128_GCM };
}
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Starts a client by sending the following requests: NEGOTIATE; SESSION_SETUP; TREE_CONNECT.");
client = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
client.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress);
client.NegotiateWithContexts(
Packet_Header_Flags_Values.NONE,
TestConfig.RequestDialects,
preauthHashAlgs: new PreauthIntegrityHashID[] { PreauthIntegrityHashID.SHA_512 },
encryptionAlgs: encryptionAlgorithms,
compressionAlgorithms: compressionAlgorithms,
capabilityValue: capabilities,
checker: (Packet_Header header, NEGOTIATE_Response response) =>
{
BaseTestSite.Assert.AreEqual(Smb2Status.STATUS_SUCCESS, header.Status, "SUT MUST return STATUS_SUCCESS if the negotiation finished successfully.");
if (TestConfig.IsWindowsPlatform)
{
bool isExpectedWindowsCompressionContext = client.Smb2Client.CompressionInfo.CompressionIds.Length == 1 && client.Smb2Client.CompressionInfo.CompressionIds[0] == compressionAlgorithms[0];
BaseTestSite.Assert.IsTrue(isExpectedWindowsCompressionContext, "Windows 10 v1903 and later and Windows Server v1903 and later only set CompressionAlgorithms to the first common algorithm supported by the client and server.");
}
else
{
bool isExpectedNonWindowsCompressionContext = Enumerable.SequenceEqual(client.Smb2Client.CompressionInfo.CompressionIds, compressionAlgorithms);
{
BaseTestSite.Assert.IsTrue(isExpectedNonWindowsCompressionContext, "[MS-SMB2] section 3.3.5.4: Non-Windows implementation MUST set CompressionAlgorithms to the CompressionIds in request if they are all supported by SUT.");
}
}
});
client.SessionSetup(
TestConfig.DefaultSecurityPackage,
TestConfig.SutComputerName,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken);
if (enableEncryption)
{
client.EnableSessionSigningAndEncryption(enableSigning: false, enableEncryption: true);
}
client.TreeConnect(uncSharePath, out treeId);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client sends CREATE request with desired access set to GENERIC_READ and GENERIC_WRITE to create a file.");
Smb2CreateContextResponse[] serverCreateContexts;
string fileName = GetTestFileName(uncSharePath);
client.Create(
treeId,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId,
out serverCreateContexts,
accessMask: AccessMask.GENERIC_READ | AccessMask.GENERIC_WRITE
);
}
/// <summary>
/// Attempt to trigger LeaseBreakNotification from a separate client
/// </summary>
/// <param name="client">Client to trigger LeaseBreakNotification</param>
/// <param name="requestDialect">Negotiate dialects</param>
/// <param name="isDirectory">True value indicating to open a directory, false for a file</param>
/// <param name="requestedLeaseState">LeaseState when open the directory or file</param>
/// <param name="accessMask">AccessMask when open the directory or file</param>
private void TriggerBreakFromClient(
Smb2FunctionalClient client,
DialectRevision[] requestDialect,
bool isDirectory,
LeaseStateValues requestedLeaseState,
AccessMask accessMask)
{
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Trigger a lease break notification by accessing same file/directory from a separate client with LeaseState {0} and AccessMask {1}", requestedLeaseState, accessMask);
#region Negotiate
status = client.Negotiate(
requestDialect,
TestConfig.IsSMB1NegotiateEnabled,
capabilityValue: Capabilities_Values.GLOBAL_CAP_DFS | Capabilities_Values.GLOBAL_CAP_DIRECTORY_LEASING | Capabilities_Values.GLOBAL_CAP_LARGE_MTU | Capabilities_Values.GLOBAL_CAP_LEASING | Capabilities_Values.GLOBAL_CAP_MULTI_CHANNEL | Capabilities_Values.GLOBAL_CAP_PERSISTENT_HANDLES);
#endregion
#region SESSION_SETUP
status = client.SessionSetup(
TestConfig.DefaultSecurityPackage,
TestConfig.SutComputerName,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken);
#endregion
#region TREE_CONNECT to share
uint treeId;
status = client.TreeConnect(uncSharePath, out treeId);
#endregion
#region CREATE
FILEID fileId;
Smb2CreateContextResponse[] serverCreateContexts;
status = client.Create(
treeId,
isDirectory ? testDirectory : fileName,
isDirectory ? CreateOptions_Values.FILE_DIRECTORY_FILE : CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId,
out serverCreateContexts,
RequestedOplockLevel_Values.OPLOCK_LEVEL_LEASE,
new Smb2CreateContextRequest[]
{
new Smb2CreateRequestLeaseV2
{
LeaseKey = Guid.NewGuid(),
LeaseState = requestedLeaseState
}
},
accessMask: accessMask);
#endregion
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Finish triggering lease break notification");
}
public void PrepareOpen(ModelDialectRevision clientMaxDialect, DurableHandle durableHandle)
{
prepareOpenClient = new Smb2FunctionalClient(testConfig.Timeout, testConfig, this.Site);
clientGuid = Guid.NewGuid();
DialectRevision[] dialects = Smb2Utility.GetDialects(ModelUtility.GetDialectRevision(clientMaxDialect));
// Connect to Share
ConnectToShare(
Site,
testConfig,
prepareOpenClient,
dialects,
clientGuid,
testConfig.AccountCredential,
out dialect,
out treeId);
Site.Assert.AreEqual(
ModelUtility.GetDialectRevision(clientMaxDialect),
dialect,
"DialectRevision {0} is expected", ModelUtility.GetDialectRevision(clientMaxDialect));
// SMB2 Create
fileName = "ResilientHandlePrepareOpen_" + Guid.NewGuid() + ".txt";
RequestedOplockLevel_Values opLockLevel = RequestedOplockLevel_Values.OPLOCK_LEVEL_NONE;
Smb2CreateContextRequest[] createContextRequests = new Smb2CreateContextRequest[0];
createGuid = Guid.Empty;
if (durableHandle == DurableHandle.DurableHandle)
{// durable handle request context with batch opLock
opLockLevel = RequestedOplockLevel_Values.OPLOCK_LEVEL_BATCH;
createGuid = Guid.NewGuid();
testConfig.CheckCreateContext(CreateContextTypeValue.SMB2_CREATE_DURABLE_HANDLE_REQUEST);
createContextRequests = new Smb2CreateContextRequest[]
{
new Smb2CreateDurableHandleRequest
{
DurableRequest = createGuid
}
};
}
// create
Smb2CreateContextResponse[] createContextResponse;
prepareOpenClient.Create(
treeId,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId,
out createContextResponse,
requestedOplockLevel_Values: opLockLevel,
createContexts: createContextRequests,
checker: (header, response) =>
{
Site.Assert.AreEqual(
Smb2Status.STATUS_SUCCESS,
header.Status,
"{0} should succeed", header.Command);
if (durableHandle == DurableHandle.DurableHandle)
{
Site.Assert.AreEqual <OplockLevel_Values>(
OplockLevel_Values.OPLOCK_LEVEL_BATCH,
response.OplockLevel,
"OplockLevel should be OPLOCK_LEVEL_BATCH if Durable Handle");
}
}
);
if (durableHandle == DurableHandle.DurableHandle)
{
// check whether response contain Durable Context
Site.Assert.IsTrue(
ContainDurableHandleResponse(createContextResponse),
"Durable Handle Response should be in the Create response.");
}
}
/// <summary>
/// Write content before failover
/// </summary>
/// <param name="fsType">FileServerType</param>
/// <param name="server">File Server name.</param>
/// <param name="serverAccessIp">File Server Access IP.</param>
/// <param name="uncSharePath">The share path to write the file.</param>
/// <param name="file">The file name for writing content.</param>
/// <param name="content">The content to write.</param>
/// <param name="clientGuid">Smb2 client Guid.</param>
/// <param name="createGuid">The Guid for smb2 create request.</param>
/// <returns></returns>
protected bool WriteContentBeforeFailover(
FileServerType fsType,
string server,
IPAddress serverAccessIp,
string uncSharePath,
string file,
string content,
Guid clientGuid,
Guid createGuid)
{
uint status = 0;
beforeFailover = new Smb2FunctionalClient(TestConfig.FailoverTimeout, TestConfig, BaseTestSite);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Start a client by sending the following requests: NEGOTIATE; SESSION_SETUP; TREE_CONNECT to {0}", uncSharePath);
beforeFailover.ConnectToServer(TestConfig.UnderlyingTransport, server, serverAccessIp);
Capabilities_Values requestCapabilities = Capabilities_Values.GLOBAL_CAP_DFS | Capabilities_Values.GLOBAL_CAP_DIRECTORY_LEASING | Capabilities_Values.GLOBAL_CAP_LARGE_MTU | Capabilities_Values.GLOBAL_CAP_LEASING | Capabilities_Values.GLOBAL_CAP_MULTI_CHANNEL | Capabilities_Values.GLOBAL_CAP_PERSISTENT_HANDLES;
status = beforeFailover.Negotiate(
TestConfig.RequestDialects,
TestConfig.IsSMB1NegotiateEnabled,
capabilityValue: requestCapabilities,
clientGuid: clientGuid,
checker: (header, response) =>
{
TestConfig.CheckNegotiateDialect(DialectRevision.Smb30, response);
});
if (status != Smb2Status.STATUS_SUCCESS)
{
BaseTestSite.Log.Add(LogEntryKind.Warning, "Negotiate failed with {0}.", Smb2Status.GetStatusCode(status));
return false;
}
status = beforeFailover.SessionSetup(
TestConfig.DefaultSecurityPackage,
server,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken);
if (status != Smb2Status.STATUS_SUCCESS)
{
BaseTestSite.Log.Add(LogEntryKind.Warning, "SessionSetup failed with {0}.", Smb2Status.GetStatusCode(status));
return false;
}
uint treeId = 0;
Share_Capabilities_Values shareCapabilities = Share_Capabilities_Values.NONE;
status = DoUntilSucceed(
() => beforeFailover.TreeConnect(uncSharePath, out treeId, (header, response) =>
{
shareCapabilities = response.Capabilities;
}),
TestConfig.FailoverTimeout,
"Retry TreeConnect until succeed within timeout span");
if (status != Smb2Status.STATUS_SUCCESS)
{
BaseTestSite.Log.Add(LogEntryKind.Warning, "TreeConnect failed with {0}.", Smb2Status.GetStatusCode(status));
return false;
}
BaseTestSite.Assert.IsTrue(shareCapabilities.HasFlag(Share_Capabilities_Values.SHARE_CAP_CONTINUOUS_AVAILABILITY),
"CA Share should have SHARE_CAP_CONTINUOUS_AVAILABILITY bit set for Capabilities in TreeConnect response.");
if (fsType == FileServerType.ScaleOutFileServer)
{
BaseTestSite.Assert.IsTrue(shareCapabilities.HasFlag(Share_Capabilities_Values.SHARE_CAP_SCALEOUT),
"ScaleOut FS should have SHARE_CAP_SCALEOUT bit set for Capabilities in TreeConnect response.");
}
FILEID fileId;
Smb2CreateContextResponse[] serverCreateContexts;
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client sends CREATE request with SMB2_CREATE_DURABLE_HANDLE_REQUEST_V2 with PERSISTENT flag set.");
status = beforeFailover.Create(
treeId,
file,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId,
out serverCreateContexts,
RequestedOplockLevel_Values.OPLOCK_LEVEL_NONE,
new Smb2CreateContextRequest[] {
new Smb2CreateDurableHandleRequestV2
{
CreateGuid = createGuid,
Flags = CREATE_DURABLE_HANDLE_REQUEST_V2_Flags.DHANDLE_FLAG_PERSISTENT,
Timeout = 3600000,
},
});
if (status != Smb2Status.STATUS_SUCCESS)
{
BaseTestSite.Log.Add(LogEntryKind.Warning, "Create failed with {0}.", Smb2Status.GetStatusCode(status));
return false;
}
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client sends WRITE request to write content to the file.");
status = beforeFailover.Write(treeId, fileId, content);
if (status != Smb2Status.STATUS_SUCCESS)
{
BaseTestSite.Log.Add(LogEntryKind.Warning, "Write content failed with {0}.", Smb2Status.GetStatusCode(status));
return false;
}
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client sends FLUSH request.");
status = beforeFailover.Flush(treeId, fileId);
if (status != Smb2Status.STATUS_SUCCESS)
{
BaseTestSite.Log.Add(LogEntryKind.Warning, "Flush failed with {0}.", Smb2Status.GetStatusCode(status));
return false;
}
return true;
}
/// <summary>
/// Write content before failover
/// </summary>
/// <param name="fsType">FileServerType</param>
/// <param name="server">File Server name.</param>
/// <param name="serverAccessIp">File Server Access IP.</param>
/// <param name="uncSharePath">The share path to write the file.</param>
/// <param name="file">The file name for writing content.</param>
/// <param name="content">The content to write.</param>
/// <param name="clientGuid">Smb2 client Guid.</param>
/// <param name="createGuid">The Guid for smb2 create request.</param>
/// <param name="fileId">File id returned by server</param>
/// <returns></returns>
protected bool WriteContentBeforeFailover(
FileServerType fsType,
string server,
IPAddress serverAccessIp,
string uncSharePath,
string file,
string content,
Guid clientGuid,
Guid createGuid,
out FILEID fileId)
{
uint status = 0;
fileId = FILEID.Zero;
beforeFailover = new Smb2FunctionalClient(TestConfig.FailoverTimeout, TestConfig, BaseTestSite);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Start a client by sending the following requests: NEGOTIATE; SESSION_SETUP; TREE_CONNECT to {0}", uncSharePath);
beforeFailover.ConnectToServer(TestConfig.UnderlyingTransport, server, serverAccessIp);
Capabilities_Values requestCapabilities = Capabilities_Values.GLOBAL_CAP_DFS | Capabilities_Values.GLOBAL_CAP_DIRECTORY_LEASING | Capabilities_Values.GLOBAL_CAP_LARGE_MTU | Capabilities_Values.GLOBAL_CAP_LEASING | Capabilities_Values.GLOBAL_CAP_MULTI_CHANNEL | Capabilities_Values.GLOBAL_CAP_PERSISTENT_HANDLES;
status = beforeFailover.Negotiate(
TestConfig.RequestDialects,
TestConfig.IsSMB1NegotiateEnabled,
capabilityValue: requestCapabilities,
clientGuid: clientGuid,
checker: (header, response) =>
{
TestConfig.CheckNegotiateDialect(DialectRevision.Smb30, response);
});
if (status != Smb2Status.STATUS_SUCCESS)
{
BaseTestSite.Log.Add(LogEntryKind.Warning, "Negotiate failed with {0}.", Smb2Status.GetStatusCode(status));
return(false);
}
status = beforeFailover.SessionSetup(
TestConfig.DefaultSecurityPackage,
server,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken);
if (status != Smb2Status.STATUS_SUCCESS)
{
BaseTestSite.Log.Add(LogEntryKind.Warning, "SessionSetup failed with {0}.", Smb2Status.GetStatusCode(status));
return(false);
}
uint treeId = 0;
Share_Capabilities_Values shareCapabilities = Share_Capabilities_Values.NONE;
status = beforeFailover.TreeConnect(uncSharePath, out treeId, (header, response) =>
{
shareCapabilities = response.Capabilities;
});
if (status != Smb2Status.STATUS_SUCCESS)
{
BaseTestSite.Log.Add(LogEntryKind.Warning, "TreeConnect failed with {0}.", Smb2Status.GetStatusCode(status));
return(false);
}
BaseTestSite.Assert.IsTrue(shareCapabilities.HasFlag(Share_Capabilities_Values.SHARE_CAP_CONTINUOUS_AVAILABILITY),
"CA Share should have SHARE_CAP_CONTINUOUS_AVAILABILITY bit set for Capabilities in TreeConnect response.");
if (fsType == FileServerType.ScaleOutFileServer)
{
BaseTestSite.Assert.IsTrue(shareCapabilities.HasFlag(Share_Capabilities_Values.SHARE_CAP_SCALEOUT),
"ScaleOut FS should have SHARE_CAP_SCALEOUT bit set for Capabilities in TreeConnect response.");
}
Smb2CreateContextResponse[] serverCreateContexts;
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client sends CREATE request with SMB2_CREATE_DURABLE_HANDLE_REQUEST_V2 with PERSISTENT flag set.");
status = beforeFailover.Create(
treeId,
file,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId,
out serverCreateContexts,
RequestedOplockLevel_Values.OPLOCK_LEVEL_NONE,
new Smb2CreateContextRequest[] {
new Smb2CreateDurableHandleRequestV2
{
CreateGuid = createGuid,
Flags = CREATE_DURABLE_HANDLE_REQUEST_V2_Flags.DHANDLE_FLAG_PERSISTENT,
Timeout = 3600000,
},
});
if (status != Smb2Status.STATUS_SUCCESS)
{
BaseTestSite.Log.Add(LogEntryKind.Warning, "Create failed with {0}.", Smb2Status.GetStatusCode(status));
return(false);
}
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client sends WRITE request to write content to the file.");
status = beforeFailover.Write(treeId, fileId, content);
if (status != Smb2Status.STATUS_SUCCESS)
{
BaseTestSite.Log.Add(LogEntryKind.Warning, "Write content failed with {0}.", Smb2Status.GetStatusCode(status));
return(false);
}
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client sends FLUSH request.");
status = beforeFailover.Flush(treeId, fileId);
if (status != Smb2Status.STATUS_SUCCESS)
{
BaseTestSite.Log.Add(LogEntryKind.Warning, "Flush failed with {0}.", Smb2Status.GetStatusCode(status));
return(false);
}
return(true);
}
public void SetupConnection(ModelDialectRevision clientMaxDialect)
{
testClient = new Smb2FunctionalClient(testConfig.Timeout, testConfig, this.Site);
testClient.ConnectToServer(testConfig.UnderlyingTransport, testConfig.SutComputerName, testConfig.SutIPAddress);
testClient.RequestSent += new Action<Packet_Header>(PrintSequenceWindow);
DialectRevision[] dialects = Smb2Utility.GetDialects(ModelUtility.GetDialectRevision(clientMaxDialect));
uint status;
NEGOTIATE_Response? negotiateResponse = null;
status = testClient.Negotiate(
dialects,
testConfig.IsSMB1NegotiateEnabled,
capabilityValue: Capabilities_Values.GLOBAL_CAP_LARGE_MTU,
checker: (header, response) =>
{
Site.Assert.AreEqual(
Smb2Status.STATUS_SUCCESS,
header.Status,
"{0} should succeed", header.Command);
// The server MUST grant the client at least 1 credit when responding to SMB2 NEGOTIATE.
Site.Assert.IsTrue(
header.CreditRequestResponse >= 1,
"The server MUST grant the client at least 1 credit when responding to SMB2 NEGOTIATE");
negotiateResponse = response;
});
Site.Log.Add(
LogEntryKind.Debug,
"The maximum size, in bytes, of Length in READ/WRITE that server will accept on the connection is {0}",
testClient.MaxBufferSize);
Site.Assert.AreEqual(
ModelUtility.GetDialectRevision(clientMaxDialect),
negotiateResponse.Value.DialectRevision,
"DialectRevision {0} is expected", ModelUtility.GetDialectRevision(clientMaxDialect));
negotiateDialect = negotiateResponse.Value.DialectRevision;
if ((negotiateDialect == DialectRevision.Smb21 || ModelUtility.IsSmb3xFamily(negotiateDialect))
// In case server does not support multicredit even implement Smb21 or Smb30
&& testConfig.IsMultiCreditSupported)
{
isMultiCreditSupportedOnConnection = true;
}
else
{
isMultiCreditSupportedOnConnection = false;
}
status = testClient.SessionSetup(
testConfig.DefaultSecurityPackage,
testConfig.SutComputerName,
testConfig.AccountCredential,
testConfig.UseServerGssToken);
status = testClient.TreeConnect(
uncSharePath,
out treeId);
Smb2CreateContextResponse[] serverCreateContexts;
fileName = Guid.NewGuid().ToString();
status = testClient.Create(
treeId,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId,
out serverCreateContexts);
}
/// <summary>
/// Read content after failover
/// </summary>
/// <param name="server">File server name.</param>
/// <param name="serverAccessIp">File server access IP.</param>
/// <param name="uncSharePath">The share path to read the file.</param>
/// <param name="file">The file name for reading content.</param>
/// <param name="content">The content to read.</param>
/// <param name="clientGuid">Smb2 client Guid.</param>
/// <param name="createGuid">The Guid for smb2 create request.</param>
/// <param name="fileId">FileId used in DH2C create context</param>
/// <returns></returns>
protected bool ReadContentAfterFailover(string server,
IPAddress serverAccessIp,
string uncSharePath,
string file,
string content,
Guid clientGuid,
Guid createGuid,
FILEID fileId)
{
uint status;
BaseTestSite.Assert.AreNotEqual(
null,
serverAccessIp,
"Access IP to the file server should not be empty");
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Got IP {0} to access the file server", serverAccessIp.ToString());
Smb2FunctionalClient afterFailover = new Smb2FunctionalClient(TestConfig.FailoverTimeout, TestConfig, BaseTestSite);
DoUntilSucceed(() => afterFailover.ConnectToServer(TestConfig.UnderlyingTransport, server, serverAccessIp), TestConfig.FailoverTimeout,
"Retry to connect to server until succeed within timeout span");
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client sends NEGOTIATE request with the same clientguid of previous client.");
status = afterFailover.Negotiate(
TestConfig.RequestDialects,
TestConfig.IsSMB1NegotiateEnabled,
capabilityValue: Capabilities_Values.GLOBAL_CAP_DFS | Capabilities_Values.GLOBAL_CAP_DIRECTORY_LEASING | Capabilities_Values.GLOBAL_CAP_LARGE_MTU | Capabilities_Values.GLOBAL_CAP_LEASING | Capabilities_Values.GLOBAL_CAP_MULTI_CHANNEL | Capabilities_Values.GLOBAL_CAP_PERSISTENT_HANDLES,
clientGuid: clientGuid);
if (status != Smb2Status.STATUS_SUCCESS)
{
BaseTestSite.Log.Add(LogEntryKind.Warning, "Negotiate failed with {0}.", Smb2Status.GetStatusCode(status));
return(false);
}
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client sends SESSION_SETUP request with the same SESSION_ID of previous client.");
status = afterFailover.ReconnectSessionSetup(
beforeFailover,
TestConfig.DefaultSecurityPackage,
server,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken);
if (status != Smb2Status.STATUS_SUCCESS)
{
BaseTestSite.Log.Add(LogEntryKind.Warning, "ReconnectSessionSetup failed with {0}.", Smb2Status.GetStatusCode(status));
return(false);
}
// Retry TreeConnect because network path may not be available immediately
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client retries TREE_CONNECT to {0} until succeed or timeout in {1} because network path may not be available immediately.", uncSharePath, TestConfig.FailoverTimeout);
uint treeId = 0;
status = afterFailover.TreeConnect(uncSharePath, out treeId, (header, response) => { });
if (status != Smb2Status.STATUS_SUCCESS)
{
BaseTestSite.Log.Add(LogEntryKind.Warning, "TreeConnect failed with {0}.", Smb2Status.GetStatusCode(status));
return(false);
}
// Retry Create because file may not be available immediately
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client retries to send CREATE request with SMB2_CREATE_DURABLE_HANDLE_RECONNECT_V2 context with PERSISTENT flag set until succeed or timeout in {0}.", TestConfig.FailoverTimeout);
Smb2CreateContextResponse[] serverCreateContexts;
status = DoUntilSucceed(
() => afterFailover.Create(
treeId,
file,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId,
out serverCreateContexts,
RequestedOplockLevel_Values.OPLOCK_LEVEL_NONE,
new Smb2CreateContextRequest[] {
new Smb2CreateDurableHandleReconnectV2
{
FileId = new FILEID {
Persistent = fileId.Persistent
},
CreateGuid = createGuid,
Flags = CREATE_DURABLE_HANDLE_RECONNECT_V2_Flags.DHANDLE_FLAG_PERSISTENT
},
},
checker: (header, response) => { }),
TestConfig.FailoverTimeout,
"Retry Create until succeed within timeout span");
if (status != Smb2Status.STATUS_SUCCESS)
{
BaseTestSite.Log.Add(LogEntryKind.Warning, "Create failed with {0}.", Smb2Status.GetStatusCode(status));
return(false);
}
string readContent;
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client sends READ request to read content.");
status = afterFailover.Read(treeId, fileId, 0, (uint)content.Length, out readContent);
if (status != Smb2Status.STATUS_SUCCESS)
{
BaseTestSite.Log.Add(LogEntryKind.Warning, "Read failed with {0}.", Smb2Status.GetStatusCode(status));
return(false);
}
BaseTestSite.Assert.IsTrue(
content.Equals(readContent),
"Content read after failover should be identical to that written before failover");
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Tear down the client by sending the following requests: CLOSE; TREE_DISCONNECT; LOG_OFF");
status = afterFailover.Close(treeId, fileId);
status = afterFailover.TreeDisconnect(treeId);
status = afterFailover.LogOff();
afterFailover.Disconnect();
return(true);
}
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);
}
/// <summary>
/// One client requests a lease
/// </summary>
/// <param name="leaseStateType">Type of the LeaseState in the requested lease context</param>
public void RequestLease(ModelLeaseStateType leaseStateType)
{
Smb2CreateContextResponse[] responses;
FILEID fileId;
LeaseStateValues leaseState = LeaseStateValues.SMB2_LEASE_NONE;
switch (leaseStateType)
{
case ModelLeaseStateType.Lease_None:
leaseState = LeaseStateValues.SMB2_LEASE_NONE;
break;
case ModelLeaseStateType.Lease_R:
leaseState = LeaseStateValues.SMB2_LEASE_READ_CACHING;
break;
case ModelLeaseStateType.Lease_RH:
leaseState = LeaseStateValues.SMB2_LEASE_READ_CACHING | LeaseStateValues.SMB2_LEASE_HANDLE_CACHING;
break;
case ModelLeaseStateType.Lease_RW:
leaseState = LeaseStateValues.SMB2_LEASE_READ_CACHING | LeaseStateValues.SMB2_LEASE_WRITE_CACHING;
break;
case ModelLeaseStateType.Lease_RWH:
leaseState = LeaseStateValues.SMB2_LEASE_READ_CACHING | LeaseStateValues.SMB2_LEASE_WRITE_CACHING | LeaseStateValues.SMB2_LEASE_HANDLE_CACHING;
break;
default:
break;
}
leaseClient.Create(
treeIdLease,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId,
out responses,
RequestedOplockLevel_Values.OPLOCK_LEVEL_LEASE,
new Smb2CreateContextRequest[]
{
new Smb2CreateRequestLease()
{
LeaseKey = Guid.NewGuid(),
LeaseState = leaseState
}
});
if (responses == null)
{
throw new Exception("There is no Smb2CreateContextResponse in response data!");
}
if (responses.Length == 0 || responses[0] is not Smb2CreateResponseLease)
{
throw new Exception("There is no SMB2_CREATE_RESPONSE_LEASE create context in response data!");
}
grantedLeaseState = ((Smb2CreateResponseLease)responses[0]).LeaseState;
HandleResult();
}
public void DirectoryLeasing_BreakHandleCachingByParentDeleted()
{
#region Prepare test directory
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Create test directory.");
uncSharePath = Smb2Utility.GetUncPath(TestConfig.SutComputerName, TestConfig.BasicFileShare);
string parentDirectory = "ParentDirectory_" + Guid.NewGuid().ToString();
sutProtocolController.CreateDirectory(uncSharePath, parentDirectory);
testDirectory = CreateTestDirectory(TestConfig.SutComputerName, TestConfig.BasicFileShare + "\\" + parentDirectory);
#endregion
#region Initialize test clients
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Initialize test clients.");
Guid clientGuidRequestingLease = Guid.NewGuid();
Smb2FunctionalClient clientRequestingLease = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
Guid clientGuidTriggeringBreak = Guid.NewGuid();
Smb2FunctionalClient clientTriggeringBreak = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
clientRequestingLease.Smb2Client.LeaseBreakNotificationReceived +=
new Action<Packet_Header, LEASE_BREAK_Notification_Packet>(base.OnLeaseBreakNotificationReceived);
clientRequestingLease.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress);
clientTriggeringBreak.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress);
#endregion
#region CREATE an open to request lease
uint treeIdClientRequestingLease;
FILEID fileIdClientRequestingLease;
string targetName = parentDirectory + "\\" + testDirectory;
LeaseStateValues requestedLeaseState = LeaseStateValues.SMB2_LEASE_READ_CACHING | LeaseStateValues.SMB2_LEASE_HANDLE_CACHING;
// Add expected NewLeaseState
expectedNewLeaseState = LeaseStateValues.SMB2_LEASE_READ_CACHING;
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"Client attempts to request lease {0} on directory {1}", requestedLeaseState, testDirectory);
status = CreateOpenFromClient(clientRequestingLease, clientGuidRequestingLease, targetName, true, requestedLeaseState, AccessMask.GENERIC_READ, out treeIdClientRequestingLease, out fileIdClientRequestingLease);
BaseTestSite.Assert.AreEqual(
Smb2Status.STATUS_SUCCESS,
status,
"Create an open to {0} should succeed, actual status is {1}", testDirectory, Smb2Status.GetStatusCode(status));
#endregion
// Create a timer that signals the delegate to invoke CheckBreakNotification
Timer timer = new Timer(base.CheckBreakNotification, treeIdClientRequestingLease, 0, Timeout.Infinite);
base.clientToAckLeaseBreak = clientRequestingLease;
#region Attempt to trigger lease break by deleting parent directory
uint treeIdClientTriggeringBreak;
FILEID fileIdClientTriggeringBreak;
AccessMask accessMaskTrigger = AccessMask.DELETE;
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"A separate client attempts to trigger lease break by deleting its parent directory");
status = CreateOpenFromClient(clientTriggeringBreak, clientGuidTriggeringBreak, parentDirectory, true, LeaseStateValues.SMB2_LEASE_NONE, accessMaskTrigger, out treeIdClientTriggeringBreak, out fileIdClientTriggeringBreak);
BaseTestSite.Assert.AreEqual(
Smb2Status.STATUS_SUCCESS,
status,
"Create an open to {0} should succeed", parentDirectory);
#region set FileDispositionInformation for deletion
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Set FileDispositionInformation for deletion.");
FileDispositionInformation fileDispositionInfo;
fileDispositionInfo.DeletePending = 1; // Set 1 to indicate directory SHOULD be delted when the open closed
byte[] inputBuffer = TypeMarshal.ToBytes<FileDispositionInformation>(fileDispositionInfo);
status = clientTriggeringBreak.SetFileAttributes(
treeIdClientTriggeringBreak,
(byte)FileInformationClasses.FileDispositionInformation,
fileIdClientTriggeringBreak,
inputBuffer,
(header, response) =>
{
BaseTestSite.Assert.AreNotEqual(
Smb2Status.STATUS_SUCCESS,
header.Status,
"Setting FileDispositionInformation to the parent directory for deletion when child is opened by others is not expected to SUCCESS. " +
"Actually server returns with {0}.", Smb2Status.GetStatusCode(header.Status));
BaseTestSite.CaptureRequirementIfAreEqual(
Smb2Status.STATUS_DIRECTORY_NOT_EMPTY,
header.Status,
RequirementCategory.STATUS_DIRECTORY_NOT_EMPTY.Id,
RequirementCategory.STATUS_DIRECTORY_NOT_EMPTY.Description);
});
status = clientTriggeringBreak.Close(treeIdClientTriggeringBreak, fileIdClientTriggeringBreak);
#endregion
#region CREATE an open to parent directory again
BaseTestSite.Log.Add(LogEntryKind.TestStep, "CREATE an open to parent directory again.");
// Currently we need an additional CREATE to open the parent directory to trigger the lease break
// which is the same way when Windows attempt to delete the parent directory when child is opened by others
Smb2CreateContextResponse[] serverCreateContexts;
status = clientTriggeringBreak.Create(
treeIdClientTriggeringBreak,
targetName,
CreateOptions_Values.FILE_DIRECTORY_FILE | CreateOptions_Values.FILE_DELETE_ON_CLOSE,
out fileIdClientTriggeringBreak,
out serverCreateContexts,
RequestedOplockLevel_Values.OPLOCK_LEVEL_LEASE,
new Smb2CreateContextRequest[]
{
new Smb2CreateRequestLeaseV2
{
LeaseKey = clientGuidTriggeringBreak,
LeaseState = LeaseStateValues.SMB2_LEASE_NONE
}
},
accessMask: accessMaskTrigger);
#endregion
#endregion
}
private void AppInstanceIdTest(bool sameAppInstanceId, bool containCreateDurableContext)
{
string content = Smb2Utility.CreateRandomString(TestConfig.WriteBufferLengthInKb);
#region Client 1 Connect to Server
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Start the first client by sending the following requests: NEGOTIATE; SESSION_SETUP; TREE_CONNECT");
clientForInitialOpen = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
clientForInitialOpen.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress, TestConfig.ClientNic1IPAddress);
clientForInitialOpen.Negotiate(TestConfig.RequestDialects, TestConfig.IsSMB1NegotiateEnabled);
clientForInitialOpen.SessionSetup(
TestConfig.DefaultSecurityPackage,
TestConfig.SutComputerName,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken);
uint treeIdForInitialOpen;
clientForInitialOpen.TreeConnect(sharePath, out treeIdForInitialOpen);
Guid appInstanceId = Guid.NewGuid();
FILEID fileIdForInitialOpen;
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"The first client sends CREATE request for exclusive open with SMB2_CREATE_APP_INSTANCE_ID create context.");
Smb2CreateContextResponse[] serverCreateContexts;
Smb2CreateContextRequest[] createContextsRequestForInitialOpen = null;
if (containCreateDurableContext)
{
BaseTestSite.Log.Add(LogEntryKind.TestStep, "SMB2_CREATE_DURABLE_HANDLE_REQUEST_V2 create context is also included in the CREATE request.");
createContextsRequestForInitialOpen = new Smb2CreateContextRequest[] {
new Smb2CreateDurableHandleRequestV2
{
CreateGuid = Guid.NewGuid()
},
new Smb2CreateAppInstanceId
{
AppInstanceId = appInstanceId
}
};
}
else
{
BaseTestSite.Log.Add(LogEntryKind.TestStep, "SMB2_CREATE_DURABLE_HANDLE_REQUEST_V2 create context is not included in the CREATE request.");
createContextsRequestForInitialOpen = new Smb2CreateContextRequest[] {
new Smb2CreateAppInstanceId
{
AppInstanceId = appInstanceId
}
};
}
clientForInitialOpen.Create(
treeIdForInitialOpen,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileIdForInitialOpen,
out serverCreateContexts,
RequestedOplockLevel_Values.OPLOCK_LEVEL_NONE,
createContextsRequestForInitialOpen,
shareAccess: ShareAccess_Values.NONE);
#endregion
#region Client 2 Connect to Server
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Start the second client by sending the following requests: NEGOTIATE; SESSION-SETUP; TREE_CONNECT");
clientForReOpen = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
clientForReOpen.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress, TestConfig.ClientNic2IPAddress);
clientForReOpen.Negotiate(TestConfig.RequestDialects, TestConfig.IsSMB1NegotiateEnabled);
clientForReOpen.SessionSetup(
TestConfig.DefaultSecurityPackage,
TestConfig.SutComputerName,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken);
uint treeIdForReOpen;
clientForReOpen.TreeConnect(sharePath, out treeIdForReOpen);
FILEID fileIdForReOpen;
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"The second client sends CREATE request for exclusive open with the {0} SMB2_CREATE_APP_INSTANCE_ID of the first client.", sameAppInstanceId ? "same" : "different");
Smb2CreateContextRequest[] createContextsRequestForReOpen = null;
if (containCreateDurableContext)
{
BaseTestSite.Log.Add(LogEntryKind.TestStep, "SMB2_CREATE_DURABLE_HANDLE_REQUEST_V2 create context is also included in the CREATE request.");
createContextsRequestForReOpen = new Smb2CreateContextRequest[] {
new Smb2CreateDurableHandleRequestV2
{
CreateGuid = Guid.NewGuid()
},
new Smb2CreateAppInstanceId
{
AppInstanceId = sameAppInstanceId ? appInstanceId : Guid.NewGuid()
}
};
}
else
{
BaseTestSite.Log.Add(LogEntryKind.TestStep, "SMB2_CREATE_DURABLE_HANDLE_REQUEST_V2 create context is not included in the CREATE request.");
createContextsRequestForReOpen = new Smb2CreateContextRequest[] {
new Smb2CreateAppInstanceId
{
AppInstanceId = sameAppInstanceId ? appInstanceId : Guid.NewGuid()
}
};
}
clientForReOpen.Create(
treeIdForReOpen,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileIdForReOpen,
out serverCreateContexts,
RequestedOplockLevel_Values.OPLOCK_LEVEL_NONE,
createContextsRequestForReOpen,
shareAccess: ShareAccess_Values.NONE,
checker: (header, response) =>
{
if (sameAppInstanceId)
{
BaseTestSite.Assert.AreEqual(Smb2Status.STATUS_SUCCESS, header.Status, "The second client should create the open successfully.");
}
else
{
BaseTestSite.Assert.AreNotEqual(Smb2Status.STATUS_SUCCESS, header.Status, "The second client should not create the open successfully.");
}
});
BaseTestSite.Log.Add(LogEntryKind.TestStep, "The first client sends another WRITE request.");
if (sameAppInstanceId)
{
clientForInitialOpen.Write(treeIdForInitialOpen, fileIdForInitialOpen, content,
checker: (header, response) =>
{
BaseTestSite.Assert.AreNotEqual(
Smb2Status.STATUS_SUCCESS,
header.Status,
"The initial open is closed. Write should not succeed. Actually server returns with {0}.", Smb2Status.GetStatusCode(header.Status));
BaseTestSite.CaptureRequirementIfAreEqual(
Smb2Status.STATUS_FILE_CLOSED,
header.Status,
RequirementCategory.STATUS_FILE_CLOSED.Id,
RequirementCategory.STATUS_FILE_CLOSED.Description);
});
// The first open is closed, no need to do clean up job.
// Clean up the second client.
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Tear down the second client by sending the following requests: CLOSE; TREE_DISCONNECT; LOG_OFF; DISCONNECT");
clientForReOpen.Close(treeIdForReOpen, fileIdForReOpen);
clientForReOpen.TreeDisconnect(treeIdForReOpen);
clientForReOpen.LogOff();
clientForReOpen.Disconnect();
}
else
{
BaseTestSite.Log.Add(LogEntryKind.TestStep, "The initial open is not closed. Write should succeed.");
clientForInitialOpen.Write(treeIdForInitialOpen, fileIdForInitialOpen, content);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Tear down the first client by sending the following requests: CLOSE; TREE_DISCONNECT; LOG_OFF");
clientForInitialOpen.Close(treeIdForInitialOpen, fileIdForInitialOpen);
clientForInitialOpen.TreeDisconnect(treeIdForInitialOpen);
clientForInitialOpen.LogOff();
// The second client doesn't create the open succesfully, so no need to close the open.
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Tear down the second client by sending the following requests: TREE_DISCONNECT; LOG_OFF; DISCONNECT");
clientForReOpen.TreeDisconnect(treeIdForReOpen);
clientForReOpen.LogOff();
clientForReOpen.Disconnect();
}
#endregion
}
/// <summary>
/// Verify if server grant lease state as expected
/// </summary>
/// <param name="requestedLeaseState">Requested lease state from client</param>
/// <param name="expectedGrantedLeaseState">Expected lease state that server granted</param>
private void VerifyGrantedLeaseState(LeaseStateValues requestedLeaseState, LeaseStateValues expectedGrantedLeaseState)
{
Guid clientGuid = Guid.NewGuid();
string testDirectory = "DirectoryLeasing_GrantedLeaseState_" + clientGuid.ToString();
#region Connect to share
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Connect to share {0}.", uncSharePath);
Smb2FunctionalClient client = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
client.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress);
#region Negotiate
Capabilities_Values clientCapabilities =
Capabilities_Values.GLOBAL_CAP_DFS | Capabilities_Values.GLOBAL_CAP_DIRECTORY_LEASING | Capabilities_Values.GLOBAL_CAP_LARGE_MTU
| Capabilities_Values.GLOBAL_CAP_LEASING | Capabilities_Values.GLOBAL_CAP_MULTI_CHANNEL | Capabilities_Values.GLOBAL_CAP_PERSISTENT_HANDLES;
client.Negotiate(
TestConfig.RequestDialects,
TestConfig.IsSMB1NegotiateEnabled,
SecurityMode_Values.NEGOTIATE_SIGNING_ENABLED,
clientCapabilities,
clientGuid,
checker: (Packet_Header header, NEGOTIATE_Response response) =>
{
BaseTestSite.Assert.AreEqual(
Smb2Status.STATUS_SUCCESS,
header.Status,
"NEGOTIATE should succeed.");
TestConfig.CheckNegotiateDialect(DialectRevision.Smb30, response);
TestConfig.CheckNegotiateCapabilities(NEGOTIATE_Response_Capabilities_Values.GLOBAL_CAP_DIRECTORY_LEASING, response);
});
#endregion
#region SessionSetup
status = client.SessionSetup(
TestConfig.DefaultSecurityPackage,
TestConfig.SutComputerName,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken);
BaseTestSite.Assert.AreEqual(
Smb2Status.STATUS_SUCCESS,
status,
"SessionSetup should succeed, actual status is {0}", Smb2Status.GetStatusCode(status));
#endregion
#region TreeConnect
uint treeId;
status = client.TreeConnect(uncSharePath, out treeId);
BaseTestSite.Assert.AreEqual(
Smb2Status.STATUS_SUCCESS,
status,
"TreeConnect should succeed, actual status is {0}", Smb2Status.GetStatusCode(status));
#endregion
#endregion
#region CREATE open to directory with lease
BaseTestSite.Log.Add(LogEntryKind.TestStep, "CREATE open to directory with lease.");
Smb2CreateContextResponse[] serverCreateContexts;
FILEID fileId;
status = client.Create(
treeId,
testDirectory,
CreateOptions_Values.FILE_DIRECTORY_FILE,
out fileId,
out serverCreateContexts,
RequestedOplockLevel_Values.OPLOCK_LEVEL_LEASE,
new Smb2CreateContextRequest[]
{
new Smb2CreateRequestLeaseV2
{
LeaseKey = clientGuid,
LeaseState = requestedLeaseState
}
},
accessMask: AccessMask.GENERIC_ALL,
shareAccess: ShareAccess_Values.FILE_SHARE_READ,
checker: (header, response) => { });
BaseTestSite.Assert.AreEqual(
Smb2Status.STATUS_SUCCESS,
status,
"Create an open on directory should succeed, actual status is {0}", Smb2Status.GetStatusCode(status));
#endregion
#region Verify server granted lease state
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Verify server granted lease state.");
BaseTestSite.Assert.AreNotEqual(
null,
serverCreateContexts,
"Server should return granted lease state");
foreach (Smb2CreateContextResponse serverCreateContext in serverCreateContexts)
{
Smb2CreateResponseLeaseV2 createResponseLeaseV2 = serverCreateContext as Smb2CreateResponseLeaseV2;
if (createResponseLeaseV2 != null)
{
BaseTestSite.Assert.AreEqual(
expectedGrantedLeaseState,
createResponseLeaseV2.LeaseState,
"Server granted lease state {0} should be the same as {1}", createResponseLeaseV2.LeaseState, expectedGrantedLeaseState);
break;
}
}
#endregion
}
public void SharePermission_CreateClose_DeleteFile_MaximalAccessNotIncludeDeleteOrGenericAll()
{
_SID sid = DtypUtility.GetSidFromAccount(TestConfig.DomainName, azUser01Name);
if (!dynamicallyConfigurableShareExist)
{
BaseTestSite.Assert.Inconclusive("Required share: {0} does not exist!", dynamicallyConfigurableShareName);
}
object ace = DtypUtility.CreateAccessAllowedAce(sid, (DtypUtility.ACCESS_MASK_STANDARD_RIGHTS_ALL | DtypUtility.ACCESS_MASK_SPECIFIC_RIGHTS_ALL) & ~DtypUtility.ACCESS_MASK_DELETE, ACE_FLAGS.None);
SetSecurityDescriptorOnDynamicallyConfigurableShare(ace);
string shareName = dynamicallyConfigurableShareName;
string shareUncPath = Smb2Utility.GetUncPath(TestConfig.SutComputerName, shareName);
Smb2FunctionalClient client = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
client.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress);
AccountCredential user = new AccountCredential(TestConfig.DomainName, azUser01Name, TestConfig.UserPassword);
try
{
BaseTestSite.Log.Add(LogEntryKind.Debug, "Client sends NEGOTIATE message.");
client.Negotiate(TestConfig.RequestDialects, TestConfig.IsSMB1NegotiateEnabled);
BaseTestSite.Log.Add(LogEntryKind.Debug, "Client sends SESSION_SETUP message using account: {0}@{1}.", user.AccountName, user.DomainName);
client.SessionSetup(TestConfig.DefaultSecurityPackage, TestConfig.SutComputerName, user, false);
uint treeId;
BaseTestSite.Log.Add(LogEntryKind.Debug, "Client sends TREE_CONNECT message to access share: {0}.", shareUncPath);
client.TreeConnect(shareUncPath, out treeId, checker: (header, response) =>
{
BaseTestSite.Assert.IsTrue((response.MaximalAccess.ACCESS_MASK & (DtypUtility.ACCESS_MASK_DELETE | DtypUtility.ACCESS_MASK_GENERIC_ALL)) == 0,
"Treeconnect.MaximalAccess does not include DELETE or GENERIC_ALL.");
});
string fileName = GetTestFileName(shareUncPath);
FILEID fileId;
Smb2CreateContextResponse[] createContexResponse;
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Create the file: {0}", fileName);
BaseTestSite.Log.Add(LogEntryKind.Debug, "Client sends CREATE request.");
uint status = client.Create(
treeId,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId,
out createContexResponse,
accessMask: AccessMask.FILE_READ_DATA | AccessMask.FILE_WRITE_DATA | AccessMask.FILE_APPEND_DATA |
AccessMask.FILE_READ_ATTRIBUTES | AccessMask.FILE_READ_EA | AccessMask.FILE_WRITE_ATTRIBUTES |
AccessMask.FILE_WRITE_EA | AccessMask.READ_CONTROL | AccessMask.WRITE_DAC | AccessMask.SYNCHRONIZE, // Windows client behavior
shareAccess: ShareAccess_Values.NONE,
createDisposition: CreateDisposition_Values.FILE_CREATE);
client.Close(treeId, fileId);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Delete the file: {0}", fileName);
BaseTestSite.Log.Add(LogEntryKind.Debug, "Client sends CREATE request with FILE_DELETE_ON_CLOSE flag set in CreateOptions .");
status = client.Create(
treeId,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE | CreateOptions_Values.FILE_DELETE_ON_CLOSE,
out fileId,
out createContexResponse,
accessMask: AccessMask.DELETE | AccessMask.FILE_READ_ATTRIBUTES | AccessMask.SYNCHRONIZE, // Windows client behavior
shareAccess: ShareAccess_Values.FILE_SHARE_DELETE,
createDisposition: CreateDisposition_Values.FILE_OPEN,
checker: (header, response) =>
{
if (TestConfig.Platform == Platform.NonWindows)
{
BaseTestSite.Assert.AreNotEqual(Smb2Status.STATUS_SUCCESS, header.Status,
"If the FILE_DELETE_ON_CLOSE flag is set in CreateOptions and " +
"Treeconnect.MaximalAccess does not include DELETE or GENERIC_ALL, " +
"the server SHOULD fail the request with STATUS_ACCESS_DENIED");
}
else
{
BaseTestSite.Assert.AreEqual(Smb2Status.STATUS_ACCESS_DENIED, header.Status,
"If the FILE_DELETE_ON_CLOSE flag is set in CreateOptions and " +
"Treeconnect.MaximalAccess does not include DELETE or GENERIC_ALL, " +
"the server SHOULD fail the request with STATUS_ACCESS_DENIED");
}
});
client.TreeDisconnect(treeId);
client.LogOff();
}
catch (Exception e)
{
BaseTestSite.Assert.Fail("Case failed due to: {0}", e.Message);
}
finally
{
client.Disconnect();
}
}
/// <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) =>
{
});
}
private void SendCreateRequestWithSpecificAppInstanceversion(
Smb2FunctionalClient client,
Guid appInstanceId,
ulong?appInstanceVersionHigh,
ulong?appInstanceVersionLow,
DialectRevision dialect,
uint expectedCreateResponseStatus,
out uint treeId,
out FILEID fileId
)
{
#region Client connects to Server
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client connects to the file server by sending the following requests: NEGOTIATE; SESSION_SETUP; TREE_CONNECT");
client.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress, TestConfig.ClientNic1IPAddress);
client.Negotiate(Smb2Utility.GetDialects(dialect), TestConfig.IsSMB1NegotiateEnabled);
client.SessionSetup(
TestConfig.DefaultSecurityPackage,
TestConfig.SutComputerName,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken);
client.TreeConnect(uncSharePath, out treeId);
Smb2CreateContextResponse[] serverCreateContexts;
Smb2CreateAppInstanceVersion appInstanceVersion = new Smb2CreateAppInstanceVersion();
Smb2CreateContextRequest[] clientCreateContexts;
if (appInstanceVersionHigh.HasValue && appInstanceVersionLow.HasValue)
{
appInstanceVersion.AppInstanceVersionHigh = appInstanceVersionHigh.Value;
appInstanceVersion.AppInstanceVersionLow = appInstanceVersionLow.Value;
clientCreateContexts =
new Smb2CreateContextRequest[] {
new Smb2CreateAppInstanceId
{
AppInstanceId = appInstanceId
},
appInstanceVersion
};
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client sends CREATE request with AppInstanceVersionHigh = {0}, AppInstanceVersionLow = {1}.", appInstanceVersion.AppInstanceVersionHigh, appInstanceVersion.AppInstanceVersionLow);
}
else
{
clientCreateContexts =
new Smb2CreateContextRequest[] {
new Smb2CreateAppInstanceId
{
AppInstanceId = appInstanceId
}
};
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client sends CREATE request without AppInstanceVersion.");
}
client.Create(
treeId,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId,
out serverCreateContexts,
RequestedOplockLevel_Values.OPLOCK_LEVEL_NONE,
clientCreateContexts,
shareAccess: ShareAccess_Values.NONE,
checker: (header, response) =>
{
BaseTestSite.Assert.AreEqual(
expectedCreateResponseStatus,
header.Status,
(expectedCreateResponseStatus == Smb2Status.STATUS_SUCCESS ?
"The open will be closed. Create should succeed. Actually server returns with {0}."
: "The open cannot be closed. Create should not succeed. Actually server returns with {0}."),
Smb2Status.GetStatusCode(header.Status));
});
#endregion
}
private void SendCreateRequestWithSpecificAppInstanceversion(
Smb2FunctionalClient client,
Guid appInstanceId,
ulong? appInstanceVersionHigh,
ulong? appInstanceVersionLow,
DialectRevision dialect,
uint expectedCreateResponseStatus,
out uint treeId,
out FILEID fileId
)
{
#region Client connects to Server
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client connects to the file server by sending the following requests: NEGOTIATE; SESSION_SETUP; TREE_CONNECT");
client.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress, TestConfig.ClientNic1IPAddress);
client.Negotiate(Smb2Utility.GetDialects(dialect), TestConfig.IsSMB1NegotiateEnabled);
client.SessionSetup(
TestConfig.DefaultSecurityPackage,
TestConfig.SutComputerName,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken);
client.TreeConnect(uncSharePath, out treeId);
Smb2CreateContextResponse[] serverCreateContexts;
Smb2CreateAppInstanceVersion appInstanceVersion = new Smb2CreateAppInstanceVersion();
Smb2CreateContextRequest[] clientCreateContexts;
if (appInstanceVersionHigh.HasValue && appInstanceVersionLow.HasValue)
{
appInstanceVersion.AppInstanceVersionHigh = appInstanceVersionHigh.Value;
appInstanceVersion.AppInstanceVersionLow = appInstanceVersionLow.Value;
clientCreateContexts =
new Smb2CreateContextRequest[] {
new Smb2CreateAppInstanceId
{
AppInstanceId = appInstanceId
},
appInstanceVersion
};
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client sends CREATE request with AppInstanceVersionHigh = {0}, AppInstanceVersionLow = {1}.", appInstanceVersion.AppInstanceVersionHigh, appInstanceVersion.AppInstanceVersionLow);
}
else
{
clientCreateContexts =
new Smb2CreateContextRequest[] {
new Smb2CreateAppInstanceId
{
AppInstanceId = appInstanceId
}
};
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client sends CREATE request without AppInstanceVersion.");
}
client.Create(
treeId,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId,
out serverCreateContexts,
RequestedOplockLevel_Values.OPLOCK_LEVEL_NONE,
clientCreateContexts,
shareAccess: ShareAccess_Values.NONE,
checker: (header, response) =>
{
BaseTestSite.Assert.AreEqual(
expectedCreateResponseStatus,
header.Status,
(expectedCreateResponseStatus == Smb2Status.STATUS_SUCCESS ?
"The open will be closed. Create should succeed. Actually server returns with {0}."
: "The open cannot be closed. Create should not succeed. Actually server returns with {0}."),
Smb2Status.GetStatusCode(header.Status));
});
#endregion
}
private void WriteFromMainChannel(
DialectRevision[] requestDialect,
DialectRevision expectedDialect,
IPAddress serverIp,
IPAddress clientIp,
string contentWrite,
bool isNicRedundantOnServer,
out uint treeId,
out FILEID fileId)
{
mainChannelClient.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, serverIp, clientIp);
#region Negotiate
mainChannelClient.Negotiate(
requestDialect,
TestConfig.IsSMB1NegotiateEnabled,
capabilityValue: Capabilities_Values.GLOBAL_CAP_DFS | Capabilities_Values.GLOBAL_CAP_DIRECTORY_LEASING | Capabilities_Values.GLOBAL_CAP_LARGE_MTU | Capabilities_Values.GLOBAL_CAP_LEASING | Capabilities_Values.GLOBAL_CAP_MULTI_CHANNEL | Capabilities_Values.GLOBAL_CAP_PERSISTENT_HANDLES,
clientGuid: clientGuid,
checker: (Packet_Header header, NEGOTIATE_Response response) =>
{
BaseTestSite.Assert.AreEqual(
Smb2Status.STATUS_SUCCESS,
header.Status,
"Negotiation should succeed, actually server returns {0}.", Smb2Status.GetStatusCode(header.Status));
TestConfig.CheckNegotiateDialect(expectedDialect, response);
if (Smb2Utility.IsSmb3xFamily(expectedDialect))
{
TestConfig.CheckNegotiateCapabilities(NEGOTIATE_Response_Capabilities_Values.GLOBAL_CAP_MULTI_CHANNEL, response);
}
});
#endregion
#region SESSION_SETUP
mainChannelClient.SessionSetup(
TestConfig.DefaultSecurityPackage,
TestConfig.SutComputerName,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken);
#endregion
#region Retrieve 2nd IP on server for alternative channel if there is
if (TestConfig.UnderlyingTransport == Smb2TransportType.Tcp &&
isNicRedundantOnServer &&
TestConfig.IsIoCtlCodeSupported(CtlCode_Values.FSCTL_QUERY_NETWORK_INTERFACE_INFO))
{
#region TREE_CONNECT to IPC$
string ipcPath = Smb2Utility.GetIPCPath(TestConfig.SutComputerName);
mainChannelClient.TreeConnect(ipcPath, out treeId);
#endregion
#region IOCTL FSCTL_QUERY_NETWORK_INTERFACE_INFO
NETWORK_INTERFACE_INFO_Response[] networkInfoResponses;
string interfaceAddress;
bool secondAddressQueried = false;
mainChannelClient.QueryNetworkInterfaceInfo(treeId, out networkInfoResponses);
foreach (NETWORK_INTERFACE_INFO_Response netInfoResp in networkInfoResponses)
{
interfaceAddress = netInfoResp.AddressStorage.Address;
if (interfaceAddress != null)
{
BaseTestSite.Log.Add(LogEntryKind.Debug, "Get NETWORK_INTERFACE_INFO: " + interfaceAddress);
if (interfaceAddress == serverIps[1].ToString())
{
secondAddressQueried = true;
BaseTestSite.Log.Add(LogEntryKind.Debug, "Address queried by IOCTL request with FSCTL_QUERY_NETWORK_INTERFACE_INFO matches server second address {0}", serverIps[1].ToString());
break;
}
}
}
BaseTestSite.Assert.IsTrue(
secondAddressQueried,
"Second address {0} should be queried by IOCTL request with FSCTL_QUERY_NETWORK_INTERFACE_INFO", serverIps[1].ToString());
#endregion
}
#endregion
#region TREE_CONNECT to share
string uncSharePath = Smb2Utility.GetUncPath(TestConfig.SutComputerName, TestConfig.BasicFileShare);
mainChannelClient.TreeConnect(uncSharePath, out treeId);
#endregion
#region CREATE
Smb2CreateContextResponse[] serverCreateContexts;
mainChannelClient.Create(
treeId,
GetTestFileName(uncSharePath),
CreateOptions_Values.FILE_NON_DIRECTORY_FILE | CreateOptions_Values.FILE_DELETE_ON_CLOSE,
out fileId,
out serverCreateContexts);
#endregion
if (Smb2Utility.IsSmb3xFamily(expectedDialect))
{
#region WRITE
mainChannelClient.Write(treeId, fileId, contentWrite);
#endregion
}
}
