public void HostedCacheServer_BVT_CacheOfferingRetrieval_V2()
{
CheckApplicability();
EventQueue eventQueue = new EventQueue(BaseTestSite);
eventQueue.Timeout = testConfig.Timeout;
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Retrieve the original content data from content server");
byte[] content = contentInformationUtility.RetrieveContentData();
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Retrieve the content information from content server");
Content_Information_Data_Structure_V2 contentInformation =
PccrcUtility.ParseContentInformationV2(contentInformationUtility.RetrieveContentInformation(BranchCacheVersion.V2));
CryptoAlgoId_Values cryptoAlgoId = CryptoAlgoId_Values.AES_128;
PccrrClient pccrrClient = new PccrrClient(testConfig.HostedCacheServerComputerName, testConfig.HostedCacheServerHTTPListenPort);
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Send PCCRR GetSegList request to HostedCacheServer to make sure that this file does not exist in HostedCacheServer.");
for (int i = 0; i < contentInformation.chunks.Length; ++i)
{
var chunk = contentInformation.chunks[i];
for (int j = 0; j < chunk.chunkData.Length; j++)
{
var pccrrGetSegListRequest = pccrrClient.CreateMsgGetSegListRequest(
cryptoAlgoId,
Guid.NewGuid(),
new byte[][] { contentInformation.GetSegmentId(i, j) });
pccrrClient.SendPacket(
pccrrGetSegListRequest,
testConfig.Timeout);
var pccrrGetSegListResponse
= (PccrrSegListResponsePacket)pccrrClient.ExpectPacket();
BaseTestSite.Assert.AreEqual<uint>(
0,
pccrrGetSegListResponse.MsgSegList.SegmentRangeCount,
"The server MUST set the SegmentRangeCount field to zero if it doesn't have the requested segments data.");
}
}
using (PccrrTestServerV2 pccrrTestServer = new PccrrTestServerV2())
{
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Start PCCRR server to be ready to serve content to hosted cache server");
pccrrTestServer.Start(
testConfig.ClientContentRetrievalListenPort,
cryptoAlgoId,
contentInformation,
content,
eventQueue);
PCHCClient pchcClient = new PCHCClient(
TransferProtocol.HTTP,
testConfig.HostedCacheServerComputerName,
testConfig.ContentServerHTTPListenPort,
PchcConsts.HttpUrl,
testConfig.DomainName,
testConfig.UserName,
testConfig.UserPassword);
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Offer all content segments to hosted cache server");
var batchedOfferMessage = pchcClient.CreateBatchedOfferMessage(
testConfig.ClientContentRetrievalListenPort,
contentInformation);
var responseMessage = pchcClient.SendBatchedOfferMessage(batchedOfferMessage);
TestClassBase.BaseTestSite.Assert.AreEqual<RESPONSE_CODE>(
RESPONSE_CODE.OK,
responseMessage.ResponseCode,
@"The hosted cache MUST send a response code of 0 when BATCHED_OFFER_MESSAGE request received");
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Make sure all segments are retrieved by hosted cache server");
int totalBlockCount = contentInformation.GetBlockCount();
int blockCount = 0;
TestUtility.DoUntilSucceed(delegate()
{
eventQueue.Expect<MessageArrivedEventArgs>(typeof(PccrrServer).GetEvent("MessageArrived"), delegate(System.Net.IPEndPoint sender, PccrrPacket pccrrPacket)
{
var pccrrGetBlksRequest = pccrrPacket as PccrrGETBLKSRequestPacket;
if (pccrrGetBlksRequest != null)
{
blockCount++;
}
});
return blockCount == totalBlockCount;
}, TimeSpan.MaxValue, TimeSpan.Zero);
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Wait until cache is available on hosted cache server");
TestUtility.DoUntilSucceed(() => sutControlAdapter.IsLocalCacheExisted(testConfig.HostedCacheServerComputerFQDNOrNetBiosName), testConfig.Timeout, testConfig.RetryInterval);
}
List<byte> retrievedContent = new List<byte>();
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Start PCCRR client to retrieve all the content from hosted cache server");
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Negotiate PCCRR version");
var pccrrNegotiateRequest = pccrrClient.CreateMsgNegoRequest(
///[MS-PCCRR]Section 2.2.3: ProtVer: Both the Major and Minor version number can express the version range of 0x0000 to 0xFFFF. Currently, the protocol
///version number MUST be set to {major = 1 (0x0001), minor = 0 (0x0000)}.
///Active TDI#69240: Windows server 2012 Standard RTM sets the major version to 2
new ProtoVersion { MajorVersion = 1, MinorVersion = 0 }, //MinSupportedProtocolVersion
new ProtoVersion { MajorVersion = 1, MinorVersion = 0 }, //MaxSupportedProtocolVersion
cryptoAlgoId,
MsgType_Values.MSG_NEGO_REQ);
pccrrClient.SendPacket(
pccrrNegotiateRequest,
testConfig.Timeout);
var pccrrNegotiateResponse
= (PccrrNegoResponsePacket)pccrrClient.ExpectPacket();
if (testConfig.SupportBranchCacheV1)
{
BaseTestSite.Assert.IsTrue(
pccrrNegotiateResponse.MsgNegoResp.MinSupporteProtocolVersion.MajorVersion <= 1 &&
pccrrNegotiateResponse.MsgNegoResp.MaxSupporteProtocolVersion.MajorVersion >= 1,
"SupportedProtocolVersion doesn't match configuration");
}
Aes aes = PccrrUtitlity.CreateAes(cryptoAlgoId);
for (int i = 0; i < contentInformation.chunks.Length; i++)
{
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Retrieve all segments in chunk {0}",
i);
var chunk = contentInformation.chunks[i];
for (int j = 0; j < chunk.chunkData.Length; j++)
{
// Retrieve segment list
var pccrrGetSegListRequest = pccrrClient.CreateMsgGetSegListRequest(
cryptoAlgoId,
Guid.NewGuid(),
new byte[][] { contentInformation.GetSegmentId(i, j) });
pccrrClient.SendPacket(
pccrrGetSegListRequest,
testConfig.Timeout);
var pccrrGetSegListResponse
= (PccrrSegListResponsePacket)pccrrClient.ExpectPacket();
BaseTestSite.Assert.AreNotEqual<uint>(
0,
pccrrGetSegListResponse.MsgSegList.SegmentRangeCount,
"The server MUST set the SegmentRangeCount field to a value greater than zero if it has the requested segments data.");
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Retrieve segment {0} in chunk {1}",
j,
i);
PccrrGETBLKSRequestPacket pccrrBlkRequest = pccrrClient.CreateMsgGetBlksRequest(
contentInformation.GetSegmentId(i, j),
cryptoAlgoId,
MsgType_Values.MSG_GETBLKS,
0,
1);
pccrrClient.SendPacket(
pccrrBlkRequest,
testConfig.Timeout);
PccrrBLKResponsePacket pccrrBlkResponse
= (PccrrBLKResponsePacket)pccrrClient.ExpectPacket();
BaseTestSite.Assert.AreNotEqual<uint>(
0,
pccrrBlkResponse.MsgBLK.SizeOfBlock,
"The server MUST set the SizeOfBlock field to a value greater than zero if it has the requested blocks data.");
byte[] block = pccrrBlkResponse.MsgBLK.Block;
if (cryptoAlgoId != CryptoAlgoId_Values.NoEncryption)
block = PccrrUtitlity.Decrypt(aes, block, contentInformation.chunks[i].chunkData[j].SegmentSecret, pccrrBlkResponse.MsgBLK.IVBlock);
retrievedContent.AddRange(block);
}
}
BaseTestSite.Assert.IsTrue(
Enumerable.SequenceEqual(content, retrievedContent),
"The retrieved cached data should be the same as server data.");
}
public void HostedCacheServer_PchcServer_BatchedOffer_ContentRetrieved()
{
CheckApplicability();
EventQueue eventQueue = new EventQueue(BaseTestSite);
eventQueue.Timeout = testConfig.Timeout;
byte[] content = TestUtility.GenerateRandomArray(ContentInformationUtility.DefaultBlockSize);
Content_Information_Data_Structure_V2 contentInformationV2 = contentInformationUtility.CreateContentInformationV2();
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Start PCCRR server to be ready to serve content to hosted cache server");
using (PccrrTestServerV2 pccrrTestServerV2 = new PccrrTestServerV2())
{
pccrrTestServerV2.Start(
testConfig.ClientContentRetrievalListenPort,
CryptoAlgoId_Values.AES_128,
contentInformationV2,
content,
eventQueue);
PCHCClient pchcClient = new PCHCClient(
TransferProtocol.HTTP,
testConfig.HostedCacheServerComputerName,
testConfig.HostedCacheServerHTTPListenPort,
PchcConsts.HttpUrl,
testConfig.DomainName,
testConfig.UserName,
testConfig.UserPassword);
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Directly Supply segment info to hosted cache server");
var batchedOfferMessage = pchcClient.CreateBatchedOfferMessage(
testConfig.ClientContentRetrievalListenPort,
contentInformationV2);
pchcClient.SendBatchedOfferMessage(batchedOfferMessage);
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Make sure all the segments in chunk 0 is retrieved by hosted cache server");
int blockCount = 0;
int totalBlockCount = contentInformationV2.GetBlockCount();
TestUtility.DoUntilSucceed(delegate()
{
eventQueue.Expect<MessageArrivedEventArgs>(typeof(PccrrServer).GetEvent("MessageArrived"), delegate(System.Net.IPEndPoint sender, PccrrPacket pccrrPacket)
{
var pccrrGetBlksRequest = pccrrPacket as PccrrGETBLKSRequestPacket;
if (pccrrGetBlksRequest != null)
{
blockCount++;
}
});
return blockCount == totalBlockCount;
}, TimeSpan.MaxValue, TimeSpan.Zero);
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Wait until cache is available on hosted cache server");
TestUtility.DoUntilSucceed(() => sutControlAdapter.IsLocalCacheExisted(testConfig.HostedCacheServerComputerFQDNOrNetBiosName), testConfig.Timeout, testConfig.RetryInterval);
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Re-supply segment info to hosted cache server");
var batchedOfferResponse = pchcClient.SendBatchedOfferMessage(batchedOfferMessage);
BaseTestSite.Assert.AreEqual(
RESPONSE_CODE.OK,
batchedOfferResponse.ResponseCode,
"Hosted cache server should return OK to batched offer message");
}
}
public void HostedCacheServer_PccrrServer_MessageHeader_CryptoAlgoIdV2(CryptoAlgoId_Values algoId)
{
CheckApplicability();
EventQueue eventQueue = new EventQueue(BaseTestSite);
eventQueue.Timeout = testConfig.Timeout;
byte[] content = TestUtility.GenerateRandomArray(ContentInformationUtility.DefaultBlockSize);
Content_Information_Data_Structure_V2 contentInformationV2 = contentInformationUtility.CreateContentInformationV2();
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Start PCCRR server to be ready to serve content to hosted cache server");
using (PccrrTestServerV2 pccrrTestServerV2 = new PccrrTestServerV2())
{
pccrrTestServerV2.Start(
testConfig.ClientContentRetrievalListenPort,
algoId,
contentInformationV2,
content,
eventQueue);
PCHCClient pchcClient = new PCHCClient(
TransferProtocol.HTTP,
testConfig.HostedCacheServerComputerName,
testConfig.HostedCacheServerHTTPListenPort,
PchcConsts.HttpUrl,
testConfig.DomainName,
testConfig.UserName,
testConfig.UserPassword);
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Directly Supply segment info to hosted cache server");
var batchedOfferMessage = pchcClient.CreateBatchedOfferMessage(
testConfig.ClientContentRetrievalListenPort,
contentInformationV2);
pchcClient.SendBatchedOfferMessage(batchedOfferMessage);
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Make sure segment 0 in chunk 0 is retrieved by hosted cache server");
int segmentCount = 0;
TestUtility.DoUntilSucceed(delegate()
{
eventQueue.Expect<MessageArrivedEventArgs>(typeof(PccrrServer).GetEvent("MessageArrived"), delegate(System.Net.IPEndPoint sender, PccrrPacket pccrrPacket)
{
var pccrrGetBlksRequest = pccrrPacket as PccrrGETBLKSRequestPacket;
if (pccrrGetBlksRequest != null)
{
segmentCount++;
}
});
return segmentCount == 1;
}, TimeSpan.MaxValue, TimeSpan.Zero);
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Wait until cache is available on hosted cache server");
TestUtility.DoUntilSucceed(() => sutControlAdapter.IsLocalCacheExisted(testConfig.HostedCacheServerComputerFQDNOrNetBiosName), testConfig.Timeout, testConfig.RetryInterval);
}
PccrrClient pccrrClient = new PccrrClient(testConfig.HostedCacheServerComputerName, testConfig.HostedCacheServerHTTPListenPort);
Aes aes = PccrrUtitlity.CreateAes(algoId);
BaseTestSite.Log.Add(
LogEntryKind.Debug,
"Retrieve block 0 in segment 0 from hosted cache server");
PccrrGETBLKSRequestPacket pccrrBlkRequest = pccrrClient.CreateMsgGetBlksRequest(
contentInformationV2.GetSegmentId(0,0),
algoId,
MsgType_Values.MSG_GETBLKS,
(uint)0,
1);
pccrrClient.SendPacket(
pccrrBlkRequest,
testConfig.Timeout);
PccrrBLKResponsePacket pccrrBlkResponse
= (PccrrBLKResponsePacket)pccrrClient.ExpectPacket();
byte[] data = pccrrBlkResponse.MsgBLK.Block;
if (algoId != CryptoAlgoId_Values.NoEncryption)
data = PccrrUtitlity.Decrypt(aes, data, contentInformationV2.chunks[0].chunkData[0].SegmentSecret, pccrrBlkResponse.MsgBLK.IVBlock);
BaseTestSite.Assert.IsTrue(
Enumerable.SequenceEqual(content.Take((int)contentInformationV2.chunks[0].chunkData[0].cbSegment), data),
"The retrieved cached data should be the same as server data.");
}
