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
435 lines
14 KiB
C#
435 lines
14 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="HttpInputStream.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
/*
|
|
* Input stream used in response and uploaded file objects
|
|
*
|
|
* Copyright (c) 1998 Microsoft Corporation
|
|
*/
|
|
|
|
namespace System.Web {
|
|
|
|
using System.IO;
|
|
using System.CodeDom.Compiler; // needed for TempFilesCollection
|
|
using System.Security;
|
|
using System.Security.Permissions;
|
|
using System.Web.Hosting;
|
|
|
|
|
|
/*
|
|
* Wrapper around temporary file or byte[] for input stream
|
|
*
|
|
* Pattern of use:
|
|
* ctor
|
|
* AddBytes
|
|
* ...
|
|
* DoneAddingBytes
|
|
* access bytes: [] / CopyBytes / WriteBytes / GetAsByteArray
|
|
* Dispose
|
|
*/
|
|
internal class HttpRawUploadedContent : IDisposable {
|
|
private int _fileThreshold; // for sizes over this use file
|
|
private int _expectedLength;// content-length
|
|
private bool _completed; // true when all data's in
|
|
private int _length; // length of the data
|
|
private byte[] _data; // contains data (either all of it or part read from file)
|
|
private TempFile _file; // temporary file with content (null when using byte[])
|
|
private int _chunkOffset; // which part of file is cached in data - offset
|
|
private int _chunkLength; // which part of file is cached in data - length
|
|
|
|
internal HttpRawUploadedContent(int fileThreshold, int expectedLength) {
|
|
_fileThreshold = fileThreshold;
|
|
_expectedLength = expectedLength;
|
|
|
|
if (_expectedLength >= 0 && _expectedLength < _fileThreshold)
|
|
_data = new byte[_expectedLength];
|
|
else
|
|
_data = new byte[_fileThreshold];
|
|
}
|
|
|
|
public void Dispose() {
|
|
if (_file != null)
|
|
_file.Dispose();
|
|
}
|
|
|
|
internal void AddBytes(byte[] data, int offset, int length) {
|
|
if (_completed)
|
|
throw new InvalidOperationException();
|
|
|
|
if (length <= 0)
|
|
return;
|
|
|
|
if (_file == null) {
|
|
// fits in the existing _data
|
|
if (_length + length <= _data.Length) {
|
|
Array.Copy(data, offset, _data, _length, length);
|
|
_length += length;
|
|
return;
|
|
}
|
|
|
|
// doesn't fit in _data but still under threshold
|
|
// possible if content-length is -1, or when filtering
|
|
if (_length + length <= _fileThreshold) {
|
|
byte[] newData = new byte[_fileThreshold];
|
|
if (_length > 0)
|
|
Array.Copy(_data, 0, newData, 0, _length);
|
|
Array.Copy(data, offset, newData, _length, length);
|
|
|
|
_data = newData;
|
|
_length += length;
|
|
return;
|
|
}
|
|
|
|
// need to convert to file
|
|
_file = new TempFile();
|
|
_file.AddBytes(_data, 0, _length);
|
|
}
|
|
|
|
// using file
|
|
_file.AddBytes(data, offset, length);
|
|
_length += length;
|
|
}
|
|
|
|
internal void DoneAddingBytes() {
|
|
if (_data == null)
|
|
_data = new byte[0];
|
|
|
|
if (_file != null)
|
|
_file.DoneAddingBytes();
|
|
|
|
_completed = true;
|
|
}
|
|
|
|
internal int Length {
|
|
get { return _length; }
|
|
}
|
|
|
|
internal byte this[int index] {
|
|
get {
|
|
if (!_completed)
|
|
throw new InvalidOperationException();
|
|
|
|
// all data in memory
|
|
if (_file == null)
|
|
return _data[index];
|
|
|
|
// index in the chunk already read
|
|
if (index >= _chunkOffset && index < _chunkOffset + _chunkLength)
|
|
return _data[index - _chunkOffset];
|
|
|
|
// check bounds
|
|
if (index < 0 || index >= _length)
|
|
throw new ArgumentOutOfRangeException("index");
|
|
|
|
// read from file
|
|
_chunkLength = _file.GetBytes(index, _data.Length, _data, 0);
|
|
_chunkOffset = index;
|
|
return _data[0];
|
|
}
|
|
}
|
|
|
|
internal void CopyBytes(int offset, byte[] buffer, int bufferOffset, int length) {
|
|
if (!_completed)
|
|
throw new InvalidOperationException();
|
|
|
|
if (_file != null) {
|
|
if (offset >= _chunkOffset && offset+length < _chunkOffset + _chunkLength) {
|
|
// preloaded
|
|
Array.Copy(_data, offset - _chunkOffset, buffer, bufferOffset, length);
|
|
}
|
|
else {
|
|
if (length <= _data.Length) {
|
|
// read from file and remember the chunk
|
|
_chunkLength = _file.GetBytes(offset, _data.Length, _data, 0);
|
|
_chunkOffset = offset;
|
|
Array.Copy(_data, offset - _chunkOffset, buffer, bufferOffset, length);
|
|
}
|
|
else {
|
|
// read from file
|
|
_file.GetBytes(offset, length, buffer, bufferOffset);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
Array.Copy(_data, offset, buffer, bufferOffset, length);
|
|
}
|
|
}
|
|
|
|
internal void WriteBytes(int offset, int length, Stream stream) {
|
|
if (!_completed)
|
|
throw new InvalidOperationException();
|
|
|
|
if (_file != null) {
|
|
int readPosition = offset;
|
|
int bytesRemaining = length;
|
|
byte[] buf = new byte[bytesRemaining > _fileThreshold ? _fileThreshold : bytesRemaining];
|
|
|
|
while (bytesRemaining > 0) {
|
|
int bytesToRead = bytesRemaining > _fileThreshold ? _fileThreshold : bytesRemaining;
|
|
int bytesRead = _file.GetBytes(readPosition, bytesToRead, buf, 0);
|
|
if (bytesRead == 0)
|
|
break;
|
|
|
|
stream.Write(buf, 0, bytesRead);
|
|
|
|
readPosition += bytesRead;
|
|
bytesRemaining -= bytesRead;
|
|
}
|
|
}
|
|
else {
|
|
stream.Write(_data, offset, length);
|
|
}
|
|
}
|
|
|
|
internal byte[] GetAsByteArray() {
|
|
// If the request is chunked, _data can be much larger than
|
|
// the actual number of bytes read, and FillInFormCollection
|
|
// will call FillFromEncodedBytes and incorrectly append a
|
|
// bunch of zeros to the last form value. Therefore, we copy
|
|
// the data into a smaller array if _length < _data.Length
|
|
if (_file == null && _length == _data.Length) {
|
|
return _data;
|
|
}
|
|
return GetAsByteArray(0, _length);
|
|
}
|
|
|
|
internal byte[] GetAsByteArray(int offset, int length) {
|
|
if (!_completed)
|
|
throw new InvalidOperationException();
|
|
|
|
if (length == 0)
|
|
return new byte[0];
|
|
|
|
byte[] result = new byte[length];
|
|
CopyBytes(offset, result, 0, length);
|
|
return result;
|
|
}
|
|
|
|
// helper class for a temp file for large posted data
|
|
class TempFile : IDisposable {
|
|
TempFileCollection _tempFiles;
|
|
String _filename;
|
|
Stream _filestream;
|
|
|
|
internal TempFile() {
|
|
// suspend the impersonation for the file creation
|
|
using (new ApplicationImpersonationContext()) {
|
|
String tempDir = Path.Combine(HttpRuntime.CodegenDirInternal, "uploads");
|
|
|
|
// Assert IO access to the temporary directory
|
|
new FileIOPermission(FileIOPermissionAccess.AllAccess, tempDir).Assert();
|
|
|
|
if (!Directory.Exists(tempDir)) {
|
|
try {
|
|
Directory.CreateDirectory(tempDir);
|
|
}
|
|
catch {
|
|
}
|
|
}
|
|
|
|
_tempFiles = new TempFileCollection(tempDir, false /*keepFiles*/);
|
|
_filename = _tempFiles.AddExtension("post", false /*keepFiles*/);
|
|
//using 4096 as the buffer size, same as the BCL
|
|
_filestream = new FileStream(_filename, FileMode.Create, FileAccess.ReadWrite, FileShare.None, 4096, FileOptions.DeleteOnClose);
|
|
}
|
|
}
|
|
|
|
public void Dispose() {
|
|
// suspend the impersonation for the file creation
|
|
using (new ApplicationImpersonationContext()) {
|
|
try {
|
|
// force filestream handle to close
|
|
// since we're using FILE_FLAG_DELETE_ON_CLOSE
|
|
// this will delete it from disk as well
|
|
if (_filestream != null) {
|
|
_filestream.Close();
|
|
}
|
|
|
|
_tempFiles.Delete();
|
|
((IDisposable)_tempFiles).Dispose();
|
|
}
|
|
catch {
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void AddBytes(byte[] data, int offset, int length) {
|
|
if (_filestream == null)
|
|
throw new InvalidOperationException();
|
|
|
|
_filestream.Write(data, offset, length);
|
|
}
|
|
|
|
internal void DoneAddingBytes() {
|
|
if (_filestream == null)
|
|
throw new InvalidOperationException();
|
|
|
|
_filestream.Flush();
|
|
_filestream.Seek(0, SeekOrigin.Begin);
|
|
}
|
|
|
|
internal int GetBytes(int offset, int length, byte[] buffer, int bufferOffset) {
|
|
if (_filestream == null)
|
|
throw new InvalidOperationException();
|
|
|
|
_filestream.Seek(offset, SeekOrigin.Begin);
|
|
return _filestream.Read(buffer, bufferOffset, length);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Stream object over HttpRawUploadedContent
|
|
* Not a publc class - used internally, returned as Stream
|
|
*/
|
|
internal class HttpInputStream : Stream {
|
|
private HttpRawUploadedContent _data; // the buffer with the content
|
|
private int _offset; // offset to the start of this stream
|
|
private int _length; // length of this stream
|
|
private int _pos; // current reader posision
|
|
|
|
//
|
|
// Internal access (from this package)
|
|
//
|
|
|
|
internal HttpInputStream(HttpRawUploadedContent data, int offset, int length) {
|
|
Init(data, offset, length);
|
|
}
|
|
|
|
protected void Init(HttpRawUploadedContent data, int offset, int length) {
|
|
_data = data;
|
|
_offset = offset;
|
|
_length = length;
|
|
_pos = 0;
|
|
}
|
|
|
|
protected void Uninit() {
|
|
_data = null;
|
|
_offset = 0;
|
|
_length = 0;
|
|
_pos = 0;
|
|
}
|
|
|
|
internal byte[] GetAsByteArray() {
|
|
if (_length == 0)
|
|
return null;
|
|
|
|
return _data.GetAsByteArray(_offset, _length);
|
|
}
|
|
|
|
internal void WriteTo(Stream s) {
|
|
if (_data != null && _length > 0)
|
|
_data.WriteBytes(_offset, _length, s);
|
|
}
|
|
|
|
//
|
|
// BufferedStream implementation
|
|
//
|
|
|
|
public override bool CanRead {
|
|
get {return true;}
|
|
}
|
|
|
|
public override bool CanSeek {
|
|
get {return true;}
|
|
}
|
|
|
|
public override bool CanWrite {
|
|
get {return false;}
|
|
}
|
|
|
|
public override long Length {
|
|
get {return _length;}
|
|
}
|
|
|
|
public override long Position {
|
|
get {return _pos;}
|
|
|
|
set {
|
|
Seek(value, SeekOrigin.Begin);
|
|
}
|
|
}
|
|
|
|
protected override void Dispose(bool disposing) {
|
|
try {
|
|
if (disposing)
|
|
Uninit();
|
|
}
|
|
finally {
|
|
base.Dispose(disposing);
|
|
}
|
|
}
|
|
|
|
public override void Flush() {
|
|
}
|
|
|
|
public override long Seek(long offset, SeekOrigin origin) {
|
|
int newpos = _pos;
|
|
int offs = (int)offset;
|
|
|
|
switch (origin) {
|
|
case SeekOrigin.Begin:
|
|
newpos = offs;
|
|
break;
|
|
case SeekOrigin.Current:
|
|
newpos = _pos + offs;
|
|
break;
|
|
case SeekOrigin.End:
|
|
newpos = _length + offs;
|
|
break;
|
|
default:
|
|
throw new ArgumentOutOfRangeException("origin");
|
|
}
|
|
|
|
if (newpos < 0 || newpos > _length)
|
|
throw new ArgumentOutOfRangeException("offset");
|
|
|
|
_pos = newpos;
|
|
return _pos;
|
|
}
|
|
|
|
public override void SetLength(long length) {
|
|
throw new NotSupportedException();
|
|
}
|
|
|
|
public override int Read(byte[] buffer, int offset, int count) {
|
|
// find the number of bytes to copy
|
|
int numBytes = _length - _pos;
|
|
if (count < numBytes)
|
|
numBytes = count;
|
|
|
|
// copy the bytes
|
|
if (numBytes > 0)
|
|
_data.CopyBytes(_offset + _pos, buffer, offset, numBytes);
|
|
|
|
// adjust the position
|
|
_pos += numBytes;
|
|
return numBytes;
|
|
}
|
|
|
|
public override void Write(byte[] buffer, int offset, int count) {
|
|
throw new NotSupportedException();
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Stream used as the source for input filtering
|
|
*/
|
|
|
|
internal class HttpInputStreamFilterSource : HttpInputStream {
|
|
internal HttpInputStreamFilterSource() : base(null, 0, 0) {
|
|
}
|
|
|
|
internal void SetContent(HttpRawUploadedContent data) {
|
|
if (data != null)
|
|
base.Init(data, 0, data.Length);
|
|
else
|
|
base.Uninit();
|
|
}
|
|
}
|
|
|
|
}
|