2016-08-03 10:59:49 +00:00
// ==++==
//
// 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
[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 ;
}
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 ;
// Is this thread currently doing infinite resource lookups?
private int infinitelyRecursingCount ;
// Data representing one individual resource lookup on a thread.
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 ;
}
}
[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 ) {
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]" ;
}
// 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 ;
}
#if FEATURE_CORECLR
[System.Security.SecurityCritical] // auto-generated
#else
[System.Security.SecuritySafeCritical]
#endif
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? Note - our backout code will set
// the ResourceHelper's currentlyLoading stack to null if an exception occurs.
if ( rh . currentlyLoading ! = null & & rh . currentlyLoading . Count > 0 & & rh . currentlyLoading . Contains ( key ) ) {
// We can start infinitely recursing for one resource lookup,
// then during our failure reporting, start infinitely recursing again.
// avoid that.
if ( rh . infinitelyRecursingCount > 0 ) {
userData . m_retVal = "[Resource lookup failed - infinite recursion or critical failure detected.]" ;
return ;
}
rh . infinitelyRecursingCount + + ;
// 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 &
// clr.dll are both of the same build flavor. Also, user
// code in the resource lookup process (like an assembly
// resolve event or custom CultureInfo) might potentially cause issues.
// Note: our infrastructure for reporting this exception will again cause resource lookup.
// This is the most direct way of dealing with that problem.
String message = "Infinite recursion during resource lookup within mscorlib. This may be a bug in mscorlib, or potentially in certain extensibility points such as assembly resolve events or CultureInfo names. Resource name: " + key ;
Assert . Fail ( "[mscorlib recursive resource lookup bug]" , message , Assert . COR_E_FAILFAST , System . Diagnostics . StackTrace . TraceFormat . NoResourceLookup ) ;
Environment . FailFast ( message ) ;
}
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 ( 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 + "\"" ) ;
userData . m_retVal = s ;
}
#if FEATURE_CORECLR
[System.Security.SecurityCritical] // auto-generated
#endif
[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 ) ;
}
}
}
private static volatile ResourceHelper m_resHelper ; // Doesn't need to be initialized as they're zero-init.
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 < Object > ( ref s_InternalSyncObject , o , null ) ;
}
return s_InternalSyncObject ;
}
}
private static volatile OperatingSystem m_os ; // Cached OperatingSystem value
/ * = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = TickCount = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
* * Action : Gets the number of ticks since the system was started .
* * Returns : The number of ticks since the system was started .
* * Arguments : None
* * Exceptions : None
= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = * /
public static extern int TickCount {
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[MethodImplAttribute(MethodImplOptions.InternalCall)]
get ;
}
// Terminates this process with the given exit code.
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.Process)]
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
[SuppressUnmanagedCodeSecurity]
internal static extern void _Exit ( int exitCode ) ;
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Process)]
[ResourceConsumption(ResourceScope.Process)]
#pragma warning disable 618
[SecurityPermissionAttribute(SecurityAction.Demand, Flags=SecurityPermissionFlag.UnmanagedCode)]
#pragma warning restore 618
public static void Exit ( int exitCode ) {
_Exit ( exitCode ) ;
}
public static extern int ExitCode {
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[MethodImplAttribute(MethodImplOptions.InternalCall)]
get ;
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[MethodImplAttribute(MethodImplOptions.InternalCall)]
set ;
}
// Note: The CLR's Watson bucketization code looks at the caller of the FCALL method
// to assign blame for crashes. Don't mess with this, such as by making it call
// another managed helper method, unless you consult with some CLR Watson experts.
[System.Security.SecurityCritical]
[ResourceExposure(ResourceScope.Process)]
[MethodImplAttribute(MethodImplOptions.InternalCall)]
public static extern void FailFast ( String message ) ;
[System.Security.SecurityCritical]
[ResourceExposure(ResourceScope.Process)]
[MethodImplAttribute(MethodImplOptions.InternalCall)]
internal static extern void FailFast ( String message , uint exitCode ) ;
// This overload of FailFast will allow you to specify the exception object
// whose bucket details *could* be used when undergoing the failfast process.
// To be specific:
//
// 1) When invoked from within a managed EH clause (fault/finally/catch),
// if the exception object is preallocated, the runtime will try to find its buckets
// and use them. If the exception object is not preallocated, it will use the bucket
// details contained in the object (if any).
//
// 2) When invoked from outside the managed EH clauses (fault/finally/catch),
// if the exception object is preallocated, the runtime will use the callsite's
// IP for bucketing. If the exception object is not preallocated, it will use the bucket
// details contained in the object (if any).
[System.Security.SecurityCritical]
[ResourceExposure(ResourceScope.Process)]
[MethodImplAttribute(MethodImplOptions.InternalCall)]
public static extern void FailFast ( String message , Exception exception ) ;
#if ! FEATURE_CORECLR
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
[SecurityCritical] // Our security team doesn't yet allow safe-critical P/Invoke methods.
[ResourceExposure(ResourceScope.None)]
[SuppressUnmanagedCodeSecurity]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
internal static extern void TriggerCodeContractFailure ( ContractFailureKind failureKind , String message , String condition , String exceptionAsString ) ;
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
[SecurityCritical] // Our security team doesn't yet allow safe-critical P/Invoke methods.
[ResourceExposure(ResourceScope.None)]
[SuppressUnmanagedCodeSecurity]
[return: MarshalAs(UnmanagedType.Bool)]
private static extern bool GetIsCLRHosted ( ) ;
internal static bool IsCLRHosted {
[SecuritySafeCritical]
get { return GetIsCLRHosted ( ) ; }
}
public static String CommandLine {
[System.Security.SecuritySafeCritical] // auto-generated
get {
new EnvironmentPermission ( EnvironmentPermissionAccess . Read , "Path" ) . Demand ( ) ;
String commandLine = null ;
GetCommandLine ( JitHelpers . GetStringHandleOnStack ( ref commandLine ) ) ;
return commandLine ;
}
}
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode), SuppressUnmanagedCodeSecurity]
private static extern void GetCommandLine ( StringHandleOnStack retString ) ;
#endif // !FEATURE_CORECLR
/ * = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = CurrentDirectory = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
* * Action : Provides a getter and setter for the current directory . The original
* * current directory is the one from which the process was started .
* * Returns : The current directory ( from the getter ) . Void from the setter .
* * Arguments : The current directory to which to switch to the setter .
* * Exceptions :
= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = * /
public static String CurrentDirectory
{
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
get {
return Directory . GetCurrentDirectory ( ) ;
}
#if FEATURE_CORECLR
[System.Security.SecurityCritical] // auto-generated
#endif
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
set {
Directory . SetCurrentDirectory ( value ) ;
}
}
// Returns the system directory (ie, C:\WinNT\System32).
public static String SystemDirectory {
#if FEATURE_CORECLR
[System.Security.SecurityCritical]
#else
[System.Security.SecuritySafeCritical] // auto-generated
#endif
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
get {
StringBuilder sb = new StringBuilder ( Path . MAX_PATH ) ;
int r = Win32Native . GetSystemDirectory ( sb , Path . MAX_PATH ) ;
Contract . Assert ( r < Path . MAX_PATH , "r < Path.MAX_PATH" ) ;
if ( r = = 0 ) __Error . WinIOError ( ) ;
String path = sb . ToString ( ) ;
#if ! FEATURE_CORECLR
// Do security check
2016-11-10 13:04:39 +00:00
FileIOPermission . QuickDemand ( FileIOPermissionAccess . PathDiscovery , path ) ;
2016-08-03 10:59:49 +00:00
#endif
return path ;
}
}
#if ! FEATURE_PAL
// Returns the windows directory (ie, C:\WinNT).
// Used by NLS+ custom culures only at the moment.
internal static String InternalWindowsDirectory {
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
get {
StringBuilder sb = new StringBuilder ( Path . MAX_PATH ) ;
int r = Win32Native . GetWindowsDirectory ( sb , Path . MAX_PATH ) ;
Contract . Assert ( r < Path . MAX_PATH , "r < Path.MAX_PATH" ) ;
if ( r = = 0 ) __Error . WinIOError ( ) ;
String path = sb . ToString ( ) ;
return path ;
}
}
[System.Security.SecuritySafeCritical] // auto-generated
public static String ExpandEnvironmentVariables ( String name )
{
if ( name = = null )
throw new ArgumentNullException ( "name" ) ;
Contract . EndContractBlock ( ) ;
if ( name . Length = = 0 ) {
return name ;
}
if ( AppDomain . IsAppXModel ( ) & & ! AppDomain . IsAppXDesignMode ( ) ) {
// Environment variable accessors are not approved modern API.
// Behave as if no variables are defined in this case.
return name ;
}
int currentSize = 100 ;
StringBuilder blob = new StringBuilder ( currentSize ) ; // A somewhat reasonable default size
int size ;
#if ! FEATURE_CORECLR
bool isFullTrust = CodeAccessSecurityEngine . QuickCheckForAllDemands ( ) ;
// Do a security check to guarantee we can read each of the
// individual environment variables requested here.
String [ ] varArray = name . Split ( new char [ ] { '%' } ) ;
StringBuilder vars = isFullTrust ? null : new StringBuilder ( ) ;
bool fJustExpanded = false ; // to accommodate expansion alg.
for ( int i = 1 ; i < varArray . Length - 1 ; i + + ) { // Skip first and last tokens
// ExpandEnvironmentStrings' greedy algorithm expands every
// non-boundary %-delimited substring, provided the previous
// has not been expanded.
// if "foo" is not expandable, and "PATH" is, then both
// %foo%PATH% and %foo%foo%PATH% will expand PATH, but
// %PATH%PATH% will expand only once.
// Therefore, if we've just expanded, skip this substring.
if ( varArray [ i ] . Length = = 0 | | fJustExpanded = = true )
{
fJustExpanded = false ;
continue ; // Nothing to expand
}
// Guess a somewhat reasonable initial size, call the method, then if
// it fails (ie, the return value is larger than our buffer size),
// make a new buffer & try again.
blob . Length = 0 ;
String envVar = "%" + varArray [ i ] + "%" ;
size = Win32Native . ExpandEnvironmentStrings ( envVar , blob , currentSize ) ;
if ( size = = 0 )
Marshal . ThrowExceptionForHR ( Marshal . GetHRForLastWin32Error ( ) ) ;
// some environment variable might be changed while this function is called
while ( size > currentSize ) {
currentSize = size ;
blob . Capacity = currentSize ;
blob . Length = 0 ;
size = Win32Native . ExpandEnvironmentStrings ( envVar , blob , currentSize ) ;
if ( size = = 0 )
Marshal . ThrowExceptionForHR ( Marshal . GetHRForLastWin32Error ( ) ) ;
}
if ( ! isFullTrust ) {
String temp = blob . ToString ( ) ;
fJustExpanded = ( temp ! = envVar ) ;
if ( fJustExpanded ) { // We expanded successfully, we need to do String comparison here
// since %FOO% can become %FOOD
vars . Append ( varArray [ i ] ) ;
vars . Append ( ';' ) ;
}
}
}
if ( ! isFullTrust )
new EnvironmentPermission ( EnvironmentPermissionAccess . Read , vars . ToString ( ) ) . Demand ( ) ;
#endif // !FEATURE_CORECLR
blob . Length = 0 ;
size = Win32Native . ExpandEnvironmentStrings ( name , blob , currentSize ) ;
if ( size = = 0 )
Marshal . ThrowExceptionForHR ( Marshal . GetHRForLastWin32Error ( ) ) ;
while ( size > currentSize ) {
currentSize = size ;
blob . Capacity = currentSize ;
blob . Length = 0 ;
size = Win32Native . ExpandEnvironmentStrings ( name , blob , currentSize ) ;
if ( size = = 0 )
Marshal . ThrowExceptionForHR ( Marshal . GetHRForLastWin32Error ( ) ) ;
}
return blob . ToString ( ) ;
}
#endif // FEATURE_PAL
public static String MachineName {
[System.Security.SecuritySafeCritical] // auto-generated
get {
// In future release of operating systems, you might be able to rename a machine without
// rebooting. Therefore, don't cache this machine name.
new EnvironmentPermission ( EnvironmentPermissionAccess . Read , "COMPUTERNAME" ) . Demand ( ) ;
StringBuilder buf = new StringBuilder ( MaxMachineNameLength ) ;
int len = MaxMachineNameLength ;
if ( Win32Native . GetComputerName ( buf , ref len ) = = 0 )
throw new InvalidOperationException ( Environment . GetResourceString ( "InvalidOperation_ComputerName" ) ) ;
return buf . ToString ( ) ;
}
}
[SecurityCritical]
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
[SuppressUnmanagedCodeSecurity]
private static extern Int32 GetProcessorCount ( ) ;
public static int ProcessorCount {
[System.Security.SecuritySafeCritical] // auto-generated
get {
return GetProcessorCount ( ) ;
}
}
public static int SystemPageSize {
[System.Security.SecuritySafeCritical] // auto-generated
get {
( new EnvironmentPermission ( PermissionState . Unrestricted ) ) . Demand ( ) ;
Win32Native . SYSTEM_INFO info = new Win32Native . SYSTEM_INFO ( ) ;
Win32Native . GetSystemInfo ( ref info ) ;
return info . dwPageSize ;
}
}
#if ! FEATURE_CORECLR
/ * = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = GetCommandLineArgs = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
* * Action : Gets the command line and splits it appropriately to deal with whitespace ,
* * quotes , and escape characters .
* * Returns : A string array containing your command line arguments .
* * Arguments : None
* * Exceptions : None .
= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = * /
[System.Security.SecuritySafeCritical] // auto-generated
public static String [ ] GetCommandLineArgs ( ) {
new EnvironmentPermission ( EnvironmentPermissionAccess . Read , "Path" ) . Demand ( ) ;
return GetCommandLineArgsNative ( ) ;
}
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[MethodImplAttribute(MethodImplOptions.InternalCall)]
private static extern String [ ] GetCommandLineArgsNative ( ) ;
// We need to keep this Fcall since it is used in AppDomain.cs.
// If we call GetEnvironmentVariable from AppDomain.cs, we will use StringBuilder class.
// That has side effect to change the ApartmentState of the calling Thread to MTA.
// So runtime can't change the ApartmentState of calling thread any more.
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.Process)]
[MethodImplAttribute(MethodImplOptions.InternalCall)]
internal static extern String nativeGetEnvironmentVariable ( String variable ) ;
#endif //!FEATURE_CORECLR
/ * = = = = = = = = = = = = = = = = = = = = = = = = = = = = GetEnvironmentVariable = = = = = = = = = = = = = = = = = = = = = = = = = = = =
* * Action :
* * Returns :
* * Arguments :
* * Exceptions :
= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = * /
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
public static String GetEnvironmentVariable ( String variable )
{
if ( variable = = null )
throw new ArgumentNullException ( "variable" ) ;
Contract . EndContractBlock ( ) ;
if ( AppDomain . IsAppXModel ( ) & & ! AppDomain . IsAppXDesignMode ( ) ) {
// Environment variable accessors are not approved modern API.
// Behave as if the variable was not found in this case.
return null ;
}
#if ! FEATURE_CORECLR
( new EnvironmentPermission ( EnvironmentPermissionAccess . Read , variable ) ) . Demand ( ) ;
#endif //!FEATURE_CORECLR
StringBuilder blob = StringBuilderCache . Acquire ( 128 ) ; // A somewhat reasonable default size
int requiredSize = Win32Native . GetEnvironmentVariable ( variable , blob , blob . Capacity ) ;
if ( requiredSize = = 0 ) { // GetEnvironmentVariable failed
if ( Marshal . GetLastWin32Error ( ) = = Win32Native . ERROR_ENVVAR_NOT_FOUND ) {
StringBuilderCache . Release ( blob ) ;
return null ;
}
}
while ( requiredSize > blob . Capacity ) { // need to retry since the environment variable might be changed
blob . Capacity = requiredSize ;
blob . Length = 0 ;
requiredSize = Win32Native . GetEnvironmentVariable ( variable , blob , blob . Capacity ) ;
}
return StringBuilderCache . GetStringAndRelease ( blob ) ;
}
#if ! FEATURE_PAL
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
public static string GetEnvironmentVariable ( string variable , EnvironmentVariableTarget target )
{
if ( variable = = null )
{
throw new ArgumentNullException ( "variable" ) ;
}
Contract . EndContractBlock ( ) ;
if ( target = = EnvironmentVariableTarget . Process )
{
return GetEnvironmentVariable ( variable ) ;
}
#if FEATURE_WIN32_REGISTRY
( new EnvironmentPermission ( PermissionState . Unrestricted ) ) . Demand ( ) ;
if ( target = = EnvironmentVariableTarget . Machine ) {
using ( RegistryKey environmentKey =
Registry . LocalMachine . OpenSubKey ( @"System\CurrentControlSet\Control\Session Manager\Environment" , false ) ) {
Contract . Assert ( environmentKey ! = null , @"HKLM\System\CurrentControlSet\Control\Session Manager\Environment is missing!" ) ;
if ( environmentKey = = null ) {
return null ;
}
string value = environmentKey . GetValue ( variable ) as string ;
return value ;
}
}
else if ( target = = EnvironmentVariableTarget . User ) {
using ( RegistryKey environmentKey =
Registry . CurrentUser . OpenSubKey ( "Environment" , false ) ) {
Contract . Assert ( environmentKey ! = null , @"HKCU\Environment is missing!" ) ;
if ( environmentKey = = null ) {
return null ;
}
string value = environmentKey . GetValue ( variable ) as string ;
return value ;
}
}
else
#endif // FEATURE_WIN32_REGISTRY
{
throw new ArgumentException ( Environment . GetResourceString ( "Arg_EnumIllegalVal" , ( int ) target ) ) ;
}
}
#endif
/ * = = = = = = = = = = = = = = = = = = = = = = = = = = = GetEnvironmentVariables = = = = = = = = = = = = = = = = = = = = = = = = = = = =
* * Action : Returns an IDictionary containing all enviroment variables and their values .
* * Returns : An IDictionary containing all environment variables and their values .
* * Arguments : None .
* * Exceptions : None .
= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = * /
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.Machine)]
private unsafe static char [ ] GetEnvironmentCharArray ( )
{
char [ ] block = null ;
// Make sure pStrings is not leaked with async exceptions
RuntimeHelpers . PrepareConstrainedRegions ( ) ;
try {
}
finally {
char * pStrings = null ;
try
{
pStrings = Win32Native . GetEnvironmentStrings ( ) ;
if ( pStrings = = null ) {
throw new OutOfMemoryException ( ) ;
}
// Format for GetEnvironmentStrings is:
// [=HiddenVar=value\0]* [Variable=value\0]* \0
// See the description of Environment Blocks in MSDN's
// CreateProcess page (null-terminated array of null-terminated strings).
// Search for terminating \0\0 (two unicode \0's).
char * p = pStrings ;
while ( ! ( * p = = '\0' & & * ( p + 1 ) = = '\0' ) )
p + + ;
int len = ( int ) ( p - pStrings + 1 ) ;
block = new char [ len ] ;
fixed ( char * pBlock = block )
String . wstrcpy ( pBlock , pStrings , len ) ;
}
finally
{
if ( pStrings ! = null )
Win32Native . FreeEnvironmentStrings ( pStrings ) ;
}
}
return block ;
}
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
public static IDictionary GetEnvironmentVariables ( )
{
if ( AppDomain . IsAppXModel ( ) & & ! AppDomain . IsAppXDesignMode ( ) ) {
// Environment variable accessors are not approved modern API.
// Behave as if no environment variables are defined in this case.
return new Hashtable ( 0 ) ;
}
#if ! FEATURE_CORECLR
bool isFullTrust = CodeAccessSecurityEngine . QuickCheckForAllDemands ( ) ;
StringBuilder vars = isFullTrust ? null : new StringBuilder ( ) ;
bool first = true ;
#endif
char [ ] block = GetEnvironmentCharArray ( ) ;
Hashtable table = new Hashtable ( 20 ) ;
// Copy strings out, parsing into pairs and inserting into the table.
// The first few environment variable entries start with an '='!
// The current working directory of every drive (except for those drives
// you haven't cd'ed into in your DOS window) are stored in the
// environment block (as =C:=pwd) and the program's exit code is
// as well (=ExitCode=00000000) Skip all that start with =.
// Read docs about Environment Blocks on MSDN's CreateProcess page.
// Format for GetEnvironmentStrings is:
// (=HiddenVar=value\0 | Variable=value\0)* \0
// See the description of Environment Blocks in MSDN's
// CreateProcess page (null-terminated array of null-terminated strings).
// Note the =HiddenVar's aren't always at the beginning.
for ( int i = 0 ; i < block . Length ; i + + ) {
int startKey = i ;
// Skip to key
// On some old OS, the environment block can be corrupted.
// Someline will not have '=', so we need to check for '\0'.
while ( block [ i ] ! = '=' & & block [ i ] ! = '\0' ) {
i + + ;
}
if ( block [ i ] = = '\0' ) {
continue ;
}
// Skip over environment variables starting with '='
if ( i - startKey = = 0 ) {
while ( block [ i ] ! = 0 ) {
i + + ;
}
continue ;
}
String key = new String ( block , startKey , i - startKey ) ;
i + + ; // skip over '='
int startValue = i ;
while ( block [ i ] ! = 0 ) {
// Read to end of this entry
i + + ;
}
String value = new String ( block , startValue , i - startValue ) ;
// skip over 0 handled by for loop's i++
table [ key ] = value ;
#if ! FEATURE_CORECLR
if ( ! isFullTrust ) {
if ( first ) {
first = false ;
}
else {
vars . Append ( ';' ) ;
}
vars . Append ( key ) ;
}
#endif
}
#if ! FEATURE_CORECLR
if ( ! isFullTrust )
new EnvironmentPermission ( EnvironmentPermissionAccess . Read , vars . ToString ( ) ) . Demand ( ) ;
#endif
return table ;
}
#if ! FEATURE_PAL
internal static IDictionary GetRegistryKeyNameValuePairs ( RegistryKey registryKey ) {
Hashtable table = new Hashtable ( 20 ) ;
if ( registryKey ! = null ) {
string [ ] names = registryKey . GetValueNames ( ) ;
foreach ( string name in names ) {
string value = registryKey . GetValue ( name , "" ) . ToString ( ) ;
table . Add ( name , value ) ;
}
}
return table ;
}
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
public static IDictionary GetEnvironmentVariables ( EnvironmentVariableTarget target ) {
if ( target = = EnvironmentVariableTarget . Process ) {
return GetEnvironmentVariables ( ) ;
}
#if FEATURE_WIN32_REGISTRY
( new EnvironmentPermission ( PermissionState . Unrestricted ) ) . Demand ( ) ;
if ( target = = EnvironmentVariableTarget . Machine ) {
using ( RegistryKey environmentKey =
Registry . LocalMachine . OpenSubKey ( @"System\CurrentControlSet\Control\Session Manager\Environment" , false ) ) {
return GetRegistryKeyNameValuePairs ( environmentKey ) ;
}
}
else if ( target = = EnvironmentVariableTarget . User ) {
using ( RegistryKey environmentKey =
Registry . CurrentUser . OpenSubKey ( "Environment" , false ) ) {
return GetRegistryKeyNameValuePairs ( environmentKey ) ;
}
}
else
#endif // FEATURE_WIN32_REGISTRY
{
throw new ArgumentException ( Environment . GetResourceString ( "Arg_EnumIllegalVal" , ( int ) target ) ) ;
}
}
#endif
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
public static void SetEnvironmentVariable ( string variable , string value ) {
CheckEnvironmentVariableName ( variable ) ;
#if ! FEATURE_CORECLR
new EnvironmentPermission ( PermissionState . Unrestricted ) . Demand ( ) ;
#endif
// explicitly null out value if is the empty string.
if ( String . IsNullOrEmpty ( value ) | | value [ 0 ] = = '\0' ) {
value = null ;
}
else {
if ( value . Length > = MaxEnvVariableValueLength ) {
throw new ArgumentException ( Environment . GetResourceString ( "Argument_LongEnvVarValue" ) ) ;
}
}
if ( AppDomain . IsAppXModel ( ) & & ! AppDomain . IsAppXDesignMode ( ) ) {
// Environment variable accessors are not approved modern API.
// so we throw PlatformNotSupportedException.
throw new PlatformNotSupportedException ( ) ;
}
if ( ! Win32Native . SetEnvironmentVariable ( variable , value ) ) {
int errorCode = Marshal . GetLastWin32Error ( ) ;
// Allow user to try to clear a environment variable
if ( errorCode = = Win32Native . ERROR_ENVVAR_NOT_FOUND ) {
return ;
}
// The error message from Win32 is "The filename or extension is too long",
// which is not accurate.
if ( errorCode = = Win32Native . ERROR_FILENAME_EXCED_RANGE ) {
throw new ArgumentException ( Environment . GetResourceString ( "Argument_LongEnvVarValue" ) ) ;
}
throw new ArgumentException ( Win32Native . GetMessage ( errorCode ) ) ;
}
}
private static void CheckEnvironmentVariableName ( string variable ) {
if ( variable = = null ) {
throw new ArgumentNullException ( "variable" ) ;
}
if ( variable . Length = = 0 ) {
throw new ArgumentException ( Environment . GetResourceString ( "Argument_StringZeroLength" ) , "variable" ) ;
}
if ( variable [ 0 ] = = '\0' ) {
throw new ArgumentException ( Environment . GetResourceString ( "Argument_StringFirstCharIsZero" ) , "variable" ) ;
}
// Make sure the environment variable name isn't longer than the
// max limit on environment variable values. (MSDN is ambiguous
// on whether this check is necessary.)
if ( variable . Length > = MaxEnvVariableValueLength ) {
throw new ArgumentException ( Environment . GetResourceString ( "Argument_LongEnvVarValue" ) ) ;
}
if ( variable . IndexOf ( '=' ) ! = - 1 ) {
throw new ArgumentException ( Environment . GetResourceString ( "Argument_IllegalEnvVarName" ) ) ;
}
Contract . EndContractBlock ( ) ;
}
#if ! FEATURE_PAL
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
public static void SetEnvironmentVariable ( string variable , string value , EnvironmentVariableTarget target ) {
if ( target = = EnvironmentVariableTarget . Process ) {
SetEnvironmentVariable ( variable , value ) ;
return ;
}
CheckEnvironmentVariableName ( variable ) ;
// System-wide environment variables stored in the registry are
// limited to 1024 chars for the environment variable name.
if ( variable . Length > = MaxSystemEnvVariableLength ) {
throw new ArgumentException ( Environment . GetResourceString ( "Argument_LongEnvVarName" ) ) ;
}
new EnvironmentPermission ( PermissionState . Unrestricted ) . Demand ( ) ;
// explicitly null out value if is the empty string.
if ( String . IsNullOrEmpty ( value ) | | value [ 0 ] = = '\0' ) {
value = null ;
}
#if FEATURE_WIN32_REGISTRY
if ( target = = EnvironmentVariableTarget . Machine ) {
using ( RegistryKey environmentKey =
Registry . LocalMachine . OpenSubKey ( @"System\CurrentControlSet\Control\Session Manager\Environment" , true ) ) {
Contract . Assert ( environmentKey ! = null , @"HKLM\System\CurrentControlSet\Control\Session Manager\Environment is missing!" ) ;
if ( environmentKey ! = null ) {
if ( value = = null )
environmentKey . DeleteValue ( variable , false ) ;
else
environmentKey . SetValue ( variable , value ) ;
}
}
}
else if ( target = = EnvironmentVariableTarget . User ) {
// User-wide environment variables stored in the registry are
// limited to 255 chars for the environment variable name.
if ( variable . Length > = MaxUserEnvVariableLength ) {
throw new ArgumentException ( Environment . GetResourceString ( "Argument_LongEnvVarValue" ) ) ;
}
using ( RegistryKey environmentKey =
Registry . CurrentUser . OpenSubKey ( "Environment" , true ) ) {
Contract . Assert ( environmentKey ! = null , @"HKCU\Environment is missing!" ) ;
if ( environmentKey ! = null ) {
if ( value = = null )
environmentKey . DeleteValue ( variable , false ) ;
else
environmentKey . SetValue ( variable , value ) ;
}
}
}
else
{
throw new ArgumentException ( Environment . GetResourceString ( "Arg_EnumIllegalVal" , ( int ) target ) ) ;
}
// send a WM_SETTINGCHANGE message to all windows
IntPtr r = Win32Native . SendMessageTimeout ( new IntPtr ( Win32Native . HWND_BROADCAST ) , Win32Native . WM_SETTINGCHANGE , IntPtr . Zero , "Environment" , 0 , 1000 , IntPtr . Zero ) ;
if ( r = = IntPtr . Zero ) BCLDebug . Assert ( false , "SetEnvironmentVariable failed: " + Marshal . GetLastWin32Error ( ) ) ;
#else // FEATURE_WIN32_REGISTRY
throw new ArgumentException ( Environment . GetResourceString ( "Arg_EnumIllegalVal" , ( int ) target ) ) ;
#endif
}
#endif
/ * = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = GetLogicalDrives = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
* * Action : Retrieves the names of the logical drives on this machine in the form "C:\".
* * Arguments : None .
* * Exceptions : IOException .
* * Permissions : SystemInfo Permission .
= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = * /
[System.Security.SecuritySafeCritical] // auto-generated
public static String [ ] GetLogicalDrives ( ) {
new EnvironmentPermission ( PermissionState . Unrestricted ) . Demand ( ) ;
int drives = Win32Native . GetLogicalDrives ( ) ;
if ( drives = = 0 )
__Error . WinIOError ( ) ;
uint d = ( uint ) drives ;
int count = 0 ;
while ( d ! = 0 ) {
if ( ( ( int ) d & 1 ) ! = 0 ) count + + ;
d > > = 1 ;
}
String [ ] result = new String [ count ] ;
char [ ] root = new char [ ] { 'A' , ':' , '\\' } ;
d = ( uint ) drives ;
count = 0 ;
while ( d ! = 0 ) {
if ( ( ( int ) d & 1 ) ! = 0 ) {
result [ count + + ] = new String ( root ) ;
}
d > > = 1 ;
root [ 0 ] + + ;
}
return result ;
}
/ * = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = NewLine = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
* * Action : A property which returns the appropriate newline string for the given
* * platform .
* * Returns : \ r \ n on Win32 .
* * Arguments : None .
* * Exceptions : None .
= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = * /
public static String NewLine {
get {
Contract . Ensures ( Contract . Result < String > ( ) ! = null ) ;
return "\r\n" ;
}
}
/ * = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = Version = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
* * Action : Returns the COM + version struct , describing the build number .
* * Returns :
* * Arguments :
* * Exceptions :
= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = * /
public static Version Version {
get {
// Previously this represented the File version of mscorlib.dll. Many other libraries in the framework and outside took dependencies on the first three parts of this version
// remaining constant throughout 4.x. From 4.0 to 4.5.2 this was fine since the file version only incremented the last part.Starting with 4.6 we switched to a file versioning
// scheme that matched the product version. In order to preserve compatibility with existing libraries, this needs to be hard-coded.
return new Version ( 4 , 0 , 30319 , 42000 ) ;
}
}
/ * = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = WorkingSet = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
* * Action :
* * Returns :
* * Arguments :
* * Exceptions :
= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = * /
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode), SuppressUnmanagedCodeSecurity]
private static extern long GetWorkingSet ( ) ;
public static long WorkingSet {
[System.Security.SecuritySafeCritical] // auto-generated
get {
new EnvironmentPermission ( PermissionState . Unrestricted ) . Demand ( ) ;
return GetWorkingSet ( ) ;
}
}
/ * = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = OSVersion = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
* * Action :
* * Returns :
* * Arguments :
* * Exceptions :
= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = * /
public static OperatingSystem OSVersion {
[System.Security.SecuritySafeCritical] // auto-generated
get {
Contract . Ensures ( Contract . Result < OperatingSystem > ( ) ! = null ) ;
if ( m_os = = null ) { // We avoid the lock since we don't care if two threads will set this at the same time.
Microsoft . Win32 . Win32Native . OSVERSIONINFO osvi = new Microsoft . Win32 . Win32Native . OSVERSIONINFO ( ) ;
if ( ! GetVersion ( osvi ) ) {
throw new InvalidOperationException ( Environment . GetResourceString ( "InvalidOperation_GetVersion" ) ) ;
}
Microsoft . Win32 . Win32Native . OSVERSIONINFOEX osviEx = new Microsoft . Win32 . Win32Native . OSVERSIONINFOEX ( ) ;
if ( ! GetVersionEx ( osviEx ) )
throw new InvalidOperationException ( Environment . GetResourceString ( "InvalidOperation_GetVersion" ) ) ;
PlatformID id = PlatformID . Win32NT ;
#if FEATURE_LEGACYNETCF
// return platform as WinCE, to ensure apps earlier than WP8 works as expected.
if ( CompatibilitySwitches . IsAppEarlierThanWindowsPhone8 )
{
id = PlatformID . WinCE ;
}
#endif
Version v = new Version ( osvi . MajorVersion , osvi . MinorVersion , osvi . BuildNumber , ( osviEx . ServicePackMajor < < 16 ) | osviEx . ServicePackMinor ) ;
m_os = new OperatingSystem ( id , v , osvi . CSDVersion ) ;
}
Contract . Assert ( m_os ! = null , "m_os != null" ) ;
return m_os ;
}
}
#if FEATURE_CORESYSTEM
internal static bool IsWindows8OrAbove {
get {
return true ;
}
}
#if FEATURE_COMINTEROP
internal static bool IsWinRTSupported {
get {
return true ;
}
}
#endif // FEATURE_COMINTEROP
#else // FEATURE_CORESYSTEM
private static volatile bool s_IsWindows8OrAbove ;
private static volatile bool s_CheckedOSWin8OrAbove ;
// Windows 8 version is 6.2
internal static bool IsWindows8OrAbove {
get {
if ( ! s_CheckedOSWin8OrAbove ) {
OperatingSystem OS = Environment . OSVersion ;
s_IsWindows8OrAbove = ( OS . Platform = = PlatformID . Win32NT & &
( ( OS . Version . Major = = 6 & & OS . Version . Minor > = 2 ) | | ( OS . Version . Major > 6 ) ) ) ;
s_CheckedOSWin8OrAbove = true ;
}
return s_IsWindows8OrAbove ;
}
}
#if FEATURE_COMINTEROP
private static volatile bool s_WinRTSupported ;
private static volatile bool s_CheckedWinRT ;
// Does the current version of Windows have Windows Runtime suppport?
internal static bool IsWinRTSupported {
[SecuritySafeCritical]
get {
if ( ! s_CheckedWinRT ) {
s_WinRTSupported = WinRTSupported ( ) ;
s_CheckedWinRT = true ;
}
return s_WinRTSupported ;
}
}
[SecurityCritical]
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
[SuppressUnmanagedCodeSecurity]
[return: MarshalAs(UnmanagedType.Bool)]
private static extern bool WinRTSupported ( ) ;
#endif // FEATURE_COMINTEROP
#endif // FEATURE_CORESYSTEM
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[MethodImplAttribute(MethodImplOptions.InternalCall)]
internal static extern bool GetVersion ( Microsoft . Win32 . Win32Native . OSVERSIONINFO osVer ) ;
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[MethodImplAttribute(MethodImplOptions.InternalCall)]
internal static extern bool GetVersionEx ( Microsoft . Win32 . Win32Native . OSVERSIONINFOEX osVer ) ;
/ * = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = StackTrace = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
* * Action :
* * Returns :
* * Arguments :
* * Exceptions :
= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = * /
public static String StackTrace {
[System.Security.SecuritySafeCritical] // auto-generated
get {
Contract . Ensures ( Contract . Result < String > ( ) ! = null ) ;
new EnvironmentPermission ( PermissionState . Unrestricted ) . Demand ( ) ;
return GetStackTrace ( null , true ) ;
}
}
#if FEATURE_CORECLR
[System.Security.SecurityCritical] // auto-generated
#endif
internal static String GetStackTrace ( Exception e , bool needFileInfo )
{
// Note: Setting needFileInfo to true will start up COM and set our
// apartment state. Try to not call this when passing "true"
// before the EE's ExecuteMainMethod has had a chance to set up the
// apartment state. --
StackTrace st ;
if ( e = = null )
st = new StackTrace ( needFileInfo ) ;
else
st = new StackTrace ( e , needFileInfo ) ;
// Do no include a trailing newline for backwards compatibility
return st . ToString ( System . Diagnostics . StackTrace . TraceFormat . Normal ) ;
}
[System.Security.SecuritySafeCritical] // auto-generated
private static void InitResourceHelper ( ) {
// Only the default AppDomain should have a ResourceHelper. All calls to
// GetResourceString from any AppDomain delegate to GetResourceStringLocal
// in the default AppDomain via the fcall GetResourceFromDefault.
bool tookLock = false ;
RuntimeHelpers . PrepareConstrainedRegions ( ) ;
try {
Monitor . Enter ( Environment . InternalSyncObject , ref tookLock ) ;
if ( m_resHelper = = null ) {
ResourceHelper rh = new ResourceHelper ( "mscorlib" ) ;
System . Threading . Thread . MemoryBarrier ( ) ;
m_resHelper = rh ;
}
}
finally {
if ( tookLock )
Monitor . Exit ( Environment . InternalSyncObject ) ;
}
}
#if ! FEATURE_CORECLR
[System.Security.SecurityCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[MethodImplAttribute(MethodImplOptions.InternalCall)]
internal extern static String GetResourceFromDefault ( String key ) ;
#endif
// Looks up the resource string value for key.
//
// if you change this method's signature then you must change the code that calls it
// in excep.cpp and probably you will have to visit mscorlib.h to add the new signature
// as well as metasig.h to create the new signature type
#if FEATURE_CORECLR
[System.Security.SecurityCritical] // auto-generated
#endif
internal static String GetResourceStringLocal ( String key ) {
if ( m_resHelper = = null )
InitResourceHelper ( ) ;
return m_resHelper . GetResourceString ( key ) ;
}
// #threadCultureInfo
// Currently in silverlight, CurrentCulture and CurrentUICulture are isolated
// within an AppDomain. This is in contrast to the desktop, in which cultures
// leak across AppDomain boundaries with the thread.
//
// Note that mscorlib transitions to the default domain to perform resource
// lookup. This causes problems for the silverlight changes: since culture isn't
// passed, resource string lookup won't necessarily use the culture of the thread
// originating the request. To get around that problem, we pass the CultureInfo
// so that the ResourceManager GetString(x, cultureInfo) overload can be used.
// We first perform the same check as in CultureInfo to make sure it's safe to
// let the CultureInfo travel across AppDomains.
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
internal static String GetResourceString ( String key ) {
#if FEATURE_CORECLR
return GetResourceStringLocal ( key ) ;
#else
return GetResourceFromDefault ( key ) ;
#endif //FEATURE_CORECLR
}
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
internal static String GetResourceString ( String key , params Object [ ] values ) {
String s = GetResourceString ( key ) ;
return String . Format ( CultureInfo . CurrentCulture , s , values ) ;
}
//The following two internal methods are not used anywhere within the framework,
// but are being kept around as external platforms built on top of us have taken
// dependency by using private reflection on them for getting system resource strings
[ResourceExposure(ResourceScope.None)]
internal static String GetRuntimeResourceString ( String key ) {
return GetResourceString ( key ) ;
}
[ResourceExposure(ResourceScope.None)]
internal static String GetRuntimeResourceString ( String key , params Object [ ] values ) {
return GetResourceString ( key , values ) ;
}
public static bool Is64BitProcess {
get {
#if WIN32
return false ;
#else
return true ;
#endif
}
}
#if ! FEATURE_PAL
public static bool Is64BitOperatingSystem {
[System.Security.SecuritySafeCritical]
get {
#if WIN32
bool isWow64 ; // WinXP SP2+ and Win2k3 SP1+
return Win32Native . DoesWin32MethodExist ( Win32Native . KERNEL32 , "IsWow64Process" )
& & Win32Native . IsWow64Process ( Win32Native . GetCurrentProcess ( ) , out isWow64 )
& & isWow64 ;
#else
// 64-bit programs run only on 64-bit
//<
return true ;
#endif
}
}
#endif
public static extern bool HasShutdownStarted {
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[MethodImplAttribute(MethodImplOptions.InternalCall)]
get ;
}
#if ! FEATURE_CORECLR
// This is the temporary Whidbey stub for compatibility flags
[ResourceExposure(ResourceScope.None)]
[MethodImplAttribute(MethodImplOptions.InternalCall)]
[System.Security.SecurityCritical]
internal static extern bool GetCompatibilityFlag ( CompatibilityFlag flag ) ;
#endif //!FEATURE_CORECLR
public static string UserName {
[System.Security.SecuritySafeCritical] // auto-generated
get {
new EnvironmentPermission ( EnvironmentPermissionAccess . Read , "UserName" ) . Demand ( ) ;
StringBuilder sb = new StringBuilder ( 256 ) ;
int size = sb . Capacity ;
if ( Win32Native . GetUserName ( sb , ref size ) )
{
return sb . ToString ( ) ;
}
return String . Empty ;
}
}
// Note that this is a handle to a process window station, but it does
// not need to be closed. CloseWindowStation would ignore this handle.
// We also do handle equality checking as well. This isn't a great fit
// for SafeHandle. We don't gain anything by using SafeHandle here.
#if ! FEATURE_PAL & & ! FEATURE_CORESYSTEM
private static volatile IntPtr processWinStation ; // Doesn't need to be initialized as they're zero-init.
private static volatile bool isUserNonInteractive ;
#endif
public static bool UserInteractive {
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.None)]
[ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
get {
#if ! FEATURE_PAL & & ! FEATURE_CORESYSTEM
IntPtr hwinsta = Win32Native . GetProcessWindowStation ( ) ;
if ( hwinsta ! = IntPtr . Zero & & processWinStation ! = hwinsta ) {
int lengthNeeded = 0 ;
Win32Native . USEROBJECTFLAGS flags = new Win32Native . USEROBJECTFLAGS ( ) ;
if ( Win32Native . GetUserObjectInformation ( hwinsta , Win32Native . UOI_FLAGS , flags , Marshal . SizeOf ( flags ) , ref lengthNeeded ) ) {
if ( ( flags . dwFlags & Win32Native . WSF_VISIBLE ) = = 0 ) {
isUserNonInteractive = true ;
}
}
processWinStation = hwinsta ;
}
// The logic is reversed to avoid static initialization to true
return ! isUserNonInteractive ;
#else
return true ;
#endif
}
}
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
public static string GetFolderPath ( SpecialFolder folder ) {
if ( ! Enum . IsDefined ( typeof ( SpecialFolder ) , folder ) )
throw new ArgumentException ( Environment . GetResourceString ( "Arg_EnumIllegalVal" , ( int ) folder ) ) ;
Contract . EndContractBlock ( ) ;
return InternalGetFolderPath ( folder , SpecialFolderOption . None ) ;
}
[System.Security.SecuritySafeCritical] // auto-generated
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
public static string GetFolderPath ( SpecialFolder folder , SpecialFolderOption option ) {
if ( ! Enum . IsDefined ( typeof ( SpecialFolder ) , folder ) )
throw new ArgumentException ( Environment . GetResourceString ( "Arg_EnumIllegalVal" , ( int ) folder ) ) ;
if ( ! Enum . IsDefined ( typeof ( SpecialFolderOption ) , option ) )
throw new ArgumentException ( Environment . GetResourceString ( "Arg_EnumIllegalVal" , ( int ) option ) ) ;
Contract . EndContractBlock ( ) ;
return InternalGetFolderPath ( folder , option ) ;
}
[System.Security.SecurityCritical]
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
internal static string UnsafeGetFolderPath ( SpecialFolder folder )
{
return InternalGetFolderPath ( folder , SpecialFolderOption . None , suppressSecurityChecks : true ) ;
}
[System.Security.SecurityCritical]
[ResourceExposure(ResourceScope.Machine)]
[ResourceConsumption(ResourceScope.Machine)]
private static string InternalGetFolderPath ( SpecialFolder folder , SpecialFolderOption option , bool suppressSecurityChecks = false )
{
#if FEATURE_CORESYSTEM
// This is currently customized for Windows Phone since CoreSystem doesn't support
// SHGetFolderPath. The allowed folder values are based on the version of .NET CF WP7 was using.
switch ( folder )
{
case SpecialFolder . System :
return SystemDirectory ;
case SpecialFolder . ApplicationData :
case SpecialFolder . Favorites :
case SpecialFolder . Programs :
case SpecialFolder . StartMenu :
case SpecialFolder . Startup :
case SpecialFolder . Personal :
throw new PlatformNotSupportedException ( ) ;
default :
throw new PlatformNotSupportedException ( ) ;
}
#else // FEATURE_CORESYSTEM
#if ! FEATURE_CORECLR
if ( option = = SpecialFolderOption . Create & & ! suppressSecurityChecks ) {
FileIOPermission createPermission = new FileIOPermission ( PermissionState . None ) ;
createPermission . AllFiles = FileIOPermissionAccess . Write ;
createPermission . Demand ( ) ;
}
#endif
StringBuilder sb = new StringBuilder ( Path . MAX_PATH ) ;
int hresult = Win32Native . SHGetFolderPath ( IntPtr . Zero , /* hwndOwner: [in] Reserved */
( ( int ) folder | ( int ) option ) , /* nFolder: [in] CSIDL */
IntPtr . Zero , /* hToken: [in] access token */
Win32Native . SHGFP_TYPE_CURRENT , /* dwFlags: [in] retrieve current path */
sb ) ; /* pszPath: [out]resultant path */
String s ;
if ( hresult < 0 )
{
switch ( hresult )
{
default :
// The previous incarnation threw away all errors. In order to limit
// breaking changes, we will be permissive about these errors
// instead of calling ThowExceptionForHR.
//Runtime.InteropServices.Marshal.ThrowExceptionForHR(hresult);
break ;
case __HResults . COR_E_PLATFORMNOTSUPPORTED :
// This one error is the one we do want to throw.
// <
throw new PlatformNotSupportedException ( ) ;
}
// SHGetFolderPath does not initialize the output buffer on error
s = String . Empty ;
}
else
{
s = sb . ToString ( ) ;
}
if ( ! suppressSecurityChecks )
{
// On CoreCLR we can check with the host if we're not trying to use any special options.
// Otherwise, we need to do a full demand since hosts aren't expecting to handle requests to
// create special folders.
#if FEATURE_CORECLR
if ( option = = SpecialFolderOption . None )
{
FileSecurityState state = new FileSecurityState ( FileSecurityStateAccess . PathDiscovery , String . Empty , s ) ;
state . EnsureState ( ) ;
}
else
#endif // FEATURE_CORECLR
{
new FileIOPermission ( FileIOPermissionAccess . PathDiscovery , s ) . Demand ( ) ;
}
}
return s ;
#endif // FEATURE_CORESYSTEM
}
#if ! FEATURE_PAL
public static string UserDomainName
{
[System.Security.SecuritySafeCritical] // auto-generated
get {
new EnvironmentPermission ( EnvironmentPermissionAccess . Read , "UserDomain" ) . Demand ( ) ;
byte [ ] sid = new byte [ 1024 ] ;
int sidLen = sid . Length ;
StringBuilder domainName = new StringBuilder ( 1024 ) ;
uint domainNameLen = ( uint ) domainName . Capacity ;
int peUse ;
byte ret = Win32Native . GetUserNameEx ( Win32Native . NameSamCompatible , domainName , ref domainNameLen ) ;
if ( ret = = 1 ) {
string samName = domainName . ToString ( ) ;
int index = samName . IndexOf ( '\\' ) ;
if ( index ! = - 1 ) {
return samName . Substring ( 0 , index ) ;
}
}
domainNameLen = ( uint ) domainName . Capacity ;
bool success = Win32Native . LookupAccountName ( null , UserName , sid , ref sidLen , domainName , ref domainNameLen , out peUse ) ;
if ( ! success ) {
int errorCode = Marshal . GetLastWin32Error ( ) ;
throw new InvalidOperationException ( Win32Native . GetMessage ( errorCode ) ) ;
}
return domainName . ToString ( ) ;
}
}
#endif // !FEATURE_PAL
public enum SpecialFolderOption {
None = 0 ,
Create = Win32Native . CSIDL_FLAG_CREATE ,
DoNotVerify = Win32Native . CSIDL_FLAG_DONT_VERIFY ,
}
//////!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!////////
//////!!!!!! Keep the following locations synchronized !!!!!!////////
//////!!!!!! 1) ndp\clr\src\BCL\Microsoft\Win32\Win32Native.cs !!!!!!////////
//////!!!!!! 2) ndp\clr\src\BCL\System\Environment.cs !!!!!!////////
//////!!!!!! 3) rotor\pal\inc\rotor_pal.h !!!!!!////////
//////!!!!!! 4) rotor\pal\corunix\shfolder\shfolder.cpp !!!!!!////////
//////!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!////////
[ComVisible(true)]
public enum SpecialFolder {
//
// Represents the file system directory that serves as a common repository for
// application-specific data for the current, roaming user.
// A roaming user works on more than one computer on a network. A roaming user's
// profile is kept on a server on the network and is loaded onto a system when the
// user logs on.
//
ApplicationData = Win32Native . CSIDL_APPDATA ,
//
// Represents the file system directory that serves as a common repository for application-specific data that
// is used by all users.
//
CommonApplicationData = Win32Native . CSIDL_COMMON_APPDATA ,
//
// Represents the file system directory that serves as a common repository for application specific data that
// is used by the current, non-roaming user.
//
LocalApplicationData = Win32Native . CSIDL_LOCAL_APPDATA ,
//
// Represents the file system directory that serves as a common repository for Internet
// cookies.
//
Cookies = Win32Native . CSIDL_COOKIES ,
Desktop = Win32Native . CSIDL_DESKTOP ,
//
// Represents the file system directory that serves as a common repository for the user's
// favorite items.
//
Favorites = Win32Native . CSIDL_FAVORITES ,
//
// Represents the file system directory that serves as a common repository for Internet
// history items.
//
History = Win32Native . CSIDL_HISTORY ,
//
// Represents the file system directory that serves as a common repository for temporary
// Internet files.
//
InternetCache = Win32Native . CSIDL_INTERNET_CACHE ,
//
// Represents the file system directory that contains
// the user's program groups.
//
Programs = Win32Native . CSIDL_PROGRAMS ,
MyComputer = Win32Native . CSIDL_DRIVES ,
MyMusic = Win32Native . CSIDL_MYMUSIC ,
MyPictures = Win32Native . CSIDL_MYPICTURES ,
// "My Videos" folder
MyVideos = Win32Native . CSIDL_MYVIDEO ,
//
// Represents the file system directory that contains the user's most recently used
// documents.
//
Recent = Win32Native . CSIDL_RECENT ,
//
// Represents the file system directory that contains Send To menu items.
//
SendTo = Win32Native . CSIDL_SENDTO ,
//
// Represents the file system directory that contains the Start menu items.
//
StartMenu = Win32Native . CSIDL_STARTMENU ,
//
// Represents the file system directory that corresponds to the user's Startup program group. The system
// starts these programs whenever any user logs on to Windows NT, or
// starts Windows 95 or Windows 98.
//
Startup = Win32Native . CSIDL_STARTUP ,
//
// System directory.
//
System = Win32Native . CSIDL_SYSTEM ,
//
// Represents the file system directory that serves as a common repository for document
// templates.
//
Templates = Win32Native . CSIDL_TEMPLATES ,
//
// Represents the file system directory used to physically store file objects on the desktop.
// This should not be confused with the desktop folder itself, which is
// a virtual folder.
//
DesktopDirectory = Win32Native . CSIDL_DESKTOPDIRECTORY ,
//
// Represents the file system directory that serves as a common repository for documents.
//
Personal = Win32Native . CSIDL_PERSONAL ,
//
// "MyDocuments" is a better name than "Personal"
//
MyDocuments = Win32Native . CSIDL_PERSONAL ,
//
// Represents the program files folder.
//
ProgramFiles = Win32Native . CSIDL_PROGRAM_FILES ,
//
// Represents the folder for components that are shared across applications.
//
CommonProgramFiles = Win32Native . CSIDL_PROGRAM_FILES_COMMON ,
#if ! FEATURE_CORECLR
//
// <user name>\Start Menu\Programs\Administrative Tools
//
AdminTools = Win32Native . CSIDL_ADMINTOOLS ,
//
// USERPROFILE\Local Settings\Application Data\Microsoft\CD Burning
//
CDBurning = Win32Native . CSIDL_CDBURN_AREA ,
//
// All Users\Start Menu\Programs\Administrative Tools
//
CommonAdminTools = Win32Native . CSIDL_COMMON_ADMINTOOLS ,
//
// All Users\Documents
//
CommonDocuments = Win32Native . CSIDL_COMMON_DOCUMENTS ,
//
// All Users\My Music
//
CommonMusic = Win32Native . CSIDL_COMMON_MUSIC ,
//
// Links to All Users OEM specific apps
//
CommonOemLinks = Win32Native . CSIDL_COMMON_OEM_LINKS ,
//
// All Users\My Pictures
//
CommonPictures = Win32Native . CSIDL_COMMON_PICTURES ,
//
// All Users\Start Menu
//
CommonStartMenu = Win32Native . CSIDL_COMMON_STARTMENU ,
//
// All Users\Start Menu\Programs
//
CommonPrograms = Win32Native . CSIDL_COMMON_PROGRAMS ,
//
// All Users\Startup
//
CommonStartup = Win32Native . CSIDL_COMMON_STARTUP ,
//
// All Users\Desktop
//
CommonDesktopDirectory = Win32Native . CSIDL_COMMON_DESKTOPDIRECTORY ,
//
// All Users\Templates
//
CommonTemplates = Win32Native . CSIDL_COMMON_TEMPLATES ,
//
// All Users\My Video
//
CommonVideos = Win32Native . CSIDL_COMMON_VIDEO ,
//
// windows\fonts
//
Fonts = Win32Native . CSIDL_FONTS ,
//
// %APPDATA%\Microsoft\Windows\Network Shortcuts
//
NetworkShortcuts = Win32Native . CSIDL_NETHOOD ,
//
// %APPDATA%\Microsoft\Windows\Printer Shortcuts
//
PrinterShortcuts = Win32Native . CSIDL_PRINTHOOD ,
//
// USERPROFILE
//
UserProfile = Win32Native . CSIDL_PROFILE ,
//
// x86 Program Files\Common on RISC
//
CommonProgramFilesX86 = Win32Native . CSIDL_PROGRAM_FILES_COMMONX86 ,
//
// x86 C:\Program Files on RISC
//
ProgramFilesX86 = Win32Native . CSIDL_PROGRAM_FILESX86 ,
//
// Resource Directory
//
Resources = Win32Native . CSIDL_RESOURCES ,
//
// Localized Resource Directory
//
LocalizedResources = Win32Native . CSIDL_RESOURCES_LOCALIZED ,
//
// %windir%\System32 or %windir%\syswow64
//
SystemX86 = Win32Native . CSIDL_SYSTEMX86 ,
//
// GetWindowsDirectory()
//
Windows = Win32Native . CSIDL_WINDOWS ,
#endif // !FEATURE_CORECLR
}
public static int CurrentManagedThreadId
{
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
get
{
return Thread . CurrentThread . ManagedThreadId ;
}
}
}
}
