Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

314 lines
12 KiB
C#

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.ServiceModel.Channels
{
using System.Collections.Generic;
using System.Runtime;
using System.ServiceModel;
using System.ServiceModel.Security.Tokens;
using System.Transactions;
using SR = System.ServiceModel.SR;
sealed class MsmqOutputSessionChannel : TransportOutputChannel, IOutputSessionChannel
{
MsmqQueue msmqQueue;
List<ArraySegment<byte>> buffers;
Transaction associatedTx;
IOutputSession session;
MsmqChannelFactory<IOutputSessionChannel> factory;
MessageEncoder encoder;
SecurityTokenProviderContainer certificateTokenProvider;
public MsmqOutputSessionChannel(MsmqChannelFactory<IOutputSessionChannel> factory, EndpointAddress to, Uri via, bool manualAddressing)
: base(factory, to, via, manualAddressing, factory.MessageVersion)
{
this.factory = factory;
this.encoder = this.factory.MessageEncoderFactory.CreateSessionEncoder();
this.buffers = new List<ArraySegment<byte>>();
this.buffers.Add(EncodeSessionPreamble());
if (factory.IsMsmqX509SecurityConfigured)
{
this.certificateTokenProvider = factory.CreateX509TokenProvider(to, via);
}
this.session = new OutputSession();
}
int CalcSessionGramSize()
{
long sessionGramSize = 0;
for (int i = 0; i < this.buffers.Count; i++)
{
ArraySegment<byte> buffer = this.buffers[i];
sessionGramSize += buffer.Count;
}
if (sessionGramSize > int.MaxValue)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new InvalidOperationException(SR.GetString(SR.MsmqSessionGramSizeMustBeInIntegerRange)));
return (int)sessionGramSize;
}
void CopySessionGramToBuffer(byte[] sessionGramBuffer)
{
int sessionGramOffset = 0;
for (int i = 0; i < this.buffers.Count; i++)
{
ArraySegment<byte> buffer = this.buffers[i];
Buffer.BlockCopy(buffer.Array, buffer.Offset, sessionGramBuffer, sessionGramOffset, buffer.Count);
sessionGramOffset += buffer.Count;
}
}
void ReturnSessionGramBuffers()
{
// Don't return that fancy/schmancy end buffer
for (int i = 0; i < this.buffers.Count - 1; i++)
{
this.Factory.BufferManager.ReturnBuffer(this.buffers[i].Array);
}
}
public IOutputSession Session
{
get { return this.session; }
}
void OnCloseCore(bool isAborting, TimeSpan timeout)
{
// Dump the messages into the queue as a big bag.
// no MSMQ send if aborting
// no MSMQ send if the channel has only a preamble (no actual messages sent)
if (!isAborting && this.buffers.Count > 1)
{
lock (ThisLock)
{
VerifyTransaction();
buffers.Add(EncodeEndMarker());
}
int size = CalcSessionGramSize();
using (MsmqOutputMessage<IOutputSessionChannel> msmqMessage = new MsmqOutputMessage<IOutputSessionChannel>(this.Factory, size, this.RemoteAddress))
{
msmqMessage.ApplyCertificateIfNeeded(this.certificateTokenProvider, this.factory.MsmqTransportSecurity.MsmqAuthenticationMode, timeout);
msmqMessage.Body.EnsureBufferLength(size);
msmqMessage.Body.BufferLength = size;
CopySessionGramToBuffer(msmqMessage.Body.Buffer);
bool lockHeld = false;
try
{
Msmq.EnterXPSendLock(out lockHeld, this.factory.MsmqTransportSecurity.MsmqProtectionLevel);
this.msmqQueue.Send(msmqMessage, MsmqTransactionMode.CurrentOrSingle);
MsmqDiagnostics.SessiongramSent(this.Session.Id, msmqMessage.MessageId, this.buffers.Count);
}
catch (MsmqException ex)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(ex.Normalized);
}
finally
{
if (lockHeld)
{
Msmq.LeaveXPSendLock();
}
ReturnSessionGramBuffers();
}
}
}
if (null != this.msmqQueue)
this.msmqQueue.Dispose();
this.msmqQueue = null;
if (certificateTokenProvider != null)
{
if (isAborting)
certificateTokenProvider.Abort();
else
certificateTokenProvider.Close(timeout);
}
}
protected override void OnAbort()
{
this.OnCloseCore(true, TimeSpan.Zero);
}
protected override IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state)
{
this.OnCloseCore(false, timeout);
return new CompletedAsyncResult(callback, state);
}
protected override void OnEndClose(IAsyncResult result)
{
CompletedAsyncResult.End(result);
}
protected override void OnClose(TimeSpan timeout)
{
this.OnCloseCore(false, timeout);
}
void OnOpenCore(TimeSpan timeout)
{
if (null == Transaction.Current)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCritical(new InvalidOperationException(SR.GetString(SR.MsmqTransactionCurrentRequired)));
this.associatedTx = Transaction.Current;
this.associatedTx.EnlistVolatile(new TransactionEnlistment(this, this.associatedTx), EnlistmentOptions.None);
this.msmqQueue = new MsmqQueue(this.Factory.AddressTranslator.UriToFormatName(this.RemoteAddress.Uri),
UnsafeNativeMethods.MQ_SEND_ACCESS);
if (certificateTokenProvider != null)
{
certificateTokenProvider.Open(timeout);
}
}
protected override IAsyncResult OnBeginOpen(TimeSpan timeout, AsyncCallback callback, object state)
{
OnOpenCore(timeout);
return new CompletedAsyncResult(callback, state);
}
protected override void OnEndOpen(IAsyncResult result)
{
CompletedAsyncResult.End(result);
}
protected override void OnOpen(TimeSpan timeout)
{
OnOpenCore(timeout);
}
protected override IAsyncResult OnBeginSend(Message message, TimeSpan timeout, AsyncCallback callback, object state)
{
OnSend(message, timeout);
return new CompletedAsyncResult(callback, state);
}
protected override void OnEndSend(IAsyncResult result)
{
CompletedAsyncResult.End(result);
}
protected override void OnSend(Message message, TimeSpan timeout)
{
lock (ThisLock)
{
ThrowIfDisposed();
VerifyTransaction();
// serialize the indigo message to byte array and save...
this.buffers.Add(EncodeMessage(message));
}
}
void VerifyTransaction()
{
if (this.associatedTx != Transaction.Current)
{
this.Fault();
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCritical(new InvalidOperationException(SR.GetString(SR.MsmqSameTransactionExpected)));
}
if (TransactionStatus.Active != Transaction.Current.TransactionInformation.Status)
{
this.Fault();
throw DiagnosticUtility.ExceptionUtility.ThrowHelperCritical(new InvalidOperationException(SR.GetString(SR.MsmqTransactionNotActive)));
}
}
ArraySegment<byte> EncodeSessionPreamble()
{
EncodedVia encodedVia = new EncodedVia(this.Via.AbsoluteUri);
EncodedContentType encodedContentType = EncodedContentType.Create(this.encoder.ContentType);
int startSize = ClientSimplexEncoder.ModeBytes.Length
+ SessionEncoder.CalcStartSize(encodedVia, encodedContentType)
+ ClientSimplexEncoder.PreambleEndBytes.Length;
byte[] startBytes = this.Factory.BufferManager.TakeBuffer(startSize);
Buffer.BlockCopy(ClientSimplexEncoder.ModeBytes, 0, startBytes, 0, ClientSimplexEncoder.ModeBytes.Length);
SessionEncoder.EncodeStart(startBytes, ClientSimplexEncoder.ModeBytes.Length, encodedVia, encodedContentType);
Buffer.BlockCopy(ClientSimplexEncoder.PreambleEndBytes, 0, startBytes, startSize - ClientSimplexEncoder.PreambleEndBytes.Length, ClientSimplexEncoder.PreambleEndBytes.Length);
return new ArraySegment<byte>(startBytes, 0, startSize);
}
ArraySegment<byte> EncodeEndMarker()
{
return new ArraySegment<byte>(SessionEncoder.EndBytes, 0, SessionEncoder.EndBytes.Length);
}
// Stick a message into a buffer
ArraySegment<byte> EncodeMessage(Message message)
{
ArraySegment<byte> messageData = this.encoder.WriteMessage(message,
int.MaxValue,
this.Factory.BufferManager,
SessionEncoder.MaxMessageFrameSize);
return SessionEncoder.EncodeMessageFrame(messageData);
}
MsmqChannelFactory<IOutputSessionChannel> Factory
{
get { return this.factory; }
}
class OutputSession : IOutputSession
{
string id = "uuid:/session-gram/" + Guid.NewGuid();
public string Id
{
get { return this.id; }
}
}
class TransactionEnlistment : IEnlistmentNotification
{
MsmqOutputSessionChannel channel;
Transaction transaction;
public TransactionEnlistment(MsmqOutputSessionChannel channel, Transaction transaction)
{
this.channel = channel;
this.transaction = transaction;
}
public void Prepare(PreparingEnlistment preparingEnlistment)
{
// Abort if this happens before the channel is closed...
if (this.channel.State != CommunicationState.Closed)
{
channel.Fault();
Exception e = DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.MsmqSessionChannelsMustBeClosed)));
preparingEnlistment.ForceRollback(e);
}
else
preparingEnlistment.Prepared();
}
public void Commit(Enlistment enlistment)
{
enlistment.Done();
}
public void Rollback(Enlistment enlistment)
{
this.channel.Fault();
enlistment.Done();
}
public void InDoubt(Enlistment enlistment)
{
enlistment.Done();
}
}
}
}