CorePsStub.cs

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

using System;
using System.Globalization;
using System.Reflection;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using Microsoft.Win32;
using System.Management.Automation.Remoting;

#pragma warning disable 1591, 1572, 1571, 1573, 1587, 1570, 0067

#region CLR_STUBS

// This namespace contains stubs for some .NET types that are not in CoreCLR, such as ISerializable and SerializableAttribute.
// We use the stubs in this namespace to reduce #if/def in the code as much as possible.
namespace Microsoft.PowerShell.CoreClr.Stubs
{
    using System.Runtime.InteropServices;
    // We create some stub attribute types to make some attribute markers work in CoreCLR.
    // The purpose of this is to avoid #if/def in powershell code as much as possible.

    #region Attribute_Related

    /// <summary>
    /// Stub for SpecialNameAttribute
    /// </summary>
    public sealed class SpecialNameAttribute : Attribute
    {
        /// <summary>
        /// 
        /// </summary>
        public SpecialNameAttribute() { }
    }

    /// <summary>
    /// Stub for SerializableAttribute
    /// </summary>
    public sealed class SerializableAttribute : Attribute
    {
        /// <summary>
        /// 
        /// </summary>
        public SerializableAttribute() { }
    }

    /// <summary>
    /// Stub for NonSerializedAttribute
    /// </summary>
    public sealed class NonSerializedAttribute : Attribute
    {
        /// <summary>
        /// 
        /// </summary>
        public NonSerializedAttribute() { }
    }

    /// <summary>
    /// Stub for SecurityAction
    /// </summary>
    public enum SecurityAction
    {
        Assert = 3,
        Demand = 2,
        InheritanceDemand = 7,
        LinkDemand = 6,
        PermitOnly = 5
    }

    /// <summary>
    /// Stub for SecurityPermissionAttribute
    /// </summary>
    public sealed class SecurityPermissionAttribute : Attribute
    {
        public SecurityPermissionAttribute(SecurityAction action) { }
        public bool SerializationFormatter { get; set; }

        public bool UnmanagedCode { get; set; }
    }

    /// <summary>
    /// Stub for TypeLibTypeAttribute
    /// </summary>
    public sealed class TypeLibTypeAttribute : Attribute
    {
        /// <summary>
        /// 
        /// </summary>
        /// <param name="flags"></param>
        public TypeLibTypeAttribute(short flags) { }
    }

    /// <summary>
    /// Stub for SuppressUnmanagedCodeSecurityAttribute
    /// </summary>
    public class SuppressUnmanagedCodeSecurityAttribute : Attribute
    { }

    /// <summary>
    /// Stub for HostProtectionAttribute
    /// </summary>
    public sealed class HostProtectionAttribute : Attribute
    {
        public HostProtectionAttribute(SecurityAction action) { }
        public bool MayLeakOnAbort { get; set; }
    }

    /// <summary>
    /// Stub for ResourceExposureAttribute
    /// </summary>
    public sealed class ResourceExposureAttribute : Attribute
    {
        private ResourceScope _resourceExposureLevel;

        public ResourceExposureAttribute(ResourceScope exposureLevel)
        {
            _resourceExposureLevel = exposureLevel;
        }

        public ResourceScope ResourceExposureLevel
        {
            get { return _resourceExposureLevel; }
        }
    }

    /// <summary>
    /// Stub for ResourceScope
    /// </summary>
    public enum ResourceScope
    {
        None = 0,
        // Resource type
        Machine = 0x1,
        Process = 0x2,
        AppDomain = 0x4,
        Library = 0x8,
        // Visibility
        Private = 0x10,  // Private to this one class.
        Assembly = 0x20,  // Assembly-level, like C#'s "internal"
    }

    /// <summary>
    /// Stub for ReliabilityContractAttribute
    /// </summary>
    public sealed class ReliabilityContractAttribute : Attribute
    {
        /// <summary>
        /// 
        /// </summary>
        public ReliabilityContractAttribute(Consistency consistencyGuarantee, Cer cer)
        {
        }
    }

