Environment.cs source code in C# .NET

                        
Code:
                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / clr / src / BCL / System / Environment.cs / 1305376 / Environment.cs
                        

                        
                            // ==++== 
//
//   Copyright (c) Microsoft Corporation.  All rights reserved.
//
// ==--== 
/*============================================================
** 
** Class: Environment 
**
** 
** Purpose: Provides some basic access to some environment
** functionality.
**
** 
============================================================*/
namespace System { 
    using System.IO; 
    using System.Security;
    using System.Resources; 
    using System.Globalization;
    using System.Collections;
    using System.Security.Permissions;
    using System.Text; 
    using System.Configuration.Assemblies;
    using System.Runtime.InteropServices; 
    using System.Reflection; 
    using System.Diagnostics;
    using Microsoft.Win32; 
    using System.Runtime.CompilerServices;
    using System.Threading;
    using System.Runtime.ConstrainedExecution;
    using System.Runtime.Versioning; 
    using System.Diagnostics.Contracts;
 
#if !FEATURE_PAL 
    [ComVisible(true)]
    public enum EnvironmentVariableTarget { 
        Process = 0,
#if FEATURE_WIN32_REGISTRY
        User = 1,
        Machine = 2, 
#endif
    } 
#endif 

#if FEATURE_SPLIT_RESOURCES 
    // See code:#splitResourceFeature
    internal enum ResourceHelperState {
        UNITIALIZED = 0,
        HAVE_RESOURCES = 1, 
        NO_RESOURCES = 2,
    } 
#endif // FEATURE_SPLIT_RESOURCES 

    [ComVisible(true)] 
    public static class Environment {

        // Assume the following constants include the terminating '\0' - use <, not <=
        const int MaxEnvVariableValueLength = 32767;  // maximum length for environment variable name and value 
        // System environment variables are stored in the registry, and have
        // a size restriction that is separate from both normal environment 
        // variables and registry value name lengths, according to MSDN. 
        // MSDN doesn't detail whether the name is limited to 1024, or whether
        // that includes the contents of the environment variable. 
        const int MaxSystemEnvVariableLength = 1024;
        const int MaxUserEnvVariableLength = 255;

        internal sealed class ResourceHelper 
        {
            internal ResourceHelper(String name) { 
                m_name = name; 
            }
 
#if FEATURE_SPLIT_RESOURCES
            // See code:#splitResourceFeature
            internal ResourceHelper(String name, bool isDebug) : this(name)
            { 
                m_isDebug = isDebug;
                if (!isDebug) { 
                    m_state = (int)ResourceHelperState.HAVE_RESOURCES; 
                }
            } 
#endif // FEATURE_SPLIT_RESOURCES

            private String m_name;
            private ResourceManager SystemResMgr; 

            // To avoid infinite loops when calling GetResourceString.  See comments 
            // in GetResourceString for this field. 
            private Stack currentlyLoading;
 
            // process-wide state (since this is only used in one domain),
            // used to avoid the TypeInitialization infinite recusion
            // in GetResourceStringCode
            internal bool resourceManagerInited = false; 

#if FEATURE_SPLIT_RESOURCES 
 
            private bool m_isDebug;
            private int m_state = (int)ResourceHelperState.UNITIALIZED; 

            internal bool UseFallback() {
                // this always returns false for runtime resources because its state can never be NO_RESOURCES
                return m_state == (int)ResourceHelperState.NO_RESOURCES; 
            }
 
#endif // FEATURE_SPLIT_RESOURCES 

            internal class GetResourceStringUserData 
            {
                public ResourceHelper m_resourceHelper;
                public String m_key;
                public CultureInfo m_culture; 
                public String m_retVal;
                public bool m_lockWasTaken; 
 
                public GetResourceStringUserData(ResourceHelper resourceHelper, String key, CultureInfo culture)
                { 
                    m_resourceHelper = resourceHelper;
                    m_key = key;
                    m_culture = culture;
                } 
            }
 
            [System.Security.SecuritySafeCritical]  // auto-generated 
            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
            internal String GetResourceString(String key) { 
                if (key == null || key.Length == 0) {
                    Contract.Assert(false, "Environment::GetResourceString with null or empty key.  Bug in caller, or weird recursive loading problem?");
                    return "[Resource lookup failed - null or empty resource name]";
                } 
                return GetResourceString(key, null);
            } 
 
