public ProgressWorkerRequest(HttpWorkerRequest wr, HttpRequest request)
{
this._originalWorkerRequest = wr;
this._request = request;
this._boundary = this.GetBoundary(this._request);
this._requestStateStore = new Areas.Lib.UploadProgress.Upload.RequestStateStore(this._request.ContentEncoding);
}
public HttpWorkerRequest GetNextRequest (HttpWorkerRequest req)
{
if (!CanExecuteRequest (req)) {
if (req != null) {
lock (queue) {
Queue (req);
}
}
return null;
}
HttpWorkerRequest result;
lock (queue) {
result = Dequeue ();
if (result != null) {
if (req != null)
Queue (req);
} else {
result = req;
}
}
return result;
}
protected DecoratedWorkerRequest(HttpWorkerRequest origWorker)
{
if (log.IsDebugEnabled) log.Debug("origWorker=" + origWorker);
OrigWorker = origWorker;
// Remember the original HttpContext so that it can be used by UploadHttpModule.AppendToLog().
OrigContext = HttpContext.Current;
}
public TestWebContext(string virtualPath, string page)
{
_out = new StringWriter();
HttpWorkerRequest wr;
AppDomain domain = Thread.GetDomain();
// are we running within a valid AspNet AppDomain?
string appPath = (string) domain.GetData(".appPath");
if (appPath != null)
{
wr = new SimpleWorkerRequest(page, string.Empty, _out);
}
else
{
appPath = domain.BaseDirectory + "\\";
wr = new SimpleWorkerRequest(virtualPath, appPath, page, string.Empty, _out);
}
HttpContext ctx = new HttpContext(wr);
HttpContext.Current = ctx;
HttpBrowserCapabilities browser = new HttpBrowserCapabilities();
browser.Capabilities = new CaseInsensitiveHashtable(); //CollectionsUtil.CreateCaseInsensitiveHashtable();
browser.Capabilities[string.Empty] = "Test User Agent"; // string.Empty is the key for "user agent"
// avoids NullReferenceException when accessing HttpRequest.FilePath
object virtualPathObject = ExpressionEvaluator.GetValue(null, "T(System.Web.VirtualPath).Create('/')");
object cachedPathData = ExpressionEvaluator.GetValue(null, "T(System.Web.CachedPathData).GetRootWebPathData()");
ExpressionEvaluator.SetValue(cachedPathData, "_virtualPath", virtualPathObject);
ExpressionEvaluator.SetValue(cachedPathData, "_physicalPath", appPath);
ctx.Request.Browser = browser;
string filePath = ctx.Request.FilePath;
_wr = wr;
}
// This constructor creates the header collection for response headers.
// Try to preallocate the base collection with a size that should be sufficient
// to store the headers for most requests.
internal HttpHeaderCollection(HttpWorkerRequest wr, HttpResponse response, int capacity) : base(capacity) {
// if this is an IIS7WorkerRequest, then the collection will be writeable and we will
// call into IIS7 to update the header blocks when changes are made.
_iis7WorkerRequest = wr as IIS7WorkerRequest;
_response = response;
}
void IHttpResponseElement.Send(HttpWorkerRequest wr)
{
if (this._size > 0)
{
bool isBufferFromUnmanagedPool = false;
wr.SendResponseFromMemory(new IntPtr(this._data.ToInt64() + this._offset), this._size, isBufferFromUnmanagedPool);
}
}
public static KeyValuePair<HttpContext, HttpApplication> GetContext(HttpWorkerRequest wr, params IHttpModule[] modules) {
var ctx = new HttpContext(wr);
var app = new MyApp(modules);
SetHttpApplicationFactoryCustomApplication(app);
InitInternal(app, ctx);
AssignContext(app, ctx);
return new KeyValuePair<HttpContext, HttpApplication>(ctx, app);
}
public static RequestBufferlessStream CreateStream(HttpWorkerRequest workerRequest)
{
if (workerRequest == null)
throw new ArgumentNullException("workerRequest");
long totalBytes = (long)workerRequest.GetTotalEntityBodyLength();
return new RequestBufferlessStream(workerRequest, totalBytes);
}
void IHttpResponseElement.Send(HttpWorkerRequest wr)
{
if (this._size > 0)
{
bool isBufferFromUnmanagedPool = false;
wr.SendResponseFromMemory(new IntPtr(this._data.ToInt64() + this._offset), this._size, isBufferFromUnmanagedPool);
}
}
private bool CheckClientConnected(HttpWorkerRequest wr)
{
if ((DateTime.UtcNow - wr.GetStartTime()) > this._clientConnectedTime)
{
return wr.IsClientConnected();
}
return true;
}
private bool CheckClientConnected(HttpWorkerRequest wr)
{
if ((DateTime.UtcNow - wr.GetStartTime()) > this._clientConnectedTime)
{
return(wr.IsClientConnected());
}
return(true);
}
// This constructor creates the header collection for response headers.
// Try to preallocate the base collection with a size that should be sufficient
// to store the headers for most requests.
internal HttpHeaderCollection(HttpWorkerRequest wr, HttpResponse response, int capacity) : base(capacity) {
// if this is an IIS7WorkerRequest, then the collection will be writeable and we will
// call into IIS7 to update the header blocks when changes are made.
_iis7WorkerRequest = wr as IIS7WorkerRequest;
_response = response;
}
void IHttpResponseElement.Send(HttpWorkerRequest wr)
{
int length = base._size - base._free;
if (length > 0)
{
wr.SendResponseFromMemory(this._data, length);
}
}
// Caller may invoke this repeatedly until EndRead returns zero, at which point the entire entity has been read.
public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, Object state)
{
HttpWorkerRequest wr = _context.WorkerRequest;
// Only perform an async read if the worker request supports it and we're not in a cancellable period.
// If we were to allow async read in a cancellable period, the timeout manager could raise a ThreadAbortEx and
// corrupt the state of the request.
if (wr != null && wr.SupportsAsyncRead && !_context.IsInCancellablePeriod)
{
if (!_preloadedContentRead)
{
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
if (offset < 0)
{
throw new ArgumentOutOfRangeException("offset");
}
if (count < 0)
{
throw new ArgumentOutOfRangeException("count");
}
if (buffer.Length - offset < count)
{
throw new ArgumentException(SR.GetString(SR.InvalidOffsetOrCount, "offset", "count"));
}
_preloadedBytesRead = GetPreloadedContent(buffer, ref offset, ref count);
}
if (_remainingBytes == 0)
{
// set count to zero and invoke BeginRead to return an async result
count = 0;
}
if (_persistEntityBody)
{
// hold a reference so we can add bytes to _rawContent when EndRead is called
_buffer = buffer;
_offset = offset;
_count = count;
}
try {
return(wr.BeginRead(buffer, offset, count, callback, state));
}
catch (HttpException) {
if (_persistEntityBody)
{
SetRawContentOnce();
}
throw;
}
}
else
{
// perform a sync read
return(base.BeginRead(buffer, offset, count, callback, state));
}
}
// method called from HttpRuntime for incoming requests
internal HttpWorkerRequest GetRequestToExecute(HttpWorkerRequest wr)
{
int workerThreads, ioThreads;
ThreadPool.GetAvailableThreads(out workerThreads, out ioThreads);
int freeThreads;
if (_iis6)
{
freeThreads = workerThreads; // ignore IO threads to avoid starvation from Indigo TCP requests
}
else
{
freeThreads = (ioThreads > workerThreads) ? workerThreads : ioThreads;
}
// fast path when there are threads available and nothing queued
if (freeThreads >= _minExternFreeThreads && _count == 0)
{
return(wr);
}
bool isLocal = IsLocal(wr);
// fast path when there are threads for local requests available and nothing queued
if (isLocal && freeThreads >= _minLocalFreeThreads && _count == 0)
{
return(wr);
}
// reject if queue limit exceeded
if (_count >= _queueLimit)
{
HttpRuntime.RejectRequestNow(wr, false);
return(null);
}
// can't execute the current request on the current thread -- need to queue
QueueRequest(wr, isLocal);
// maybe can execute a request previously queued
if (freeThreads >= _minExternFreeThreads)
{
wr = DequeueRequest(false); // enough threads to process even external requests
}
else if (freeThreads >= _minLocalFreeThreads)
{
wr = DequeueRequest(true); // enough threads to process only local requests
}
else
{
wr = null; // not enough threads -> do nothing on this thread
ScheduleMoreWorkIfNeeded(); // try to schedule to worker thread
}
return(wr);
}
public HttpContext(HttpWorkerRequest wr)
{
WorkerRequest = wr;
request = new HttpRequest(WorkerRequest, this);
response = new HttpResponse(WorkerRequest, this);
#if NET_4_0
SessionStateBehavior = SessionStateBehavior.Default;
#endif
}
/*
* Write HttpWorkerRequest
*/
/*public*/ void IHttpResponseElement.Send(HttpWorkerRequest wr)
{
int n = _size - _free;
if (n > 0)
{
wr.SendResponseFromMemory(_data, n);
}
}
public override void Send(HttpWorkerRequest wr)
{
if (length == 0)
{
return;
}
blocks.Send(wr, start, length);
}
public void Send(HttpWorkerRequest wr, int start, int end)
{
if (end - start <= 0)
{
return;
}
wr.SendResponseFromMemory((IntPtr)(data + start), end - start);
}
// We preallocate the base collection with a size that should be sufficient
// to store all server variables w/o having to expand
internal HttpServerVarsCollection(HttpWorkerRequest wr, HttpRequest request) : base(59) {
// if this is an IIS7WorkerRequest, then the collection will be writeable and we will
// call into IIS7 to update the server var block when changes are made.
_iis7workerRequest = wr as IIS7WorkerRequest;
_request = request;
_populated = false;
Debug.Assert( _request != null );
}
void IHttpResponseElement.Send(HttpWorkerRequest wr)
{
int length = base._size - base._free;
if (length > 0)
{
wr.SendResponseFromMemory(this._data, length, true);
}
}
public override void Send(HttpWorkerRequest wr)
{
if (_position == 0)
{
return;
}
wr.SendResponseFromMemory(buffer, 0, _position, _encoding);
}
internal void SetWorkerRequest(HttpWorkerRequest wr)
{
worker_request = wr;
current_exe_path = null;
file_path = null;
base_virtual_dir = null;
form = null;
all_params = null;
}
bool CanExecuteRequest (HttpWorkerRequest req)
{
if (disposing)
return false;
int threads, cports;
ThreadPool.GetAvailableThreads (out threads, out cports);
bool local = (req != null && req.GetLocalAddress () == "127.0.0.1");
return (threads > minFree) || (local && threads > minLocalFree);
}
public HttpContext (HttpWorkerRequest WorkerRequest)
{
Context = this;
_oTimestamp = DateTime.Now;
_oRequest = new HttpRequest (WorkerRequest, this);
_oResponse = new HttpResponse (WorkerRequest, this);
_oWorkerRequest = WorkerRequest;
_oTrace = new TraceContext (this);
}
// We preallocate the base collection with a size that should be sufficient
// to store all server variables w/o having to expand
internal HttpServerVarsCollection(HttpWorkerRequest wr, HttpRequest request) : base(59)
{
// if this is an IIS7WorkerRequest, then the collection will be writeable and we will
// call into IIS7 to update the server var block when changes are made.
_iis7workerRequest = wr as IIS7WorkerRequest;
_request = request;
_populated = false;
Debug.Assert(_request != null);
}
void UnsafeWrite(HttpWorkerRequest wr, byte [] buffer, int offset, int count)
{
if (count <= 0)
{
return;
}
byte [] copy = new byte [count];
Array.Copy(buffer, offset, copy, 0, count);
wr.SendResponseFromMemory(copy, count);
}
internal void Send(HttpWorkerRequest wr)
{
if (_knownHeaderIndex >= 0)
{
wr.SendKnownResponseHeader(_knownHeaderIndex, _value);
}
else
{
wr.SendUnknownResponseHeader(_unknownHeader, _value);
}
}
static void RealProcessRequest(object o)
{
HttpWorkerRequest req = (HttpWorkerRequest)o;
bool started_internally = req.StartedInternally;
do
{
Process(req);
req = QueuePendingRequest(started_internally);
} while (started_internally && req != null);
}
HttpWorkerRequest Dequeue()
{
if (queue.Count > 0)
{
HttpWorkerRequest request = (HttpWorkerRequest)queue.Dequeue();
requestsQueuedCounter.Decrement();
return(request);
}
return(null);
}
internal void Send(HttpWorkerRequest wr)
{
if (this._knownHeaderIndex >= 0)
{
wr.SendKnownResponseHeader(this._knownHeaderIndex, this._value);
}
else
{
wr.SendUnknownResponseHeader(this._unknownHeader, this._value);
}
}
void Queue(HttpWorkerRequest wr)
{
if (queue.Count < queueLimit)
{
queue.Enqueue(wr);
requestsQueuedCounter.Increment();
return;
}
HttpRuntime.FinishUnavailable(wr);
}
// When this returns zero, the entire entity has been read.
public override int EndRead(IAsyncResult asyncResult)
{
HttpWorkerRequest wr = _context.WorkerRequest;
if (wr != null && wr.SupportsAsyncRead && !_context.IsInCancellablePeriod)
{
int totalBytesRead = _preloadedBytesRead;
if (_preloadedBytesRead > 0)
{
_preloadedBytesRead = 0;
}
int bytesRead = 0;
try {
bytesRead = wr.EndRead(asyncResult);
}
catch (HttpException) {
if (_persistEntityBody)
{
SetRawContentOnce();
}
throw;
}
totalBytesRead += bytesRead;
if (bytesRead > 0)
{
if (_persistEntityBody)
{
if (_rawContent != null)
{
_rawContent.AddBytes(_buffer, _offset, bytesRead);
}
_buffer = null;
_offset = 0;
_count = 0;
}
int dummy1 = 0, dummy2 = 0, dummy3 = 0;
UpdateCounters(bytesRead, ref dummy1, ref dummy2, ref dummy3);
}
if (_persistEntityBody
// we might attempt a read with count == 0, in which case bytesRead will
// be zero but we may not be done reading the entity body. Don't set raw
// content until bytesRead is 0 and count is not 0 or _remainingBytes is 0
&& ((bytesRead == 0 && _count != 0) || _remainingBytes == 0))
{
SetRawContentOnce();
}
return(totalBytesRead);
}
else
{
return(base.EndRead(asyncResult));
}
}
// ctor used in HttpRuntime
internal HttpContext(HttpWorkerRequest wr, bool initResponseWriter)
{
_wr = wr;
Init(new HttpRequest(wr, this), new HttpResponse(wr, this));
if (initResponseWriter)
{
_response.InitResponseWriter();
}
PerfCounters.IncrementCounter(AppPerfCounter.REQUESTS_EXECUTING);
}
internal HttpResponse(HttpWorkerRequest worker_request, HttpContext context) : this()
{
WorkerRequest = worker_request;
this.context = context;
#if !TARGET_J2EE
if (worker_request != null)
{
use_chunked = (worker_request.GetHttpVersion() == "HTTP/1.1");
}
#endif
}
//
// This is called from the QueueManager if a request
// can not be processed (load, no resources, or
// appdomain unload).
//
static internal void FinishUnavailable(HttpWorkerRequest wr)
{
wr.SendStatus(503, "Service unavailable");
wr.SendUnknownResponseHeader("Connection", "close");
Encoding enc = Encoding.ASCII;
wr.SendUnknownResponseHeader("Content-Type", "text/html; charset=" + enc.WebName);
byte [] contentBytes = enc.GetBytes(content503);
wr.SendUnknownResponseHeader("Content-Length", contentBytes.Length.ToString());
wr.SendResponseFromMemory(contentBytes, contentBytes.Length);
wr.FlushResponse(true);
wr.CloseConnection();
HttpApplication.requests_total_counter.Increment();
}
void IHttpResponseElement.Send(HttpWorkerRequest wr)
{
if (this._size > 0L)
{
if (this._useTransmitFile)
{
wr.TransmitFile(this._filename, this._offset, this._size, this._isImpersonating);
}
else
{
wr.SendResponseFromFile(this._filename, this._offset, this._size);
}
}
}
bool CanExecuteRequest(HttpWorkerRequest req)
{
if (disposing)
{
return(false);
}
int threads, cports;
ThreadPool.GetAvailableThreads(out threads, out cports);
bool local = (req != null && req.GetLocalAddress() == "127.0.0.1");
return((threads > minFree) || (local && threads > minLocalFree));
}
internal HttpResponseHeader(string unknownHeader, string value, bool enableHeaderChecking)
{
if (enableHeaderChecking)
{
HttpEncoder.Current.HeaderNameValueEncode(unknownHeader, value, out _unknownHeader, out _value);
_knownHeaderIndex = HttpWorkerRequest.GetKnownResponseHeaderIndex(_unknownHeader);
}
else
{
_unknownHeader = unknownHeader;
_knownHeaderIndex = HttpWorkerRequest.GetKnownResponseHeaderIndex(_unknownHeader);
_value = value;
}
}
public AsyncUpload(HttpWorkerRequest wRquest)
{
if (wRquest == null) throw new ArgumentNullException("wRquest");
this.uploadProcess = new UploadProcess(delegate(float f) { });
workerRequest = wRquest;
//当前读到的流长度
this.preLen = workerRequest.GetPreloadedEntityBodyLength();
//请求流的总长度
this.totLen = workerRequest.GetTotalEntityBodyLength();
//内容分隔符 如: -----------------------------152733254716788
if (preLen == 0 && workerRequest.IsClientConnected() && workerRequest.HasEntityBody())
{
byte[] buffer = new byte[8192];
preLen = workerRequest.ReadEntityBody(buffer, buffer.Length);
byte[] buf = new byte[preLen];
for (int i = 0; i < buf.Length; i++) buf[i] = buffer[i];
this.perBodyBytes = buf;
}
else
this.perBodyBytes = workerRequest.GetPreloadedEntityBody();
this.headerBytes = this.GetBoundaryBytes(Encoding.UTF8.GetBytes(workerRequest.GetKnownRequestHeader(HttpWorkerRequest.HeaderContentType)));
//请求流尾部分隔符 如: -----------------------------152733254716788--
this.contentEnd = new byte[this.headerBytes.Length + 2];
this.headerBytes.CopyTo(this.contentEnd, 0);
this.contentEnd[this.headerBytes.Length] = 45;
this.contentEnd[this.headerBytes.Length + 1] = 45;
//当前流中第一个文件分隔符的位置
int fHeaderPosition = perBodyBytes.Indexof(fileNameHeader);
//尝试在已读取到的流中找文件尾位置
this.fEndPosition = perBodyBytes.Indexof(contentEnd);
if (fHeaderPosition > -1)
{
//先找到文件名
IList<byte> bufList = new List<byte>();
int i = fHeaderPosition + fileNameHeader.Length;
while (i < perBodyBytes.Length)
{
if (perBodyBytes[i] == 34) break;
bufList.Add(perBodyBytes[i]);
i++;
}
this.FileName = Encoding.UTF8.GetString(bufList.ToArray());//file name
this.fPosition = perBodyBytes.Indexof(wrapBytes, i) + 4;//当前流中此文件的开始位置
this.FileLength = this.totLen - this.fPosition;
}
}
/*
* Write HttpWorkerRequest
*/
/*public*/ void IHttpResponseElement.Send(HttpWorkerRequest wr)
{
if (_size > 0)
{
if (_filename != null)
{
wr.SendResponseFromFile(_filename, _offset, _size);
}
else
{
wr.SendResponseFromFile(_fileHandle, _offset, _size);
}
}
}
public RequestStream(HttpWorkerRequest request)
{
this.request = request;
tempBuff = request.GetPreloadedEntityBody();
_contentLength = long.Parse(request.GetKnownRequestHeader(HttpWorkerRequest.HeaderContentLength));
// Handle the case where GetPreloadedEntityBody is null -- e.g. Mono
if (tempBuff == null || tempBuff.Length == 0)
{
isInPreloaded = false;
}
}
private HttpWorkerRequest DequeueRequest(bool localOnly)
{
HttpWorkerRequest wr = null;
while (_count > 0)
{
lock (this) {
if (_localQueue.Count > 0)
{
wr = (HttpWorkerRequest)_localQueue.Dequeue();
_count--;
}
else if (!localOnly && _externQueue.Count > 0)
{
wr = (HttpWorkerRequest)_externQueue.Dequeue();
_count--;
}
}
if (wr == null)
{
break;
}
else
{
PerfCounters.DecrementGlobalCounter(GlobalPerfCounter.REQUESTS_QUEUED);
PerfCounters.DecrementCounter(AppPerfCounter.REQUESTS_IN_APPLICATION_QUEUE);
if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Information, EtwTraceFlags.Infrastructure))
{
EtwTrace.Trace(EtwTraceType.ETW_TYPE_REQ_DEQUEUED, wr);
}
if (!CheckClientConnected(wr))
{
HttpRuntime.RejectRequestNow(wr, true);
wr = null;
PerfCounters.IncrementGlobalCounter(GlobalPerfCounter.REQUESTS_DISCONNECTED);
PerfCounters.IncrementCounter(AppPerfCounter.APP_REQUEST_DISCONNECTED);
}
else
{
break;
}
}
}
return(wr);
}
protected override string InternalGet(string name)
{
int headerIndex = HttpWorkerRequest.GetKnownRequestHeaderIndex(name);
string headerValue = null;
if (headerIndex >= 0)
{
headerValue = _request.WorkerRequest.GetKnownRequestHeader(headerIndex);
}
if (headerValue == null)
{
headerValue = _request.WorkerRequest.GetUnknownRequestHeader(name);
}
return(headerValue);
}
internal HttpClientCertificate (HttpWorkerRequest hwr)
{
// we don't check hwr for null so we end up throwing a
// NullReferenceException just like MS implementation
// if the public ctor for HttpRequest is used
this.hwr = hwr;
flags = GetIntNoPresense ("CERT_FLAGS");
if (IsPresent) {
from = hwr.GetClientCertificateValidFrom ();
until = hwr.GetClientCertificateValidUntil ();
} else {
from = DateTime.Now;
until = from;
}
}
void IHttpResponseElement.Send(HttpWorkerRequest wr)
{
if (this._isIIS7WorkerRequest)
{
IIS7WorkerRequest request = wr as IIS7WorkerRequest;
if (request != null)
{
request.SendResponseFromIISAllocatedRequestMemory(this._firstSubstData, this._firstSubstDataSize);
}
}
else
{
this._firstSubstitution.Send(wr);
}
}
internal void Flush(HttpWorkerRequest wr, bool final_flush)
{
if (!dirty && !final_flush)
{
return;
}
for (Bucket b = first_bucket; b != null; b = b.Next)
{
b.Send(wr);
}
wr.FlushResponse(final_flush);
Clear();
}
static void Redirect (HttpWorkerRequest wr, string location)
{
string host = wr.GetKnownRequestHeader (HttpWorkerRequest.HeaderHost);
wr.SendStatus (301, "Moved Permanently");
wr.SendUnknownResponseHeader ("Connection", "close");
wr.SendUnknownResponseHeader ("Date", DateTime.Now.ToUniversalTime ().ToString ("r"));
wr.SendUnknownResponseHeader ("Location", String.Format ("{0}://{1}{2}", wr.GetProtocol(), host, location));
Encoding enc = Encoding.ASCII;
wr.SendUnknownResponseHeader ("Content-Type", "text/html; charset=" + enc.WebName);
string content = String.Format (CONTENT301, host, location);
byte [] contentBytes = enc.GetBytes (content);
wr.SendUnknownResponseHeader ("Content-Length", contentBytes.Length.ToString ());
wr.SendResponseFromMemory (contentBytes, contentBytes.Length);
wr.FlushResponse (true);
wr.CloseConnection ();
}
private void QueueRequest(HttpWorkerRequest wr, bool isLocal) {
lock (this) {
if (isLocal) {
_localQueue.Enqueue(wr);
}
else {
_externQueue.Enqueue(wr);
}
_count++;
}
PerfCounters.IncrementGlobalCounter(GlobalPerfCounter.REQUESTS_QUEUED);
PerfCounters.IncrementCounter(AppPerfCounter.REQUESTS_IN_APPLICATION_QUEUE);
if (EtwTrace.IsTraceEnabled(EtwTraceLevel.Information, EtwTraceFlags.Infrastructure)) EtwTrace.Trace(EtwTraceType.ETW_TYPE_REQ_QUEUED, wr);
}
/// <summary>
/// Gets the response.
/// </summary>
/// <param name="workerRequest">The worker request.</param>
/// <returns>The <see cref="Response"/>.</returns>
protected virtual Response GetResponse(HttpWorkerRequest workerRequest)
{
if (workerRequest == null)
{
throw new ArgumentNullException("workerRequest");
}
WorkerRequest workerRequestCandidate = workerRequest as WorkerRequest;
if (workerRequestCandidate == null)
{
throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, "workerRequest is of improper type. It should be based on {0}", typeof(WorkerRequest).AssemblyQualifiedName));
}
return workerRequestCandidate.Response;
}
internal static bool IsUploadStatusRequest(HttpWorkerRequest request, out string id)
{
id = string.Empty;
if (request.GetHttpVerbName() != GetVerbName)
return false;
Match m = _getUploadId.Match(request.GetRawUrl());
if (!m.Success)
return false;
id = m.Value;
return true;
}
// helpers
private static bool IsLocal(HttpWorkerRequest wr) {
String remoteAddress = wr.GetRemoteAddress();
// check if localhost
if (remoteAddress == "127.0.0.1" || remoteAddress == "::1")
return true;
// if unknown, assume not local
if (String.IsNullOrEmpty(remoteAddress))
return false;
// compare with local address
if (remoteAddress == wr.GetLocalAddress())
return true;
return false;
}
private static void ResolveWorkerRequestType(HttpWorkerRequest workerRequest)
{
if (workerRequest is IIS7WorkerRequest)
{
s_WrType = EtwWorkerRequestType.IIS7Integrated;
}
else if (workerRequest is ISAPIWorkerRequestInProc)
{
s_WrType = EtwWorkerRequestType.InProc;
}
else if (workerRequest is ISAPIWorkerRequestOutOfProc)
{
s_WrType = EtwWorkerRequestType.OutOfProc;
}
else
{
s_WrType = EtwWorkerRequestType.Unknown;
}
}
internal void SendContent (HttpWorkerRequest WorkerRequest)
{
// use URL encoding on the value (see bug #75392)
// but only for CR and LF. Other characters are left untouched.
string actual_val = val;
if (actual_val != null) {
int crlf = actual_val.IndexOfAny (CRLF);
if (crlf >= 0) {
actual_val = actual_val.Replace ("\r", "%0d");
actual_val = actual_val.Replace ("\n", "%0a");
}
}
if (null != header) {
WorkerRequest.SendUnknownResponseHeader (header, actual_val);
} else {
WorkerRequest.SendKnownResponseHeader (header_id, actual_val);
}
}
// Determines whether or not a given HttpWorkerRequest meets the requirements for "same-origin"
// as called out in these two documents:
// - http://tools.ietf.org/html/rfc6454 (Web Origin)
// - http://tools.ietf.org/html/rfc6455 (WebSockets)
public static bool IsSameOriginRequest(HttpWorkerRequest workerRequest) {
string hostHeader = workerRequest.GetKnownRequestHeader(HttpWorkerRequest.HeaderHost);
if (String.IsNullOrEmpty(hostHeader)) {
// RFC 6455 (Sec. 4.1) and RFC 2616 (Sec. 14.23) make the "Host" header mandatory
return false;
}
string secWebSocketOriginHeader = workerRequest.GetUnknownRequestHeader("Origin");
if (String.IsNullOrEmpty(secWebSocketOriginHeader)) {
// RFC 6455 (Sec. 4.1) makes the "Origin" header mandatory for browser clients.
// Phone apps, console clients, and similar non-browser clients aren't required to send the header,
// but this method isn't intended for those use cases anyway, so we can fail them. (Note: it's still
// possible for a non-browser app to send the appropriate Origin header.)
return false;
}
// create URI instances from both the "Host" and the "Origin" headers
Uri hostHeaderUri = null;
Uri originHeaderUri = null;
bool urisCreatedSuccessfully = Uri.TryCreate(workerRequest.GetProtocol() + "://" + hostHeader.Trim(), UriKind.Absolute, out hostHeaderUri) // RFC 2616 (Sec. 14.23): "Host" header doesn't contain the scheme, so we need to prepend
&& Uri.TryCreate(secWebSocketOriginHeader.Trim(), UriKind.Absolute, out originHeaderUri);
if (!urisCreatedSuccessfully) {
// construction of one of the Uri instances failed
return false;
}
// RFC 6454 (Sec. 4), schemes must be normalized to lowercase. (And for WebSockets we only
// support HTTP / HTTPS anyway.)
if (originHeaderUri.Scheme != "http" && originHeaderUri.Scheme != "https") {
return false;
}
// RFC 6454 (Sec. 5), comparisons should be ordinal. The Uri class will automatically
// fill in the Port property using the default value for the scheme if the provided input doesn't
// explicitly contain a port number.
return hostHeaderUri.Scheme == originHeaderUri.Scheme
&& hostHeaderUri.Host == originHeaderUri.Host
&& hostHeaderUri.Port == originHeaderUri.Port;
}
string Fill (HttpWorkerRequest wr, bool standard)
{
StringBuilder sb = new StringBuilder ();
for (int i = 0; i < HttpWorkerRequest.RequestHeaderMaximum; i++){
string val = wr.GetKnownRequestHeader (i);
if (val == null || val == "")
continue;
string key = HttpWorkerRequest.GetKnownRequestHeaderName (i);
AppendKeyValue (sb, key, val, standard);
}
string [][] other = wr.GetUnknownRequestHeaders ();
if (other == null)
return sb.ToString ();
for (int i = other.Length; i > 0; ){
i--;
AppendKeyValue (sb, other [i][0], other [i][1], standard);
}
return sb.ToString ();
}
private ProgressWorkerRequest GetProgressWorker(HttpWorkerRequest workerRequest)
{
if (this.IsAsyncUploadRequest)
{
return new AsyncProgressWorkerRequest(workerRequest, this.Context.Request);
}
return new ProgressWorkerRequest(workerRequest, this.Context.Request);
}
internal HttpResponse (HttpWorkerRequest worker_request, HttpContext context) : this ()
{
WorkerRequest = worker_request;
this.context = context;
if (worker_request != null && worker_request.GetHttpVersion () == "HTTP/1.1") {
string gi = worker_request.GetServerVariable ("GATEWAY_INTERFACE");
use_chunked = (String.IsNullOrEmpty (gi) ||
!gi.StartsWith ("cgi", StringComparison.OrdinalIgnoreCase));
} else {
use_chunked = false;
}
writer = new HttpWriter (this);
}
public HttpUploadWorkerRequest(HttpWorkerRequest request)
{
_httpWorkerRequest = request;
_inspector = new EntityBodyInspector(this);
}
private static bool IsIIS7WorkerRequest(HttpWorkerRequest workerRequest)
{
return workerRequest.GetType().FullName == IIS7WorkerRequestTypeName;
}