    /// <summary>
    /// Stub for Cer
    /// </summary>
    public enum Cer
    {
        /// <summary>
        /// None
        /// </summary>
        None,

        /// <summary>
        /// MayFail
        /// </summary>
        MayFail,

        /// <summary>
        /// Success
        /// </summary>
        Success
    }

    /// <summary>
    /// Stub for Consistency
    /// </summary>
    public enum Consistency
    {
        /// <summary>
        /// MayCorruptProcess
        /// </summary>
        MayCorruptProcess,

        /// <summary>
        /// MayCorruptAppDomain
        /// </summary>
        MayCorruptAppDomain,

        /// <summary>
        /// MayCorruptInstance
        /// </summary>
        MayCorruptInstance,

        /// <summary>
        /// WillNotCorruptState
        /// </summary>
        WillNotCorruptState
    }

    #endregion Attribute_Related

    #region Serialization_Related

    /// <summary>
    /// Stub for SerializationInfo
    /// </summary>
    public sealed class SerializationInfo
    {
        /// <summary>
        /// 
        /// </summary>
        public SerializationInfo() { }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="name"></param>
        /// <param name="value"></param>
        public void AddValue(string name, object value)
        {
            throw new NotImplementedException("AddValue(string name, object value)");
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="name"></param>
        /// <param name="value"></param>
        public void AddValue(string name, bool value)
        {
            throw new NotImplementedException("AddValue(string name, bool value)");
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="name"></param>
        /// <param name="value"></param>
        /// <param name="type"></param>
        public void AddValue(string name, Object value, Type type)
        {
            throw new NotImplementedException("AddValue(string name, Object value,    Type type)");
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="name"></param>
        /// <param name="value"></param>
        public void AddValue(string name, int value)
        {
            throw new NotImplementedException("AddValue(string name, int value)");
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="name"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        public object GetValue(string name, Type type)
        {
            throw new NotImplementedException("GetValue(string name, Type type)");
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public string GetString(string name)
        {
            throw new NotImplementedException("GetString(string name)");
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public bool GetBoolean(string name)
        {
            throw new NotImplementedException("GetBoolean(string name)");
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public int GetInt32(string name)
        {
            throw new NotImplementedException("GetInt32(string name)");
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="type"></param>
        public void SetType(System.Type type)
        {
            throw new NotImplementedException("SetType(System.Type type)");
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public long GetInt64(string name)
        {
            throw new NotImplementedException("GetInt64(string name)");
        }
    }

    #endregion Serialization_Related

    #region Interface_Related

    /// <summary>
    /// Stub for ISerializable
    /// </summary>
    public interface ISerializable
    {
        /// <summary>
        /// 
        /// </summary>
        /// <param name="info"></param>
        /// <param name="context"></param>
        void GetObjectData(SerializationInfo info, System.Runtime.Serialization.StreamingContext context);
    }

    /// <summary>
    /// Stub for ICloneable
    /// </summary>
    public interface ICloneable
    {
        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        object Clone();
    }

    /// <summary>
    /// Stub for IObjectReference
    /// </summary>
    public interface IObjectReference
    {
        /// <summary>
        /// 
        /// </summary>
        /// <param name="context"></param>
        /// <returns></returns>
        Object GetRealObject(System.Runtime.Serialization.StreamingContext context);
    }

    /// <summary>
    /// Stub for IRuntimeVariables
    /// </summary>
    public interface IRuntimeVariables
    {
        /// <summary>
        /// 
        /// </summary>
        int Count { get; }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        object this[int index] { get; set; }
    }

    #endregion Interface_Related

    #region Exception_Related

    /// <summary>
    /// Stub for SystemException
    /// </summary>
    public class SystemException : Exception
    {
        /// <summary>
        /// SystemException constructor
        /// </summary>
        public SystemException() : base() { }

        /// <summary>
        /// SystemException constructor
        /// </summary>
        /// <param name="message"></param>
        public SystemException(string message) : base(message) { }

        /// <summary>
        /// SystemException constructor
        /// </summary>
        /// <param name="message"></param>
        /// <param name="innerException"></param>
        public SystemException(string message, Exception innerException) : base(message, innerException) { }

        /// <summary>
        /// SystemException constructor
        /// </summary>
        /// <param name="info"></param>
        /// <param name="context"></param>
        protected SystemException(SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }

        /// <summary>
        /// SystemException constructor
        /// </summary>
        /// <param name="info"></param>
        /// <param name="context"></param>
        public virtual void GetObjectData(SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
    }

    /// <summary>
    /// Stub for AccessViolationException
    /// </summary>
    public class AccessViolationException : Exception
    {
        /// <summary>
        /// AccessViolationException constructor
        /// </summary>
        public AccessViolationException() : base() { }

        /// <summary>
        /// AccessViolationException constructor
        /// </summary>
        /// <param name="message"></param>
        public AccessViolationException(string message) : base(message) { }

        /// <summary>
        /// AccessViolationException constructor
        /// </summary>
        /// <param name="message"></param>
        /// <param name="innerException"></param>
        public AccessViolationException(string message, Exception innerException) : base(message, innerException) { }

        /// <summary>
        /// AccessViolationException constructor
        /// </summary>
        /// <param name="info"></param>
        /// <param name="context"></param>
        protected AccessViolationException(SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }

        /// <summary>
        /// AccessViolationException constructor
        /// </summary>
        /// <param name="info"></param>
        /// <param name="context"></param>
        public virtual void GetObjectData(SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { }
    }

    /// <summary>
    /// Stub for ThreadAbortException
    /// </summary>
    public sealed class ThreadAbortException : Exception
    {
    }

    /// <summary>
    /// Stub for AppDomainUnloadedException
    /// </summary>
    public sealed class AppDomainUnloadedException : Exception
    {
    }

    #endregion Exception_Related

    #region SafeHandle_Related

    /// <summary>
    /// Stub for SafeHandleZeroOrMinusOneIsInvalid
    /// </summary>
    public abstract class SafeHandleZeroOrMinusOneIsInvalid : SafeHandle
    {
        /// <summary>
        /// Constructor
        /// </summary>
        protected SafeHandleZeroOrMinusOneIsInvalid(bool ownsHandle)
            : base(IntPtr.Zero, ownsHandle)
        {
        }

        /// <summary>
        /// IsInvalid
        /// </summary>
        public override bool IsInvalid
        {
            get
            {
                return handle == IntPtr.Zero || handle == new IntPtr(-1);
            }
        }
    }

    /// <summary>
    /// Stub for SafeHandleMinusOneIsInvalid
    /// </summary>
    public abstract class SafeHandleMinusOneIsInvalid : SafeHandle
    {
        /// <summary>
        /// Constructor
        /// </summary>
        protected SafeHandleMinusOneIsInvalid(bool ownsHandle) 
            : base(new IntPtr(-1), ownsHandle)
        {
        }

        /// <summary>
        /// IsInvalid
        /// </summary>
        public override bool IsInvalid
        {
            get
            {
                return handle == new IntPtr(-1);
            }
        }
    }

    #endregion SafeHandle_Related

    #region Misc_Types

    /// <summary>
    /// Stub for SecurityZone
    /// </summary>
    public enum SecurityZone
    {
        MyComputer = 0,
        Intranet = 1,
        Trusted = 2,
        Internet = 3,
        Untrusted = 4,

        NoZone = -1,
    }

    /// <summary>
    /// Stub for MailAddress
    /// </summary>
    public class MailAddress
    {
        public MailAddress(string address) { }
    }

    #endregion Misc_Types

    #region SystemManagementStubs

    // Summary:
    //     Describes the authentication level to be used to connect to WMI. This is
    //     used for the COM connection to WMI.
    public enum AuthenticationLevel
    {
        // Summary:
        //     Authentication level should remain as it was before.
        Unchanged = -1,
        //
        // Summary:
        //     The default COM authentication level. WMI uses the default Windows Authentication
        //     setting.
        Default = 0,
        //
        // Summary:
        //     No COM authentication.
        None = 1,
        //
        // Summary:
        //     Connect-level COM authentication.
        Connect = 2,
        //
        // Summary:
        //     Call-level COM authentication.
        Call = 3,
        //
        // Summary:
        //     Packet-level COM authentication.
        Packet = 4,
        //
        // Summary:
        //     Packet Integrity-level COM authentication.
        PacketIntegrity = 5,
        //
        // Summary:
        //     Packet Privacy-level COM authentication.
        PacketPrivacy = 6,
    }

    // Summary:
    //     Describes the impersonation level to be used to connect to WMI.
    public enum ImpersonationLevel
    {
        // Summary:
        //     Default impersonation.
        Default = 0,
        //
        // Summary:
        //     Anonymous COM impersonation level that hides the identity of the caller.
        //     Calls to WMI may fail with this impersonation level.
        Anonymous = 1,
        //
        // Summary:
        //     Identify-level COM impersonation level that allows objects to query the credentials
        //     of the caller. Calls to WMI may fail with this impersonation level.
        Identify = 2,
        //
        // Summary:
        //     Impersonate-level COM impersonation level that allows objects to use the
        //     credentials of the caller. This is the recommended impersonation level for
        //     WMI calls.
        Impersonate = 3,
        //
        // Summary:
        //     Delegate-level COM impersonation level that allows objects to permit other
        //     objects to use the credentials of the caller. This level, which will work
        //     with WMI calls but may constitute an unnecessary security risk, is supported
        //     only under Windows 2000.
        Delegate = 4,
    }

    #endregion
}


//TODO:CORECLR Put Stubs to System.Management.Core.dll
namespace System
{
    /// <summary>
    /// TODO:CORECLR Inspection of the binary module needs to be re-write without using AppDomain
    /// </summary>
    internal sealed class AppDomain
    {
        /// <summary>
        /// 
        /// </summary>
        public static System.AppDomain CreateDomain(string friendlyName)
        {
            return null;
        }

        /// <summary>
        /// 
        /// </summary>
        public static void Unload(System.AppDomain domain)
        {
        }
    }
}

namespace System.Net
{
    internal class WebClient //: Component 
    {
        public WebClient() { }

        public void Dispose() { }

        public bool UseDefaultCredentials { get; set; }
    }
}

namespace System.Security
{
    using System.Text;

    /// <summary>
    /// 
    /// </summary>  
    sealed public class SecurityElement
    {
        private static readonly string[] s_escapeStringPairs = new string[]
            {
                // these must be all once character escape sequences or a new escaping algorithm is needed
                "<", "&lt;",
                ">", "&gt;",
                "\"", "&quot;",
                "\'", "&apos;",
                "&", "&amp;"
            };
        private static readonly char[] s_escapeChars = new char[] { '<', '>', '\"', '\'', '&' };

        /// <summary>
        /// Replaces invalid XML characters in a string with their valid XML equivalent.
        /// </summary>  
        public static string Escape(string str)
        {
            if (str == null)
                return null;

            StringBuilder sb = null;

            int strLen = str.Length;
            int index; // Pointer into the string that indicates the location of the current '&' character
            int newIndex = 0; // Pointer into the string that indicates the start index of the "remaining" string (that still needs to be processed).

            do
            {
                index = str.IndexOfAny(s_escapeChars, newIndex);

                if (index == -1)
                {
                    if (sb == null)
                        return str;
                    else
                    {
                        sb.Append(str, newIndex, strLen - newIndex);
                        return sb.ToString();
                    }
                }
                else
                {
                    if (sb == null)
                        sb = new StringBuilder();

                    sb.Append(str, newIndex, index - newIndex);
                    sb.Append(GetEscapeSequence(str[index]));

                    newIndex = (index + 1);
                }
            }
            while (true);
        }

        private static string GetEscapeSequence(char c)
        {
            int iMax = s_escapeStringPairs.Length;

            for (int i = 0; i < iMax; i += 2)
            {
                String strEscSeq = s_escapeStringPairs[i];
                String strEscValue = s_escapeStringPairs[i + 1];

                if (strEscSeq[0] == c)
                    return strEscValue;
            }

            Diagnostics.Debug.Assert(false, "Unable to find escape sequence for this character");
            return c.ToString();
        }
    }
}

#endregion CLR_STUBS

#region PS_STUBS
// Include PS types that are not needed for PowerShell on CSS

namespace System.Management.Automation
{
    #region PSTransaction

    /// <summary>
    /// We don't need PSTransaction related types on CSS because System.Transactions 
    /// namespace is not available in CoreCLR
    /// </summary>
    public sealed class PSTransactionContext : IDisposable
    {
        internal PSTransactionContext(Internal.PSTransactionManager transactionManager) { }
        public void Dispose() { }
    }

    /// <summary>
    /// The severity of error that causes PowerShell to automatically
    /// rollback the transaction.
    /// </summary>
    public enum RollbackSeverity
    {
        /// <summary>
        /// Non-terminating errors or worse
        /// </summary>
        Error,

        /// <summary>
        /// Terminating errors or worse
        /// </summary>
        TerminatingError,

        /// <summary>
        /// Do not rollback the transaction on error
        /// </summary>
        Never
    }

    #endregion PSTransaction

    #region CMS

    internal static class CmsUtils
    {
        internal static string BEGIN_CERTIFICATE_SIGIL = "-----BEGIN CERTIFICATE-----";
        internal static string END_CERTIFICATE_SIGIL = "-----END CERTIFICATE-----";

        internal static string Encrypt(byte[] contentBytes, CmsMessageRecipient[] recipients, SessionState sessionState, out ErrorRecord error)
        {
            throw new NotImplementedException("CmsUtils.Encrypt(...) is not implemented in CoreCLR powershell.");
        }

        internal static string GetAsciiArmor(byte[] bytes)
        {
            throw new NotImplementedException("CmsUtils.GetAsciiArmor(...) is not implemented in CoreCLR powershell.");
        }

        internal static byte[] RemoveAsciiArmor(string actualContent, string beginMarker, string endMarker, out int startIndex, out int endIndex)
        {
            throw new NotImplementedException("CmsUtils.RemoveAsciiArmor(...) is not implemented in CoreCLR powershell.");
        }
    }

    #endregion CMS

    #region ApartmentState

    internal enum ApartmentState
    {
        //
        // Summary:
        //     The System.Threading.Thread will create and enter a single-threaded apartment.
        STA = 0,
        //
        // Summary:
        //     The System.Threading.Thread will create and enter a multithreaded apartment.
        MTA = 1,
        //
        // Summary:
        //     The System.Threading.Thread.ApartmentState property has not been set.
        Unknown = 2
    }

    #endregion ApartmentState
}

namespace System.Management.Automation.Internal
{
    /// <summary>
    /// We don't need PSTransaction related types on CSS because System.Transactions 
    /// namespace is not available in CoreCLR
    /// </summary>
    internal sealed class PSTransactionManager : IDisposable
    {
        /// <summary>
        /// Determines if you have a transaction that you can set active and work on.
        /// </summary>
        /// <remarks>
        /// Always return false in CoreCLR
        /// </remarks>
        internal bool HasTransaction
        {
            get
            {
                return false;
            }
        }

        /// <summary>
        /// Determines if the last transaction has been committed.
        /// </summary>
        internal bool IsLastTransactionCommitted
        {
            get
            {
                throw new NotImplementedException("IsLastTransactionCommitted");
            }
        }

        /// <summary>
        /// Determines if the last transaction has been rolled back.
        /// </summary>
        internal bool IsLastTransactionRolledBack
        {
            get
            {
                throw new NotImplementedException("IsLastTransactionRolledBack");
            }
        }

        /// <summary>
        /// Gets the rollback preference for the active transaction
        /// </summary>
        internal RollbackSeverity RollbackPreference
        {
            get
            {
                throw new NotImplementedException("RollbackPreference");
            }
        }

        /// <summary>
        /// Called by engine APIs to ensure they are protected from
        /// ambient transactions.
        /// </summary>
        /// <remarks>
        /// Always return null in CoreCLR
        /// </remarks>
        internal static IDisposable GetEngineProtectionScope()
        {
            return null;
        }

        /// <summary>
        /// Aborts the current transaction, no matter how many subscribers are part of it.
        /// </summary>
        internal void Rollback(bool suppressErrors)
        {
            throw new NotImplementedException("Rollback");
        }

        public void Dispose() { }
    }
}

namespace System.Management.Automation.ComInterop
{
    using System.Dynamic;
    using System.Diagnostics;
    using System.Runtime.InteropServices;

    /// <summary>
    /// Provides helper methods to bind COM objects dynamically.
    /// </summary>
    /// <remarks>
    /// COM is not supported in core powershell. So this is a stub type.
    /// </remarks>
    internal static class ComBinder
    {
        /// <summary>
        /// Tries to perform binding of the dynamic get index operation.
        /// </summary>
        /// <remarks>
        /// Always return false in CoreCLR.
        /// </remarks>
        public static bool TryBindGetIndex(GetIndexBinder binder, DynamicMetaObject instance, DynamicMetaObject[] args, out DynamicMetaObject result)
        {
            result = null;
            return false;
        }

        /// <summary>
        /// Tries to perform binding of the dynamic set index operation.
        /// </summary>
        /// <remarks>
        /// Always return false in CoreCLR.
        /// </remarks>
        public static bool TryBindSetIndex(SetIndexBinder binder, DynamicMetaObject instance, DynamicMetaObject[] args, DynamicMetaObject value, out DynamicMetaObject result)
        {
            result = null;
            return false;
        }

        /// <summary>
        /// Tries to perform binding of the dynamic get member operation.
        /// </summary>
        /// <remarks>
        /// Always return false in CoreCLR.
        /// </remarks>
        public static bool TryBindGetMember(GetMemberBinder binder, DynamicMetaObject instance, out DynamicMetaObject result)
        {
            result = null;
            return false;
        }

        /// <summary>
        /// Tries to perform binding of the dynamic set member operation.
        /// </summary>
        /// <remarks>
        /// Always return false in CoreCLR.
        /// </remarks>
        public static bool TryBindSetMember(SetMemberBinder binder, DynamicMetaObject instance, DynamicMetaObject value, out DynamicMetaObject result)
        {
            result = null;
            return false;
        }

        /// <summary>
        /// Tries to perform binding of the dynamic invoke member operation.
        /// </summary>
        /// <remarks>
        /// Always return false in CoreCLR.
        /// </remarks>
        public static bool TryBindInvokeMember(InvokeMemberBinder binder, bool isSetProperty, DynamicMetaObject instance, DynamicMetaObject[] args, out DynamicMetaObject result)
        {
            result = null;
            return false;
        }
    }

#pragma warning disable 618 // Disable obsolete warning about VarEnum in CoreCLR
    internal class VarEnumSelector
    {
        private static readonly Dictionary<VarEnum, Type> _ComToManagedPrimitiveTypes = CreateComToManagedPrimitiveTypes();