public void Rollback(Message message) { try { if (DebugTrace.Verbose) { DebugTrace.Trace(TraceLevel.Verbose, "Dispatching completion Rollback message"); if (DebugTrace.Pii) { DebugTrace.TracePii(TraceLevel.Verbose, "Sender is {0}", CoordinationServiceSecurity.GetSenderName(message)); } } RollbackMessage.ReadFrom(message, this.service.ProtocolVersion); this.dispatch.Rollback(message); } catch (CommunicationException exception) { Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Warning); base.OnMessageException(message, exception); } catch (Exception exception2) { DebugTrace.Trace(TraceLevel.Error, "Unhandled exception {0} dispatching completion Rollback message: {1}", exception2.GetType().Name, exception2); Microsoft.Transactions.Bridge.DiagnosticUtility.InvokeFinalHandler(exception2); } }
protected void OnReceive(Message message) { DebugTrace.TraceEnter(this, "OnReceive"); if ((message != null) && !this.tokenResolver.FaultInSupportingToken(message)) { if (DebugTrace.Verbose) { DebugTrace.Trace(TraceLevel.Verbose, "Failed to fault in SCT for supporting token signature"); } Fault invalidParameters = Faults.Version(this.protocolVersion).InvalidParameters; if (message.Headers.MessageId != null) { if (DebugTrace.Verbose) { DebugTrace.Trace(TraceLevel.Verbose, "Attempting to send {0} fault", invalidParameters.Code.Name); } Message reply = Library.CreateFaultMessage(message.Headers.MessageId, message.Version, invalidParameters); RequestReplyCorrelator.AddressReply(reply, new RequestReplyCorrelator.ReplyToInfo(message)); SendSecurityHeader header = SupportingTokenChannel <TChannel> .SecurityStandardsManager.CreateSendSecurityHeader(reply, string.Empty, true, false, SecurityAlgorithmSuite.Default, MessageDirection.Output); header.RequireMessageProtection = false; header.AddTimestamp(SecurityProtocolFactory.defaultTimestampValidityDuration); reply = header.SetupExecution(); this.TrySendFaultReply(reply); } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(Microsoft.Transactions.SR.GetString("SupportingTokenSignatureExpected"))); } DebugTrace.TraceLeave(this, "OnReceive"); }
public IAsyncResult BeginCreateCoordinationContext(Message message, AsyncCallback callback, object state) { if (DebugTrace.Verbose) { DebugTrace.Trace(TraceLevel.Verbose, "Dispatching CreateCoordinationContext request"); if (DebugTrace.Pii) { DebugTrace.TracePii(TraceLevel.Verbose, "Sender is {0}", CoordinationServiceSecurity.GetSenderName(message)); } } Microsoft.Transactions.Wsat.Messaging.RequestAsyncResult result = new Microsoft.Transactions.Wsat.Messaging.RequestAsyncResult(message, callback, state); try { this.dispatch.CreateCoordinationContext(message, result); } catch (InvalidMessageException exception) { Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Warning); base.OnMessageException(result, message, exception, Faults.Version(this.service.ProtocolVersion).InvalidParameters); } catch (CommunicationException exception2) { Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Warning); base.OnMessageException(result, message, exception2, Faults.Version(this.service.ProtocolVersion).CreateContextDispatchFailed); } catch (Exception exception3) { DebugTrace.Trace(TraceLevel.Error, "Unhandled exception {0} dispatching CreateCoordinationContext message: {1}", exception3.GetType().Name, exception3); Microsoft.Transactions.Bridge.DiagnosticUtility.InvokeFinalHandler(exception3); } return(result); }
private void CloseComplete(IAsyncResult result) { try { ((IChannel)result.AsyncState).EndClose(result); if (DebugTrace.Verbose) { DebugTrace.Trace(TraceLevel.Verbose, "Closed {0}", base.GetType().Name); } } catch (CommunicationException exception) { Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Warning); DebugTrace.Trace(TraceLevel.Warning, "Exception {0} closing a proxy: {1}", exception.GetType().Name, exception.Message); } catch (TimeoutException exception2) { Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Warning); DebugTrace.Trace(TraceLevel.Warning, "Exception {0} closing a proxy: {1}", exception2.GetType().Name, exception2.Message); } catch (Exception exception3) { DebugTrace.Trace(TraceLevel.Error, "Unhandled exception {0} closing a proxy: {1}", exception3.GetType().Name, exception3); Microsoft.Transactions.Bridge.DiagnosticUtility.InvokeFinalHandler(exception3); } }
private void TraceAccessCheckResult(bool result, MessageProperties messageProperties) { if (result) { if (DebugTrace.Info) { if (DebugTrace.Pii) { DebugTrace.TracePii(TraceLevel.Info, "Access granted to {0} by global ACL", CoordinationServiceSecurity.GetSenderName(messageProperties)); } else { DebugTrace.Trace(TraceLevel.Info, "Access granted by global ACL"); } } } else if (DebugTrace.Warning) { if (DebugTrace.Pii) { DebugTrace.TracePii(TraceLevel.Warning, "Access denied to {0} by global ACL", CoordinationServiceSecurity.GetSenderName(messageProperties)); } else { DebugTrace.Trace(TraceLevel.Warning, "Access denied by global ACL"); } } }
public RegisterResponse EndSendRegister(IAsyncResult ar) { RegisterResponse response; try { Message message = base.EndSendRequest(ar, base.coordinationStrings.RegisterResponseAction); using (message) { if (DebugTrace.Verbose) { DebugTrace.Trace(TraceLevel.Verbose, "Dispatching RegisterResponse reply"); if (DebugTrace.Pii) { DebugTrace.TracePii(TraceLevel.Verbose, "Sender is {0}", CoordinationServiceSecurity.GetSenderName(message)); } } response = new RegisterResponse(message, base.protocolVersion); } } catch (CommunicationException exception) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new WsatReceiveFailureException(exception)); } return(response); }
protected override void Close() { IChannel state = (IChannel)this.channel; if (DebugTrace.Verbose) { DebugTrace.Trace(TraceLevel.Verbose, "Closing {0}", state.GetType().Name); } try { IAsyncResult result = state.BeginClose(Fx.ThunkCallback(new AsyncCallback(this.OnCloseComplete)), state); if (result.CompletedSynchronously) { this.CloseComplete(result); } } catch (CommunicationException exception) { Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Warning); DebugTrace.Trace(TraceLevel.Warning, "Exception {0} closing a proxy: {1}", exception.GetType().Name, exception.Message); } catch (TimeoutException exception2) { Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Warning); DebugTrace.Trace(TraceLevel.Warning, "Exception {0} closing a proxy: {1}", exception2.GetType().Name, exception2.Message); } catch (Exception exception3) { DebugTrace.Trace(TraceLevel.Error, "Unhandled exception {0} closing a proxy: {1}", exception3.GetType().Name, exception3); Microsoft.Transactions.Bridge.DiagnosticUtility.InvokeFinalHandler(exception3); } }
public void Replay(Message message) { ProtocolVersionHelper.AssertProtocolVersion10(this.protocolVersion, typeof(TwoPhaseCommitCoordinatorDispatcher), "constr"); try { if (DebugTrace.Verbose) { DebugTrace.Trace(TraceLevel.Verbose, "Dispatching 2PC Replay message"); if (DebugTrace.Pii) { DebugTrace.TracePii(TraceLevel.Verbose, "Sender is {0}", CoordinationServiceSecurity.GetSenderName(message)); } } ReplayMessage.ReadFrom(message, this.protocolVersion); this.dispatch.Replay(message); } catch (CommunicationException exception) { Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Warning); base.OnMessageException(message, exception); } catch (Exception exception2) { DebugTrace.Trace(TraceLevel.Error, "Unhandled exception {0} dispatching Replay message: {1}", exception2.GetType().Name, exception2); Microsoft.Transactions.Bridge.DiagnosticUtility.InvokeFinalHandler(exception2); } }
private void Fault(Message message) { try { MessageFault fault = MessageFault.CreateFault(message, 0x10000); if (DebugTrace.Verbose) { FaultCode baseFaultCode = Library.GetBaseFaultCode(fault); DebugTrace.Trace(TraceLevel.Verbose, "Dispatching participant completion fault {0}", (baseFaultCode == null) ? "unknown" : baseFaultCode.Name); if (DebugTrace.Pii) { DebugTrace.TracePii(TraceLevel.Verbose, "Sender is {0}", CoordinationServiceSecurity.GetSenderName(message)); } } this.dispatch.Fault(message, fault); } catch (CommunicationException exception) { Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Warning); base.OnMessageException(message, exception); } catch (Exception exception2) { DebugTrace.Trace(TraceLevel.Error, "Unhandled exception {0} dispatching completion fault from participant: {1}", exception2.GetType().Name, exception2); Microsoft.Transactions.Bridge.DiagnosticUtility.InvokeFinalHandler(exception2); } }
public bool FaultInSupportingToken(Message message) { DebugTrace.TraceEnter(this, "FaultInSupportingToken"); bool flag = false; WsatRegistrationHeader header = this.ReadRegistrationHeader(message); if (((header == null) || (header.TransactionId == Guid.Empty)) || string.IsNullOrEmpty(header.TokenId)) { if (DebugTrace.Warning) { DebugTrace.Trace(TraceLevel.Warning, "Invalid or absent RegisterInfo in register message"); } } else { currentSct = this.DeriveToken(header.TransactionId, header.TokenId); flag = true; if (DebugTrace.Verbose) { DebugTrace.Trace(TraceLevel.Verbose, "Created SCT with id {0} for transaction {1}", header.TokenId, header.TransactionId); } } DebugTrace.TraceLeave(this, "FaultInSupportingToken"); return(flag); }
private void TraceCheckIdentityResult(bool access, EndpointAddress service, Message message) { if (DebugTrace.Verbose) { if (DebugTrace.Pii) { string senderName = GetSenderName(message); if (access) { DebugTrace.Trace(TraceLevel.Verbose, "Access granted by identity verifier to {0}", senderName); } else { DebugTrace.Trace(TraceLevel.Verbose, "Access denied by identity verifier to {0}, expected {1}", senderName, (service.Identity == null) ? service.Uri.AbsoluteUri : service.Identity.ToString()); } } else if (access) { DebugTrace.Trace(TraceLevel.Verbose, "Access granted by identity verifier"); } else { DebugTrace.Trace(TraceLevel.Verbose, "Access denied by identity verifier"); } } }
protected override void InitializeRuntime() { DebugTrace.TraceEnter(this, "OnCreateListeners"); base.InitializeRuntime(); if (base.SingletonInstance is IWSActivationCoordinator) { if (DebugTrace.Info) { for (int i = 0; i < base.ChannelDispatchers.Count; i++) { ChannelDispatcher dispatcher = base.ChannelDispatchers[i] as ChannelDispatcher; if (dispatcher != null) { for (int j = 0; j < dispatcher.Endpoints.Count; j++) { EndpointDispatcher dispatcher2 = dispatcher.Endpoints[j]; DebugTrace.Trace(TraceLevel.Info, "Listening on {0}", dispatcher2.EndpointAddress.Uri); } } } } } else { this.CreateBaseEndpointAddress(); } DebugTrace.TraceLeave(this, "OnCreateListeners"); }
private static void UnhandledExceptionHandler(object sender, UnhandledExceptionEventArgs args) { if (DebugTrace.Error) { Exception exceptionObject = (Exception)args.ExceptionObject; DebugTrace.Trace(TraceLevel.Error, "Unhandled {0} thrown: {1}", exceptionObject.GetType().Name, exceptionObject); } }
public static void AddIssuedToken(Message message, RequestSecurityTokenResponse rstr) { TransactionFlowProperty.Ensure(message).IssuedTokens.Add(rstr); if (DebugTrace.Verbose) { DebugTrace.Trace(TraceLevel.Verbose, "Added issued token to message"); } }
public IAsyncResult BeginSendCreateCoordinationContext(ref CreateCoordinationContext create, AsyncCallback callback, object state) { if (DebugTrace.Verbose) { DebugTrace.Trace(TraceLevel.Verbose, "Sending CreateCoordinationContext to {0}", base.to.Uri); } Message message = this.CreateCreateCoordinationContextMessage(ref create); return(base.BeginSendRequest(message, callback, state)); }
public IAsyncResult BeginSendRegister(ref Register register, AsyncCallback callback, object state) { if (DebugTrace.Verbose) { DebugTrace.Trace(TraceLevel.Verbose, "Sending Register to {0}", base.to.Uri); } Message message = this.CreateRegisterMessage(ref register); return(base.BeginSendRequest(message, callback, state)); }
private TChannel WrapChannel(TChannel innerChannel) { if (DebugTrace.Verbose) { DebugTrace.Trace(TraceLevel.Verbose, "Creating new SupportingTokenChannel<{0}>", typeof(TChannel).Name); } if (typeof(TChannel) == typeof(IDuplexChannel)) { return((TChannel) new SupportingTokenDuplexChannel(this, (IDuplexChannel)innerChannel, this.tokenResolver, this.protocolVersion)); } DiagnosticUtility.FailFast("SupportingTokenListener does not support " + typeof(TChannel).Name); return(default(TChannel)); }
public static void AddSupportingToken(Message message, RequestSecurityTokenResponse rstr) { GenericXmlSecurityToken token = rstr.GetIssuedToken(null, null, SecurityKeyEntropyMode.ServerEntropy, null, null, null); SecurityMessageProperty property = new SecurityMessageProperty(); SupportingTokenSpecification item = new SupportingTokenSpecification(token, new List <IAuthorizationPolicy>().AsReadOnly(), SecurityTokenAttachmentMode.Endorsing, SecurityContextSecurityTokenParameters); property.OutgoingSupportingTokens.Add(item); message.Properties.Security = property; if (DebugTrace.Verbose) { DebugTrace.Trace(TraceLevel.Verbose, "Attached supporting token {0} to register message", rstr.Context); } }
public Message SendRequest(Message message, string replyAction) { Message message2; try { message2 = base.GetChannel(message).SendRequest(message); } catch (TimeoutException exception) { Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Warning); base.OnChannelFailure(); throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new WsatSendFailureException(exception)); } catch (QuotaExceededException exception2) { Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Warning); base.OnChannelFailure(); throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new WsatSendFailureException(exception2)); } catch (FaultException exception3) { Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception3, TraceEventType.Warning); base.OnChannelFailure(); throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new WsatFaultException(exception3.CreateMessageFault(), exception3.Action)); } catch (CommunicationException exception4) { Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception4, TraceEventType.Warning); base.OnChannelFailure(); throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new WsatSendFailureException(exception4)); } catch (Exception exception5) { DebugTrace.Trace(TraceLevel.Error, "Unhandled exception {0} in RequestReplyProxy.SendRequest: {1}", exception5.GetType().Name, exception5); base.OnChannelFailure(); Microsoft.Transactions.Bridge.DiagnosticUtility.InvokeFinalHandler(exception5); return(null); } try { this.ValidateReply(message2, replyAction); } catch { message2.Close(); throw; } return(message2); }
protected void OnMessageException(Message message, CommunicationException exception) { DebugTrace.Trace(TraceLevel.Warning, "{0} - {1} reading datagram with action {2}: {3}", base.GetType().Name, exception.GetType().Name, message.Headers.Action, exception.Message); EndpointAddress faultToHeader = Library.GetFaultToHeader(message.Headers, this.protocolVersion); if (faultToHeader == null) { DebugTrace.Trace(TraceLevel.Warning, "Ignoring invalid datagram - a fault-to header could not be obtained"); } else { DatagramProxy proxy = null; try { proxy = this.CreateFaultProxy(faultToHeader); } catch (CreateChannelFailureException exception2) { Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Warning); DebugTrace.Trace(TraceLevel.Warning, "Ignoring invalid datagram: {0}", exception2.Message); } if (proxy != null) { try { IAsyncResult ar = proxy.BeginSendFault(message.Headers.MessageId, Faults.Version(this.protocolVersion).InvalidParameters, null, null); proxy.EndSendMessage(ar); if (DebugTrace.Warning) { DebugTrace.Trace(TraceLevel.Warning, "Sent InvalidParameters fault to {0}", proxy.To.Uri); } } catch (WsatSendFailureException exception3) { Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception3, TraceEventType.Warning); if (DebugTrace.Warning) { DebugTrace.Trace(TraceLevel.Warning, "{0} sending InvalidParameters fault to {1}: {2}", exception3.GetType().Name, proxy.To.Uri, exception3.Message); } } finally { proxy.Release(); } } } }
public override SecurityTokenAuthenticator CreateSecurityTokenAuthenticator(SecurityTokenRequirement tokenRequirement, out SecurityTokenResolver outOfBandTokenResolver) { if (tokenRequirement == null) { throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("tokenRequirement"); } if (!(tokenRequirement.TokenType == ServiceModelSecurityTokenTypes.SecurityContext)) { return(base.CreateSecurityTokenAuthenticator(tokenRequirement, out outOfBandTokenResolver)); } if (DebugTrace.Verbose) { DebugTrace.Trace(TraceLevel.Verbose, "CreateSecurityTokenAuthenticator for SecurityContext"); } outOfBandTokenResolver = this.serverCreds.tokenResolver; return(this.serverCreds.tokenAuthenticator); }
public SecurityContextSecurityToken GetContext(UniqueId contextId, UniqueId generation) { DebugTrace.TraceEnter(this, "GetContext"); SecurityContextSecurityToken currentSct = null; if (((SupportingTokenSecurityTokenResolver.currentSct != null) && (SupportingTokenSecurityTokenResolver.currentSct.ContextId == contextId)) && (SupportingTokenSecurityTokenResolver.currentSct.KeyGeneration == generation)) { if (DebugTrace.Verbose) { DebugTrace.Trace(TraceLevel.Verbose, "Found SCT with matching id {0}", contextId); } currentSct = SupportingTokenSecurityTokenResolver.currentSct; SupportingTokenSecurityTokenResolver.currentSct = null; } DebugTrace.TraceLeave(this, "GetContext"); return(currentSct); }
private void CreateBaseEndpointAddress() { if (DebugTrace.Info) { DebugTrace.Trace(TraceLevel.Info, "Creating base endpoint for {0}", base.SingletonInstance.GetType().Name); } if (((base.ChannelDispatchers.Count != 1) || (base.ChannelDispatchers[0] == null)) || ((base.ChannelDispatchers[0] as ChannelDispatcher).Endpoints.Count != 1)) { DiagnosticUtility.FailFast("Must have exactly one endpoint dispatcher"); } EndpointDispatcher dispatcher = (base.ChannelDispatchers[0] as ChannelDispatcher).Endpoints[0]; this.baseEndpoint = dispatcher.EndpointAddress; if (DebugTrace.Info) { DebugTrace.Trace(TraceLevel.Info, "Listening on {0}", this.baseEndpoint.Uri); } }
private WsatRegistrationHeader ReadRegistrationHeader(Message message) { WsatRegistrationHeader header = null; try { header = WsatRegistrationHeader.ReadFrom(message); } catch (InvalidEnlistmentHeaderException exception) { DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Error); if (DebugTrace.Error) { DebugTrace.Trace(TraceLevel.Error, "Invalid RegisterInfo header found in register message: {0}", exception.Message); } } return(header); }
private void BuildSidDictionary(List <string> windowsIdentities) { this.sids = new Dictionary <Claim, Claim>(windowsIdentities.Count, Claim.DefaultComparer); foreach (string str in windowsIdentities) { Exception exception = null; try { NTAccount account = new NTAccount(str); SecurityIdentifier sid = (SecurityIdentifier)account.Translate(typeof(SecurityIdentifier)); Claim key = Claim.CreateWindowsSidClaim(sid); if (!this.sids.ContainsKey(key)) { this.sids.Add(key, key); } } catch (ArgumentException exception2) { Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Warning); exception = exception2; } catch (IdentityNotMappedException exception3) { Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception3, TraceEventType.Warning); exception = exception3; } catch (SystemException exception4) { Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception4, TraceEventType.Warning); exception = exception4; } if ((exception != null) && DebugTrace.Warning) { if (DebugTrace.Pii) { DebugTrace.Trace(TraceLevel.Warning, "Could not add account {0} to SID table: {1}", str, exception.Message); } else { DebugTrace.Trace(TraceLevel.Warning, "Could not add account to SID table: {0}", exception.GetType().Name); } } } }
protected IAsyncResult BeginSendRequest(Message message, AsyncCallback callback, object state) { IAsyncResult result; base.AddRef(); try { result = base.GetChannel(message).BeginRequest(message, callback, state); } catch (TimeoutException exception) { Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Warning); base.OnChannelFailure(); result = new SendMessageFailureAsyncResult(exception, callback, state); } catch (QuotaExceededException exception2) { Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Warning); base.OnChannelFailure(); result = new SendMessageFailureAsyncResult(exception2, callback, state); } catch (FaultException exception3) { Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception3, TraceEventType.Warning); base.OnChannelFailure(); result = new SendMessageFailureAsyncResult(exception3, callback, state); } catch (CommunicationException exception4) { Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception4, TraceEventType.Warning); base.OnChannelFailure(); result = new SendMessageFailureAsyncResult(exception4, callback, state); } catch (Exception exception5) { DebugTrace.Trace(TraceLevel.Error, "Unhandled exception {0} in RequestReplyProxy.BeginSendRequest: {1}", exception5.GetType().Name, exception5); base.OnChannelFailure(); throw Microsoft.Transactions.Bridge.DiagnosticUtility.InvokeFinalHandler(exception5); } return(result); }
private bool AccessCheck(AuthorizationContext authzContext, MessageProperties messageProperties, string claimType, Dictionary <Claim, Claim> dictionary) { if (authzContext != null) { foreach (ClaimSet set in authzContext.ClaimSets) { foreach (Claim claim in set.FindClaims(claimType, Rights.PossessProperty)) { if (dictionary.ContainsKey(claim)) { return(true); } } } } else if (DebugTrace.Info) { DebugTrace.Trace(TraceLevel.Info, "No authzContext was passed into AccessCheck"); } return(false); }
public IAsyncResult BeginSendMessage(Message message, AsyncCallback callback, object state) { IAsyncResult result; if (base.from != null) { MessagingVersionHelper.SetReplyAddress(message, base.from, base.protocolVersion); } if (base.protocolVersion == ProtocolVersion.Version11) { message.Headers.ReplyTo = noneAddress; } base.AddRef(); try { result = base.GetChannel(message).BeginSend(message, callback, state); } catch (TimeoutException exception) { Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Warning); result = new SendMessageFailureAsyncResult(exception, callback, state); } catch (QuotaExceededException exception2) { Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Warning); result = new SendMessageFailureAsyncResult(exception2, callback, state); } catch (CommunicationException exception3) { Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception3, TraceEventType.Warning); result = new SendMessageFailureAsyncResult(exception3, callback, state); } catch (Exception exception4) { DebugTrace.Trace(TraceLevel.Error, "Unhandled exception {0} in DatagramProxy.BeginSendMessage: {1}", exception4.GetType().Name, exception4); throw Microsoft.Transactions.Bridge.DiagnosticUtility.InvokeFinalHandler(exception4); } return(result); }
public RegisterResponse SendRegister(ref Register register) { if (DebugTrace.Verbose) { DebugTrace.Trace(TraceLevel.Verbose, "Sending Register to {0}", base.to.Uri); } Message message = this.CreateRegisterMessage(ref register); Message message2 = base.SendRequest(message, base.coordinationStrings.RegisterResponseAction); using (message2) { if (DebugTrace.Verbose) { DebugTrace.Trace(TraceLevel.Verbose, "Dispatching RegisterResponse reply"); if (DebugTrace.Pii) { DebugTrace.TracePii(TraceLevel.Verbose, "Sender is {0}", CoordinationServiceSecurity.GetSenderName(message2)); } } return(new RegisterResponse(message2, base.protocolVersion)); } }
public void EndSendMessage(IAsyncResult ar) { try { SendMessageFailureAsyncResult result = ar as SendMessageFailureAsyncResult; if (result != null) { result.End(); } else { base.GetChannel(null).EndSend(ar); } } catch (TimeoutException exception) { Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Warning); throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new WsatSendFailureException(exception)); } catch (QuotaExceededException exception2) { Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Warning); throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new WsatSendFailureException(exception2)); } catch (CommunicationException exception3) { Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception3, TraceEventType.Warning); throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new WsatSendFailureException(exception3)); } catch (Exception exception4) { DebugTrace.Trace(TraceLevel.Error, "Unhandled exception {0} in DatagramProxy.EndSendMessage: {1}", exception4.GetType().Name, exception4); Microsoft.Transactions.Bridge.DiagnosticUtility.InvokeFinalHandler(exception4); } finally { base.Release(); } }