InitialSessionStateProvider.cs

/********************************************************************++
 * Copyright (c) Microsoft Corporation.  All rights reserved.
 * --********************************************************************/

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Management.Automation.Tracing;
using Microsoft.PowerShell.Commands;
using Microsoft.Win32;
using System.Reflection;
using System.IO;
using System.Xml;
using System.Globalization;
using System.Diagnostics.CodeAnalysis;
using System.Management.Automation.Internal;
using System.Management.Automation.Runspaces;
using Dbg = System.Management.Automation.Diagnostics;
using System.Collections;


namespace System.Management.Automation.Remoting
{
    /// <summary>
    /// This struct is used to represent contents from configuration xml. The
    /// XML is passed to plugins by WSMan API.
    /// This helper does not validate XML content as it is already validated
    /// by WSMan.
    /// </summary>
    internal class ConfigurationDataFromXML
    {
        #region Config XML Constants

        internal const string INITPARAMETERSTOKEN = "InitializationParameters";
        internal const string PARAMTOKEN = "Param";
        internal const string NAMETOKEN = "Name";
        internal const string VALUETOKEN = "Value";
        internal const string APPBASETOKEN = "applicationbase";
        internal const string ASSEMBLYTOKEN = "assemblyname";
        internal const string SHELLCONFIGTYPETOKEN = "pssessionconfigurationtypename";
        internal const string STARTUPSCRIPTTOKEN = "startupscript";
        internal const string MAXRCVDOBJSIZETOKEN = "psmaximumreceivedobjectsizemb";
        internal const string MAXRCVDOBJSIZETOKEN_CamelCase = "PSMaximumReceivedObjectSizeMB";
        internal const string MAXRCVDCMDSIZETOKEN = "psmaximumreceiveddatasizepercommandmb";
        internal const string MAXRCVDCMDSIZETOKEN_CamelCase = "PSMaximumReceivedDataSizePerCommandMB";
        internal const string THREADOPTIONSTOKEN = "pssessionthreadoptions";
#if !CORECLR // No ApartmentState In CoreCLR
        internal const string THREADAPTSTATETOKEN = "pssessionthreadapartmentstate";
#endif
        internal const string SESSIONCONFIGTOKEN = "sessionconfigurationdata";
        internal const string PSVERSIONTOKEN = "PSVersion";
        internal const string MAXPSVERSIONTOKEN = "MaxPSVersion";
        internal const string MODULESTOIMPORT = "ModulesToImport";
        internal const string HOSTMODE = "hostmode";
        internal const string ENDPOINTCONFIGURATIONTYPE = "sessiontype";
        internal const string WORKFLOWCOREASSEMBLY = "Microsoft.PowerShell.Workflow.ServiceCore, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL";
        internal const string WORKFLOWCORETYPENAME = "Microsoft.PowerShell.Workflow.PSWorkflowSessionConfiguration";
        internal const string PSWORKFLOWMODULE = "%windir%\\system32\\windowspowershell\\v1.0\\Modules\\PSWorkflow";
        internal const string CONFIGFILEPATH = "configfilepath";
        internal const string CONFIGFILEPATH_CamelCase = "ConfigFilePath";

        #endregion

        internal string StartupScript;
        // this field is used only by an Out-Of-Process (IPC) server process
        internal string InitializationScriptForOutOfProcessRunspace;
        internal string ApplicationBase;
        internal string AssemblyName;
        internal string EndPointConfigurationTypeName;
        internal Type EndPointConfigurationType;
        internal Nullable<int> MaxReceivedObjectSizeMB;
        internal Nullable<int> MaxReceivedCommandSizeMB;
        // Used to set properties on the RunspacePool created for this shell.
        internal Nullable<PSThreadOptions> ShellThreadOptions;

#if !CORECLR // No ApartmentState In CoreCLR
        internal Nullable<System.Threading.ApartmentState> ShellThreadApartmentState;
#endif
        internal PSSessionConfigurationData SessionConfigurationData;
        internal string ConfigFilePath;

