Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Workflow.ComponentModel/AuthoringOM/Compiler/Configuration.cs

@@ -0,0 +1,167 @@
+namespace System.Workflow.ComponentModel.Compiler
+{
+    using System.Xml;
+    using System.Collections.Generic;
+    using System.Configuration;
+    using System.Globalization;
+    using System.Xml.Serialization;
+    using System.Text.RegularExpressions;
+
+    internal sealed class WorkflowCompilerConfigurationSectionGroup : ConfigurationSectionGroup
+    {
+        public WorkflowCompilerConfigurationSectionGroup()
+        {
+        }
+    }
+
+    internal sealed class AuthorizedTypesSectionHandler : IConfigurationSectionHandler
+    {
+        const string TargetFxVersionAttribute = "version";
+        #region IConfigurationSectionHandler Members
+
+        object IConfigurationSectionHandler.Create(object parent, object configContext, XmlNode section)
+        {
+            Dictionary<string, IList<AuthorizedType>> authorizedTypes = new Dictionary<string, IList<AuthorizedType>>();
+
+            XmlAttributeOverrides authorizedTypeOverrides = new XmlAttributeOverrides();
+            XmlAttributes authorizedTypeAttributes = new XmlAttributes();
+            authorizedTypeAttributes.XmlRoot = new XmlRootAttribute("authorizedType");
+            authorizedTypeOverrides.Add(typeof(AuthorizedType), authorizedTypeAttributes);
+            XmlSerializer xmlSerializer = new XmlSerializer(typeof(AuthorizedType), authorizedTypeOverrides);
+            foreach (XmlNode targetFx in section.ChildNodes)
+            {
+                XmlAttribute versionAttribute = targetFx.Attributes.GetNamedItem(TargetFxVersionAttribute) as XmlAttribute;
+                if (versionAttribute != null)
+                {
+                    string version = versionAttribute.Value;
+                    if (!string.IsNullOrEmpty(version))
+                    {
+                        IList<AuthorizedType> versionTypes;
+                        if (!authorizedTypes.TryGetValue(version, out versionTypes))
+                        {
+                            versionTypes = new List<AuthorizedType>();
+                            authorizedTypes.Add(version, versionTypes);
+                        }
+                        foreach (XmlNode authorizedTypeNode in targetFx.ChildNodes)
+                        {
+                            AuthorizedType authorizedType = xmlSerializer.Deserialize(new XmlNodeReader(authorizedTypeNode)) as AuthorizedType;
+                            if (authorizedType != null)
+                            {
+                                versionTypes.Add(authorizedType);
+                            }
+                        }
+                    }
+                }
+            }
+            return authorizedTypes;
+        }
+
+        #endregion
+    }
+    
+    [XmlType("authorizedType")]
+    [Obsolete("The System.Workflow.* types are deprecated.  Instead, please use the new types from System.Activities.*")]
+    public sealed class AuthorizedType
+    {
+        private string assemblyName;
+        private string namespaceName;
+        private string typeName;
+        private bool isAuthorized;
+        private Regex regex;
+
+        [XmlAttribute]
+        public string Assembly
+        {
+            get
+            {
+                return this.assemblyName;
+            }
+            set
+            {
+                this.assemblyName = value;
+            }
+        }
+
+        [XmlAttribute]
+        public string Namespace
+        {
+            get
+            {
+                return this.namespaceName;
+            }
+
+            set
+            {
+                this.namespaceName = value;
+            }
+        }
+
+        [XmlAttribute]
+        public string TypeName
+        {
+            get
+            {
+                return this.typeName;
+            }
+
+            set
+            {
+                this.typeName = value;
+            }
+        }
+
+        [XmlAttribute]
+        public string Authorized
+        {
+            get
+            {
+                return this.isAuthorized.ToString();
+            }
+
+            set
+            {
+                this.isAuthorized = bool.Parse(value);
+            }
+        }
+
+        [XmlIgnore]
+        public Regex RegularExpression
+        {
+            get
+            {
+                if (this.regex == null)
+                {
+                    this.regex = new Regex(MakeRegex(string.Format(CultureInfo.InvariantCulture, "{0}.{1}, {2}", new object[] { this.namespaceName, this.typeName, this.assemblyName })), RegexOptions.Compiled);
+                    return this.regex;
+                }
+                return this.regex;
+            }
+        }
+
+        private static string MakeRegex(string inputString)
+        {
+            // RegEx uses the following as meta characters:
+            // [\^$.|?*+()
+            // Of these we translate * and ? to DOS wildcard equivalents in RegEx. 
+            // We escape rest of the Regex meta characters to thwart any luring 
+            // attacks caused by malformed inputString using meta characters.
+            string outputString = inputString.Replace(@"\", @"\\");
+            outputString = outputString.Replace("[", @"\[");
+            outputString = outputString.Replace("^", @"\^");
+            outputString = outputString.Replace("$", @"\$");
+            outputString = outputString.Replace("|", @"\|");
+            outputString = outputString.Replace("+", @"\+");
+            outputString = outputString.Replace("(", @"\(");
+            outputString = outputString.Replace(")", @"\)");
+            outputString = outputString.Replace(".", @"\x2E");
+
+            outputString = outputString.Replace("*", @"[\w\x60\x2E]{0,}");
+            outputString = outputString.Replace("?", @"\w{1,1}");
+
+            // Make whitespaces optional
+            outputString = outputString.Replace(" ", @"\s{0,}");
+            return outputString;
+        }
+    }
+}
+