/// <summary> /// Transform the RESPONSE_MESSAGE to a byte array /// </summary> /// <param name="responseMessage">The RESPONSE_MESSAGE message</param> /// <returns>The result array</returns> public static byte[] EncodeResponseMessage(RESPONSE_MESSAGE responseMessage) { List<byte> list = new List<byte>(); list.AddRange(GetBytesFromUint32(responseMessage.TransportHeader.Size, false)); list.Add((byte)responseMessage.ResponseCode); return list.ToArray(); }
/// <summary> /// Transform the RESPONSE_MESSAGE to a byte array /// </summary> /// <param name="responseMessage">The RESPONSE_MESSAGE message</param> /// <returns>The result array</returns> public static byte[] EncodeResponseMessage(RESPONSE_MESSAGE responseMessage) { List <byte> list = new List <byte>(); list.AddRange(GetBytesFromUint32(responseMessage.TransportHeader.Size, false)); list.Add((byte)responseMessage.ResponseCode); return(list.ToArray()); }
/// <summary> /// Convert the responsemessage struct defined in adapter to stack /// </summary> /// <param name="responseMessageStack">The response message of send initialInfoMeaage or segmentInfoMessage</param> /// <returns>Return the ResponseMessage type defined in adapter</returns> public static ResponseMessage ConvertFromStackForResponseMsg(RESPONSE_MESSAGE responseMessageStack) { ResponseMessage responseMessage; responseMessage.ResponseCode = ConvertFromStackForResponseCode(responseMessageStack.ResponseCode); responseMessage.TransportHeader = ConvertFromStackForTransHeader(responseMessageStack.TransportHeader); return responseMessage; }
/// <summary> /// Send Reponse Message to the client. /// </summary> /// <param name="responseMessage">The response message.</param> public void SendPackage(RESPONSE_MESSAGE responseMessage) { this.SendByte(EncodeMessage.EncodeResponseMessage(responseMessage)); if (this.logger != null) { this.logger.AddDebug("Pchc response message is sent successfully."); } }
/// <summary> /// Send the BATCHED_OFFER_MESSAGE request. /// </summary> /// <param name="batchedOfferMessage">The BATCHED_OFFER_MESSAGE message.</param> /// <returns>The repsonse message RESPONSE_MESSAGE from the hosted cache.</returns> public RESPONSE_MESSAGE SendBatchedOfferMessage(BATCHED_OFFER_MESSAGE batchedOfferMessage) { List <byte> buffer = new List <byte>(); buffer.AddRange(TypeMarshal.ToBytes(batchedOfferMessage.MessageHeader)); buffer.AddRange(TypeMarshal.ToBytes(batchedOfferMessage.ConnectionInfo)); for (int i = 0; i < batchedOfferMessage.SegmentDescriptors.Length; i++) { buffer.AddRange(TypeMarshal.ToBytes(batchedOfferMessage.SegmentDescriptors[i])); } return(this.responseMessage = this.SendByte(buffer.ToArray())); }
/// <summary> /// Send the byte array of PCHC message using https transport . /// </summary> /// <param name="httpRequestPayload">The http request payload.</param> /// <returns>The pchc response message.</returns> private RESPONSE_MESSAGE SendByte(byte[] httpRequestPayload) { // Set the timeout of http. int timeout = 20000; byte[] payloadBuffer = null; HttpWebResponse httpWebResponse; this.httpClientTransport.Send(HttpVersion.Version10, null, httpRequestPayload, HttpMethod.POST, timeout); try { httpWebResponse = this.httpClientTransport.Receive(ref payloadBuffer); } catch (WebException e) { if (e.Message.Contains(HttpStatusCode.Unauthorized.ToString())) { throw new HttpStatusCode401Exception(); } else if (e.Message.ToLower().Contains("timed out".ToLower())) { throw new NoRESPONSEMESSAGEException(); } else { // Un expected exception is received. throw; } } this.httpResponseMethod = httpWebResponse.Method; this.httpResponseUri = httpWebResponse.ResponseUri; if (payloadBuffer == null) { throw new NoRESPONSEMESSAGEException(); } try { this.responseMessage = DecodeMessage.DecodeResponseMessage(payloadBuffer); } catch (ArgumentOutOfRangeException e) { throw new NoRESPONSEMESSAGEException(e.Message); } return(this.responseMessage); }
public void HostedCacheServer_PchcServer_InitialOffer_SegmentInfoRetrieved() { CheckApplicability(); Content_Information_Data_Structure contentInformation = contentInformationUtility.CreateContentInformationV1(); PCHCClient pchcClient = new PCHCClient( TransferProtocol.HTTPS, testConfig.HostedCacheServerComputerName, testConfig.HostedCacheServerHTTPSListenPort, PchcConsts.HttpsUrl, testConfig.DomainName, testConfig.UserName, testConfig.UserPassword); BaseTestSite.Log.Add( LogEntryKind.Debug, "Send initial offer message to hosted cache server"); INITIAL_OFFER_MESSAGE initialOfferMessage = pchcClient.CreateInitialOfferMessage( testConfig.ClientContentRetrievalListenPort, contentInformation.GetSegmentId(0)); pchcClient.SendInitialOfferMessage(initialOfferMessage); BaseTestSite.Log.Add( LogEntryKind.Debug, "Supply segment info to hosted cache server"); SEGMENT_INFO_MESSAGE segmentInfoMessage = pchcClient.CreateSegmentInfoMessage( testConfig.ClientContentRetrievalListenPort, contentInformation, 0); pchcClient.SendSegmentInfoMessage(segmentInfoMessage); Microsoft.Protocols.TestTools.StackSdk.BranchCache.Pchc.RESPONSE_MESSAGE responseMessage2 = pchcClient.SendInitialOfferMessage(initialOfferMessage); TestClassBase.BaseTestSite.Assert.AreEqual <RESPONSE_CODE>( RESPONSE_CODE.INTERESTED, responseMessage2.ResponseCode, @"The hosted cache MUST specify a response code of 0 if it already has block hash."); }
public void HostedCacheServer_BVT_CacheOfferingRetrieval_V1() { CheckApplicability(); EventQueue eventQueue = new EventQueue(BaseTestSite); eventQueue.Timeout = testConfig.Timeout; BaseTestSite.Log.Add( LogEntryKind.Debug, "Trigger hash generation on content server"); byte[] content = contentInformationUtility.RetrieveContentData(); Content_Information_Data_Structure contentInformation = PccrcUtility.ParseContentInformation(contentInformationUtility.RetrieveContentInformation(BranchCacheVersion.V1)); CryptoAlgoId_Values cryptoAlgoId = CryptoAlgoId_Values.AES_128; PccrrClient pccrrClient = new PccrrClient(testConfig.HostedCacheServerComputerName, testConfig.HostedCacheServerHTTPListenPort); for (int i = 0; i < contentInformation.cSegments; ++i) { var pccrrBlkListRequest = pccrrClient.CreateMsgGetBlkListRequest( contentInformation.GetSegmentId(i), new BLOCK_RANGE[] { new BLOCK_RANGE { Index = 0, Count = contentInformation.segments[i].BlockCount } }, cryptoAlgoId, MsgType_Values.MSG_GETBLKLIST); pccrrClient.SendPacket( pccrrBlkListRequest, testConfig.Timeout); var pccrrBlkListResponse = (PccrrBLKLISTResponsePacket)pccrrClient.ExpectPacket(); BaseTestSite.Assert.AreEqual <uint>( 0, pccrrBlkListResponse.MsgBLKLIST.BlockRangeCount, "The server MUST set the BlockRangeCount field to zero if it doesn't have the requested blocks data."); } BaseTestSite.Log.Add( LogEntryKind.Debug, "Retrieve content information from content server"); using (PccrrTestServerV1 pccrrTestServer = new PccrrTestServerV1()) { 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.HTTPS, testConfig.HostedCacheServerComputerName, testConfig.HostedCacheServerHTTPSListenPort, PchcConsts.HttpsUrl, testConfig.DomainName, testConfig.UserName, testConfig.UserPassword); for (int i = 0; i < contentInformation.cSegments; i++) { BaseTestSite.Log.Add( LogEntryKind.Debug, "Offer content segment {0} to hosted cache server", i); INITIAL_OFFER_MESSAGE initialOfferMessage = pchcClient.CreateInitialOfferMessage( testConfig.ClientContentRetrievalListenPort, contentInformation.GetSegmentId(i)); Microsoft.Protocols.TestTools.StackSdk.BranchCache.Pchc.RESPONSE_MESSAGE responseMessage = pchcClient.SendInitialOfferMessage(initialOfferMessage); TestClassBase.BaseTestSite.Assert.AreEqual <RESPONSE_CODE>( RESPONSE_CODE.INTERESTED, responseMessage.ResponseCode, @"The hosted cache MUST specify a response code of 1 if its list of block hashes associated with the segment is incomplete."); BaseTestSite.Log.Add( LogEntryKind.Debug, "Supply segment info to hosted cache server"); SEGMENT_INFO_MESSAGE segmentInfoMessage = pchcClient.CreateSegmentInfoMessage( testConfig.ClientContentRetrievalListenPort, contentInformation, i); responseMessage = pchcClient.SendSegmentInfoMessage(segmentInfoMessage); TestClassBase.BaseTestSite.Assert.AreEqual <RESPONSE_CODE>( RESPONSE_CODE.OK, responseMessage.ResponseCode, @"The hosted cache MUST send a response code of 0 when SEGMENT_INFO_MESSAGE request received"); BaseTestSite.Log.Add( LogEntryKind.Debug, "Make sure all blocks in segment {0} are retrieved by hosted cache server", i); 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 == contentInformation.segments[i].BlockCount); }, 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, "Negotiate PCCRR version"); var pccrrNegotiateRequest = pccrrClient.CreateMsgNegoRequest( new ProtoVersion { MajorVersion = 1, MinorVersion = 0 }, new ProtoVersion { MajorVersion = 1, MinorVersion = ushort.MaxValue }, 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"); } if (testConfig.SupportBranchCacheV2) { BaseTestSite.Assert.IsTrue( pccrrNegotiateResponse.MsgNegoResp.MinSupporteProtocolVersion.MajorVersion <= 2 && pccrrNegotiateResponse.MsgNegoResp.MaxSupporteProtocolVersion.MajorVersion >= 2, "SupportedProtocolVersion doesn't match configuration"); } Aes aes = PccrrUtitlity.CreateAes(cryptoAlgoId); for (int i = 0; i < contentInformation.cSegments; i++) { BaseTestSite.Log.Add( LogEntryKind.Debug, "Retrieve block list for segment {0}", i); var pccrrBlkListRequest = pccrrClient.CreateMsgGetBlkListRequest( contentInformation.GetSegmentId(i), new BLOCK_RANGE[] { new BLOCK_RANGE { Index = 0, Count = contentInformation.segments[i].BlockCount } }, cryptoAlgoId, MsgType_Values.MSG_GETBLKLIST); pccrrClient.SendPacket( pccrrBlkListRequest, testConfig.Timeout); var pccrrBlkListResponse = (PccrrBLKLISTResponsePacket)pccrrClient.ExpectPacket(); BaseTestSite.Assert.AreNotEqual <uint>( 0, pccrrBlkListResponse.MsgBLKLIST.BlockRangeCount, "The server MUST set the BlockRangeCount field to a value greater than zero if it has the requested blocks data."); for (int j = 0; j < contentInformation.segments[i].BlockCount; j++) { BaseTestSite.Log.Add( LogEntryKind.Debug, "Retrieve block {0} for segment {1}", j, i); PccrrGETBLKSRequestPacket pccrrBlkRequest = pccrrClient.CreateMsgGetBlksRequest( contentInformation.GetSegmentId(i), cryptoAlgoId, MsgType_Values.MSG_GETBLKS, (uint)j, 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.segments[i].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."); }
/// <summary> /// Send the byte array of PCHC message using https transport . /// </summary> /// <param name="httpRequestPayload">The http request payload.</param> /// <returns>The pchc response message.</returns> private RESPONSE_MESSAGE SendByte(byte[] httpRequestPayload) { // Set the timeout of http. int timeout = 20000; byte[] payloadBuffer = null; HttpWebResponse httpWebResponse; this.httpClientTransport.Send(HttpVersion.Version10, null, httpRequestPayload, HttpMethod.POST, timeout); try { httpWebResponse = this.httpClientTransport.Receive(ref payloadBuffer); } catch (WebException e) { if (e.Message.Contains(HttpStatusCode.Unauthorized.ToString())) { throw new HttpStatusCode401Exception(); } else if (e.Message.ToLower().Contains("timed out".ToLower())) { throw new NoRESPONSEMESSAGEException(); } else { // Un expected exception is received. throw; } } this.httpResponseMethod = httpWebResponse.Method; this.httpResponseUri = httpWebResponse.ResponseUri; if (payloadBuffer == null) { throw new NoRESPONSEMESSAGEException(); } try { this.responseMessage = DecodeMessage.DecodeResponseMessage(payloadBuffer); } catch (ArgumentOutOfRangeException e) { throw new NoRESPONSEMESSAGEException(e.Message); } return this.responseMessage; }
/// <summary> /// Send the SEGMENT_INFO_MESSAGE request. /// </summary> /// <param name="segmentInfoMessage">The SEGMENT_INFO_MESSAGE message.</param> /// <returns>The repsonse message RESPONSE_MESSAGE from the hosted cache.</returns> public RESPONSE_MESSAGE SendSegmentInfoMessage(SEGMENT_INFO_MESSAGE segmentInfoMessage) { return this.responseMessage = this.SendByte(EncodeMessage.EncodeSegmentInfoMessage(segmentInfoMessage)); }
/// <summary> /// Send the INITIAL_OFFER_MESSAGE request. /// </summary> /// <param name="initialOfferMessage">The INITIAL_OFFER_MESSAGE message.</param> /// <returns>The repsonse message RESPONSE_MESSAGE from the hosted cache.</returns> public RESPONSE_MESSAGE SendInitialOfferMessage(INITIAL_OFFER_MESSAGE initialOfferMessage) { return this.responseMessage = this.SendByte(EncodeMessage.EncodeInitialOfferMessage(initialOfferMessage)); }
/// <summary> /// Send the BATCHED_OFFER_MESSAGE request. /// </summary> /// <param name="batchedOfferMessage">The BATCHED_OFFER_MESSAGE message.</param> /// <returns>The repsonse message RESPONSE_MESSAGE from the hosted cache.</returns> public RESPONSE_MESSAGE SendBatchedOfferMessage(BATCHED_OFFER_MESSAGE batchedOfferMessage) { List<byte> buffer = new List<byte>(); buffer.AddRange(TypeMarshal.ToBytes(batchedOfferMessage.MessageHeader)); buffer.AddRange(TypeMarshal.ToBytes(batchedOfferMessage.ConnectionInfo)); for (int i = 0; i < batchedOfferMessage.SegmentDescriptors.Length; i++) { buffer.AddRange(TypeMarshal.ToBytes(batchedOfferMessage.SegmentDescriptors[i])); } return this.responseMessage = this.SendByte(buffer.ToArray()); }
/// <summary> /// Send the SEGMENT_INFO_MESSAGE request. /// </summary> /// <param name="segmentInfoMessage">The SEGMENT_INFO_MESSAGE message.</param> /// <returns>The repsonse message RESPONSE_MESSAGE from the hosted cache.</returns> public RESPONSE_MESSAGE SendSegmentInfoMessage(SEGMENT_INFO_MESSAGE segmentInfoMessage) { return(this.responseMessage = this.SendByte(EncodeMessage.EncodeSegmentInfoMessage(segmentInfoMessage))); }
/// <summary> /// Send the INITIAL_OFFER_MESSAGE request. /// </summary> /// <param name="initialOfferMessage">The INITIAL_OFFER_MESSAGE message.</param> /// <returns>The repsonse message RESPONSE_MESSAGE from the hosted cache.</returns> public RESPONSE_MESSAGE SendInitialOfferMessage(INITIAL_OFFER_MESSAGE initialOfferMessage) { return(this.responseMessage = this.SendByte(EncodeMessage.EncodeInitialOfferMessage(initialOfferMessage))); }
public void HostedCacheServer_PchcServer_InitialOffer_ContentRereieved() { CheckApplicability(); EventQueue eventQueue = new EventQueue(BaseTestSite); eventQueue.Timeout = testConfig.Timeout; Content_Information_Data_Structure contentInformation = contentInformationUtility.CreateContentInformationV1(); CryptoAlgoId_Values cryptoAlgoId = CryptoAlgoId_Values.AES_128; using (PccrrTestServerV1 pccrrTestServer = new PccrrTestServerV1()) { BaseTestSite.Log.Add( LogEntryKind.Debug, "Start PCCRR server to be ready to serve content to hosted cache server"); pccrrTestServer.Start( testConfig.ClientContentRetrievalListenPort, cryptoAlgoId, new ProtoVersion { MajorVersion = 1, MinorVersion = 0 }, contentInformation, TestUtility.GenerateRandomArray(ContentInformationUtility.DefaultBlockSize), eventQueue); PCHCClient pchcClient = new PCHCClient( TransferProtocol.HTTPS, testConfig.HostedCacheServerComputerName, testConfig.HostedCacheServerHTTPSListenPort, PchcConsts.HttpsUrl, testConfig.DomainName, testConfig.UserName, testConfig.UserPassword); BaseTestSite.Log.Add( LogEntryKind.Debug, "Send initial offer message to hosted cache server"); SEGMENT_INFO_MESSAGE segmentInfoMessage = pchcClient.CreateSegmentInfoMessage( testConfig.ClientContentRetrievalListenPort, contentInformation, 0); pchcClient.SendSegmentInfoMessage(segmentInfoMessage); BaseTestSite.Log.Add( LogEntryKind.Debug, "Make sure all blocks in segment 0 are retrieved by hosted cache server"); 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 == contentInformation.segments[0].BlockCount); }, 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); INITIAL_OFFER_MESSAGE initialOfferMessage = pchcClient.CreateInitialOfferMessage( testConfig.ClientContentRetrievalListenPort, contentInformation.GetSegmentId(0)); Microsoft.Protocols.TestTools.StackSdk.BranchCache.Pchc.RESPONSE_MESSAGE responseMessage2 = pchcClient.SendInitialOfferMessage(initialOfferMessage); TestClassBase.BaseTestSite.Assert.AreEqual <RESPONSE_CODE>( RESPONSE_CODE.INTERESTED, responseMessage2.ResponseCode, @"The hosted cache MUST specify a response code of 0 if it already has block data and block hash."); } }