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

1008 lines
39 KiB
C#

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.ServiceModel.Channels
{
using System.Runtime;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.ServiceModel;
using System.ServiceModel.Diagnostics;
using System.Text;
using System.Threading;
using System.Transactions;
enum MsmqTransactionMode
{
None, // do not use a transaction
Single, // create a single message transaction
CurrentOrSingle, // use Transaction.Current if set, Single otherwise
CurrentOrNone, // use Transaction.Current if set, None otherwise
CurrentOrThrow, // use Transaction.Current if set, throw otherwise
}
class MsmqQueue : IDisposable
{
MsmqQueueHandle handle;
bool isBoundToCompletionPort;
bool isAsyncEnabled;
protected int shareMode;
protected string formatName;
protected int accessMode;
public MsmqQueue(string formatName, int accessMode)
{
this.formatName = formatName;
this.accessMode = accessMode;
this.shareMode = UnsafeNativeMethods.MQ_DENY_NONE;
}
public MsmqQueue(string formatName, int accessMode, int shareMode)
{
this.formatName = formatName;
this.accessMode = accessMode;
this.shareMode = shareMode;
}
protected object ThisLock
{
get { return this; }
}
public string FormatName
{
get { return this.formatName; }
}
public override string ToString()
{
return this.formatName;
}
public void Dispose()
{
lock (this.ThisLock)
{
CloseQueue();
}
}
internal void EnsureOpen()
{
GetHandle();
}
MsmqQueueHandle GetHandleForAsync(out bool useCompletionPort)
{
lock (this.ThisLock)
{
if (this.handle == null)
{
this.handle = OpenQueue();
}
if (!this.isAsyncEnabled)
{
if (IsCompletionPortSupported(this.handle))
{
ThreadPool.BindHandle(this.handle);
this.isBoundToCompletionPort = true;
}
this.isAsyncEnabled = true;
}
useCompletionPort = this.isBoundToCompletionPort;
return this.handle;
}
}
protected MsmqQueueHandle GetHandle()
{
lock (this.ThisLock)
{
if (this.handle == null)
{
this.handle = OpenQueue();
}
return this.handle;
}
}
static bool IsCompletionPortSupported(MsmqQueueHandle handle)
{
// if it's a kernel handle, then it supports completion ports
int flags;
#pragma warning suppress 56523
return UnsafeNativeMethods.GetHandleInformation(handle, out flags) != 0;
}
[ResourceConsumption(ResourceScope.Machine)]
internal virtual MsmqQueueHandle OpenQueue()
{
MsmqQueueHandle handle;
int error = UnsafeNativeMethods.MQOpenQueue(this.formatName, this.accessMode,
this.shareMode, out handle);
if (error != 0)
{
Utility.CloseInvalidOutSafeHandle(handle);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(SR.MsmqOpenError, MsmqError.GetErrorString(error)), error));
}
MsmqDiagnostics.QueueOpened(this.formatName);
return handle;
}
public virtual void CloseQueue()
{
if (this.handle != null)
{
CloseQueue(this.handle);
this.handle = null;
this.isBoundToCompletionPort = false;
this.isAsyncEnabled = false;
MsmqDiagnostics.QueueClosed(this.formatName);
}
}
void CloseQueue(MsmqQueueHandle handle)
{
handle.Dispose();
}
protected void HandleIsStale(MsmqQueueHandle handle)
{
lock (this.ThisLock)
{
if (this.handle == handle)
{
CloseQueue();
}
}
}
public static void GetMsmqInformation(ref Version version, ref bool activeDirectoryEnabled)
{
PrivateComputerProperties properties = new PrivateComputerProperties();
using (properties)
{
IntPtr nativePropertiesPointer = properties.Pin();
try
{
int error = UnsafeNativeMethods.MQGetPrivateComputerInformation(null,
nativePropertiesPointer);
if (error != 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(
SR.MsmqGetPrivateComputerInformationError, MsmqError.GetErrorString(error)), error));
}
int packedVersion = properties.Version.Value;
version = new Version(
packedVersion >> 24,
(packedVersion & 0x00FF0000) >> 16,
packedVersion & 0xFFFF);
activeDirectoryEnabled = properties.ActiveDirectory.Value;
}
finally
{
properties.Unpin();
}
}
}
public static bool IsReadable(string formatName, out MsmqException ex)
{
return SupportsAccessMode(formatName, UnsafeNativeMethods.MQ_RECEIVE_ACCESS, out ex);
}
public static bool IsWriteable(string formatName)
{
MsmqException ex;
return SupportsAccessMode(formatName, UnsafeNativeMethods.MQ_SEND_ACCESS, out ex);
}
public static bool IsMoveable(string formatName)
{
MsmqException ex;
return SupportsAccessMode(formatName, UnsafeNativeMethods.MQ_MOVE_ACCESS, out ex);
}
internal static bool IsQueueOpenable(string formatName, int accessMode, int shareMode, out int error)
{
MsmqQueueHandle handle;
error = UnsafeNativeMethods.MQOpenQueue(formatName, accessMode,
shareMode, out handle);
if (error != 0)
{
Utility.CloseInvalidOutSafeHandle(handle);
return false;
}
handle.Dispose();
return true;
}
static bool SupportsAccessMode(string formatName, int accessType, out MsmqException msmqException)
{
msmqException = null;
try
{
using (MsmqQueue msmqQueue = new MsmqQueue(formatName, accessType))
{
msmqQueue.GetHandle();
}
}
catch (Exception ex)
{
msmqException = ex as MsmqException;
if (null != msmqException)
{
return false;
}
throw;
}
return true;
}
public static bool TryGetIsTransactional(string formatName, out bool isTransactional)
{
using (QueueTransactionProperties properties = new QueueTransactionProperties())
{
IntPtr nativePropertiesPointer = properties.Pin();
try
{
if (UnsafeNativeMethods.MQGetQueueProperties(formatName,
nativePropertiesPointer) == 0)
{
isTransactional = properties.Transaction.Value != UnsafeNativeMethods.MQ_TRANSACTIONAL_NONE;
return true;
}
else
{
isTransactional = false;
MsmqDiagnostics.QueueTransactionalStatusUnknown(formatName);
return false;
}
}
finally
{
properties.Unpin();
}
}
}
protected static bool IsErrorDueToStaleHandle(int error)
{
switch (error)
{
case UnsafeNativeMethods.MQ_ERROR_STALE_HANDLE:
case UnsafeNativeMethods.MQ_ERROR_INVALID_HANDLE:
case UnsafeNativeMethods.MQ_ERROR_INVALID_PARAMETER:
case UnsafeNativeMethods.MQ_ERROR_QUEUE_DELETED:
return true;
default:
return false;
}
}
protected static bool IsReceiveErrorDueToInsufficientBuffer(int error)
{
switch (error)
{
case UnsafeNativeMethods.MQ_ERROR_BUFFER_OVERFLOW:
case UnsafeNativeMethods.MQ_INFORMATION_FORMATNAME_BUFFER_TOO_SMALL:
case UnsafeNativeMethods.MQ_ERROR_FORMATNAME_BUFFER_TOO_SMALL:
case UnsafeNativeMethods.MQ_ERROR_SENDERID_BUFFER_TOO_SMALL:
case UnsafeNativeMethods.MQ_ERROR_SECURITY_DESCRIPTOR_TOO_SMALL:
case UnsafeNativeMethods.MQ_ERROR_USER_BUFFER_TOO_SMALL:
case UnsafeNativeMethods.MQ_ERROR_SENDER_CERT_BUFFER_TOO_SMALL:
case UnsafeNativeMethods.MQ_ERROR_RESULT_BUFFER_TOO_SMALL:
case UnsafeNativeMethods.MQ_ERROR_LABEL_BUFFER_TOO_SMALL:
case UnsafeNativeMethods.MQ_ERROR_SYMM_KEY_BUFFER_TOO_SMALL:
case UnsafeNativeMethods.MQ_ERROR_SIGNATURE_BUFFER_TOO_SMALL:
case UnsafeNativeMethods.MQ_ERROR_PROV_NAME_BUFFER_TOO_SMALL:
return true;
default:
return false;
}
}
public void MarkMessageRejected(long lookupId)
{
MsmqQueueHandle handle = GetHandle();
int error = 0;
try
{
error = UnsafeNativeMethods.MQMarkMessageRejected(handle, lookupId);
}
catch (ObjectDisposedException ex)
{
MsmqDiagnostics.ExpectedException(ex);
}
if (error != 0)
{
if (IsErrorDueToStaleHandle(error))
{
HandleIsStale(handle);
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(SR.MsmqSendError, MsmqError.GetErrorString(error)), error));
}
}
int TryMoveMessageDtcTransacted(long lookupId, MsmqQueueHandle sourceQueueHandle, MsmqQueueHandle destinationQueueHandle, MsmqTransactionMode transactionMode)
{
IDtcTransaction dtcTransaction = GetNativeTransaction(transactionMode);
if (dtcTransaction != null)
{
try
{
return UnsafeNativeMethods.MQMoveMessage(sourceQueueHandle, destinationQueueHandle,
lookupId, dtcTransaction);
}
finally
{
Marshal.ReleaseComObject(dtcTransaction);
}
}
else
{
return UnsafeNativeMethods.MQMoveMessage(sourceQueueHandle, destinationQueueHandle,
lookupId, (IntPtr)GetTransactionConstant(transactionMode));
}
}
public MoveReceiveResult TryMoveMessage(long lookupId, MsmqQueue destinationQueue, MsmqTransactionMode transactionMode)
{
MsmqQueueHandle sourceQueueHandle = GetHandle();
MsmqQueueHandle destinationQueueHandle = destinationQueue.GetHandle();
int error;
try
{
if (RequiresDtcTransaction(transactionMode))
{
error = TryMoveMessageDtcTransacted(lookupId, sourceQueueHandle, destinationQueueHandle, transactionMode);
}
else
{
error = UnsafeNativeMethods.MQMoveMessage(sourceQueueHandle, destinationQueueHandle,
lookupId, (IntPtr)GetTransactionConstant(transactionMode));
}
}
catch (ObjectDisposedException ex)
{
MsmqDiagnostics.ExpectedException(ex);
return MoveReceiveResult.Succeeded;
}
if (error != 0)
{
if (error == UnsafeNativeMethods.MQ_ERROR_MESSAGE_NOT_FOUND)
return MoveReceiveResult.MessageNotFound;
else if (error == UnsafeNativeMethods.MQ_ERROR_MESSAGE_LOCKED_UNDER_TRANSACTION)
return MoveReceiveResult.MessageLockedUnderTransaction;
else if (IsErrorDueToStaleHandle(error))
{
HandleIsStale(sourceQueueHandle);
destinationQueue.HandleIsStale(destinationQueueHandle);
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(SR.MsmqSendError,
MsmqError.GetErrorString(error)), error));
}
return MoveReceiveResult.Succeeded;
}
public virtual ReceiveResult TryReceive(NativeMsmqMessage message, TimeSpan timeout, MsmqTransactionMode transactionMode)
{
return TryReceiveInternal(message, timeout, transactionMode, UnsafeNativeMethods.MQ_ACTION_RECEIVE);
}
ReceiveResult TryReceiveInternal(NativeMsmqMessage message, TimeSpan timeout, MsmqTransactionMode transactionMode, int action)
{
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
MsmqQueueHandle handle = GetHandle();
while (true)
{
int error = ReceiveCore(handle, message, timeoutHelper.RemainingTime(), transactionMode, action);
if (0 == error)
return ReceiveResult.MessageReceived;
if (IsReceiveErrorDueToInsufficientBuffer(error))
{
message.GrowBuffers();
continue;
}
else if (error == UnsafeNativeMethods.MQ_ERROR_IO_TIMEOUT)
{
return ReceiveResult.Timeout;
}
else if (error == UnsafeNativeMethods.MQ_ERROR_OPERATION_CANCELLED)
{
return ReceiveResult.OperationCancelled;
}
else if (error == UnsafeNativeMethods.MQ_ERROR_INVALID_HANDLE)
{
// should happen only if racing with Close
return ReceiveResult.OperationCancelled;
}
else if (IsErrorDueToStaleHandle(error))
{
HandleIsStale(handle);
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(SR.MsmqReceiveError, MsmqError.GetErrorString(error)), error));
}
}
public MoveReceiveResult TryReceiveByLookupId(long lookupId, NativeMsmqMessage message, MsmqTransactionMode transactionMode)
{
return this.TryReceiveByLookupId(lookupId, message, transactionMode, UnsafeNativeMethods.MQ_LOOKUP_RECEIVE_CURRENT);
}
public MoveReceiveResult TryReceiveByLookupId(long lookupId, NativeMsmqMessage message, MsmqTransactionMode transactionMode, int action)
{
MsmqQueueHandle handle = GetHandle();
int error = 0;
while (true)
{
try
{
error = ReceiveByLookupIdCore(handle, lookupId, message, transactionMode, action);
}
catch (ObjectDisposedException ex)
{
// ---- with Close
MsmqDiagnostics.ExpectedException(ex);
return MoveReceiveResult.Succeeded;
}
if (0 == error)
{
return MoveReceiveResult.Succeeded;
}
if (IsReceiveErrorDueToInsufficientBuffer(error))
{
message.GrowBuffers();
continue;
}
else if (UnsafeNativeMethods.MQ_ERROR_MESSAGE_NOT_FOUND == error)
{
return MoveReceiveResult.MessageNotFound;
}
else if (UnsafeNativeMethods.MQ_ERROR_MESSAGE_LOCKED_UNDER_TRANSACTION == error)
{
return MoveReceiveResult.MessageLockedUnderTransaction;
}
else if (IsErrorDueToStaleHandle(error))
{
HandleIsStale(handle);
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(SR.MsmqReceiveError, MsmqError.GetErrorString(error)), error));
}
}
[PermissionSet(SecurityAction.Demand, Unrestricted = true), SecuritySafeCritical]
protected unsafe int ReceiveByLookupIdCoreDtcTransacted(MsmqQueueHandle handle, long lookupId, NativeMsmqMessage message, MsmqTransactionMode transactionMode, int action)
{
IDtcTransaction dtcTransaction = GetNativeTransaction(transactionMode);
IntPtr nativePropertiesPointer = message.Pin();
try
{
if (dtcTransaction != null)
{
try
{
return UnsafeNativeMethods.MQReceiveMessageByLookupId(handle, lookupId, action, nativePropertiesPointer, null, IntPtr.Zero, dtcTransaction);
}
finally
{
Marshal.ReleaseComObject(dtcTransaction);
}
}
else
{
return UnsafeNativeMethods.MQReceiveMessageByLookupId(handle, lookupId, action, nativePropertiesPointer, null, IntPtr.Zero, (IntPtr)GetTransactionConstant(transactionMode));
}
}
finally
{
message.Unpin();
}
}
[PermissionSet(SecurityAction.Demand, Unrestricted = true), SecuritySafeCritical]
unsafe int ReceiveByLookupIdCore(MsmqQueueHandle handle, long lookupId, NativeMsmqMessage message, MsmqTransactionMode transactionMode, int action)
{
if (RequiresDtcTransaction(transactionMode))
{
return ReceiveByLookupIdCoreDtcTransacted(handle, lookupId, message, transactionMode, action);
}
else
{
IntPtr nativePropertiesPointer = message.Pin();
try
{
return UnsafeNativeMethods.MQReceiveMessageByLookupId(handle, lookupId, action, nativePropertiesPointer, null, IntPtr.Zero, (IntPtr)GetTransactionConstant(transactionMode));
}
finally
{
message.Unpin();
}
}
}
[PermissionSet(SecurityAction.Demand, Unrestricted = true), SecuritySafeCritical]
unsafe int ReceiveCoreDtcTransacted(MsmqQueueHandle handle, NativeMsmqMessage message, TimeSpan timeout, MsmqTransactionMode transactionMode, int action)
{
IDtcTransaction dtcTransaction = GetNativeTransaction(transactionMode);
int timeoutInMilliseconds = TimeoutHelper.ToMilliseconds(timeout);
IntPtr nativePropertiesPointer = message.Pin();
try
{
if (dtcTransaction != null)
{
try
{
return UnsafeNativeMethods.MQReceiveMessage(handle.DangerousGetHandle(), timeoutInMilliseconds,
action, nativePropertiesPointer, null, IntPtr.Zero, IntPtr.Zero, dtcTransaction);
}
finally
{
Marshal.ReleaseComObject(dtcTransaction);
}
}
else
{
return UnsafeNativeMethods.MQReceiveMessage(handle.DangerousGetHandle(), timeoutInMilliseconds,
action, nativePropertiesPointer, null, IntPtr.Zero, IntPtr.Zero, (IntPtr)GetTransactionConstant(transactionMode));
}
}
finally
{
message.Unpin();
}
}
[PermissionSet(SecurityAction.Demand, Unrestricted = true), SecuritySafeCritical]
unsafe int ReceiveCore(MsmqQueueHandle handle, NativeMsmqMessage message, TimeSpan timeout, MsmqTransactionMode transactionMode, int action)
{
if (RequiresDtcTransaction(transactionMode))
{
return ReceiveCoreDtcTransacted(handle, message, timeout, transactionMode, action);
}
else
{
int timeoutInMilliseconds = TimeoutHelper.ToMilliseconds(timeout);
IntPtr nativePropertiesPointer = message.Pin();
try
{
return UnsafeNativeMethods.MQReceiveMessage(handle.DangerousGetHandle(), timeoutInMilliseconds,
action, nativePropertiesPointer, null, IntPtr.Zero, IntPtr.Zero, (IntPtr)GetTransactionConstant(transactionMode));
}
finally
{
message.Unpin();
}
}
}
protected IDtcTransaction GetNativeTransaction(MsmqTransactionMode transactionMode)
{
Transaction transaction = Transaction.Current;
if (transaction != null)
{
return TransactionInterop.GetDtcTransaction(transaction);
}
if (transactionMode == MsmqTransactionMode.CurrentOrThrow)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.MsmqTransactionRequired)));
}
return null;
}
public ReceiveResult TryPeek(NativeMsmqMessage message, TimeSpan timeout)
{
return TryReceiveInternal(message, timeout, MsmqTransactionMode.None,
UnsafeNativeMethods.MQ_ACTION_PEEK_CURRENT);
}
bool RequiresDtcTransaction(MsmqTransactionMode transactionMode)
{
switch (transactionMode)
{
case MsmqTransactionMode.None:
case MsmqTransactionMode.Single:
return false;
case MsmqTransactionMode.CurrentOrSingle:
case MsmqTransactionMode.CurrentOrNone:
case MsmqTransactionMode.CurrentOrThrow:
return true;
default:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("transactionMode"));
}
}
int GetTransactionConstant(MsmqTransactionMode transactionMode)
{
switch (transactionMode)
{
case MsmqTransactionMode.CurrentOrNone:
case MsmqTransactionMode.None:
return UnsafeNativeMethods.MQ_NO_TRANSACTION;
case MsmqTransactionMode.Single:
case MsmqTransactionMode.CurrentOrSingle:
return UnsafeNativeMethods.MQ_SINGLE_MESSAGE;
default:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("transactionMode"));
}
}
int SendDtcTransacted(NativeMsmqMessage message, MsmqTransactionMode transactionMode)
{
IDtcTransaction dtcTransaction = GetNativeTransaction(transactionMode);
MsmqQueueHandle handle = GetHandle();
IntPtr nativePropertiesPointer = message.Pin();
try
{
if (dtcTransaction != null)
{
try
{
return UnsafeNativeMethods.MQSendMessage(handle, nativePropertiesPointer,
dtcTransaction);
}
finally
{
Marshal.ReleaseComObject(dtcTransaction);
}
}
else
{
return UnsafeNativeMethods.MQSendMessage(handle, nativePropertiesPointer,
(IntPtr)GetTransactionConstant(transactionMode));
}
}
finally
{
message.Unpin();
}
}
public void Send(NativeMsmqMessage message, MsmqTransactionMode transactionMode)
{
int error = 0;
if (RequiresDtcTransaction(transactionMode))
{
error = SendDtcTransacted(message, transactionMode);
}
else
{
MsmqQueueHandle handle = GetHandle();
IntPtr nativePropertiesPointer = message.Pin();
try
{
error = UnsafeNativeMethods.MQSendMessage(handle, nativePropertiesPointer,
(IntPtr)GetTransactionConstant(transactionMode));
}
finally
{
message.Unpin();
}
}
if (error != 0)
{
if (IsErrorDueToStaleHandle(error))
{
HandleIsStale(handle);
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(SR.MsmqSendError, MsmqError.GetErrorString(error)), error));
}
}
[PermissionSet(SecurityAction.Demand, Unrestricted = true), SecuritySafeCritical]
unsafe int ReceiveCoreAsync(MsmqQueueHandle handle, IntPtr nativePropertiesPointer, TimeSpan timeout,
int action, NativeOverlapped* nativeOverlapped,
UnsafeNativeMethods.MQReceiveCallback receiveCallback)
{
int timeoutInMilliseconds = TimeoutHelper.ToMilliseconds(timeout);
return UnsafeNativeMethods.MQReceiveMessage(handle, timeoutInMilliseconds, action,
nativePropertiesPointer, nativeOverlapped, receiveCallback,
IntPtr.Zero, (IntPtr)UnsafeNativeMethods.MQ_NO_TRANSACTION);
}
public IAsyncResult BeginTryReceive(NativeMsmqMessage message, TimeSpan timeout,
AsyncCallback callback, object state)
{
return new TryReceiveAsyncResult(this, message, timeout,
UnsafeNativeMethods.MQ_ACTION_RECEIVE, callback, state);
}
public ReceiveResult EndTryReceive(IAsyncResult result)
{
return TryReceiveAsyncResult.End(result);
}
public IAsyncResult BeginPeek(NativeMsmqMessage message, TimeSpan timeout,
AsyncCallback callback, object state)
{
return new TryReceiveAsyncResult(this, message, timeout,
UnsafeNativeMethods.MQ_ACTION_PEEK_CURRENT, callback, state);
}
public ReceiveResult EndPeek(IAsyncResult result)
{
return TryReceiveAsyncResult.End(result);
}
class TryReceiveAsyncResult : AsyncResult
{
MsmqQueue msmqQueue;
int action;
TimeoutHelper timeoutHelper;
NativeMsmqMessage message;
unsafe NativeOverlapped* nativeOverlapped = null;
MsmqQueueHandle handle;
ReceiveResult receiveResult;
unsafe static IOCompletionCallback onPortedCompletion = Fx.ThunkCallback(new IOCompletionCallback(OnPortedCompletion));
unsafe static UnsafeNativeMethods.MQReceiveCallback onNonPortedCompletion;
[PermissionSet(SecurityAction.Demand, Unrestricted = true), SecuritySafeCritical]
public TryReceiveAsyncResult(MsmqQueue msmqQueue, NativeMsmqMessage message, TimeSpan timeout,
int action, AsyncCallback callback, object state)
: base(callback, state)
{
this.msmqQueue = msmqQueue;
this.message = message;
this.action = action;
this.timeoutHelper = new TimeoutHelper(timeout);
StartReceive(true);
}
[PermissionSet(SecurityAction.Demand, Unrestricted = true), SecuritySafeCritical]
unsafe ~TryReceiveAsyncResult()
{
if (null != this.nativeOverlapped
&& ! Environment.HasShutdownStarted
&& ! AppDomain.CurrentDomain.IsFinalizingForUnload())
{
Overlapped.Free(this.nativeOverlapped);
}
}
[PermissionSet(SecurityAction.Demand, Unrestricted = true), SecuritySafeCritical]
unsafe void StartReceive(bool synchronously)
{
bool useCompletionPort;
try
{
this.handle = this.msmqQueue.GetHandleForAsync(out useCompletionPort);
}
catch (MsmqException ex)
{
OnCompletion(ex.ErrorCode, synchronously);
return;
}
if (null != nativeOverlapped)
{
Fx.Assert("---- in StartReceive");
}
IntPtr nativePropertiesPointer = this.message.Pin();
nativeOverlapped = new Overlapped(0, 0, IntPtr.Zero, this).UnsafePack(onPortedCompletion, this.message.GetBuffersForAsync());
int error;
try
{
if (useCompletionPort)
{
error = msmqQueue.ReceiveCoreAsync(this.handle, nativePropertiesPointer, this.timeoutHelper.RemainingTime(),
this.action, nativeOverlapped, null);
}
else
{
if (onNonPortedCompletion == null)
{
onNonPortedCompletion = new UnsafeNativeMethods.MQReceiveCallback(OnNonPortedCompletion);
}
error = msmqQueue.ReceiveCoreAsync(this.handle, nativePropertiesPointer, this.timeoutHelper.RemainingTime(),
this.action, nativeOverlapped, onNonPortedCompletion);
}
}
catch (ObjectDisposedException ex)
{
// if Close ----s with the async Receive, it is possible that SafeHandle will throw ObjectDisposedException
// the behavior should be same as if operation was just cancelled (the channel will return no message)
MsmqDiagnostics.ExpectedException(ex);
error = UnsafeNativeMethods.MQ_ERROR_OPERATION_CANCELLED;
}
if (error != 0)
{
if (error != UnsafeNativeMethods.MQ_INFORMATION_OPERATION_PENDING)
{
Overlapped.Free(nativeOverlapped);
nativeOverlapped = null;
GC.SuppressFinalize(this);
OnCompletion(error, synchronously);
}
}
}
[PermissionSet(SecurityAction.Demand, Unrestricted = true), SecuritySafeCritical]
unsafe static void OnNonPortedCompletion(int error, IntPtr handle, int timeout,
int action, IntPtr props, NativeOverlapped* nativeOverlapped, IntPtr cursor)
{
ThreadPool.UnsafeQueueNativeOverlapped(nativeOverlapped);
}
[PermissionSet(SecurityAction.Demand, Unrestricted = true), SecuritySafeCritical]
unsafe static void OnPortedCompletion(uint error, uint numBytes, NativeOverlapped* nativeOverlapped)
{
Overlapped overlapped = Overlapped.Unpack(nativeOverlapped);
TryReceiveAsyncResult result = (TryReceiveAsyncResult)overlapped.AsyncResult;
if (error != 0)
{
error = (uint)UnsafeNativeMethods.MQGetOverlappedResult(nativeOverlapped);
}
Overlapped.Free(nativeOverlapped);
result.nativeOverlapped = null;
#pragma warning suppress 56508 // Suppression justified. Presharp warning concerns different scenario.
GC.SuppressFinalize(result);
result.OnCompletion((int)error, false);
}
void OnCompletion(int error, bool completedSynchronously)
{
Exception completionException = null;
this.receiveResult = ReceiveResult.MessageReceived;
try
{
if (error != 0)
{
if (error == UnsafeNativeMethods.MQ_ERROR_IO_TIMEOUT)
{
this.receiveResult = ReceiveResult.Timeout;
}
else if (error == UnsafeNativeMethods.MQ_ERROR_OPERATION_CANCELLED)
{
this.receiveResult = ReceiveResult.OperationCancelled;
}
else
{
if (IsReceiveErrorDueToInsufficientBuffer(error))
{
this.message.Unpin();
message.GrowBuffers();
StartReceive(completedSynchronously);
return;
}
else if (IsErrorDueToStaleHandle(error))
{
this.msmqQueue.HandleIsStale(this.handle);
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(SR.MsmqReceiveError, MsmqError.GetErrorString(error)), error));
}
}
}
catch (Exception e)
{
if (e is NullReferenceException || e is SEHException)
throw;
completionException = e;
}
this.message.Unpin();
Complete(completedSynchronously, completionException);
}
public static ReceiveResult End(IAsyncResult result)
{
TryReceiveAsyncResult thisPtr = AsyncResult.End<TryReceiveAsyncResult>(result);
return thisPtr.receiveResult;
}
}
class QueueTransactionProperties : NativeMsmqMessage
{
ByteProperty transaction;
public QueueTransactionProperties() : base(1)
{
this.transaction = new ByteProperty(this, UnsafeNativeMethods.PROPID_Q_TRANSACTION);
}
public ByteProperty Transaction
{
get { return this.transaction; }
}
}
class PrivateComputerProperties : NativeMsmqMessage
{
IntProperty version;
BooleanProperty activeDirectory;
public PrivateComputerProperties()
: base(2)
{
this.version = new IntProperty(this, UnsafeNativeMethods.PROPID_PC_VERSION);
this.activeDirectory = new BooleanProperty(this, UnsafeNativeMethods.PROPID_PC_DS_ENABLED);
}
public IntProperty Version
{
get { return this.version; }
}
public BooleanProperty ActiveDirectory
{
get { return this.activeDirectory; }
}
}
public enum MoveReceiveResult
{
Unknown,
Succeeded,
MessageNotFound,
MessageLockedUnderTransaction
}
internal enum ReceiveResult
{
Unknown,
MessageReceived,
Timeout,
OperationCancelled
}
}
static class MsmqFormatName
{
const string systemMessagingLabelPrefix = "LABEL:";
const string systemMessagingFormatNamePrefix = "FORMATNAME:";
public static string ToSystemMessagingQueueName(string formatName)
{
return systemMessagingFormatNamePrefix + formatName;
}
public static string FromQueuePath(string queuePath)
{
int len = 256;
StringBuilder buffer = new StringBuilder(len);
int error = UnsafeNativeMethods.MQPathNameToFormatName(queuePath, buffer, ref len);
if (UnsafeNativeMethods.MQ_ERROR_FORMATNAME_BUFFER_TOO_SMALL == error)
{
buffer = new StringBuilder(len);
error = UnsafeNativeMethods.MQPathNameToFormatName(queuePath, buffer, ref len);
}
if (0 != error)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new MsmqException(SR.GetString(SR.MsmqPathLookupError, queuePath, MsmqError.GetErrorString(error)), error));
}
return buffer.ToString();
}
}
}