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]));
}
