XmlReaderSettings.cs

using Microsoft.Win32;
using System.ComponentModel;
using System.IO;
using System.Security;
using System.Security.Permissions;
using System.Xml.Schema;
using System.Xml.XmlConfiguration;

namespace System.Xml
{
    [global::__DynamicallyInvokable]
    [PermissionSet(SecurityAction.InheritanceDemand, Name = "FullTrust")]
    public sealed class XmlReaderSettings
    {
        private bool useAsync;

        private XmlNameTable nameTable;

        private XmlResolver xmlResolver;

        private int lineNumberOffset;

        private int linePositionOffset;

        private ConformanceLevel conformanceLevel;

        private bool checkCharacters;

        private long maxCharactersInDocument;

        private long maxCharactersFromEntities;

        private bool ignoreWhitespace;

        private bool ignorePIs;

        private bool ignoreComments;

        private DtdProcessing dtdProcessing;

        private ValidationType validationType;

        private XmlSchemaValidationFlags validationFlags;

        private XmlSchemaSet schemas;

        private ValidationEventHandler valEventHandler;

        private bool closeInput;

        private bool isReadOnly;

        private static bool? s_enableLegacyXmlSettings;

        [global::__DynamicallyInvokable]
        public bool Async
        {
            [global::__DynamicallyInvokable]
            get
            {
                return useAsync;
            }
            [global::__DynamicallyInvokable]
            set
            {
                CheckReadOnly("Async");
                useAsync = value;
            }
        }

        [global::__DynamicallyInvokable]
        public XmlNameTable NameTable
        {
            [global::__DynamicallyInvokable]
            get
            {
                return nameTable;
            }
            [global::__DynamicallyInvokable]
            set
            {
                CheckReadOnly("NameTable");
                nameTable = value;
            }
        }

        internal bool IsXmlResolverSet
        {
            get;
            set;
        }

        public XmlResolver XmlResolver
        {
            set
            {
                CheckReadOnly("XmlResolver");
                xmlResolver = value;
                IsXmlResolverSet = true;
            }
        }

        [global::__DynamicallyInvokable]
        public int LineNumberOffset
        {
            [global::__DynamicallyInvokable]
            get
            {
                return lineNumberOffset;
            }
            [global::__DynamicallyInvokable]
            set
            {
                CheckReadOnly("LineNumberOffset");
                lineNumberOffset = value;
            }
        }

        [global::__DynamicallyInvokable]
        public int LinePositionOffset
        {
            [global::__DynamicallyInvokable]
            get
            {
                return linePositionOffset;
            }
            [global::__DynamicallyInvokable]
            set
            {
                CheckReadOnly("LinePositionOffset");
                linePositionOffset = value;
            }
        }

        [global::__DynamicallyInvokable]
        public ConformanceLevel ConformanceLevel
        {
            [global::__DynamicallyInvokable]
            get
            {
                return conformanceLevel;
            }
            [global::__DynamicallyInvokable]
            set
            {
                CheckReadOnly("ConformanceLevel");
                if ((uint)value > 2u)
                {
                    throw new ArgumentOutOfRangeException("value");
                }
                conformanceLevel = value;
            }
        }

        [global::__DynamicallyInvokable]
        public bool CheckCharacters
        {
            [global::__DynamicallyInvokable]
            get
            {
                return checkCharacters;
            }
            [global::__DynamicallyInvokable]
            set
            {
                CheckReadOnly("CheckCharacters");
                checkCharacters = value;
            }
        }

        [global::__DynamicallyInvokable]
        public long MaxCharactersInDocument
        {
            [global::__DynamicallyInvokable]
            get
            {
                return maxCharactersInDocument;
            }
            [global::__DynamicallyInvokable]
            set
            {
                CheckReadOnly("MaxCharactersInDocument");
                if (value < 0)
                {
                    throw new ArgumentOutOfRangeException("value");
                }
                maxCharactersInDocument = value;
            }
        }

