Files
mono/mcs/class/referencesource/System.Web/State/SessionStateModule.cs
T
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

1461 lines
62 KiB
C#

//------------------------------------------------------------------------------
// <copyright file="SessionStateModule.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
/*
* SessionStateModule
*
* Copyright (c) 1998-2002, Microsoft Corporation
*
*/
namespace System.Web.SessionState {
using System;
using System.Threading;
using System.Collections;
using System.Configuration;
using System.IO;
using System.Web.Caching;
using System.Web.Util;
using System.Web.Configuration;
using System.Xml;
using System.Security.Cryptography;
using System.Data.SqlClient;
using System.Globalization;
using System.Security.Permissions;
using System.Text;
using System.Web.Hosting;
using System.Web.Management;
using Microsoft.Win32;
public delegate void SessionStateItemExpireCallback(
string id, SessionStateStoreData item);
class SessionOnEndTargetWorkItem {
SessionOnEndTarget _target;
HttpSessionState _sessionState;
internal SessionOnEndTargetWorkItem(SessionOnEndTarget target, HttpSessionState sessionState) {
_target = target;
_sessionState = sessionState;
}
internal void RaiseOnEndCallback() {
_target.RaiseOnEnd(_sessionState);
}
}
/*
* Calls the OnSessionEnd event. We use an object other than the SessionStateModule
* because the state of the module is unknown - it could have been disposed
* when a session ends.
*/
class SessionOnEndTarget {
internal int _sessionEndEventHandlerCount;
internal SessionOnEndTarget() {
}
internal int SessionEndEventHandlerCount {
get {
return _sessionEndEventHandlerCount;
}
set {
_sessionEndEventHandlerCount = value;
}
}
internal void RaiseOnEnd(HttpSessionState sessionState) {
Debug.Trace("SessionOnEnd", "Firing OnSessionEnd for " + sessionState.SessionID);
if (_sessionEndEventHandlerCount > 0) {
HttpApplicationFactory.EndSession(sessionState, this, EventArgs.Empty);
}
}
internal void RaiseSessionOnEnd(String id, SessionStateStoreData item) {
HttpSessionStateContainer sessionStateContainer = new HttpSessionStateContainer(
id,
item.Items,
item.StaticObjects,
item.Timeout,
false,
SessionStateModule.s_configCookieless,
SessionStateModule.s_configMode,
true);
HttpSessionState sessionState = new HttpSessionState(sessionStateContainer);
if (HttpRuntime.ShutdownInProgress) {
// call directly when shutting down
RaiseOnEnd(sessionState);
}
else {
// post via thread pool
SessionOnEndTargetWorkItem workItem = new SessionOnEndTargetWorkItem(this, sessionState);
WorkItem.PostInternal(new WorkItemCallback(workItem.RaiseOnEndCallback));
}
}
}
/*
* The sesssion state module provides session state services
* for an application.
*/
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public sealed class SessionStateModule : IHttpModule {
internal const string SQL_CONNECTION_STRING_DEFAULT = "data source=localhost;Integrated Security=SSPI";
internal const string STATE_CONNECTION_STRING_DEFAULT = "tcpip=loopback:42424";
internal const int TIMEOUT_DEFAULT = 20;
internal const SessionStateMode MODE_DEFAULT = SessionStateMode.InProc;
private static long LOCKED_ITEM_POLLING_INTERVAL = 500; // in milliseconds
static readonly TimeSpan LOCKED_ITEM_POLLING_DELTA = new TimeSpan(250 * TimeSpan.TicksPerMillisecond);
static readonly TimeSpan DEFAULT_DBG_EXECUTION_TIMEOUT = new TimeSpan(0, 0, System.Web.Compilation.PageCodeDomTreeGenerator.DebugScriptTimeout);
// When we are using Cache to store session state (InProc and StateServer),
// can't specify a timeout value larger than 1 year because CacheEntry ctor
// will throw an exception.
internal const int MAX_CACHE_BASED_TIMEOUT_MINUTES = 365 * 24 * 60;
bool s_oneTimeInit;
static int s_timeout;
#pragma warning disable 0649
static ReadWriteSpinLock s_lock;
#pragma warning restore 0649
static bool s_trustLevelInsufficient;
static TimeSpan s_configExecutionTimeout;
static bool s_configRegenerateExpiredSessionId;
static bool s_useHostingIdentity;
internal static HttpCookieMode s_configCookieless;
internal static SessionStateMode s_configMode;
// This is used as a perf optimization for IIS7 Integrated Mode. If session state is released
// in ReleaseState, we can disable the EndRequest notification if the mode is InProc or StateServer
// because neither InProcSessionStateStore.EndRequest nor OutOfProcSessionStateStore.EndRequest
// are implemented.
static bool s_canSkipEndRequestCall;
private static bool s_PollIntervalRegLookedUp = false;
private static object s_PollIntervalRegLock = new object();
//
// Check if we can optmize for InProc case.
// Optimization details:
//
// If we are in InProc mode, and cookieless=false, in certain scenarios we
// can avoid reading the session ID from the cookies because that's an expensive operation.
// To allow that, we use s_sessionEverSet to keep track of whether we've ever created
// any session state.
//
// If no session has ever be created, we can optimize in the following two cases:
//
// Case 1: Page has disabled session state
// In BeginAcquireState, we usually read the session ID, and reset the timeout value
// of the session state. However, since no session has ever been created, we can
// skip both reading the session id and resetting the timeout.
//
// Case 2: Page has enabled session state
// In this case, we will delay reading (and creating it if not found) the session ID
// until it's really needed. (e.g. from HttpSessionStateContainer.SessionID)
//
// Please note that we optimize only if the app is using SessionIDManager
// as the session ID provider; otherwise, we do not have knowledge about
// the provider in order to optimize safely.
//
// And we will delay reading the id only if we are using cookie to store the session ID. If we
// use cookieless, in the delayed session ID creation scenario, cookieless requires a redirect,
// and it'll be bad to do that in the middle of a page execution.
//
static bool s_allowInProcOptimization;
static bool s_sessionEverSet;
//
// Another optimization is to delay the creation of a new session state store item
// until it's needed.
static bool s_allowDelayedStateStoreItemCreation;
static HttpSessionStateContainer s_delayedSessionState = new HttpSessionStateContainer();
/* per application vars */
EventHandler _sessionStartEventHandler;
Timer _timer;
TimerCallback _timerCallback;
volatile int _timerId;
ISessionIDManager _idManager;
bool _usingAspnetSessionIdManager;
SessionStateStoreProviderBase _store;
bool _supportSessionExpiry;
IPartitionResolver _partitionResolver;
bool _ignoreImpersonation;
readonly SessionOnEndTarget _onEndTarget = new SessionOnEndTarget();
/* per request data goes in _rq* variables */
bool _acquireCalled;
bool _releaseCalled;
HttpSessionStateContainer _rqSessionState;
String _rqId;
bool _rqIdNew;
ISessionStateItemCollection _rqSessionItems;
HttpStaticObjectsCollection _rqStaticObjects;
bool _rqIsNewSession;
bool _rqSessionStateNotFound;
bool _rqReadonly;
HttpContext _rqContext;
HttpAsyncResult _rqAr;
SessionStateStoreData _rqItem;
object _rqLockId; // The id of its SessionStateItem ownership
// If the ownership change hands (e.g. this ownership
// times out), the lockId of the item at the store
// will change.
int _rqInCallback;
DateTime _rqLastPollCompleted;
TimeSpan _rqExecutionTimeout;
bool _rqAddedCookie;
SessionStateActions _rqActionFlags;
ImpersonationContext _rqIctx;
internal int _rqChangeImpersonationRefCount;
ImpersonationContext _rqTimerThreadImpersonationIctx;
bool _rqSupportSessionIdReissue;
/// <devdoc>
/// <para>
/// Initializes a new instance of the <see cref='System.Web.State.SessionStateModule'/>
/// class.
/// </para>
/// </devdoc>
[SecurityPermission(SecurityAction.Demand, Unrestricted=true)]
public SessionStateModule() {
}
static bool CheckTrustLevel(SessionStateSection config) {
switch (config.Mode) {
case SessionStateMode.SQLServer:
case SessionStateMode.StateServer:
return HttpRuntime.HasAspNetHostingPermission(AspNetHostingPermissionLevel.Medium);
default:
case SessionStateMode.Off:
case SessionStateMode.InProc: // In-proc session doesn't require any trust level (part of ASURT 124513)
return true;
}
}
[AspNetHostingPermission(SecurityAction.Assert, Level=AspNetHostingPermissionLevel.Low)]
private SessionStateStoreProviderBase SecureInstantiateProvider(ProviderSettings settings) {
return (SessionStateStoreProviderBase)ProvidersHelper.InstantiateProvider(settings, typeof(SessionStateStoreProviderBase));
}
// Create an instance of the custom store as specified in the config file
SessionStateStoreProviderBase InitCustomStore(SessionStateSection config) {
string providerName = config.CustomProvider;
ProviderSettings ps;
if (String.IsNullOrEmpty(providerName)) {
throw new ConfigurationErrorsException(
SR.GetString(SR.Invalid_session_custom_provider, providerName),
config.ElementInformation.Properties["customProvider"].Source, config.ElementInformation.Properties["customProvider"].LineNumber);
}
ps = config.Providers[providerName];
if (ps == null) {
throw new ConfigurationErrorsException(
SR.GetString(SR.Missing_session_custom_provider, providerName),
config.ElementInformation.Properties["customProvider"].Source, config.ElementInformation.Properties["customProvider"].LineNumber);
}
return SecureInstantiateProvider(ps);
}
IPartitionResolver InitPartitionResolver(SessionStateSection config) {
string partitionResolverType = config.PartitionResolverType;
Type resolverType;
IPartitionResolver iResolver;
if (String.IsNullOrEmpty(partitionResolverType)) {
return null;
}
if (config.Mode != SessionStateMode.StateServer &&
config.Mode != SessionStateMode.SQLServer) {
throw new ConfigurationErrorsException(SR.GetString(SR.Cant_use_partition_resolve),
config.ElementInformation.Properties["partitionResolverType"].Source, config.ElementInformation.Properties["partitionResolverType"].LineNumber);
}
resolverType = ConfigUtil.GetType(partitionResolverType, "partitionResolverType", config);
ConfigUtil.CheckAssignableType(typeof(IPartitionResolver), resolverType, config, "partitionResolverType");
iResolver = (IPartitionResolver)HttpRuntime.CreatePublicInstance(resolverType);
iResolver.Initialize();
return iResolver;
}
ISessionIDManager InitSessionIDManager(SessionStateSection config) {
string sessionIDManagerType = config.SessionIDManagerType;
ISessionIDManager iManager;
if (String.IsNullOrEmpty(sessionIDManagerType)) {
iManager = new SessionIDManager();
_usingAspnetSessionIdManager = true;
}
else {
Type managerType;
managerType = ConfigUtil.GetType(sessionIDManagerType, "sessionIDManagerType", config);
ConfigUtil.CheckAssignableType(typeof(ISessionIDManager), managerType, config, "sessionIDManagerType");
iManager = (ISessionIDManager)HttpRuntime.CreatePublicInstance(managerType);
}
iManager.Initialize();
return iManager;
}
void InitModuleFromConfig(HttpApplication app, SessionStateSection config) {
if (config.Mode == SessionStateMode.Off) {
return;
}
app.AddOnAcquireRequestStateAsync(
new BeginEventHandler(this.BeginAcquireState),
new EndEventHandler(this.EndAcquireState));
app.ReleaseRequestState += new EventHandler(this.OnReleaseState);
app.EndRequest += new EventHandler(this.OnEndRequest);
_partitionResolver = InitPartitionResolver(config);
switch (config.Mode) {
case SessionStateMode.InProc:
if (HttpRuntime.UseIntegratedPipeline) {
s_canSkipEndRequestCall = true;
}
_store = new InProcSessionStateStore();
_store.Initialize(null, null);
break;
#if !FEATURE_PAL // FEATURE_PAL does not enable out of proc session state
case SessionStateMode.StateServer:
if (HttpRuntime.UseIntegratedPipeline) {
s_canSkipEndRequestCall = true;
}
_store = new OutOfProcSessionStateStore();
((OutOfProcSessionStateStore)_store).Initialize(null, null, _partitionResolver);
break;
case SessionStateMode.SQLServer:
_store = new SqlSessionStateStore();
((SqlSessionStateStore)_store).Initialize(null, null, _partitionResolver);
#if DBG
((SqlSessionStateStore)_store).SetModule(this);
#endif
break;
#else // !FEATURE_PAL
case SessionStateMode.StateServer:
throw new NotImplementedException("ROTORTODO");
break;
case SessionStateMode.SQLServer:
throw new NotImplementedException("ROTORTODO");
break;
#endif // !FEATURE_PAL
case SessionStateMode.Custom:
_store = InitCustomStore(config);
break;
default:
break;
}
// We depend on SessionIDManager to manage session id
_idManager = InitSessionIDManager(config);
if ((config.Mode == SessionStateMode.InProc || config.Mode == SessionStateMode.StateServer) &&
_usingAspnetSessionIdManager) {
// If we're using InProc mode or StateServer mode, and also using our own session id module,
// we know we don't care about impersonation in our all session state store read/write
// and session id read/write.
_ignoreImpersonation = true;
}
}
public void Init(HttpApplication app) {
bool initModuleCalled = false;
SessionStateSection config = RuntimeConfig.GetAppConfig().SessionState;
if (!s_oneTimeInit) {
s_lock.AcquireWriterLock();
try {
if (!s_oneTimeInit) {
InitModuleFromConfig(app, config);
initModuleCalled = true;
if (!CheckTrustLevel(config))
s_trustLevelInsufficient = true;
s_timeout = (int)config.Timeout.TotalMinutes;
s_useHostingIdentity = config.UseHostingIdentity;
// See if we can try InProc optimization. See inline doc of s_allowInProcOptimization
// for details.
if (config.Mode == SessionStateMode.InProc &&
_usingAspnetSessionIdManager) {
s_allowInProcOptimization = true;
}
if (config.Mode != SessionStateMode.Custom &&
config.Mode != SessionStateMode.Off &&
!config.RegenerateExpiredSessionId) {
s_allowDelayedStateStoreItemCreation = true;
}
s_configExecutionTimeout = RuntimeConfig.GetConfig().HttpRuntime.ExecutionTimeout;
s_configRegenerateExpiredSessionId = config.RegenerateExpiredSessionId;
s_configCookieless = config.Cookieless;
s_configMode = config.Mode;
// The last thing to set in this if-block.
s_oneTimeInit = true;
Debug.Trace("SessionStateModuleInit",
"Configuration: _mode=" + config.Mode +
";Timeout=" + config.Timeout +
";CookieMode=" + config.Cookieless +
";SqlConnectionString=" + config.SqlConnectionString +
";StateConnectionString=" + config.StateConnectionString +
";s_allowInProcOptimization=" + s_allowInProcOptimization +
";s_allowDelayedStateStoreItemCreation=" + s_allowDelayedStateStoreItemCreation);
}
}
finally {
s_lock.ReleaseWriterLock();
}
}
if (!initModuleCalled) {
InitModuleFromConfig(app, config);
}
if (s_trustLevelInsufficient) {
throw new HttpException(SR.GetString(SR.Session_state_need_higher_trust));
}
}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public void Dispose() {
if (_timer != null) {
((IDisposable)_timer).Dispose();
}
if (_store != null) {
_store.Dispose();
}
}
void ResetPerRequestFields() {
Debug.Assert(_rqIctx == null, "_rqIctx == null");
Debug.Assert(_rqChangeImpersonationRefCount == 0, "_rqChangeImpersonationRefCount == 0");
_rqSessionState = null;
_rqId = null;
_rqSessionItems = null;
_rqStaticObjects = null;
_rqIsNewSession = false;
_rqSessionStateNotFound = true;
_rqReadonly = false;
_rqItem = null;
_rqContext = null;
_rqAr = null;
_rqLockId = null;
_rqInCallback = 0;
_rqLastPollCompleted = DateTime.MinValue;
_rqExecutionTimeout = TimeSpan.Zero;
_rqAddedCookie = false;
_rqIdNew = false;
_rqActionFlags = 0;
_rqIctx = null;
_rqChangeImpersonationRefCount = 0;
_rqTimerThreadImpersonationIctx = null;
_rqSupportSessionIdReissue = false;
}
/*
* Add a OnStart event handler.
*
* @param sessionEventHandler
*/
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public event EventHandler Start {
add {
_sessionStartEventHandler += value;
}
remove {
_sessionStartEventHandler -= value;
}
}
void RaiseOnStart(EventArgs e) {
if (_sessionStartEventHandler == null)
return;
Debug.Trace("SessionStateModuleRaiseOnStart",
"Session_Start called for session id:" + _rqId);
// Session_OnStart for ASPCOMPAT pages has to be raised from an STA thread
//
if (HttpRuntime.ApartmentThreading || _rqContext.InAspCompatMode) {
#if !FEATURE_PAL // FEATURE_PAL does not enable COM
AspCompatApplicationStep.RaiseAspCompatEvent(
_rqContext,
_rqContext.ApplicationInstance,
null,
_sessionStartEventHandler,
this,
e);
#else // !FEATURE_PAL
throw new NotImplementedException ("ROTORTODO");
#endif // !FEATURE_PAL
}
else {
if (HttpContext.Current == null) {
// This can happen if it's called by a timer thread
DisposableHttpContextWrapper.SwitchContext(_rqContext);
}
_sessionStartEventHandler(this, e);
}
}
/*
* Fire the OnStart event.
*
* @param e
*/
void OnStart(EventArgs e) {
RaiseOnStart(e);
}
/*
* Add a OnEnd event handler.
*
* @param sessionEventHandler
*/
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public event EventHandler End {
add {
lock(_onEndTarget) {
if (_store != null && _onEndTarget.SessionEndEventHandlerCount == 0) {
_supportSessionExpiry = _store.SetItemExpireCallback(
new SessionStateItemExpireCallback(_onEndTarget.RaiseSessionOnEnd));
}
++_onEndTarget.SessionEndEventHandlerCount;
}
}
remove {
lock(_onEndTarget) {
--_onEndTarget.SessionEndEventHandlerCount;
//
if (_store != null && _onEndTarget.SessionEndEventHandlerCount == 0) {
_store.SetItemExpireCallback(null);
_supportSessionExpiry = false;
}
}
}
}
/*
* Acquire session state
*/
IAsyncResult BeginAcquireState(Object source, EventArgs e, AsyncCallback cb, Object extraData) {
bool requiresState;
bool isCompleted = true;
bool skipReadingId = false;
Debug.Trace("SessionStateModuleOnAcquireState", "Beginning SessionStateModule::OnAcquireState");
_acquireCalled = true;
_releaseCalled = false;
ResetPerRequestFields();
_rqContext = ((HttpApplication)source).Context;
_rqAr = new HttpAsyncResult(cb, extraData);
ChangeImpersonation(_rqContext, false);
try {
if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Information, EtwTraceFlags.AppSvc)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_SESSION_DATA_BEGIN, _rqContext.WorkerRequest);
/* Notify the store we are beginning to get process request */
_store.InitializeRequest(_rqContext);
/* determine if the request requires state at all */
requiresState = _rqContext.RequiresSessionState;
// SessionIDManager may need to do a redirect if cookieless setting is AutoDetect
if (_idManager.InitializeRequest(_rqContext, false, out _rqSupportSessionIdReissue)) {
_rqAr.Complete(true, null, null);
if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Information, EtwTraceFlags.AppSvc)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_SESSION_DATA_END, _rqContext.WorkerRequest);
return _rqAr;
}
// See if we can skip reading the session id. See inline doc of s_allowInProcOptimization
// for details.
if (s_allowInProcOptimization &&
!s_sessionEverSet &&
(!requiresState || // Case 1
!((SessionIDManager)_idManager).UseCookieless(_rqContext)) ) { // Case 2
skipReadingId = true;
#if DBG
if (!requiresState) {
// Case 1
Debug.Trace("SessionStateModuleOnAcquireState", "Skip reading id because page has disabled session state");
}
else {
// Case 2
Debug.Trace("SessionStateModuleOnAcquireState", "Delay reading id because we're using InProc optimization, and we are not using cookieless");
}
#endif
}
else {
/* Get sessionid */
_rqId = _idManager.GetSessionID(_rqContext);
Debug.Trace("SessionStateModuleOnAcquireState", "Current request id=" + _rqId);
}
if (!requiresState) {
if (_rqId == null) {
Debug.Trace("SessionStateModuleOnAcquireState",
"Handler does not require state, " +
"session id skipped or no id found, " +
"skipReadingId=" + skipReadingId +
"\nReturning from SessionStateModule::OnAcquireState");
}
else {
Debug.Trace("SessionStateModuleOnAcquireState",
"Handler does not require state, " +
"resetting timeout for SessionId=" + _rqId +
"\nReturning from SessionStateModule::OnAcquireState");
// Still need to update the sliding timeout to keep session alive.
// There is a plan to skip this for perf reason. But it was postponed to
// after Whidbey.
_store.ResetItemTimeout(_rqContext, _rqId);
}
_rqAr.Complete(true, null, null);
if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Information, EtwTraceFlags.AppSvc)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_SESSION_DATA_END, _rqContext.WorkerRequest);
return _rqAr;
}
_rqExecutionTimeout = _rqContext.Timeout;
// If the page is marked as DEBUG, HttpContext.Timeout will return a very large value (~1 year)
// In this case, we want to use the executionTimeout value specified in the config to avoid
// PollLockedSession to run forever.
if (_rqExecutionTimeout == DEFAULT_DBG_EXECUTION_TIMEOUT) {
_rqExecutionTimeout = s_configExecutionTimeout;
}
/* determine if we need just read-only access */
_rqReadonly = _rqContext.ReadOnlySessionState;
if (_rqId != null) {
/* get the session state corresponding to this session id */
isCompleted = GetSessionStateItem();
}
else if (!skipReadingId) {
/* if there's no id yet, create it */
bool redirected = CreateSessionId();
_rqIdNew = true;
if (redirected) {
if (s_configRegenerateExpiredSessionId) {
// See inline comments in CreateUninitializedSessionState()
CreateUninitializedSessionState();
}
_rqAr.Complete(true, null, null);
if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Information, EtwTraceFlags.AppSvc)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_SESSION_DATA_END, _rqContext.WorkerRequest);
return _rqAr;
}
}
if (isCompleted) {
CompleteAcquireState();
_rqAr.Complete(true, null, null);
}
return _rqAr;
}
finally {
RestoreImpersonation();
}
}
internal bool CreateSessionId() {
// CreateSessionId should be called only if:
Debug.Assert(_rqId == null || // Session id isn't found in the request, OR
(_rqSessionStateNotFound && // The session state isn't found, AND
s_configRegenerateExpiredSessionId && // We are regenerating expired session id, AND
_rqSupportSessionIdReissue && // This request supports session id re-issue, AND
!_rqIdNew), // The above three condition should imply the session id
// isn't just created, but is sent by the request.
"CreateSessionId should be called only if we're generating new id, or re-generating expired one");
Debug.Assert(_rqChangeImpersonationRefCount > 0, "Must call ChangeImpersonation first");
bool redirected;
_rqId = _idManager.CreateSessionID(_rqContext);
_idManager.SaveSessionID(_rqContext, _rqId, out redirected, out _rqAddedCookie);
return redirected;
}
internal void EnsureStateStoreItemLocked() {
// DevDiv 665141:
// Ensure ownership of the session state item here as the session ID now can be put on the wire (by Response.Flush)
// and the client can initiate a request before this one reaches OnReleaseState and thus causing a race condition.
// Note: It changes when we call into the Session Store provider. Now it may happen at BeginAcquireState instead of OnReleaseState.
// Item is locked yet here only if this is a new session
if (!_rqSessionStateNotFound) {
return;
}
Debug.Assert(_rqId != null, "Session State ID must exist");
Debug.Assert(_rqItem != null, "Session State item must exist");
ChangeImpersonation(_rqContext, false);
try {
// Store the item if already have been created
_store.SetAndReleaseItemExclusive(_rqContext, _rqId, _rqItem, _rqLockId, true /*_rqSessionStateNotFound*/);
// Lock Session State Item in Session State Store
LockSessionStateItem();
}
catch {
throw;
}
finally {
RestoreImpersonation();
}
// Mark as old session here. The SessionState is fully initialized, the item is locked
_rqSessionStateNotFound = false;
s_sessionEverSet = true;
}
// Called when AcquireState is done. This function will add the returned
// SessionStateStore item to the request context.
void CompleteAcquireState() {
Debug.Trace("SessionStateModuleOnAcquireState", "Item retrieved=" + (_rqItem != null).ToString(CultureInfo.InvariantCulture));
bool delayInitStateStoreItem = false;
Debug.Assert(!(s_allowDelayedStateStoreItemCreation && s_configRegenerateExpiredSessionId),
"!(s_allowDelayedStateStoreItemCreation && s_configRegenerateExpiredSessionId)");
try {
if (_rqItem != null) {
_rqSessionStateNotFound = false;
if ((_rqActionFlags & SessionStateActions.InitializeItem) != 0) {
Debug.Trace("SessionStateModuleOnAcquireState", "Initialize an uninit item");
_rqIsNewSession = true;
}
else {
_rqIsNewSession = false;
}
}
else {
_rqIsNewSession = true;
_rqSessionStateNotFound = true;
if (s_allowDelayedStateStoreItemCreation) {
Debug.Trace("SessionStateModuleOnAcquireState", "Delay creating new session state");
delayInitStateStoreItem = true;
}
// We couldn't find the session state.
if (!_rqIdNew && // If the request has a session id, that means the session state has expired
s_configRegenerateExpiredSessionId && // And we're asked to regenerate expired session
_rqSupportSessionIdReissue) { // And this request support session id reissue
// We will generate a new session id for this expired session state
bool redirected = CreateSessionId();
Debug.Trace("SessionStateModuleOnAcquireState", "Complete re-creating new id; redirected=" + redirected);
if (redirected) {
Debug.Trace("SessionStateModuleOnAcquireState", "Will redirect because we've reissued a new id and it's cookieless");
CreateUninitializedSessionState();
return;
}
}
}
if (delayInitStateStoreItem) {
_rqSessionState = s_delayedSessionState;
}
else {
InitStateStoreItem(true);
}
// Set session state module
SessionStateUtility.AddHttpSessionStateModuleToContext(_rqContext, this, delayInitStateStoreItem);
if (_rqIsNewSession) {
Debug.Trace("SessionStateModuleOnAcquireState", "Calling OnStart");
OnStart(EventArgs.Empty);
}
}
finally {
if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Information, EtwTraceFlags.AppSvc)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_SESSION_DATA_END, _rqContext.WorkerRequest);
}
#if DBG
if (_rqIsNewSession) {
if (_rqId == null) {
Debug.Assert(s_allowInProcOptimization, "s_allowInProcOptimization");
Debug.Trace("SessionStateModuleOnAcquireState", "New session: session id reading is delayed"+
"\nReturning from SessionStateModule::OnAcquireState");
}
else {
Debug.Trace("SessionStateModuleOnAcquireState", "New session: SessionId= " + _rqId +
"\nReturning from SessionStateModule::OnAcquireState");
}
}
else {
Debug.Trace("SessionStateModuleOnAcquireState", "Retrieved old session, SessionId= " + _rqId +
"\nReturning from SessionStateModule::OnAcquireState");
}
#endif
}
void CreateUninitializedSessionState() {
Debug.Assert(_rqChangeImpersonationRefCount > 0, "Must call ChangeImpersonation first");
// When we generate a new session id in cookieless case, and if "reissueExpiredSession" is
// true, we need to generate a new temporary empty session and save it
// under the new session id, otherwise when the next request (i.e. when the browser is
// redirected back to the web server) comes in, we will think it's accessing an expired session.
_store.CreateUninitializedItem(_rqContext, _rqId, s_timeout);
}
internal void InitStateStoreItem(bool addToContext) {
Debug.Assert(_rqId != null || s_allowInProcOptimization, "_rqId != null || s_allowInProcOptimization");
ChangeImpersonation(_rqContext, false);
try {
if (_rqItem == null) {
Debug.Trace("InitStateStoreItem", "Creating new session state");
_rqItem = _store.CreateNewStoreData(_rqContext, s_timeout);
}
_rqSessionItems = _rqItem.Items;
if (_rqSessionItems == null) {
throw new HttpException(SR.GetString(SR.Null_value_for_SessionStateItemCollection));
}
// No check for null because we allow our custom provider to return a null StaticObjects.
_rqStaticObjects = _rqItem.StaticObjects;
_rqSessionItems.Dirty = false;
_rqSessionState = new HttpSessionStateContainer(
this,
_rqId, // could be null if we're using InProc optimization
_rqSessionItems,
_rqStaticObjects,
_rqItem.Timeout,
_rqIsNewSession,
s_configCookieless,
s_configMode,
_rqReadonly);
if (addToContext) {
SessionStateUtility.AddHttpSessionStateToContext(_rqContext, _rqSessionState);
}
}
finally {
RestoreImpersonation();
}
}
// Used for InProc session id optimization
internal string DelayedGetSessionId() {
Debug.Assert(s_allowInProcOptimization, "Shouldn't be called if we don't allow InProc optimization");
Debug.Assert(_rqId == null, "Shouldn't be called if we already have the id");
Debug.Assert(!((SessionIDManager)_idManager).UseCookieless(_rqContext), "We can delay session id only if we are not using cookieless");
Debug.Trace("DelayedOperation", "Delayed getting session id");
bool redirected;
ChangeImpersonation(_rqContext, false);
try {
_rqId = _idManager.GetSessionID(_rqContext);
if (_rqId == null) {
Debug.Trace("DelayedOperation", "Delayed creating session id");
redirected = CreateSessionId();
Debug.Assert(!redirected, "DelayedGetSessionId shouldn't redirect us here.");
}
}
finally {
RestoreImpersonation();
}
return _rqId;
}
void LockSessionStateItem() {
bool locked;
TimeSpan lockAge;
Debug.Assert(_rqId != null, "_rqId != null");
Debug.Assert(_rqChangeImpersonationRefCount > 0, "Must call ChangeImpersonation first");
if (!_rqReadonly) {
SessionStateStoreData storedItem = _store.GetItemExclusive(_rqContext, _rqId, out locked, out lockAge, out _rqLockId, out _rqActionFlags);
Debug.Assert(storedItem != null, "Must succeed in locking session state item.");
}
}
bool GetSessionStateItem() {
bool isCompleted = true;
bool locked;
TimeSpan lockAge;
Debug.Assert(_rqId != null, "_rqId != null");
Debug.Assert(_rqChangeImpersonationRefCount > 0, "Must call ChangeImpersonation first");
if (_rqReadonly) {
_rqItem = _store.GetItem(_rqContext, _rqId, out locked, out lockAge, out _rqLockId, out _rqActionFlags);
}
else {
_rqItem = _store.GetItemExclusive(_rqContext, _rqId, out locked, out lockAge, out _rqLockId, out _rqActionFlags);
// DevDiv Bugs 146875: WebForm and WebService Session Access Concurrency Issue
// If we have an expired session, we need to insert the state in the store here to
// ensure serialized access in case more than one entity requests it simultaneously.
// If the state has already been created before, CreateUninitializedSessionState is a no-op.
if (_rqItem == null && locked == false && _rqId != null) {
if (!(s_configCookieless == HttpCookieMode.UseUri && s_configRegenerateExpiredSessionId == true)) {
CreateUninitializedSessionState();
_rqItem = _store.GetItemExclusive(_rqContext, _rqId, out locked, out lockAge, out _rqLockId, out _rqActionFlags);
}
}
}
// We didn't get it because it's locked....
if (_rqItem == null && locked) {
//
if (lockAge >= _rqExecutionTimeout) {
/* Release the lock on the item, which is held by another thread*/
Debug.Trace("SessionStateModuleOnAcquireState",
"Lock timed out, lockAge=" + lockAge +
", id=" + _rqId);
_store.ReleaseItemExclusive(_rqContext, _rqId, _rqLockId);
}
Debug.Trace("SessionStateModuleOnAcquireState",
"Item is locked, will poll, id=" + _rqId);
isCompleted = false;
PollLockedSession();
}
return isCompleted;
}
void PollLockedSession() {
if (_timerCallback == null) {
_timerCallback = new TimerCallback(this.PollLockedSessionCallback);
}
if (_timer == null) {
_timerId++;
#if DBG
if (!Debug.IsTagPresent("Timer") || Debug.IsTagEnabled("Timer"))
#endif
{
if (!s_PollIntervalRegLookedUp)
LookUpRegForPollInterval();
_timer = new Timer(_timerCallback, _timerId, LOCKED_ITEM_POLLING_INTERVAL, LOCKED_ITEM_POLLING_INTERVAL);
}
}
}
[RegistryPermission(SecurityAction.Assert, Unrestricted = true)]
private static void LookUpRegForPollInterval() {
lock (s_PollIntervalRegLock) {
if (s_PollIntervalRegLookedUp)
return;
try {
object o = Registry.GetValue(@"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\ASP.NET", "SessionStateLockedItemPollInterval", 0);
if (o != null && (o is int || o is uint) && ((int)o) > 0)
LOCKED_ITEM_POLLING_INTERVAL = (int) o;
s_PollIntervalRegLookedUp = true;
}
catch { // ignore exceptions
}
}
}
void ResetPollTimer() {
_timerId++;
if (_timer != null) {
((IDisposable)_timer).Dispose();
_timer = null;
}
}
void ChangeImpersonation(HttpContext context, bool timerThread) {
#if !FEATURE_PAL // FEATURE_PAL doesn't enable impersonation
_rqChangeImpersonationRefCount++;
if (_ignoreImpersonation) {
return;
}
// If SQL store isn't using integrated security, and we're using our own session id module,
// we know we don't care about impersonation in our all session state store read/write
// and session id read/write.
if (s_configMode == SessionStateMode.SQLServer &&
((SqlSessionStateStore)_store).KnowForSureNotUsingIntegratedSecurity &&
_usingAspnetSessionIdManager) {
return;
}
// Please note that there are two types of calls coming in. One is from a request thread,
// where timerThread==false; the other is from PollLockedSessionCallback, where
// timerThread==true.
if (s_useHostingIdentity) {
// If we're told to use Application Identity, in each case we should impersonate,
// if not called yet.
if (_rqIctx == null) {
_rqIctx = new ApplicationImpersonationContext();
}
}
else {
if (timerThread) {
// For the timer thread, we should explicity impersonate back to what the HttpContext was
// orginally impersonating.
_rqTimerThreadImpersonationIctx = new ClientImpersonationContext(context, false);
}
else {
// For a request thread, if we're told to not use hosting id, there's no need
// to do anything special.
Debug.Assert(_rqIctx == null, "_rqIctx == null");
return;
}
}
#endif // !FEATURE_PAL
}
void RestoreImpersonation() {
Debug.Assert(_rqChangeImpersonationRefCount != 0, "_rqChangeImpersonationRefCount != 0");
_rqChangeImpersonationRefCount--;
if (_rqChangeImpersonationRefCount == 0) {
Debug.Assert(!(_rqIctx != null && _rqTimerThreadImpersonationIctx != null), "Should not have mixed mode of impersonation");
if (_rqIctx != null) {
_rqIctx.Undo();
_rqIctx = null;
}
if (_rqTimerThreadImpersonationIctx != null) {
Debug.Assert(_rqContext != null, "_rqContext != null");
_rqTimerThreadImpersonationIctx.Undo();
_rqTimerThreadImpersonationIctx = null;
}
}
}
void PollLockedSessionCallback(object state) {
Debug.Assert(_rqId != null, "_rqId != null");
Debug.Trace("SessionStateModuleOnAcquireState",
"Polling callback called from timer, id=" + _rqId);
bool isCompleted = false;
Exception error = null;
/* check whether we are currently in a callback */
if (Interlocked.CompareExchange(ref _rqInCallback, 1, 0) != 0)
return;
try {
/*
* check whether this callback is for the current request,
* and whether sufficient time has passed since the last poll
* to try again.
*/
int timerId = (int) state;
if ( (timerId == _timerId) &&
(DateTime.UtcNow - _rqLastPollCompleted >= LOCKED_ITEM_POLLING_DELTA)) {
ChangeImpersonation(_rqContext, true);
try {
isCompleted = GetSessionStateItem();
_rqLastPollCompleted = DateTime.UtcNow;
if (isCompleted) {
Debug.Assert(_timer != null, "_timer != null");
ResetPollTimer();
CompleteAcquireState();
}
}
finally {
RestoreImpersonation();
}
}
}
catch (Exception e) {
ResetPollTimer();
error = e;
}
finally {
Interlocked.Exchange(ref _rqInCallback, 0);
}
if (isCompleted || error != null) {
_rqAr.Complete(false, null, error);
}
}
void EndAcquireState(IAsyncResult ar) {
((HttpAsyncResult)ar).End();
}
// Called by OnReleaseState to get the session id.
string ReleaseStateGetSessionID() {
if (_rqId == null) {
Debug.Assert(s_allowInProcOptimization, "s_allowInProcOptimization");
DelayedGetSessionId();
}
Debug.Assert(_rqId != null, "_rqId != null");
return _rqId;
}
/*
* Release session state
*/
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
void OnReleaseState(Object source, EventArgs eventArgs) {
HttpApplication app;
HttpContext context;
bool setItemCalled = false;
Debug.Trace("SessionStateOnReleaseState", "Beginning SessionStateModule::OnReleaseState");
Debug.Assert(!(_rqAddedCookie && !_rqIsNewSession),
"If session id was added to the cookie, it must be a new session.");
// !!!
// Please note that due to InProc session id optimization, this function should not
// use _rqId directly because it can still be null. Instead, use DelayedGetSessionId().
_releaseCalled = true;
app = (HttpApplication)source;
context = app.Context;
ChangeImpersonation(context, false);
try {
if (_rqSessionState != null) {
bool delayedSessionState = (_rqSessionState == s_delayedSessionState);
Debug.Trace("SessionStateOnReleaseState", "Remove session state from context");
SessionStateUtility.RemoveHttpSessionStateFromContext(_rqContext, delayedSessionState);
/*
* Don't store untouched new sessions.
*/
if (
// The store doesn't have the session state.
// ( Please note we aren't checking _rqIsNewSession because _rqIsNewSession
// is lalso true if the item is converted from temp to perm in a GetItemXXX() call.)
_rqSessionStateNotFound
// OnStart is not defined
&& _sessionStartEventHandler == null
// Nothing has been stored in session state
&& (delayedSessionState || !_rqSessionItems.Dirty)
&& (delayedSessionState || _rqStaticObjects == null || _rqStaticObjects.NeverAccessed)
) {
Debug.Trace("SessionStateOnReleaseState", "Not storing unused new session.");
}
else if (_rqSessionState.IsAbandoned) {
Debug.Trace("SessionStateOnReleaseState", "Removing session due to abandonment, SessionId=" + _rqId);
if (_rqSessionStateNotFound) {
// The store provider doesn't have it, and so we don't need to remove it from the store.
// However, if the store provider supports session expiry, and we have a Session_End in global.asax,
// we need to explicitly call Session_End.
if (_supportSessionExpiry) {
if (delayedSessionState) {
Debug.Assert(s_allowDelayedStateStoreItemCreation, "s_allowDelayedStateStoreItemCreation");
Debug.Assert(_rqItem == null, "_rqItem == null");
InitStateStoreItem(false /*addToContext*/);
}
_onEndTarget.RaiseSessionOnEnd(ReleaseStateGetSessionID(), _rqItem);
}
}
else {
Debug.Assert(_rqItem != null, "_rqItem cannot null if it's not a new session");
// Remove it from the store because the session is abandoned.
_store.RemoveItem(_rqContext, ReleaseStateGetSessionID(), _rqLockId, _rqItem);
}
}
else if (!_rqReadonly ||
(_rqReadonly &&
_rqIsNewSession &&
_sessionStartEventHandler != null &&
!SessionIDManagerUseCookieless)) {
// We need to save it since it isn't read-only
// See Dev10 588711: Issuing a redirect from inside of Session_Start event
// triggers an infinite loop when using pages with read-only session state
// We save it only if there is no error, and if something has changed (unless it's a new session)
if ( context.Error == null // no error
&& ( _rqSessionStateNotFound
|| _rqSessionItems.Dirty // SessionItems has changed.
|| (_rqStaticObjects != null && !_rqStaticObjects.NeverAccessed) // Static objects have been accessed
|| _rqItem.Timeout != _rqSessionState.Timeout // Timeout value has changed
)
) {
if (delayedSessionState) {
Debug.Assert(_rqIsNewSession, "Saving a session and delayedSessionState is true: _rqIsNewSession must be true");
Debug.Assert(s_allowDelayedStateStoreItemCreation, "Saving a session and delayedSessionState is true: s_allowDelayedStateStoreItemCreation");
Debug.Assert(_rqItem == null, "Saving a session and delayedSessionState is true: _rqItem == null");
InitStateStoreItem(false /*addToContext*/);
}
#if DBG
if (_rqSessionItems.Dirty) {
Debug.Trace("SessionStateOnReleaseState", "Setting new session due to dirty SessionItems, SessionId=" + _rqId);
}
else if (_rqStaticObjects != null && !_rqStaticObjects.NeverAccessed) {
Debug.Trace("SessionStateOnReleaseState", "Setting new session due to accessed Static Objects, SessionId=" + _rqId);
}
else if (_rqSessionStateNotFound) {
Debug.Trace("SessionStateOnReleaseState", "Setting new session because it's not found, SessionId=" + _rqId);
}
else {
Debug.Trace("SessionStateOnReleaseState", "Setting new session due to options change, SessionId=" + _rqId +
"\n\t_rq.timeout=" + _rqItem.Timeout.ToString(CultureInfo.InvariantCulture) +
", _rqSessionState.timeout=" + _rqSessionState.Timeout.ToString(CultureInfo.InvariantCulture));
}
#endif
if (_rqItem.Timeout != _rqSessionState.Timeout) {
_rqItem.Timeout = _rqSessionState.Timeout;
}
s_sessionEverSet = true;
setItemCalled = true;
_store.SetAndReleaseItemExclusive(_rqContext, ReleaseStateGetSessionID(), _rqItem, _rqLockId, _rqSessionStateNotFound);
}
else {
// Can't save it because of various reason. Just release our exclusive lock on it.
Debug.Trace("SessionStateOnReleaseState", "Release exclusive lock on session, SessionId=" + _rqId);
if (!_rqSessionStateNotFound) {
Debug.Assert(_rqItem != null, "_rqItem cannot null if it's not a new session");
_store.ReleaseItemExclusive(_rqContext, ReleaseStateGetSessionID(), _rqLockId);
}
}
}
#if DBG
else {
Debug.Trace("SessionStateOnReleaseState", "Session is read-only, ignoring SessionId=" + _rqId);
}
#endif
Debug.Trace("SessionStateOnReleaseState", "Returning from SessionStateModule::OnReleaseState");
}
if (_rqAddedCookie && !setItemCalled && context.Response.IsBuffered()) {
_idManager.RemoveSessionID(_rqContext);
}
}
finally {
RestoreImpersonation();
}
// WOS 1679798: PERF: Session State Module should disable EndRequest on successful cleanup
bool implementsIRequiresSessionState = context.RequiresSessionState;
if (HttpRuntime.UseIntegratedPipeline
&& (context.NotificationContext.CurrentNotification == RequestNotification.ReleaseRequestState)
&& (s_canSkipEndRequestCall || !implementsIRequiresSessionState)) {
context.DisableNotifications(RequestNotification.EndRequest, 0 /*postNotifications*/);
_acquireCalled = false;
_releaseCalled = false;
ResetPerRequestFields();
}
}
/*
* End of request processing. Possibly does release if skipped due to errors
*/
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
void OnEndRequest(Object source, EventArgs eventArgs) {
HttpApplication app;
HttpContext context;
String id;
Debug.Trace("SessionStateOnEndRequest", "Beginning SessionStateModule::OnEndRequest");
app = (HttpApplication)source;
context = app.Context;
/* determine if the request requires state at all */
if (!context.RequiresSessionState) {
return;
}
ChangeImpersonation(context, false);
try {
if (!_releaseCalled) {
if (_acquireCalled) {
/*
* need to do release here if the request short-circuited due to an error
*/
OnReleaseState(source, eventArgs);
}
else {
/*
* 'advise' -- update session timeout
*/
if (_rqContext == null) {
_rqContext = context;
}
// We haven't called BeginAcquireState. So we have to call these InitializeRequest
// methods here.
bool dummy;
_store.InitializeRequest(_rqContext);
_idManager.InitializeRequest(_rqContext, true, out dummy);
id = _idManager.GetSessionID(context);
if (id != null) {
Debug.Trace("SessionStateOnEndRequest", "Resetting timeout for SessionId=" + id);
_store.ResetItemTimeout(context, id);
}
#if DBG
else {
Debug.Trace("SessionStateOnEndRequest", "No session id found.");
}
#endif
}
}
/* Notify the store we are finishing a request */
_store.EndRequest(_rqContext);
}
finally {
_acquireCalled = false;
_releaseCalled = false;
RestoreImpersonation();
ResetPerRequestFields();
}
Debug.Trace("SessionStateOnEndRequest", "Returning from SessionStateModule::OnEndRequest");
}
internal static void ReadConnectionString(SessionStateSection config, ref string cntString, string propName) {
ConfigsHelper.GetRegistryStringAttribute(ref cntString, config, propName);
HandlerBase.CheckAndReadConnectionString(ref cntString, true);
}
internal bool SessionIDManagerUseCookieless {
get {
// See VSWhidbey 399907
if (!_usingAspnetSessionIdManager) {
return s_configCookieless == HttpCookieMode.UseUri;
}
else {
return ((SessionIDManager)_idManager).UseCookieless(_rqContext);
}
}
}
// DevDiv Bugs 151914: Release session state before executing child request
internal void EnsureReleaseState(HttpApplication app) {
if (HttpRuntime.UseIntegratedPipeline && _acquireCalled && !_releaseCalled) {
try {
OnReleaseState(app, null);
}
catch { }
}
}
}
}