        /// <summary>
        /// Using optionName and optionValue updates the current object
        /// </summary>
        /// <param name="optionName"></param>
        /// <param name="optionValue"></param>
        /// <exception cref="ArgumentException">
        /// 1. "optionName" is not valid in "InitializationParameters" section.
        /// 2. "startupscript" must specify a PowerShell script file that ends with extension ".ps1".
        /// </exception>
        private void Update(string optionName, string optionValue)
        {
            switch (optionName.ToLowerInvariant())
            {
                case APPBASETOKEN:
                    AssertValueNotAssigned(APPBASETOKEN, ApplicationBase);
                    // this is a folder pointing to application base of the plugin shell
                    // allow the folder path to use environment variables.
                    ApplicationBase = Environment.ExpandEnvironmentVariables(optionValue);
                    break;
                case ASSEMBLYTOKEN:
                    AssertValueNotAssigned(ASSEMBLYTOKEN, AssemblyName);
                    AssemblyName = optionValue;
                    break;
                case SHELLCONFIGTYPETOKEN:
                    AssertValueNotAssigned(SHELLCONFIGTYPETOKEN, EndPointConfigurationTypeName);
                    EndPointConfigurationTypeName = optionValue;
                    break;
                case STARTUPSCRIPTTOKEN:
                    AssertValueNotAssigned(STARTUPSCRIPTTOKEN, StartupScript);
                    if (!optionValue.EndsWith(".ps1", StringComparison.OrdinalIgnoreCase))
                    {
                        throw PSTraceSource.NewArgumentException(STARTUPSCRIPTTOKEN,
                            RemotingErrorIdStrings.StartupScriptNotCorrect,
                            STARTUPSCRIPTTOKEN);
                    }
                    // allow the script file to exist in any path..and support
                    // environment variable expansion.
                    StartupScript = Environment.ExpandEnvironmentVariables(optionValue);
                    break;
                case MAXRCVDOBJSIZETOKEN:
                    AssertValueNotAssigned(MAXRCVDOBJSIZETOKEN, MaxReceivedObjectSizeMB);
                    MaxReceivedObjectSizeMB = GetIntValueInBytes(optionValue);
                    break;
                case MAXRCVDCMDSIZETOKEN:
                    AssertValueNotAssigned(MAXRCVDCMDSIZETOKEN, MaxReceivedCommandSizeMB);
                    MaxReceivedCommandSizeMB = GetIntValueInBytes(optionValue);
                    break;
                case THREADOPTIONSTOKEN:
                    AssertValueNotAssigned(THREADOPTIONSTOKEN, ShellThreadOptions);
                    ShellThreadOptions = (PSThreadOptions)LanguagePrimitives.ConvertTo(
                        optionValue, typeof(PSThreadOptions), CultureInfo.InvariantCulture);
                    break;
#if !CORECLR // No ApartmentState In CoreCLR
                case THREADAPTSTATETOKEN:
                    AssertValueNotAssigned(THREADAPTSTATETOKEN, ShellThreadApartmentState);
                    ShellThreadApartmentState = (System.Threading.ApartmentState)LanguagePrimitives.ConvertTo(
                        optionValue, typeof(System.Threading.ApartmentState), CultureInfo.InvariantCulture);
                    break;
#endif
                case SESSIONCONFIGTOKEN:
                    {
                        AssertValueNotAssigned(SESSIONCONFIGTOKEN, SessionConfigurationData);
                        SessionConfigurationData = PSSessionConfigurationData.Create(optionValue);
                    }
                    break;
                case CONFIGFILEPATH:
                    {
                        AssertValueNotAssigned(CONFIGFILEPATH, ConfigFilePath);
                        ConfigFilePath = optionValue.ToString();
                    }
                    break;
                default:
                    // we dont need to evaluate PSVersion and other custom authz
                    // related tokens
                    break;
            }
        }

        /// <summary>
        /// Checks if the originalValue is empty. If not throws an exception
        /// </summary>
        /// <param name="optionName"></param>
        /// <param name="originalValue"></param>
        /// <exception cref="ArgumentException">
        /// 1. "optionName" is already defined
        /// </exception>
        private void AssertValueNotAssigned(string optionName, object originalValue)
        {
            if (originalValue != null)
            {
                throw PSTraceSource.NewArgumentException(optionName,
                    RemotingErrorIdStrings.DuplicateInitializationParameterFound, optionName, INITPARAMETERSTOKEN);
            }
        }

        /// <summary>
        /// Converts the value specified by <paramref name="optionValue"/> to int.
        /// Multiplies the value by 1MB (1024*1024) to get the number in bytes.
        /// </summary>
        /// <param name="optionValueInMB"></param>
        /// <returns>
        /// If value is specified, specified value as int . otherwise null.
        /// </returns>
        private static Nullable<int> GetIntValueInBytes(string optionValueInMB)
        {
            Nullable<int> result = null;
            try
            {
                double variableValue = (double)LanguagePrimitives.ConvertTo(optionValueInMB,
                    typeof(double), System.Globalization.CultureInfo.InvariantCulture);

                result = unchecked((int)(variableValue * 1024 * 1024)); // Multiply by 1MB
            }
            catch (InvalidCastException)
            {
            }

            if (result < 0)
            {
                result = null;
            }

            return result;
        }


