|
//------------------------------------------------------------------------------
// <copyright file="XmlPreloadedResolver.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
// <owner current="true" primary="true">Microsoft</owner>
//------------------------------------------------------------------------------
using System.IO;
using System.Xml;
#if !SILVERLIGHT
using System.Net;
#endif
using System.Text;
using System.Xml.Utils;
using System.Reflection;
using System.Diagnostics;
using System.Collections.Generic;
using System.Runtime.Versioning;
namespace System.Xml.Resolvers {
//
// XmlPreloadedResolver is an XmlResolver that which can be pre-loaded with data.
// By default it contains well-known DTDs for XHTML 1.0 and RSS 0.91.
// Custom mappings of URIs to data can be added with the Add method.
//
public partial class XmlPreloadedResolver : XmlResolver {
//
// PreloadedData class
//
abstract class PreloadedData {
// Returns preloaded data as Stream; Stream must always be supported
internal abstract Stream AsStream();
// Returns preloaded data as TextReader, or throws when not supported
internal virtual TextReader AsTextReader() {
throw new XmlException(Res.GetString(Res.Xml_UnsupportedClass));
}
// Returns true for types that are supported for this preloaded data; Stream must always be supported
internal virtual bool SupportsType(Type type) {
if (type == null || type == typeof(Stream)) {
return true;
}
return false;
}
};
//
// XmlKnownDtdData class
//
class XmlKnownDtdData : PreloadedData {
internal string publicId;
internal string systemId;
private string resourceName;
internal XmlKnownDtdData(string publicId, string systemId, string resourceName) {
this.publicId = publicId;
this.systemId = systemId;
this.resourceName = resourceName;
}
internal override Stream AsStream() {
Assembly asm = Assembly.GetExecutingAssembly();
return asm.GetManifestResourceStream(resourceName);
}
}
class ByteArrayChunk : PreloadedData {
byte[] array;
int offset;
int length;
internal ByteArrayChunk(byte[] array)
: this(array, 0, array.Length) {
}
internal ByteArrayChunk(byte[] array, int offset, int length) {
this.array = array;
this.offset = offset;
this.length = length;
}
internal override Stream AsStream() {
return new MemoryStream(array, offset, length);
}
}
class StringData : PreloadedData {
string str;
internal StringData(string str) {
this.str = str;
}
internal override Stream AsStream() {
return new MemoryStream(Encoding.Unicode.GetBytes(str));
}
internal override TextReader AsTextReader() {
return new StringReader(str);
}
internal override bool SupportsType(Type type) {
if (type == typeof(TextReader)) {
return true;
}
return base.SupportsType(type);
}
}
//
// Fields
//
XmlResolver fallbackResolver;
Dictionary<Uri, PreloadedData> mappings;
XmlKnownDtds preloadedDtds;
//
// Static/constant fiels
//
static XmlKnownDtdData[] Xhtml10_Dtd = new XmlKnownDtdData[] {
new XmlKnownDtdData( "-//W3C//DTD XHTML 1.0 Strict//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd", "xhtml1-strict.dtd" ),
new XmlKnownDtdData( "-//W3C//DTD XHTML 1.0 Transitional//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd", "xhtml1-transitional.dtd" ),
new XmlKnownDtdData( "-//W3C//DTD XHTML 1.0 Frameset//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd", "xhtml1-frameset.dtd" ),
new XmlKnownDtdData( "-//W3C//ENTITIES Latin 1 for XHTML//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml-lat1.ent", "xhtml-lat1.ent" ),
new XmlKnownDtdData( "-//W3C//ENTITIES Symbols for XHTML//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml-symbol.ent", "xhtml-symbol.ent" ),
new XmlKnownDtdData( "-//W3C//ENTITIES Special for XHTML//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml-special.ent", "xhtml-special.ent" ),
};
static XmlKnownDtdData[] Rss091_Dtd = new XmlKnownDtdData[] {
new XmlKnownDtdData( "-//Netscape Communications//DTD RSS 0.91//EN", "http://my.netscape.com/publish/formats/rss-0.91.dtd", "rss-0.91.dtd" ),
};
//
// Constructors
//
public XmlPreloadedResolver()
: this(null) {
}
public XmlPreloadedResolver(XmlKnownDtds preloadedDtds)
: this(null, preloadedDtds, null) {
}
public XmlPreloadedResolver(XmlResolver fallbackResolver)
: this(fallbackResolver, XmlKnownDtds.All, null) {
}
public XmlPreloadedResolver(XmlResolver fallbackResolver, XmlKnownDtds preloadedDtds)
: this (fallbackResolver, preloadedDtds, null) {
}
public XmlPreloadedResolver(XmlResolver fallbackResolver, XmlKnownDtds preloadedDtds, IEqualityComparer<Uri> uriComparer) {
this.fallbackResolver = fallbackResolver;
this.mappings = new Dictionary<Uri, PreloadedData>(16, uriComparer);
this.preloadedDtds = preloadedDtds;
// load known DTDs
if (preloadedDtds != 0) {
if ((preloadedDtds & XmlKnownDtds.Xhtml10) != 0) {
AddKnownDtd(Xhtml10_Dtd);
}
if ((preloadedDtds & XmlKnownDtds.Rss091) != 0) {
AddKnownDtd(Rss091_Dtd);
}
}
}
#if !SILVERLIGHT
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
#endif
public override Uri ResolveUri(Uri baseUri, string relativeUri) {
// 1) special-case well-known public IDs
// 2) To make FxCop happy we need to use StartsWith() overload that takes StringComparison ->
// .StartsWith(string) is equal to .StartsWith(string, StringComparison.CurrentCulture);
if (relativeUri != null && relativeUri.StartsWith("-//", StringComparison.CurrentCulture)) {
// 1) XHTML 1.0 public IDs
// 2) To make FxCop happy we need to use StartsWith() overload that takes StringComparison ->
// .StartsWith(string) is equal to .StartsWith(string, StringComparison.CurrentCulture);
if ((preloadedDtds & XmlKnownDtds.Xhtml10) != 0 && relativeUri.StartsWith("-//W3C//", StringComparison.CurrentCulture)) {
for (int i = 0; i < Xhtml10_Dtd.Length; i++) {
if (relativeUri == Xhtml10_Dtd[i].publicId) {
return new Uri(relativeUri, UriKind.Relative);
}
}
}
// RSS 0.91 public IDs
if ((preloadedDtds & XmlKnownDtds.Rss091) != 0) {
Debug.Assert(Rss091_Dtd.Length == 1);
if (relativeUri == Rss091_Dtd[0].publicId) {
return new Uri(relativeUri, UriKind.Relative);
}
}
}
return base.ResolveUri(baseUri, relativeUri);
}
public override Object GetEntity(Uri absoluteUri, string role, Type ofObjectToReturn) {
if (absoluteUri == null) {
throw new ArgumentNullException("absoluteUri");
}
PreloadedData data;
if (!mappings.TryGetValue(absoluteUri, out data)) {
if (fallbackResolver != null) {
return fallbackResolver.GetEntity(absoluteUri, role, ofObjectToReturn);
}
throw new XmlException(Res.GetString(Res.Xml_CannotResolveUrl, absoluteUri.ToString()));
}
if (ofObjectToReturn == null || ofObjectToReturn == typeof(Stream) || ofObjectToReturn == typeof(Object)) {
return data.AsStream();
}
else if (ofObjectToReturn == typeof(TextReader)) {
return data.AsTextReader();
}
else {
throw new XmlException(Res.GetString(Res.Xml_UnsupportedClass));
}
}
#if !SILVERLIGHT
public override ICredentials Credentials {
set {
if (fallbackResolver != null) {
fallbackResolver.Credentials = value;
}
}
}
#endif
public override bool SupportsType(Uri absoluteUri, Type type) {
if (absoluteUri == null) {
throw new ArgumentNullException("absoluteUri");
}
PreloadedData data;
if (!mappings.TryGetValue(absoluteUri, out data)) {
if (fallbackResolver != null) {
return fallbackResolver.SupportsType(absoluteUri, type);
}
return base.SupportsType(absoluteUri, type);
}
return data.SupportsType(type);
}
public void Add(Uri uri, byte[] value) {
if (uri == null) {
throw new ArgumentNullException("uri");
}
if (value == null) {
throw new ArgumentNullException("value");
}
Add(uri, new ByteArrayChunk(value, 0, value.Length));
}
public void Add(Uri uri, byte[] value, int offset, int count) {
if (uri == null) {
throw new ArgumentNullException("uri");
}
if (value == null) {
throw new ArgumentNullException("value");
}
if (count < 0) {
throw new ArgumentOutOfRangeException("count");
}
if (offset < 0) {
throw new ArgumentOutOfRangeException("offset");
}
if (value.Length - offset < count) {
throw new ArgumentOutOfRangeException("count");
}
Add(uri, new ByteArrayChunk(value, offset, count));
}
public void Add(Uri uri, Stream value) {
if (uri == null) {
throw new ArgumentNullException("uri");
}
if (value == null) {
throw new ArgumentNullException("value");
}
if (value.CanSeek) {
// stream of known length -> allocate the byte array and read all data into it
int size = checked((int)value.Length);
byte[] bytes = new byte[size];
value.Read(bytes, 0, size);
Add(uri, new ByteArrayChunk(bytes));
}
else {
// stream of unknown length -> read into memory stream and then get internal the byte array
MemoryStream ms = new MemoryStream();
byte[] buffer = new byte[4096];
int read;
while ((read = value.Read(buffer, 0, buffer.Length)) > 0) {
ms.Write(buffer, 0, read);
}
int size = checked((int)ms.Position);
byte[] bytes = new byte[size];
Array.Copy(ms.GetBuffer(), bytes, size);
Add(uri, new ByteArrayChunk(bytes));
}
}
public void Add(Uri uri, string value) {
if (uri == null) {
throw new ArgumentNullException("uri");
}
if (value == null) {
throw new ArgumentNullException("value");
}
Add(uri, new StringData(value));
}
public IEnumerable<Uri> PreloadedUris {
get {
// read-only collection of keys
return mappings.Keys;
}
}
public void Remove(Uri uri) {
if (uri == null) {
throw new ArgumentNullException("uri");
}
mappings.Remove(uri);
}
//
// Private implementation methods
//
private void Add(Uri uri, PreloadedData data) {
Debug.Assert(uri != null);
// override if exists
if (mappings.ContainsKey(uri)) {
mappings[uri] = data;
}
else {
mappings.Add(uri, data);
}
}
private void AddKnownDtd(XmlKnownDtdData[] dtdSet) {
for (int i = 0; i < dtdSet.Length; i++) {
XmlKnownDtdData dtdInfo = dtdSet[i];
mappings.Add(new Uri(dtdInfo.publicId, UriKind.RelativeOrAbsolute), dtdInfo);
mappings.Add(new Uri(dtdInfo.systemId, UriKind.RelativeOrAbsolute), dtdInfo);
}
}
}
}
|