public override void Reply(Message message, TimeSpan timeout) { TimeoutHelper helper = new TimeoutHelper(timeout); Message message2 = message; if (message != null) { CorrelationCallbackMessageProperty property; this.contextProtocol.OnOutgoingMessage(message, this); if (CorrelationCallbackMessageProperty.TryGet(message, out property)) { ContextExchangeCorrelationHelper.AddOutgoingCorrelationCallbackData(property, message, false); if (property.IsFullyDefined) { message2 = property.FinalizeCorrelation(message, helper.RemainingTime()); message2.Properties.Remove(CorrelationCallbackMessageProperty.Name); } } } try { this.innerContext.Reply(message2, helper.RemainingTime()); } finally { if ((message != null) && !object.ReferenceEquals(message, message2)) { message2.Close(); } } }
public override IAsyncResult BeginWrite(byte[] buffer, int offset, int size, bool immediate, TimeSpan timeout, AsyncCallback callback, object state) { ThreadTrace.Trace("BC:BeginWrite"); TimeoutHelper helper = new TimeoutHelper(timeout); this.Flush(helper.RemainingTime()); return base.BeginWrite(buffer, offset, size, immediate, helper.RemainingTime(), callback, state); }
internal async Task<Message> ParseIncomingResponse(TimeoutHelper timeoutHelper) { ValidateAuthentication(); ValidateResponseStatusCode(); bool hasContent = await ValidateContentTypeAsync(); Message message = null; if (!hasContent) { if (_encoder.MessageVersion == MessageVersion.None) { message = new NullMessage(); } else { return null; } } else { message = await ReadStreamAsMessageAsync(timeoutHelper); } var exception = ProcessHttpAddressing(message); Contract.Assert(exception == null, "ProcessHttpAddressing should not set an exception after parsing a response message."); return message; }
public override void OnOpen(TimeSpan timeout) { TimeoutHelper timeoutHelper = new TimeoutHelper(timeout); base.OnOpen(timeoutHelper.RemainingTime()); if (this.Factory.ActAsInitiator) { // 1. Create a token requirement for the provider InitiatorServiceModelSecurityTokenRequirement tokenProviderRequirement = CreateInitiatorTokenRequirement(); // 2. Create a provider SecurityTokenProvider tokenProvider = this.Factory.SecurityTokenManager.CreateSecurityTokenProvider(tokenProviderRequirement); SecurityUtils.OpenTokenProviderIfRequired(tokenProvider, timeoutHelper.RemainingTime()); if (this.Factory.SecurityTokenParameters.HasAsymmetricKey) { this.initiatorAsymmetricTokenProvider = tokenProvider; } else { this.initiatorSymmetricTokenProvider = tokenProvider; } // 3. Create a token requirement for authenticator InitiatorServiceModelSecurityTokenRequirement tokenAuthenticatorRequirement = CreateInitiatorTokenRequirement(); // 4. Create authenticator (we dont support out of band resolvers on the client side SecurityTokenResolver outOfBandTokenResolver; this.initiatorTokenAuthenticator = this.Factory.SecurityTokenManager.CreateSecurityTokenAuthenticator(tokenAuthenticatorRequirement, out outOfBandTokenResolver); SecurityUtils.OpenTokenAuthenticatorIfRequired(this.initiatorTokenAuthenticator, timeoutHelper.RemainingTime()); } }
public LoadRetryAsyncResult(SqlWorkflowInstanceStore store, System.Runtime.DurableInstancing.InstancePersistenceContext context, System.Runtime.DurableInstancing.InstancePersistenceCommand command, TimeSpan timeout, AsyncCallback callback, object state) : base(callback, state) { this.InstanceStore = store; this.InstancePersistenceContext = context; this.InstancePersistenceCommand = command; this.commandTimeout = new TimeoutHelper(timeout); this.InstanceStore.BeginTryCommandInternal(this.InstancePersistenceContext, this.InstancePersistenceCommand, this.commandTimeout.RemainingTime(), onTryCommandCallback, this); }
protected override SecurityProtocol OnCreateSecurityProtocol(EndpointAddress target, Uri via, object listenerSecurityState, TimeSpan timeout) { SecurityProtocolFactory protocolFactoryForOutgoingMessages = this.ProtocolFactoryForOutgoingMessages; SecurityProtocolFactory protocolFactoryForIncomingMessages = this.ProtocolFactoryForIncomingMessages; TimeoutHelper helper = new TimeoutHelper(timeout); SecurityProtocol outgoingProtocol = (protocolFactoryForOutgoingMessages == null) ? null : protocolFactoryForOutgoingMessages.CreateSecurityProtocol(target, via, listenerSecurityState, false, helper.RemainingTime()); return new DuplexSecurityProtocol(outgoingProtocol, (protocolFactoryForIncomingMessages == null) ? null : protocolFactoryForIncomingMessages.CreateSecurityProtocol(null, null, listenerSecurityState, false, helper.RemainingTime())); }
public TimeoutStream(Stream stream, ref TimeoutHelper timeoutHelper) : base(stream) { if (!stream.CanTimeout) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("stream", System.ServiceModel.SR.GetString("StreamDoesNotSupportTimeout")); } this.timeoutHelper = timeoutHelper; }
protected override void OnClose(TimeSpan timeout) { TimeoutHelper timeoutHelper = new TimeoutHelper(timeout); base.OnClose(timeoutHelper.RemainingTime()); if (this.transportManagerContainer != null && !TransferTransportManagers()) { this.transportManagerContainer.Close(timeoutHelper.RemainingTime()); } }
internal SendReceiveAsyncResult(SendReceiveReliableRequestor requestor, Message request, TimeSpan timeout, AsyncCallback callback, object state) : base(callback, state) { this.requestor = requestor; this.request = request; this.timeoutHelper = new TimeoutHelper(timeout); if (this.BeginSend()) { base.Complete(true); } }
protected override void OnClose(TimeSpan timeout) { TimeoutHelper helper = new TimeoutHelper(timeout); base.Connection.Write(SingletonEncoder.EndBytes, 0, SingletonEncoder.EndBytes.Length, true, helper.RemainingTime()); this.connectionDemuxer.ReuseConnection(this.rawConnection, helper.RemainingTime()); if (this.channelBindingToken != null) { this.channelBindingToken.Dispose(); } }
public SqlCommandAsyncResult(SqlCommand sqlCommand, string connectionString, DependentTransaction dependentTransaction, TimeSpan timeout, int retryCount, int maximumRetries, AsyncCallback callback, object state) : base(callback, state) { long num = Math.Min(timeout.Ticks, MaximumOpenTimeout.Ticks); this.sqlCommand = sqlCommand; this.connectionString = connectionString; this.dependentTransaction = dependentTransaction; this.timeoutHelper = new TimeoutHelper(TimeSpan.FromTicks(num)); this.retryCount = retryCount; this.maximumRetries = maximumRetries; }
public virtual void Abandon(Exception exception, TimeSpan timeout) { EnsureValidTimeout(timeout); TimeoutHelper timeoutHelper = new TimeoutHelper(timeout); this.WaitForStateLock(timeoutHelper.RemainingTime()); try { if (PreAbandon()) { return; } } finally { // Abandon can never be reverted, release the state lock. this.ReleaseStateLock(); } bool success = false; try { if (exception == null) { OnAbandon(timeoutHelper.RemainingTime()); } else { if (TD.ReceiveContextAbandonWithExceptionIsEnabled()) { TD.ReceiveContextAbandonWithException(this.eventTraceActivity, this.GetType().ToString(), exception.GetType().ToString()); } OnAbandon(exception, timeoutHelper.RemainingTime()); } lock (ThisLock) { ThrowIfFaulted(); ThrowIfNotAbandoning(); this.State = ReceiveContextState.Abandoned; } success = true; } finally { if (!success) { if (TD.ReceiveContextAbandonFailedIsEnabled()) { TD.ReceiveContextAbandonFailed(this.eventTraceActivity, this.GetType().ToString()); } Fault(); } } }
protected virtual IAsyncResult BeginSecureOutgoingMessageAtInitiatorCore(Message message, string actor, TimeSpan timeout, AsyncCallback callback, object state) { IList<SupportingTokenSpecification> list; TimeoutHelper helper = new TimeoutHelper(timeout); if (base.TryGetSupportingTokens(base.SecurityProtocolFactory, base.Target, base.Via, message, helper.RemainingTime(), false, out list)) { this.SetUpDelayedSecurityExecution(ref message, actor, list); return new CompletedAsyncResult<Message>(message, callback, state); } return new SecureOutgoingMessageAsyncResult(actor, message, this, timeout, callback, state); }
public override void OnClose(TimeSpan timeout) { TimeoutHelper helper = new TimeoutHelper(timeout); if (this.forwardProtocolFactory != null) { this.forwardProtocolFactory.Close(false, helper.RemainingTime()); } if (this.reverseProtocolFactory != null) { this.reverseProtocolFactory.Close(false, helper.RemainingTime()); } }
public CloseCommunicationAsyncResult(TimeSpan timeout, AsyncCallback callback, object state, object mutex) : base(callback, state) { this.timeout = timeout; this.timeoutHelper = new TimeoutHelper(timeout); this.mutex = mutex; if (timeout < TimeSpan.Zero) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TimeoutException(System.ServiceModel.SR.GetString("SFxCloseTimedOut1", new object[] { timeout }))); } this.timer = new IOThreadTimer(new Action<object>(CloseCommunicationAsyncResult.TimeoutCallback), this, true); this.timer.Set(timeout); }
protected override Message OnRequest(Message request, TimeSpan timeout, bool last) { RequestContext context; TimeoutHelper helper = new TimeoutHelper(timeout); base.Binder.Send(request, helper.RemainingTime(), MaskingMode.None); TimeSpan receiveTimeout = this.GetReceiveTimeout(helper.RemainingTime()); base.Binder.TryReceive(receiveTimeout, out context, MaskingMode.None); if (context == null) { return null; } return context.RequestMessage; }
private void CloseInitiate(TimeSpan timeout) { TimeoutHelper helper = new TimeoutHelper(timeout); foreach (InstanceContext context in this.ToArray()) { try { if (context.State == CommunicationState.Opened) { IAsyncResult result = context.BeginClose(helper.RemainingTime(), Fx.ThunkCallback(new AsyncCallback(InstanceContextManager.CloseInstanceContextCallback)), context); if (result.CompletedSynchronously) { context.EndClose(result); } } else { context.Abort(); } } catch (ObjectDisposedException exception) { if (DiagnosticUtility.ShouldTraceInformation) { DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Information); } } catch (InvalidOperationException exception2) { if (DiagnosticUtility.ShouldTraceInformation) { DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Information); } } catch (CommunicationException exception3) { if (DiagnosticUtility.ShouldTraceInformation) { DiagnosticUtility.ExceptionUtility.TraceHandledException(exception3, TraceEventType.Information); } } catch (TimeoutException exception4) { if (DiagnosticUtility.ShouldTraceInformation) { DiagnosticUtility.ExceptionUtility.TraceHandledException(exception4, TraceEventType.Information); } } } }
protected override void VerifyIncomingMessageCore(ref Message message, TimeSpan timeout) { string actor = string.Empty; ReceiveSecurityHeader securityHeader = this.Factory.StandardsManager.CreateReceiveSecurityHeader(message, actor, this.Factory.IncomingAlgorithmSuite, MessageDirection.Input); securityHeader.RequireMessageProtection = false; securityHeader.ReaderQuotas = this.Factory.SecurityBindingElement.ReaderQuotas; IList<SupportingTokenAuthenticatorSpecification> supportingAuthenticators = base.GetSupportingTokenAuthenticatorsAndSetExpectationFlags(this.Factory, message, securityHeader); ReadOnlyCollection<SecurityTokenResolver> outOfBandResolvers = base.MergeOutOfBandResolvers(supportingAuthenticators, this.sessionTokenResolverList); if ((supportingAuthenticators != null) && (supportingAuthenticators.Count > 0)) { supportingAuthenticators = new List<SupportingTokenAuthenticatorSpecification>(supportingAuthenticators); supportingAuthenticators.Insert(0, this.sessionTokenAuthenticatorSpecificationList[0]); } else { supportingAuthenticators = this.sessionTokenAuthenticatorSpecificationList; } securityHeader.ConfigureTransportBindingServerReceiveHeader(supportingAuthenticators); securityHeader.ConfigureOutOfBandTokenResolver(outOfBandResolvers); securityHeader.ExpectEndorsingTokens = true; TimeoutHelper helper = new TimeoutHelper(timeout); securityHeader.SetTimeParameters(this.Factory.NonceCache, this.Factory.ReplayWindow, this.Factory.MaxClockSkew); securityHeader.EnforceDerivedKeyRequirement = message.Headers.Action != this.Factory.StandardsManager.SecureConversationDriver.CloseAction.Value; securityHeader.Process(helper.RemainingTime(), System.ServiceModel.Security.SecurityUtils.GetChannelBindingFromMessage(message), this.Factory.ExtendedProtectionPolicy); if (securityHeader.Timestamp == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new MessageSecurityException(System.ServiceModel.SR.GetString("RequiredTimestampMissingInSecurityHeader"))); } bool flag = false; if (securityHeader.EndorsingSupportingTokens != null) { for (int i = 0; i < securityHeader.EndorsingSupportingTokens.Count; i++) { SecurityContextSecurityToken token = securityHeader.EndorsingSupportingTokens[i] as SecurityContextSecurityToken; if ((token != null) && (token.ContextId == this.sessionId)) { flag = true; break; } } } if (!flag) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new MessageSecurityException(System.ServiceModel.SR.GetString("NoSessionTokenPresentInMessage"))); } message = securityHeader.ProcessedMessage; base.AttachRecipientSecurityProperty(message, securityHeader.BasicSupportingTokens, securityHeader.EndorsingSupportingTokens, securityHeader.SignedEndorsingSupportingTokens, securityHeader.SignedSupportingTokens, securityHeader.SecurityTokenAuthorizationPoliciesMapping); base.OnIncomingMessageVerified(message); }
protected override IAsyncResult BeginSecureOutgoingMessageAtInitiatorCore(Message message, string actor, TimeSpan timeout, AsyncCallback callback, object state) { SecurityToken token; SecurityToken token2; SecurityTokenParameters parameters; IList<SupportingTokenSpecification> list; this.GetTokensForOutgoingMessages(out token, out token2, out parameters); TimeoutHelper helper = new TimeoutHelper(timeout); if (!base.TryGetSupportingTokens(base.SecurityProtocolFactory, base.Target, base.Via, message, helper.RemainingTime(), false, out list)) { return new SecureOutgoingMessageAsyncResult(actor, message, this, token, token2, parameters, helper.RemainingTime(), callback, state); } this.SetupDelayedSecurityExecution(actor, ref message, token, token2, parameters, list); return new CompletedAsyncResult<Message>(message, callback, state); }
public override async Task<WebSocket> CreateWebSocketAsync(Uri address, WebHeaderCollection headers, ICredentials credentials, WebSocketTransportSettings settings, TimeoutHelper timeoutHelper) { ClientWebSocket webSocket = new ClientWebSocket(); webSocket.Options.Credentials = credentials; webSocket.Options.AddSubProtocol(settings.SubProtocol); webSocket.Options.KeepAliveInterval = settings.KeepAliveInterval; foreach (var headerObj in headers) { var header = headerObj as string; webSocket.Options.SetRequestHeader(header, headers[header]); } await webSocket.ConnectAsync(address, timeoutHelper.CancellationToken); return webSocket; }
internal ProxyRpc(ServiceChannel channel, ProxyOperationRuntime operation, string action, object[] inputs, TimeSpan timeout) { this.Action = action; this.Activity = null; this.Channel = channel; this.Correlation = EmptyArray.Allocate(operation.Parent.CorrelationCount); this.InputParameters = inputs; this.Operation = operation; this.OutputParameters = null; this.Request = null; this.Reply = null; this.ActivityId = Guid.Empty; this.ReturnValue = null; this.MessageVersion = channel.MessageVersion; this.TimeoutHelper = new System.Runtime.TimeoutHelper(timeout); }
internal ComposedAsyncResult(TimeSpan timeout, OperationWithTimeoutBeginCallback[] beginOperations, OperationEndCallback[] endOperations, AsyncCallback callback, object state) : base(callback, state) { this.completedSynchronously = true; this.timeoutHelper = new TimeoutHelper(timeout); this.beginOperations = beginOperations; this.endOperations = endOperations; this.SkipToNextOperation(); if (this.currentOperation < this.beginOperations.Length) { this.beginOperations[this.currentOperation](this.RemainingTime(), onOperationCompleted, this); } else { base.Complete(this.completedSynchronously); } }
public override void OnOpen(TimeSpan timeout) { if (this.serverTokenProvider == null) { throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("NoServerX509TokenProvider"))); } TimeoutHelper helper = new TimeoutHelper(timeout); System.ServiceModel.Security.SecurityUtils.OpenTokenProviderIfRequired(this.serverTokenProvider, helper.RemainingTime()); if (this.clientTokenAuthenticator != null) { System.ServiceModel.Security.SecurityUtils.OpenTokenAuthenticatorIfRequired(this.clientTokenAuthenticator, helper.RemainingTime()); } SecurityToken token = this.serverTokenProvider.GetToken(helper.RemainingTime()); this.serverToken = this.ValidateX509Token(token); base.OnOpen(helper.RemainingTime()); }
// tx aborts can ---- with DeleteMessage but this ---- is harmless because // - internal state changes are protected via the internalStateLock // - we do not have an ordering requirement between DeleteMessage and a tx abort // // tx commits cannot ---- with DeleteMessage as the ReceiveContext state machine does not allow // DeleteMessage calls if the tx holding this lock committed public void DeleteMessage(MsmqReceiveContext receiveContext, TimeSpan timeout) { TimeoutHelper helper = new TimeoutHelper(timeout); long lookupId = receiveContext.LookupId; lock (this.internalStateLock) { // Expiry map is first checked before calling ReceiveContextExists as we need to throw // validity expired exception if the lookup id is not in the map. if (this.messageExpiryMap.ContainsKey(lookupId)) { Fx.Assert(ReceiveContextExists(receiveContext), "Mismatch between the receive context object stored in the map and the object passed to the method"); MsmqReceiveContext entry = this.messageExpiryMap[lookupId]; if (DateTime.UtcNow > entry.ExpiryTime) { entry.MarkContextExpired(); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(SR.MessageValidityExpired, lookupId))); } else { ((ILockingQueue)this.queue).DeleteMessage(lookupId, helper.RemainingTime()); if (Transaction.Current != null) { List<MsmqReceiveContext> transMsgs; if (!this.transMessages.TryGetValue(Transaction.Current.TransactionInformation.DistributedIdentifier, out transMsgs)) { transMsgs = new List<MsmqReceiveContext>(); this.transMessages.Add(Transaction.Current.TransactionInformation.DistributedIdentifier, transMsgs); // only need to attach the tx complete handler once per transaction Transaction.Current.TransactionCompleted += this.transactionCompletedHandler; } transMsgs.Add(entry); } else { this.messageExpiryMap.Remove(lookupId); } } } else { // it was cleaned up by the expiry timer throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MsmqException(SR.GetString(SR.MessageValidityExpired, lookupId))); } } }
protected override IAsyncResult BeginSecureOutgoingMessageCore(Message message, TimeSpan timeout, SecurityProtocolCorrelationState correlationState, AsyncCallback callback, object state) { SecurityToken token; SecurityToken token2; SecurityToken token3; SecurityTokenParameters parameters; IList<SupportingTokenSpecification> list; this.GetTokensForOutgoingMessages(out token, out token2, out token3, out parameters); TimeoutHelper helper = new TimeoutHelper(timeout); if (base.TryGetSupportingTokens(this.Factory, base.Target, base.Via, message, helper.RemainingTime(), false, out list)) { SecurityProtocolCorrelationState state2 = this.CreateCorrelationStateIfRequired(); this.SetUpDelayedSecurityExecution(ref message, token, token2, token3, parameters, list, state2); return new CompletedAsyncResult<Message, SecurityProtocolCorrelationState>(message, state2, callback, state); } return new SecureOutgoingMessageAsyncResult(message, this, token, token2, token3, parameters, helper.RemainingTime(), callback, state); }
public override void OnOpen(TimeSpan timeout) { if ((this.ForwardProtocolFactory != null) && object.ReferenceEquals(this.ForwardProtocolFactory, this.ReverseProtocolFactory)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("ReverseProtocolFactory", System.ServiceModel.SR.GetString("SameProtocolFactoryCannotBeSetForBothDuplexDirections")); } if (this.forwardProtocolFactory != null) { this.forwardProtocolFactory.ListenUri = base.ListenUri; } if (this.reverseProtocolFactory != null) { this.reverseProtocolFactory.ListenUri = base.ListenUri; } TimeoutHelper helper = new TimeoutHelper(timeout); this.Open(this.ForwardProtocolFactory, base.ActAsInitiator, "ForwardProtocolFactory", helper.RemainingTime()); this.Open(this.ReverseProtocolFactory, !base.ActAsInitiator, "ReverseProtocolFactory", helper.RemainingTime()); }
internal IConnection SendPreamble(IConnection connection, ref TimeoutHelper timeoutHelper, ClientFramingDecoder decoder, out SecurityMessageProperty remoteSecurity) { connection.Write(Preamble, 0, Preamble.Length, true, timeoutHelper.RemainingTime()); if (_upgrade != null) { IStreamUpgradeChannelBindingProvider channelBindingProvider = _upgrade.GetProperty<IStreamUpgradeChannelBindingProvider>(); StreamUpgradeInitiator upgradeInitiator = _upgrade.CreateUpgradeInitiator(this.RemoteAddress, this.Via); if (!ConnectionUpgradeHelper.InitiateUpgrade(upgradeInitiator, ref connection, decoder, this, ref timeoutHelper)) { ConnectionUpgradeHelper.DecodeFramingFault(decoder, connection, Via, _messageEncoder.ContentType, ref timeoutHelper); } #if FEATURE_CORECLR // ExtendedProtection if (channelBindingProvider != null && channelBindingProvider.IsChannelBindingSupportEnabled) { _channelBindingToken = channelBindingProvider.GetChannelBinding(upgradeInitiator, ChannelBindingKind.Endpoint); } #endif // FEATURE_CORECLR // ExtendedProtection remoteSecurity = StreamSecurityUpgradeInitiator.GetRemoteSecurity(upgradeInitiator); connection.Write(ClientSingletonEncoder.PreambleEndBytes, 0, ClientSingletonEncoder.PreambleEndBytes.Length, true, timeoutHelper.RemainingTime()); } else { remoteSecurity = null; } // read ACK byte[] ackBuffer = new byte[1]; int ackBytesRead = connection.Read(ackBuffer, 0, ackBuffer.Length, timeoutHelper.RemainingTime()); if (!ConnectionUpgradeHelper.ValidatePreambleResponse(ackBuffer, ackBytesRead, decoder, this.Via)) { ConnectionUpgradeHelper.DecodeFramingFault(decoder, connection, Via, _messageEncoder.ContentType, ref timeoutHelper); } return connection; }
public void FlushPendingRecords(TimeSpan timeout) { try { if (this.HasPendingRecords) { TimeoutHelper helper = new TimeoutHelper(timeout); for (int i = 0; i < this.trackingParticipants.Count; i++) { TrackingParticipant participant = this.trackingParticipants[i]; RuntimeTrackingProfile runtimeTrackingProfile = this.GetRuntimeTrackingProfile(participant); if (this.pendingTrackingRecords != null) { for (int j = 0; j < this.pendingTrackingRecords.Count; j++) { TrackingRecord record = this.pendingTrackingRecords[j]; TrackingRecord record2 = null; bool shouldClone = this.trackingParticipants.Count > 1; if (runtimeTrackingProfile == null) { record2 = shouldClone ? record.Clone() : record; } else { record2 = runtimeTrackingProfile.Match(record, shouldClone); } if (record2 != null) { participant.Track(record2, helper.RemainingTime()); if (TD.TrackingRecordRaisedIsEnabled()) { TD.TrackingRecordRaised(record2.ToString(), participant.GetType().ToString()); } } } } } } } finally { this.ClearPendingRecords(); } }
public override void OnClose(TimeSpan timeout) { TimeoutHelper helper = new TimeoutHelper(timeout); if (this.serverTokenProvider != null) { System.ServiceModel.Security.SecurityUtils.CloseTokenProviderIfRequired(this.serverTokenProvider, helper.RemainingTime()); this.serverTokenProvider = null; } if (this.clientTokenAuthenticator != null) { System.ServiceModel.Security.SecurityUtils.CloseTokenAuthenticatorIfRequired(this.clientTokenAuthenticator, helper.RemainingTime()); this.clientTokenAuthenticator = null; } if (this.serverToken != null) { this.serverToken = null; } base.OnClose(helper.RemainingTime()); }
protected override IAsyncResult BeginSecureOutgoingMessageCore(Message message, TimeSpan timeout, SecurityProtocolCorrelationState correlationState, AsyncCallback callback, object state) { SecurityToken token; SecurityTokenParameters parameters; IList<SupportingTokenSpecification> list; SecurityToken token2; SecurityProtocolCorrelationState state2; TimeoutHelper helper = new TimeoutHelper(timeout); if (this.TryGetTokenSynchronouslyForOutgoingSecurity(message, correlationState, false, helper.RemainingTime(), out token, out parameters, out token2, out list, out state2)) { this.SetUpDelayedSecurityExecution(ref message, token2, token, parameters, list, base.GetSignatureConfirmationCorrelationState(correlationState, state2)); return new CompletedAsyncResult<Message, SecurityProtocolCorrelationState>(message, state2, callback, state); } if (!this.Factory.ActAsInitiator) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("ProtocolMustBeInitiator", new object[] { base.GetType().ToString() }))); } return new SecureOutgoingMessageAsyncResult(message, this, this.GetTokenProvider(), this.Factory.ApplyConfidentiality, this.initiatorTokenAuthenticator, correlationState, helper.RemainingTime(), callback, state); }
public IOThreadCancellationTokenSource(TimeSpan timeout) { TimeoutHelper.ThrowIfNegativeArgument(timeout); this.timeout = timeout; }
internal ReceiveTimeoutAsyncResult(TimeSpan timeout, AsyncCallback callback, object state) : base(callback, state) { this.timeoutHelper = new System.Runtime.TimeoutHelper(timeout); }