        /// <summary>
        /// Creates the struct from initialization parameters xml.
        /// </summary>
        /// <param name="initializationParameters">
        /// Initialization Parameters xml passed by WSMan API. This data is read from the config
        /// xml and is in the following format:
        /// </param>
        /// <returns></returns>
        /// <exception cref="ArgumentException">
        /// 1. "optionName" is already defined
        /// </exception>
        /* 
                  <InitializationParameters>
                    <Param Name="PSVersion" Value="2.0" />
                    <Param Name="ApplicationBase" Value="<folder path>" />
                    ...
                  </InitializationParameters> 
        */
        /* The following extensions have been added in V3 providing the user
         * the ability to pass data to the session configuration for initialization
         * 
                <Param Name="SessionConfigurationData" Value="<SessionConfigurationData with XML escaping>" />
         * 
         * The session configuration data blob can be defined as under
                    <SessionConfigurationData>
                        <Param Name="ModulesToImport" Value="<folder path>" />
                        <Param Name="PrivateData" />
                            <PrivateData>
                            ...
                            </PrivateData>
                        </Param>
                    </SessionConfigurationData>                    
         */
        internal static ConfigurationDataFromXML Create(string initializationParameters)
        {
            ConfigurationDataFromXML result = new ConfigurationDataFromXML();
            if (string.IsNullOrEmpty(initializationParameters))
            {
                return result;
            }

            XmlReaderSettings readerSettings = new XmlReaderSettings();
            readerSettings.CheckCharacters = false;
            readerSettings.IgnoreComments = true;
            readerSettings.IgnoreProcessingInstructions = true;
            readerSettings.MaxCharactersInDocument = 10000;
            readerSettings.ConformanceLevel = ConformanceLevel.Fragment;
#if !CORECLR // No XmlReaderSettings.XmlResolver in CoreCLR
            readerSettings.XmlResolver = null;
#endif

            using (XmlReader reader = XmlReader.Create(new StringReader(initializationParameters), readerSettings))
            {
                // read the header <InitializationParameters>
                if (reader.ReadToFollowing(INITPARAMETERSTOKEN))
                {
                    bool isParamFound = reader.ReadToDescendant(PARAMTOKEN);
                    while (isParamFound)
                    {
                        if (!reader.MoveToAttribute(NAMETOKEN))
                        {
                            throw PSTraceSource.NewArgumentException(initializationParameters,
                                RemotingErrorIdStrings.NoAttributesFoundForParamElement,
                                NAMETOKEN, VALUETOKEN, PARAMTOKEN);
                        }

                        string optionName = reader.Value;

                        if (!reader.MoveToAttribute(VALUETOKEN))
                        {
                            throw PSTraceSource.NewArgumentException(initializationParameters,
                                                                        RemotingErrorIdStrings.NoAttributesFoundForParamElement,
                                                                        NAMETOKEN, VALUETOKEN, PARAMTOKEN);
                        }

                        string optionValue = reader.Value;
                        result.Update(optionName, optionValue);

                        // move to next Param token.
                        isParamFound = reader.ReadToFollowing(PARAMTOKEN);
                    }
                }
            }

            // assign defaults after parsing the xml content.
            if (null == result.MaxReceivedObjectSizeMB)
            {
                result.MaxReceivedObjectSizeMB = BaseTransportManager.MaximumReceivedObjectSize;
            }

            if (null == result.MaxReceivedCommandSizeMB)
            {
                result.MaxReceivedCommandSizeMB = BaseTransportManager.MaximumReceivedDataSize;
            }

            return result;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        /// <exception cref="ArgumentException">
        /// 1. Unable to load type "{0}" specified in "InitializationParameters" section.
        /// </exception>
        internal PSSessionConfiguration CreateEndPointConfigurationInstance()
        {
            try
            {
                return (PSSessionConfiguration)Activator.CreateInstance(EndPointConfigurationType);
            }
            catch (TypeLoadException)
            {
            }
            catch (ArgumentException)
            {
            }
            catch (MissingMethodException)
            {
            }
            catch (InvalidCastException)
            {
            }
            catch (TargetInvocationException)
            {
            }

            // if we are here, that means we are unble to load the type specified
            // in the config xml.. notify the same.
            throw PSTraceSource.NewArgumentException("typeToLoad", RemotingErrorIdStrings.UnableToLoadType,
                    EndPointConfigurationTypeName, ConfigurationDataFromXML.INITPARAMETERSTOKEN);
        }
    }

    /// <summary>
    /// InitialSessionStateProvider is used by 3rd parties to provide shell configurtion
    /// on the remote server.
    /// </summary>
    public abstract class PSSessionConfiguration : IDisposable
    {
        #region tracer
        /// <summary>
        /// Tracer for Server Remote session
        /// </summary>
        [TraceSourceAttribute("ServerRemoteSession", "ServerRemoteSession")]
        private static readonly PSTraceSource s_tracer = PSTraceSource.GetTracer("ServerRemoteSession", "ServerRemoteSession");
        #endregion tracer

        #region public interfaces

        /// <summary>
        /// Derived classes must override this to supply an InitialSesionState
        /// to be used to construct a Runspace for the user
        /// </summary>
        /// <param name="senderInfo">
        /// User Identity for which this information is requested
        /// </param>
        /// <returns></returns>
        public abstract InitialSessionState GetInitialSessionState(PSSenderInfo senderInfo);

        /// <summary>
        /// 
        /// </summary>
        /// <param name="sessionConfigurationData"></param>
        /// <param name="senderInfo"></param>
        /// <param name="configProviderId"></param>
        /// <returns></returns>
        public virtual InitialSessionState GetInitialSessionState(PSSessionConfigurationData sessionConfigurationData,
            PSSenderInfo senderInfo, string configProviderId)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// Maximum size (in bytes) of a deserialized object received from a remote machine.
        /// If null, then the size is unlimited. Default is 10MB.
        /// </summary>
        /// <param name="senderInfo">
        /// User Identity for which this information is requested
        /// </param>
        /// <returns></returns>
        public virtual Nullable<int> GetMaximumReceivedObjectSize(PSSenderInfo senderInfo)
        {
            return BaseTransportManager.MaximumReceivedObjectSize;
        }

