//------------------------------------------------------------------------------

// <copyright file="HttpRuntime.cs" company="Microsoft">

// Copyright (c) Microsoft Corporation. All rights reserved.

// </copyright>

//------------------------------------------------------------------------------

/*

* The ASP.NET runtime services

*

* Copyright (c) 1998 Microsoft Corporation

*/

namespace System.Web

{

using System;

using System.Collections;

using System.Collections.Generic;

using System.Collections.Concurrent;

using System.Configuration;

using System.Data;

using System.Data.Common;

using System.Diagnostics.CodeAnalysis;

using System.Globalization;

using System.IO;

using System.Net;

using System.Reflection;

using System.Resources;

using System.Runtime;

using System.Web.Hosting;

#if NETCOREAPP

using System.Runtime.Loader;

#endif

using System.Runtime.InteropServices;

using System.Runtime.Remoting.Messaging;

using System.Security;

using System.Security.Cryptography;

using System.Security.Permissions;

using System.Security.Policy;

using System.Security.Principal;

using System.Text;

using System.Threading;

using System.Web;

using System.Web.Caching;

using System.Web.Compilation;

using System.Web.Configuration;

using System.Web.Management;

using System.Web.Security;

using System.Web.UI;

using System.Web.Util;

using System.Xml;

using Microsoft.Win32;

/// <devdoc>

/// <para>Provides a set of ASP.NET runtime services.</para>

/// </devdoc>

public sealed class HttpRuntime

{

internal const string codegenDirName = "Temporary_ASP.NET_Files";

internal const string profileFileName = "profileoptimization.prof";

private static HttpRuntime _theRuntime; // single instance of the class

internal static byte[] s_autogenKeys = new byte[1024];

//

// Names of special ASP.NET directories

//

internal const string BinDirectoryName = "bin";

internal static string BinDotnetDirectoryName => Path.GetFileName(AppDomain.CurrentDomain.BaseDirectory);

internal const string CodeDirectoryName = "App_Code";

internal const string WebRefDirectoryName = "App_WebReferences";

internal const string ResourcesDirectoryName = "App_GlobalResources";

internal const string LocalResourcesDirectoryName = "App_LocalResources";

internal const string DataDirectoryName = "App_Data";

internal const string ThemesDirectoryName = "App_Themes";

internal const string GlobalThemesDirectoryName = "Themes";

internal const string BrowsersDirectoryName = "App_Browsers";

private static string DirectorySeparatorString = new string(Path.DirectorySeparatorChar, 1);

private static string DoubleDirectorySeparatorString = new string(Path.DirectorySeparatorChar, 2);

private static char[] s_InvalidPhysicalPathChars = { '/', '?', '*', '<', '>', '|', '"' };

#if OLD

// For s_forbiddenDirs and s_forbiddenDirsConstant, see

// ndll.h, and RestrictIISFolders in regiis.cxx

internal static string[] s_forbiddenDirs = {

BinDirectoryName,

CodeDirectoryName,

DataDirectoryName,

ResourcesDirectoryName,

WebRefDirectoryName,

};

internal static Int32[] s_forbiddenDirsConstant = {

UnsafeNativeMethods.RESTRICT_BIN,

UnsafeNativeMethods.RESTRICT_CODE,

UnsafeNativeMethods.RESTRICT_DATA,

UnsafeNativeMethods.RESTRICT_RESOURCES,

UnsafeNativeMethods.RESTRICT_WEBREFERENCES,

};

#endif

static HttpRuntime()

{

AddAppDomainTraceMessage("*HttpRuntime::cctor");

StaticInit();

_theRuntime = new HttpRuntime();

_theRuntime.Init();

AddAppDomainTraceMessage("HttpRuntime::cctor*");

}

[SecurityPermission(SecurityAction.LinkDemand, Unrestricted = true)]

public HttpRuntime()

{

}

//

// static initialization to get hooked up to the unmanaged code

// get installation directory, etc.

//

private static bool s_initialized = false;

private static String s_installDirectory;

private static bool s_isEngineLoaded = false;

// Force the static initialization of this class.

internal static void ForceStaticInit() { }

private static void StaticInit()

{

if (s_initialized)

{

// already initialized

return;

}

bool isEngineLoaded = false;

bool wasEngineLoadedHere = false;

String installDir = null;

// load webengine.dll if it is not loaded already

#if !WebFormsForCore && !FEATURE_PAL // FEATURE_PAL does not enable IIS-based hosting features

installDir = RuntimeEnvironment.GetRuntimeDirectory();

if (UnsafeNativeMethods.GetModuleHandle(ModName.ENGINE_FULL_NAME) != IntPtr.Zero)

{

isEngineLoaded = true;

}

// Load webengine.dll if not loaded already

if (!isEngineLoaded)

{

String fullPath = installDir + Path.DirectorySeparatorChar + ModName.ENGINE_FULL_NAME;

if (UnsafeNativeMethods.LoadLibrary(fullPath) != IntPtr.Zero)

{

isEngineLoaded = true;

wasEngineLoadedHere = true;

}

}

if (isEngineLoaded)

{

UnsafeNativeMethods.InitializeLibrary(false);

if (wasEngineLoadedHere)

{

UnsafeNativeMethods.PerfCounterInitialize();

}

}

#else // !FEATURE_PAL

string p = typeof(object).Module.FullyQualifiedName;

installDir = Path.GetDirectoryName(p);

#endif // !FEATURE_PAL

s_installDirectory = installDir;

s_isEngineLoaded = isEngineLoaded;

s_initialized = true;

PopulateIISVersionInformation();

AddAppDomainTraceMessage("Initialize");

}

//

// Runtime services

//

private NamedPermissionSet _namedPermissionSet;

private PolicyLevel _policyLevel;

private string _hostSecurityPolicyResolverType = null;

private FileChangesMonitor _fcm;

private Cache _cachePublic;

private bool _isOnUNCShare;

private Profiler _profiler;

private RequestTimeoutManager _timeoutManager;

private RequestQueue _requestQueue;

private bool _apartmentThreading;

private bool _processRequestInApplicationTrust;

private bool _disableProcessRequestInApplicationTrust;

private bool _isLegacyCas;

//

// Counters

//

private bool _beforeFirstRequest = true;

private DateTime _firstRequestStartTime;

private bool _firstRequestCompleted;

private bool _userForcedShutdown;

private bool _configInited;

private bool _fusionInited;

private int _activeRequestCount;

private volatile bool _disposingHttpRuntime;

private DateTime _lastShutdownAttemptTime;

private bool _shutdownInProgress;

private String _shutDownStack;

private String _shutDownMessage;

private ApplicationShutdownReason _shutdownReason = ApplicationShutdownReason.None;

private string _trustLevel;

private string _wpUserId;

private bool _shutdownWebEventRaised;

//

// Header Newlines

//

private bool _enableHeaderChecking;

//

// Callbacks

//

private AsyncCallback _requestNotificationCompletionCallback;

private AsyncCallback _handlerCompletionCallback;

private HttpWorkerRequest.EndOfSendNotification _asyncEndOfSendCallback;

private WaitCallback _appDomainUnloadCallback;

//

// Initialization error (to be reported on subsequent requests)

//

private Exception _initializationError;

private bool _hostingInitFailed; // make such errors non-sticky

private Timer _appDomainShutdownTimer = null;

//

// App domain related

//

private String _tempDir;

private String _codegenDir;

private String _appDomainAppId;

private String _appDomainAppPath;

private VirtualPath _appDomainAppVPath;

private String _appDomainId;

//

// Debugging support

//

private bool _debuggingEnabled = false;

//

// App_Offline.htm support

//

private const string AppOfflineFileName = "App_Offline.htm";

private const long MaxAppOfflineFileLength = 1024 * 1024;

private byte[] _appOfflineMessage;

//

// Client script support

//

private const string AspNetClientFilesSubDirectory = "asp.netclientfiles";

private const string AspNetClientFilesParentVirtualPath = "/aspnet_client/system_web/";

private string _clientScriptVirtualPath;

private string _clientScriptPhysicalPath;

//

// IIS version and whether we're using the integrated pipeline

//

private static Version _iisVersion;

private static bool _useIntegratedPipeline = true;

//

// Prefetch

//

private static bool _enablePrefetchOptimization;

/////////////////////////////////////////////////////////////////////////

// 3 steps of initialization:

// Init() is called from HttpRuntime cctor

// HostingInit() is called by the Hosting Environment

// FirstRequestInit() is called on first HTTP request

//

/*

* Context-less initialization (on app domain creation)

*/

private void Init()

{

try

{

#if NETFRAMEWORK && !FEATURE_PAL

if (Environment.OSVersion.Platform != PlatformID.Win32NT)

throw new PlatformNotSupportedException(SR.GetString(SR.RequiresNT));

#else // !FEATURE_PAL

// ROTORTODO

// Do nothing: FEATURE_PAL environment will always support ASP.NET hosting

#endif // !FEATURE_PAL

_profiler = new Profiler();

_timeoutManager = new RequestTimeoutManager();

_wpUserId = GetCurrentUserName();

_requestNotificationCompletionCallback = new AsyncCallback(this.OnRequestNotificationCompletion);

_handlerCompletionCallback = new AsyncCallback(this.OnHandlerCompletion);

_asyncEndOfSendCallback = new HttpWorkerRequest.EndOfSendNotification(this.EndOfSendCallback);

_appDomainUnloadCallback = new WaitCallback(this.ReleaseResourcesAndUnloadAppDomain);

// appdomain values

if (GetAppDomainString(".appDomain") != null)

{

Debug.Assert(HostingEnvironment.IsHosted);

_appDomainAppId = GetAppDomainString(".appId");

_appDomainAppPath = GetAppDomainString(".appPath");

_appDomainAppVPath = VirtualPath.CreateNonRelativeTrailingSlash(GetAppDomainString(".appVPath"));

_appDomainId = GetAppDomainString(".domainId");

_isOnUNCShare = StringUtil.StringStartsWith(_appDomainAppPath, "\\\\");

// init perf counters for this appdomain

PerfCounters.Open(_appDomainAppId);

}

else

{

Debug.Assert(!HostingEnvironment.IsHosted);

}

// _appDomainAppPath should be set before file change notifications are initialized

// DevDiv 248126: Check httpRuntime fcnMode first before we use the registry key

_fcm = new FileChangesMonitor(HostingEnvironment.FcnMode);

}

catch (Exception e)

{

// remember static initalization error

InitializationException = e;

}

}

private void SetUpDataDirectory()

{

// Set the DataDirectory (see VSWhidbey 226834) with permission (DevDiv 29614)

string dataDirectory = Path.Combine(_appDomainAppPath, DataDirectoryName);

#if NETFRAMEWORK

AppDomain.CurrentDomain.SetData("DataDirectory", dataDirectory,

new FileIOPermission(FileIOPermissionAccess.PathDiscovery, dataDirectory));

#else

ApplicationManager.SetLoadContextData("DataDirectory", dataDirectory);

#endif

}

private void DisposeAppDomainShutdownTimer() {

Timer timer = _appDomainShutdownTimer;

if (timer != null && Interlocked.CompareExchange(ref _appDomainShutdownTimer, null, timer) == timer) {

timer.Dispose();

}

}

private void AppDomainShutdownTimerCallback(Object state) {

try {

DisposeAppDomainShutdownTimer();

ShutdownAppDomain(ApplicationShutdownReason.InitializationError, "Initialization Error");

}

catch { } // ignore exceptions

}

/*

* Restart the AppDomain in 10 seconds

*/

private void StartAppDomainShutdownTimer() {

if (_appDomainShutdownTimer == null && !_shutdownInProgress) {

lock (this) {

if (_appDomainShutdownTimer == null && !_shutdownInProgress) {

_appDomainShutdownTimer = new Timer(

new TimerCallback(this.AppDomainShutdownTimerCallback),

null,

10 * 1000,

0);

}

}

}

}

/*

* Initialization from HostingEnvironment of HTTP independent features

*/

private void HostingInit(HostingEnvironmentFlags hostingFlags, PolicyLevel policyLevel, Exception appDomainCreationException) {

using (new ApplicationImpersonationContext()) {

try {

// To ignore FCN during initialization

_firstRequestStartTime = DateTime.UtcNow;

SetUpDataDirectory();

// Throw an exception about lack of access to app directory early on

EnsureAccessToApplicationDirectory();

// Monitor renames to directories we are watching, and notifications on the bin directory

//

// Note that this must be the first monitoring that we do of the application directory.

// There is a bug in Windows 2000 Server where notifications on UNC shares do not

// happen correctly if:

// 1. the directory is monitored for regular notifications

// 2. the directory is then monitored for directory renames

// 3. the directory is monitored again for regular notifications

StartMonitoringDirectoryRenamesAndBinDirectory();

// Initialize ObjectCacheHost before config is read, since config relies on the cache

if (InitializationException == null) {

HostingEnvironment.InitializeObjectCacheHost();

}

//

// Get the configuration needed to minimally initialize

// the components required for a complete configuration system,

// especially SetTrustLevel.

//

// We want to do this before calling SetUpCodegenDirectory(),

// to remove the risk of the config system loading

// codegen assemblies in full trust (VSWhidbey 460506)

//

CacheSection cacheSection;

TrustSection trustSection;

SecurityPolicySection securityPolicySection;

CompilationSection compilationSection;

HostingEnvironmentSection hostingEnvironmentSection;

Exception configInitException;

GetInitConfigSections(

out cacheSection,

out trustSection,

out securityPolicySection,

out compilationSection,

out hostingEnvironmentSection,

out configInitException);

// Once the configuration system is initialized, we can read

// the cache configuration settings.

//

// Note that we must do this after we start monitoring directory renames,

// as reading config will cause file monitoring on the application directory

// to occur.

// Set up the codegen directory for the app. This needs to be done before we process

// the policy file, because it needs to replace the $CodeGen$ token.

SetUpCodegenDirectory(compilationSection);

if(compilationSection != null) {

_enablePrefetchOptimization = compilationSection.EnablePrefetchOptimization;

if(_enablePrefetchOptimization) {

#if NETFRAMEWORK

UnsafeNativeMethods.StartPrefetchActivity((uint)StringUtil.GetStringHashCode(_appDomainAppId));

#else

throw new NotSupportedException("Prefetch optimization not supported in WebFormsForCore.");

#endif

}

}

// NOTE: after calling SetUpCodegenDirectory(), and until we call SetTrustLevel(), we are at

// risk of codegen assemblies being loaded in full trust. No code that might cause

// assembly loading should be added here! This is only valid if the legacyCasModel is set

// to true in <trust> section.

// Throw the original configuration exception from ApplicationManager if configuration is broken.

if (appDomainCreationException != null) {

throw appDomainCreationException;

}

if (trustSection == null || String.IsNullOrEmpty(trustSection.Level)) {

throw new ConfigurationErrorsException(SR.GetString(SR.Config_section_not_present, "trust"));

}

if (trustSection.LegacyCasModel) {

try {

_disableProcessRequestInApplicationTrust = false;

_isLegacyCas = true;

// Set code access policy on the app domain

SetTrustLevel(trustSection, securityPolicySection);

}

catch {

// throw the original config exception if it exists

if (configInitException != null)

throw configInitException;

throw;

}

}

else if ((hostingFlags & HostingEnvironmentFlags.ClientBuildManager) != 0) {

_trustLevel = "Full";

}

else {

_disableProcessRequestInApplicationTrust = true;

// Set code access policy properties of the runtime object

SetTrustParameters(trustSection, securityPolicySection, policyLevel);

}

// Configure fusion to use directories set in the app config

InitFusion(hostingEnvironmentSection);

// set the sliding expiration for URL metadata

CachedPathData.InitializeUrlMetadataSlidingExpiration(hostingEnvironmentSection);

// Complete initialization of configuration.

// Note that this needs to be called after SetTrustLevel,

// as it indicates that we have the permission set needed

// to correctly run configuration section handlers.

// As little config should be read before CompleteInit() as possible.

// No section that runs before CompleteInit() should demand permissions,

// as the permissions set has not yet determined until SetTrustLevel()

// is called.

HttpConfigurationSystem.CompleteInit();

//

// If an exception occurred loading configuration,

// we are now ready to handle exception processing

// with the correct trust level set.

//

if (configInitException != null) {

throw configInitException;

}

SetThreadPoolLimits();

SetAutogenKeys();

// Initialize the build manager

BuildManager.InitializeBuildManager();

if(compilationSection != null && compilationSection.ProfileGuidedOptimizations == ProfileGuidedOptimizationsFlags.All) {

ProfileOptimization.SetProfileRoot(_codegenDir);

ProfileOptimization.StartProfile(profileFileName);

}

// Determine apartment threading setting

InitApartmentThreading();

// Init debugging

InitDebuggingSupport();

_processRequestInApplicationTrust = trustSection.ProcessRequestInApplicationTrust;

// Init AppDomain Resource Perf Counters

AppDomainResourcePerfCounters.Init();

RelaxMapPathIfRequired();

}

catch (Exception e) {

_hostingInitFailed = true;

InitializationException = e;

Debug.Trace("AppDomainFactory", "HostingInit failed. " + e.ToString());

if ((hostingFlags & HostingEnvironmentFlags.ThrowHostingInitErrors) != 0)

throw;

}

}

}

internal static Exception InitializationException {

get {

return _theRuntime._initializationError;

}

// The exception is "cached" for 10 seconds, then the AppDomain is restarted.

set {

_theRuntime._initializationError = value;

// In v2.0, we shutdown immediately if hostingInitFailed...so we don't need the timer

if (!HostingInitFailed) {

_theRuntime.StartAppDomainShutdownTimer();

}

}

}

internal static bool HostingInitFailed {

get {

return _theRuntime._hostingInitFailed;

}

}

internal static void InitializeHostingFeatures(HostingEnvironmentFlags hostingFlags, PolicyLevel policyLevel, Exception appDomainCreationException) {

_theRuntime.HostingInit(hostingFlags, policyLevel, appDomainCreationException);

}

internal static bool EnableHeaderChecking {

get {

return _theRuntime._enableHeaderChecking;

}

}

internal static bool ProcessRequestInApplicationTrust {

get {

return _theRuntime._processRequestInApplicationTrust;

}

}

internal static bool DisableProcessRequestInApplicationTrust {

get {

return _theRuntime._disableProcessRequestInApplicationTrust;

}

}

internal static bool IsLegacyCas {

get {

return _theRuntime._isLegacyCas;

}

}

internal static byte[] AppOfflineMessage {

get {

return _theRuntime._appOfflineMessage;

}

}

/*

* Initialization on first request (context available)

*/

private void FirstRequestInit(HttpContext context) {

Exception error = null;

if (InitializationException == null && _appDomainId != null) {

#if DBG

HttpContext.SetDebugAssertOnAccessToCurrent(true);

#endif

try {

using (new ApplicationImpersonationContext()) {

// Is this necessary? See InitHttpConfiguration

CultureInfo savedCulture = Thread.CurrentThread.CurrentCulture;

CultureInfo savedUICulture = Thread.CurrentThread.CurrentUICulture;

try {

// Ensure config system is initialized

InitHttpConfiguration(); // be sure config system is set

// Check if applicaton is enabled

CheckApplicationEnabled();

// Check access to temp compilation directory (under hosting identity)

CheckAccessToTempDirectory();

// Initialize health monitoring

InitializeHealthMonitoring();

// Init request queue (after reading config)

InitRequestQueue();

// configure the profiler according to config

InitTrace(context);

// Start heatbeat for Web Event Health Monitoring

HealthMonitoringManager.StartHealthMonitoringHeartbeat();

// Remove read and browse access of the bin directory

RestrictIISFolders(context);

// Preload all assemblies from bin (only if required). ASURT 114486

PreloadAssembliesFromBin();

// Decide whether or not to encode headers. VsWhidbey 257154

InitHeaderEncoding();

// Force the current encoder + validator to load so that there's a deterministic

// place (here) for an exception to occur if there's a load error

HttpEncoder.InitializeOnFirstRequest();

RequestValidator.InitializeOnFirstRequest();

if (context.WorkerRequest is ISAPIWorkerRequestOutOfProc) {

// Make sure that the <processModel> section has no errors

ProcessModelSection processModel = RuntimeConfig.GetMachineConfig().ProcessModel;

}

// Throw after ResponseEnd

HttpResponse.RethrowIfResponseEnd(() => context?.Response);

}

catch (ThreadAbortException e)

{

throw;

}

finally

{

Thread.CurrentThread.CurrentUICulture = savedUICulture;

SetCurrentThreadCultureWithAssert(savedCulture);

}

}

}

catch (ThreadAbortException e)

{

throw;

}

catch (ConfigurationException e) {

error = e;

}

catch (Exception e) {

// remember second-phase initialization error

error = new HttpException(SR.GetString(SR.XSP_init_error, e.Message), e);

}

finally {

#if DBG

HttpContext.SetDebugAssertOnAccessToCurrent(false);

#endif

}

}

if (InitializationException != null) {

// throw cached exception. We need to wrap it in a new exception, otherwise

// we lose the original stack.

throw new HttpException(InitializationException.Message, InitializationException);

}

else if (error != null) {

InitializationException = error;

// throw new exception

throw error;

}

AddAppDomainTraceMessage("FirstRequestInit");

}

[SecurityPermission(SecurityAction.Assert, ControlThread = true)]

internal static void SetCurrentThreadCultureWithAssert(CultureInfo cultureInfo) {

Thread.CurrentThread.CurrentCulture = cultureInfo;

}

private void EnsureFirstRequestInit(HttpContext context) {

if (_beforeFirstRequest) {

lock (this) {

if (_beforeFirstRequest) {

_firstRequestStartTime = DateTime.UtcNow;

FirstRequestInit(context);

_beforeFirstRequest = false;

context.FirstRequest = true;

}

}

}

}

private void EnsureAccessToApplicationDirectory() {

if (!FileUtil.DirectoryAccessible(_appDomainAppPath)) {

//

if (_appDomainAppPath.IndexOf('?') >= 0) {

// Possible Unicode when not supported

throw new HttpException(SR.GetString(SR.Access_denied_to_unicode_app_dir, _appDomainAppPath));

}

else {

throw new HttpException(SR.GetString(SR.Access_denied_to_app_dir, _appDomainAppPath));

}

}

}

private void StartMonitoringDirectoryRenamesAndBinDirectory() {

if (OSInfo.IsWindows) _fcm.StartMonitoringDirectoryRenamesAndBinDirectory(AppDomainAppPathInternal, new FileChangeEventHandler(this.OnCriticalDirectoryChange));

}

//

// Monitor a local resources subdirectory and unload appdomain when it changes

//

internal static void StartListeningToLocalResourcesDirectory(VirtualPath virtualDir) {

#if !FEATURE_PAL // FEATURE_PAL does not enable file change notification

if (OSInfo.IsWindows) _theRuntime._fcm.StartListeningToLocalResourcesDirectory(virtualDir);

#endif // !FEATURE_PAL

}

//

// Get the configuration needed to minimally initialize

// the components required for a complete configuration system,

//

// Note that if the application configuration file has an error,

// AppLKGConfig will still retreive any valid configuration from

// that file, or from location directives that apply to the

// application path. This implies that an administrator can

// lock down an application's trust level in root web.config,

// and it will still take effect if the application's web.config

// has errors.

//

private void GetInitConfigSections(

out CacheSection cacheSection,

out TrustSection trustSection,

out SecurityPolicySection securityPolicySection,

out CompilationSection compilationSection,

out HostingEnvironmentSection hostingEnvironmentSection,

out Exception initException) {

cacheSection = null;

trustSection = null;

securityPolicySection = null;

compilationSection = null;

hostingEnvironmentSection = null;

initException = null;

// AppLKGConfig is guaranteed to not throw an exception.

RuntimeConfig appLKGConfig = RuntimeConfig.GetAppLKGConfig();

// AppConfig may throw an exception.

RuntimeConfig appConfig = null;

try {

appConfig = RuntimeConfig.GetAppConfig();

}

catch (Exception e) {

initException = e;

}

// Cache section

if (appConfig != null) {

try {

cacheSection = appConfig.Cache;

}

catch (Exception e) {

if (initException == null) {

initException = e;

}

}

}

if (cacheSection == null) {

cacheSection = appLKGConfig.Cache;

}

// Trust section

if (appConfig != null) {

try {

trustSection = appConfig.Trust;

}

catch (Exception e) {

if (initException == null) {

initException = e;

}

}

}

if (trustSection == null) {

trustSection = appLKGConfig.Trust;

}

// SecurityPolicy section

if (appConfig != null) {

try {

securityPolicySection = appConfig.SecurityPolicy;

}

catch (Exception e) {

if (initException == null) {

initException = e;

}

}

}

if (securityPolicySection == null) {

securityPolicySection = appLKGConfig.SecurityPolicy;

}

// Compilation section

if (appConfig != null) {

try {

compilationSection = appConfig.Compilation;

}

catch (Exception e) {

if (initException == null) {

initException = e;

}

}

}

if (compilationSection == null) {

compilationSection = appLKGConfig.Compilation;

}

// HostingEnvironment section

if (appConfig != null) {

try {

hostingEnvironmentSection = appConfig.HostingEnvironment;

}

catch (Exception e) {

if (initException == null) {

initException = e;

}

}

}

if (hostingEnvironmentSection == null) {

hostingEnvironmentSection = appLKGConfig.HostingEnvironment;

}

}

[DllImport("libc")]

static extern uint geteuid();

public static string UserId => OSInfo.IsWindows ? Environment.UserName : geteuid().ToString();

// Set up the codegen directory for the app

[SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands", Justification = "This call site is trusted.")]

private void SetUpCodegenDirectory(CompilationSection compilationSection) {

AppDomain appDomain = Thread.GetDomain();

string codegenBase;

// devdiv 1038337. Passing the corresponding IsDevelopmentEnvironment flag to ConstructSimpleAppName

string simpleAppName = System.Web.Hosting.AppManagerAppDomainFactory.ConstructSimpleAppName(

AppDomainAppVirtualPath, HostingEnvironment.IsDevelopmentEnvironment);

string tempDirectory = null;

// These variables are used for error handling

string tempDirAttribName = null;

string configFileName = null;

int configLineNumber = 0;

if (compilationSection != null && !String.IsNullOrEmpty(compilationSection.TempDirectory)) {

tempDirectory = compilationSection.TempDirectory;

compilationSection.GetTempDirectoryErrorInfo(out tempDirAttribName,

out configFileName, out configLineNumber);

}

if (tempDirectory != null) {

tempDirectory = tempDirectory.Trim();

if (!Path.IsPathRooted(tempDirectory)) {

// Make sure the path is not relative (VSWhidbey 260075)

tempDirectory = null;

}

else {

try {

// Canonicalize it to avoid problems with spaces (VSWhidbey 229873)

tempDirectory = new DirectoryInfo(tempDirectory).FullName;

}

catch {

tempDirectory = null;

}

}

if (tempDirectory == null) {

throw new ConfigurationErrorsException(

SR.GetString(SR.Invalid_temp_directory, tempDirAttribName),

configFileName, configLineNumber);

}

#if FEATURE_PAL

} else {

System.UInt32 length = 0;

StringBuilder sb = null;

bool bRet;

// Get the required length

bRet = UnsafeNativeMethods.GetUserTempDirectory(

UnsafeNativeMethods.DeploymentDirectoryType.ddtInstallationDependentDirectory,

null, ref length);

if (true == bRet) {

// now, allocate the string

sb = new StringBuilder ((int)length);

// call again to get the value

bRet = UnsafeNativeMethods.GetUserTempDirectory(

UnsafeNativeMethods.DeploymentDirectoryType.ddtInstallationDependentDirectory,

sb, ref length);

}

if (false == bRet) {

throw new ConfigurationException(

HttpRuntime.FormatResourceString(SR.Invalid_temp_directory, tempDirAttribName));

}

tempDirectory = Path.Combine(sb.ToString(), codegenDirName);

}

// Always try to create the ASP.Net temp directory for FEATURE_PAL

#endif // FEATURE_PAL

// Create the config-specified directory if needed

try {

Directory.CreateDirectory(tempDirectory);

}

catch (Exception e) {

throw new ConfigurationErrorsException(

SR.GetString(SR.Invalid_temp_directory, tempDirAttribName),

e,

configFileName, configLineNumber);