            [System.Security.SecuritySafeCritical]  // auto-generated
            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)] 
            internal String GetResourceString(String key, CultureInfo culture)  {
                if (key == null || key.Length == 0) {
                    BCLDebug.Assert(false, "Environment::GetResourceString with null or empty key.  Bug in caller, or weird recursive loading problem?");
                    return "[Resource lookup failed - null or empty resource name]"; 
                }
 
#if FEATURE_SPLIT_RESOURCES 
                if (UseFallback()) {
                    return null; 
                }
#endif // FEATURE_SPLIT_RESOURCES

                // We have a somewhat common potential for infinite 
                // loops with mscorlib's ResourceManager.  If "potentially dangerous"
                // code throws an exception, we will get into an infinite loop 
                // inside the ResourceManager and this "potentially dangerous" code. 
                // Potentially dangerous code includes the IO package, CultureInfo,
                // parts of the loader, some parts of Reflection, Security (including 
                // custom user-written permissions that may parse an XML file at
                // class load time), assembly load event handlers, etc.  Essentially,
                // this is not a bounded set of code, and we need to fix the problem.
                // Fortunately, this is limited to mscorlib's error lookups and is NOT 
                // a general problem for all user code using the ResourceManager.
 
                // The solution is to make sure only one thread at a time can call 
                // GetResourceString.  Also, since resource lookups can be
                // reentrant, if the same thread comes into GetResourceString 
                // twice looking for the exact same resource name before
                // returning, we're going into an infinite loop and we should
                // return a bogus string.
 
                GetResourceStringUserData userData = new GetResourceStringUserData(this, key, culture);
 
                RuntimeHelpers.TryCode tryCode = new RuntimeHelpers.TryCode(GetResourceStringCode); 
                RuntimeHelpers.CleanupCode cleanupCode = new RuntimeHelpers.CleanupCode(GetResourceStringBackoutCode);
 
                RuntimeHelpers.ExecuteCodeWithGuaranteedCleanup(tryCode, cleanupCode, userData);
                return userData.m_retVal;

            } 

            [System.Security.SecuritySafeCritical]  // auto-generated 
            private void GetResourceStringCode(Object userDataIn) 
            {
                GetResourceStringUserData userData = (GetResourceStringUserData) userDataIn; 
                ResourceHelper rh = userData.m_resourceHelper;
                String key = userData.m_key;
                CultureInfo culture = userData.m_culture;
 
                Monitor.Enter(rh, ref userData.m_lockWasTaken);
 
                // Are we recursively looking up the same resource? 
                if (rh.currentlyLoading != null && rh.currentlyLoading.Count > 0 && rh.currentlyLoading.Contains(key)) {
                    // This is often a bug in the BCL, security, NLS+ code, 
                    // or the loader somewhere.  However, this could also
                    // be a setup problem - check whether mscorlib &
                    // mscorwks are both of the same build flavor.
                    String stackTrace = "[Couldn't get a stack trace]"; 
                    try
                    { 
                        StackTrace st = new StackTrace(true); 
                        // Don't attempt to localize strings in this stack trace, otherwise it could cause
                        // infinite recursion. This stack trace is used for an Assert message only, and 
                        // so the lack of localization should not be an issue.
                        stackTrace = st.ToString( System.Diagnostics.StackTrace.TraceFormat.NoResourceLookup );
                    }
                    catch(StackOverflowException) {} 
                    catch(NullReferenceException) {}
                    catch(OutOfMemoryException) {} 
 
                    Contract.Assert(false, "Infinite recursion during resource lookup.  Resource name: " + key + Environment.NewLine + stackTrace);
 
                    // Note: can't append the key name, since that may require
                    // an extra allocation...
                    userData.m_retVal = "[Resource lookup failed - infinite recursion or critical failure detected.]";
                    return; 
                }
                if (rh.currentlyLoading == null) 
                    rh.currentlyLoading = new Stack(4); 

                // Call class constructors preemptively, so that we cannot get into an infinite 
                // loop constructing a TypeInitializationException.  If this were omitted,
                // we could get the Infinite recursion assert above by failing type initialization
                // between the Push and Pop calls below.
 
                if (!rh.resourceManagerInited)
                { 
                    // process-critical code here.  No ThreadAbortExceptions 
                    // can be thrown here.  Other exceptions percolate as normal.
                    RuntimeHelpers.PrepareConstrainedRegions(); 
                    try {
                    }
                    finally {
                        RuntimeHelpers.RunClassConstructor(typeof(ResourceManager).TypeHandle); 
                        RuntimeHelpers.RunClassConstructor(typeof(ResourceReader).TypeHandle);
                        RuntimeHelpers.RunClassConstructor(typeof(RuntimeResourceSet).TypeHandle); 
                        RuntimeHelpers.RunClassConstructor(typeof(BinaryReader).TypeHandle); 
                        rh.resourceManagerInited = true;
                    } 

                }

                rh.currentlyLoading.Push(key); 

#if FEATURE_SPLIT_RESOURCES 
                if (rh.SystemResMgr == null) { 
                    rh.SystemResMgr = new ResourceManager(m_name, typeof(Object).Assembly, m_isDebug);
                } 
                String s = rh.SystemResMgr.GetString(key, culture);
                rh.currentlyLoading.Pop();

                if (rh.m_isDebug) { 
                    int detectedState = (s == null) ? (int)ResourceHelperState.NO_RESOURCES : (int)ResourceHelperState.HAVE_RESOURCES;
                    // update state only if it's currently in the UNITIALIZED state 
                    int currentState = Interlocked.CompareExchange(ref m_state, detectedState, (int)ResourceHelperState.UNITIALIZED); 
                }
                else { 
                    Contract.Assert(s!=null, "Managed resource string lookup failed.  Was your resource name misspelled?  Did you rebuild mscorlib after adding a resource to resources.txt?  Debug this w/ cordbg and bug whoever owns the code that called Environment.GetResourceString.  Resource name was: \""+key+"\"");
                }

#else 
                if (rh.SystemResMgr == null) {
                    rh.SystemResMgr = new ResourceManager(m_name, typeof(Object).Assembly); 
                } 
                String s = rh.SystemResMgr.GetString(key, null);
                rh.currentlyLoading.Pop(); 

                Contract.Assert(s!=null, "Managed resource string lookup failed.  Was your resource name misspelled?  Did you rebuild mscorlib after adding a resource to resources.txt?  Debug this w/ cordbg and bug whoever owns the code that called Environment.GetResourceString.  Resource name was: \""+key+"\"");

#endif // !FEATURE_SPLIT_RESOURCES 

                userData.m_retVal = s; 
            } 