        /// <summary>
        /// Total data (in bytes) that can be received from a remote machine
        /// targeted towards a command. If null, then the size is unlimited.
        /// Default is 50MB.
        /// </summary>
        /// <param name="senderInfo">
        /// User Identity for which this information is requested
        /// </param>
        /// <returns></returns>
        public virtual Nullable<int> GetMaximumReceivedDataSizePerCommand(PSSenderInfo senderInfo)
        {
            return BaseTransportManager.MaximumReceivedDataSize;
        }

        /// <summary>
        /// Derived classes can override this method to provide application private data
        /// that is going to be sent to the client and exposed via 
        /// <see cref="System.Management.Automation.Runspaces.PSSession.ApplicationPrivateData"/>,
        /// <see cref="System.Management.Automation.Runspaces.Runspace.GetApplicationPrivateData"/> and
        /// <see cref="System.Management.Automation.Runspaces.RunspacePool.GetApplicationPrivateData"/>
        /// </summary>
        /// <param name="senderInfo">
        /// User Identity for which this information is requested
        /// </param>
        /// <returns>Application private data or <c>null</c></returns>
        public virtual PSPrimitiveDictionary GetApplicationPrivateData(PSSenderInfo senderInfo)
        {
            return null;
        }

        #endregion

        #region IDisposable Overrides

        /// <summary>
        /// Disose this configuration object. This will be called when a Runspace/RunspacePool
        /// created using InitialSessionState from this object is Closed.
        /// </summary>
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="isDisposing"></param>
        protected virtual void Dispose(bool isDisposing)
        {
        }

        #endregion

        #region GetInitialSessionState from 3rd party shell ids

        /// <summary>
        /// 
        /// </summary>
        /// <param name="shellId"></param>
        /// <param name="initializationParameters">
        /// Initialization Parameters xml passed by WSMan API. This data is read from the config
        /// xml and is in the following format:  
        /// </param>   
        /// <returns></returns>        
        /// <exception cref="InvalidOperationException">
        /// 1. Non existent InitialSessionState provider for the shellID
        /// </exception>
        /* 
                  <InitializationParameters>
                    <Param Name="PSVersion" Value="2.0" />
                    <Param Name="ApplicationBase" Value="<folder path>" />
                    ...
                  </InitializationParameters>
         */
        internal static ConfigurationDataFromXML LoadEndPointConfiguration(string shellId,
            string initializationParameters)
        {
            ConfigurationDataFromXML configData = null;

            if (!s_ssnStateProviders.ContainsKey(initializationParameters))
            {
                LoadRSConfigProvider(shellId, initializationParameters);
            }

            lock (s_syncObject)
            {
                if (!s_ssnStateProviders.TryGetValue(initializationParameters, out configData))
                {
                    throw PSTraceSource.NewInvalidOperationException(RemotingErrorIdStrings.NonExistentInitialSessionStateProvider, shellId);
                }
            }

            return configData;
        }

