a575963da9
Former-commit-id: da6be194a6b1221998fc28233f2503bd61dd9d14
631 lines
14 KiB
C#
631 lines
14 KiB
C#
//
|
|
// XmlMtomDictionaryReader.cs
|
|
//
|
|
// Author:
|
|
// Atsushi Enomoto <atsushi@ximian.com>
|
|
//
|
|
// Copyright (C) 2009 Novell, Inc. http://www.novell.com
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining
|
|
// a copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to
|
|
// permit persons to whom the Software is furnished to do so, subject to
|
|
// the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be
|
|
// included in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
|
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
//
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Net.Mime;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using System.Xml;
|
|
|
|
namespace System.Xml
|
|
{
|
|
internal class XmlMtomDictionaryReader : XmlDictionaryReader
|
|
{
|
|
public XmlMtomDictionaryReader (
|
|
Stream stream, Encoding encoding,
|
|
XmlDictionaryReaderQuotas quotas)
|
|
{
|
|
this.stream = stream;
|
|
this.encoding = encoding;
|
|
this.quotas = quotas;
|
|
|
|
Initialize ();
|
|
}
|
|
|
|
public XmlMtomDictionaryReader (
|
|
Stream stream, Encoding [] encodings, string contentType,
|
|
XmlDictionaryReaderQuotas quotas,
|
|
int maxBufferSize,
|
|
OnXmlDictionaryReaderClose onClose)
|
|
{
|
|
this.stream = stream;
|
|
this.encodings = encodings;
|
|
content_type = contentType != null ? CreateContentType (contentType) : null;
|
|
this.quotas = quotas;
|
|
this.max_buffer_size = maxBufferSize;
|
|
on_close = onClose;
|
|
|
|
Initialize ();
|
|
}
|
|
|
|
Stream stream;
|
|
Encoding encoding;
|
|
Encoding [] encodings;
|
|
ContentType content_type;
|
|
XmlDictionaryReaderQuotas quotas;
|
|
int max_buffer_size;
|
|
OnXmlDictionaryReaderClose on_close;
|
|
|
|
Dictionary<string,MimeEncodedStream> readers = new Dictionary<string,MimeEncodedStream> ();
|
|
|
|
void Initialize ()
|
|
{
|
|
var nt = new NameTable ();
|
|
initial_reader = new NonInteractiveStateXmlReader (String.Empty, nt, ReadState.Initial);
|
|
eof_reader = new NonInteractiveStateXmlReader (String.Empty, nt, ReadState.EndOfFile);
|
|
xml_reader = initial_reader;
|
|
}
|
|
|
|
ContentType CreateContentType (string contentTypeString)
|
|
{
|
|
ContentType c = null;
|
|
foreach (var s_ in contentTypeString.Split (';')) {
|
|
var s = s_.Trim ();
|
|
if (c == null) {
|
|
// first one
|
|
c = new ContentType (s);
|
|
continue;
|
|
}
|
|
int idx = s.IndexOf ('=');
|
|
if (idx < 0)
|
|
throw new XmlException ("Invalid content type header");
|
|
var val = StripBraces (s.Substring (idx + 1));
|
|
c.Parameters [s.Substring (0, idx)] = val;
|
|
}
|
|
return c;
|
|
}
|
|
|
|
XmlReader xml_reader, initial_reader, eof_reader, part_reader;
|
|
XmlReader Reader {
|
|
get { return part_reader ?? xml_reader; }
|
|
}
|
|
|
|
public override bool EOF {
|
|
get { return Reader == eof_reader; }
|
|
}
|
|
|
|
public override void Close ()
|
|
{
|
|
if (!EOF && on_close != null)
|
|
on_close (this);
|
|
xml_reader = eof_reader;
|
|
}
|
|
|
|
public override bool Read ()
|
|
{
|
|
if (EOF)
|
|
return false;
|
|
|
|
if (Reader == initial_reader)
|
|
SetupPrimaryReader ();
|
|
|
|
if (part_reader != null)
|
|
part_reader = null;
|
|
|
|
if (!Reader.Read ()) {
|
|
xml_reader = eof_reader;
|
|
return false;
|
|
}
|
|
if (Reader.LocalName == "Include" && Reader.NamespaceURI == "http://www.w3.org/2004/08/xop/include") {
|
|
string cid = Reader.GetAttribute ("href");
|
|
if (!cid.StartsWith ("cid:"))
|
|
throw new XmlException ("Cannot resolve non-cid href attribute value in XOP Include element");
|
|
cid = cid.Substring (4);
|
|
if (!readers.ContainsKey (cid))
|
|
ReadToIdentifiedStream (cid);
|
|
part_reader = new MultiPartedXmlReader (Reader, readers [cid]);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void SetupPrimaryReader ()
|
|
{
|
|
ReadOptionalMimeHeaders ();
|
|
if (current_content_type != null)
|
|
content_type = current_content_type;
|
|
|
|
if (content_type == null)
|
|
throw new XmlException ("Content-Type header for the MTOM message was not found");
|
|
if (content_type.Boundary == null)
|
|
throw new XmlException ("Content-Type header for the MTOM message must contain 'boundary' parameter");
|
|
|
|
if (encoding == null && content_type.CharSet != null)
|
|
encoding = Encoding.GetEncoding (content_type.CharSet);
|
|
if (encoding == null && encodings == null)
|
|
throw new XmlException ("Encoding specification is required either in the constructor argument or the content-type header");
|
|
|
|
// consume the first identifier.
|
|
string ident = "--" + content_type.Boundary;
|
|
string idline;
|
|
|
|
while (true) {
|
|
idline = ReadAsciiLine ().Trim ();
|
|
if (idline == null)
|
|
return;
|
|
if (idline.Length != 0)
|
|
break;
|
|
}
|
|
if (!idline.StartsWith (ident, StringComparison.Ordinal))
|
|
throw new XmlException (String.Format ("Unexpected boundary line was found. Expected boundary is '{0}' but it was '{1}'", content_type.Boundary, idline));
|
|
|
|
string start = content_type.Parameters ["start"];
|
|
ReadToIdentifiedStream (start);
|
|
|
|
xml_reader = XmlReader.Create (readers [start].CreateTextReader ());
|
|
}
|
|
|
|
int buffer_length;
|
|
byte [] buffer;
|
|
int peek_char;
|
|
|
|
ContentType current_content_type;
|
|
int content_index;
|
|
string current_content_id, current_content_encoding;
|
|
|
|
void ReadToIdentifiedStream (string id)
|
|
{
|
|
while (true) {
|
|
if (!ReadNextStream ())
|
|
throw new XmlException (String.Format ("The stream '{0}' did not appear", id));
|
|
if (current_content_id == id || id == null)
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool ReadNextStream ()
|
|
{
|
|
ReadOptionalMimeHeaders ();
|
|
string ident = "--" + content_type.Boundary;
|
|
|
|
StringBuilder sb = new StringBuilder ();
|
|
while (true) {
|
|
string n = ReadAsciiLine ();
|
|
if (n == null && sb.Length == 0)
|
|
return false;
|
|
else if (n == null || n.StartsWith (ident, StringComparison.Ordinal))
|
|
break;
|
|
sb.Append (n);
|
|
}
|
|
readers.Add (current_content_id, new MimeEncodedStream (current_content_id, current_content_encoding, sb.ToString ()));
|
|
return true;
|
|
}
|
|
|
|
void ReadOptionalMimeHeaders ()
|
|
{
|
|
peek_char = stream.ReadByte ();
|
|
if (peek_char == '-') // no header
|
|
return;
|
|
ReadMimeHeaders ();
|
|
}
|
|
|
|
string ReadAllHeaderLines ()
|
|
{
|
|
string s = String.Empty;
|
|
|
|
while (true) {
|
|
var n = ReadAsciiLine ();
|
|
if (n.Length == 0)
|
|
return s;
|
|
n = n.TrimEnd ();
|
|
s += n;
|
|
if (n [n.Length - 1] != ';')
|
|
s += '\n';
|
|
}
|
|
}
|
|
|
|
void ReadMimeHeaders ()
|
|
{
|
|
foreach (var s in ReadAllHeaderLines ().Split ('\n')) {
|
|
if (s.Length == 0)
|
|
continue;
|
|
int idx = s.IndexOf (':');
|
|
if (idx < 0)
|
|
throw new XmlException (String.Format ("Unexpected header string: {0}", s));
|
|
string v = StripBraces (s.Substring (idx + 1).Trim ());
|
|
switch (s.Substring (0, idx).ToLower ()) {
|
|
case "content-type":
|
|
current_content_type = CreateContentType (v);
|
|
break;
|
|
case "content-id":
|
|
current_content_id = v;
|
|
break;
|
|
case "content-transfer-encoding":
|
|
current_content_encoding = v;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
string StripBraces (string s)
|
|
{
|
|
// could be foo, <foo>, "foo" and "<foo>".
|
|
if (s.Length >= 2 && s [0] == '"' && s [s.Length - 1] == '"')
|
|
s = s.Substring (1, s.Length - 2);
|
|
if (s.Length >= 2 && s [0] == '<' && s [s.Length - 1] == '>')
|
|
s = s.Substring (1, s.Length - 2);
|
|
return s;
|
|
}
|
|
|
|
string ReadAsciiLine ()
|
|
{
|
|
if (buffer == null)
|
|
buffer = new byte [1024];
|
|
int bpos = 0;
|
|
int b = peek_char;
|
|
bool skipRead = b >= 0;
|
|
peek_char = -1;
|
|
while (true) {
|
|
if (skipRead)
|
|
skipRead = false;
|
|
else
|
|
b = stream.ReadByte ();
|
|
if (b < 0) {
|
|
if (bpos > 0)
|
|
throw new XmlException ("The stream ends without end of line");
|
|
return null;
|
|
}
|
|
if (b == '\r') {
|
|
b = stream.ReadByte ();
|
|
if (b < 0) {
|
|
buffer [bpos++] = (byte) '\r';
|
|
break;
|
|
}
|
|
else if (b == '\n')
|
|
break;
|
|
buffer [bpos++] = (byte) '\r';
|
|
skipRead = true;
|
|
}
|
|
else
|
|
buffer [bpos++] = (byte) b;
|
|
if (bpos == buffer.Length) {
|
|
var newbuf = new byte [buffer.Length << 1];
|
|
Array.Copy (buffer, 0, newbuf, 0, buffer.Length);
|
|
buffer = newbuf;
|
|
}
|
|
}
|
|
return Encoding.ASCII.GetString (buffer, 0, bpos);
|
|
}
|
|
|
|
// The rest are just reader delegation.
|
|
|
|
public override int AttributeCount {
|
|
get { return Reader.AttributeCount; }
|
|
}
|
|
|
|
public override string BaseURI {
|
|
get { return Reader.BaseURI; }
|
|
}
|
|
|
|
public override int Depth {
|
|
get { return Reader.Depth; }
|
|
}
|
|
|
|
public override bool HasValue {
|
|
get { return Reader.HasValue; }
|
|
}
|
|
|
|
public override bool IsEmptyElement {
|
|
get { return Reader.IsEmptyElement; }
|
|
}
|
|
|
|
public override string LocalName {
|
|
get { return Reader.LocalName; }
|
|
}
|
|
|
|
public override string NamespaceURI {
|
|
get { return Reader.NamespaceURI; }
|
|
}
|
|
|
|
public override XmlNameTable NameTable {
|
|
get { return Reader.NameTable; }
|
|
}
|
|
|
|
public override XmlNodeType NodeType {
|
|
get { return Reader.NodeType; }
|
|
}
|
|
|
|
public override string Prefix {
|
|
get { return Reader.Prefix; }
|
|
}
|
|
|
|
public override ReadState ReadState {
|
|
get { return Reader.ReadState; }
|
|
}
|
|
|
|
public override string Value {
|
|
get { return Reader.Value; }
|
|
}
|
|
|
|
public override bool MoveToElement ()
|
|
{
|
|
return Reader.MoveToElement ();
|
|
}
|
|
|
|
public override string GetAttribute (int index)
|
|
{
|
|
return Reader.GetAttribute (index);
|
|
}
|
|
|
|
public override string GetAttribute (string name)
|
|
{
|
|
return Reader.GetAttribute (name);
|
|
}
|
|
|
|
public override string GetAttribute (string localName, string namespaceURI)
|
|
{
|
|
return Reader.GetAttribute (localName, namespaceURI);
|
|
}
|
|
|
|
public override void MoveToAttribute (int index)
|
|
{
|
|
Reader.MoveToAttribute (index);
|
|
}
|
|
|
|
public override bool MoveToAttribute (string name)
|
|
{
|
|
return Reader.MoveToAttribute (name);
|
|
}
|
|
|
|
public override bool MoveToAttribute (string localName, string namespaceURI)
|
|
{
|
|
return Reader.MoveToAttribute (localName, namespaceURI);
|
|
}
|
|
|
|
public override bool MoveToFirstAttribute ()
|
|
{
|
|
return Reader.MoveToFirstAttribute ();
|
|
}
|
|
|
|
public override bool MoveToNextAttribute ()
|
|
{
|
|
return Reader.MoveToNextAttribute ();
|
|
}
|
|
|
|
public override string LookupNamespace (string prefix)
|
|
{
|
|
return Reader.LookupNamespace (prefix);
|
|
}
|
|
|
|
public override bool ReadAttributeValue ()
|
|
{
|
|
return Reader.ReadAttributeValue ();
|
|
}
|
|
|
|
public override void ResolveEntity ()
|
|
{
|
|
Reader.ResolveEntity ();
|
|
}
|
|
}
|
|
|
|
class NonInteractiveStateXmlReader : DummyStateXmlReader
|
|
{
|
|
public NonInteractiveStateXmlReader (string baseUri, XmlNameTable nameTable, ReadState readState)
|
|
: base (baseUri, nameTable, readState)
|
|
{
|
|
}
|
|
|
|
public override int Depth {
|
|
get { return 0; }
|
|
}
|
|
|
|
public override bool HasValue {
|
|
get { return false; }
|
|
}
|
|
|
|
public override string Value {
|
|
get { return String.Empty; }
|
|
}
|
|
|
|
public override XmlNodeType NodeType {
|
|
get { return XmlNodeType.None; }
|
|
}
|
|
}
|
|
|
|
class MultiPartedXmlReader : DummyStateXmlReader
|
|
{
|
|
public MultiPartedXmlReader (XmlReader reader, MimeEncodedStream value)
|
|
: base (reader.BaseURI, reader.NameTable, reader.ReadState)
|
|
{
|
|
this.owner = reader;
|
|
this.value = value.CreateTextReader ().ReadToEnd ();
|
|
}
|
|
|
|
XmlReader owner;
|
|
string value;
|
|
|
|
public override int Depth {
|
|
get { return owner.Depth; }
|
|
}
|
|
|
|
public override bool HasValue {
|
|
get { return true; }
|
|
}
|
|
|
|
public override string Value {
|
|
get { return value; }
|
|
}
|
|
|
|
public override XmlNodeType NodeType {
|
|
get { return XmlNodeType.Text; }
|
|
}
|
|
}
|
|
|
|
abstract class DummyStateXmlReader : XmlReader
|
|
{
|
|
protected DummyStateXmlReader (string baseUri, XmlNameTable nameTable, ReadState readState)
|
|
{
|
|
base_uri = baseUri;
|
|
name_table = nameTable;
|
|
read_state = readState;
|
|
}
|
|
|
|
string base_uri;
|
|
XmlNameTable name_table;
|
|
ReadState read_state;
|
|
|
|
public override string BaseURI {
|
|
get { return base_uri; }
|
|
}
|
|
|
|
public override bool EOF {
|
|
get { return false; }
|
|
}
|
|
|
|
public override void Close ()
|
|
{
|
|
throw new NotSupportedException ();
|
|
}
|
|
|
|
public override bool Read ()
|
|
{
|
|
throw new NotSupportedException ();
|
|
}
|
|
|
|
// The rest are just reader delegation.
|
|
|
|
public override int AttributeCount {
|
|
get { return 0; }
|
|
}
|
|
|
|
public override bool IsEmptyElement {
|
|
get { return false; }
|
|
}
|
|
|
|
public override string LocalName {
|
|
get { return String.Empty; }
|
|
}
|
|
|
|
public override string NamespaceURI {
|
|
get { return String.Empty; }
|
|
}
|
|
|
|
public override XmlNameTable NameTable {
|
|
get { return name_table; }
|
|
}
|
|
|
|
public override string Prefix {
|
|
get { return String.Empty; }
|
|
}
|
|
|
|
public override ReadState ReadState {
|
|
get { return read_state; }
|
|
}
|
|
|
|
public override bool MoveToElement ()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
public override string GetAttribute (int index)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
public override string GetAttribute (string name)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
public override string GetAttribute (string localName, string namespaceURI)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
public override void MoveToAttribute (int index)
|
|
{
|
|
throw new ArgumentOutOfRangeException ();
|
|
}
|
|
|
|
public override bool MoveToAttribute (string name)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
public override bool MoveToAttribute (string localName, string namespaceURI)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
public override bool MoveToFirstAttribute ()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
public override bool MoveToNextAttribute ()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
public override string LookupNamespace (string prefix)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
public override bool ReadAttributeValue ()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
public override void ResolveEntity ()
|
|
{
|
|
throw new InvalidOperationException ();
|
|
}
|
|
}
|
|
|
|
class MimeEncodedStream
|
|
{
|
|
public MimeEncodedStream (string id, string contentEncoding, string value)
|
|
{
|
|
Id = id;
|
|
ContentEncoding = contentEncoding;
|
|
EncodedString = value;
|
|
}
|
|
|
|
public string Id { get; set; }
|
|
public string ContentEncoding { get; set; }
|
|
public string EncodedString { get; set; }
|
|
|
|
public string DecodedBase64String {
|
|
get { return Convert.ToBase64String (Encoding.ASCII.GetBytes (EncodedString)); }
|
|
}
|
|
|
|
public TextReader CreateTextReader ()
|
|
{
|
|
switch (ContentEncoding) {
|
|
case "7bit":
|
|
case "8bit":
|
|
return new StringReader (EncodedString);
|
|
default:
|
|
return new StringReader (DecodedBase64String);
|
|
}
|
|
}
|
|
}
|
|
}
|