public override Message ReadMessage(Stream stream, int maxSizeOfHeaders, string contentType)
{
if (stream == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("stream"));
}
if (WcfEventSource.Instance.TextMessageDecodingStartIsEnabled())
{
WcfEventSource.Instance.TextMessageDecodingStart();
}
XmlReader reader = TakeStreamedReader(stream, GetEncodingFromContentType(contentType, _contentEncodingMap));
Message message = Message.CreateMessage(reader, maxSizeOfHeaders, _version);
message.Properties.Encoder = this;
if (WcfEventSource.Instance.StreamedMessageReadByEncoderIsEnabled())
{
WcfEventSource.Instance.StreamedMessageReadByEncoder(EventTraceActivityHelper.TryExtractActivity(message, true));
}
if (MessageLogger.LogMessagesAtTransportLevel)
{
MessageLogger.LogMessage(ref message, MessageLoggingSource.TransportReceive);
}
return(message);
}
public override bool Match(Message message)
{
if (message == null)
{
throw FxTrace.Exception.ArgumentNull("message");
}
if (InnerFilter.Match(message))
{
bool isMatch = ((message.Headers.ReplyTo == null) ||
(message.Headers.ReplyTo.IsAnonymous));
if (!isMatch && TD.DiscoveryMessageWithInvalidReplyToIsEnabled())
{
EventTraceActivity eventTraceActivity = null;
if (Fx.Trace.IsEtwProviderEnabled)
{
eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message);
}
TD.DiscoveryMessageWithInvalidReplyTo(eventTraceActivity, message.Headers.MessageId.ToString());
}
return(isMatch);
}
return(false);
}
RoutingService()
{
this.SessionMessages = new List <MessageRpc>(1);
//We only need to call this here if we trace in this method. BeginXXX methods call it again.
//FxTrace.Trace.SetAndTraceTransfer(this.ActivityID, true);
this.operationContext = OperationContext.Current;
if (Fx.Trace.IsEtwProviderEnabled)
{
this.eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(this.operationContext.IncomingMessage);
}
IContextChannel channel = this.operationContext.Channel;
ServiceHostBase host = this.operationContext.Host;
this.ChannelExtension = channel.Extensions.Find <RoutingChannelExtension>();
if (this.ChannelExtension == null)
{
throw FxTrace.Exception.AsError(new ConfigurationErrorsException(SR2.RoutingExtensionNotFound));
}
this.RoutingConfig = host.Extensions.Find <RoutingExtension>().RoutingConfiguration;
this.RoutingConfig.VerifyConfigured();
this.ChannelExtension.AttachService(this);
}
protected virtual void PrepareMessage(Message message)
{
message.Properties.Via = _localVia;
ApplyChannelBinding(message);
if (FxTrace.Trace.IsEnd2EndActivityTracingEnabled)
{
EventTraceActivity eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message);
Guid relatedActivityId = EventTraceActivity.GetActivityIdFromThread();
if (eventTraceActivity == null)
{
eventTraceActivity = EventTraceActivity.GetFromThreadOrCreate();
EventTraceActivityHelper.TryAttachActivity(message, eventTraceActivity);
}
if (WcfEventSource.Instance.MessageReceivedByTransportIsEnabled())
{
WcfEventSource.Instance.MessageReceivedByTransport(
eventTraceActivity,
LocalAddress != null && LocalAddress.Uri != null ? LocalAddress.Uri.AbsoluteUri : string.Empty,
relatedActivityId);
}
}
}
public WriteMessageAsyncResult(Message message, Stream stream, TextMessageEncoder textEncoder, AsyncCallback callback, object state)
: base(callback, state)
{
this.message = message;
this.textEncoder = textEncoder;
this.xmlWriter = textEncoder.TakeStreamedWriter(stream);
this.eventTraceActivity = null;
if (TD.TextMessageEncodingStartIsEnabled())
{
this.eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message);
TD.TextMessageEncodingStart(this.eventTraceActivity);
}
if (!textEncoder.optimizeWriteForUTF8)
{
xmlWriter.WriteStartDocument();
}
IAsyncResult result = message.BeginWriteMessage(this.xmlWriter, PrepareAsyncCompletion(onWriteMessage), this);
if (SyncContinue(result))
{
this.Complete(true);
}
}
public override Message ReadMessage(Stream stream, int maxSizeOfHeaders, string contentType)
{
if (stream == null)
{
throw FxTrace.Exception.ArgumentNull("stream");
}
if (TD.ByteStreamMessageDecodingStartIsEnabled())
{
TD.ByteStreamMessageDecodingStart();
}
Message message = ByteStreamMessage.CreateMessage(stream, this.quotas, this.moveBodyReaderToContent);
message.Properties.Encoder = this;
if (SMTD.StreamedMessageReadByEncoderIsEnabled())
{
SMTD.StreamedMessageReadByEncoder(EventTraceActivityHelper.TryExtractActivity(message, true));
}
if (MessageLogger.LogMessagesAtTransportLevel)
{
MessageLogger.LogMessage(ref message, MessageLoggingSource.TransportReceive);
}
return(message);
}
// negotiation failure methods
Message HandleNegotiationException(Message request, Exception e)
{
SecurityTraceRecordHelper.TraceServiceSecurityNegotiationFailure <T>(
EventTraceActivityHelper.TryExtractActivity(request),
this,
e);
return(CreateFault(request, e));
}
private void SetActivityIdOnThread(ref MessageRpc rpc)
{
if (FxTrace.Trace.IsEnd2EndActivityTracingEnabled && rpc.EventTraceActivity != null)
{
// Propogate the ActivityId to the service operation
EventTraceActivityHelper.SetOnThread(rpc.EventTraceActivity);
}
}
public override Task <ArraySegment <byte> > WriteMessageAsync(Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset)
{
if (message == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException(nameof(message)));
}
if (bufferManager == null)
{
throw TraceUtility.ThrowHelperError(new ArgumentNullException(nameof(bufferManager)), message);
}
if (maxMessageSize < 0)
{
throw TraceUtility.ThrowHelperError(new ArgumentOutOfRangeException(nameof(maxMessageSize), maxMessageSize,
SR.ValueMustBeNonNegative), message);
}
if (messageOffset < 0 || messageOffset > maxMessageSize)
{
throw TraceUtility.ThrowHelperError(new ArgumentOutOfRangeException(nameof(messageOffset), messageOffset,
SR.Format(SR.ValueMustBeInRange, 0, maxMessageSize)), message);
}
ThrowIfMismatchedMessageVersion(message);
EventTraceActivity eventTraceActivity = null;
if (WcfEventSource.Instance.TextMessageEncodingStartIsEnabled())
{
eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message);
WcfEventSource.Instance.TextMessageEncodingStart(eventTraceActivity);
}
message.Properties.Encoder = this;
TextBufferedMessageWriter messageWriter = TakeBufferedWriter();
ArraySegment <byte> messageData = messageWriter.WriteMessage(message, bufferManager, messageOffset, maxMessageSize);
ReturnMessageWriter(messageWriter);
if (WcfEventSource.Instance.MessageWrittenByEncoderIsEnabled())
{
WcfEventSource.Instance.MessageWrittenByEncoder(
eventTraceActivity ?? EventTraceActivityHelper.TryExtractActivity(message),
messageData.Count,
this);
}
if (MessageLogger.LogMessagesAtTransportLevel)
{
XmlDictionaryReader xmlDictionaryReader = XmlDictionaryReader.CreateTextReader(messageData.Array, messageData.Offset, messageData.Count, XmlDictionaryReaderQuotas.Max);
MessageLogger.LogMessage(ref message, xmlDictionaryReader, MessageLoggingSource.TransportSend);
}
return(Task.FromResult(messageData));
}
// returns false if the max pending messages total size was hit.
internal bool EnqueueMessage(Message message, int messageBufferSize, Action messageDequeuedCallback)
{
Action onMessageDequeuedCallback = () =>
{
lock (this.ThisLock)
{
this.pendingMessagesTotalSize -= messageBufferSize;
Fx.Assert(this.pendingMessagesTotalSize >= 0, "pendingMessagesTotalSize should not be negative.");
}
messageDequeuedCallback();
};
bool success = false;
lock (this.ThisLock)
{
if (this.pendingMessagesTotalSize + messageBufferSize <= this.maxPendingMessagesTotalSize)
{
message.Properties.Via = this.Via;
this.pendingMessagesTotalSize += messageBufferSize;
try
{
this.FinishEnqueueMessage(message, onMessageDequeuedCallback, false);
success = true;
}
finally
{
if (!success)
{
this.pendingMessagesTotalSize -= messageBufferSize;
}
}
}
else
{
if (TD.MaxPendingMessagesTotalSizeReachedIsEnabled())
{
string messageIdString = string.Empty;
if (message.Headers.MessageId != null)
{
messageIdString = string.Format(CultureInfo.CurrentCulture, "'{0}' ", message.Headers.MessageId.ToString());
}
EventTraceActivity eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message);
TD.MaxPendingMessagesTotalSizeReached(eventTraceActivity, messageIdString, this.maxPendingMessagesTotalSize, typeof(TransportBindingElement).FullName);
}
}
}
return(success);
}
public override async Task WriteMessageAsync(Message message, Stream stream)
{
if (message == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException(nameof(message)));
}
if (stream == null)
{
throw TraceUtility.ThrowHelperError(new ArgumentNullException(nameof(stream)), message);
}
ThrowIfMismatchedMessageVersion(message);
EventTraceActivity eventTraceActivity = null;
if (WcfEventSource.Instance.TextMessageEncodingStartIsEnabled())
{
eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message);
WcfEventSource.Instance.TextMessageEncodingStart(eventTraceActivity);
}
message.Properties.Encoder = this;
XmlDictionaryWriter xmlWriter = TakeStreamedWriter(stream);
if (_optimizeWriteForUTF8)
{
await message.WriteMessageAsync(xmlWriter);
}
else
{
xmlWriter.WriteStartDocument();
await message.WriteMessageAsync(xmlWriter);
xmlWriter.WriteEndDocument();
}
await xmlWriter.FlushAsync();
ReturnStreamedWriter(xmlWriter);
if (WcfEventSource.Instance.StreamedMessageWrittenByEncoderIsEnabled())
{
WcfEventSource.Instance.StreamedMessageWrittenByEncoder(eventTraceActivity ?? EventTraceActivityHelper.TryExtractActivity(message));
}
if (MessageLogger.LogMessagesAtTransportLevel)
{
MessageLogger.LogMessage(ref message, MessageLoggingSource.TransportSend);
}
}
void TraceHttpMessageReceived(Message message)
{
if (FxTrace.Trace.IsEnd2EndActivityTracingEnabled)
{
bool attached = false;
Guid relatedId = this.eventTraceActivity != null ? this.eventTraceActivity.ActivityId : Guid.Empty;
HttpRequestMessageProperty httpProperty;
// Encoder will always add an activity. We need to remove this and read it
// from the web headers for http since correlation might be propogated.
if (message.Headers.MessageId == null &&
message.Properties.TryGetValue <HttpRequestMessageProperty>(HttpRequestMessageProperty.Name, out httpProperty))
{
try
{
string e2eId = httpProperty.Headers[EventTraceActivity.Name];
if (!String.IsNullOrEmpty(e2eId))
{
byte[] data = Convert.FromBase64String(e2eId);
if (data != null && data.Length == 16)
{
Guid id = new Guid(data);
this.eventTraceActivity = new EventTraceActivity(id, true);
message.Properties[EventTraceActivity.Name] = this.eventTraceActivity;
attached = true;
}
}
}
catch (Exception ex)
{
if (Fx.IsFatal(ex))
{
throw;
}
}
}
if (!attached)
{
this.eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message, true);
}
if (TD.MessageReceivedByTransportIsEnabled())
{
TD.MessageReceivedByTransport(
this.eventTraceActivity,
this.listener != null && this.listener.Uri != null ? this.listener.Uri.AbsoluteUri : string.Empty,
relatedId);
}
}
}
public MessageRpc(Message message, OperationContext operationContext, bool impersonationRequired)
{
Fx.Assert(message != null, "message cannot be null");
Fx.Assert(operationContext != null, "operationContext cannot be null");
this.originalMessage = message;
this.OperationContext = operationContext;
if (Fx.Trace.IsEtwProviderEnabled)
{
this.eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message);
}
//passing in true causes this to return null if the thread is not impersonating.
this.windowsIdentity = WindowsIdentity.GetCurrent(true);
if (impersonationRequired && !AspNetEnvironment.Current.AspNetCompatibilityEnabled)
{
if (this.windowsIdentity == null || this.windowsIdentity.ImpersonationLevel != TokenImpersonationLevel.Impersonation)
{
//Temporarily revert impersonation to process token to throw an exception
IDisposable autoRevert = null;
try
{
try { }
finally
{
autoRevert = WindowsIdentity.Impersonate(IntPtr.Zero);
}
Win32Exception errorDetail = new Win32Exception(ERROR_BAD_IMPERSONATION_LEVEL);
throw FxTrace.Exception.AsError(new SecurityNegotiationException(errorDetail.Message));
}
finally
{
if (autoRevert != null)
{
autoRevert.Dispose();
}
}
}
}
ReceiveContext.TryGet(message, out this.receiveContext);
this.transaction = Transaction.Current;
if (this.transaction == null)
{
this.transaction = TransactionMessageProperty.TryGetTransaction(message);
}
}
private EventTraceActivity TraceDispatchMessageStart(Message message)
{
if (FxTrace.Trace.IsEnd2EndActivityTracingEnabled && message != null)
{
EventTraceActivity eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message);
if (WcfEventSource.Instance.DispatchMessageStartIsEnabled())
{
WcfEventSource.Instance.DispatchMessageStart(eventTraceActivity);
}
return(eventTraceActivity);
}
return(null);
}
private async Task WriteMessageInternalAsync(Message message, Stream stream, string startInfo, string boundary, string startUri, bool writeMessageHeaders)
{
if (message == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException(nameof(message)));
}
if (stream == null)
{
throw TraceUtility.ThrowHelperError(new ArgumentNullException(nameof(stream)), message);
}
ThrowIfMismatchedMessageVersion(message);
EventTraceActivity eventTraceActivity = null;
if (WcfEventSource.Instance.MtomMessageEncodingStartIsEnabled())
{
eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message);
WcfEventSource.Instance.MtomMessageEncodingStart(eventTraceActivity);
}
message.Properties.Encoder = this;
if (MessageLogger.LogMessagesAtTransportLevel)
{
MessageLogger.LogMessage(ref message, MessageLoggingSource.TransportSend);
}
XmlDictionaryWriter xmlWriter = _factory.TakeStreamedWriter(stream, startInfo, boundary, startUri, writeMessageHeaders);
if (_writeEncoding.WebName == "utf-8")
{
await message.WriteMessageAsync(xmlWriter);
}
else
{
await xmlWriter.WriteStartDocumentAsync();
await message.WriteMessageAsync(xmlWriter);
await xmlWriter.WriteEndDocumentAsync();
}
await xmlWriter.FlushAsync();
_factory.ReturnStreamedWriter(xmlWriter);
if (WcfEventSource.Instance.StreamedMessageWrittenByEncoderIsEnabled())
{
WcfEventSource.Instance.StreamedMessageWrittenByEncoder(eventTraceActivity ?? EventTraceActivityHelper.TryExtractActivity(message));
}
}
protected override void OnSend(Message message, TimeSpan timeout)
{
ThrowIfDisposedOrNotOpen();
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
// If timeout == TimeSpan.MaxValue, then we want to pass Timeout.Infinite as
// SemaphoreSlim doesn't accept timeouts > Int32.MaxValue.
// Using TimeoutHelper.RemainingTime() would yield a value less than TimeSpan.MaxValue
// and would result in the value Int32.MaxValue so we must use the original timeout specified.
if (!SendLock.Wait(TimeoutHelper.ToMilliseconds(timeout)))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TimeoutException(
SR.Format(SR.SendToViaTimedOut, Via, timeout),
TimeoutHelper.CreateEnterTimedOutException(timeout)));
}
try
{
// check again in case the previous send faulted while we were waiting for the lock
ThrowIfDisposedOrNotOpen();
ThrowIfOutputSessionClosed();
bool success = false;
try
{
ApplyChannelBinding(message);
OnSendCore(message, timeoutHelper.RemainingTime());
success = true;
if (WcfEventSource.Instance.MessageSentByTransportIsEnabled())
{
EventTraceActivity eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message);
WcfEventSource.Instance.MessageSentByTransport(eventTraceActivity, RemoteAddress.Uri.AbsoluteUri);
}
}
finally
{
if (!success)
{
Fault();
}
}
}
finally
{
SendLock.Release();
}
}
bool WriteCore()
{
// check again in case the previous send faulted while we were waiting for the lock
this.channel.ThrowIfDisposedOrNotOpen();
this.channel.ThrowIfOutputSessionClosed();
this.channel.ApplyChannelBinding(this.message);
Message message = this.message;
this.message = null;
// Because we nullify the message, we need to save its trace activity, for logging events later on.
if (TD.MessageSentByTransportIsEnabled())
{
this.eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message);
}
AsyncCompletionResult completionResult;
if (this.streamedOutput)
{
completionResult = this.channel.StartWritingStreamedMessage(message, this.timeoutHelper.RemainingTime(), onWriteComplete, this);
}
else
{
bool allowOutputBatching;
ArraySegment <byte> messageData;
allowOutputBatching = message.Properties.AllowOutputBatching;
messageData = this.channel.EncodeMessage(message);
this.buffer = messageData.Array;
completionResult = this.channel.StartWritingBufferedMessage(
message,
messageData,
allowOutputBatching,
this.timeoutHelper.RemainingTime(),
onWriteComplete,
this);
}
if (completionResult == AsyncCompletionResult.Queued)
{
return(false);
}
this.channel.FinishWritingMessage();
return(true);
}
public DiscoveryOperationContext(OperationContext operationContext)
{
Fx.Assert(operationContext != null, "The operationContext must be non null.");
if (Fx.Trace.IsEtwProviderEnabled)
{
this.eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(operationContext.IncomingMessage);
}
this.operationContext = operationContext;
this.operationContextExtension = DiscoveryOperationContext.GetDiscoveryOperationContextExtension(this.operationContext);
this.messageProperty = DiscoveryOperationContext.GetDiscoveryMessageProperty(this.operationContext);
this.thisLock = new object();
}
static bool HandleWriteMessage(IAsyncResult result)
{
WriteMessageAsyncResult thisPtr = (WriteMessageAsyncResult)result.AsyncState;
thisPtr.message.EndWriteMessage(result);
thisPtr.writer.Flush();
if (SMTD.MessageWrittenAsynchronouslyByEncoderIsEnabled())
{
SMTD.MessageWrittenAsynchronouslyByEncoder(
thisPtr.eventTraceActivity ?? EventTraceActivityHelper.TryExtractActivity(thisPtr.message));
}
return(true);
}
public static bool TryGet(Message message, out ReceiveContext property)
{
if (message == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("message");
}
bool result = TryGet(message.Properties, out property);
if (result && FxTrace.Trace.IsEnd2EndActivityTracingEnabled && property.eventTraceActivity == null)
{
property.eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message);
}
return(result);
}
internal static bool EnsureReplyTo()
{
OperationContext context = OperationContext.Current;
if (context.IncomingMessageHeaders.ReplyTo == null)
{
if (TD.DiscoveryMessageWithNullReplyToIsEnabled())
{
EventTraceActivity eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(context.IncomingMessage);
TD.DiscoveryMessageWithNullReplyTo(eventTraceActivity, context.IncomingMessageHeaders.MessageId.ToString());
}
return(false);
}
return(true);
}
protected override void OnSend(Message message, TimeSpan timeout)
{
this.ThrowIfDisposedOrNotOpen();
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
if (!this.sendLock.TryEnter(timeoutHelper.RemainingTime()))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TimeoutException(
SR.GetString(SR.SendToViaTimedOut, Via, timeout),
ThreadNeutralSemaphore.CreateEnterTimedOutException(timeout)));
}
try
{
// check again in case the previous send faulted while we were waiting for the lock
this.ThrowIfDisposedOrNotOpen();
this.ThrowIfOutputSessionClosed();
bool success = false;
try
{
this.ApplyChannelBinding(message);
this.OnSendCore(message, timeoutHelper.RemainingTime());
success = true;
if (TD.MessageSentByTransportIsEnabled())
{
EventTraceActivity eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message);
TD.MessageSentByTransport(eventTraceActivity, this.RemoteAddress.Uri.AbsoluteUri);
}
}
finally
{
if (!success)
{
this.Fault();
}
}
}
finally
{
this.sendLock.Exit();
}
}
void WriteMessage(Message message, Stream stream, string startInfo, string boundary, string startUri, bool writeMessageHeaders)
{
if (message == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("message"));
}
if (stream == null)
{
throw TraceUtility.ThrowHelperError(new ArgumentNullException("stream"), message);
}
ThrowIfMismatchedMessageVersion(message);
EventTraceActivity eventTraceActivity = null;
if (TD.MtomMessageEncodingStartIsEnabled())
{
eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message);
TD.MtomMessageEncodingStart(eventTraceActivity);
}
message.Properties.Encoder = this;
if (MessageLogger.LogMessagesAtTransportLevel)
{
MessageLogger.LogMessage(ref message, MessageLoggingSource.TransportSend);
}
XmlDictionaryWriter xmlWriter = TakeStreamedWriter(stream, startInfo, boundary, startUri, writeMessageHeaders);
if (this.writeEncoding.WebName == "utf-8")
{
message.WriteMessage(xmlWriter);
}
else
{
xmlWriter.WriteStartDocument();
message.WriteMessage(xmlWriter);
xmlWriter.WriteEndDocument();
}
xmlWriter.Flush();
ReturnStreamedWriter(xmlWriter);
if (TD.StreamedMessageWrittenByEncoderIsEnabled())
{
TD.StreamedMessageWrittenByEncoder(eventTraceActivity ?? EventTraceActivityHelper.TryExtractActivity(message));
}
}
public override Message ReadMessage(ArraySegment <byte> buffer, BufferManager bufferManager, string contentType)
{
if (bufferManager == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("bufferManager");
}
if (contentType == this.ContentType)
{
contentType = null;
}
if (TD.MtomMessageDecodingStartIsEnabled())
{
TD.MtomMessageDecodingStart();
}
MtomBufferedMessageData messageData = TakeBufferedReader();
messageData.ContentType = contentType;
messageData.Open(buffer, bufferManager);
RecycledMessageState messageState = messageData.TakeMessageState();
if (messageState == null)
{
messageState = new RecycledMessageState();
}
Message message = new BufferedMessage(messageData, messageState);
message.Properties.Encoder = this;
if (MessageLogger.LogMessagesAtTransportLevel)
{
MessageLogger.LogMessage(ref message, MessageLoggingSource.TransportReceive);
}
if (TD.MessageReadByEncoderIsEnabled() && buffer != null)
{
TD.MessageReadByEncoder(
EventTraceActivityHelper.TryExtractActivity(message, true),
buffer.Count,
this);
}
return(message);
}
bool IsInvalid(TMessage message)
{
UniqueId messageId = OperationContext.Current.IncomingMessageHeaders.MessageId;
if (messageId == null)
{
if (TD.DiscoveryMessageWithNullMessageIdIsEnabled())
{
TD.DiscoveryMessageWithNullMessageId(null, ProtocolStrings.TracingStrings.Bye);
}
return(true);
}
EventTraceActivity eventTraceActivity = null;
if (Fx.Trace.IsEtwProviderEnabled)
{
eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(OperationContext.Current.IncomingMessage);
}
if (this.announcementServiceImpl.IsDuplicate(messageId))
{
if (TD.DuplicateDiscoveryMessageIsEnabled())
{
TD.DuplicateDiscoveryMessage(eventTraceActivity, ProtocolStrings.TracingStrings.Bye, messageId.ToString());
}
return(true);
}
else if (this.ValidateContent(message))
{
return(false);
}
else
{
if (TD.DiscoveryMessageWithInvalidContentIsEnabled())
{
TD.DiscoveryMessageWithInvalidContent(eventTraceActivity, ProtocolStrings.TracingStrings.Bye, messageId.ToString());
}
return(true);
}
}
public override Message ReadMessage(ArraySegment <byte> buffer, BufferManager bufferManager, string contentType)
{
if (bufferManager == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException(nameof(bufferManager)));
}
if (WcfEventSource.Instance.TextMessageDecodingStartIsEnabled())
{
WcfEventSource.Instance.TextMessageDecodingStart();
}
Message message;
UTF8BufferedMessageData messageData = TakeBufferedReader();
messageData.Encoding = GetEncodingFromContentType(contentType, _contentEncodingMap);
messageData.Open(buffer, bufferManager);
RecycledMessageState messageState = messageData.TakeMessageState();
if (messageState == null)
{
messageState = new RecycledMessageState();
}
message = new BufferedMessage(messageData, messageState);
message.Properties.Encoder = this;
if (WcfEventSource.Instance.MessageReadByEncoderIsEnabled())
{
WcfEventSource.Instance.MessageReadByEncoder(
EventTraceActivityHelper.TryExtractActivity(message, true),
buffer.Count,
this);
}
if (MessageLogger.LogMessagesAtTransportLevel)
{
MessageLogger.LogMessage(ref message, MessageLoggingSource.TransportReceive);
}
return(message);
}
internal static void StartOperationInvokeTrace(string methodName)
{
if (TD.OperationInvokedIsEnabled())
{
OperationContext context = OperationContext.Current;
EventTraceActivity eventTraceActivity = null;
if (context != null && context.IncomingMessage != null)
{
eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(context.IncomingMessage);
}
if (TD.OperationInvokedIsEnabled())
{
TD.OperationInvoked(eventTraceActivity, methodName, TraceUtility.GetCallerInfo(OperationContext.Current));
}
if (TD.OperationCompletedIsEnabled() || TD.OperationFaultedIsEnabled() || TD.OperationFailedIsEnabled())
{
TraceUtility.UpdateAsyncOperationContextWithStartTime(eventTraceActivity, DateTime.UtcNow.Ticks);
}
}
}
public WriteMessageAsyncResult(Message message, Stream stream, AsyncCallback callback, object state)
: base(callback, state)
{
this.message = message;
this.stream = stream;
this.writer = new XmlByteStreamWriter(stream, false);
if (onCleanup == null)
{
onCleanup = new Action <IAsyncResult, Exception>(Cleanup);
}
this.OnCompleting += onCleanup;
Exception completionException = null;
bool completeSelf = false;
this.eventTraceActivity = null;
if (TD.ByteStreamMessageEncodingStartIsEnabled())
{
this.eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message);
TD.ByteStreamMessageEncodingStart(this.eventTraceActivity);
}
try
{
IAsyncResult result = message.BeginWriteMessage(writer, PrepareAsyncCompletion(HandleWriteMessage), this);
completeSelf = SyncContinue(result);
}
catch (Exception ex)
{
if (Fx.IsFatal(ex))
{
throw;
}
completeSelf = true;
completionException = ex;
}
if (completeSelf)
{
this.Complete(true, completionException);
}
}
public override void WriteMessage(Message message, Stream stream)
{
if (message == null)
{
throw FxTrace.Exception.ArgumentNull("message");
}
if (stream == null)
{
throw FxTrace.Exception.ArgumentNull("stream");
}
ThrowIfMismatchedMessageVersion(message);
EventTraceActivity eventTraceActivity = null;
if (TD.ByteStreamMessageEncodingStartIsEnabled())
{
eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message);
TD.ByteStreamMessageEncodingStart(eventTraceActivity);
}
message.Properties.Encoder = this;
if (MessageLogger.LogMessagesAtTransportLevel)
{
MessageLogger.LogMessage(ref message, MessageLoggingSource.TransportSend);
}
using (XmlWriter writer = new XmlByteStreamWriter(stream, false))
{
message.WriteMessage(writer);
writer.Flush();
}
if (SMTD.StreamedMessageWrittenByEncoderIsEnabled())
{
SMTD.StreamedMessageWrittenByEncoder(eventTraceActivity ?? EventTraceActivityHelper.TryExtractActivity(message));
}
}
public override Message ReadMessage(ArraySegment <byte> buffer, BufferManager bufferManager, string contentType)
{
if (buffer.Array == null)
{
throw FxTrace.Exception.ArgumentNull("buffer.Array");
}
if (bufferManager == null)
{
throw FxTrace.Exception.ArgumentNull("bufferManager");
}
if (TD.ByteStreamMessageDecodingStartIsEnabled())
{
TD.ByteStreamMessageDecodingStart();
}
ByteStreamBufferedMessageData messageData = new ByteStreamBufferedMessageData(buffer, bufferManager);
Message message = ByteStreamMessage.CreateMessage(messageData, this.bufferedReadReaderQuotas, this.moveBodyReaderToContent);
message.Properties.Encoder = this;
if (SMTD.MessageReadByEncoderIsEnabled())
{
SMTD.MessageReadByEncoder(
EventTraceActivityHelper.TryExtractActivity(message, true),
buffer.Count,
this);
}
if (MessageLogger.LogMessagesAtTransportLevel)
{
MessageLogger.LogMessage(ref message, MessageLoggingSource.TransportReceive);
}
return(message);
}