            [PrePrepareMethod] 
            private void GetResourceStringBackoutCode(Object userDataIn, bool exceptionThrown)
            {
                GetResourceStringUserData userData = (GetResourceStringUserData) userDataIn;
                ResourceHelper rh = userData.m_resourceHelper; 

                if (exceptionThrown) 
                { 
                    if (userData.m_lockWasTaken)
                    { 
                        // Backout code - throw away potentially corrupt state
                        rh.SystemResMgr = null;
                        rh.currentlyLoading = null;
                    } 
                }
                // Release the lock, if we took it. 
                if (userData.m_lockWasTaken) 
                {
                    Monitor.Exit(rh); 
                }
            }

        } 

        // #splitResourceFeature 
        // 
        // Overview:
        // FEATURE_SPLIT_RESOURCES is enabled only in coreclr builds. With this feature, resources are split into 
        // runtime (critical) and debug resources. There are <10 runtime resources, and these are handled with the
        // runtime resource helper. Debug resources will only be present in debug packs so we allow fallback in
        // case these resources aren't present. If they aren't present, we return a general resource string.
        // 
        // Impact to GetResourceString callers:
        // To minimize impact of this feature on the codebase, the typical resource helper is co-opted for debug 
        // resources and a new runtime resource helper is introduced to handle the runtime resources. To save 
        // lookup time, if FEATURE_SPLIT_RESOURCES is enabled, callers looking for runtime resources will call the
        // XRuntime overloads. (There were <10 such callers.) 
        //
        // Some exception classes need to know if fallback was used, so they can do something other than their
        // typical exception message formatting. So Environment now provides some internal overloads to allow
        // these callers to detect this. 
        //
        // Differences in resource lookup when FEATURE_SPLIT_RESOURCES is enabled: 
        // You'll need some historical information first, otherwise the changes probably won't make sense, so... 
        //
        // A bit of history: 
        // Historically (Orcas and before), mscorlib's resources were embedded in mscorlib.dll. Furthermore,
        // its resources were loaded in the default appdomain. This latter characteristic is yet another way in
        // which mscorlib is distinct from other framework assemblies. This is achieved by the fcall
        // GetResourceFromDefault, which transitions into the default appdomain and then calls Environment's 
        // GetResourceStringLocal.
        // 
        // The changes -- deployment: 
        // The <10 runtime resources are still embedded in mscorlib, but all others are pulled out into a
        // satellite assembly. To reserve the right to have all mscorlib's resources in a satellite assembly in 
        // thefuture (and given that these are optional), this optional satellite assembly is called
        // mscorlib.debug.resources.dll. To achieve this, we added some special casing in the VM to accept this
        // new name as an mscorlib satellite assembly. When attempting to load this satellite assembly,
        // localization is performed in the normal way: if mscorlib.dll, etc are stored in , then you 
        // can place the satellite assembly under \en-US, or \ in general
        // and we'll grab the assembly for the current culture. The ResourceManager does the usual fallback magic 
        // in case the current culture's resources aren't present. 
        //
        // The changes -- lookup: 
        // Resources are still loaded in the default appdomain so we added extra magic below to do the transitions
        // for runtime and optional resource messages. If the optional resource set isn't found on first lookup,
        // we flag that and return the default fallback message (which is a runtime resource string). We avoid
        // this work subsequently via the new field ResourceHelper.m_useFallbackMessage. 
#if FEATURE_SPLIT_RESOURCES
        private static ResourceHelper m_runtimeResHelper;  // Doesn't need to be initialized as they're zero-init. 
#endif // FEATURE_SPLIT_RESOURCES 
        private static ResourceHelper m_resHelper;  // Doesn't need to be initialized as they're zero-init.
 
        private static bool s_IsWindowsVista;
        private static bool s_CheckedOSType;

        private static bool s_IsW2k3; 
        private static volatile bool s_CheckedOSW2k3;
 
        private const  int    MaxMachineNameLength = 256; 

        // Private object for locking instead of locking on a public type for SQL reliability work. 
        private static Object s_InternalSyncObject;
        private static Object InternalSyncObject {
            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
            get { 
                if (s_InternalSyncObject == null) {
                    Object o = new Object(); 
                    Interlocked.CompareExchange