public static AtomicTransactionStrings Version(ProtocolVersion protocolVersion)
{
ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(AtomicTransactionStrings), "V");
switch (protocolVersion)
{
case ProtocolVersion.Version10:
return(AtomicTransactionStrings10.Instance);
case ProtocolVersion.Version11:
return(AtomicTransactionStrings11.Instance);
}
return(null);
}
public static IWSActivationCoordinator Instance(CoordinationService service, IActivationCoordinator dispatch)
{
ProtocolVersionHelper.AssertProtocolVersion(service.ProtocolVersion, typeof(ActivationCoordinatorDispatcher), "Instance");
switch (service.ProtocolVersion)
{
case ProtocolVersion.Version10:
return(new ActivationCoordinatorDispatcher10(service, dispatch));
case ProtocolVersion.Version11:
return(new ActivationCoordinatorDispatcher11(service, dispatch));
}
return(null);
}
private static SecurityStandardsManager CreateStandardsManager(ProtocolVersion protocolVersion)
{
ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(CoordinationServiceSecurity), "CreateStandardsManager");
switch (protocolVersion)
{
case ProtocolVersion.Version10:
return(SecurityStandardsManager.DefaultInstance);
case ProtocolVersion.Version11:
return(SecurityStandardsManager2007);
}
return(null);
}
public static IdentifierElement Instance(string identifier, ProtocolVersion protocolVersion)
{
ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(IdentifierElement), "V");
switch (protocolVersion)
{
case ProtocolVersion.Version10:
return(new IdentifierElement10(identifier));
case ProtocolVersion.Version11:
return(new IdentifierElement11(identifier));
}
return(null);
}
public static IWSCompletionParticipant Instance(CoordinationService service, ICompletionParticipant dispatch)
{
ProtocolVersionHelper.AssertProtocolVersion(service.ProtocolVersion, typeof(CompletionParticipantDispatcher), "Instance");
switch (service.ProtocolVersion)
{
case ProtocolVersion.Version10:
return(new CompletionParticipantDispatcher10(service, dispatch));
case ProtocolVersion.Version11:
return(new CompletionParticipantDispatcher11(service, dispatch));
}
return(null);
}
public static MessageSecurityVersion SecurityVersion(ProtocolVersion protocolVersion)
{
ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(MessagingVersionHelper), "SecurityVersion");
switch (protocolVersion)
{
case ProtocolVersion.Version10:
return(MessageSecurityVersion.WSSecurity11WSTrustFebruary2005WSSecureConversationFebruary2005WSSecurityPolicy11);
case ProtocolVersion.Version11:
return(MessageSecurityVersion.WSSecurity11WSTrust13WSSecureConversation13WSSecurityPolicy12);
}
return(null);
}
public static System.ServiceModel.Channels.MessageVersion MessageVersion(ProtocolVersion protocolVersion)
{
ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(MessagingVersionHelper), "MessageVersion");
switch (protocolVersion)
{
case ProtocolVersion.Version10:
return(System.ServiceModel.Channels.MessageVersion.Soap11WSAddressingAugust2004);
case ProtocolVersion.Version11:
return(System.ServiceModel.Channels.MessageVersion.Soap11WSAddressing10);
}
return(null);
}
private static DataContractSerializer IdentifierElementSerializer(ProtocolVersion protocolVersion)
{
ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(CoordinationServiceSecurity), "IdentifierElementSerializer");
switch (protocolVersion)
{
case ProtocolVersion.Version10:
if (identifierElementSerializer10 == null)
{
identifierElementSerializer10 = new DataContractSerializer(typeof(IdentifierElement10));
}
return(identifierElementSerializer10);
case ProtocolVersion.Version11:
if (identifierElementSerializer11 == null)
{
identifierElementSerializer11 = new DataContractSerializer(typeof(IdentifierElement11));
}
return(identifierElementSerializer11);
}
return(null);
}
public static void CreateIssuedToken(Guid transactionId, string coordinationContextId, ProtocolVersion protocolVersion, out RequestSecurityTokenResponse issuedToken, out string sctId)
{
sctId = CoordinationContext.CreateNativeIdentifier(Guid.NewGuid());
byte[] key = DeriveIssuedTokenKey(transactionId, sctId);
DateTime utcNow = DateTime.UtcNow;
SecurityContextSecurityToken token = new SecurityContextSecurityToken(new UniqueId(sctId), key, utcNow, utcNow + TimeSpan.FromDays(36500.0));
BinarySecretSecurityToken token2 = new BinarySecretSecurityToken(key);
SecurityStandardsManager standardsManager = CreateStandardsManager(protocolVersion);
RequestSecurityTokenResponse response = new RequestSecurityTokenResponse(standardsManager)
{
TokenType = standardsManager.SecureConversationDriver.TokenTypeUri,
RequestedUnattachedReference = SecurityContextSecurityTokenParameters.CreateKeyIdentifierClause(token, SecurityTokenReferenceStyle.External),
RequestedAttachedReference = SecurityContextSecurityTokenParameters.CreateKeyIdentifierClause(token, SecurityTokenReferenceStyle.Internal),
RequestedSecurityToken = token,
RequestedProofToken = token2
};
DataContractSerializer serializer = IdentifierElementSerializer(protocolVersion);
ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(CoordinationServiceSecurity), "CreateIssuedToken");
switch (protocolVersion)
{
case ProtocolVersion.Version10:
response.SetAppliesTo <IdentifierElement10>(new IdentifierElement10(coordinationContextId), serializer);
break;
case ProtocolVersion.Version11:
response.SetAppliesTo <IdentifierElement11>(new IdentifierElement11(coordinationContextId), serializer);
break;
}
response.MakeReadOnly();
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "Created issued token with id {0} for transaction {1}", sctId, transactionId);
}
issuedToken = response;
}
public static void SetReplyAddress(Message message, EndpointAddress replyTo, ProtocolVersion protocolVersion)
{
ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(MessagingVersionHelper), "SetReplyAddress");
switch (protocolVersion)
{
case ProtocolVersion.Version10:
if (message.Headers.ReplyTo == null)
{
message.Headers.ReplyTo = replyTo;
}
if (message.Headers.MessageId == null)
{
message.Headers.MessageId = new UniqueId();
}
return;
case ProtocolVersion.Version11:
if (message.Headers.From == null)
{
message.Headers.From = replyTo;
}
return;
}
}
protected override void SerializeExtended()
{
Guid guid;
DebugTrace.TraceEnter(this, "SerializeExtended");
WsATv1LogEntryFlags flags = 0;
WsATv1LogEntryFlags pathFlags = 0;
EndpointAddress endpoint = base.logEntry.Endpoint;
Uri uri = endpoint.Uri;
if (GetRemoteEnlistmentId(endpoint, out guid))
{
flags = (WsATv1LogEntryFlags)((byte)(flags | WsATv1LogEntryFlags.OptimizedEndpointRepresentation));
if (string.Compare(uri.Scheme, Uri.UriSchemeHttps, StringComparison.OrdinalIgnoreCase) != 0)
{
Microsoft.Transactions.Bridge.DiagnosticUtility.FailFast("Endpoints must use the HTTPS scheme");
}
if (0x944 == uri.Port)
{
flags = (WsATv1LogEntryFlags)((byte)(flags | WsATv1LogEntryFlags.UsesDefaultPort));
}
pathFlags = GetPathFlags(endpoint, this.protocolVersion);
flags = (WsATv1LogEntryFlags)((byte)(flags | pathFlags));
}
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "SerializeExtended flags: {0}", flags);
}
byte num = 0;
ProtocolVersionHelper.AssertProtocolVersion(this.protocolVersion, base.GetType(), "SerializeExtended");
switch (this.protocolVersion)
{
case ProtocolVersion.Version10:
num = 1;
break;
case ProtocolVersion.Version11:
num = 2;
break;
}
base.mem.WriteByte(num);
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "Wrote version: {0} bytes", base.mem.Length);
}
base.mem.WriteByte((byte)flags);
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "Wrote flags: {0} bytes", base.mem.Length);
}
if (((byte)(flags & WsATv1LogEntryFlags.OptimizedEndpointRepresentation)) == 0)
{
SerializationUtils.WriteEndpointAddress(base.mem, endpoint, this.protocolVersion);
}
else
{
SerializationUtils.WriteGuid(base.mem, ref guid);
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "Wrote enlistmentId: {0} bytes", base.mem.Length);
}
SerializationUtils.WriteString(base.mem, uri.Host);
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "Wrote hostName: {0} bytes", base.mem.Length);
}
if (((byte)(flags & WsATv1LogEntryFlags.UsesDefaultPort)) == 0)
{
if ((uri.Port < 0) || (uri.Port > 0xffff))
{
Microsoft.Transactions.Bridge.DiagnosticUtility.FailFast("TCP port must be valid");
}
SerializationUtils.WriteInt(base.mem, uri.Port);
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "Wrote port: {0} bytes", base.mem.Length);
}
}
if (((int)pathFlags) == 0)
{
SerializationUtils.WriteString(base.mem, uri.AbsolutePath);
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "Wrote address path: {0} bytes", base.mem.Length);
}
}
}
DebugTrace.TraceLeave(this, "DeserializeExtended");
}
public static RequestSecurityTokenResponse GetIssuedToken(Message message, string identifier, ProtocolVersion protocolVersion)
{
ICollection <RequestSecurityTokenResponse> is2 = TransactionFlowProperty.TryGetIssuedTokens(message);
if (is2 == null)
{
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "No issued tokens found in message");
}
return(null);
}
string str = CoordinationStrings.Version(protocolVersion).Identifier;
string str2 = CoordinationStrings.Version(protocolVersion).Namespace;
foreach (RequestSecurityTokenResponse response in is2)
{
string str3;
string str4;
response.GetAppliesToQName(out str3, out str4);
if ((str3 == str) && (str4 == str2))
{
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "Found issued token in message");
}
try
{
IdentifierElement appliesTo = null;
DataContractSerializer serializer = IdentifierElementSerializer(protocolVersion);
ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(CoordinationServiceSecurity), "GetIssuedToken");
switch (protocolVersion)
{
case ProtocolVersion.Version10:
appliesTo = response.GetAppliesTo <IdentifierElement10>(serializer);
break;
case ProtocolVersion.Version11:
appliesTo = response.GetAppliesTo <IdentifierElement11>(serializer);
break;
}
if (!(appliesTo.Identifier != identifier))
{
return(response);
}
if (DebugTrace.Error)
{
DebugTrace.Trace(TraceLevel.Error, "Issued token identifier does not match expected {0}", identifier);
}
throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(Microsoft.Transactions.SR.GetString("IssuedTokenIdentifierMismatch")));
}
catch (SerializationException exception)
{
if (DebugTrace.Error)
{
DebugTrace.Trace(TraceLevel.Error, "Issued token AppliesTo element could not be deserialized: {0}", exception.Message);
}
throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(exception.Message, exception));
}
return(response);
}
}
if (DebugTrace.Verbose)
{
DebugTrace.Trace(TraceLevel.Verbose, "No matching issued token found in message");
}
return(null);
}
