/// <summary> /// Encode pack. /// </summary> /// <returns>Encoded bytes.</returns> public override byte[] Encode() { RESPONSE_MESSAGE responseMessage = new RESPONSE_MESSAGE(); responseMessage.MESSAGEBODY = this.msgBLKLIST; responseMessage.MESSAGEHEADER = this.MessageHeader; byte[] ret; List <byte> temp = new List <byte>(); byte[] tempPayload; List <byte> listRet = new List <byte>(); listRet.AddRange(MarshalHelper.GetBytes(((MSG_BLKLIST)responseMessage.MESSAGEBODY).SizeOfSegmentId, false)); listRet.AddRange(((MSG_BLKLIST)responseMessage.MESSAGEBODY).SegmentId); while (listRet.Count % 4 != 0) { listRet.Add(byte.MinValue); } listRet.AddRange(MarshalHelper.GetBytes(((MSG_BLKLIST)responseMessage.MESSAGEBODY).BlockRangeCount, false)); for (int i = 0; i < ((MSG_BLKLIST)responseMessage.MESSAGEBODY).BlockRangeCount; i++) { listRet.AddRange(MarshalHelper.GetBytes(((MSG_BLKLIST)responseMessage.MESSAGEBODY).BlockRanges[i].Index, false)); listRet.AddRange(MarshalHelper.GetBytes(((MSG_BLKLIST)responseMessage.MESSAGEBODY).BlockRanges[i].Count, false)); } listRet.AddRange(MarshalHelper.GetBytes(((MSG_BLKLIST)responseMessage.MESSAGEBODY).NextBlockIndex, false)); tempPayload = listRet.ToArray(); responseMessage.MESSAGEHEADER.MsgSize = (uint)tempPayload.Length + 16; List <byte> listRet1 = new List <byte>(); listRet1.AddRange(MarshalHelper.GetBytes((ushort)responseMessage.MESSAGEHEADER.ProtVer.MinorVersion, false)); listRet1.AddRange(MarshalHelper.GetBytes((ushort)responseMessage.MESSAGEHEADER.ProtVer.MajorVersion, false)); listRet1.AddRange(MarshalHelper.GetBytes((uint)responseMessage.MESSAGEHEADER.MsgType, false)); listRet1.AddRange(MarshalHelper.GetBytes(responseMessage.MESSAGEHEADER.MsgSize, false)); listRet1.AddRange(MarshalHelper.GetBytes((uint)responseMessage.MESSAGEHEADER.CryptoAlgoId, false)); temp.AddRange(listRet1.ToArray()); temp.AddRange(tempPayload); temp.InsertRange(0, MarshalHelper.GetBytes((uint)temp.Count, false)); ret = (byte[])temp.ToArray(); return(ret); }
/// <summary> /// Decode pack. /// </summary> /// <param name="rawdata">The rawdata.</param> /// <returns>The PccrrPacket.</returns> public override PccrrPacket Decode(byte[] rawdata) { if (rawdata == null) { throw new ArgumentNullException("rawdata"); } if (rawdata.Length == 0) { throw new ArgumentException("The raw data should not be empty."); } PccrrNegoResponsePacket packet = new PccrrNegoResponsePacket(); int messageLength = 0; messageLength = rawdata.Length; if (messageLength > 0) { int index = 0; byte[] data = rawdata; RESPONSE_MESSAGE ret = new RESPONSE_MESSAGE(); ret.TRANSPORTRESPONSEHEADER.Size = MarshalHelper.GetUInt32(data, ref index, false); MESSAGE_HEADER ret1 = new MESSAGE_HEADER(); ret1.ProtVer.MinorVersion = MarshalHelper.GetUInt16(data, ref index, false); ret1.ProtVer.MajorVersion = MarshalHelper.GetUInt16(data, ref index, false); ret1.MsgType = (MsgType_Values)MarshalHelper.GetUInt32(data, ref index, false); ret1.MsgSize = MarshalHelper.GetUInt32(data, ref index, false); ret1.CryptoAlgoId = (CryptoAlgoId_Values)MarshalHelper.GetUInt32(data, ref index, false); MSG_NEGO_RESP ret2 = new MSG_NEGO_RESP(); ret2.MinSupporteProtocolVersion.MinorVersion = MarshalHelper.GetUInt16(data, ref index, false); ret2.MinSupporteProtocolVersion.MajorVersion = MarshalHelper.GetUInt16(data, ref index, false); ret2.MaxSupporteProtocolVersion.MinorVersion = MarshalHelper.GetUInt16(data, ref index, false); ret2.MaxSupporteProtocolVersion.MajorVersion = MarshalHelper.GetUInt16(data, ref index, false); packet.TransportResponseHeader = ret.TRANSPORTRESPONSEHEADER; packet.MsgNegoResp = ret2; packet.MessageHeader = ret1; } return(packet); }
/// <summary> /// Encode pack. /// </summary> /// <returns>Encode bytes.</returns> public override byte[] Encode() { RESPONSE_MESSAGE responseMessage = new RESPONSE_MESSAGE(); responseMessage.MESSAGEBODY = this.msgNegoResp; responseMessage.MESSAGEHEADER = this.MessageHeader; byte[] ret; List <byte> temp = new List <byte>(); byte[] tempPayload; List <byte> listRet = new List <byte>(); listRet.AddRange(MarshalHelper.GetBytes(((MSG_NEGO_RESP)responseMessage.MESSAGEBODY).MinSupporteProtocolVersion.MinorVersion, false)); listRet.AddRange(MarshalHelper.GetBytes(((MSG_NEGO_RESP)responseMessage.MESSAGEBODY).MinSupporteProtocolVersion.MajorVersion, false)); listRet.AddRange(MarshalHelper.GetBytes(((MSG_NEGO_RESP)responseMessage.MESSAGEBODY).MaxSupporteProtocolVersion.MinorVersion, false)); listRet.AddRange(MarshalHelper.GetBytes(((MSG_NEGO_RESP)responseMessage.MESSAGEBODY).MaxSupporteProtocolVersion.MajorVersion, false)); tempPayload = listRet.ToArray(); responseMessage.MESSAGEHEADER.MsgSize = (uint)tempPayload.Length + 16; List <byte> listRet1 = new List <byte>(); listRet1.AddRange(MarshalHelper.GetBytes((ushort)responseMessage.MESSAGEHEADER.ProtVer.MinorVersion, false)); listRet1.AddRange(MarshalHelper.GetBytes((ushort)responseMessage.MESSAGEHEADER.ProtVer.MajorVersion, false)); listRet1.AddRange(MarshalHelper.GetBytes((uint)responseMessage.MESSAGEHEADER.MsgType, false)); listRet1.AddRange(MarshalHelper.GetBytes(responseMessage.MESSAGEHEADER.MsgSize, false)); listRet1.AddRange(MarshalHelper.GetBytes((uint)responseMessage.MESSAGEHEADER.CryptoAlgoId, false)); temp.AddRange(listRet1.ToArray()); temp.AddRange(tempPayload); temp.InsertRange(0, MarshalHelper.GetBytes((uint)temp.Count, false)); ret = (byte[])temp.ToArray(); return(ret); }
/// <summary> /// Decode response message. /// </summary> /// <param name="rawdata">The raw data.</param> /// <returns>The PccrrPacket.</returns> public PccrrPacket DecodeResponseMessage(byte[] rawdata) { if (rawdata == null) { throw new ArgumentNullException("rawdata"); } if (rawdata.Length == 0) { throw new ArgumentException("The raw data should not be empty."); } int messageLength = 0; messageLength = rawdata.Length; PccrrPacket packet = null; if (messageLength > 0) { int index = 0; RESPONSE_MESSAGE ret = new RESPONSE_MESSAGE(); ret.TRANSPORTRESPONSEHEADER.Size = MarshalHelper.GetUInt32(rawdata, ref index, false); ret.MESSAGEHEADER = this.DecodeMessageHeader(rawdata, ref index); switch (ret.MESSAGEHEADER.MsgType) { case MsgType_Values.MSG_BLKLIST: PccrrBLKLISTResponsePacket pccrrBLKLISTResponsePacket = new PccrrBLKLISTResponsePacket(); MSG_BLKLIST msgBLKLIST = this.DecodeMSG_BLKLIST(rawdata, ref index); pccrrBLKLISTResponsePacket.TransportResponseHeader = ret.TRANSPORTRESPONSEHEADER; pccrrBLKLISTResponsePacket.MsgBLKLIST = msgBLKLIST; pccrrBLKLISTResponsePacket.MessageHeader = ret.MESSAGEHEADER; packet = pccrrBLKLISTResponsePacket; break; case MsgType_Values.MSG_BLK: PccrrBLKResponsePacket pccrrBLKResponsePacket = new PccrrBLKResponsePacket(); MSG_BLK msgBLK = this.DecodeMSG_BLK(rawdata, ref index); pccrrBLKResponsePacket.TransportResponseHeader = ret.TRANSPORTRESPONSEHEADER; pccrrBLKResponsePacket.MsgBLK = msgBLK; pccrrBLKResponsePacket.MessageHeader = ret.MESSAGEHEADER; packet = pccrrBLKResponsePacket; break; case MsgType_Values.MSG_NEGO_RESP: PccrrNegoResponsePacket pccrrNegoResponsePacket = new PccrrNegoResponsePacket(); MSG_NEGO_RESP msgNEGORESP = this.DecodeMSG_NEGO_RESP(rawdata, ref index); pccrrNegoResponsePacket.TransportResponseHeader = ret.TRANSPORTRESPONSEHEADER; pccrrNegoResponsePacket.MsgNegoResp = msgNEGORESP; pccrrNegoResponsePacket.MessageHeader = ret.MESSAGEHEADER; packet = pccrrNegoResponsePacket; break; case MsgType_Values.MSG_SEGLIST: PccrrSegListResponsePacket pccrrSegListResponsePacket = new PccrrSegListResponsePacket(); pccrrSegListResponsePacket.MsgSegList = TypeMarshal.ToStruct <MSG_SEGLIST>(rawdata, ref index); pccrrSegListResponsePacket.TransportResponseHeader = ret.TRANSPORTRESPONSEHEADER; pccrrSegListResponsePacket.MessageHeader = ret.MESSAGEHEADER; packet = pccrrSegListResponsePacket; break; } } return(packet); }
/// <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(); }
/// <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> /// 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> /// Encode pack. /// </summary> /// <returns>Encode bytes.</returns> public override byte[] Encode() { RESPONSE_MESSAGE responseMessage = new RESPONSE_MESSAGE(); responseMessage.MESSAGEBODY = this.msgNegoResp; responseMessage.MESSAGEHEADER = this.MessageHeader; byte[] ret; List<byte> temp = new List<byte>(); byte[] tempPayload; List<byte> listRet = new List<byte>(); listRet.AddRange(MarshalHelper.GetBytes(((MSG_NEGO_RESP)responseMessage.MESSAGEBODY).MinSupporteProtocolVersion.MinorVersion, false)); listRet.AddRange(MarshalHelper.GetBytes(((MSG_NEGO_RESP)responseMessage.MESSAGEBODY).MinSupporteProtocolVersion.MajorVersion, false)); listRet.AddRange(MarshalHelper.GetBytes(((MSG_NEGO_RESP)responseMessage.MESSAGEBODY).MaxSupporteProtocolVersion.MinorVersion, false)); listRet.AddRange(MarshalHelper.GetBytes(((MSG_NEGO_RESP)responseMessage.MESSAGEBODY).MaxSupporteProtocolVersion.MajorVersion, false)); tempPayload = listRet.ToArray(); responseMessage.MESSAGEHEADER.MsgSize = (uint)tempPayload.Length + 16; List<byte> listRet1 = new List<byte>(); listRet1.AddRange(MarshalHelper.GetBytes((ushort)responseMessage.MESSAGEHEADER.ProtVer.MinorVersion, false)); listRet1.AddRange(MarshalHelper.GetBytes((ushort)responseMessage.MESSAGEHEADER.ProtVer.MajorVersion, false)); listRet1.AddRange(MarshalHelper.GetBytes((uint)responseMessage.MESSAGEHEADER.MsgType, false)); listRet1.AddRange(MarshalHelper.GetBytes(responseMessage.MESSAGEHEADER.MsgSize, false)); listRet1.AddRange(MarshalHelper.GetBytes((uint)responseMessage.MESSAGEHEADER.CryptoAlgoId, false)); temp.AddRange(listRet1.ToArray()); temp.AddRange(tempPayload); temp.InsertRange(0, MarshalHelper.GetBytes((uint)temp.Count, false)); ret = (byte[])temp.ToArray(); return ret; }
/// <summary> /// Decode pack. /// </summary> /// <param name="rawdata">The rawdata.</param> /// <returns>The PccrrPacket.</returns> public override PccrrPacket Decode(byte[] rawdata) { if (rawdata == null) { throw new ArgumentNullException("rawdata"); } if (rawdata.Length == 0) { throw new ArgumentException("The raw data should not be empty."); } PccrrNegoResponsePacket packet = new PccrrNegoResponsePacket(); int messageLength = 0; messageLength = rawdata.Length; if (messageLength > 0) { int index = 0; byte[] data = rawdata; RESPONSE_MESSAGE ret = new RESPONSE_MESSAGE(); ret.TRANSPORTRESPONSEHEADER.Size = MarshalHelper.GetUInt32(data, ref index, false); MESSAGE_HEADER ret1 = new MESSAGE_HEADER(); ret1.ProtVer.MinorVersion = MarshalHelper.GetUInt16(data, ref index, false); ret1.ProtVer.MajorVersion = MarshalHelper.GetUInt16(data, ref index, false); ret1.MsgType = (MsgType_Values)MarshalHelper.GetUInt32(data, ref index, false); ret1.MsgSize = MarshalHelper.GetUInt32(data, ref index, false); ret1.CryptoAlgoId = (CryptoAlgoId_Values)MarshalHelper.GetUInt32(data, ref index, false); MSG_NEGO_RESP ret2 = new MSG_NEGO_RESP(); ret2.MinSupporteProtocolVersion.MinorVersion = MarshalHelper.GetUInt16(data, ref index, false); ret2.MinSupporteProtocolVersion.MajorVersion = MarshalHelper.GetUInt16(data, ref index, false); ret2.MaxSupporteProtocolVersion.MinorVersion = MarshalHelper.GetUInt16(data, ref index, false); ret2.MaxSupporteProtocolVersion.MajorVersion = MarshalHelper.GetUInt16(data, ref index, false); packet.TransportResponseHeader = ret.TRANSPORTRESPONSEHEADER; packet.MsgNegoResp = ret2; packet.MessageHeader = ret1; } return packet; }
/// <summary> /// Decode response message. /// </summary> /// <param name="rawdata">The raw data.</param> /// <returns>The PccrrPacket.</returns> public PccrrPacket DecodeResponseMessage(byte[] rawdata) { if (rawdata == null) { throw new ArgumentNullException("rawdata"); } if (rawdata.Length == 0) { throw new ArgumentException("The raw data should not be empty."); } int messageLength = 0; messageLength = rawdata.Length; PccrrPacket packet = null; if (messageLength > 0) { int index = 0; RESPONSE_MESSAGE ret = new RESPONSE_MESSAGE(); ret.TRANSPORTRESPONSEHEADER.Size = MarshalHelper.GetUInt32(rawdata, ref index, false); ret.MESSAGEHEADER = this.DecodeMessageHeader(rawdata, ref index); switch (ret.MESSAGEHEADER.MsgType) { case MsgType_Values.MSG_BLKLIST: PccrrBLKLISTResponsePacket pccrrBLKLISTResponsePacket = new PccrrBLKLISTResponsePacket(); MSG_BLKLIST msgBLKLIST = this.DecodeMSG_BLKLIST(rawdata, ref index); pccrrBLKLISTResponsePacket.TransportResponseHeader = ret.TRANSPORTRESPONSEHEADER; pccrrBLKLISTResponsePacket.MsgBLKLIST = msgBLKLIST; pccrrBLKLISTResponsePacket.MessageHeader = ret.MESSAGEHEADER; packet = pccrrBLKLISTResponsePacket; break; case MsgType_Values.MSG_BLK: PccrrBLKResponsePacket pccrrBLKResponsePacket = new PccrrBLKResponsePacket(); MSG_BLK msgBLK = this.DecodeMSG_BLK(rawdata, ref index); pccrrBLKResponsePacket.TransportResponseHeader = ret.TRANSPORTRESPONSEHEADER; pccrrBLKResponsePacket.MsgBLK = msgBLK; pccrrBLKResponsePacket.MessageHeader = ret.MESSAGEHEADER; packet = pccrrBLKResponsePacket; break; case MsgType_Values.MSG_NEGO_RESP: PccrrNegoResponsePacket pccrrNegoResponsePacket = new PccrrNegoResponsePacket(); MSG_NEGO_RESP msgNEGORESP = this.DecodeMSG_NEGO_RESP(rawdata, ref index); pccrrNegoResponsePacket.TransportResponseHeader = ret.TRANSPORTRESPONSEHEADER; pccrrNegoResponsePacket.MsgNegoResp = msgNEGORESP; pccrrNegoResponsePacket.MessageHeader = ret.MESSAGEHEADER; packet = pccrrNegoResponsePacket; break; case MsgType_Values.MSG_SEGLIST: PccrrSegListResponsePacket pccrrSegListResponsePacket = new PccrrSegListResponsePacket(); pccrrSegListResponsePacket.MsgSegList = TypeMarshal.ToStruct<MSG_SEGLIST>(rawdata, ref index); pccrrSegListResponsePacket.TransportResponseHeader = ret.TRANSPORTRESPONSEHEADER; pccrrSegListResponsePacket.MessageHeader = ret.MESSAGEHEADER; packet = pccrrSegListResponsePacket; break; } } return packet; }
/// <summary> /// Encode pack. /// </summary> /// <returns>Encode bytes.</returns> public override byte[] Encode() { RESPONSE_MESSAGE responseMessage = new RESPONSE_MESSAGE(); responseMessage.MESSAGEBODY = this.msgBLK; responseMessage.MESSAGEHEADER = this.MessageHeader; byte[] ret; List<byte> temp = new List<byte>(); byte[] tempPayload; List<byte> listRet = new List<byte>(); listRet.AddRange(MarshalHelper.GetBytes(((MSG_BLK)responseMessage.MESSAGEBODY).SizeOfSegmentId, false)); listRet.AddRange(((MSG_BLK)responseMessage.MESSAGEBODY).SegmentId); while (listRet.Count % 4 != 0) { listRet.Add(byte.MinValue); } listRet.AddRange(MarshalHelper.GetBytes(((MSG_BLK)responseMessage.MESSAGEBODY).BlockIndex, false)); listRet.AddRange(MarshalHelper.GetBytes(((MSG_BLK)responseMessage.MESSAGEBODY).NextBlockIndex, false)); listRet.AddRange(MarshalHelper.GetBytes(((MSG_BLK)responseMessage.MESSAGEBODY).SizeOfBlock, false)); if (((MSG_BLK)responseMessage.MESSAGEBODY).Block != null) { listRet.AddRange(((MSG_BLK)responseMessage.MESSAGEBODY).Block); } while (listRet.Count % 4 != 0) { listRet.Add(byte.MinValue); } listRet.AddRange(MarshalHelper.GetBytes(((MSG_BLK)responseMessage.MESSAGEBODY).SizeOfVrfBlock, false)); while (listRet.Count % 4 != 0) { listRet.Add(byte.MinValue); } listRet.AddRange(MarshalHelper.GetBytes(((MSG_BLK)responseMessage.MESSAGEBODY).SizeOfIVBlock, false)); if (((MSG_BLK)responseMessage.MESSAGEBODY).IVBlock != null) { listRet.AddRange(((MSG_BLK)responseMessage.MESSAGEBODY).IVBlock); } tempPayload = listRet.ToArray(); responseMessage.MESSAGEHEADER.MsgSize = (uint)tempPayload.Length + 16; List<byte> listRet1 = new List<byte>(); listRet1.AddRange(MarshalHelper.GetBytes((ushort)responseMessage.MESSAGEHEADER.ProtVer.MinorVersion, false)); listRet1.AddRange(MarshalHelper.GetBytes((ushort)responseMessage.MESSAGEHEADER.ProtVer.MajorVersion, false)); listRet1.AddRange(MarshalHelper.GetBytes((uint)responseMessage.MESSAGEHEADER.MsgType, false)); listRet1.AddRange(MarshalHelper.GetBytes(responseMessage.MESSAGEHEADER.MsgSize, false)); listRet1.AddRange(MarshalHelper.GetBytes((uint)responseMessage.MESSAGEHEADER.CryptoAlgoId, false)); temp.AddRange(listRet1.ToArray()); temp.AddRange(tempPayload); temp.InsertRange(0, MarshalHelper.GetBytes((uint)temp.Count, false)); ret = (byte[])temp.ToArray(); return ret; }