/// <summary>
/// Send message MSG_NEGO_REQ
/// </summary>
public void SendMsgNegoReq()
{
PccrrNegoRequestPacket packet = this.pccrrStack.CreateMsgNegoRequest(this.minSupV, this.maxSupV, this.cryptoAlgo, MsgType_Values.MSG_NEGO_REQ, this.protoVer);
this.pccrrStack.SendPacket(packet, new TimeSpan(0, 0, this.timeout));
PccrrPacket respMSG = this.pccrrStack.ExpectPacket();
PccrrNegoResponsePacket pccrrNegoResponsePacket = respMSG as PccrrNegoResponsePacket;
MSG_NEGO_RESP msgNegoResp = pccrrNegoResponsePacket.MsgNegoResp;
MESSAGE_HEADER messageHeader = pccrrNegoResponsePacket.MessageHeader;
TRANSPORT_RESPONSE_HEADER transportRespH = pccrrNegoResponsePacket.TransportResponseHeader;
RESPONSE_MESSAGE respMessage = new RESPONSE_MESSAGE();
respMessage.MESSAGEBODY = msgNegoResp;
respMessage.MESSAGEHEADER = messageHeader;
respMessage.TRANSPORTRESPONSEHEADER = transportRespH;
this.uiPayload = Marshal.SizeOf(messageHeader) + Marshal.SizeOf(msgNegoResp);
this.VerifyHttpResponse();
PccrrBothRoleCaptureCode.CaptureHttpRequirements();
this.VerifyMsgNegoResp(msgNegoResp);
this.VerifyMessageHeader(messageHeader);
PccrrBothRoleCaptureCode.CaptureMessageHeaderRequirements(messageHeader, this.uiPayload);
this.VerifyTransportResponseHeader(transportRespH);
PccrrBothRoleCaptureCode.CaptureMessageRequirements();
this.VerifyResponseMessage(respMessage);
this.ReceiveMsgNegoResp();
}
private void DataProcessing(byte[] byteMsg)
{
try
{
msgheader = (MESSAGE_HEADER)sock.RawDeserialize(byteMsg, typeof(MESSAGE_HEADER));
int Tcode = Convert.ToInt32(IPAddress.NetworkToHostOrder(msgheader.TransactionCode));
int msgLen = Convert.ToInt32(IPAddress.NetworkToHostOrder(msgheader.MessageLength));
// File.AppendAllText(Environment.CurrentDirectory + Path.DirectorySeparatorChar + "testData.txt", Tcode.ToString() +"_"+ "\n");
switch (Tcode)
{
case 7207:
DataProcessing_7207(byteMsg);
break;
case 7208:
//DataProcessing_7208(byteMsg);
break;
}
}
catch (Exception ex)
{
Console.WriteLine("DataProcessing " + ex.ToString());
}
}
public DrugPrescriptionEntity()
{
MESSAGE_HEADER = new MESSAGE_HEADER();
PATIENT_IDENTIFICATION = new PATIENT_IDENTIFICATION();
COMMON_ORDER_DETAILS = new COMMON_ORDER_DETAILS();
PHARMACY_ENCODED_ORDER = new List <PHARMACY_ENCODED_ORDER>();
}
/// <summary>
/// Send message MSG_NEGO_RESP.
/// </summary>
/// <param name="isSupportVersion">If it is true, it is support version, if it is false, it is not support version.</param>
/// <param name="isWellFormed">If it is true, it is well formed, if it is false, it is not well formed.</param>
public void SendMsgNegoResp(bool isSupportVersion, bool isWellFormed)
{
PccrrNegoResponsePacket pccrrNegoResponsePacket;
if (!isSupportVersion && isWellFormed)
{
pccrrNegoResponsePacket = this.pccrrStackSer.CreateMsgNegoResponse(this.minErrorSupV, this.maxErrorSupV, CryptoAlgoId_Values.AES_128, MsgType_Values.MSG_NEGO_RESP, this.protoErrorVer);
}
else if (isSupportVersion && isWellFormed)
{
pccrrNegoResponsePacket = this.pccrrStackSer.CreateMsgNegoResponse(this.minSupV, this.maxSupV, CryptoAlgoId_Values.AES_128, MsgType_Values.MSG_NEGO_RESP, this.protoVer);
}
else
{
pccrrNegoResponsePacket = this.pccrrStackSer.CreateMsgNegoResponse(this.minErrorSupV, this.maxErrorSupV, CryptoAlgoId_Values.AES_128, MsgType_Values.MSG_NEGO_RESP, this.protoErrorVer);
MSG_NEGO_RESP msgNegoResp = new MSG_NEGO_RESP();
MESSAGE_HEADER messageHeader = new MESSAGE_HEADER();
messageHeader = pccrrNegoResponsePacket.MessageHeader;
msgNegoResp.MinSupporteProtocolVersion.MajorVersion = 0;
msgNegoResp.MinSupporteProtocolVersion.MinorVersion = 0;
messageHeader.ProtVer.MajorVersion = 1;
messageHeader.ProtVer.MinorVersion = 0;
msgNegoResp.MaxSupporteProtocolVersion.MajorVersion = 0;
msgNegoResp.MaxSupporteProtocolVersion.MinorVersion = 0;
pccrrNegoResponsePacket.MsgNegoResp = msgNegoResp;
pccrrNegoResponsePacket.MessageHeader = messageHeader;
}
this.pccrrStackSer.SendPacket(pccrrNegoResponsePacket);
}
/// <summary>
/// Send message MSG_GETBLKLIST.
/// </summary>
/// <param name="sid">segment id.</param>
/// <param name="blockRang">Block ranges client wants to get.</param>
/// <param name="isVersionSupported">The version in message is supported by server or not.</param>
public void SendMsgGetBlkList(byte[] sid, BLOCKRANGE[] blockRang, bool isVersionSupported)
{
PccrrGETBLKLISTRequestPacket packet;
BLOCK_RANGE[] blockRanges = Helper.ConvertToStackBLOCKRANGEArray(blockRang);
if (!isVersionSupported)
{
packet = this.pccrrStack.CreateMsgGetBlkListRequest(sid, blockRanges, this.cryptoAlgo, MsgType_Values.MSG_GETBLKLIST, this.protoErrorVer);
}
else
{
packet = this.pccrrStack.CreateMsgGetBlkListRequest(sid, blockRanges, this.cryptoAlgo, MsgType_Values.MSG_GETBLKLIST, this.protoVer);
}
this.pccrrStack.SendPacket(packet, new TimeSpan(0, 0, this.timeout));
PccrrPacket respMSG = this.pccrrStack.ExpectPacket();
if (!isVersionSupported)
{
PccrrNegoResponsePacket pccrrNegoResponsePacket = respMSG as PccrrNegoResponsePacket;
if (pccrrNegoResponsePacket != null)
{
this.ReceiveMsgNegoResp();
}
}
else
{
PccrrBLKLISTResponsePacket pccrrBLKLISTResponsePacket = respMSG as PccrrBLKLISTResponsePacket;
MSG_BLKLIST msgBLKLIST = pccrrBLKLISTResponsePacket.MsgBLKLIST;
MESSAGE_HEADER messageHeader = pccrrBLKLISTResponsePacket.MessageHeader;
TRANSPORT_RESPONSE_HEADER transportRespH = pccrrBLKLISTResponsePacket.TransportResponseHeader;
RESPONSE_MESSAGE respMessage = new RESPONSE_MESSAGE();
respMessage.MESSAGEBODY = msgBLKLIST;
respMessage.MESSAGEHEADER = messageHeader;
respMessage.TRANSPORTRESPONSEHEADER = transportRespH;
if (msgBLKLIST.BlockRanges.Length != 0)
{
BLOCK_RANGE blockRange = pccrrBLKLISTResponsePacket.MsgBLKLIST.BlockRanges[0];
PccrrBothRoleCaptureCode.CaptureBlockRangeRequirements(blockRange);
}
this.VerifyMsgBlkList(msgBLKLIST);
PccrrBothRoleCaptureCode.CaptureCommonDataTypesRequirements(msgBLKLIST);
this.VerifyResponseMessage(respMessage);
BLOCKRANGE[] blkRanges = Helper.ConvertFromStackBLOCKRANGEArray(msgBLKLIST.BlockRanges);
this.ReceiveMsgBlkList(msgBLKLIST.BlockRangeCount, blkRanges, msgBLKLIST.NextBlockIndex);
}
}
/// <summary>
/// Convert the messageHeaderStack struct defined in stack to adapter
/// </summary>
/// <param name="messageHeaderStack">The messageHeaderStack message</param>
/// <returns>Return the messageHeaderStack type defined in adapter</returns>
private static MessageHeader ConvertFromStackForMsgHeader(MESSAGE_HEADER messageHeaderStack)
{
MessageHeader messageHeader;
messageHeader.MajorVersion = messageHeaderStack.MajorVersion;
messageHeader.MinorVersion = messageHeaderStack.MinorVersion;
messageHeader.MsgType = ConvertFromStackForPCHCMsgType(messageHeaderStack.MsgType);
messageHeader.Padding = messageHeaderStack.Padding;
return(messageHeader);
}
private async Task <IndexClientMessage> CreatePretestEncounters(MESSAGE_HEADER header,
PATIENT_IDENTIFICATION pid, ClientStage stagedClient, ClientPretestStage pretest,
params LoadAction[] actions)
{
ENCOUNTERS encounter = null;
// PLACER_DETAIL
var placerDetail = PLACER_DETAIL.Create(pretest.UserId, pretest.Id);
// PRE_TEST
PRE_TEST preTest = null;
if (actions.Contains(LoadAction.All) || actions.Contains(LoadAction.Pretest))
{
preTest = PRE_TEST.Create(pretest);
}
// HIV_TESTS
HIV_TESTS hivTests = null;
if (actions.Contains(LoadAction.All) || actions.Contains(LoadAction.Testing))
{
var allfinalTests = await _clientFinalTestStageExtractor.Extract(stagedClient.ClientId);
var alltests = await _clientTestingStageExtractor.Extract();
var finalTest = allfinalTests.Where(x => x.PretestEncounterId == pretest.Id).ToList()
.LastOrDefault();
var tests = alltests.Where(x => x.PretestEncounterId == pretest.Id).ToList();
if (null != finalTest && tests.Any())
{
hivTests = HIV_TESTS.Create(tests, finalTest);
}
}
// GET THE LAST ONE
encounter = ENCOUNTERS.Create(placerDetail, preTest, hivTests, null, new List <NewTracing>(), null);
return(new IndexClientMessage(header,
new List <NEWCLIENT> {
NEWCLIENT.Create(pid, encounter)
}, stagedClient.ClientId));
}
/// <summary>
/// Capture MESSAGE_HEADER structure related requirements.
/// </summary>
/// <param name="messageHeader">Message header object</param>
private void VerifyMessageHeader(MESSAGE_HEADER messageHeader)
{
// Add the debug information
Site.Log.Add(LogEntryKind.Debug, "Verify MS-PCCRR_R67");
// Verify MS-PCCRR requirement: MS-PCCRR_R67
bool isVerifyR67 = messageHeader.CryptoAlgoId == CryptoAlgoId_Values.V1 ||
messageHeader.CryptoAlgoId == CryptoAlgoId_Values.AES_128 ||
messageHeader.CryptoAlgoId == CryptoAlgoId_Values.AES_192 ||
messageHeader.CryptoAlgoId == CryptoAlgoId_Values.AES_256;
Site.CaptureRequirementIfIsTrue(
isVerifyR67,
67,
@"[In MESSAGE_HEADER][CryptoAlgoId (4 bytes)]MUST be one of the following values[0x00000000,AES_128
0x00000001,AES_192 0x00000002,AES_256 0x00000003].<3>");
}
/// <summary>
/// Verify the received message from client.
/// </summary>
/// <param name="remoteAddr">The remote address.</param>
/// <param name="pccrrPacket">The pccrrPacket.</param>
private void RetrievalTransport_Receive(IPEndPoint remoteAddr, PccrrPacket pccrrPacket)
{
PccrrGETBLKSRequestPacket pccrrGETBLKSRequestPacket = pccrrPacket as PccrrGETBLKSRequestPacket;
if (pccrrGETBLKSRequestPacket != null)
{
MSG_GETBLKS msgGETBLKS = pccrrGETBLKSRequestPacket.MsgGetBLKS;
MESSAGE_HEADER messageHEADER = pccrrGETBLKSRequestPacket.MessageHeader;
this.sid = msgGETBLKS.SegmentID;
REQUEST_MESSAGE requestMESSAGE = new REQUEST_MESSAGE();
requestMESSAGE.MESSAGEBODY = msgGETBLKS;
requestMESSAGE.MESSAGEHEADER = messageHEADER;
this.uiPayload = Marshal.SizeOf(messageHEADER) + Marshal.SizeOf(msgGETBLKS) + 24;
PccrrBothRoleCaptureCode.CaptureBlockRangeRequirements(msgGETBLKS.ReqBlockRanges[0]);
PccrrBothRoleCaptureCode.CaptureMessageHeaderRequirements(messageHEADER, this.uiPayload);
this.VerifyGetBlocks(msgGETBLKS);
this.VerifyRequestMessage(requestMESSAGE);
PccrrBothRoleCaptureCode.CaptureSegmentIdRequirements(msgGETBLKS.SegmentID);
PccrrBothRoleCaptureCode.CaptureHttpRequirements();
PccrrBothRoleCaptureCode.CaptureMessageRequirements();
this.ReceiveMsgGetBlk(msgGETBLKS.ReqBlockRanges[0].Index);
}
else
{
PccrrGETBLKLISTRequestPacket pccrrGETBLKLISTRequestPacket = pccrrPacket as PccrrGETBLKLISTRequestPacket;
if (pccrrGETBLKLISTRequestPacket != null)
{
MSG_GETBLKLIST msgGETBLKLIST = pccrrGETBLKLISTRequestPacket.MsgGetBLKLIST;
this.sid = msgGETBLKLIST.SegmentID;
this.VerifyGetBlkList(msgGETBLKLIST);
PccrrBothRoleCaptureCode.CaptureCommonDataTypesRequirements(msgGETBLKLIST);
_BLOCKRANGE[] blockRanges = ClientHelper.ConvertFromStackBLOCKRANGEArray(msgGETBLKLIST.NeededBlockRanges);
this.ReceiveMsgGetBlkList(blockRanges);
}
else
{
this.ReceiveMsgNegoReq();
}
}
}
private TracingMessage(MESSAGE_HEADER messageHeader, Guid clientId, List <INTERNAL_PATIENT_ID> patientIds, PLACER_DETAIL placerDetail, List <NewTracing> tracings) : base(messageHeader, clientId)
{
INTERNAL_PATIENT_ID = patientIds;
PLACER_DETAIL = placerDetail;
TRACING = tracings;
}
protected ClientMessage(MESSAGE_HEADER messageHeader, Guid clientId)
{
MESSAGE_HEADER = messageHeader;
ClientId = clientId;
}
public PartnerClientMessage(MESSAGE_HEADER messageHeader, List <PARTNER> partners, Guid clientId)
{
MESSAGE_HEADER = messageHeader;
PARTNERS = partners;
ClientId = clientId;
}
private PartnerMessage(MESSAGE_HEADER messageHeader, Guid clientId, List <NEWPARTNER> clients) : base(messageHeader, clientId)
{
PARTNERS = clients;
}
public async Task <IEnumerable <IndexClientMessage> > Load(Guid?htsClientId = null, params LoadAction[] actions)
{
var messages = new List <IndexClientMessage>();
if (!actions.Any())
{
actions = new[] { LoadAction.All }
}
;
var facs = _practiceRepository.GetAllDefault().ToList();
// Set Facility
var facility = facs.FirstOrDefault(x => x.IsDefault);
if (null == facility)
{
throw new Exception($"Default Faciltity Not found");
}
// MESSAGE_HEADER
var facilityCode = facility.Code;
var header = MESSAGE_HEADER.Create(facilityCode);
// NEWCLIENT
var stagedIndexClients = _clientStageRepository.GetIndexClients();
if (!htsClientId.IsNullOrEmpty())
{
stagedIndexClients = stagedIndexClients.Where(x => x.ClientId == htsClientId);
}
foreach (var stagedClient in stagedIndexClients)
{
header.UpdateMfl(stagedClient.SiteCode);
#region PATIENT_IDENTIFICATION
var pid = PATIENT_IDENTIFICATION.Create(stagedClient);
#endregion
ENCOUNTERS encounter = null;
if (!actions.Contains(LoadAction.RegistrationOnly))
{
var pretests = _clientPretestStageRepository.GetByClientId(stagedClient.ClientId).ToList();
// PRETEST AND TESTING
if (pretests.Any())
{
var lastPretest = pretests.OrderByDescending(x => x.EncounterDate).FirstOrDefault();
foreach (var pretest in pretests)
{
var pretestEncounter =
await CreatePretestEncounters(header, pid, stagedClient, pretest, actions);
messages.Add(pretestEncounter);
}
if (null != lastPretest)
{
var nonPretest =
await CreateNonPretestEncounters(header, pid, stagedClient, lastPretest, actions);
if (null != nonPretest)
{
messages.Add(nonPretest);
}
}
}
else
{
var registration = CreateRegistration(header, pid, stagedClient, encounter);
messages.Add(registration);
}
}
else
{
messages.Add(new IndexClientMessage(header,
new List <NEWCLIENT> {
NEWCLIENT.Create(pid, encounter)
}, stagedClient.ClientId));
}
}
return(messages);
}
private DemographicMessage(MESSAGE_HEADER messageHeader, Guid clientId, List <NEWAFYAMOBILECLIENT> clients) : base(messageHeader, clientId)
{
CLIENTS = clients;
}
public async Task <IEnumerable <FamilyClientMessage> > Load(Guid?htsClientId = null, params LoadAction[] actions)
{
var messages = new List <FamilyClientMessage>();
if (!actions.Any())
{
actions = new[] { LoadAction.All }
}
;
// Set Facility
var facility = _practiceRepository.GetDefault();
if (null == facility)
{
throw new Exception($"Default Faciltity Not found");
}
// MESSAGE_HEADER
var facilityCode = facility.Code;
var header = MESSAGE_HEADER.Create(facilityCode);
// CLIENT
var familyMembers = _clientStageRelationshipRepository.GetAll(x => !x.IsPartner);
if (!htsClientId.IsNullOrEmpty())
{
familyMembers = familyMembers.Where(x => x.SecondaryClientId == htsClientId);
}
foreach (var familyMember in familyMembers)
{
var stagedClient = _clientStageRepository.GetQueued(familyMember.SecondaryClientId);
if (null != stagedClient && !stagedClient.IsIndex)
{
header.UpdateMfl(stagedClient.SiteCode);
#region PATIENT_IDENTIFICATION
var pid = PARTNER_FAMILY_PATIENT_IDENTIFICATION.Create(stagedClient, familyMember.IndexClientId,
familyMember.Relation);
#endregion
FAMILY_ENCOUNTER encounter = null;
if (!actions.Contains(LoadAction.RegistrationOnly))
{
PLACER_DETAIL placerDetail = null;
FAMILY_SCREENING familyScreening = null;
List <FAMILY_TRACING> familyTracings = new List <FAMILY_TRACING>();
#region ENCOUNTERS
var screening = await _clientFamilyScreeningStageExtractor.Extract(stagedClient.ClientId);
var screeningStage = screening.OrderBy(x => x.ScreeningDate).LastOrDefault();
// PLACER_DETAIL
if (null != screeningStage)
{
placerDetail = PLACER_DETAIL.Create(screeningStage.UserId, screeningStage.Id);
// FAMILY_SCREENING
if (actions.Contains(LoadAction.All) || actions.Contains(LoadAction.ContactScreenig))
{
familyScreening = FAMILY_SCREENING.Create(screeningStage);
}
}
// FAMILY_TRACING
if (actions.Contains(LoadAction.All) || actions.Contains(LoadAction.ContactTracing))
{
var allTracing = await _clientFamilyTracingStageExtractor.Extract(stagedClient.ClientId);
if (allTracing.Any())
{
familyTracings = FAMILY_TRACING.Create(allTracing.ToList());
}
}
#endregion
encounter = new FAMILY_ENCOUNTER(placerDetail, familyScreening, familyTracings);
}
messages.Add(new FamilyClientMessage(header,
new List <FAMILY> {
new FAMILY(pid, encounter)
}, stagedClient.ClientId));
}
}
return(messages);
}
public IndexClientMessage(MESSAGE_HEADER messageHeader, List <NEWCLIENT> clients, Guid clientId)
{
ClientId = clientId;
MESSAGE_HEADER = messageHeader;
CLIENTS = clients;
}
public PartnerScreening(MESSAGE_HEADER messageHeader, Guid clientId, List <INTERNAL_PATIENT_ID> patientIds, PLACER_DETAIL placerDetail, PARTNER_SCREENING familyScreening) : base(messageHeader, clientId)
{
INTERNAL_PATIENT_ID = patientIds;
PLACER_DETAIL = placerDetail;
PARTNER_SCREENING = familyScreening;
}
public PartnerTracing(MESSAGE_HEADER messageHeader, Guid clientId, List <INTERNAL_PATIENT_ID> patientIds, PLACER_DETAIL placerDetail, List <PARTNER_TRACING> tracings) : base(messageHeader, clientId)
{
INTERNAL_PATIENT_ID = patientIds;
PLACER_DETAIL = placerDetail;
TRACING = tracings;
}
private ReferralMessage(MESSAGE_HEADER messageHeader, Guid clientId, List <INTERNAL_PATIENT_ID> patientIds, PLACER_DETAIL placerDetail, NewReferral referral) : base(messageHeader, clientId)
{
INTERNAL_PATIENT_ID = patientIds;
PLACER_DETAIL = placerDetail;
REFERRAL = referral;
}
public FamilyClientMessage(MESSAGE_HEADER messageHeader, List <FAMILY> family, Guid clientId)
{
MESSAGE_HEADER = messageHeader;
FAMILY = family;
ClientId = clientId;
}
private FamilyMessage(MESSAGE_HEADER messageHeader, Guid clientId, List <NEWFAMILY> clients) : base(messageHeader, clientId)
{
FAMILY = clients;
}
private PretestMessage(MESSAGE_HEADER messageHeader, Guid clientId, List <INTERNAL_PATIENT_ID> patientIds, PLACER_DETAIL placerDetail, PRE_TEST preTest) : base(messageHeader, clientId)
{
INTERNAL_PATIENT_ID = patientIds;
PLACER_DETAIL = placerDetail;
PRE_TEST = preTest;
}
private async Task <IndexClientMessage> CreateNonPretestEncounters(MESSAGE_HEADER header, PATIENT_IDENTIFICATION pid, ClientStage stagedClient, ClientPretestStage lastPretest, params LoadAction[] actions)
{
ENCOUNTERS encounter = null;
// PLACER_DETAIL
var lastplacerDetail = PLACER_DETAIL.Create(lastPretest.UserId, lastPretest.Id);
// NewReferral
NewReferral newReferral = null;
if (actions.Contains(LoadAction.All) || actions.Contains(LoadAction.Referral))
{
var allReferrals = await _clientReferralStageExtractor.Extract(stagedClient.ClientId);
if (allReferrals.Any())
{
var referrall = allReferrals.LastOrDefault();
newReferral = NewReferral.Create(referrall);
}
}
// NewTracing
var newTracings = new List <NewTracing>();
if (actions.Contains(LoadAction.All) || actions.Contains(LoadAction.Tracing))
{
var allTracing = await _clientTracingStageExtractor.Extract(stagedClient.ClientId);
if (allTracing.Any())
{
newTracings = NewTracing.Create(allTracing.ToList());
}
}
// NewLinkage
NewLinkage newLinkage = null;
if (actions.Contains(LoadAction.All) || actions.Contains(LoadAction.Linkage))
{
var allLinkages = await _clientLinkageStageExtractor.Extract(stagedClient.ClientId);
if (allLinkages.Any())
{
var linkage = allLinkages.LastOrDefault();
newLinkage = linkage.HasData ? NewLinkage.Create(linkage) : null;
}
}
if (null == newReferral && !newTracings.Any() && null == newLinkage)
{
return(null);
}
encounter = ENCOUNTERS.Create(lastplacerDetail, null, null, newReferral, newTracings, newLinkage);
return(new IndexClientMessage(header,
new List <NEWCLIENT> {
NEWCLIENT.Create(pid, encounter)
}, stagedClient.ClientId));
}
private TestsMessage(MESSAGE_HEADER messageHeader, Guid clientId, List <INTERNAL_PATIENT_ID> patientIds, PLACER_DETAIL placerDetail, HIV_TESTS tests) : base(messageHeader, clientId)
{
INTERNAL_PATIENT_ID = patientIds;
PLACER_DETAIL = placerDetail;
HIV_TESTS = tests;
}
/// <summary>
/// Send message MSG_GETBLKS
/// </summary>
/// <param name="sid">segment id.</param>
/// <param name="blockRang">Block ranges client wants to get</param>
/// <param name="isVersionSupported">The version in this message is supported in server.</param>
public void SendMsgGetBlks(byte[] sid, BLOCKRANGE[] blockRang, bool isVersionSupported)
{
PccrrGETBLKSRequestPacket packet;
BLOCK_RANGE[] blockRanges = Helper.ConvertToStackBLOCKRANGEArray(blockRang);
if (!isVersionSupported)
{
packet = this.pccrrStack.CreateMsgGetBlksRequest(sid, this.cryptoAlgo, MsgType_Values.MSG_GETBLKS, this.protoErrorVer);
}
else
{
packet = this.pccrrStack.CreateMsgGetBlksRequest(sid, this.cryptoAlgo, MsgType_Values.MSG_GETBLKS, this.protoVer);
}
for (int i = 0; i < blockRanges.Length; i++)
{
if (blockRanges.Length == 1)
{
packet.MsgGetBLKS.ReqBlockRanges[i].Index = blockRanges[i].Index;
packet.MsgGetBLKS.ReqBlockRanges[i].Count = blockRanges[i].Count;
}
else
{
MSG_GETBLKS msgGETBLKS = packet.MsgGetBLKS;
msgGETBLKS.ReqBlockRanges = new BLOCK_RANGE[blockRanges.Length];
msgGETBLKS.ReqBlockRangeCount = (uint)blockRanges.Length;
packet.MsgGetBLKS = msgGETBLKS;
packet.MsgGetBLKS.ReqBlockRanges[i].Index = blockRanges[i].Index;
packet.MsgGetBLKS.ReqBlockRanges[i].Count = blockRanges[i].Count;
}
}
this.pccrrStack.SendPacket(packet, new TimeSpan(0, 0, this.timeout));
PccrrPacket respMSG = this.pccrrStack.ExpectPacket();
if (!isVersionSupported)
{
PccrrNegoResponsePacket pccrrNegoResponsePacket = respMSG as PccrrNegoResponsePacket;
if (pccrrNegoResponsePacket != null)
{
this.ReceiveMsgNegoResp();
}
}
else
{
PccrrBLKResponsePacket pccrrBLKResponsePacket = respMSG as PccrrBLKResponsePacket;
MSG_BLK msgBLK = pccrrBLKResponsePacket.MsgBLK;
MESSAGE_HEADER messageHeader = pccrrBLKResponsePacket.MessageHeader;
TRANSPORT_RESPONSE_HEADER transportRespH = pccrrBLKResponsePacket.TransportResponseHeader;
RESPONSE_MESSAGE respMessage = new RESPONSE_MESSAGE();
respMessage.MESSAGEBODY = msgBLK;
respMessage.MESSAGEHEADER = messageHeader;
respMessage.TRANSPORTRESPONSEHEADER = transportRespH;
this.VerifyMsgBlk(msgBLK);
PccrrBothRoleCaptureCode.CaptureSegmentIdRequirements(msgBLK.SegmentId);
this.VerifyResponseMessage(respMessage);
bool isSizeOfBlockZero = false;
if (msgBLK.SizeOfBlock == 0)
{
isSizeOfBlockZero = true;
}
else
{
isSizeOfBlockZero = false;
}
bool isBlockEmpty = false;
if (msgBLK.Block.Length == 0)
{
isBlockEmpty = true;
}
else
{
isBlockEmpty = false;
}
CryptoAlgoIdValues crypAlgoId = Helper.ConvertFromStackCryptoAlgoIdValues(pccrrBLKResponsePacket.MessageHeader.CryptoAlgoId);
this.ReceiveMsgBlk(msgBLK.BlockIndex, msgBLK.NextBlockIndex, isSizeOfBlockZero, isBlockEmpty, crypAlgoId);
}
}
/// <summary>
/// Validate the MESSAGE_HEADER of request message.
/// </summary>
/// <param name="messageHeader">A MESSAGE_HEADER in the request message.</param>
private void ValidateRequestMessageHeader(MESSAGE_HEADER messageHeader)
{
// Capture MS-PCHC R15
string typeofMinorVersion = messageHeader.MinorVersion.GetType().ToString();
string typeofMajorVersion = messageHeader.MajorVersion.GetType().ToString();
int versionSize = 0;
if (typeofMinorVersion.Equals("System.Byte") && typeofMajorVersion.Equals("System.Byte"))
{
versionSize = 2;
}
Site.CaptureRequirementIfAreEqual <int>(
2,
versionSize,
15,
@"[In MESSAGE_HEADER] Version (2 bytes): The message version,
expressed as major and minor values.");
// Add the debug information
Site.Log.Add(
LogEntryKind.Debug,
@"Verify MS-PCHC_R17, capture it directly for the message header is unmarshalled correctly from stack.");
// Capture MS-PCHC R17
Site.CaptureRequirement(
17,
@"[In MESSAGE_HEADER] Note that the order of the subfields[MinorVersion,MajorVersion]
is reversed; the MinorVersion subfield occurs first.");
// Capture MS-PCHC R18
Site.CaptureRequirementIfAreEqual <byte>(
0x00,
messageHeader.MinorVersion,
18,
"[In MESSAGE_HEADER] MinorVersion (1 byte): The minor part of the version, which MUST be 0x00.");
// Capture MS-PCHC R19
Site.CaptureRequirementIfAreEqual <byte>(
0x01,
messageHeader.MajorVersion,
19,
"[In MESSAGE_HEADER] MajorVersion (1 byte): The major part of the version, which MUST be 0x01.");
// Add the debug information
Site.Log.Add(
LogEntryKind.Debug,
@"Verify MS-PCHC_R16:The Version is 1.0. The minor version is 0x00 and verified in MS-PCHC_R18,
major version is 0x01 and verified in MS-PCHC_R19,
the actual minor versionis {0} and the actual major version is{1}",
(int)messageHeader.MajorVersion,
(int)messageHeader.MinorVersion);
// Capture MS-PCHC R16
Site.CaptureRequirement(
16,
"[In MESSAGE_HEADER] The version[expressed as major and minor values] MUST be 1.0.");
// Capture MS-PCHC R20
int messageTypeSize = sizeof(PCHCMessageType);
Site.CaptureRequirementIfAreEqual <int>(
2,
messageTypeSize,
20,
"[In MESSAGE_HEADER] Type (2 bytes): A 16-bit unsigned integer .");
// Capture MS-PCHC R23
Site.CaptureRequirementIfAreEqual <int>(
4,
messageHeader.Padding.Length,
23,
"[In MESSAGE_HEADER] Padding (4 bytes).");
// Add the debug information
Site.Log.Add(
LogEntryKind.Debug,
@"Verify MS-PCHC_R14:The messageHeader is an instance of MESSAGE_HEADER.
Above requirements about Version, Type, Padding are already valideted.");
// Capture MS-PCHC R14
Site.CaptureRequirement(
14,
@"[In MESSAGE_HEADER] All Peer Content Caching and Retrieval:
Hosted Cache Protocol [MS-PCHC] request messages use a common header,
which consists of the following fields[Version, Type, Padding].");
}
private IndexClientMessage CreateRegistration(MESSAGE_HEADER header, PATIENT_IDENTIFICATION pid, ClientStage stagedClient, ENCOUNTERS encounter)
{
return(new IndexClientMessage(header, new List <NEWCLIENT> {
NEWCLIENT.Create(pid, encounter)
}, stagedClient.ClientId));
}
/// <summary>
/// Capture MESSAGE_HEADER structure releated requirements.
/// </summary>
/// <param name="messageHeader">Message header object</param>
/// <param name="uiPayload">The length of http content body.</param>
public static void CaptureMessageHeaderRequirements(MESSAGE_HEADER messageHeader, int uiPayload)
{
// The protocol version of the server-peer, which is configured in ptfconfig file.
ushort uiMajor = ushort.Parse(
site.Properties.Get(
"PCCRR.Protocol.MSG_NEGO_REQ.MinSupportedProtocolVersion.MajorVer"));
ushort uiMinor = ushort.Parse(
site.Properties.Get(
"PCCRR.Protocol.MSG_NEGO_REQ.MinSupportedProtocolVersion.MinorVer"));
ProtoVersion protVer = messageHeader.ProtVer;
//
// Add the debug information
//
site.Log.Add(LogEntryKind.Debug, "Verify MS-PCCRR_R47");
// Verify MS-PCCRR requirement: MS-PCCRR_R47
// If the following types are verified, means those fields are the layout of message header.
bool isVerifyR47 = messageHeader.GetType() == typeof(MESSAGE_HEADER) &&
messageHeader.ProtVer.GetType() == typeof(ProtoVersion) &&
messageHeader.MsgType.GetType() == typeof(MsgType_Values) &&
messageHeader.MsgSize.GetType() == typeof(uint) &&
messageHeader.CryptoAlgoId.GetType() == typeof(CryptoAlgoId_Values);
site.CaptureRequirementIfIsTrue(
isVerifyR47,
47,
@"[In MESSAGE_HEADER]The layout of the message header is as follows
[ProtVer,MsgType,MsgSize,CryptoAlgoId].");
//
// Add the debug information
//
site.Log.Add(LogEntryKind.Debug, "Verify MS-PCCRR_R48");
bool isVerifyR48 = messageHeader.ProtVer.GetType() == typeof(ProtoVersion) &&
messageHeader.ProtVer.MajorVersion.GetType() == typeof(ushort) &&
messageHeader.ProtVer.MinorVersion.GetType() == typeof(ushort);
// Verify MS-PCCRR requirement: MS-PCCRR_R48
site.CaptureRequirementIfIsTrue(
isVerifyR48,
48,
@"[MESSAGE_HEADER]ProtVer (4 bytes): Protocol version number, formed by concatenating the
protocol major version number and protocol minor version number, encoded as follows (where MSB
is Most Significant Byte and LSB is Least Significant Byte): 1st Byte (Addr: X) is Minor version
MSB;2nd Byte (Addr: X+1) is Minor version LSB;3rd Byte (Addr: X+2) is Major version MSB;4th Byte
(Addr: X+3) is Major version LSB.");
//
// Add the debug information
//
site.Log.Add(LogEntryKind.Debug, "Verify MS-PCCRR_R49");
// Verify MS-PCCRR requirement: MS-PCCRR_R49
// The protVer field will be set in HttpTransport_Receive method when receive a response message
// Verify its low byte
site.CaptureRequirementIfAreEqual <ushort>(
uiMajor,
protVer.MajorVersion,
49,
@"[In MESSAGE_HEADER][ProtVer (4 bytes)]The major version number is encoded in the least
significant word of the protocol version's DWORD.");
//
// Add the debug information
//
site.Log.Add(LogEntryKind.Debug, "Verify MS-PCCRR_R50");
// Verify MS-PCCRR requirement: MS-PCCRR_R50
// Verify its high byte
site.CaptureRequirementIfAreEqual <ushort>(
uiMinor,
protVer.MinorVersion,
50,
@"[In MESSAGE_HEADER][ProtVer (4 bytes)]The minor version number is encoded in the most significant
word of the protocol version's DWORD.");
//
// Add the debug information
//
site.Log.Add(LogEntryKind.Debug, "Verify MS-PCCRR_R51");
// Verify MS-PCCRR requirement: MS-PCCRR_R51
// This is a bug, Major version number is 2 bytes.
bool isVerifyR51 = uiMajor >= 0x0000 && uiMajor <= 0xFFFF;
site.CaptureRequirementIfIsTrue(
isVerifyR51,
51,
@"[In MESSAGE_HEADER][ProtVer (4 bytes)]Major version number can express the version range of
0x00000000 to 0xFFFFFFFF.");
//
// Add the debug information
//
site.Log.Add(LogEntryKind.Debug, "Verify MS-PCCRR_R5100");
// Verify MS-PCCRR requirement: MS-PCCRR_R5100
// This is a bug, Minor version number is 2 bytes.
bool isVerifyR5100 = uiMinor >= 0x0000 && uiMinor <= 0xFFFF;
site.CaptureRequirementIfIsTrue(
isVerifyR5100,
5100,
@"[In MESSAGE_HEADER][ProtVer (4 bytes)]Minor version number can express the version range of
0x00000000 to 0xFFFFFFFF.");
//
// Add the debug information
//
site.Log.Add(LogEntryKind.Debug, "Verify MS-PCCRR_R52");
// Verify MS-PCCRR requirement: MS-PCCRR_R52
bool isVerifyR52 = ((uint)protVer.MajorVersion & 0x0000FFFF) == 0x00000001 &&
((uint)protVer.MinorVersion & 0xFFFF0000) == 0x00000000;
site.CaptureRequirementIfIsTrue(
isVerifyR52,
52,
@"[In MESSAGE_HEADER][ProtVer (4 bytes)]Currently, the protocol[MS-PCCRR] version number MUST be
set to {major=1 (0x0001), minor=0 (0x0000)}.");
//
// Add the debug information
//
site.Log.Add(LogEntryKind.Debug, "Verify MS-PCCRR_R54");
// Verify MS-PCCRR requirement: MS-PCCRR_R54
bool isVerifyR54 = messageHeader.MsgType == MsgType_Values.MSG_NEGO_REQ ||
messageHeader.MsgType == MsgType_Values.MSG_NEGO_RESP ||
messageHeader.MsgType == MsgType_Values.MSG_GETBLKLIST ||
messageHeader.MsgType == MsgType_Values.MSG_GETBLKS ||
messageHeader.MsgType == MsgType_Values.MSG_BLKLIST ||
messageHeader.MsgType == MsgType_Values.MSG_BLK;
site.CaptureRequirementIfIsTrue(
isVerifyR54,
54,
@"[In MESSAGE_HEADER][MsgType (4 bytes)]MUST be set to one of the following values
[MSG_NEGO_REQ 0x00000000,MSG_NEGO_RESP 0x00000001,MSG_GETBLKLIST 0x00000002,MSG_GETBLKS 0x00000003,
MSG_BLKLIST0x00000004,MSG_BLK 0x00000005].");
//
// Add the debug information
//
site.Log.Add(LogEntryKind.Debug, "Verify MS-PCCRR_R318");
// Verify MS-PCCRR requirement: MS-PCCRR_R318
bool isVerifyR318 = messageHeader.CryptoAlgoId == CryptoAlgoId_Values.V1 ||
messageHeader.CryptoAlgoId == CryptoAlgoId_Values.AES_128 ||
messageHeader.CryptoAlgoId == CryptoAlgoId_Values.AES_192 ||
messageHeader.CryptoAlgoId == CryptoAlgoId_Values.AES_256;
site.CaptureRequirementIfIsTrue(
isVerifyR318,
318,
@"[In Appendix A: Product Behavior]<3> Section 2.2.3: Windows supports: no encryption, AES_128,
AES_ 192, and AES_256.");
//
// Add the debug information
//
site.Log.Add(LogEntryKind.Debug, "Verify MS-PCCRR_R64");
// Verify MS-PCCRR requirement: MS-PCCRR_R64
site.CaptureRequirementIfAreEqual <uint>(
(uint)uiPayload,
messageHeader.MsgSize,
64,
@"[In MESSAGE_HEADER]MsgSize (4 bytes): Protocol message total size including MESSAGE_HEADER,
but not including the Transport Header.");
//
// Add the debug information
//
site.Log.Add(LogEntryKind.Debug, "Verify MS-PCCRR_R65");
// Verify MS-PCCRR requirement: MS-PCCRR_R65
bool isVerifyR65 = messageHeader.MsgSize >= 16 && messageHeader.MsgSize <= 98304;
site.CaptureRequirementIfIsTrue(
isVerifyR65,
65,
@"[In MESSAGE_HEADER][MsgSize (4 bytes)]The valid range of the total message size MUST be from
16 bytes to 98,304 bytes (or 96 KB).");
//
// Add the debug information
//
site.Log.Add(LogEntryKind.Debug, "Verify MS-PCCRR_R66");
// Verify MS-PCCRR requirement: MS-PCCRR_R66
site.CaptureRequirementIfAreEqual <int>(
4,
sizeof(CryptoAlgoId_Values),
66,
@"[In MESSAGE_HEADER]CryptoAlgoId (4 bytes): Encryption algorithm used by the server-role peer
to encrypt data.");
//
// Add the debug information
//
site.Log.Add(LogEntryKind.Debug, "Verify MS-PCCRR_R317");
if (messageHeader.MsgType == MsgType_Values.MSG_GETBLKS)
{
bool isVerifyR317 = messageHeader.CryptoAlgoId == CryptoAlgoId_Values.AES_128;
// Verify MS-PCCRR requirement: MS-PCCRR_R317
site.CaptureRequirementIfIsTrue(
isVerifyR317,
317,
@"[In Appendix A: Product Behavior]<3> Section 2.2.3: Windows uses AES_128 as the default encryption
algorithm.");
// Verify MS-PCCRR requirement: MS-PCCRR_R19
bool isFourBytesAlign = messageHeader.MsgSize % 4 == 0;
CaptureFieldAlignRequirements(isFourBytesAlign);
}
}
private LinkageMessage(MESSAGE_HEADER messageHeader, Guid clientId, List <INTERNAL_PATIENT_ID> patientIds, PLACER_DETAIL placerDetail, NewLinkage linkage) : base(messageHeader, clientId)
{
INTERNAL_PATIENT_ID = patientIds;
PLACER_DETAIL = placerDetail;
LINKAGE = linkage;
}
