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();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|