        [global::__DynamicallyInvokable]
        public long MaxCharactersFromEntities
        {
            [global::__DynamicallyInvokable]
            get
            {
                return maxCharactersFromEntities;
            }
            [global::__DynamicallyInvokable]
            set
            {
                CheckReadOnly("MaxCharactersFromEntities");
                if (value < 0)
                {
                    throw new ArgumentOutOfRangeException("value");
                }
                maxCharactersFromEntities = value;
            }
        }

        [global::__DynamicallyInvokable]
        public bool IgnoreWhitespace
        {
            [global::__DynamicallyInvokable]
            get
            {
                return ignoreWhitespace;
            }
            [global::__DynamicallyInvokable]
            set
            {
                CheckReadOnly("IgnoreWhitespace");
                ignoreWhitespace = value;
            }
        }

        [global::__DynamicallyInvokable]
        public bool IgnoreProcessingInstructions
        {
            [global::__DynamicallyInvokable]
            get
            {
                return ignorePIs;
            }
            [global::__DynamicallyInvokable]
            set
            {
                CheckReadOnly("IgnoreProcessingInstructions");
                ignorePIs = value;
            }
        }

        [global::__DynamicallyInvokable]
        public bool IgnoreComments
        {
            [global::__DynamicallyInvokable]
            get
            {
                return ignoreComments;
            }
            [global::__DynamicallyInvokable]
            set
            {
                CheckReadOnly("IgnoreComments");
                ignoreComments = value;
            }
        }

        [Obsolete("Use XmlReaderSettings.DtdProcessing property instead.")]
        public bool ProhibitDtd
        {
            get
            {
                return dtdProcessing == DtdProcessing.Prohibit;
            }
            set
            {
                CheckReadOnly("ProhibitDtd");
                dtdProcessing = ((!value) ? DtdProcessing.Parse : DtdProcessing.Prohibit);
            }
        }

        [global::__DynamicallyInvokable]
        public DtdProcessing DtdProcessing
        {
            [global::__DynamicallyInvokable]
            get
            {
                return dtdProcessing;
            }
            [global::__DynamicallyInvokable]
            set
            {
                CheckReadOnly("DtdProcessing");
                if ((uint)value > 2u)
                {
                    throw new ArgumentOutOfRangeException("value");
                }
                dtdProcessing = value;
            }
        }

        [global::__DynamicallyInvokable]
        public bool CloseInput
        {
            [global::__DynamicallyInvokable]
            get
            {
                return closeInput;
            }
            [global::__DynamicallyInvokable]
            set
            {
                CheckReadOnly("CloseInput");
                closeInput = value;
            }
        }

        public ValidationType ValidationType
        {
            get
            {
                return validationType;
            }
            set
            {
                CheckReadOnly("ValidationType");
                if ((uint)value > 4u)
                {
                    throw new ArgumentOutOfRangeException("value");
                }
                validationType = value;
            }
        }

        public XmlSchemaValidationFlags ValidationFlags
        {
            get
            {
                return validationFlags;
            }
            set
            {
                CheckReadOnly("ValidationFlags");
                if ((uint)value > 31u)
                {
                    throw new ArgumentOutOfRangeException("value");
                }
                validationFlags = value;
            }
        }

        public XmlSchemaSet Schemas
        {
            get
            {
                if (schemas == null)
                {
                    schemas = new XmlSchemaSet();
                }
                return schemas;
            }
            set
            {
                CheckReadOnly("Schemas");
                schemas = value;
            }
        }

        internal bool ReadOnly
        {
            get
            {
                return isReadOnly;
            }
            set
            {
                isReadOnly = value;
            }
        }

        public event ValidationEventHandler ValidationEventHandler
        {
            add
            {
                CheckReadOnly("ValidationEventHandler");
                valEventHandler = (ValidationEventHandler)Delegate.Combine(valEventHandler, value);
            }
            remove
            {
                CheckReadOnly("ValidationEventHandler");
                valEventHandler = (ValidationEventHandler)Delegate.Remove(valEventHandler, value);
            }
        }

