public SecurityVerifiedMessage(Message messageToProcess, ReceiveSecurityHeader securityHeader) : base(messageToProcess) { ReceivedSecurityHeader = securityHeader; if (securityHeader.RequireMessageProtection) { XmlDictionaryReader messageReader; BufferedMessage bufferedMessage = InnerMessage as BufferedMessage; if (bufferedMessage != null && Headers.ContainsOnlyBufferedMessageHeaders) { messageReader = bufferedMessage.GetMessageReader(); } else { _messageBuffer = new XmlBuffer(int.MaxValue); XmlDictionaryWriter writer = _messageBuffer.OpenSection(ReceivedSecurityHeader.ReaderQuotas); InnerMessage.WriteMessage(writer); _messageBuffer.CloseSection(); _messageBuffer.Close(); messageReader = _messageBuffer.GetReader(0); } MoveToSecurityHeader(messageReader, securityHeader.HeaderIndex, true); _cachedReaderAtSecurityHeader = messageReader; _state = BodyState.Buffered; } else { _envelopeAttributes = XmlAttributeHolder.emptyArray; _headerAttributes = XmlAttributeHolder.emptyArray; _bodyAttributes = XmlAttributeHolder.emptyArray; _canDelegateCreateBufferedCopyToInnerMessage = true; } }
protected override void OnWriteStartBody(XmlDictionaryWriter writer) { if (_startBodyFragment != null || _fullBodyFragment != null) { WriteStartInnerMessageWithId(writer); return; } switch (_state) { case BodyState.Created: case BodyState.Encrypted: InnerMessage.WriteStartBody(writer); return; case BodyState.Signed: case BodyState.EncryptedThenSigned: XmlDictionaryReader reader = _fullBodyBuffer.GetReader(0); writer.WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI); writer.WriteAttributes(reader, false); reader.Close(); return; case BodyState.SignedThenEncrypted: writer.WriteStartElement(_bodyPrefix, XD.MessageDictionary.Body, Version.Envelope.DictionaryNamespace); if (_bodyAttributes != null) { XmlAttributeHolder.WriteAttributes(_bodyAttributes, writer); } return; default: throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateBadStateException(nameof(OnWriteStartBody))); } }
public override byte[] GetBytes() { StringBuilder builder = new StringBuilder(128); builder.Append(Command); if (noTransactionIDCommands.IndexOf(Command) == -1) { if (TransactionID != -1) { builder.Append(' '); builder.Append(TransactionID.ToString(CultureInfo.InvariantCulture)); } } foreach (string val in CommandValues) { builder.Append(' '); builder.Append(val); } if (InnerMessage != null) { builder.Append(' '); builder.Append(InnerMessage.GetBytes().Length); builder.Append("\r\n"); return(AppendArray(System.Text.Encoding.UTF8.GetBytes(builder.ToString()), InnerMessage.GetBytes())); } else { builder.Append("\r\n"); return(System.Text.Encoding.UTF8.GetBytes(builder.ToString())); } }
/// <summary> /// Get the debug string representation of the message /// </summary> /// <returns></returns> /// <remarks> /// To futher developers: /// You cannot simply apply Encoding.UTF8.GetString(GetByte()) in this function /// since the InnerMessage of MSNMessage may contain binary data. /// </remarks> public override string ToString() { StringBuilder builder = new StringBuilder(128); builder.Append(Command); if (noTransactionIDCommands.IndexOf(Command) == -1) { if (TransactionID != -1) { builder.Append(' '); builder.Append(TransactionID.ToString(CultureInfo.InvariantCulture)); } } foreach (string val in CommandValues) { builder.Append(' '); builder.Append(val); } if (InnerMessage != null) { builder.Append(' '); builder.Append(InnerMessage.GetBytes().Length); } //For toString, we do not return the inner message's string. return(builder.ToString()); }
unsafe Int64 MyDotaChatFunction(void *a1, void *a2) { //Native.MessageBeep((uint)Native.BeepType.Asterisk); string s = dllpurpose; DotaMessage chat = *(DotaMessage *)a2; string type = Marshal.PtrToStringAnsi((IntPtr)chat.type); string username = Marshal.PtrToStringAnsi((IntPtr)chat.username); string message = ""; InnerMessage innermessage = *chat.innermessage; if (innermessage.check < 0x10) { message = Marshal.PtrToStringAnsi((IntPtr)(&innermessage.message)); } else { message = Marshal.PtrToStringAnsi((IntPtr)innermessage.message); } string json = string.Format("{{ \"Type\" : \"{0}\",\"Username\" : \"{1}\",\"Message\" : \"{2}\" }}", type, username, message); lock (this._messageQueue) { if (this._messageQueue.Count < 1000) { // Add message to send to server this._messageQueue.Enqueue(json); } } return(originalMethod(a1, a2)); }
/// <summary> /// Prepares the messages before it is sended. Some message objects will set properties in their /// 'parent' message object in this method. This method is automatically called for /// the inner message object, if present. /// </summary> public virtual void PrepareMessage() { if (InnerMessage != null) { InnerMessage.PrepareMessage(); } }
protected override void OnWriteBodyContents(XmlDictionaryWriter writer) { switch (_state) { case BodyState.Created: InnerMessage.WriteBodyContents(writer); return; case BodyState.Signed: case BodyState.EncryptedThenSigned: XmlDictionaryReader reader = _fullBodyBuffer.GetReader(0); reader.ReadStartElement(); while (reader.NodeType != XmlNodeType.EndElement) { writer.WriteNode(reader, false); } reader.ReadEndElement(); reader.Close(); return; case BodyState.Encrypted: case BodyState.SignedThenEncrypted: _encryptedBodyContent.WriteTo(writer, ServiceModelDictionaryManager.Instance); break; default: throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateBadStateException(nameof(OnWriteBodyContents))); } }
protected override void OnWriteMessage(XmlDictionaryWriter writer) { // For Kerb one shot, the channel binding will be need to be fished out of the message, cached and added to the // token before calling ISC. AttachChannelBindingTokenIfFound(); EnsureUniqueSecurityApplication(); MessagePrefixGenerator prefixGenerator = new MessagePrefixGenerator(writer); _securityHeader.StartSecurityApplication(); Headers.Add(_securityHeader); InnerMessage.WriteStartEnvelope(writer); Headers.RemoveAt(Headers.Count - 1); _securityHeader.ApplyBodySecurity(writer, prefixGenerator); InnerMessage.WriteStartHeaders(writer); _securityHeader.ApplySecurityAndWriteHeaders(Headers, writer, prefixGenerator); _securityHeader.RemoveSignatureEncryptionIfAppropriate(); _securityHeader.CompleteSecurityApplication(); _securityHeader.WriteHeader(writer, Version); writer.WriteEndElement(); if (_fullBodyFragment != null) { ((IFragmentCapableXmlDictionaryWriter)writer).WriteFragment(_fullBodyFragment, 0, _fullBodyFragmentLength); } else { if (_startBodyFragment != null) { ((IFragmentCapableXmlDictionaryWriter)writer).WriteFragment(_startBodyFragment.GetBuffer(), 0, (int)_startBodyFragment.Length); } else { OnWriteStartBody(writer); } OnWriteBodyContents(writer); if (_endBodyFragment != null) { ((IFragmentCapableXmlDictionaryWriter)writer).WriteFragment(_endBodyFragment.GetBuffer(), 0, (int)_endBodyFragment.Length); } else { writer.WriteEndElement(); } } writer.WriteEndElement(); }
private void WriteStartInnerMessageWithId(XmlDictionaryWriter writer) { InnerMessage.WriteStartBody(writer); if (_bodyIdInserted) { _securityHeader.StandardsManager.IdManager.WriteIdAttribute(writer, BodyId); } }
/// <summary> /// Returns debug info /// </summary> /// <returns></returns> public override string ToString() { return("[P2PMessage]\r\n" + header.ToString() + String.Format(System.Globalization.CultureInfo.InvariantCulture, "FOOTER : {1:x} ({1})\r\n", Footer.ToString(System.Globalization.CultureInfo.InvariantCulture), Footer) + String.Format(System.Globalization.CultureInfo.InvariantCulture, "DATA : {0}\r\n", ((InnerMessage != null) ? InnerMessage.ToString() : String.Format("Binary data: {0:D} bytes", (InnerBody == null ? 0 : InnerBody.Length))))); }
protected override MessageBuffer OnCreateBufferedCopy(int maxBufferSize) { if (_canDelegateCreateBufferedCopyToInnerMessage && InnerMessage is BufferedMessage) { return(InnerMessage.CreateBufferedCopy(maxBufferSize)); } else { return(base.OnCreateBufferedCopy(maxBufferSize)); } }
/// <summary> /// Textual presentation. /// </summary> /// <returns></returns> public string ToDebugString() { if (InnerMessage != null) { return(ToString() + "\r\n" + InnerMessage.ToDebugString()); } else { return(ToString()); } }
private void SetBodyId() { BodyId = InnerMessage.GetBodyAttribute( UtilityStrings.IdAttribute, _securityHeader.StandardsManager.IdManager.DefaultIdNamespaceUri); if (BodyId == null) { BodyId = _securityHeader.GenerateId(); _bodyIdInserted = true; } }
public void AddMessage(String text) { var inner = new InnerMessage(text) { HoldOn = DateTime.UtcNow }; lock (messages) { messages.Add(inner); } }
public void WriteBodyToEncrypt(EncryptedData encryptedData, SymmetricAlgorithm algorithm) { encryptedData.Id = _securityHeader.GenerateId(); BodyContentHelper helper = new BodyContentHelper(); XmlDictionaryWriter encryptingWriter = helper.CreateWriter(); InnerMessage.WriteBodyContents(encryptingWriter); encryptedData.SetUpEncryption(algorithm, helper.ExtractResult()); _encryptedBodyContent = encryptedData; _state = BodyState.Encrypted; }
protected override void OnClose() { try { InnerMessage.Close(); } finally { _fullBodyBuffer = null; _bodyAttributes = null; _state = BodyState.Disposed; } }
protected override void OnWriteStartBody(XmlDictionaryWriter writer) { if (_state == BodyState.Created) { InnerMessage.WriteStartBody(writer); return; } XmlDictionaryReader reader = CreateFullBodyReader(); reader.MoveToContent(); writer.WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI); writer.WriteAttributes(reader, false); reader.Close(); }
public override string ToString() { string contentEncoding = string.Empty; string debugString = string.Empty; if (ContentHeaders.ContainsKey(MIMEContentHeaders.ContentTransferEncoding) && InnerBody != null) { contentEncoding = ContentHeaders[MIMEContentHeaders.ContentTransferEncoding].Value; } byte[] readableBinaries = GetBytes(); switch (contentEncoding) { case MIMEContentTransferEncoding.Binary: int payLoadLength = 0; payLoadLength = InnerBody.Length; byte[] headers = new byte[readableBinaries.Length - payLoadLength]; Buffer.BlockCopy(readableBinaries, 0, headers, 0, headers.Length); if (InnerBody != null && InnerMessage == null) { if (ContentHeaders.ContainsKey(MIMEContentHeaders.BridgingOffsets)) { debugString = Encoding.UTF8.GetString(headers) + "\r\nMulti-Package Binary Data: {Length: " + payLoadLength + "}"; } else { debugString = Encoding.UTF8.GetString(headers) + "\r\nUnknown Binary Data: {Length: " + payLoadLength + "}"; } } if (InnerBody != null && InnerMessage != null) { debugString = Encoding.UTF8.GetString(headers) + "\r\n" + InnerMessage.ToString(); } break; default: debugString = Encoding.UTF8.GetString(readableBinaries); break; } return(debugString); }
public static InnerMessageDto ToDto(this InnerMessage message) { return(new InnerMessageDto { Id = message.Id, Status = message.Status, LastActivity = message.LastActivity, Title = message.Title, ReceiverType = message.ReceiverType, ReceiverId = message.ReceiverId, SenderType = message.SenderType, SentBySystem = message.SentBySystem, Created = message.Created, Body = message.Body, OneResponseForAll = message.OneResponseForAll, SenderId = message.SenderId }); }
public void WriteBodyToSignWithFragments(Stream stream, bool includeComments, string[] inclusivePrefixes, XmlDictionaryWriter writer) { IFragmentCapableXmlDictionaryWriter fragmentingWriter = (IFragmentCapableXmlDictionaryWriter)writer; SetBodyId(); BufferedOutputStream fullBodyFragment = new BufferManagerOutputStream(SR.XmlBufferQuotaExceeded, 1024, int.MaxValue, _securityHeader.StreamBufferManager); writer.StartCanonicalization(stream, includeComments, inclusivePrefixes); fragmentingWriter.StartFragment(fullBodyFragment, false); WriteStartInnerMessageWithId(writer); InnerMessage.WriteBodyContents(writer); writer.WriteEndElement(); fragmentingWriter.EndFragment(); writer.EndCanonicalization(); _fullBodyFragment = fullBodyFragment.ToArray(out _fullBodyFragmentLength); _state = BodyState.Signed; }
protected override void OnWriteBodyContents(XmlDictionaryWriter writer) { if (_state == BodyState.Created) { InnerMessage.WriteBodyContents(writer); return; } XmlDictionaryReader reader = CreateFullBodyReader(); reader.ReadStartElement(); while (reader.NodeType != XmlNodeType.EndElement) { writer.WriteNode(reader, false); } reader.ReadEndElement(); reader.Close(); }
protected override void OnClose() { if (_cachedDecryptedBodyContentReader != null) { try { _cachedDecryptedBodyContentReader.Close(); } catch (IOException) { } finally { _cachedDecryptedBodyContentReader = null; } } if (_cachedReaderAtSecurityHeader != null) { try { _cachedReaderAtSecurityHeader.Close(); } catch (IOException) { } finally { _cachedReaderAtSecurityHeader = null; } } _messageBuffer = null; _decryptedBuffer = null; _state = BodyState.Disposed; InnerMessage.Close(); }
public void WriteBodyToEncryptThenSign(Stream canonicalStream, EncryptedData encryptedData, SymmetricAlgorithm algorithm) { encryptedData.Id = _securityHeader.GenerateId(); SetBodyId(); XmlDictionaryWriter encryptingWriter = XmlDictionaryWriter.CreateTextWriter(Stream.Null); // The XmlSerializer body formatter would add a // document declaration to the body fragment when a fresh writer // is provided. Hence, insert a dummy element here and capture // the body contents as a fragment. encryptingWriter.WriteStartElement("a"); MemoryStream ms = new MemoryStream(); ((IFragmentCapableXmlDictionaryWriter)encryptingWriter).StartFragment(ms, true); InnerMessage.WriteBodyContents(encryptingWriter); ((IFragmentCapableXmlDictionaryWriter)encryptingWriter).EndFragment(); encryptingWriter.WriteEndElement(); ms.Flush(); encryptedData.SetUpEncryption(algorithm, new ArraySegment <byte>(ms.GetBuffer(), 0, (int)ms.Length)); _fullBodyBuffer = new XmlBuffer(int.MaxValue); XmlDictionaryWriter canonicalWriter = _fullBodyBuffer.OpenSection(XmlDictionaryReaderQuotas.Max); canonicalWriter.StartCanonicalization(canonicalStream, false, null); WriteStartInnerMessageWithId(canonicalWriter); encryptedData.WriteTo(canonicalWriter, ServiceModelDictionaryManager.Instance); canonicalWriter.WriteEndElement(); canonicalWriter.EndCanonicalization(); canonicalWriter.Flush(); _fullBodyBuffer.CloseSection(); _fullBodyBuffer.Close(); _state = BodyState.EncryptedThenSigned; }
public void WriteBodyToSignThenEncryptWithFragments( Stream stream, bool includeComments, string[] inclusivePrefixes, EncryptedData encryptedData, SymmetricAlgorithm algorithm, XmlDictionaryWriter writer) { IFragmentCapableXmlDictionaryWriter fragmentingWriter = (IFragmentCapableXmlDictionaryWriter)writer; SetBodyId(); encryptedData.Id = _securityHeader.GenerateId(); _startBodyFragment = new MemoryStream(); BufferedOutputStream bodyContentFragment = new BufferManagerOutputStream(SR.XmlBufferQuotaExceeded, 1024, int.MaxValue, _securityHeader.StreamBufferManager); _endBodyFragment = new MemoryStream(); writer.StartCanonicalization(stream, includeComments, inclusivePrefixes); fragmentingWriter.StartFragment(_startBodyFragment, false); WriteStartInnerMessageWithId(writer); fragmentingWriter.EndFragment(); fragmentingWriter.StartFragment(bodyContentFragment, true); InnerMessage.WriteBodyContents(writer); fragmentingWriter.EndFragment(); fragmentingWriter.StartFragment(_endBodyFragment, false); writer.WriteEndElement(); fragmentingWriter.EndFragment(); writer.EndCanonicalization(); byte[] bodyBuffer = bodyContentFragment.ToArray(out int bodyLength); encryptedData.SetUpEncryption(algorithm, new ArraySegment <byte>(bodyBuffer, 0, bodyLength)); _encryptedBodyContent = encryptedData; _state = BodyState.SignedThenEncrypted; }
public SecurityVerifiedMessage(Message messageToProcess, ReceiveSecurityHeader securityHeader) : base(messageToProcess) { ReceivedSecurityHeader = securityHeader; if (securityHeader.RequireMessageProtection) { XmlDictionaryReader messageReader; if (InnerMessage is BufferedMessage bufferedMessage && Headers.ContainsOnlyBufferedMessageHeaders) { messageReader = bufferedMessage.GetMessageReader(); } else { _messageBuffer = new XmlBuffer(int.MaxValue); XmlDictionaryWriter writer = _messageBuffer.OpenSection(ReceivedSecurityHeader.ReaderQuotas); InnerMessage.WriteMessage(writer); _messageBuffer.CloseSection(); _messageBuffer.Close(); messageReader = _messageBuffer.GetReader(0); } MoveToSecurityHeader(messageReader, securityHeader.HeaderIndex, true); _cachedReaderAtSecurityHeader = messageReader; _state = BodyState.Buffered; }
protected override XmlDictionaryReader OnGetReaderAtBodyContents() { if (_state == BodyState.Created) { return(InnerMessage.GetReaderAtBodyContents()); } if (_bodyDecrypted) { EnsureDecryptedBodyStatusDetermined(); } if (_cachedDecryptedBodyContentReader != null) { XmlDictionaryReader result = _cachedDecryptedBodyContentReader; _cachedDecryptedBodyContentReader = null; return(result); } else { XmlDictionaryReader reader = CreateFullBodyReader(); reader.ReadStartElement(); reader.MoveToContent(); return(reader); } }
/// <summary> /// Split big P2PMessages to transport over sb or dc. /// </summary> /// <param name="maxSize"></param> /// <returns></returns> public P2PMessage[] SplitMessage(int maxSize) { uint payloadMessageSize = 0; if (Version == P2PVersion.P2PV1) { payloadMessageSize = V1Header.MessageSize; } if (Version == P2PVersion.P2PV2) { payloadMessageSize = (uint)V2Header.MessageSize - (uint)V2Header.DataPacketHeaderLength; } if (payloadMessageSize <= maxSize) { return new P2PMessage[] { this } } ; List <P2PMessage> chunks = new List <P2PMessage>(); byte[] totalMessage = (InnerBody != null) ? InnerBody : InnerMessage.GetBytes(); long offset = 0; if (Version == P2PVersion.P2PV1) { while (offset < totalMessage.LongLength) { P2PMessage chunkMessage = new P2PMessage(Version); uint messageSize = (uint)Math.Min((uint)maxSize, (totalMessage.LongLength - offset)); byte[] chunk = new byte[messageSize]; Buffer.BlockCopy(totalMessage, (int)offset, chunk, 0, (int)messageSize); chunkMessage.V1Header.Flags = V1Header.Flags; chunkMessage.V1Header.AckIdentifier = V1Header.AckIdentifier; chunkMessage.V1Header.AckTotalSize = V1Header.AckTotalSize; chunkMessage.V1Header.Identifier = V1Header.Identifier; chunkMessage.V1Header.SessionId = V1Header.SessionId; chunkMessage.V1Header.TotalSize = V1Header.TotalSize; chunkMessage.V1Header.Offset = (ulong)offset; chunkMessage.V1Header.MessageSize = messageSize; chunkMessage.InnerBody = chunk; chunkMessage.V1Header.AckSessionId = V1Header.AckSessionId; chunkMessage.Footer = Footer; chunkMessage.PrepareMessage(); chunks.Add(chunkMessage); offset += messageSize; } } if (Version == P2PVersion.P2PV2) { uint nextId = Header.Identifier; long dataRemain = (long)V2Header.DataRemaining; while (offset < totalMessage.LongLength) { P2PMessage chunkMessage = new P2PMessage(Version); int maxDataSize = maxSize; if (offset == 0 && V2Header.HeaderTLVs.Count > 0) { foreach (KeyValuePair <byte, byte[]> keyvalue in V2Header.HeaderTLVs) { chunkMessage.V2Header.HeaderTLVs[keyvalue.Key] = keyvalue.Value; } maxDataSize = maxSize - chunkMessage.V2Header.HeaderLength; } uint dataSize = (uint)Math.Min((uint)maxDataSize, (totalMessage.LongLength - offset)); byte[] chunk = new byte[dataSize]; Buffer.BlockCopy(totalMessage, (int)offset, chunk, 0, (int)dataSize); if (offset == 0) { chunkMessage.V2Header.OperationCode = V2Header.OperationCode; } chunkMessage.V2Header.SessionId = V2Header.SessionId; chunkMessage.V2Header.TFCombination = V2Header.TFCombination; chunkMessage.V2Header.PackageNumber = V2Header.PackageNumber; if (totalMessage.LongLength + dataRemain - (dataSize + offset) > 0) { chunkMessage.V2Header.DataRemaining = (ulong)(totalMessage.LongLength + dataRemain - (dataSize + offset)); } if ((offset != 0) && TFCombination.First == (V2Header.TFCombination & TFCombination.First)) { chunkMessage.V2Header.TFCombination = (TFCombination)(V2Header.TFCombination - TFCombination.First); } chunkMessage.InnerBody = chunk; chunkMessage.Header.Identifier = nextId; nextId += chunkMessage.Header.MessageSize; chunks.Add(chunkMessage); offset += dataSize; } } return(chunks.ToArray()); }
void IMessage.ReadFrom(IInputStream input) { uint tag; while ((tag = input.ReadTag()) != 0) { switch (tag) { case 9: _fdouble = input.ReadDouble(); break; case 21: _ffloat = input.ReadFloat(); break; case 24: _fint32 = input.ReadInt32(); break; case 32: _fint64 = input.ReadInt64(); break; case 40: _fuint32 = input.ReadUInt32(); break; case 48: _fuint64 = input.ReadUInt64(); break; case 56: _fsint32 = input.ReadSInt32(); break; case 64: _fsint64 = input.ReadSInt64(); break; case 77: _ffixed32 = input.ReadFixed32(); break; case 81: _ffixed64 = input.ReadFixed64(); break; case 93: _fsfixed32 = input.ReadSFixed32(); break; case 97: _fsfixed64 = input.ReadSFixed64(); break; case 104: _fbool = input.ReadBool(); break; case 114: _fstring = input.ReadString(); break; case 122: _fbytes = input.ReadBytes(); break; case 128: _fenum = (SomeEnum)input.ReadEnum(); break; case 138: if (_finner == null) { _finner = new InnerMessage(); } input.ReadMessage(_finner); break; case 146: if (_frep == null) { _frep = new global::System.Collections.Generic.List <InnerMessage>(); } input.ReadRepeated(_frep.Add, _tinyRepeatedTypeTestroot_Classes_InnerMessage, x => _frep.Capacity = _frep.Count + x); break; case 152: if (_frepEnum == null) { _frepEnum = new global::System.Collections.Generic.List <SomeEnum>(); } input.ReadRepeated(_frepEnum.Add, _tinyRepeatedTypeTestroot_Classes_TestEnum, x => _frepEnum.Capacity = _frepEnum.Count + x); break; case 162: if (_frepString == null) { _frepString = new global::System.Collections.Generic.List <string>(); } input.ReadRepeated(_frepString.Add, RepeatedTypes.String, x => _frepString.Capacity = _frepString.Count + x); break; case 173: if (_frepFixed32 == null) { _frepFixed32 = new global::System.Collections.Generic.List <uint>(); } input.ReadRepeated(_frepFixed32.Add, RepeatedTypes.Fixed32, x => _frepFixed32.Capacity = _frepFixed32.Count + x); break; case 176: if (_frepUint32 == null) { _frepUint32 = new global::System.Collections.Generic.List <uint>(); } input.ReadRepeated(_frepUint32.Add, RepeatedTypes.UInt32, x => _frepUint32.Capacity = _frepUint32.Count + x); break; default: input.SkipField(); break; } } }
private void WriteInnerMessageWithId(XmlDictionaryWriter writer) { WriteStartInnerMessageWithId(writer); InnerMessage.WriteBodyContents(writer); writer.WriteEndElement(); }
/// <summary> /// Returns the inner message as a byte array. /// </summary> /// <remarks> /// If the inner message is set the GetBytes() method is called upon that inner message. /// If there is no inner message set, but the InnerBody property contains data then /// that data is returned. /// </remarks> /// <returns></returns> protected virtual byte[] GetInnerBytes() { return((InnerBody != null) ? InnerBody : (InnerMessage != null ? InnerMessage.GetBytes() : new byte[0])); }