mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
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
629 lines
21 KiB
C#
629 lines
21 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="SessionStateItemCollection.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
/*
|
|
* SessionStateItemCollection
|
|
*
|
|
* Copyright (c) 1998-1999, Microsoft Corporation
|
|
*
|
|
*/
|
|
|
|
namespace System.Web.SessionState {
|
|
|
|
using System.IO;
|
|
using System.Collections;
|
|
using System.Collections.Specialized;
|
|
using System.Web.Util;
|
|
using System.Security;
|
|
using System.Security.Permissions;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
|
|
public interface ISessionStateItemCollection : ICollection {
|
|
|
|
Object this[String name]
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
Object this[int index]
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
void Remove(String name);
|
|
|
|
void RemoveAt(int index);
|
|
|
|
void Clear();
|
|
|
|
NameObjectCollectionBase.KeysCollection Keys {
|
|
get;
|
|
}
|
|
|
|
bool Dirty {
|
|
get;
|
|
set;
|
|
}
|
|
}
|
|
|
|
public sealed class SessionStateItemCollection : NameObjectCollectionBase, ISessionStateItemCollection {
|
|
|
|
class KeyedCollection : NameObjectCollectionBase {
|
|
|
|
internal KeyedCollection(int count) : base(count, Misc.CaseInsensitiveInvariantKeyComparer) {
|
|
}
|
|
|
|
internal Object this[String name]
|
|
{
|
|
get {
|
|
return BaseGet(name);
|
|
}
|
|
|
|
set {
|
|
Object oldValue = BaseGet(name);
|
|
if (oldValue == null && value == null)
|
|
return;
|
|
|
|
BaseSet(name, value);
|
|
}
|
|
}
|
|
|
|
internal Object this[int index]
|
|
{
|
|
get {
|
|
return BaseGet(index);
|
|
}
|
|
}
|
|
|
|
internal void Remove(String name) {
|
|
BaseRemove(name);
|
|
}
|
|
|
|
internal void RemoveAt(int index) {
|
|
BaseRemoveAt(index);
|
|
}
|
|
|
|
internal void Clear() {
|
|
BaseClear();
|
|
}
|
|
|
|
internal string GetKey( int index) {
|
|
return BaseGetKey(index);
|
|
}
|
|
|
|
internal bool ContainsKey(string name) {
|
|
// Please note that we don't expect null value to be inserted.
|
|
return (BaseGet(name) != null);
|
|
}
|
|
}
|
|
|
|
class SerializedItemPosition {
|
|
int _offset;
|
|
int _dataLength;
|
|
|
|
internal SerializedItemPosition(int offset, int dataLength) {
|
|
this._offset = offset;
|
|
this._dataLength = dataLength;
|
|
}
|
|
|
|
internal int Offset {
|
|
get { return _offset; }
|
|
}
|
|
|
|
internal int DataLength {
|
|
get { return _dataLength; }
|
|
}
|
|
|
|
// Mark the item as deserialized by making the offset -1.
|
|
internal void MarkDeserializedOffset() {
|
|
_offset = -1;
|
|
}
|
|
|
|
internal void MarkDeserializedOffsetAndCheck() {
|
|
if (_offset >= 0) {
|
|
MarkDeserializedOffset();
|
|
}
|
|
else {
|
|
Debug.Fail("Offset shouldn't be negative inside MarkDeserializedOffsetAndCheck.");
|
|
}
|
|
}
|
|
|
|
internal bool IsDeserialized {
|
|
get { return _offset < 0; }
|
|
}
|
|
}
|
|
|
|
static Hashtable s_immutableTypes;
|
|
const int NO_NULL_KEY = -1;
|
|
const int SIZE_OF_INT32 = 4;
|
|
bool _dirty;
|
|
KeyedCollection _serializedItems;
|
|
Stream _stream;
|
|
int _iLastOffset;
|
|
object _serializedItemsLock = new object();
|
|
|
|
public SessionStateItemCollection() : base(Misc.CaseInsensitiveInvariantKeyComparer) {
|
|
}
|
|
|
|
static SessionStateItemCollection() {
|
|
Type t;
|
|
s_immutableTypes = new Hashtable(19);
|
|
|
|
t=typeof(String);
|
|
s_immutableTypes.Add(t, t);
|
|
t=typeof(Int32);
|
|
s_immutableTypes.Add(t, t);
|
|
t=typeof(Boolean);
|
|
s_immutableTypes.Add(t, t);
|
|
t=typeof(DateTime);
|
|
s_immutableTypes.Add(t, t);
|
|
t=typeof(Decimal);
|
|
s_immutableTypes.Add(t, t);
|
|
t=typeof(Byte);
|
|
s_immutableTypes.Add(t, t);
|
|
t=typeof(Char);
|
|
s_immutableTypes.Add(t, t);
|
|
t=typeof(Single);
|
|
s_immutableTypes.Add(t, t);
|
|
t=typeof(Double);
|
|
s_immutableTypes.Add(t, t);
|
|
t=typeof(SByte);
|
|
s_immutableTypes.Add(t, t);
|
|
t=typeof(Int16);
|
|
s_immutableTypes.Add(t, t);
|
|
t=typeof(Int64);
|
|
s_immutableTypes.Add(t, t);
|
|
t=typeof(UInt16);
|
|
s_immutableTypes.Add(t, t);
|
|
t=typeof(UInt32);
|
|
s_immutableTypes.Add(t, t);
|
|
t=typeof(UInt64);
|
|
s_immutableTypes.Add(t, t);
|
|
t=typeof(TimeSpan);
|
|
s_immutableTypes.Add(t, t);
|
|
t=typeof(Guid);
|
|
s_immutableTypes.Add(t, t);
|
|
t=typeof(IntPtr);
|
|
s_immutableTypes.Add(t, t);
|
|
t=typeof(UIntPtr);
|
|
s_immutableTypes.Add(t, t);
|
|
}
|
|
|
|
static internal bool IsImmutable(Object o) {
|
|
return s_immutableTypes[o.GetType()] != null;
|
|
}
|
|
|
|
internal void DeserializeAllItems() {
|
|
if (_serializedItems == null) {
|
|
return;
|
|
}
|
|
|
|
lock (_serializedItemsLock) {
|
|
for (int i = 0; i < _serializedItems.Count; i++) {
|
|
DeserializeItem(_serializedItems.GetKey(i), false);
|
|
}
|
|
}
|
|
}
|
|
|
|
void DeserializeItem(int index) {
|
|
// No-op if SessionStateItemCollection is not deserialized from a persistent storage.
|
|
if (_serializedItems == null) {
|
|
return;
|
|
}
|
|
|
|
#if DBG
|
|
// The keys in _serializedItems should match the beginning part of
|
|
// the list in NameObjectCollectionBase
|
|
for (int i=0; i < _serializedItems.Count; i++) {
|
|
Debug.Assert(_serializedItems.GetKey(i) == BaseGetKey(i));
|
|
}
|
|
#endif
|
|
|
|
lock (_serializedItemsLock) {
|
|
// No-op if the item isn't serialized.
|
|
if (index >= _serializedItems.Count) {
|
|
return;
|
|
}
|
|
|
|
DeserializeItem(_serializedItems.GetKey(index), false);
|
|
}
|
|
}
|
|
|
|
[SecurityPermission(SecurityAction.Assert, Flags = SecurityPermissionFlag.SerializationFormatter)]
|
|
private object ReadValueFromStreamWithAssert() {
|
|
return AltSerialization.ReadValueFromStream(new BinaryReader(_stream));
|
|
}
|
|
|
|
void DeserializeItem(String name, bool check) {
|
|
object val;
|
|
|
|
lock (_serializedItemsLock) {
|
|
if (check) {
|
|
// No-op if SessionStateItemCollection is not deserialized from a persistent storage,
|
|
if (_serializedItems == null) {
|
|
return;
|
|
}
|
|
|
|
// User is asking for an item we don't have.
|
|
if (!_serializedItems.ContainsKey(name)) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
Debug.Assert(_serializedItems != null);
|
|
Debug.Assert(_stream != null);
|
|
|
|
SerializedItemPosition position = (SerializedItemPosition)_serializedItems[name];
|
|
if (position.IsDeserialized) {
|
|
// It has been deserialized already.
|
|
return;
|
|
}
|
|
|
|
// Position the stream to the place where the item is stored.
|
|
_stream.Seek(position.Offset, SeekOrigin.Begin);
|
|
|
|
// Set the value
|
|
Debug.Trace("SessionStateItemCollection", "Deserialized an item: keyname=" + name);
|
|
|
|
if (!HttpRuntime.DisableProcessRequestInApplicationTrust) {
|
|
// VSWhidbey 427316: Sandbox Serialization in non full trust cases
|
|
if (HttpRuntime.NamedPermissionSet != null && HttpRuntime.ProcessRequestInApplicationTrust) {
|
|
HttpRuntime.NamedPermissionSet.PermitOnly();
|
|
}
|
|
}
|
|
|
|
// This deserialization work used to be done in AcquireRequestState event when
|
|
// there is no user code on the stack.
|
|
// In whidbey we added this on-demand deserialization for performance reason. However,
|
|
// in medium and low trust cases the page doesn't have permission to do it.
|
|
// So we have to assert the permission.
|
|
// (See VSWhidbey 275003)
|
|
val = ReadValueFromStreamWithAssert();
|
|
|
|
BaseSet(name, val);
|
|
|
|
// At the end, mark the item as deserialized by making the offset -1
|
|
position.MarkDeserializedOffsetAndCheck();
|
|
}
|
|
|
|
}
|
|
|
|
void MarkItemDeserialized(String name) {
|
|
// No-op if SessionStateItemCollection is not deserialized from a persistent storage,
|
|
if (_serializedItems == null) {
|
|
return;
|
|
}
|
|
|
|
lock (_serializedItemsLock) {
|
|
// If the serialized collection contains this key, mark it deserialized
|
|
if (_serializedItems.ContainsKey(name)) {
|
|
// Mark the item as deserialized by making it -1.
|
|
((SerializedItemPosition)_serializedItems[name]).MarkDeserializedOffset();
|
|
}
|
|
}
|
|
}
|
|
|
|
void MarkItemDeserialized(int index) {
|
|
// No-op if SessionStateItemCollection is not deserialized from a persistent storage,
|
|
if (_serializedItems == null) {
|
|
return;
|
|
}
|
|
|
|
#if DBG
|
|
// The keys in _serializedItems should match the beginning part of
|
|
// the list in NameObjectCollectionBase
|
|
for (int i=0; i < _serializedItems.Count; i++) {
|
|
Debug.Assert(_serializedItems.GetKey(i) == BaseGetKey(i));
|
|
}
|
|
#endif
|
|
|
|
lock (_serializedItemsLock) {
|
|
// No-op if the item isn't serialized.
|
|
if (index >= _serializedItems.Count) {
|
|
return;
|
|
}
|
|
|
|
((SerializedItemPosition)_serializedItems[index]).MarkDeserializedOffset();
|
|
}
|
|
}
|
|
|
|
public bool Dirty {
|
|
get {return _dirty;}
|
|
set {_dirty = value;}
|
|
}
|
|
|
|
public Object this[String name]
|
|
{
|
|
get {
|
|
DeserializeItem(name, true);
|
|
|
|
Object obj = BaseGet(name);
|
|
if (obj != null) {
|
|
if (!IsImmutable(obj)) {
|
|
// If the item is immutable (e.g. an array), then the caller has the ability to change
|
|
// its content without calling our setter. So we have to mark the collection
|
|
// as dirty.
|
|
Debug.Trace("SessionStateItemCollection", "Setting _dirty to true in get");
|
|
_dirty = true;
|
|
}
|
|
}
|
|
|
|
return obj;
|
|
}
|
|
|
|
set {
|
|
MarkItemDeserialized(name);
|
|
Debug.Trace("SessionStateItemCollection", "Setting _dirty to true in set");
|
|
BaseSet(name, value);
|
|
_dirty = true;
|
|
}
|
|
}
|
|
|
|
public Object this[int index]
|
|
{
|
|
get {
|
|
DeserializeItem(index);
|
|
|
|
Object obj = BaseGet(index);
|
|
if (obj != null) {
|
|
if (!IsImmutable(obj)) {
|
|
Debug.Trace("SessionStateItemCollection", "Setting _dirty to true in get");
|
|
_dirty = true;
|
|
}
|
|
}
|
|
|
|
return obj;
|
|
}
|
|
|
|
set {
|
|
MarkItemDeserialized(index);
|
|
Debug.Trace("SessionStateItemCollection", "Setting _dirty to true in set");
|
|
BaseSet(index, value);
|
|
_dirty = true;
|
|
}
|
|
}
|
|
|
|
|
|
public void Remove(String name) {
|
|
lock (_serializedItemsLock) {
|
|
if (_serializedItems != null) {
|
|
_serializedItems.Remove(name);
|
|
}
|
|
|
|
BaseRemove(name);
|
|
_dirty = true;
|
|
}
|
|
}
|
|
|
|
public void RemoveAt(int index) {
|
|
lock (_serializedItemsLock) {
|
|
if (_serializedItems != null && index < _serializedItems.Count) {
|
|
_serializedItems.RemoveAt(index);
|
|
}
|
|
|
|
BaseRemoveAt(index);
|
|
_dirty = true;
|
|
}
|
|
}
|
|
|
|
public void Clear() {
|
|
lock (_serializedItemsLock) {
|
|
if (_serializedItems != null) {
|
|
_serializedItems.Clear();
|
|
}
|
|
BaseClear();
|
|
_dirty = true;
|
|
}
|
|
}
|
|
|
|
public override IEnumerator GetEnumerator() {
|
|
// Have to deserialize all items; otherwise the enumerator won't
|
|
// work because we'll keep on changing the collection during
|
|
// individual item deserialization
|
|
DeserializeAllItems();
|
|
|
|
return base.GetEnumerator();
|
|
}
|
|
|
|
public override NameObjectCollectionBase.KeysCollection Keys {
|
|
get {
|
|
// Unfortunately, we have to deserialize all items first, because
|
|
// Keys.GetEnumerator might be called and we have the same problem
|
|
// as in GetEnumerator() above.
|
|
DeserializeAllItems();
|
|
|
|
return base.Keys;
|
|
}
|
|
}
|
|
|
|
[SecurityPermission(SecurityAction.Assert, Flags = SecurityPermissionFlag.SerializationFormatter)]
|
|
private void WriteValueToStreamWithAssert(object value, BinaryWriter writer) {
|
|
AltSerialization.WriteValueToStream(value, writer);
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Security", "CA2107:ReviewDenyAndPermitOnlyUsage",
|
|
Justification = "Not a new FxCop warning suppression -- this proped up again because Serialize(BinaryWriter writer) function was changed Serialize(BinaryWriter writer, bool assertSerializationFormatterPermission)")]
|
|
public void Serialize(BinaryWriter writer) {
|
|
int count;
|
|
int i;
|
|
long iOffsetStart;
|
|
long iValueStart;
|
|
string key;
|
|
object value;
|
|
long curPos;
|
|
byte[] buffer = null;
|
|
Stream baseStream = writer.BaseStream;
|
|
|
|
if (!HttpRuntime.DisableProcessRequestInApplicationTrust) {
|
|
// VSWhidbey 427316: Sandbox Serialization in non full trust cases
|
|
if (HttpRuntime.NamedPermissionSet != null && HttpRuntime.ProcessRequestInApplicationTrust) {
|
|
HttpRuntime.NamedPermissionSet.PermitOnly();
|
|
}
|
|
}
|
|
|
|
lock (_serializedItemsLock) {
|
|
count = Count;
|
|
writer.Write(count);
|
|
|
|
if (count > 0) {
|
|
if (BaseGet(null) != null) {
|
|
// We have a value with a null key. Find its index.
|
|
for (i = 0; i < count; i++) {
|
|
key = BaseGetKey(i);
|
|
if (key == null) {
|
|
writer.Write(i);
|
|
break;
|
|
}
|
|
}
|
|
|
|
Debug.Assert(i != count);
|
|
}
|
|
else {
|
|
writer.Write(NO_NULL_KEY);
|
|
}
|
|
|
|
// Write out all the keys.
|
|
for (i = 0; i < count; i++) {
|
|
key = BaseGetKey(i);
|
|
if (key != null) {
|
|
writer.Write(key);
|
|
}
|
|
}
|
|
|
|
// Next, allocate space to store the offset:
|
|
// - We won't store the offset of first item because it's always zero.
|
|
// - The offset of an item is counted from the beginning of serialized values
|
|
// - But we will store the offset of the first byte off the last item because
|
|
// we need that to calculate the size of the last item.
|
|
iOffsetStart = baseStream.Position;
|
|
baseStream.Seek(SIZE_OF_INT32 * count, SeekOrigin.Current);
|
|
|
|
iValueStart = baseStream.Position;
|
|
|
|
for (i = 0; i < count; i++) {
|
|
// See if that item has not be deserialized yet.
|
|
if (_serializedItems != null &&
|
|
i < _serializedItems.Count &&
|
|
!((SerializedItemPosition)_serializedItems[i]).IsDeserialized) {
|
|
|
|
SerializedItemPosition position = (SerializedItemPosition)_serializedItems[i];
|
|
|
|
Debug.Assert(_stream != null);
|
|
|
|
// The item is read as serialized data from a store, and it's still
|
|
// serialized, meaning no one has referenced it. Just copy
|
|
// the bytes over.
|
|
|
|
// Move the stream to the serialized data and copy it over to writer
|
|
_stream.Seek(position.Offset, SeekOrigin.Begin);
|
|
|
|
if (buffer == null || buffer.Length < position.DataLength) {
|
|
buffer = new Byte[position.DataLength];
|
|
}
|
|
#if DBG
|
|
int read =
|
|
#endif
|
|
_stream.Read(buffer, 0, position.DataLength);
|
|
#if DBG
|
|
Debug.Assert(read == position.DataLength);
|
|
#endif
|
|
|
|
baseStream.Write(buffer, 0, position.DataLength);
|
|
}
|
|
else {
|
|
value = BaseGet(i);
|
|
WriteValueToStreamWithAssert(value, writer);
|
|
}
|
|
|
|
curPos = baseStream.Position;
|
|
|
|
// Write the offset
|
|
baseStream.Seek(i * SIZE_OF_INT32 + iOffsetStart, SeekOrigin.Begin);
|
|
writer.Write((int)(curPos - iValueStart));
|
|
|
|
// Move back to current position
|
|
baseStream.Seek(curPos, SeekOrigin.Begin);
|
|
|
|
Debug.Trace("SessionStateItemCollection",
|
|
"Serialize: curPost=" + curPos + ", offset= " + (int)(curPos - iValueStart));
|
|
}
|
|
}
|
|
#if DBG
|
|
writer.Write((byte)0xff);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
public static SessionStateItemCollection Deserialize(BinaryReader reader) {
|
|
SessionStateItemCollection d = new SessionStateItemCollection();
|
|
int count;
|
|
int nullKey;
|
|
String key;
|
|
int i;
|
|
byte[] buffer;
|
|
|
|
count = reader.ReadInt32();
|
|
|
|
if (count > 0) {
|
|
nullKey = reader.ReadInt32();
|
|
|
|
d._serializedItems = new KeyedCollection(count);
|
|
|
|
// First, deserialize all the keys
|
|
for (i = 0; i < count; i++) {
|
|
if (i == nullKey) {
|
|
key = null;
|
|
}
|
|
else {
|
|
key = reader.ReadString();
|
|
}
|
|
|
|
// Need to set them with null value first, so that
|
|
// the order of them items is correct.
|
|
d.BaseSet(key, null);
|
|
}
|
|
|
|
// Next, deserialize all the offsets
|
|
// First offset will be 0, and the data length will be the first read offset
|
|
int offset0 = reader.ReadInt32();
|
|
d._serializedItems[d.BaseGetKey(0)] = new SerializedItemPosition(0, offset0);
|
|
|
|
int offset1 = 0;
|
|
for (i = 1; i < count; i++) {
|
|
offset1 = reader.ReadInt32();
|
|
d._serializedItems[d.BaseGetKey(i)] = new SerializedItemPosition(offset0, offset1 - offset0);
|
|
offset0 = offset1;
|
|
}
|
|
|
|
//
|
|
d._iLastOffset = offset0;
|
|
|
|
Debug.Trace("SessionStateItemCollection",
|
|
"Deserialize: _iLastOffset= " + d._iLastOffset);
|
|
|
|
// _iLastOffset is the first byte past the last item, which equals
|
|
// the total length of all serialized data
|
|
buffer = new byte[d._iLastOffset];
|
|
int bytesRead = reader.BaseStream.Read(buffer, 0, d._iLastOffset);
|
|
if (bytesRead != d._iLastOffset) {
|
|
throw new HttpException(SR.GetString(SR.Invalid_session_state));
|
|
}
|
|
d._stream = new MemoryStream(buffer);
|
|
}
|
|
|
|
#if DBG
|
|
Debug.Assert(reader.ReadByte() == 0xff);
|
|
#endif
|
|
|
|
d._dirty = false;
|
|
|
|
return d;
|
|
}
|
|
}
|
|
}
|