internal static void LoadElementExtensions(XmlBuffer buffer, XmlDictionaryWriter writer, Workspace workspace)
{
if (workspace == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("workspace");
}
Atom10FeedFormatter.CloseBuffer(buffer, writer);
workspace.LoadElementExtensions(buffer);
}
internal static void LoadElementExtensions(XmlBuffer buffer, XmlDictionaryWriter writer, CategoriesDocument categories)
{
if (categories == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("categories");
}
Atom10FeedFormatter.CloseBuffer(buffer, writer);
categories.LoadElementExtensions(buffer);
}
internal static void LoadElementExtensions(XmlBuffer buffer, XmlDictionaryWriter writer, ServiceDocument document)
{
if (document == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("document");
}
Atom10FeedFormatter.CloseBuffer(buffer, writer);
document.LoadElementExtensions(buffer);
}
internal static void LoadElementExtensions(XmlBuffer buffer, XmlDictionaryWriter writer, ResourceCollectionInfo collection)
{
if (collection == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("collection");
}
Atom10FeedFormatter.CloseBuffer(buffer, writer);
collection.LoadElementExtensions(buffer);
}
internal static void LoadElementExtensions(XmlBuffer buffer, XmlDictionaryWriter writer, CategoriesDocument categories)
{
if (categories == null)
{
throw new ArgumentNullException(nameof(categories));
}
Atom10FeedFormatter.CloseBuffer(buffer, writer);
categories.LoadElementExtensions(buffer);
}
protected override void SetItem(int index, SyndicationElementExtension item)
{
if (item == null)
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("item");
}
base.SetItem(index, item);
if (this.initialized)
{
this.buffer = null;
}
}
internal BodyWriter OnCreateBufferedCopy(int maxBufferSize, XmlDictionaryReaderQuotas quotas)
{
XmlBuffer buffer = new XmlBuffer(maxBufferSize);
using (XmlDictionaryWriter writer = buffer.OpenSection(quotas))
{
writer.WriteStartElement("a");
OnWriteBodyContents(writer);
writer.WriteEndElement();
}
buffer.CloseSection();
buffer.Close();
return new BufferedBodyWriter(buffer);
}
static XmlBuffer CreateXmlBuffer(XmlDictionaryReader unparsedExtensionsReader, int maxExtensionSize)
{
XmlBuffer buffer = new XmlBuffer(maxExtensionSize);
using (XmlDictionaryWriter writer = buffer.OpenSection(unparsedExtensionsReader.Quotas))
{
writer.WriteStartElement(Rss20Constants.ExtensionWrapperTag);
while (unparsedExtensionsReader.IsStartElement())
{
writer.WriteNode(unparsedExtensionsReader, false);
}
writer.WriteEndElement();
}
buffer.CloseSection();
buffer.Close();
return buffer;
}
public DefaultMessageBuffer(Message message, XmlBuffer msgBuffer)
{
_msgBuffer = msgBuffer;
_version = message.Version;
_isNullMessage = message is NullMessage;
_properties = new KeyValuePair<string, object>[message.Properties.Count];
((ICollection<KeyValuePair<string, object>>)message.Properties).CopyTo(_properties, 0);
_understoodHeaders = new bool[message.Headers.Count];
for (int i = 0; i < _understoodHeaders.Length; ++i)
_understoodHeaders[i] = message.Headers.IsUnderstood(i);
if (_version == MessageVersion.None)
{
_to = message.Headers.To;
_action = message.Headers.Action;
}
}
public BufferedHeader(MessageVersion version, XmlBuffer buffer, XmlDictionaryReader reader, XmlAttributeHolder[] envelopeAttributes, XmlAttributeHolder[] headerAttributes)
{
_streamed = true;
_buffer = buffer;
_version = version;
GetHeaderAttributes(reader, version, out _actor, out _mustUnderstand, out _relay, out _isRefParam);
_name = reader.LocalName;
_ns = reader.NamespaceURI;
Fx.Assert(_name != null, "");
Fx.Assert(_ns != null, "");
_bufferIndex = buffer.SectionCount;
XmlDictionaryWriter writer = buffer.OpenSection(reader.Quotas);
// Write an enclosing Envelope tag
writer.WriteStartElement(MessageStrings.Envelope);
if (envelopeAttributes != null)
XmlAttributeHolder.WriteAttributes(envelopeAttributes, writer);
// Write and enclosing Header tag
writer.WriteStartElement(MessageStrings.Header);
if (headerAttributes != null)
XmlAttributeHolder.WriteAttributes(headerAttributes, writer);
writer.WriteNode(reader, false);
writer.WriteEndElement();
writer.WriteEndElement();
buffer.CloseSection();
}
public BufferedHeader(MessageVersion version, XmlBuffer buffer, int bufferIndex, MessageHeaderInfo headerInfo)
{
_version = version;
_buffer = buffer;
_bufferIndex = bufferIndex;
_actor = headerInfo.Actor;
_relay = headerInfo.Relay;
_name = headerInfo.Name;
_ns = headerInfo.Namespace;
_isRefParam = headerInfo.IsReferenceParameter;
_mustUnderstand = headerInfo.MustUnderstand;
}
public BufferedHeader(MessageVersion version, XmlBuffer buffer, int bufferIndex, string name, string ns, bool mustUnderstand, string actor, bool relay, bool isRefParam)
{
_version = version;
_buffer = buffer;
_bufferIndex = bufferIndex;
_name = name;
_ns = ns;
_mustUnderstand = mustUnderstand;
_actor = actor;
_relay = relay;
_isRefParam = isRefParam;
}
public void WriteBodyToEncryptThenSign(Stream canonicalStream, EncryptedData encryptedData, SymmetricAlgorithm algorithm)
{
encryptedData.Id = this.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);
this.InnerMessage.WriteBodyContents(encryptingWriter);
((IFragmentCapableXmlDictionaryWriter)encryptingWriter).EndFragment();
encryptingWriter.WriteEndElement();
ms.Flush();
encryptedData.SetUpEncryption(algorithm, new ArraySegment<byte>(ms.GetBuffer(), 0, (int) ms.Length));
this.fullBodyBuffer = new XmlBuffer(int.MaxValue);
XmlDictionaryWriter canonicalWriter = this.fullBodyBuffer.OpenSection(XmlDictionaryReaderQuotas.Max);
canonicalWriter.StartCanonicalization(canonicalStream, false, null);
WriteStartInnerMessageWithId(canonicalWriter);
encryptedData.WriteTo(canonicalWriter, ServiceModelDictionaryManager.Instance);
canonicalWriter.WriteEndElement();
canonicalWriter.EndCanonicalization();
canonicalWriter.Flush();
this.fullBodyBuffer.CloseSection();
this.fullBodyBuffer.Close();
this.state = BodyState.EncryptedThenSigned;
}
internal void LoadElementExtensions(XmlBuffer buffer)
{
this.elementExtensions = new SyndicationElementExtensionCollection(buffer);
}
internal static void LoadElementExtensions(XmlBuffer buffer, XmlDictionaryWriter writer, SyndicationPerson person)
{
SyndicationFeedFormatter.LoadElementExtensions(buffer, writer, person);
}
internal static void CreateBufferIfRequiredAndWriteNode(ref XmlBuffer buffer, ref XmlDictionaryWriter extWriter, XmlDictionaryReader reader, int maxExtensionSize)
{
SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, maxExtensionSize);
}
internal static void LoadElementExtensions(XmlBuffer buffer, XmlDictionaryWriter writer, SyndicationCategory category)
{
SyndicationFeedFormatter.LoadElementExtensions(buffer, writer, category);
}
protected override void OnClose()
{
try
{
this.InnerMessage.Close();
}
finally
{
this.fullBodyBuffer = null;
this.bodyAttributes = null;
this.encryptedBodyContent = null;
this.state = BodyState.Disposed;
}
}
public void WriteBodyToSignThenEncrypt(Stream canonicalStream, EncryptedData encryptedData, SymmetricAlgorithm algorithm)
{
XmlBuffer buffer = new XmlBuffer(int.MaxValue);
XmlDictionaryWriter fragmentingWriter = buffer.OpenSection(XmlDictionaryReaderQuotas.Max);
WriteBodyToSignThenEncryptWithFragments(canonicalStream, false, null, encryptedData, algorithm, fragmentingWriter);
((IFragmentCapableXmlDictionaryWriter)fragmentingWriter).WriteFragment(this.startBodyFragment.GetBuffer(), 0, (int)this.startBodyFragment.Length);
((IFragmentCapableXmlDictionaryWriter)fragmentingWriter).WriteFragment(this.endBodyFragment.GetBuffer(), 0, (int)this.endBodyFragment.Length);
buffer.CloseSection();
buffer.Close();
this.startBodyFragment = null;
this.endBodyFragment = null;
XmlDictionaryReader reader = buffer.GetReader(0);
reader.MoveToContent();
this.bodyPrefix = reader.Prefix;
if (reader.HasAttributes)
{
this.bodyAttributes = XmlAttributeHolder.ReadAttributes(reader);
}
reader.Close();
}
public void WriteBodyToSign(Stream canonicalStream)
{
SetBodyId();
this.fullBodyBuffer = new XmlBuffer(int.MaxValue);
XmlDictionaryWriter canonicalWriter = this.fullBodyBuffer.OpenSection(XmlDictionaryReaderQuotas.Max);
canonicalWriter.StartCanonicalization(canonicalStream, false, null);
WriteInnerMessageWithId(canonicalWriter);
canonicalWriter.EndCanonicalization();
canonicalWriter.Flush();
this.fullBodyBuffer.CloseSection();
this.fullBodyBuffer.Close();
this.state = BodyState.Signed;
}
private string GetSignatureHash(MessageHeader header, string headerId, IPrefixGenerator prefixGenerator, XmlDictionaryWriter writer, out byte[] hash)
{
XmlDictionaryWriter writer2;
HashStream stream = this.TakeHashStream();
XmlBuffer buffer = null;
if (writer.CanCanonicalize)
{
writer2 = writer;
}
else
{
buffer = new XmlBuffer(0x7fffffff);
writer2 = buffer.OpenSection(XmlDictionaryReaderQuotas.Max);
}
writer2.StartCanonicalization(stream, false, null);
header.WriteStartHeader(writer2, base.Version);
if (headerId == null)
{
headerId = base.GenerateId();
base.StandardsManager.IdManager.WriteIdAttribute(writer2, headerId);
}
header.WriteHeaderContents(writer2, base.Version);
writer2.WriteEndElement();
writer2.EndCanonicalization();
writer2.Flush();
if (!object.ReferenceEquals(writer2, writer))
{
buffer.CloseSection();
buffer.Close();
XmlDictionaryReader reader = buffer.GetReader(0);
writer.WriteNode(reader, false);
reader.Close();
}
hash = stream.FlushHashAndGetValue();
return headerId;
}
public void WriteBodyToEncryptThenSign(Stream canonicalStream, EncryptedData encryptedData, SymmetricAlgorithm algorithm)
{
encryptedData.Id = this.securityHeader.GenerateId();
this.SetBodyId();
XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(Stream.Null);
writer.WriteStartElement("a");
MemoryStream stream = new MemoryStream();
((IFragmentCapableXmlDictionaryWriter) writer).StartFragment(stream, true);
base.InnerMessage.WriteBodyContents(writer);
((IFragmentCapableXmlDictionaryWriter) writer).EndFragment();
writer.WriteEndElement();
stream.Flush();
encryptedData.SetUpEncryption(algorithm, new ArraySegment<byte>(stream.GetBuffer(), 0, (int) stream.Length));
this.fullBodyBuffer = new XmlBuffer(0x7fffffff);
XmlDictionaryWriter writer2 = this.fullBodyBuffer.OpenSection(XmlDictionaryReaderQuotas.Max);
writer2.StartCanonicalization(canonicalStream, false, null);
this.WriteStartInnerMessageWithId(writer2);
encryptedData.WriteTo(writer2, ServiceModelDictionaryManager.Instance);
writer2.WriteEndElement();
writer2.EndCanonicalization();
writer2.Flush();
this.fullBodyBuffer.CloseSection();
this.fullBodyBuffer.Close();
this.state = BodyState.EncryptedThenSigned;
}
public BufferedBodyWriter(XmlBuffer buffer)
: base(true)
{
_buffer = buffer;
}
internal void LoadElementExtensions(XmlBuffer buffer)
{
this.extensions.LoadElementExtensions(buffer);
}
internal static void LoadElementExtensions(XmlBuffer buffer, XmlDictionaryWriter writer, SyndicationLink link)
{
SyndicationFeedFormatter.LoadElementExtensions(buffer, writer, link);
}
