private void InitializeForMarshal(WhereaboutsReader whereabouts)
{
ProtocolInformationReader protocolInformation = whereabouts.ProtocolInformation;
if ((protocolInformation != null) && protocolInformation.NetworkOutboundAccess)
{
if (protocolInformation.IsV10Enabled)
{
UriBuilder builder = new UriBuilder(Uri.UriSchemeHttps, protocolInformation.HostName, protocolInformation.HttpsPort, protocolInformation.BasePath + "/" + BindingStrings.RegistrationCoordinatorSuffix(ProtocolVersion.Version10));
this.registrationServiceAddress10 = builder.Uri;
}
if (protocolInformation.IsV11Enabled)
{
UriBuilder builder2 = new UriBuilder(Uri.UriSchemeHttps, protocolInformation.HostName, protocolInformation.HttpsPort, protocolInformation.BasePath + "/" + BindingStrings.RegistrationCoordinatorSuffix(ProtocolVersion.Version11));
this.registrationServiceAddress11 = builder2.Uri;
}
this.issuedTokensEnabled = protocolInformation.IssuedTokensEnabled;
this.maxTimeout = protocolInformation.MaxTimeout;
}
else
{
UriBuilder builder3 = new UriBuilder(Uri.UriSchemeHttps, whereabouts.HostName, 0x1bb, DisabledRegistrationPath);
this.registrationServiceAddress10 = builder3.Uri;
this.registrationServiceAddress11 = builder3.Uri;
this.issuedTokensEnabled = false;
this.maxTimeout = TimeSpan.FromMinutes(5.0);
}
}
private EndpointAddress CreateActivationEndpointAddress(ProtocolInformationReader protocol, string suffix, string spnIdentity, bool isRemote)
{
string uriSchemeHttps;
string hostName;
int httpsPort;
string str3;
if (isRemote)
{
uriSchemeHttps = Uri.UriSchemeHttps;
hostName = protocol.HostName;
httpsPort = protocol.HttpsPort;
str3 = protocol.BasePath + "/" + suffix + "Remote/";
}
else
{
uriSchemeHttps = Uri.UriSchemeNetPipe;
hostName = "localhost";
httpsPort = -1;
str3 = protocol.HostName + "/" + protocol.BasePath + "/" + suffix;
}
UriBuilder builder = new UriBuilder(uriSchemeHttps, hostName, httpsPort, str3);
if (spnIdentity != null)
{
return(new EndpointAddress(builder.Uri, EndpointIdentity.CreateSpnIdentity(spnIdentity), new AddressHeader[0]));
}
return(new EndpointAddress(builder.Uri, new AddressHeader[0]));
}
private void ReadExtendedProtocol(MemoryStream mem, uint cbTmProtocolData)
{
Guid guid = SerializationUtils.ReadGuid(mem);
if ((guid == PluggableProtocol10.ProtocolGuid) || (guid == PluggableProtocol11.ProtocolGuid))
{
this.protocolInfo = new ProtocolInformationReader(mem);
}
else
{
SerializationUtils.IncrementPosition(mem, (long)(cbTmProtocolData - 0x10));
}
}
public WsatConfiguration()
{
WhereaboutsReader whereabouts = this.GetWhereabouts();
ProtocolInformationReader protocolInformation = whereabouts.ProtocolInformation;
if (protocolInformation != null)
{
this.protocolService10Enabled = protocolInformation.IsV10Enabled;
this.protocolService11Enabled = protocolInformation.IsV11Enabled;
}
this.Initialize(whereabouts);
this.oleTxUpgradeEnabled = ReadFlag(@"Software\Microsoft\WSAT\3.0", "OleTxUpgradeEnabled", true);
}
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);
}
}
// The demand is not added now (in 4.5), to avoid a breaking change. To be considered in the next version.
/*
* [PermissionSet(SecurityAction.Demand, Unrestricted = true)] // because we use ProtocolInformationReader, which is defined in a non-APTCA assembly; WSATs are not supported in partial trust, so customers should not be broken by this demand
*/
void ReadExtendedProtocol(MemoryStream mem, uint cbTmProtocolData)
{
// Read the WSAT1.0 protoocol identifier
Guid guid = SerializationUtils.ReadGuid(mem);
if (guid == PluggableProtocol10.ProtocolGuid || guid == PluggableProtocol11.ProtocolGuid)
{
// This is the WS-AT extended whereabouts blob
this.protocolInfo = new ProtocolInformationReader(mem);
}
else
{
// Some other gateway protocol... Skip the rest of the data
SerializationUtils.IncrementPosition(mem, cbTmProtocolData - 16);
}
}
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);
}
private void InitializeForUnmarshal(WhereaboutsReader whereabouts)
{
ProtocolInformationReader protocolInformation = whereabouts.ProtocolInformation;
if ((protocolInformation != null) && protocolInformation.NetworkInboundAccess)
{
string str;
this.inboundEnabled = true;
bool flag = string.Compare(Environment.MachineName, protocolInformation.NodeName, StringComparison.OrdinalIgnoreCase) == 0;
string suffix = BindingStrings.ActivationCoordinatorSuffix(ProtocolVersion.Version10);
string str3 = BindingStrings.ActivationCoordinatorSuffix(ProtocolVersion.Version11);
if (protocolInformation.IsClustered || (protocolInformation.NetworkClientAccess && !flag))
{
if (protocolInformation.IsClustered)
{
str = null;
}
else
{
str = "host/" + protocolInformation.HostName;
}
if (protocolInformation.IsV10Enabled)
{
this.remoteActivationService10 = this.CreateActivationEndpointAddress(protocolInformation, suffix, str, true);
}
if (protocolInformation.IsV11Enabled)
{
this.remoteActivationService11 = this.CreateActivationEndpointAddress(protocolInformation, str3, str, true);
}
}
if (flag)
{
str = "host/" + protocolInformation.NodeName;
if (protocolInformation.IsV10Enabled)
{
this.localActivationService10 = this.CreateActivationEndpointAddress(protocolInformation, suffix, str, false);
}
if (protocolInformation.IsV11Enabled)
{
this.localActivationService11 = this.CreateActivationEndpointAddress(protocolInformation, str3, str, false);
}
}
}
}
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));
}
}
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);
}
}
}
}
