protected override void TestInitialize()
{
base.TestInitialize();
sharePath = Smb2Utility.GetUncPath(testConfig.SutComputerName, testConfig.BasicFileShare);
fileName = GetTestFileName(sharePath);
}
public void DurableHandleV1_WithLeaseV1_WithoutHandleCaching()
{
/// 1. Client requests a durable handle with LeaseV1 context, SMB2_LEASE_HANDLE_CACHING bit is not set in LeaseState.
/// 2. Durable Handle is not granted.
#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_REQUEST_LEASE);
#endregion
string content = Smb2Utility.CreateRandomString(testConfig.WriteBufferLengthInKb);
durableHandleUncSharePath = Smb2Utility.GetUncPath(testConfig.SutComputerName, testConfig.BasicFileShare);
string fileName = GetTestFileName(durableHandleUncSharePath);
BaseTestSite.Log.Add(
LogEntryKind.Comment,
"Client connects to server and opens file with a durable handle, SMB2_LEASE_HANDLE_CACHING bit is not set in LeaseState.");
uint treeIdBeforeDisconnection;
Connect(DialectRevision.Smb21, clientBeforeDisconnection, clientGuid, testConfig.AccountCredential, ConnectShareType.BasicShareWithoutAssert, out treeIdBeforeDisconnection, null);
Guid leaseKey = Guid.NewGuid();
// SMB2_LEASE_HANDLE_CACHING bit is not set in LeaseState
LeaseStateValues leaseState = LeaseStateValues.SMB2_LEASE_READ_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));
// Durable Handle should not be granted.
CheckCreateContextResponsesNotExist(serverCreateContexts, new DefaultDurableHandleResponseChecker(BaseTestSite));
});
clientBeforeDisconnection.TreeDisconnect(treeIdBeforeDisconnection);
clientBeforeDisconnection.LogOff();
clientBeforeDisconnection.Disconnect();
}
public void TreeConnectRequest(SigningFlagType signingFlagType)
{
uint treeId;
SigningModelSessionId modelSessionId = SigningModelSessionId.ZeroSessionId;
SigningFlagType responseSigningFlagType = SigningFlagType.SignedFlagNotSet;
string sharePath = Smb2Utility.GetUncPath(testConfig.SutComputerName, testConfig.BasicFileShare);
Packet_Header_Flags_Values headerFlags = (signingFlagType == SigningFlagType.SignedFlagSet) ? Packet_Header_Flags_Values.FLAGS_SIGNED : Packet_Header_Flags_Values.NONE;
if (signingFlagType == SigningFlagType.SignedFlagNotSet)
{
// Inform SDK to disable signning.
testClient.EnableSessionSigningAndEncryption(enableSigning: false, enableEncryption: false);
}
uint status = testClient.TreeConnect(
headerFlags,
sharePath,
out treeId,
checker: (header, response) =>
{
modelSessionId = GetModelSessionId(header.SessionId);
responseSigningFlagType = GetSigningFlagType(header.Flags);
});
TreeConnectResponse((ModelSmb2Status)status, modelSessionId, responseSigningFlagType);
}
protected override void TestCleanup()
{
if (client != null)
{
try
{
client.Disconnect();
}
catch (Exception ex)
{
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Unexpected exception when disconnect client: {0}", ex.ToString());
}
}
if (fileName != null)
{
try
{
sutProtocolController.DeleteFile(Smb2Utility.GetUncPath(testConfig.SutComputerName, testConfig.BasicFileShare), fileName);
}
catch (Exception)
{
}
}
base.TestCleanup();
}
public override void Reset()
{
if (prepareClient != null)
{
prepareClient.Disconnect();
prepareClient = null;
}
try
{
sutProtocolController.DeleteFile(Smb2Utility.GetUncPath(testConfig.SutComputerName, testConfig.BasicFileShare), fileName);
if (cleanFileWithDifferentName)
{
sutProtocolController.DeleteFile(Smb2Utility.GetUncPath(testConfig.SutComputerName, testConfig.BasicFileShare), fileName + different);
}
if (cleanFileInDifferentShare)
{
sutProtocolController.DeleteFile(Smb2Utility.GetUncPath(testConfig.SutComputerName, testConfig.DifferentFromSMBBasic), fileName);
}
}
catch
{
}
cleanFileWithDifferentName = false;
cleanFileInDifferentShare = false;
base.Reset();
}
private void OpenFile(out uint treeId, out FILEID fileId)
{
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"Open the file by sending the following requests: NEGOTIATE; SESSION_SETUP; TREE_CONNECT; CREATE.");
client.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress);
client.Negotiate(
TestConfig.RequestDialects,
TestConfig.IsSMB1NegotiateEnabled,
checker: (Packet_Header header, NEGOTIATE_Response response) =>
{
BaseTestSite.Assert.AreEqual(
Smb2Status.STATUS_SUCCESS,
header.Status,
"Negotiate should succeed, actually server returns {0}.", Smb2Status.GetStatusCode(header.Status));
});
client.SessionSetup(
TestConfig.DefaultSecurityPackage,
TestConfig.SutComputerName,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken);
client.TreeConnect(Smb2Utility.GetUncPath(TestConfig.SutComputerName, TestConfig.BasicFileShare), out treeId);
Smb2CreateContextResponse[] serverCreateContexts;
client.Create(
treeId,
GetTestFileName(Smb2Utility.GetUncPath(TestConfig.SutComputerName, TestConfig.BasicFileShare)),
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId,
out serverCreateContexts);
}
public void PrepareOpen(
ModelDialectRevision dialect,
AppInstanceIdType appInstanceIdType,
CreateType createType)
{
// Connect, Negotiate, SessionSetup, TreeConnect
prepareClient = new Smb2FunctionalClient(testConfig.Timeout, testConfig, this.Site);
this.connection_ClientGuid = Guid.NewGuid();
clientDialect = dialect;
ConnectToShare(clientDialect, prepareClient, connection_ClientGuid, testConfig.BasicFileShare, out treeConnect_TreeId);
// Create
this.fileName = GetTestFileName(Smb2Utility.GetUncPath(testConfig.SutComputerName, testConfig.BasicFileShare));
Smb2CreateContextResponse[] createContextResponse;
prepareClient.Create(
this.treeConnect_TreeId,
this.fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out this.open_FileId,
out createContextResponse,
createContexts: CreateContexts(appInstanceIdType, createType, true),
shareAccess: ShareAccess_Values.NONE);
if (createType == CreateType.CreateDurableThenDisconnect)
{
prepareClient.Disconnect();
}
}
/// <summary>
/// The two client connects to the two IP addresses of scaleout file server
/// Negotiate, SessionSetup, TreeConnect
/// </summary>
private Smb2FunctionalClient InitializeClient(IPAddress ip, out uint treeId)
{
Smb2FunctionalClient client = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, this.Site);
client.ConnectToServerOverTCP(ip);
client.Negotiate(
Smb2Utility.GetDialects(DialectRevision.Smb21),
testConfig.IsSMB1NegotiateEnabled);
//client.SessionSetup(
// testConfig.DefaultSecurityPackage,
// //testConfig.ScaleOutFileServerName,
// testConfig.AccountCredential,
// testConfig.UseServerGssToken);
AccountCredential accountCredential = false ? TestConfig.NonAdminAccountCredential : TestConfig.AccountCredential;
client.SessionSetup(TestConfig.DefaultSecurityPackage, TestConfig.SutComputerName, accountCredential, false);
//client.TreeConnect(Smb2Utility.GetUncPath(testConfig.ScaleOutFileServerName, testConfig.CAShareName), out treeId);
//uint treeId_t;
string sharePath = Smb2Utility.GetUncPath(TestConfig.SutComputerName, TestConfig.BasicFileShare);
client.TreeConnect(sharePath, out treeId);
return(client);
}
public void Compound_Encrypt_UnrelatedRequests()
{
Compound_UnrelatedRequests(
firstFileName: GetTestFileName(Smb2Utility.GetUncPath(testConfig.SutComputerName, testConfig.BasicFileShare)),
secondFileName: GetTestFileName(Smb2Utility.GetUncPath(testConfig.SutComputerName, testConfig.BasicFileShare)),
isEncrypted: true);
}
protected override void TestInitialize()
{
base.TestInitialize();
client = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
client.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress);
sharePath = Smb2Utility.GetUncPath(testConfig.SutComputerName, testConfig.BasicFileShare);
}
public void BVT_Signing()
{
#region Check Applicability
TestConfig.CheckDialect(DialectRevision.Smb2002);
TestConfig.CheckSigning();
#endregion
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client sends NEGOTIATE request with NEGOTIATE_SIGNING_REQUIRED flag set.");
client.Negotiate(
TestConfig.RequestDialects,
TestConfig.IsSMB1NegotiateEnabled,
SecurityMode_Values.NEGOTIATE_SIGNING_REQUIRED);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client sends SESSION_SETUP request with NEGOTIATE_SIGNING_REQUIRED flag set.");
client.SessionSetup(
TestConfig.DefaultSecurityPackage,
TestConfig.SutComputerName,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken,
SESSION_SETUP_Request_SecurityMode_Values.NEGOTIATE_SIGNING_REQUIRED);
string uncSharepath = Smb2Utility.GetUncPath(TestConfig.SutComputerName, TestConfig.BasicFileShare);
uint treeId;
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client sends TREE_CONNECT request.");
client.TreeConnect(
uncSharepath,
out treeId);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Tear down the client by sending the following requests: TREE_DISCONNECT; LOG_OFF");
client.TreeDisconnect(treeId);
client.LogOff();
}
private void ConnectToShare(
Smb2FunctionalClient client,
Guid clientGuid,
out uint treeId)
{
client.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress);
// Negotiate
client.Negotiate(
TestConfig.RequestDialects,
TestConfig.IsSMB1NegotiateEnabled,
clientGuid: clientGuid,
checker: (Packet_Header header, NEGOTIATE_Response response) =>
{
BaseTestSite.Assert.AreEqual(
Smb2Status.STATUS_SUCCESS,
header.Status,
"CREATE should succeed.");
TestConfig.CheckNegotiateDialect(DialectRevision.Smb21, response);
});
// SMB2 SESSION SETUP
client.SessionSetup(
testConfig.DefaultSecurityPackage,
testConfig.SutComputerName,
testConfig.AccountCredential,
testConfig.UseServerGssToken);
// SMB2 Tree Connect
client.TreeConnect(
Smb2Utility.GetUncPath(testConfig.SutComputerName, testConfig.BasicFileShare),
out treeId);
}
public void DurableHandleV2_NoPersistenceGrantedOnNonCAShare()
{
/// 1. Client requests a durable handle V2 to a Non-CA share
/// 2. Expect the create response contains Smb2CreateDurableHandleResponseV2 context but no persistent flag is set.
#region Check Applicability
TestConfig.CheckDialect(DialectRevision.Smb30);
TestConfig.CheckCapabilities(NEGOTIATE_Response_Capabilities_Values.GLOBAL_CAP_LEASING);
TestConfig.CheckCreateContext(CreateContextTypeValue.SMB2_CREATE_DURABLE_HANDLE_REQUEST_V2, CreateContextTypeValue.SMB2_CREATE_DURABLE_HANDLE_RECONNECT_V2, CreateContextTypeValue.SMB2_CREATE_REQUEST_LEASE);
#endregion
durableHandleUncSharePath = Smb2Utility.GetUncPath(TestConfig.SutComputerName, TestConfig.BasicFileShare);
fileName = "DurableHandleV2_NoPersistenceGrantedOnNonCAShare" + Guid.NewGuid() + ".txt";
Guid clientGuid = Guid.NewGuid();
BaseTestSite.Log.Add(
LogEntryKind.Comment,
"Client connects to server and opens file with a durable handle");
#region client connect to server
uint treeIdBeforeDisconnection;
Connect(DialectRevision.Smb30, clientBeforeDisconnection, clientGuid, testConfig.AccountCredential, ConnectShareType.BasicShare, out treeIdBeforeDisconnection, null);
Smb2CreateContextResponse[] serverCreateContexts = null;
FILEID fileIdBeforeDisconnection;
Guid createGuid = Guid.NewGuid();
clientBeforeDisconnection.Create(
treeIdBeforeDisconnection,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileIdBeforeDisconnection,
out serverCreateContexts,
RequestedOplockLevel_Values.OPLOCK_LEVEL_NONE,
new Smb2CreateContextRequest[] {
new Smb2CreateDurableHandleRequestV2
{
CreateGuid = createGuid,
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));
});
BaseTestSite.Assert.AreEqual(
null,
serverCreateContexts,
"The server should ignore the create context when TreeConnect.Share.IsCA is FALSE.");
#endregion
clientBeforeDisconnection.Close(treeIdBeforeDisconnection, fileIdBeforeDisconnection);
clientBeforeDisconnection.TreeDisconnect(treeIdBeforeDisconnection);
clientBeforeDisconnection.LogOff();
}
// [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));
}
});
}
/// <summary>
/// Initialize the two clients. And register Oplock/Lease break notification event.
/// </summary>
public void Preparation()
{
oplockClient = InitializeClient(testConfig.SutIPAddress, out treeIdOplock);
oplockClient.Smb2Client.OplockBreakNotificationReceived += new Action <Packet_Header, OPLOCK_BREAK_Notification_Packet>(OnLeaseBreakNotificationReceived);
leaseClient = InitializeClient(testConfig.SutIPAddress, out treeIdLease);
leaseClient.Smb2Client.LeaseBreakNotificationReceived += new Action <Packet_Header, LEASE_BREAK_Notification_Packet>(OnLeaseBreakNotificationReceived);
fileName = GetTestFileName(Smb2Utility.GetUncPath(testConfig.SutComputerName, testConfig.BasicFileShare));
}
private bool CheckSMBDReadWrite(DialectRevision[] dialects, Channel_Values channel)
{
try
{
using (var client = new SMBDClient(DetectionInfo.ConnectionTimeout))
{
var config = DetectionInfo.SMBDClientCapability;
RdmaAdapterInfo rdmaAdapterInfo;
client.ConnectOverRDMA(DetectionInfo.DriverRdmaNICIPAddress, DetectionInfo.SUTRdmaNICIPAddress, DetectionInfo.SMBDPort, config.MaxReceiveSize, out rdmaAdapterInfo);
client.SMBDNegotiate(
config.CreditsRequested,
config.ReceiveCreditMax,
config.PreferredSendSize,
config.MaxReceiveSize,
config.MaxFragmentedSize
);
client.Smb2Negotiate(dialects);
client.Smb2SessionSetup(DetectionInfo.Authentication, DetectionInfo.DomainName, DetectionInfo.SUTName, DetectionInfo.UserName, DetectionInfo.Password);
string path = Smb2Utility.GetUncPath(DetectionInfo.SUTName, DetectionInfo.ShareFolder);
uint treeId;
client.Smb2TreeConnect(path, out treeId);
FILEID fileId;
client.CreateRandomFile(treeId, out fileId);
uint length = client.CalculateSMBDMaxReadWriteSize();
var buffer = Smb2Utility.CreateRandomByteArray((int)length);
client.SMBDWrite(treeId, fileId, channel, buffer, 0, DetectionInfo.Endian);
var readBuffer = new byte[length];
client.SMBDRead(treeId, fileId, channel, out readBuffer, 0, length, DetectionInfo.Endian);
if (!Enumerable.SequenceEqual(buffer, readBuffer))
{
throw new InvalidOperationException("The data is inconsistent for write and read!");
}
return(true);
}
}
catch (Exception ex)
{
DetectorUtil.WriteLog(String.Format("CheckSMBDReadWrite threw exception: {0}", ex));
return(false);
}
}
private bool AccessShare(string shareName)
{
string shareUncPath = Smb2Utility.GetUncPath(TestConfig.SutComputerName, shareName);
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Access the share {0} using account: {1}@{2}.", shareUncPath, azUser01Name, TestConfig.DomainName);
bool result = AccessShare(new AccountCredential(TestConfig.DomainName, azUser01Name, TestConfig.UserPassword), shareUncPath);
return(result);
}
protected override void TestInitialize()
{
base.TestInitialize();
client = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
fileName = "FileLevelTrim_" + Guid.NewGuid() + ".txt";
uncSharePath = Smb2Utility.GetUncPath(TestConfig.SutComputerName, TestConfig.BasicFileShare);
contentWrite = Smb2Utility.CreateRandomString(TestConfig.WriteBufferLengthInKb);
}
protected override void TestInitialize()
{
base.TestInitialize();
sharePath = Smb2Utility.GetUncPath(TestConfig.SutComputerName, TestConfig.BasicFileShare);
fileName = Path.Combine(CreateTestDirectory(sharePath), "Replay_" + Guid.NewGuid() + ".txt");
mainChannelClient = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
alternativeChannelClient = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
}
protected override void TestInitialize()
{
base.TestInitialize();
sharePath = Smb2Utility.GetUncPath(TestConfig.SutComputerName, TestConfig.BasicFileShare);
fileName = string.Format(@"{0}\Replay_{1}.txt", CreateTestDirectory(sharePath), Guid.NewGuid());
mainChannelClient = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
alternativeChannelClient = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
}
public void ResilientOpenScavengerTimer_ReconnectBeforeTimeout()
{
/// 1. Open Resilient Handle with specific timeout.
/// 2. Disconnect to start the Resilient Timer.
/// 3. Wait for specific timeout - 1 seconds.
/// 4. Reconnect the resilient handle and expect the result is success.
#region Check Applicability
TestConfig.CheckDialect(DialectRevision.Smb21);
TestConfig.CheckIOCTL(CtlCode_Values.FSCTL_LMR_REQUEST_RESILIENCY);
TestConfig.CheckCreateContext(CreateContextTypeValue.SMB2_CREATE_DURABLE_HANDLE_RECONNECT);
#endregion
Smb2FunctionalClient prepareClient = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
uint timeoutInSecond = testConfig.MaxResiliencyTimeoutInSecond / 2;
Guid clientGuid = Guid.NewGuid();
string fileName = GetTestFileName(Smb2Utility.GetUncPath(testConfig.SutComputerName, testConfig.BasicFileShare));
FILEID fileId;
// Open file & Resiliency request
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"Create resilient handle to file '{0}' and timeout is {1} seconds", fileName, timeoutInSecond);
OpenFileAndResilientRequest(
prepareClient,
clientGuid,
fileName,
timeoutInSecond * 1000, // convert second to millisecond
out fileId);
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"Disconnect the client to start the Resilient Open Scavenger Timer on server");
prepareClient.Disconnect();
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"Wait {0} seconds before Resilient Open Scavenger Timer expired.", timeoutInSecond - 1);
Thread.Sleep(TimeSpan.FromSeconds(timeoutInSecond - 1));
Smb2FunctionalClient reconnectClient = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
BaseTestSite.Log.Add(
LogEntryKind.TestStep,
"Re-establish Resilient Open, verify the returned status is STATUS_SUCCESS.");
ReconnectResilientHandle(
reconnectClient,
clientGuid,
fileName,
fileId,
NtStatus.STATUS_SUCCESS,
"Reconnect resilient handle should be successful.");
// clean
reconnectClient.Disconnect();
}
protected override void TestInitialize()
{
initializeAdapter();
testConfig = fsaAdapter.TestConfig;
sharePath = Smb2Utility.GetUncPath(testConfig.SutComputerName, fsaAdapter.ShareName);
client1 = new Smb2FunctionalClient(testConfig.Timeout, testConfig, BaseTestSite);
client2 = new Smb2FunctionalClient(testConfig.Timeout, testConfig, BaseTestSite);
client1.ConnectToServer(testConfig.UnderlyingTransport, testConfig.SutComputerName, testConfig.SutIPAddress);
client2.ConnectToServer(testConfig.UnderlyingTransport, testConfig.SutComputerName, testConfig.SutIPAddress);
}
protected override void TestInitialize()
{
base.TestInitialize();
fileName = "ResilientHandle_" + Guid.NewGuid() + ".txt";
sharePath = Smb2Utility.GetUncPath(testConfig.SutComputerName, testConfig.BasicFileShare);
clientBeforeDisconnection = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
clientAfterDisconnection = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
clientBeforeDisconnection.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress);
clientAfterDisconnection.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress);
}
private void ConnectToShare(Smb2FunctionalClient client, out uint treeId)
{
client.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress);
client.Negotiate(
TestConfig.RequestDialects,
TestConfig.IsSMB1NegotiateEnabled,
capabilityValue: Capabilities_Values.GLOBAL_CAP_ENCRYPTION); // To enable encryption later.
client.SessionSetup(TestConfig.DefaultSecurityPackage, TestConfig.SutComputerName, TestConfig.AccountCredential, false);
client.TreeConnect(Smb2Utility.GetUncPath(testConfig.SutComputerName, testConfig.BasicFileShare), out treeId);
}
private bool TryReadFile()
{
BaseTestSite.Log.Add(LogEntryKind.TestStep,
"Try read the file {0} using account: {1}@{2}.",
Smb2Utility.GetUncPath(TestConfig.SutComputerName, TestConfig.FilePermissionTestShare, tempFileName),
azUser01Name,
TestConfig.DomainName);
bool result = TryReadFile(client, new AccountCredential(TestConfig.DomainName, azUser01Name, TestConfig.UserPassword), FilePermissionTestShareUncPath, tempFileName);
return(result);
}
protected override void TestInitialize()
{
base.TestInitialize();
fileName = "OpLock" + Guid.NewGuid() + ".txt";
sharePath = Smb2Utility.GetUncPath(testConfig.SutComputerName, testConfig.BasicFileShare);
client1 = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
client2 = new Smb2FunctionalClient(TestConfig.Timeout, TestConfig, BaseTestSite);
client1.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress);
client2.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress);
OpLockNotificationReceived = new ManualResetEvent(false);
}
private void PrepareFileForTrimming(out uint treeId, out FILEID fileId)
{
#region Check Applicability
TestConfig.CheckDialect(DialectRevision.Smb30);
TestConfig.CheckIOCTL(CtlCode_Values.FSCTL_FILE_LEVEL_TRIM);
#endregion
string uncSharePath = Smb2Utility.GetUncPath(TestConfig.SutComputerName, TestConfig.BasicFileShare);
string fileName = GetTestFileName(uncSharePath);
string contentWrite = Smb2Utility.CreateRandomString(TestConfig.WriteBufferLengthInKb);
smb2Functionalclient.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.SutComputerName, TestConfig.SutIPAddress);
uint status = smb2Functionalclient.Negotiate(
TestConfig.RequestDialects,
TestConfig.IsSMB1NegotiateEnabled,
checker: (Packet_Header header, NEGOTIATE_Response response) =>
{
BaseTestSite.Assert.AreEqual(
Smb2Status.STATUS_SUCCESS,
header.Status,
"CREATE should succeed, actually server returns {0}.", Smb2Status.GetStatusCode(header.Status));
TestConfig.CheckNegotiateDialect(DialectRevision.Smb30, response);
});
status = smb2Functionalclient.SessionSetup(
TestConfig.DefaultSecurityPackage,
TestConfig.SutComputerName,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken);
status = smb2Functionalclient.TreeConnect(uncSharePath, out treeId);
Smb2CreateContextResponse[] serverCreateContexts;
status = smb2Functionalclient.Create(
treeId,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId,
out serverCreateContexts);
status = smb2Functionalclient.Write(treeId, fileId, contentWrite);
status = smb2Functionalclient.Close(treeId, fileId);
status = smb2Functionalclient.Create(
treeId,
fileName,
CreateOptions_Values.FILE_NON_DIRECTORY_FILE,
out fileId,
out serverCreateContexts);
}
private void ConnectToShare(Smb2FunctionalClient client, Guid clientGuid, string uncShareName, out uint treeId)
{
client.ConnectToServer(TestConfig.UnderlyingTransport, TestConfig.FileServerNameContainingSharedVHD, TestConfig.FileServerIPContainingSharedVHD);
client.Negotiate(
TestConfig.RequestDialects,
TestConfig.IsSMB1NegotiateEnabled,
SecurityMode_Values.NEGOTIATE_SIGNING_ENABLED,
Capabilities_Values.GLOBAL_CAP_PERSISTENT_HANDLES,
clientGuid);
client.SessionSetup(TestConfig.DefaultSecurityPackage, TestConfig.SutComputerName, TestConfig.AccountCredential, false);
client.TreeConnect(Smb2Utility.GetUncPath(TestConfig.FileServerNameContainingSharedVHD, TestConfig.ShareContainingSharedVHD), out treeId);
}
public void Signing_VerifyAesGmacSigning()
{
#region Check Applicability
TestConfig.CheckDialect(DialectRevision.Smb311);
TestConfig.CheckSigning();
#endregion
var signingAlgorithms = new SigningAlgorithm[] { SigningAlgorithm.AES_GMAC };
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client sends NEGOTIATE with the Aes-GMAC signing algorithm and NEGOTIATE_SIGNING_REQUIRED.");
client.NegotiateWithContexts(
Packet_Header_Flags_Values.NONE,
Smb2Utility.GetDialects(DialectRevision.Smb311),
SecurityMode_Values.NEGOTIATE_SIGNING_REQUIRED,
preauthHashAlgs: new PreauthIntegrityHashID[] { PreauthIntegrityHashID.SHA_512 },
compressionFlags: SMB2_COMPRESSION_CAPABILITIES_Flags.SMB2_COMPRESSION_CAPABILITIES_FLAG_NONE,
signingAlgorithms: signingAlgorithms,
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.");
});
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Client sends SESSION_SETUP request and expects response.");
client.SessionSetup(
TestConfig.DefaultSecurityPackage,
TestConfig.SutComputerName,
TestConfig.AccountCredential,
TestConfig.UseServerGssToken,
SESSION_SETUP_Request_SecurityMode_Values.NEGOTIATE_SIGNING_ENABLED);
string uncSharepath =
Smb2Utility.GetUncPath(TestConfig.SutComputerName, 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));
BaseTestSite.Assert.AreEqual(
Packet_Header_Flags_Values.FLAGS_SIGNED,
Packet_Header_Flags_Values.FLAGS_SIGNED & header.Flags,
"Server should set SMB2_FLAGS_SIGNED bit in the Flags field of the SMB2 header");
});
BaseTestSite.Log.Add(LogEntryKind.TestStep, "Tear down the client by sending the following requests: TREE_DISCONNECT; LOG_OFF");
client.TreeDisconnect(treeId);
client.LogOff();
}
public void FileServerFailover_FileLeasing()
{
uncSharePath = Smb2Utility.GetUncPath(TestConfig.ClusteredFileServerName, TestConfig.ClusteredFileShare);
// Add expected NewLeaseState
expectedNewLeaseState = LeaseStateValues.SMB2_LEASE_READ_CACHING;
FileServerFailoverWithLeasing(
false,
LeaseStateValues.SMB2_LEASE_READ_CACHING | LeaseStateValues.SMB2_LEASE_HANDLE_CACHING,
AccessMask.GENERIC_READ,
AccessMask.GENERIC_WRITE);
}
