public bool EnableDelayedAccept(HttpOutput output)
{
if (base.IsAtEof)
{
return false;
}
this.httpOutput = output;
return true;
}
public bool EnableDelayedAccept(HttpOutput output, bool closeHttpOutput)
{
if (IsAtEof)
{
return false;
}
this.closeHttpOutput = closeHttpOutput;
this.httpOutput = output;
return true;
}
public WebRequestOutputStream(Stream requestStream, HttpWebRequest httpWebRequest, HttpOutput httpOutput)
: base(requestStream)
{
this.httpWebRequest = httpWebRequest;
this.httpOutput = httpOutput;
}
public GetOutputStreamAsyncResult(HttpWebRequest httpWebRequest, HttpOutput httpOutput, AsyncCallback callback, object state)
: base(callback, state)
{
this.httpWebRequest = httpWebRequest;
this.httpOutput = httpOutput;
IAsyncResult result = null;
try
{
result = httpWebRequest.BeginGetRequestStream(onGetRequestStream, this);
}
catch (WebException webException)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(HttpChannelUtilities.CreateRequestWebException(webException, httpWebRequest, httpOutput.abortReason));
}
if (result.CompletedSynchronously)
{
CompleteGetRequestStream(result);
base.Complete(true);
}
}
public SendAsyncResult(HttpOutput httpOutput, HttpResponseMessage httpResponseMessage, bool suppressEntityBody, TimeSpan timeout, AsyncCallback callback, object state)
: base(callback, state)
{
this.httpOutput = httpOutput;
this.httpResponseMessage = httpResponseMessage;
this.suppressEntityBody = suppressEntityBody;
if (suppressEntityBody)
{
if (httpOutput.isRequest)
{
httpOutput.SetContentLength(0);
this.httpOutput.TraceSend();
this.httpOutput.LogMessage();
base.Complete(true);
return;
}
}
this.timeoutHelper = new TimeoutHelper(timeout);
Send();
}
public WriteStreamedMessageAsyncResult(TimeSpan timeout, HttpOutput httpOutput, HttpResponseMessage httpResponseMessage, AsyncCallback callback, object state)
: base(callback, state)
{
this.httpResponseMessage = httpResponseMessage;
this.httpOutput = httpOutput;
httpOutput.outputStream = httpOutput.GetWrappedOutputStream();
// Since HTTP streams don't support timeouts, we can't just use TimeoutStream here.
// Rather, we need to run a timer to bound the overall operation
if (onStreamSendTimeout == null)
{
onStreamSendTimeout = new Action<object>(OnStreamSendTimeout);
}
this.SetTimer(timeout);
bool completeSelf = false;
bool throwing = true;
try
{
completeSelf = HandleWriteStreamedMessage(null);
throwing = false;
}
finally
{
if (completeSelf || throwing)
{
this.sendTimer.Cancel();
}
}
if (completeSelf)
{
this.Complete(true);
}
}
internal void SendResponseAndClose(HttpResponseMessage httpResponseMessage)
{
if (this.TryInitiateReply())
{
// Send the response message.
try
{
if (this.httpOutput == null)
{
this.httpOutput = this.GetHttpOutputCore(new NullMessage());
}
this.httpOutput.Send(httpResponseMessage, this.DefaultSendTimeout);
}
catch (Exception ex)
{
if (Fx.IsFatal(ex))
{
throw;
}
DiagnosticUtility.TraceHandledException(ex, TraceEventType.Information);
}
}
// Close the request context.
try
{
this.Close(); // this also closes the HttpOutput
}
catch (Exception ex)
{
if (Fx.IsFatal(ex))
{
throw;
}
DiagnosticUtility.TraceHandledException(ex, TraceEventType.Information);
}
}
bool PrepareReply(ref Message message)
{
bool closeOnReceivedEof = false;
// null means we're done
if (message == null)
{
// A null message means either a one-way request or that the service operation returned null and
// hence we can close the HttpOutput. By default we keep the HttpOutput open to allow the writing to the output
// even after the HttpInput EOF is received and the HttpOutput will be closed only on close of the HttpRequestContext.
closeOnReceivedEof = true;
message = CreateAckMessage(HttpStatusCode.Accepted, string.Empty);
}
if (!listener.ManualAddressing)
{
if (message.Version.Addressing == AddressingVersion.WSAddressingAugust2004)
{
if (message.Headers.To == null ||
listener.AnonymousUriPrefixMatcher == null ||
!listener.AnonymousUriPrefixMatcher.IsAnonymousUri(message.Headers.To))
{
message.Headers.To = message.Version.Addressing.AnonymousUri;
}
}
else if (message.Version.Addressing == AddressingVersion.WSAddressing10
|| message.Version.Addressing == AddressingVersion.None)
{
if (message.Headers.To != null &&
(listener.AnonymousUriPrefixMatcher == null ||
!listener.AnonymousUriPrefixMatcher.IsAnonymousUri(message.Headers.To)))
{
message.Headers.To = null;
}
}
else
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new ProtocolException(SR.GetString(SR.AddressingVersionNotSupported, message.Version.Addressing)));
}
}
message.Properties.AllowOutputBatching = false;
this.httpOutput = GetHttpOutputCore(message);
// Reuse the HttpInput we got previously.
HttpInput input = this.httpPipeline.HttpInput;
if (input != null)
{
HttpDelayedAcceptStream requestStream = input.GetInputStream(false) as HttpDelayedAcceptStream;
if (requestStream != null && TransferModeHelper.IsRequestStreamed(listener.TransferMode)
&& requestStream.EnableDelayedAccept(this.httpOutput, closeOnReceivedEof))
{
return false;
}
}
return true;
}
void CompleteChannelModelIntegrationHandlerTask(Message replyMessage)
{
if (this.channelModelIntegrationHandlerTask != null)
{
// If Service Model (or service instance) sent us null then we create a 202 HTTP response
HttpResponseMessage httpResponseMessage = null;
this.httpOutput = this.GetHttpOutput(replyMessage);
if (replyMessage != null)
{
httpResponseMessage = this.CreateHttpResponseMessage(replyMessage);
}
else
{
httpResponseMessage = new HttpResponseMessage(HttpStatusCode.Accepted);
}
Fx.Assert(httpResponseMessage != null, "httpResponse should not be null.");
if (httpResponseMessage.RequestMessage == null)
{
httpResponseMessage.RequestMessage = this.httpRequestMessage;
Fx.Assert(httpResponseMessage.RequestMessage != null, "httpResponseMessage.RequestMessage should never be null.");
if (replyMessage != null)
{
httpResponseMessage.CopyPropertiesFromMessage(replyMessage);
}
}
HttpChannelUtilities.EnsureHttpResponseMessageContentNotNull(httpResponseMessage);
this.cancellationTokenSource.CancelAfter(TimeoutHelper.ToMilliseconds(this.defaultSendTimeout));
this.channelModelIntegrationHandlerTask.TrySetResult(httpResponseMessage);
}
this.TraceProcessResponseStop();
}
private bool PrepareReply(ref Message message)
{
if (message == null)
{
message = this.CreateAckMessage(HttpStatusCode.Accepted, string.Empty);
}
if (!this.listener.ManualAddressing)
{
if (message.Version.Addressing != AddressingVersion.WSAddressingAugust2004)
{
if ((message.Version.Addressing != AddressingVersion.WSAddressing10) && (message.Version.Addressing != AddressingVersion.None))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ProtocolException(System.ServiceModel.SR.GetString("AddressingVersionNotSupported", new object[] { message.Version.Addressing })));
}
if ((message.Headers.To != null) && ((this.listener.AnonymousUriPrefixMatcher == null) || !this.listener.AnonymousUriPrefixMatcher.IsAnonymousUri(message.Headers.To)))
{
message.Headers.To = null;
}
}
else if (((message.Headers.To == null) || (this.listener.AnonymousUriPrefixMatcher == null)) || !this.listener.AnonymousUriPrefixMatcher.IsAnonymousUri(message.Headers.To))
{
message.Headers.To = message.Version.Addressing.AnonymousUri;
}
}
message.Properties.AllowOutputBatching = false;
this.httpOutput = this.GetHttpOutput(message);
HttpDelayedAcceptStream inputStream = this.HttpInput.InputStream as HttpDelayedAcceptStream;
if (((inputStream != null) && TransferModeHelper.IsRequestStreamed(this.listener.TransferMode)) && inputStream.EnableDelayedAccept(this.httpOutput))
{
return false;
}
return true;
}
