/// <summary>
/// Create a MsgBlk response.
/// </summary>
/// <param name="segmentId">The segmentId.</param>
/// <param name="block">The block.</param>
/// <param name="cryptoAlgoIdValues">The cryptoAlgoId.</param>
/// <param name="msgTypeValues">The msgType.</param>
/// <param name="isLastBLKAvail">If it is true, the block is the last available block.</param>
/// <returns>The MsgBlk response.</returns>
public PccrrBLKResponsePacket CreateMsgBlkResponse(
byte[] segmentId,
byte[] block,
CryptoAlgoId_Values cryptoAlgoIdValues,
MsgType_Values msgTypeValues,
bool isLastBLKAvail)
{
if (segmentId == null)
{
segmentId = new byte[0];
}
if (block == null)
{
block = new byte[0];
}
PccrrBLKResponsePacket packet = new PccrrBLKResponsePacket();
MSG_BLK msgBlkResp = new MSG_BLK();
byte[] zeroPad = new byte[0] {
};
byte[] zeroPad_2 = new byte[0] {
};
byte[] zeroPad_3 = new byte[0] {
};
byte[] iVBlock = new byte[0] {
};
msgBlkResp.ZeroPad3 = zeroPad_3;
msgBlkResp.ZeroPad2 = zeroPad_2;
msgBlkResp.ZeroPad = zeroPad;
msgBlkResp.VrfBlock = null;
msgBlkResp.SizeOfVrfBlock = 0;
msgBlkResp.SizeOfSegmentId = (uint)segmentId.Length;
msgBlkResp.SizeOfIVBlock = (uint)iVBlock.Length;
msgBlkResp.SizeOfBlock = (uint)block.Length;
msgBlkResp.SegmentId = segmentId;
msgBlkResp.IVBlock = iVBlock;
msgBlkResp.Block = block;
msgBlkResp.BlockIndex = 0;
if (!isLastBLKAvail)
{
msgBlkResp.NextBlockIndex = 1;
}
else
{
msgBlkResp.NextBlockIndex = 0;
}
MESSAGE_HEADER messageHeader = PccrrUtitlity.CreateMessageHeader(cryptoAlgoIdValues, msgTypeValues, new ProtoVersion {
MajorVersion = 1, MinorVersion = 0
});
packet.MsgBLK = msgBlkResp;
packet.MessageHeader = messageHeader;
return(packet);
}
/// <summary>
/// Create a MsgGetSegList request.
/// </summary>
/// <param name="cryptoAlgoIdValues">The cryptoAlgoId.</param>
/// <param name="requestID">Request ID.</param>
/// <param name="segmentIDs">Array of segment IDs.</param>
/// <param name="extensibleBlob">Extensible blob.</param>
/// <returns>MsgGetSegList request.</returns>
public PccrrGetSegListRequestPacket CreateMsgGetSegListRequest(
CryptoAlgoId_Values cryptoAlgoIdValues,
Guid requestID,
byte[][] segmentIDs,
byte[] extensibleBlob)
{
var packet = new PccrrGetSegListRequestPacket();
var msgGetSegList = new MSG_GETSEGLIST();
msgGetSegList.RequestID = requestID;
msgGetSegList.CountOfSegmentIDs = (uint)segmentIDs.Length;
msgGetSegList.SegmentIDs = new SegmentIDStructure[segmentIDs.Length];
for (int i = 0; i < segmentIDs.Length; i++)
{
msgGetSegList.SegmentIDs[i] = new SegmentIDStructure(segmentIDs[i]);
}
///[MS-PCCRR]Section 2.2.4.4 SizeOfExtensibleBlob: Size, in bytes, of the ExtensibleBlob field. Implementations MAY support extensible blobs in MSG_GETSEGLIST
///message.Implementations that do not support extensible blobs in MSG_GETSEGLIST messages MUST set SizeOfExtensibleBlob to zero and omit the ExtensibleBlob field.
msgGetSegList.SizeOfExtensibleBlob = (uint)extensibleBlob.Length;
msgGetSegList.ExtensibleBlob = extensibleBlob;
packet.MsgGetSegList = msgGetSegList;
MESSAGE_HEADER messageHeader = PccrrUtitlity.CreateMessageHeader(cryptoAlgoIdValues, MsgType_Values.MSG_GETSEGLIST, new ProtoVersion {
MajorVersion = 2, MinorVersion = 0
});
messageHeader.MsgSize += (uint)TypeMarshal.GetBlockMemorySize(msgGetSegList);
packet.MessageHeader = messageHeader;
return(packet);
}
/// <summary>
/// Create a MsgGetBlks request.
/// </summary>
/// <param name="segmentId">The segmentId.</param>
/// <param name="cryptoAlgoIdValues">The cryptoAlgoId.</param>
/// <param name="msgTypeValues">The msgType.</param>
/// <returns>MsgGetBlks request.</returns>
public PccrrGETBLKSRequestPacket CreateMsgGetBlksRequest(
byte[] segmentId,
CryptoAlgoId_Values cryptoAlgoIdValues,
MsgType_Values msgTypeValues)
{
if (segmentId == null)
{
segmentId = new byte[0];
}
PccrrGETBLKSRequestPacket packet = new PccrrGETBLKSRequestPacket();
MSG_GETBLKS msgGetBlksReq = new MSG_GETBLKS();
msgGetBlksReq.DataForVrfBlock = null;
byte[] zeroPad = new byte[0] {
};
BLOCK_RANGE[] reqBlockRanges = new BLOCK_RANGE[1];
reqBlockRanges[0].Index = 0;
reqBlockRanges[0].Count = 1;
msgGetBlksReq.ReqBlockRanges = reqBlockRanges;
msgGetBlksReq.ReqBlockRangeCount = (uint)reqBlockRanges.Length;
msgGetBlksReq.ZeroPad = zeroPad;
msgGetBlksReq.SizeOfSegmentID = (uint)segmentId.Length;
msgGetBlksReq.SizeOfDataForVrfBlock = 0;
msgGetBlksReq.SegmentID = segmentId;
MESSAGE_HEADER messageHeader = PccrrUtitlity.CreateMessageHeader(cryptoAlgoIdValues, msgTypeValues, new ProtoVersion {
MajorVersion = 1, MinorVersion = 0
});
packet.MsgGetBLKS = msgGetBlksReq;
packet.MessageHeader = messageHeader;
return(packet);
}
/// <summary>
/// Expect a packet.
/// </summary>
/// <returns>The PccrrPacket.</returns>
public PccrrPacket ExpectPacket()
{
if (this.httpClientTransport == null)
{
throw new InvalidOperationException("The transport is null for not connected.");
}
byte[] payloadBuffer = null;
this.httpClientTransport.Receive(ref payloadBuffer);
PccrrPacket resp = null;
resp = new PccrrUtitlity().DecodeResponseMessage(payloadBuffer);
return(resp);
}
/// <summary>
/// Decode a packet.
/// </summary>
/// <param name="uri">The uri of the request.</param>
/// <param name="httpMethod">The http method.</param>
/// <param name="rawdata">The rawdata.</param>
/// <returns>The PccrrPacket.</returns>
private PccrrPacket DecodePacket(Uri uri, HttpMethod httpMethod, byte[] rawdata)
{
if (uri == null)
{
throw new ArgumentNullException("uri");
}
if (this.httpServerTransport == null)
{
throw new InvalidOperationException("The transport is null for not connected.");
}
PccrrPacket req = null;
lock (this.obj)
{
req = new PccrrUtitlity().DecodeRequestMessage(rawdata, uri, httpMethod);
return(req);
}
}
/// <summary>
/// Create a MsgNego response.
/// </summary>
/// <param name="minSupportedProtocolVer">The minSupportedProtocolVersion.</param>
/// <param name="maxSupportedProtocolVer">The maxSupportedProtocolVersion.</param>
/// <param name="cryptoAlgoIdValues">The cryptoAlgoId.</param>
/// <param name="msgTypeValues">The msgType.</param>
/// <returns>The MsgNego response.</returns>
public PccrrNegoResponsePacket CreateMsgNegoResponse(
ProtoVersion minSupportedProtocolVer,
ProtoVersion maxSupportedProtocolVer,
CryptoAlgoId_Values cryptoAlgoIdValues,
MsgType_Values msgTypeValues)
{
PccrrNegoResponsePacket packet = new PccrrNegoResponsePacket();
MSG_NEGO_RESP msgNegoResp = new MSG_NEGO_RESP();
msgNegoResp.MaxSupporteProtocolVersion = maxSupportedProtocolVer;
msgNegoResp.MinSupporteProtocolVersion = minSupportedProtocolVer;
MESSAGE_HEADER messageHeader = PccrrUtitlity.CreateMessageHeader(cryptoAlgoIdValues, msgTypeValues, new ProtoVersion {
MajorVersion = 1, MinorVersion = 0
});
packet.MsgNegoResp = msgNegoResp;
packet.MessageHeader = messageHeader;
return(packet);
}
/// <summary>
/// Create a MsgSegList response.
/// </summary>
/// <param name="cryptoAlgoIdValues">The cryptoAlgoId.</param>
/// <param name="requestID">Request ID.</param>
/// <param name="segmentRanges">Segment ranges.</param>
/// <returns>The MsgSegList response.</returns>
public PccrrSegListResponsePacket CreateSegListResponse(
CryptoAlgoId_Values cryptoAlgoIdValues,
Guid requestID,
BLOCK_RANGE[] segmentRanges)
{
var packet = new PccrrSegListResponsePacket();
var msgSegList = new MSG_SEGLIST();
msgSegList.RequestID = requestID;
msgSegList.SegmentRangeCount = (uint)segmentRanges.Length;
msgSegList.SegmentRanges = segmentRanges;
MESSAGE_HEADER messageHeader = PccrrUtitlity.CreateMessageHeader(cryptoAlgoIdValues, MsgType_Values.MSG_SEGLIST, new ProtoVersion {
MajorVersion = 2, MinorVersion = 0
});
packet.MsgSegList = msgSegList;
packet.MessageHeader = messageHeader;
return(packet);
}
/// <summary>
/// Create a MsgBlkList response.
/// </summary>
/// <param name="segmentId">The segmentId.</param>
/// <param name="blockRanges">The blockRanges.</param>
/// <param name="nextBlockIndex">The nextBlockIndex.</param>
/// <param name="cryptoAlgoIdValues">The cryptoAlgoId.</param>
/// <param name="msgTypeValues">The msgType.</param>
/// <returns>The MsgBlkList response.</returns>
public PccrrBLKLISTResponsePacket CreateMsgBlkListResponse(
byte[] segmentId,
BLOCK_RANGE[] blockRanges,
uint nextBlockIndex,
CryptoAlgoId_Values cryptoAlgoIdValues,
MsgType_Values msgTypeValues)
{
if (segmentId == null)
{
segmentId = new byte[0];
}
if (blockRanges == null)
{
blockRanges = new BLOCK_RANGE[0];
}
PccrrBLKLISTResponsePacket packet = new PccrrBLKLISTResponsePacket();
MSG_BLKLIST msgBlkListResp = new MSG_BLKLIST();
byte[] zeroPad = new byte[0] {
};
msgBlkListResp.ZeroPad = zeroPad;
msgBlkListResp.SizeOfSegmentId = (uint)segmentId.Length;
msgBlkListResp.SegmentId = segmentId;
msgBlkListResp.BlockRanges = blockRanges;
msgBlkListResp.BlockRangeCount = (uint)blockRanges.Length;
msgBlkListResp.NextBlockIndex = nextBlockIndex;
MESSAGE_HEADER messageHeader = PccrrUtitlity.CreateMessageHeader(cryptoAlgoIdValues, msgTypeValues, new ProtoVersion {
MajorVersion = 1, MinorVersion = 0
});
packet.MsgBLKLIST = msgBlkListResp;
packet.MessageHeader = messageHeader;
return(packet);
}
/// <summary>
/// Create a MsgGetBlkList request.
/// </summary>
/// <param name="segmentId">The segmentId.</param>
/// <param name="blockRanges">The needed BlockRanges.</param>
/// <param name="cryptoAlgoIdValues">The cryptoAlgoId.</param>
/// <param name="msgTypeValues">The msgType.</param>
/// <returns>MsgGetBlkList request.</returns>
public PccrrGETBLKLISTRequestPacket CreateMsgGetBlkListRequest(
byte[] segmentId,
BLOCK_RANGE[] blockRanges,
CryptoAlgoId_Values cryptoAlgoIdValues,
MsgType_Values msgTypeValues)
{
if (segmentId == null)
{
segmentId = new byte[0];
}
if (blockRanges == null)
{
blockRanges = new BLOCK_RANGE[0];
}
PccrrGETBLKLISTRequestPacket packet = new PccrrGETBLKLISTRequestPacket();
MSG_GETBLKLIST msgGetBlkListReq = new MSG_GETBLKLIST();
byte[] zeroPad = new byte[0] {
};
msgGetBlkListReq.SegmentID = segmentId;
msgGetBlkListReq.SizeOfSegmentID = (uint)segmentId.Length;
msgGetBlkListReq.NeededBlockRanges = blockRanges;
msgGetBlkListReq.NeededBlocksRangeCount = (uint)blockRanges.Length;
msgGetBlkListReq.ZeroPad = zeroPad;
MESSAGE_HEADER messageHeader = PccrrUtitlity.CreateMessageHeader(cryptoAlgoIdValues, msgTypeValues, new ProtoVersion {
MajorVersion = 1, MinorVersion = 0
});
packet.MsgGetBLKLIST = msgGetBlkListReq;
packet.MessageHeader = messageHeader;
return(packet);
}
/// <summary>
/// Expect a packet.
/// </summary>
/// <returns>The PccrrPacket.</returns>
public PccrrPacket ExpectPacket()
{
if (this.httpClientTransport == null)
{
throw new InvalidOperationException("The transport is null for not connected.");
}
byte[] payloadBuffer = null;
this.httpClientTransport.Receive(ref payloadBuffer);
PccrrPacket resp = null;
resp = new PccrrUtitlity().DecodeResponseMessage(payloadBuffer);
return resp;
}
/// <summary>
/// Decode a packet.
/// </summary>
/// <param name="uri">The uri of the request.</param>
/// <param name="httpMethod">The http method.</param>
/// <param name="rawdata">The rawdata.</param>
/// <returns>The PccrrPacket.</returns>
private PccrrPacket DecodePacket(Uri uri, HttpMethod httpMethod, byte[] rawdata)
{
if (uri == null)
{
throw new ArgumentNullException("uri");
}
if (this.httpServerTransport == null)
{
throw new InvalidOperationException("The transport is null for not connected.");
}
PccrrPacket req = null;
lock (this.obj)
{
req = new PccrrUtitlity().DecodeRequestMessage(rawdata, uri, httpMethod);
return req;
}
}
