/// <summary> /// Initialize an instance of RpcePdu class. /// </summary> /// <param name="context">context</param> /// <exception cref="ArgumentNullException"> /// Thrown when context is null. /// </exception> protected RpcePdu(RpceContext context) { if (context == null) { throw new ArgumentNullException("context"); } this.context = context; }
protected RpceCoPdu(RpceContext context, byte[] pduBytes) : base(context, pduBytes) { using (BinaryReader binaryReader = new BinaryReader(new MemoryStream(pduBytes))) { FromBytes(binaryReader); } }
/// <summary> /// Initialize an instance of RpcePdu class. /// </summary> /// <param name="context">context</param> /// <exception cref="ArgumentNullException"> /// Thrown when context is null. /// </exception> protected RpcePdu(RpceContext context) { if (context == null) { throw new ArgumentNullException("context"); } this.context = context; }
/// <summary> /// Initialize an instance of RpcePdu class. /// </summary> /// <param name="context">context</param> /// <param name="pduBytes">A byte array contains PDU data.</param> /// <exception cref="ArgumentNullException"> /// Thrown when context or pduBytes is null. /// </exception> protected RpcePdu(RpceContext context, byte[] pduBytes) : base(pduBytes) { if (context == null) { throw new ArgumentNullException("context"); } if (pduBytes == null) { throw new ArgumentNullException("pduBytes"); } this.context = context; }
/// <summary> /// Initialize an instance of RpcePdu class. /// </summary> /// <param name="context">context</param> /// <param name="pduBytes">A byte array contains PDU data.</param> /// <exception cref="ArgumentNullException"> /// Thrown when context or pduBytes is null. /// </exception> protected RpcePdu(RpceContext context, byte[] pduBytes) : base(pduBytes) { if (context == null) { throw new ArgumentNullException("context"); } if (pduBytes == null) { throw new ArgumentNullException("pduBytes"); } this.context = context; }
/// <summary> /// Decode CO PDU. /// </summary> /// <param name="context">The context that received data.</param> /// <param name="messageBytes">bytes received</param> /// <param name="consumedLength">num of bytes consumed in processing</param> /// <param name="expectedLength">num of bytes expected if the bytes is not enough</param> /// <returns>pdus</returns> internal static RpceCoPdu[] DecodeCoPdu( RpceContext context, byte[] messageBytes, out int consumedLength, out int expectedLength) { List <RpceCoPdu> pduList = new List <RpceCoPdu>(); consumedLength = 0; expectedLength = 0; while (consumedLength < messageBytes.Length) { if ((messageBytes.Length - consumedLength) < RpceUtility.CO_PDU_HEADER_SIZE) { expectedLength = RpceUtility.CO_PDU_HEADER_SIZE; break; } //#4 byte is drep uint dataRepresentation = BitConverter.ToUInt32( messageBytes, consumedLength + RpceUtility.DREP_FIELD_OFFSET); //#8 byte is frag_length ushort fragmentLength = BitConverter.ToUInt16( messageBytes, consumedLength + RpceUtility.FRAG_LENGTH_FIELD_OFFSET); if ((dataRepresentation & 0x0000FFFFU) != NativeMethods.NDR_LOCAL_DATA_REPRESENTATION) { fragmentLength = EndianUtility.ReverseByteOrder(fragmentLength); } if ((messageBytes.Length - consumedLength) < fragmentLength) { expectedLength = fragmentLength; break; } byte[] pduBytes = new byte[fragmentLength]; Buffer.BlockCopy(messageBytes, consumedLength, pduBytes, 0, fragmentLength); RpceCoPdu pdu = RpceUtility.DecodeCoPdu(context, pduBytes); pduList.Add(pdu); consumedLength += fragmentLength; } return(pduList.ToArray()); }
/// <summary> /// Decode CO PDU. /// </summary> /// <param name="context">The context that received data.</param> /// <param name="messageBytes">bytes received</param> /// <param name="consumedLength">num of bytes consumed in processing</param> /// <param name="expectedLength">num of bytes expected if the bytes is not enough</param> /// <returns>pdus</returns> internal static RpceCoPdu[] DecodeCoPdu( RpceContext context, byte[] messageBytes, out int consumedLength, out int expectedLength) { List <RpceCoPdu> pduList = new List <RpceCoPdu>(); consumedLength = 0; expectedLength = 0; while (consumedLength < messageBytes.Length) { if ((messageBytes.Length - consumedLength) < RpceUtility.CO_PDU_HEADER_SIZE) { expectedLength = RpceUtility.CO_PDU_HEADER_SIZE; break; } //#8 byte is frag_length ushort fragmentLength = BitConverter.ToUInt16( messageBytes, consumedLength + RpceUtility.FRAG_LENGTH_FIELD_OFFSET); if ((messageBytes.Length - consumedLength) < fragmentLength) { expectedLength = fragmentLength; break; } byte[] pduBytes = new byte[fragmentLength]; Buffer.BlockCopy(messageBytes, consumedLength, pduBytes, 0, fragmentLength); RpceCoPdu pdu = RpceUtility.DecodeCoPdu(context, pduBytes); pduList.Add(pdu); consumedLength += fragmentLength; } return(pduList.ToArray()); }
/// <summary> /// Fragment a PDU /// </summary> /// <param name="context">RpceContext to fragment PDU</param> /// <typeparam name="T">Type of PDU to fragment</typeparam> /// <param name="pdu">PDU to fragment</param> /// <param name="stubLength">length of data to be fragmented</param> /// <param name="extraLength">length of header and trailer</param> /// <returns>Fragmented PDUs</returns> private static T[] FragmentPdu <T>( RpceContext context, RpceCoPdu pdu, int stubLength, int extraLength) where T : RpceCoPdu { List <T> fragmentPduList = new List <T>(); bool isFirstFragment = true; while (stubLength > 0) { T fragmentPdu = (T)Activator.CreateInstance(typeof(T), context); fragmentPdu.rpc_vers = pdu.rpc_vers; fragmentPdu.rpc_vers_minor = pdu.rpc_vers_minor; fragmentPdu.PTYPE = pdu.PTYPE; fragmentPdu.pfc_flags = pdu.pfc_flags & ~(RpceCoPfcFlags.PFC_FIRST_FRAG | RpceCoPfcFlags.PFC_LAST_FRAG); fragmentPdu.packed_drep = pdu.packed_drep; fragmentPdu.frag_length = (ushort)Math.Min(context.MaxTransmitFragmentSize, stubLength + extraLength); fragmentPdu.auth_length = pdu.auth_length; fragmentPdu.call_id = pdu.call_id; if (isFirstFragment) { fragmentPdu.pfc_flags |= RpceCoPfcFlags.PFC_FIRST_FRAG; isFirstFragment = false; } if (stubLength <= (context.MaxTransmitFragmentSize - extraLength)) { fragmentPdu.pfc_flags |= RpceCoPfcFlags.PFC_LAST_FRAG; } stubLength -= (context.MaxTransmitFragmentSize - extraLength); fragmentPduList.Add(fragmentPdu); } return(fragmentPduList.ToArray()); }
/// <summary> /// Generate PFC_*** based on context and package type. /// </summary> /// <param name="context">Context of the session.</param> /// <param name="packageType">package type.</param> /// <returns>RFC_*** flag.</returns> internal static RpceCoPfcFlags GeneratePfcFlags(RpceContext context, RpcePacketType packageType) { RpceServerSessionContext sessionContext = context as RpceServerSessionContext; RpceCoPfcFlags flags = RpceCoPfcFlags.PFC_FIRST_FRAG | RpceCoPfcFlags.PFC_LAST_FRAG; if (sessionContext == null) //client-side { if (context.SupportsConcurrentMultiplexing) { flags |= RpceCoPfcFlags.PFC_CONC_MPX; } } else if ( //server-side (packageType == RpcePacketType.BindAck && sessionContext.ServerContext.SupportsConcurrentMultiplexing) || // first response, read server context sessionContext.SupportsConcurrentMultiplexing) // if it's not first response, we can read session context { flags |= RpceCoPfcFlags.PFC_CONC_MPX; } if ((packageType == RpcePacketType.Bind || packageType == RpcePacketType.BindAck || packageType == RpcePacketType.AlterContext || packageType == RpcePacketType.AlterContextResp) && context.SupportsHeaderSign) { if (sessionContext == null || //client-side sessionContext.ServerContext.SupportsHeaderSign) //server-side { flags |= RpceCoPfcFlags.PFC_SUPPORT_HEADER_SIGN; } } return(flags); }
/// <summary> /// Initialize an instance of RpceCoRequestPdu class. /// </summary> /// <param name="context">context</param> public RpceCoRequestPdu(RpceContext context) : base(context) { }
/// <summary> /// Initialize an instance of RpceCoFaultPdu class. /// </summary> /// <param name="context">context</param> public RpceCoFaultPdu(RpceContext context) : base(context) { }
/// <summary> /// Initialize an instance of RpceCoBindAckPdu class. /// </summary> /// <param name="context">context</param> public RpceCoBindAckPdu(RpceContext context) : base(context) { }
/// <summary> /// Initialize an instance of RpceCoAuth3Pdu class. /// </summary> /// <param name="context">context</param> public RpceCoAuth3Pdu(RpceContext context) : base(context) { }
/// <summary> /// Initialize an instance of RpceCoRequestPdu class. /// </summary> /// <param name="context">context</param> public RpceCoRequestPdu(RpceContext context) : base(context) { }
/// <summary> /// Fragment a PDU into several PDUs by max_xmit_frag field.<para/> /// Only bind, bind_ack, alter_context, alter_context_response, /// request and response PDUs will be fragmented.<para/> /// Must call before sign/encrypt. /// </summary> /// <param name="context">RpceContext to fragment PDU</param> /// <param name="pdu"> /// A PDU to be fragmented. /// Only bind, bind_ack, alter_context, alter_context_response, /// request and response PDUs will be fragmented. /// </param> /// <returns>Fragmented PDUs.</returns> /// <exception cref="ArgumentNullException"> /// Thrown when pdu or context is null. /// </exception> /// <exception cref="NotSupportedException">Thrown when PDU PacketType isn't supported.</exception> public static RpceCoPdu[] FragmentPdu(RpceContext context, RpceCoPdu pdu) { if (context == null) { throw new ArgumentNullException("context"); } if (pdu == null) { throw new ArgumentNullException("pdu"); } if (pdu.frag_length > context.MaxTransmitFragmentSize) { int headerAndTrailerSize; byte[] stub; switch (pdu.PTYPE) { case RpcePacketType.Request: //Get stub of request PDU RpceCoRequestPdu requestPdu = pdu as RpceCoRequestPdu; if (requestPdu == null) { throw new ArgumentException("The pdu is not a valid RpceCoRequestPdu."); } headerAndTrailerSize = requestPdu.GetSize(); if (requestPdu.auth_verifier != null) { //length of auth_verifier headerAndTrailerSize += RpceUtility.AUTH_VERIFIER_SIZE; headerAndTrailerSize += requestPdu.auth_verifier.Value.auth_value.Length; //To keep stub always be padded to 16 bytes, and pdu doesnot exceed max transmit frag size. int stubLength = context.MaxTransmitFragmentSize - headerAndTrailerSize; headerAndTrailerSize += RpceUtility.Align(stubLength, RpceUtility.AUTH_PAD_LENGTH) - stubLength; //The beginning of the verification_trailer header MUST be 4-byte aligned //with respect to the beginning of the PDU. headerAndTrailerSize = RpceUtility.Align(headerAndTrailerSize, RpceUtility.STUB_PAD_LENGTH); } stub = requestPdu.stub ?? new byte[0]; //Fragment RpceCoRequestPdu[] requestFragmentPduList = FragmentPdu <RpceCoRequestPdu>( context, pdu, stub.Length, headerAndTrailerSize); for (int i = 0; i < requestFragmentPduList.Length; i++) { //SHOULD set the alloc_hint field in every PDU to //be the combined stub data length of all remaining fragment PDUs. requestFragmentPduList[i].alloc_hint = (uint)stub.Length; requestFragmentPduList[i].p_cont_id = requestPdu.p_cont_id; requestFragmentPduList[i].opnum = requestPdu.opnum; requestFragmentPduList[i].@object = requestPdu.@object; requestFragmentPduList[i].stub = ArrayUtility.SubArray( stub, 0, Math.Min(stub.Length, context.MaxTransmitFragmentSize - headerAndTrailerSize)); //For request and response PDUs, where the request and response PDUs are //part of a fragmented request or response and authentication is requested, //the sec_trailer structure MUST be present in every fragment of the request //or response. requestFragmentPduList[i].AppendAuthenticationVerifier(); requestFragmentPduList[i].SetLength(); stub = ArrayUtility.SubArray(stub, requestFragmentPduList[i].stub.Length); } return(requestFragmentPduList); case RpcePacketType.Response: //Get stub of response PDU RpceCoResponsePdu responsePdu = pdu as RpceCoResponsePdu; if (responsePdu == null) { throw new ArgumentException("The PDU is not a valid RpceCoResponsePdu"); } headerAndTrailerSize = responsePdu.GetSize(); if (responsePdu.auth_verifier != null) { //length of auth_verifier headerAndTrailerSize += RpceUtility.AUTH_VERIFIER_SIZE; headerAndTrailerSize += responsePdu.auth_verifier.Value.auth_value.Length; //To keep stub always be padded to 16 bytes, and pdu doesnot exceed max transmit frag size. int stubLength = context.MaxTransmitFragmentSize - headerAndTrailerSize; headerAndTrailerSize += RpceUtility.Align(stubLength, RpceUtility.AUTH_PAD_LENGTH) - stubLength; //The beginning of the verification_trailer header MUST be 4-byte aligned //with respect to the beginning of the PDU. headerAndTrailerSize = RpceUtility.Align(headerAndTrailerSize, RpceUtility.STUB_PAD_LENGTH); } stub = responsePdu.stub ?? new byte[0]; //Fragment RpceCoResponsePdu[] responseFragmentPduList = FragmentPdu <RpceCoResponsePdu>( context, pdu, stub.Length, headerAndTrailerSize); for (int i = 0; i < responseFragmentPduList.Length; i++) { //SHOULD set the alloc_hint field in every PDU to //be the combined stub data length of all remaining fragment PDUs. responseFragmentPduList[i].alloc_hint = (uint)stub.Length; responseFragmentPduList[i].p_cont_id = responsePdu.p_cont_id; responseFragmentPduList[i].cancel_count = responsePdu.cancel_count; responseFragmentPduList[i].reserved = responsePdu.reserved; responseFragmentPduList[i].stub = ArrayUtility.SubArray( stub, 0, Math.Min(stub.Length, context.MaxTransmitFragmentSize - headerAndTrailerSize)); //For request and response PDUs, where the request and response PDUs are //part of a fragmented request or response and authentication is requested, //the sec_trailer structure MUST be present in every fragment of the request //or response. responseFragmentPduList[i].AppendAuthenticationVerifier(); responseFragmentPduList[i].SetLength(); stub = ArrayUtility.SubArray(stub, responseFragmentPduList[i].stub.Length); } return(responseFragmentPduList); case RpcePacketType.Bind: case RpcePacketType.BindAck: case RpcePacketType.AlterContext: case RpcePacketType.AlterContextResp: case RpcePacketType.Auth3: //Windows RPC support version 5.0 only. //Bind fragment requires RPC ver 5.1. //We don't support it. throw new NotSupportedException("bind/bind_ack/alt_context/alt_context_resp/auth3 PDU fragment are not supported."); default: throw new InvalidOperationException("PDU PacketType isn't supported."); } } //If we cannot fragment the PDU return(new RpceCoPdu[] { pdu }); }
/// <summary> /// Reassemble several fragment PDUs to one PDU.<para/> /// Must call after decrypt/verify. /// </summary> /// <param name="context">RpceContext to Reassemble PDU.</param> /// <param name="pdus">Fragment PDUs to be reassembled.</param> /// <returns>A ressembled PDU.</returns> /// <exception cref="ArgumentNullException"> /// Thrown when pdus is null. /// </exception> /// <exception cref="ArgumentException"> /// Thrown when pdus is invalid. /// </exception> /// <exception cref="InvalidOperationException">Thrown when Speicified PDU doesn't /// support fragment and reassemble.</exception> public static RpceCoPdu ReassemblePdu(RpceContext context, params RpceCoPdu[] pdus) { if (context == null) { throw new ArgumentNullException("context"); } if (pdus == null) { throw new ArgumentNullException("pdus"); } if (pdus.Length == 0) { throw new ArgumentException("There's no PDU to reassemble.", "pdus"); } //verify if the fisrt pdu has the valid PFC_FIRST_FRAG. if ((pdus[0].pfc_flags & RpceCoPfcFlags.PFC_FIRST_FRAG) == 0) { throw new ArgumentException("First PDU doesn't have PFC_FIRST_FRAG flag.", "pdus"); } //verify if fragments end expected. for (int i = 0; i < pdus.Length - 1; i++) { if ((pdus[i].pfc_flags & RpceCoPfcFlags.PFC_LAST_FRAG) != 0) { throw new ArgumentException("Fragments ended unexpected.", "pdus"); } } if ((pdus[pdus.Length - 1].pfc_flags & RpceCoPfcFlags.PFC_LAST_FRAG) == 0) { throw new ArgumentException("Fragments is not ended.", "pdus"); } //All PTYPEs should be the same. for (int i = 1; i < pdus.Length; i++) { if (pdus[i].PTYPE != pdus[0].PTYPE) { throw new ArgumentException("PDUs' PTYPE are different.", "pdus"); } } if (pdus.Length == 1) { return(pdus[0]); } RpceCoPdu reassembledPdu; switch (pdus[0].PTYPE) { case RpcePacketType.Request: RpceCoRequestPdu requestPdu = pdus[0] as RpceCoRequestPdu; if (requestPdu == null) { throw new ArgumentException("The PDU is not a valid RpceCoRequestPdu"); } for (int i = 1; i < pdus.Length; i++) { requestPdu.stub = ArrayUtility.ConcatenateArrays( requestPdu.stub, ((RpceCoRequestPdu)pdus[i]).stub); } requestPdu.pfc_flags |= RpceCoPfcFlags.PFC_LAST_FRAG; requestPdu.frag_length = (ushort)(requestPdu.GetSize() + requestPdu.stub.Length); requestPdu.auth_length = 0; requestPdu.auth_verifier = null; reassembledPdu = requestPdu; break; case RpcePacketType.Response: RpceCoResponsePdu responsePdu = pdus[0] as RpceCoResponsePdu; if (responsePdu == null) { throw new ArgumentException("The PDU is not a valid RpceCoResponsePdu"); } for (int i = 1; i < pdus.Length; i++) { responsePdu.stub = ArrayUtility.ConcatenateArrays( responsePdu.stub, ((RpceCoResponsePdu)pdus[i]).stub); } responsePdu.pfc_flags |= RpceCoPfcFlags.PFC_LAST_FRAG; responsePdu.frag_length = (ushort)(responsePdu.GetSize() + responsePdu.stub.Length); responsePdu.auth_length = 0; responsePdu.auth_verifier = null; reassembledPdu = responsePdu; break; case RpcePacketType.Bind: case RpcePacketType.BindAck: case RpcePacketType.AlterContext: case RpcePacketType.AlterContextResp: case RpcePacketType.Auth3: //Windows RPC support version 5.0 only. //Bind fragment requires RPC ver 5.1. //We don't support it. throw new NotSupportedException("bind/bind_ack/alt_context/alt_context_resp/auth3 PDU fragment are not supported."); default: throw new InvalidOperationException("Speicified PDU doesn't support fragment and reassemble."); } return(reassembledPdu); }
/// <summary> /// Initialize an instance of RpceCoCancelPdu class, and /// unmarshal a byte array to PDU struct. /// </summary> /// <param name="context">context</param> /// <param name="pduBytes">A byte array contains PDU data.</param> public RpceCoCancelPdu(RpceContext context, byte[] pduBytes) : base(context, pduBytes) { }
public static RpceCoPdu DecodeCoPdu( RpceContext context, byte[] pduBytes) { if (context == null) { throw new ArgumentNullException("context"); } if (pduBytes == null) { throw new ArgumentNullException("pduBytes"); } RpceCoPdu pdu; //#2 byte is PTYPE RpcePacketType packageType = (RpcePacketType)pduBytes[2]; //#3 byte is PFC_*** flags RpceCoPfcFlags pfcFlags = (RpceCoPfcFlags)pduBytes[3]; RpceCoPfcFlags pfcFlagsNoFragment = RpceCoPfcFlags.PFC_FIRST_FRAG | RpceCoPfcFlags.PFC_LAST_FRAG; if (((pfcFlags & pfcFlagsNoFragment) != pfcFlagsNoFragment) && (packageType == RpcePacketType.Bind || packageType == RpcePacketType.BindAck || packageType == RpcePacketType.AlterContext || packageType == RpcePacketType.AlterContextResp || packageType == RpcePacketType.Auth3)) { //If it's a fragment and PTYPE is bind/bind_ack/alter_context/alter_context_resp //Windows RPC support version 5.0 only. //Bind fragment requires RPC ver 5.1. //We don't support it. throw new NotSupportedException("bind/bind_ack/alt_context/alt_context_resp/auth3 PDU fragment are not supported."); } else { switch (packageType) { case RpcePacketType.Bind: pdu = new RpceCoBindPdu(context, pduBytes); break; case RpcePacketType.BindAck: pdu = new RpceCoBindAckPdu(context, pduBytes); break; case RpcePacketType.BindNak: pdu = new RpceCoBindNakPdu(context, pduBytes); break; case RpcePacketType.AlterContext: pdu = new RpceCoAlterContextPdu(context, pduBytes); break; case RpcePacketType.AlterContextResp: pdu = new RpceCoAlterContextRespPdu(context, pduBytes); break; case RpcePacketType.Auth3: pdu = new RpceCoAuth3Pdu(context, pduBytes); break; case RpcePacketType.Request: pdu = new RpceCoRequestPdu(context, pduBytes); break; case RpcePacketType.Response: pdu = new RpceCoResponsePdu(context, pduBytes); break; case RpcePacketType.Fault: pdu = new RpceCoFaultPdu(context, pduBytes); break; case RpcePacketType.CoCancel: pdu = new RpceCoCancelPdu(context, pduBytes); break; case RpcePacketType.Orphaned: pdu = new RpceCoOrphanedPdu(context, pduBytes); break; case RpcePacketType.Shutdown: pdu = new RpceCoShutdownPdu(context, pduBytes); break; default: throw new InvalidOperationException( string.Format("Receive invalid packet - {0}.", packageType)); } } return(pdu); }
/// <summary> /// Initialize an instance of RpceCoOrphanedPdu class, and /// unmarshal a byte array to PDU struct. /// </summary> /// <param name="context">context</param> /// <param name="pduBytes">A byte array contains PDU data.</param> public RpceCoOrphanedPdu(RpceContext context, byte[] pduBytes) : base(context, pduBytes) { }
/// <summary> /// Initialize an instance of RpceCoCancelPdu class. /// </summary> /// <param name="context">context</param> public RpceCoCancelPdu(RpceContext context) : base(context) { }
/// <summary> /// Initialize an instance of RpceCoOrphanedPdu class. /// </summary> /// <param name="context">context</param> public RpceCoOrphanedPdu(RpceContext context) : base(context) { }
/// <summary> /// Initialize an instance of RpceCoOrphanedPdu class, and /// unmarshal a byte array to PDU struct. /// </summary> /// <param name="context">context</param> /// <param name="pduBytes">A byte array contains PDU data.</param> public RpceCoOrphanedPdu(RpceContext context, byte[] pduBytes) : base(context, pduBytes) { }
/// <summary> /// Initialize an instance of RpceCoOrphanedPdu class. /// </summary> /// <param name="context">context</param> public RpceCoOrphanedPdu(RpceContext context) : base(context) { }
/// <summary> /// Initialize an instance of RpceCoShutdownPdu class, and /// unmarshal a byte array to PDU struct. /// </summary> /// <param name="context">context</param> /// <param name="pduBytes">A byte array contains PDU data.</param> public RpceCoShutdownPdu(RpceContext context, byte[] pduBytes) : base(context, pduBytes) { }
/// <summary> /// Initialize an instance of RpceCoBindPdu class. /// </summary> /// <param name="context">context</param> public RpceCoBindPdu(RpceContext context) : base(context) { }
/// <summary> /// Initialize an instance of RpceCoFaultPdu class. /// </summary> /// <param name="context">context</param> public RpceCoFaultPdu(RpceContext context) : base(context) { }
/// <summary> /// Initialize an instance of RpceCoCancelPdu class, and /// unmarshal a byte array to PDU struct. /// </summary> /// <param name="context">context</param> /// <param name="pduBytes">A byte array contains PDU data.</param> public RpceCoCancelPdu(RpceContext context, byte[] pduBytes) : base(context, pduBytes) { }
/// <summary> /// Initialize an instance of RpceCoFaultPdu class, and /// unmarshal a byte array to PDU struct. /// </summary> /// <param name="context">context</param> /// <param name="pduBytes">A byte array contains PDU data.</param> public RpceCoFaultPdu(RpceContext context, byte[] pduBytes) : base(context, pduBytes) { }
/// <summary> /// Initialize an instance of RpceCoAlterContextPdu class. /// </summary> /// <param name="context">context</param> public RpceCoAlterContextPdu(RpceContext context) : base(context) { }
/// <summary> /// Initialize an instance of RpceCoPdu class. /// </summary> /// <param name="context">context</param> protected RpceCoPdu(RpceContext context) : base(context) { }
/// <summary> /// Initialize an instance of RpceCoAuth3Pdu class, and /// unmarshal a byte array to PDU struct. /// </summary> /// <param name="context">context</param> /// <param name="pduBytes">A byte array contains PDU data.</param> public RpceCoAuth3Pdu(RpceContext context, byte[] pduBytes) : base(context, pduBytes) { }
/// <summary> /// Initialize an instance of RpceCoAuth3Pdu class. /// </summary> /// <param name="context">context</param> public RpceCoAuth3Pdu(RpceContext context) : base(context) { }
/// <summary> /// Initialize an instance of RpceCoAlterContextRespPdu class. /// </summary> /// <param name="context">context</param> public RpceCoAlterContextRespPdu(RpceContext context) : base(context) { }
/// <summary> /// Initialize an instance of RpceCoBindPdu class, and /// unmarshal a byte array to PDU struct. /// </summary> /// <param name="context">context</param> /// <param name="pduBytes">A byte array contains PDU data.</param> public RpceCoBindPdu(RpceContext context, byte[] pduBytes) : base(context, pduBytes) { }
/// <summary> /// Initialize an instance of RpceCoCancelPdu class. /// </summary> /// <param name="context">context</param> public RpceCoCancelPdu(RpceContext context) : base(context) { }
protected RpceCoPdu(RpceContext context, byte[] pduBytes) : base(context, pduBytes) { using (BinaryReader binaryReader = new BinaryReader(new MemoryStream(pduBytes))) { FromBytes(binaryReader); } }
/// <summary> /// Initialize an instance of RpceCoShutdownPdu class. /// </summary> /// <param name="context">context</param> public RpceCoShutdownPdu(RpceContext context) : base(context) { }
/// <summary> /// Initialize an instance of RpceCoAuth3Pdu class, and /// unmarshal a byte array to PDU struct. /// </summary> /// <param name="context">context</param> /// <param name="pduBytes">A byte array contains PDU data.</param> public RpceCoAuth3Pdu(RpceContext context, byte[] pduBytes) : base(context, pduBytes) { }
/// <summary> /// Initialize an instance of RpceCoShutdownPdu class, and /// unmarshal a byte array to PDU struct. /// </summary> /// <param name="context">context</param> /// <param name="pduBytes">A byte array contains PDU data.</param> public RpceCoShutdownPdu(RpceContext context, byte[] pduBytes) : base(context, pduBytes) { }
/// <summary> /// Initialize an instance of RpceCoAlterContextRespPdu class, and /// unmarshal a byte array to PDU struct. /// </summary> /// <param name="context">context</param> /// <param name="pduBytes">A byte array contains PDU data.</param> public RpceCoAlterContextRespPdu(RpceContext context, byte[] pduBytes) : base(context, pduBytes) { }
/// <summary> /// Initialize an instance of RpceCoResponsePdu class. /// </summary> /// <param name="context">context</param> public RpceCoResponsePdu(RpceContext context) : base(context) { }
/// <summary> /// Initialize an instance of RpceCoAlterContextPdu class, and /// unmarshal a byte array to PDU struct. /// </summary> /// <param name="context">context</param> /// <param name="pduBytes">A byte array contains PDU data.</param> public RpceCoAlterContextPdu(RpceContext context, byte[] pduBytes) : base(context, pduBytes) { }
/// <summary> /// Initialize an instance of RpceCoResponsePdu class, and /// unmarshal a byte array to PDU struct. /// </summary> /// <param name="context">context</param> /// <param name="pduBytes">A byte array contains PDU data.</param> public RpceCoResponsePdu(RpceContext context, byte[] pduBytes) : base(context, pduBytes) { }
/// <summary> /// Initialize an instance of RpceCoRequestPdu class, and /// unmarshal a byte array to PDU struct. /// </summary> /// <param name="context">context</param> /// <param name="pduBytes">A byte array contains PDU data.</param> public RpceCoRequestPdu(RpceContext context, byte[] pduBytes) : base(context, pduBytes) { }
/// <summary> /// Initialize an instance of RpceCoResponsePdu class. /// </summary> /// <param name="context">context</param> public RpceCoResponsePdu(RpceContext context) : base(context) { }
/// <summary> /// Initialize an instance of RpceCoFaultPdu class, and /// unmarshal a byte array to PDU struct. /// </summary> /// <param name="context">context</param> /// <param name="pduBytes">A byte array contains PDU data.</param> public RpceCoFaultPdu(RpceContext context, byte[] pduBytes) : base(context, pduBytes) { }
/// <summary> /// Initialize an instance of RpceCoResponsePdu class, and /// unmarshal a byte array to PDU struct. /// </summary> /// <param name="context">context</param> /// <param name="pduBytes">A byte array contains PDU data.</param> public RpceCoResponsePdu(RpceContext context, byte[] pduBytes) : base(context, pduBytes) { }
/// <summary> /// Initialize an instance of RpceCoBindAckPdu class, and /// unmarshal a byte array to PDU struct. /// </summary> /// <param name="context">context</param> /// <param name="pduBytes">A byte array contains PDU data.</param> public RpceCoBindAckPdu(RpceContext context, byte[] pduBytes) : base(context, pduBytes) { }
/// <summary> /// Initialize an instance of RpceCoPdu class. /// </summary> /// <param name="context">context</param> protected RpceCoPdu(RpceContext context) : base(context) { }
/// <summary> /// Initialize an instance of RpceCoRequestPdu class, and /// unmarshal a byte array to PDU struct. /// </summary> /// <param name="context">context</param> /// <param name="pduBytes">A byte array contains PDU data.</param> public RpceCoRequestPdu(RpceContext context, byte[] pduBytes) : base(context, pduBytes) { }
/// <summary> /// Initialize an instance of RpceCoShutdownPdu class. /// </summary> /// <param name="context">context</param> public RpceCoShutdownPdu(RpceContext context) : base(context) { }