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); }