        private static void LoadRSConfigProvider(string shellId, string initializationParameters)
        {
            ConfigurationDataFromXML configData = ConfigurationDataFromXML.Create(initializationParameters);

            Type endPointConfigType = LoadAndAnalyzeAssembly(shellId,
                configData.ApplicationBase,
                configData.AssemblyName,
                configData.EndPointConfigurationTypeName);
            Dbg.Assert(endPointConfigType != null, "EndPointConfiguration type cannot be null");
            configData.EndPointConfigurationType = endPointConfigType;
            lock (s_syncObject)
            {
                if (!s_ssnStateProviders.ContainsKey(initializationParameters))
                {
                    s_ssnStateProviders.Add(initializationParameters, configData);
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="shellId">
        /// shellId for which the assembly is getting loaded
        /// </param>
        /// <param name="applicationBase"></param>
        /// <param name="assemblyName"></param>
        /// <param name="typeToLoad">
        /// type which is supplying the configuration.
        /// </param>
        /// <exception cref="InvalidOperationException">
        /// </exception>
        /// <returns>
        /// Type instance representing the EndPointConfiguration to load.
        /// This Type can be instantiated when needed.
        /// </returns>
        private static Type LoadAndAnalyzeAssembly(string shellId, string applicationBase,
            string assemblyName, string typeToLoad)
        {
            if ((string.IsNullOrEmpty(assemblyName) && !string.IsNullOrEmpty(typeToLoad)) ||
                 (!string.IsNullOrEmpty(assemblyName) && string.IsNullOrEmpty(typeToLoad)))
            {
                throw PSTraceSource.NewInvalidOperationException(RemotingErrorIdStrings.TypeNeedsAssembly,
                    ConfigurationDataFromXML.ASSEMBLYTOKEN,
                    ConfigurationDataFromXML.SHELLCONFIGTYPETOKEN,
                    ConfigurationDataFromXML.INITPARAMETERSTOKEN);
            }

            Assembly assembly = null;
            if (!string.IsNullOrEmpty(assemblyName))
            {
                PSEtwLog.LogAnalyticVerbose(PSEventId.LoadingPSCustomShellAssembly,
                    PSOpcode.Connect, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic,
                    assemblyName, shellId);

                assembly = LoadSsnStateProviderAssembly(applicationBase, assemblyName);
                if (null == assembly)
                {
                    throw PSTraceSource.NewArgumentException("assemblyName", RemotingErrorIdStrings.UnableToLoadAssembly,
                        assemblyName, ConfigurationDataFromXML.INITPARAMETERSTOKEN);
                }
            }

            // configuration xml specified an assembly and typetoload.
            if (null != assembly)
            {
                try
                {
                    PSEtwLog.LogAnalyticVerbose(PSEventId.LoadingPSCustomShellType,
                        PSOpcode.Connect, PSTask.None, PSKeyword.Transport | PSKeyword.UseAlwaysAnalytic,
                        typeToLoad, shellId);

                    Type type = assembly.GetType(typeToLoad, true, true);
                    if (null == type)
                    {
                        throw PSTraceSource.NewArgumentException("typeToLoad", RemotingErrorIdStrings.UnableToLoadType,
                            typeToLoad, ConfigurationDataFromXML.INITPARAMETERSTOKEN);
                    }

                    return type;
                }
                catch (ReflectionTypeLoadException)
                {
                }
                catch (TypeLoadException)
                {
                }
                catch (ArgumentException)
                {
                }
                catch (MissingMethodException)
                {
                }
                catch (InvalidCastException)
                {
                }
                catch (TargetInvocationException)
                {
                }

                // if we are here, that means we are unble to load the type specified
                // in the config xml.. notify the same.
                throw PSTraceSource.NewArgumentException("typeToLoad", RemotingErrorIdStrings.UnableToLoadType,
                        typeToLoad, ConfigurationDataFromXML.INITPARAMETERSTOKEN);
            }

            // load the default PowerShell since plugin config
            // did not specify a typename to load.
            return typeof(DefaultRemotePowerShellConfiguration);
        }

        /// <summary>
        /// Sets the application's current working directory to <paramref name="applicationBase"/> and 
        /// loads the assembly <paramref name="assemblyName"/>. Once the assembly is loaded, the application's
        /// current working directory is set back to the orginal value.
        /// </summary>
        /// <param name="applicationBase"></param>
        /// <param name="assemblyName"></param>
        /// <returns></returns>
        // TODO: Send the exception message back to the client.
        [SuppressMessage("Microsoft.Reliability", "CA2001:AvoidCallingProblematicMethods", MessageId = "System.Reflection.Assembly.LoadFrom")]
        private static Assembly LoadSsnStateProviderAssembly(string applicationBase, string assemblyName)
        {
            Dbg.Assert(!string.IsNullOrEmpty(assemblyName), "AssemblyName cannot be null.");

            string originalDirectory = string.Empty;

            if (!string.IsNullOrEmpty(applicationBase))
            {
                // changing current working directory allows CLR loader to load dependent assemblies
                try
                {
                    originalDirectory = Directory.GetCurrentDirectory();
                    Directory.SetCurrentDirectory(applicationBase);
                }
                catch (ArgumentException e)
                {
                    s_tracer.TraceWarning("Not able to change curent working directory to {0}: {1}",
                        applicationBase, e.Message);
                }
                catch (PathTooLongException e)
                {
                    s_tracer.TraceWarning("Not able to change curent working directory to {0}: {1}",
                           applicationBase, e.Message);
                }
                catch (FileNotFoundException e)
                {
                    s_tracer.TraceWarning("Not able to change curent working directory to {0}: {1}",
                        applicationBase, e.Message);
                }
                catch (IOException e)
                {
                    s_tracer.TraceWarning("Not able to change curent working directory to {0}: {1}",
                        applicationBase, e.Message);
                }
                catch (System.Security.SecurityException e)
                {
                    s_tracer.TraceWarning("Not able to change curent working directory to {0}: {1}",
                           applicationBase, e.Message);
                }
                catch (UnauthorizedAccessException e)
                {
                    s_tracer.TraceWarning("Not able to change curent working directory to {0}: {1}",
                        applicationBase, e.Message);
                }
            }

            // Even if there is erro changing current working directory..try to load the assembly
            // This is to allow assembly loading from GAC
            Assembly result = null;
            try
            {
                try
                {
                    result = Assembly.Load(new AssemblyName(assemblyName));
                }
                catch (FileLoadException e)
                {
                    s_tracer.TraceWarning("Not able to load assembly {0}: {1}", assemblyName, e.Message);
                }
                catch (BadImageFormatException e)
                {
                    s_tracer.TraceWarning("Not able to load assembly {0}: {1}", assemblyName, e.Message);
                }
                catch (FileNotFoundException e)
                {
                    s_tracer.TraceWarning("Not able to load assembly {0}: {1}", assemblyName, e.Message);
                }

                if (null != result)
                {
                    return result;
                }
                s_tracer.WriteLine("Loading assembly from path {0}", applicationBase);
                try
                {
                    String assemblyPath;
                    if (!Path.IsPathRooted(assemblyName))
                    {
                        if (!String.IsNullOrEmpty(applicationBase) && Directory.Exists(applicationBase))
                        {
                            assemblyPath = Path.Combine(applicationBase, assemblyName);
                        }
                        else
                        {
                            assemblyPath = Path.Combine(Directory.GetCurrentDirectory(), assemblyName);
                        }
                    }
                    else
                    {
                        //Rooted path of dll is provided.
                        assemblyPath = assemblyName;
                    }
                    result = ClrFacade.LoadFrom(assemblyPath);
                }
                catch (FileLoadException e)
                {
                    s_tracer.TraceWarning("Not able to load assembly {0}: {1}", assemblyName, e.Message);
                }
                catch (BadImageFormatException e)
                {
                    s_tracer.TraceWarning("Not able to load assembly {0}: {1}", assemblyName, e.Message);
                }
                catch (FileNotFoundException e)
                {
                    s_tracer.TraceWarning("Not able to load assembly {0}: {1}", assemblyName, e.Message);
                }
            }
            finally
            {
                if (!string.IsNullOrEmpty(applicationBase))
                {
                    // set the application's directory back to the original directory
                    Directory.SetCurrentDirectory(originalDirectory);
                }
            }
            return result;
        }

        // TODO: I think this should be moved to Utils..this way all versioning related
        // logic will be in one place.
        private static RegistryKey GetConfigurationProvidersRegistryKey()
        {
            try
            {
                RegistryKey monadRootKey = PSSnapInReader.GetMonadRootKey();
                RegistryKey versionRoot = PSSnapInReader.GetVersionRootKey(monadRootKey, Utils.GetCurrentMajorVersion());
                RegistryKey configProviderKey = versionRoot.OpenSubKey(configProvidersKeyName);
                return configProviderKey;
            }
            catch (ArgumentException)
            {
            }
            catch (System.Security.SecurityException)
            {
            }

            return null;
        }

        /// <summary>
        /// Read value from the property <paramref name="name"/> for registry <paramref name="registryKey"/>
        /// as string.
        /// </summary>
        /// <param name="registryKey">
        /// Registry key from which the value is read.
        /// Caller should make sure this is not null.
        /// </param>
        /// <param name="name">
        /// Name of the property.
        /// Caller should make sure this is not null.
        /// </param>
        /// <param name="mandatory">
        /// True, if the property should exist.
        /// False, otherwise.
        /// </param>
        /// <returns>
        /// Value of the property.
        /// </returns>
        /// <exception cref="ArgumentException">
        /// </exception>
        /// <exception cref="System.Security.SecurityException">
        /// </exception>
        private static string
        ReadStringValue(RegistryKey registryKey, string name, bool mandatory)
        {
            Dbg.Assert(!string.IsNullOrEmpty(name), "caller should validate the name parameter");
            Dbg.Assert(registryKey != null, "Caller should validate the registryKey parameter");

            object value = registryKey.GetValue(name);
            if (value == null && mandatory == true)
            {
                s_tracer.TraceError("Mandatory property {0} not specified for registry key {1}",
                        name, registryKey.Name);
                throw PSTraceSource.NewArgumentException("name", RemotingErrorIdStrings.MandatoryValueNotPresent, name, registryKey.Name);
            }

            string s = value as string;
            if (string.IsNullOrEmpty(s) && mandatory == true)
            {
                s_tracer.TraceError("Value is null or empty for mandatory property {0} in {1}",
                        name, registryKey.Name);
                throw PSTraceSource.NewArgumentException("name", RemotingErrorIdStrings.MandatoryValueNotInCorrectFormat, name, registryKey.Name);
            }

            return s;
        }

        private const string configProvidersKeyName = "PSConfigurationProviders";
        private const string configProviderApplicationBaseKeyName = "ApplicationBase";
        private const string configProviderAssemblyNameKeyName = "AssemblyName";
        private static Dictionary<string, ConfigurationDataFromXML> s_ssnStateProviders =
            new Dictionary<string, ConfigurationDataFromXML>(StringComparer.OrdinalIgnoreCase);
        private static object s_syncObject = new object();

        #endregion
    }

    /// <summary>
    /// Provides Default InitialSessionState.
    /// </summary>
    internal sealed class DefaultRemotePowerShellConfiguration : PSSessionConfiguration
    {
        /// <summary>
        /// 
        /// </summary>
        /// <param name="senderInfo"></param>
        /// <returns></returns>
        public override InitialSessionState GetInitialSessionState(PSSenderInfo senderInfo)
        {
            InitialSessionState result = InitialSessionState.CreateDefault2();
            // TODO: Remove this after RDS moved to $using
            if (senderInfo.ConnectionString != null && senderInfo.ConnectionString.Contains("MSP=7a83d074-bb86-4e52-aa3e-6cc73cc066c8")) { PSSessionConfigurationData.IsServerManager = true; }

            return result;
        }

        public override InitialSessionState GetInitialSessionState(PSSessionConfigurationData sessionConfigurationData, PSSenderInfo senderInfo, string configProviderId)
        {
            if (sessionConfigurationData == null)
                throw new ArgumentNullException("sessionConfigurationData");

            if (senderInfo == null)
                throw new ArgumentNullException("senderInfo");

            if (configProviderId == null)
                throw new ArgumentNullException("configProviderId");

            InitialSessionState sessionState = InitialSessionState.CreateDefault2();
            // now get all the modules in the specified path and import the same
            if (sessionConfigurationData != null && sessionConfigurationData.ModulesToImportInternal != null)
            {
                foreach (var module in sessionConfigurationData.ModulesToImportInternal)
                {
                    var moduleName = module as string;
                    if (moduleName != null)
                    {
                        moduleName = Environment.ExpandEnvironmentVariables(moduleName);

                        sessionState.ImportPSModule(new[] { moduleName });
                    }
                    else
                    {
                        var moduleSpec = module as ModuleSpecification;
                        if (moduleSpec != null)
                        {
                            var modulesToImport = new Collection<ModuleSpecification> { moduleSpec };
                            sessionState.ImportPSModule(modulesToImport);
                        }
                    }
                }
            }

            // TODO: Remove this after RDS moved to $using
            if (senderInfo.ConnectionString != null && senderInfo.ConnectionString.Contains("MSP=7a83d074-bb86-4e52-aa3e-6cc73cc066c8")) { PSSessionConfigurationData.IsServerManager = true; }

            return sessionState;
        }
    }

    #region Declarative Initial Session Configuration

    /// <summary>
    /// Specifies type of initial session state to use. Valid values are Empty and Default.
    /// </summary>
    public enum SessionType
    {
        /// <summary>
        /// Empty session state
        /// </summary>
        Empty,

        /// <summary>
        /// Restricted remote server
        /// </summary>
        RestrictedRemoteServer,

        /// <summary>
        /// Default session state
        /// </summary>
        Default
    }

    /// <summary>
    /// Configuration type entry
    /// </summary>
    internal class ConfigTypeEntry
    {
        internal delegate bool TypeValidationCallback(string key, object obj, PSCmdlet cmdlet, string path);

        internal string Key;
        internal TypeValidationCallback ValidationCallback;

        /// <summary>
        /// 
        /// </summary>
        /// <param name="key"></param>
        /// <param name="callback"></param>
        internal ConfigTypeEntry(string key, TypeValidationCallback callback)
        {
            this.Key = key;
            this.ValidationCallback = callback;
        }
    }

    /// <summary>
    /// Configuration file constants
    /// </summary>
    internal static class ConfigFileConstants
    {
        internal static readonly string AliasDefinitions = "AliasDefinitions";
        internal static readonly string AliasDescriptionToken = "Description";
        internal static readonly string AliasNameToken = "Name";
        internal static readonly string AliasOptionsToken = "Options";
        internal static readonly string AliasValueToken = "Value";
        internal static readonly string AssembliesToLoad = "AssembliesToLoad";
        internal static readonly string Author = "Author";
        internal static readonly string CompanyName = "CompanyName";
        internal static readonly string Copyright = "Copyright";
        internal static readonly string Description = "Description";
        internal static readonly string EnforceInputParameterValidation = "EnforceInputParameterValidation";
        internal static readonly string EnvironmentVariables = "EnvironmentVariables";
        internal static readonly string ExecutionPolicy = "ExecutionPolicy";
        internal static readonly string FormatsToProcess = "FormatsToProcess";
        internal static readonly string FunctionDefinitions = "FunctionDefinitions";
        internal static readonly string FunctionNameToken = "Name";
        internal static readonly string FunctionOptionsToken = "Options";
        internal static readonly string FunctionValueToken = "ScriptBlock";
        internal static readonly string GMSAAccount = "GroupManagedServiceAccount";
        internal static readonly string Guid = "GUID";
        internal static readonly string LanguageMode = "LanguageMode";
        internal static readonly string ModulesToImport = "ModulesToImport";
        internal static readonly string MountUserDrive = "MountUserDrive";
        internal static readonly string PowerShellVersion = "PowerShellVersion";
        internal static readonly string RequiredGroups = "RequiredGroups";
        internal static readonly string RoleDefinitions = "RoleDefinitions";
        internal static readonly string SchemaVersion = "SchemaVersion";
        internal static readonly string ScriptsToProcess = "ScriptsToProcess";
        internal static readonly string SessionType = "SessionType";
        internal static readonly string RoleCapabilities = "RoleCapabilities";
        internal static readonly string RunAsVirtualAccount = "RunAsVirtualAccount";
        internal static readonly string RunAsVirtualAccountGroups = "RunAsVirtualAccountGroups";
        internal static readonly string TranscriptDirectory = "TranscriptDirectory";
        internal static readonly string TypesToProcess = "TypesToProcess";
        internal static readonly string UserDriveMaxSize = "UserDriveMaximumSize";
        internal static readonly string VariableDefinitions = "VariableDefinitions";
        internal static readonly string VariableNameToken = "Name";
        internal static readonly string VariableValueToken = "Value";
        internal static readonly string VisibleAliases = "VisibleAliases";
        internal static readonly string VisibleCmdlets = "VisibleCmdlets";
        internal static readonly string VisibleFunctions = "VisibleFunctions";
        internal static readonly string VisibleProviders = "VisibleProviders";
        internal static readonly string VisibleExternalCommands = "VisibleExternalCommands";

        internal static ConfigTypeEntry[] ConfigFileKeys = new ConfigTypeEntry[] {
            new ConfigTypeEntry(AliasDefinitions,               new ConfigTypeEntry.TypeValidationCallback(AliasDefinitionsTypeValidationCallback)),
            new ConfigTypeEntry(AssembliesToLoad,               new ConfigTypeEntry.TypeValidationCallback(StringArrayTypeValidationCallback)),
            new ConfigTypeEntry(Author,                         new ConfigTypeEntry.TypeValidationCallback(StringTypeValidationCallback)),
            new ConfigTypeEntry(CompanyName,                    new ConfigTypeEntry.TypeValidationCallback(StringTypeValidationCallback)),
            new ConfigTypeEntry(Copyright,                      new ConfigTypeEntry.TypeValidationCallback(StringTypeValidationCallback)),
            new ConfigTypeEntry(Description,                    new ConfigTypeEntry.TypeValidationCallback(StringTypeValidationCallback)),
            new ConfigTypeEntry(EnforceInputParameterValidation,new ConfigTypeEntry.TypeValidationCallback(BooleanTypeValidationCallback)),
            new ConfigTypeEntry(EnvironmentVariables,           new ConfigTypeEntry.TypeValidationCallback(HashtableTypeValiationCallback)),
            new ConfigTypeEntry(ExecutionPolicy,                new ConfigTypeEntry.TypeValidationCallback(ExecutionPolicyValidationCallback)),
            new ConfigTypeEntry(FormatsToProcess,               new ConfigTypeEntry.TypeValidationCallback(StringArrayTypeValidationCallback)),
            new ConfigTypeEntry(FunctionDefinitions,            new ConfigTypeEntry.TypeValidationCallback(FunctionDefinitionsTypeValidationCallback)),
            new ConfigTypeEntry(GMSAAccount,                    new ConfigTypeEntry.TypeValidationCallback(StringTypeValidationCallback)),
            new ConfigTypeEntry(Guid,                           new ConfigTypeEntry.TypeValidationCallback(StringTypeValidationCallback)),
            new ConfigTypeEntry(LanguageMode,                   new ConfigTypeEntry.TypeValidationCallback(LanugageModeValidationCallback)),
            new ConfigTypeEntry(ModulesToImport,                new ConfigTypeEntry.TypeValidationCallback(StringOrHashtableArrayTypeValidationCallback)),
            new ConfigTypeEntry(MountUserDrive,                 new ConfigTypeEntry.TypeValidationCallback(BooleanTypeValidationCallback)),
            new ConfigTypeEntry(PowerShellVersion,              new ConfigTypeEntry.TypeValidationCallback(StringTypeValidationCallback)),
            new ConfigTypeEntry(RequiredGroups,                 new ConfigTypeEntry.TypeValidationCallback(HashtableTypeValiationCallback)),
            new ConfigTypeEntry(RoleCapabilities,               new ConfigTypeEntry.TypeValidationCallback(StringArrayTypeValidationCallback)),
            new ConfigTypeEntry(RoleDefinitions,                new ConfigTypeEntry.TypeValidationCallback(HashtableTypeValiationCallback)),
            new ConfigTypeEntry(RunAsVirtualAccount,            new ConfigTypeEntry.TypeValidationCallback(BooleanTypeValidationCallback)),
            new ConfigTypeEntry(RunAsVirtualAccountGroups,      new ConfigTypeEntry.TypeValidationCallback(StringArrayTypeValidationCallback)),
            new ConfigTypeEntry(SchemaVersion,                  new ConfigTypeEntry.TypeValidationCallback(StringTypeValidationCallback)),
            new ConfigTypeEntry(ScriptsToProcess,               new ConfigTypeEntry.TypeValidationCallback(StringArrayTypeValidationCallback)),
            new ConfigTypeEntry(SessionType,                    new ConfigTypeEntry.TypeValidationCallback(ISSValidationCallback)),
            new ConfigTypeEntry(TranscriptDirectory,            new ConfigTypeEntry.TypeValidationCallback(StringTypeValidationCallback)),
            new ConfigTypeEntry(TypesToProcess,                 new ConfigTypeEntry.TypeValidationCallback(StringArrayTypeValidationCallback)),
            new ConfigTypeEntry(UserDriveMaxSize,               new ConfigTypeEntry.TypeValidationCallback(IntegerTypeValidationCallback)),
            new ConfigTypeEntry(VariableDefinitions,            new ConfigTypeEntry.TypeValidationCallback(VariableDefinitionsTypeValidationCallback)),
            new ConfigTypeEntry(VisibleAliases,                 new ConfigTypeEntry.TypeValidationCallback(StringArrayTypeValidationCallback)),
            new ConfigTypeEntry(VisibleCmdlets,                 new ConfigTypeEntry.TypeValidationCallback(StringArrayTypeValidationCallback)),
            new ConfigTypeEntry(VisibleFunctions,               new ConfigTypeEntry.TypeValidationCallback(StringArrayTypeValidationCallback)),
            new ConfigTypeEntry(VisibleProviders,               new ConfigTypeEntry.TypeValidationCallback(StringArrayTypeValidationCallback)),
            new ConfigTypeEntry(VisibleExternalCommands,        new ConfigTypeEntry.TypeValidationCallback(StringArrayTypeValidationCallback)),
        };