        [global::__DynamicallyInvokable]
        public XmlReaderSettings()
        {
            Initialize();
        }

        [Obsolete("This API supports the .NET Framework infrastructure and is not intended to be used directly from your code.", true)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        public XmlReaderSettings(XmlResolver resolver)
        {
            Initialize(resolver);
        }

        internal XmlResolver GetXmlResolver()
        {
            return xmlResolver;
        }

        internal XmlResolver GetXmlResolver_CheckConfig()
        {
            if (XmlReaderSection.ProhibitDefaultUrlResolver && !IsXmlResolverSet)
            {
                return null;
            }
            return xmlResolver;
        }

        [global::__DynamicallyInvokable]
        public void Reset()
        {
            CheckReadOnly("Reset");
            Initialize();
        }

        [global::__DynamicallyInvokable]
        public XmlReaderSettings Clone()
        {
            XmlReaderSettings xmlReaderSettings = MemberwiseClone() as XmlReaderSettings;
            xmlReaderSettings.ReadOnly = false;
            return xmlReaderSettings;
        }

        internal ValidationEventHandler GetEventHandler()
        {
            return valEventHandler;
        }

        internal XmlReader CreateReader(string inputUri, XmlParserContext inputContext)
        {
            if (inputUri == null)
            {
                throw new ArgumentNullException("inputUri");
            }
            if (inputUri.Length == 0)
            {
                throw new ArgumentException(Res.GetString("XmlConvert_BadUri"), "inputUri");
            }
            XmlResolver xmlResolver = GetXmlResolver();
            if (xmlResolver == null)
            {
                xmlResolver = CreateDefaultResolver();
            }
            XmlReader xmlReader = new XmlTextReaderImpl(inputUri, this, inputContext, xmlResolver);
            if (ValidationType != 0)
            {
                xmlReader = AddValidation(xmlReader);
            }
            if (useAsync)
            {
                xmlReader = XmlAsyncCheckReader.CreateAsyncCheckWrapper(xmlReader);
            }
            return xmlReader;
        }

        internal XmlReader CreateReader(Stream input, Uri baseUri, string baseUriString, XmlParserContext inputContext)
        {
            if (input == null)
            {
                throw new ArgumentNullException("input");
            }
            if (baseUriString == null)
            {
                baseUriString = ((!(baseUri == null)) ? baseUri.ToString() : string.Empty);
            }
            XmlReader xmlReader = new XmlTextReaderImpl(input, null, 0, this, baseUri, baseUriString, inputContext, closeInput);
            if (ValidationType != 0)
            {
                xmlReader = AddValidation(xmlReader);
            }
            if (useAsync)
            {
                xmlReader = XmlAsyncCheckReader.CreateAsyncCheckWrapper(xmlReader);
            }
            return xmlReader;
        }

        internal XmlReader CreateReader(TextReader input, string baseUriString, XmlParserContext inputContext)
        {
            if (input == null)
            {
                throw new ArgumentNullException("input");
            }
            if (baseUriString == null)
            {
                baseUriString = string.Empty;
            }
            XmlReader xmlReader = new XmlTextReaderImpl(input, this, baseUriString, inputContext);
            if (ValidationType != 0)
            {
                xmlReader = AddValidation(xmlReader);
            }
            if (useAsync)
            {
                xmlReader = XmlAsyncCheckReader.CreateAsyncCheckWrapper(xmlReader);
            }
            return xmlReader;
        }

        internal XmlReader CreateReader(XmlReader reader)
        {
            if (reader == null)
            {
                throw new ArgumentNullException("reader");
            }
            return AddValidationAndConformanceWrapper(reader);
        }

        private void CheckReadOnly(string propertyName)
        {
            if (isReadOnly)
            {
                throw new XmlException("Xml_ReadOnlyProperty", GetType().Name + "." + propertyName);
            }
        }

        private void Initialize()
        {
            Initialize(null);
        }

        private void Initialize(XmlResolver resolver)
        {
            nameTable = null;
            if (!EnableLegacyXmlSettings())
            {
                xmlResolver = resolver;
                maxCharactersFromEntities = 10000000L;
            }
            else
            {
                xmlResolver = ((resolver == null) ? CreateDefaultResolver() : resolver);
                maxCharactersFromEntities = 0L;
            }
            lineNumberOffset = 0;
            linePositionOffset = 0;
            checkCharacters = true;
            conformanceLevel = ConformanceLevel.Document;
            ignoreWhitespace = false;
            ignorePIs = false;
            ignoreComments = false;
            dtdProcessing = DtdProcessing.Prohibit;
            closeInput = false;
            maxCharactersInDocument = 0L;
            schemas = null;
            validationType = ValidationType.None;
            validationFlags = XmlSchemaValidationFlags.ProcessIdentityConstraints;
            validationFlags |= XmlSchemaValidationFlags.AllowXmlAttributes;
            useAsync = false;
            isReadOnly = false;
            IsXmlResolverSet = false;
        }

        private static XmlResolver CreateDefaultResolver()
        {
            return new XmlUrlResolver();
        }

        internal XmlReader AddValidation(XmlReader reader)
        {
            if (validationType == ValidationType.Schema)
            {
                XmlResolver xmlResolver = GetXmlResolver_CheckConfig();
                if (xmlResolver == null && !IsXmlResolverSet && !EnableLegacyXmlSettings())
                {
                    xmlResolver = new XmlUrlResolver();
                }
                reader = new XsdValidatingReader(reader, xmlResolver, this);
            }
            else if (validationType == ValidationType.DTD)
            {
                reader = CreateDtdValidatingReader(reader);
            }
            return reader;
        }

        private XmlReader AddValidationAndConformanceWrapper(XmlReader reader)
        {
            if (validationType == ValidationType.DTD)
            {
                reader = CreateDtdValidatingReader(reader);
            }
            reader = AddConformanceWrapper(reader);
            if (validationType == ValidationType.Schema)
            {
                reader = new XsdValidatingReader(reader, GetXmlResolver_CheckConfig(), this);
            }
            return reader;
        }

        private XmlValidatingReaderImpl CreateDtdValidatingReader(XmlReader baseReader)
        {
            return new XmlValidatingReaderImpl(baseReader, GetEventHandler(), (ValidationFlags & XmlSchemaValidationFlags.ProcessIdentityConstraints) != XmlSchemaValidationFlags.None);
        }

        internal XmlReader AddConformanceWrapper(XmlReader baseReader)
        {
            XmlReaderSettings settings = baseReader.Settings;
            bool flag = false;
            bool flag2 = false;
            bool flag3 = false;
            bool ignorePis = false;
            DtdProcessing dtdProcessing = (DtdProcessing)(-1);
            bool flag4 = false;
            if (settings == null)
            {
                if (conformanceLevel != 0 && conformanceLevel != XmlReader.GetV1ConformanceLevel(baseReader))
                {
                    throw new InvalidOperationException(Res.GetString("Xml_IncompatibleConformanceLevel", conformanceLevel.ToString()));
                }
                XmlTextReader xmlTextReader = baseReader as XmlTextReader;
                if (xmlTextReader == null)
                {
                    XmlValidatingReader xmlValidatingReader = baseReader as XmlValidatingReader;
                    if (xmlValidatingReader != null)
                    {
                        xmlTextReader = (XmlTextReader)xmlValidatingReader.Reader;
                    }
                }
                if (ignoreWhitespace)
                {
                    WhitespaceHandling whitespaceHandling = WhitespaceHandling.All;
                    if (xmlTextReader != null)
                    {
                        whitespaceHandling = xmlTextReader.WhitespaceHandling;
                    }
                    if (whitespaceHandling == WhitespaceHandling.All)
                    {
                        flag2 = true;
                        flag4 = true;
                    }
                }
                if (ignoreComments)
                {
                    flag3 = true;
                    flag4 = true;
                }
                if (ignorePIs)
                {
                    ignorePis = true;
                    flag4 = true;
                }
                DtdProcessing dtdProcessing2 = DtdProcessing.Parse;
                if (xmlTextReader != null)
                {
                    dtdProcessing2 = xmlTextReader.DtdProcessing;
                }
                if ((this.dtdProcessing == DtdProcessing.Prohibit && dtdProcessing2 != 0) || (this.dtdProcessing == DtdProcessing.Ignore && dtdProcessing2 == DtdProcessing.Parse))
                {
                    dtdProcessing = this.dtdProcessing;
                    flag4 = true;
                }
            }
            else
            {
                if (conformanceLevel != settings.ConformanceLevel && conformanceLevel != 0)
                {
                    throw new InvalidOperationException(Res.GetString("Xml_IncompatibleConformanceLevel", conformanceLevel.ToString()));
                }
                if (checkCharacters && !settings.CheckCharacters)
                {
                    flag = true;
                    flag4 = true;
                }
                if (ignoreWhitespace && !settings.IgnoreWhitespace)
                {
                    flag2 = true;
                    flag4 = true;
                }
                if (ignoreComments && !settings.IgnoreComments)
                {
                    flag3 = true;
                    flag4 = true;
                }
                if (ignorePIs && !settings.IgnoreProcessingInstructions)
                {
                    ignorePis = true;
                    flag4 = true;
                }
                if ((this.dtdProcessing == DtdProcessing.Prohibit && settings.DtdProcessing != 0) || (this.dtdProcessing == DtdProcessing.Ignore && settings.DtdProcessing == DtdProcessing.Parse))
                {
                    dtdProcessing = this.dtdProcessing;
                    flag4 = true;
                }
            }
            if (flag4)
            {
                IXmlNamespaceResolver xmlNamespaceResolver = baseReader as IXmlNamespaceResolver;
                if (xmlNamespaceResolver != null)
                {
                    return new XmlCharCheckingReaderWithNS(baseReader, xmlNamespaceResolver, flag, flag2, flag3, ignorePis, dtdProcessing);
                }
                return new XmlCharCheckingReader(baseReader, flag, flag2, flag3, ignorePis, dtdProcessing);
            }
            return baseReader;
        }

        internal static bool EnableLegacyXmlSettings()
        {
            if (s_enableLegacyXmlSettings.HasValue)
            {
                return s_enableLegacyXmlSettings.Value;
            }
            if (!BinaryCompatibility.TargetsAtLeast_Desktop_V4_5_2)
            {
                s_enableLegacyXmlSettings = true;
                return s_enableLegacyXmlSettings.Value;
            }
            bool value = false;
            if (!ReadSettingsFromRegistry(Registry.LocalMachine, ref value))
            {
                ReadSettingsFromRegistry(Registry.CurrentUser, ref value);
            }
            s_enableLegacyXmlSettings = value;
            return s_enableLegacyXmlSettings.Value;
        }

        [SecuritySafeCritical]
        [RegistryPermission(SecurityAction.Assert, Unrestricted = true)]
        private static bool ReadSettingsFromRegistry(RegistryKey hive, ref bool value)
        {
            try
            {
                using (RegistryKey registryKey = hive.OpenSubKey("SOFTWARE\\Microsoft\\.NETFramework\\XML", writable: false))
                {
                    if (registryKey != null && registryKey.GetValueKind("EnableLegacyXmlSettings") == RegistryValueKind.DWord)
                    {
                        value = ((int)registryKey.GetValue("EnableLegacyXmlSettings") == 1);
                        return true;
                    }
                }
            }
            catch
            {
            }
            return false;
        }
    }
}