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

440 lines
18 KiB
C#

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.ServiceModel.Transactions
{
using System;
using System.Diagnostics.CodeAnalysis;
using System.Runtime;
using System.ServiceModel.Channels;
using System.ServiceModel;
using System.IO;
using System.Net;
using System.Security;
using System.ServiceModel.ComIntegration;
using System.ServiceModel.Security;
using System.Transactions;
using Microsoft.Transactions.Wsat.Messaging;
using Microsoft.Transactions.Wsat.Protocol;
using Microsoft.Transactions.Wsat.Recovery;
class TransactionManagerConfigurationException : TransactionException
{
public TransactionManagerConfigurationException(string error, Exception e)
:
base(error, e)
{
}
public TransactionManagerConfigurationException(string error)
:
base(error)
{
}
}
class WsatConfiguration
{
static readonly string DisabledRegistrationPath;
const string WsatKey = @"Software\Microsoft\WSAT\3.0";
const string OleTxUpgradeEnabledValue = "OleTxUpgradeEnabled";
const bool OleTxUpgradeEnabledDefault = true;
bool oleTxUpgradeEnabled;
EndpointAddress localActivationService10;
EndpointAddress localActivationService11;
EndpointAddress remoteActivationService10;
EndpointAddress remoteActivationService11;
Uri registrationServiceAddress10;
Uri registrationServiceAddress11;
bool protocolService10Enabled = false;
bool protocolService11Enabled = false;
bool inboundEnabled;
bool issuedTokensEnabled;
TimeSpan maxTimeout;
[SuppressMessage(FxCop.Category.Security, FxCop.Rule.AptcaMethodsShouldOnlyCallAptcaMethods, Justification = "The calls to BindingStrings are safe.")]
static WsatConfiguration()
{
DisabledRegistrationPath = string.Concat(BindingStrings.AddressPrefix, "/", BindingStrings.RegistrationCoordinatorSuffix(ProtocolVersion.Version10), BindingStrings.DisabledSuffix);
}
[SuppressMessage(FxCop.Category.Security, FxCop.Rule.AptcaMethodsShouldOnlyCallAptcaMethods, Justification = "The calls to ProtocolInformationReader.IsV10Enabled and IsV11Enabled are safe.")]
public WsatConfiguration()
{
// Get whereabouts
WhereaboutsReader whereabouts = GetWhereabouts();
ProtocolInformationReader protocol = whereabouts.ProtocolInformation;
if (protocol != null)
{
this.protocolService10Enabled = protocol.IsV10Enabled;
this.protocolService11Enabled = protocol.IsV11Enabled;
}
Initialize(whereabouts);
// Read local registry flag
this.oleTxUpgradeEnabled = ReadFlag(WsatKey, OleTxUpgradeEnabledValue, OleTxUpgradeEnabledDefault);
}
void Initialize(WhereaboutsReader whereabouts)
{
// MB 47153: don't throw system exception if whereabouts data is broken
try
{
InitializeForUnmarshal(whereabouts);
InitializeForMarshal(whereabouts);
}
catch (UriFormatException e)
{
// UriBuilder.Uri can throw this if the URI is ultimately invalid
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new TransactionManagerConfigurationException(SR.GetString(SR.WsatUriCreationFailed), e));
}
catch (ArgumentOutOfRangeException e)
{
// UriBuilder constructor can throw this if port < 0
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new TransactionManagerConfigurationException(SR.GetString(SR.WsatUriCreationFailed), e));
}
}
public bool OleTxUpgradeEnabled
{
get { return this.oleTxUpgradeEnabled; }
}
public TimeSpan MaxTimeout
{
get { return this.maxTimeout; }
}
public bool IssuedTokensEnabled
{
get { return this.issuedTokensEnabled; }
}
public bool InboundEnabled
{
get { return this.inboundEnabled; }
}
public bool IsProtocolServiceEnabled(ProtocolVersion protocolVersion)
{
switch (protocolVersion)
{
case ProtocolVersion.Version10:
return this.protocolService10Enabled;
case ProtocolVersion.Version11:
return this.protocolService11Enabled;
default:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new ArgumentException(SR.GetString(SR.InvalidWsatProtocolVersion)));
}
}
public EndpointAddress LocalActivationService(ProtocolVersion protocolVersion)
{
switch (protocolVersion)
{
case ProtocolVersion.Version10:
return this.localActivationService10;
case ProtocolVersion.Version11:
return this.localActivationService11;
default:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new ArgumentException(SR.GetString(SR.InvalidWsatProtocolVersion)));
}
}
public EndpointAddress RemoteActivationService(ProtocolVersion protocolVersion)
{
switch (protocolVersion)
{
case ProtocolVersion.Version10:
return this.remoteActivationService10;
case ProtocolVersion.Version11:
return this.remoteActivationService11;
default:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new ArgumentException(SR.GetString(SR.InvalidWsatProtocolVersion)));
}
}
public EndpointAddress CreateRegistrationService(AddressHeader refParam, ProtocolVersion protocolVersion)
{
switch (protocolVersion)
{
case ProtocolVersion.Version10:
return new EndpointAddress(this.registrationServiceAddress10, refParam);
case ProtocolVersion.Version11:
return new EndpointAddress(this.registrationServiceAddress11, refParam);
default:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new ArgumentException(SR.GetString(SR.InvalidWsatProtocolVersion)));
}
}
public bool IsLocalRegistrationService(EndpointAddress endpoint, ProtocolVersion protocolVersion)
{
if (endpoint.Uri == null)
return false;
switch (protocolVersion)
{
case ProtocolVersion.Version10:
return endpoint.Uri == this.registrationServiceAddress10;
case ProtocolVersion.Version11:
return endpoint.Uri == this.registrationServiceAddress11;
default:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new ArgumentException(SR.GetString(SR.InvalidWsatProtocolVersion)));
}
}
public bool IsDisabledRegistrationService(EndpointAddress endpoint)
{
return endpoint.Uri.AbsolutePath == DisabledRegistrationPath;
}
//
// Internals
//
WhereaboutsReader GetWhereabouts()
{
try
{
return new WhereaboutsReader(TransactionInterop.GetWhereabouts());
}
catch (SerializationException e)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new TransactionManagerConfigurationException(SR.GetString(SR.WhereaboutsReadFailed), e));
}
// If GetWhereabouts throws TransactionException, let it propagate
}
[SuppressMessage(FxCop.Category.Security, FxCop.Rule.AptcaMethodsShouldOnlyCallAptcaMethods, Justification = "The calls to the ProtocolInformationReader properties and to BindingStrings.RegistrationCoordinatorSuffix(..) are safe.")]
void InitializeForUnmarshal(WhereaboutsReader whereabouts)
{
ProtocolInformationReader protocol = whereabouts.ProtocolInformation;
if (protocol != null && protocol.NetworkInboundAccess)
{
this.inboundEnabled = true;
bool isTmLocal = string.Compare(Environment.MachineName,
protocol.NodeName,
StringComparison.OrdinalIgnoreCase) == 0;
string spnIdentity;
string activationCoordinatorSuffix10 =
BindingStrings.ActivationCoordinatorSuffix(ProtocolVersion.Version10);
string activationCoordinatorSuffix11 =
BindingStrings.ActivationCoordinatorSuffix(ProtocolVersion.Version11);
if (protocol.IsClustered ||
(protocol.NetworkClientAccess && !isTmLocal))
{
if (protocol.IsClustered)
{
// We cannot reliably perform mutual authentication against a clustered resource
// See MB 43523 for more details on this
spnIdentity = null;
}
else
{
spnIdentity = "host/" + protocol.HostName;
}
if (protocol.IsV10Enabled)
{
this.remoteActivationService10 = CreateActivationEndpointAddress(protocol,
activationCoordinatorSuffix10,
spnIdentity,
true);
}
if (protocol.IsV11Enabled)
{
this.remoteActivationService11 = CreateActivationEndpointAddress(protocol,
activationCoordinatorSuffix11,
spnIdentity,
true);
}
}
if (isTmLocal)
{
spnIdentity = "host/" + protocol.NodeName;
// The net.pipe Activation endpoint uses the host name as a discriminant
// for cluster scenarios with more than one service on a node.
if (protocol.IsV10Enabled)
{
this.localActivationService10 = CreateActivationEndpointAddress(protocol,
activationCoordinatorSuffix10,
spnIdentity,
false);
}
if (protocol.IsV11Enabled)
{
this.localActivationService11 = CreateActivationEndpointAddress(protocol,
activationCoordinatorSuffix11,
spnIdentity,
false);
}
}
}
}
[SuppressMessage(FxCop.Category.Security, FxCop.Rule.AptcaMethodsShouldOnlyCallAptcaMethods, Justification = "The calls to the ProtocolInformationReader properties (HostName, HttpsPort, BasePath) are safe.")]
EndpointAddress CreateActivationEndpointAddress(ProtocolInformationReader protocol,
string suffix,
string spnIdentity,
bool isRemote)
{
string uriScheme;
string host;
int port;
string path;
if (isRemote)
{
uriScheme = Uri.UriSchemeHttps;
host = protocol.HostName;
port = protocol.HttpsPort;
path = protocol.BasePath + "/" + suffix + BindingStrings.RemoteProxySuffix;
}
else
{
uriScheme = Uri.UriSchemeNetPipe;
host = "localhost";
port = -1;
path = protocol.HostName + "/" + protocol.BasePath + "/" + suffix;
}
UriBuilder builder = new UriBuilder(uriScheme, host, port, path);
if (spnIdentity != null)
{
EndpointIdentity identity = EndpointIdentity.CreateSpnIdentity(spnIdentity);
return new EndpointAddress(builder.Uri, identity);
}
else
{
return new EndpointAddress(builder.Uri);
}
}
[SuppressMessage(FxCop.Category.Security, FxCop.Rule.AptcaMethodsShouldOnlyCallAptcaMethods, Justification = "The calls to the ProtocolInformationReader properties and to BindingStrings.RegistrationCoordinatorSuffix(..) are safe.")]
void InitializeForMarshal(WhereaboutsReader whereabouts)
{
ProtocolInformationReader protocol = whereabouts.ProtocolInformation;
if (protocol != null && protocol.NetworkOutboundAccess)
{
// We can marshal outgoing transactions using a valid address
if (protocol.IsV10Enabled)
{
UriBuilder builder10 = new UriBuilder(Uri.UriSchemeHttps,
protocol.HostName,
protocol.HttpsPort,
protocol.BasePath + "/" +
BindingStrings.RegistrationCoordinatorSuffix(ProtocolVersion.Version10));
this.registrationServiceAddress10 = builder10.Uri;
}
// when we have a WSAT1.1 coordinator
if (protocol.IsV11Enabled)
{
UriBuilder builder11 = new UriBuilder(Uri.UriSchemeHttps,
protocol.HostName,
protocol.HttpsPort,
protocol.BasePath + "/" +
BindingStrings.RegistrationCoordinatorSuffix(ProtocolVersion.Version11));
this.registrationServiceAddress11 = builder11.Uri;
}
this.issuedTokensEnabled = protocol.IssuedTokensEnabled;
this.maxTimeout = protocol.MaxTimeout;
}
else
{
// Generate an address that will not work
// We do this in order to generate coordination contexts that can be propagated
// between processes on the same node even if WS-AT is disabled
UriBuilder builder = new UriBuilder(Uri.UriSchemeHttps,
whereabouts.HostName,
443,
DisabledRegistrationPath);
this.registrationServiceAddress10 = builder.Uri;
this.registrationServiceAddress11 = builder.Uri;
this.issuedTokensEnabled = false;
this.maxTimeout = TimeSpan.FromMinutes(5);
}
}
static object ReadValue(string key, string value)
{
try
{
using (RegistryHandle regKey = RegistryHandle.GetNativeHKLMSubkey(key, false))
{
if (regKey == null)
return null;
return regKey.GetValue(value);
}
}
catch (SecurityException e)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new TransactionManagerConfigurationException(SR.GetString(SR.WsatRegistryValueReadError, value), e));
}
catch (IOException e)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new TransactionManagerConfigurationException(SR.GetString(SR.WsatRegistryValueReadError, value), e));
}
}
static int ReadInt(string key, string value, int defaultValue)
{
object regValue = ReadValue(key, value);
if (regValue == null || !(regValue is Int32))
return defaultValue;
return (int)regValue;
}
static bool ReadFlag(string key, string value, bool defaultValue)
{
return (int)ReadInt(key, value, defaultValue ? 1 : 0) != 0;
}
}
}