public static ServiceModelActivity BoundReceiveBytesOperation()
{
ServiceModelActivity activity = null;
if (DiagnosticUtility.ShouldUseActivity)
{
activity = ServiceModelActivity.CreateBoundedActivityWithTransferInOnly(Guid.NewGuid());
ServiceModelActivity.Start(activity, System.ServiceModel.SR.GetString("ActivityReceiveBytes", new object[] { TraceUtility.RetrieveMessageNumber() }), ActivityType.ReceiveBytes);
}
return(activity);
}
bool EnqueueContext(IAsyncResult listenerContextResult)
{
EventTraceActivity eventTraceActivity = null;
HttpListenerContext listenerContext;
bool enqueued = false;
if (FxTrace.Trace.IsEnd2EndActivityTracingEnabled)
{
eventTraceActivity = (EventTraceActivity)listenerContextResult.AsyncState;
if (eventTraceActivity == null)
{
eventTraceActivity = EventTraceActivity.GetFromThreadOrCreate(true);
}
}
using (LockHelper.TakeReaderLock(this.listenerRWLock))
{
if (this.listener == null)
{
return(true);
}
listenerContext = this.listener.EndGetContext(listenerContextResult);
}
// Grab the activity from the context and set that as the surrounding activity.
// If a message appears, we will transfer to the message's activity next
using (DiagnosticUtility.ShouldUseActivity ? ServiceModelActivity.BoundOperation(this.Activity) : null)
{
ServiceModelActivity activity = DiagnosticUtility.ShouldUseActivity ? ServiceModelActivity.CreateBoundedActivityWithTransferInOnly(listenerContext.Request.RequestTraceIdentifier) : null;
try
{
if (activity != null)
{
StartReceiveBytesActivity(activity, listenerContext.Request.Url);
}
if (DiagnosticUtility.ShouldTraceInformation)
{
TraceUtility.TraceHttpConnectionInformation(listenerContext.Request.LocalEndPoint.ToString(),
listenerContext.Request.RemoteEndPoint.ToString(), this);
}
base.TraceMessageReceived(eventTraceActivity, this.ListenUri);
HttpChannelListener channelListener;
if (base.TryLookupUri(listenerContext.Request.Url,
listenerContext.Request.HttpMethod,
this.HostNameComparisonMode,
listenerContext.Request.IsWebSocketRequest,
out channelListener))
{
HttpRequestContext context = HttpRequestContext.CreateContext(channelListener, listenerContext, eventTraceActivity);
IAsyncResult httpContextReceivedResult = channelListener.BeginHttpContextReceived(context,
onMessageDequeued,
onContextReceived,
DiagnosticUtility.ShouldUseActivity ? (object)new ActivityHolder(activity, context) : (object)context);
if (httpContextReceivedResult.CompletedSynchronously)
{
enqueued = EndHttpContextReceived(httpContextReceivedResult);
}
else
{
// The callback has been enqueued.
enqueued = true;
}
}
else
{
HandleMessageReceiveFailed(listenerContext);
}
}
finally
{
if (DiagnosticUtility.ShouldUseActivity && activity != null)
{
if (!enqueued)
{
// Error during enqueuing
activity.Dispose();
}
}
}
}
return(enqueued);
}
private void OnGetContextCore(IAsyncResult result)
{
bool flag = false;
while (!flag)
{
Exception exception = null;
try
{
try
{
HttpListenerContext listenerContext = null;
lock (base.ThisLock)
{
if (this.listener == null)
{
break;
}
listenerContext = this.listener.EndGetContext(result);
}
HttpChannelListener listener = null;
using (DiagnosticUtility.ShouldUseActivity ? ServiceModelActivity.BoundOperation(base.Activity) : null)
{
using (ServiceModelActivity activity = DiagnosticUtility.ShouldUseActivity ? ServiceModelActivity.CreateBoundedActivityWithTransferInOnly(listenerContext.Request.RequestTraceIdentifier) : null)
{
if (activity != null)
{
base.StartReceiveBytesActivity(activity, listenerContext.Request.Url);
}
if (DiagnosticUtility.ShouldTraceInformation)
{
TraceUtility.TraceHttpConnectionInformation(listenerContext.Request.LocalEndPoint.ToString(), listenerContext.Request.RemoteEndPoint.ToString(), this);
}
base.TraceMessageReceived(base.ListenUri);
if (base.TryLookupUri(listenerContext.Request.Url, listenerContext.Request.HttpMethod, base.HostNameComparisonMode, out listener))
{
flag = listener.HttpContextReceived(HttpRequestContext.CreateContext(listener, listenerContext), this.onMessageDequeued);
}
else
{
if (DiagnosticUtility.ShouldTraceWarning)
{
TraceUtility.TraceEvent(TraceEventType.Warning, 0x4000b, System.ServiceModel.SR.GetString("TraceCodeHttpChannelMessageReceiveFailed"), null);
}
if (string.Compare(listenerContext.Request.HttpMethod, "POST", StringComparison.OrdinalIgnoreCase) != 0)
{
listenerContext.Response.StatusCode = 0x195;
listenerContext.Response.Headers.Add(HttpResponseHeader.Allow, "POST");
}
else
{
listenerContext.Response.StatusCode = 0x194;
}
listenerContext.Response.ContentLength64 = 0L;
listenerContext.Response.Close();
}
}
}
}
catch (HttpListenerException exception2)
{
switch (exception2.ErrorCode)
{
case 8:
case 14:
case 0x5aa:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InsufficientMemoryException(System.ServiceModel.SR.GetString("InsufficentMemory"), exception2));
}
if (!System.ServiceModel.Dispatcher.ExceptionHandler.HandleTransportExceptionHelper(exception2))
{
throw;
}
}
}
catch (Exception exception3)
{
if (Fx.IsFatal(exception3))
{
throw;
}
exception = exception3;
}
if (exception != null)
{
base.Fault(exception);
}
if (!flag)
{
lock (base.ThisLock)
{
if (this.listener == null)
{
continue;
}
result = this.BeginGetContext(false);
if ((result != null) && result.CompletedSynchronously)
{
continue;
}
break;
}
}
}
}
