public SessionOperationAsyncResult(SecuritySessionSecurityTokenProvider requestor, SecuritySessionOperation operation, EndpointAddress target, Uri via, SecurityToken currentToken, TimeSpan timeout, AsyncCallback callback, object state)
: base(callback, state)
{
this.requestor = requestor;
this.operation = operation;
this.target = target;
this.via = via;
this.currentToken = currentToken;
this.timeoutHelper = new TimeoutHelper(timeout);
SecurityTraceRecordHelper.TraceBeginSecuritySessionOperation(operation, target, currentToken);
bool completeSelf = false;
try
{
completeSelf = this.StartOperation();
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
this.OnOperationFailure(e);
throw;
}
if (completeSelf)
{
this.OnOperationComplete();
Complete(true);
}
}
private IAsyncRequestChannel CreateChannel(SecuritySessionOperation operation, EndpointAddress target, Uri via)
{
IChannelFactory <IAsyncRequestChannel> cf;
if (operation == SecuritySessionOperation.Issue || operation == SecuritySessionOperation.Renew)
{
cf = _rstChannelFactory;
}
else
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException());
}
IAsyncRequestChannel channel;
if (via != null)
{
channel = cf.CreateChannel(target, via);
}
else
{
channel = cf.CreateChannel(target);
}
if (_channelParameters != null)
{
_channelParameters.PropagateChannelParameters(channel);
}
return(channel);
}
private void OnOperationFailure(SecuritySessionOperation operation, EndpointAddress target, SecurityToken currentToken, Exception e, IChannel channel)
{
if (channel != null)
{
channel.Abort();
}
}
public SessionOperationAsyncResult(SecuritySessionSecurityTokenProvider requestor, SecuritySessionOperation operation, EndpointAddress target, Uri via, SecurityToken currentToken, TimeSpan timeout, AsyncCallback callback, object state) : base(callback, state)
{
this.requestor = requestor;
this.operation = operation;
this.target = target;
this.via = via;
this.currentToken = currentToken;
this.timeoutHelper = new TimeoutHelper(timeout);
SecurityTraceRecordHelper.TraceBeginSecuritySessionOperation(operation, target, currentToken);
bool flag = false;
try
{
flag = this.StartOperation();
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
this.OnOperationFailure(exception);
throw;
}
if (flag)
{
this.OnOperationComplete();
base.Complete(true);
}
}
private IRequestChannel CreateChannel(SecuritySessionOperation operation, EndpointAddress target, Uri via)
{
IRequestChannel channel;
if ((operation != SecuritySessionOperation.Issue) && (operation != SecuritySessionOperation.Renew))
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException());
}
IChannelFactory <IRequestChannel> rstChannelFactory = this.rstChannelFactory;
if (via != null)
{
channel = rstChannelFactory.CreateChannel(target, via);
}
else
{
channel = rstChannelFactory.CreateChannel(target);
}
if (this.channelParameters != null)
{
this.channelParameters.PropagateChannelParameters(channel);
}
if (this.ownCredentialsHandle)
{
ChannelParameterCollection property = channel.GetProperty <ChannelParameterCollection>();
if (property != null)
{
property.Add(new SspiIssuanceChannelParameter(true, this.credentialsHandle));
}
}
return(channel);
}
void OnOperationFailure(SecuritySessionOperation operation, EndpointAddress target, SecurityToken currentToken, Exception e, IChannel channel)
{
SecurityTraceRecordHelper.TraceSecuritySessionOperationFailure(operation, target, currentToken, e);
if (channel != null)
{
channel.Abort();
}
}
private GenericXmlSecurityToken DoOperation(SecuritySessionOperation operation, EndpointAddress target, Uri via, SecurityToken currentToken, TimeSpan timeout)
{
GenericXmlSecurityToken token2;
if (target == null)
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("target");
}
if ((operation == SecuritySessionOperation.Renew) && (currentToken == null))
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("currentToken");
}
IRequestChannel channel = null;
try
{
object obj2;
GenericXmlSecurityToken token;
SecurityTraceRecordHelper.TraceBeginSecuritySessionOperation(operation, target, currentToken);
channel = this.CreateChannel(operation, target, via);
TimeoutHelper helper = new TimeoutHelper(timeout);
channel.Open(helper.RemainingTime());
using (Message message = this.CreateRequest(operation, target, currentToken, out obj2))
{
TraceUtility.ProcessOutgoingMessage(message);
using (Message message2 = channel.Request(message, helper.RemainingTime()))
{
if (message2 == null)
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(System.ServiceModel.SR.GetString("FailToRecieveReplyFromNegotiation")));
}
TraceUtility.ProcessIncomingMessage(message2);
ThrowIfFault(message2, this.targetAddress);
token = this.ProcessReply(message2, operation, obj2);
this.ValidateKeySize(token);
}
}
channel.Close(helper.RemainingTime());
this.OnOperationSuccess(operation, target, token, currentToken);
token2 = token;
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
if (exception is TimeoutException)
{
exception = new TimeoutException(System.ServiceModel.SR.GetString("ClientSecuritySessionRequestTimeout", new object[] { timeout }), exception);
}
this.OnOperationFailure(operation, target, currentToken, exception, channel);
throw;
}
return(token2);
}
private Message CreateRequest(SecuritySessionOperation operation, EndpointAddress target, SecurityToken currentToken, out object requestState)
{
if (operation == SecuritySessionOperation.Issue)
{
return(this.CreateIssueRequest(target, out requestState));
}
if (operation != SecuritySessionOperation.Renew)
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException());
}
return(this.CreateRenewRequest(target, currentToken, out requestState));
}
GenericXmlSecurityToken ProcessReply(Message reply, SecuritySessionOperation operation, object requestState)
{
ThrowIfFault(reply, this.targetAddress);
GenericXmlSecurityToken issuedToken = null;
if (operation == SecuritySessionOperation.Issue)
{
issuedToken = this.ProcessIssueResponse(reply, requestState);
}
else if (operation == SecuritySessionOperation.Renew)
{
issuedToken = this.ProcessRenewResponse(reply, requestState);
}
return(issuedToken);
}
IRequestChannel CreateChannel(SecuritySessionOperation operation, EndpointAddress target, Uri via)
{
IChannelFactory <IRequestChannel> cf;
if (operation == SecuritySessionOperation.Issue || operation == SecuritySessionOperation.Renew)
{
cf = this.rstChannelFactory;
}
else
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException());
}
IRequestChannel channel;
if (via != null)
{
channel = cf.CreateChannel(target, via);
}
else
{
channel = cf.CreateChannel(target);
}
if (this.channelParameters != null)
{
this.channelParameters.PropagateChannelParameters(channel);
}
if (this.ownCredentialsHandle)
{
ChannelParameterCollection newParameters = channel.GetProperty <ChannelParameterCollection>();
if (newParameters != null)
{
newParameters.Add(new SspiIssuanceChannelParameter(true, this.credentialsHandle));
}
}
return(channel);
}
GenericXmlSecurityToken DoOperation(SecuritySessionOperation operation, EndpointAddress target, Uri via, SecurityToken currentToken, TimeSpan timeout)
{
if (target == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("target");
}
if (operation == SecuritySessionOperation.Renew && currentToken == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("currentToken");
}
IRequestChannel channel = null;
try
{
SecurityTraceRecordHelper.TraceBeginSecuritySessionOperation(operation, target, currentToken);
channel = this.CreateChannel(operation, target, via);
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
channel.Open(timeoutHelper.RemainingTime());
object requestState;
GenericXmlSecurityToken issuedToken;
using (Message requestMessage = this.CreateRequest(operation, target, currentToken, out requestState))
{
EventTraceActivity eventTraceActivity = null;
if (TD.MessageReceivedFromTransportIsEnabled())
{
eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(requestMessage);
}
TraceUtility.ProcessOutgoingMessage(requestMessage, eventTraceActivity);
using (Message reply = channel.Request(requestMessage, timeoutHelper.RemainingTime()))
{
if (reply == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(SR.GetString(SR.FailToRecieveReplyFromNegotiation)));
}
if (eventTraceActivity == null && TD.MessageReceivedFromTransportIsEnabled())
{
eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(reply);
}
TraceUtility.ProcessIncomingMessage(reply, eventTraceActivity);
ThrowIfFault(reply, this.targetAddress);
issuedToken = ProcessReply(reply, operation, requestState);
ValidateKeySize(issuedToken);
}
}
channel.Close(timeoutHelper.RemainingTime());
this.OnOperationSuccess(operation, target, issuedToken, currentToken);
return(issuedToken);
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
if (e is TimeoutException)
{
e = new TimeoutException(SR.GetString(SR.ClientSecuritySessionRequestTimeout, timeout), e);
}
OnOperationFailure(operation, target, currentToken, e, channel);
throw;
}
}
void OnOperationSuccess(SecuritySessionOperation operation, EndpointAddress target, SecurityToken issuedToken, SecurityToken currentToken)
{
SecurityTraceRecordHelper.TraceSecuritySessionOperationSuccess(operation, target, currentToken, issuedToken);
}
private async Task <SecurityToken> DoOperationAsync(SecuritySessionOperation operation, EndpointAddress target, Uri via, SecurityToken currentToken, TimeSpan timeout)
{
if (target == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(target));
}
if (operation == SecuritySessionOperation.Renew && currentToken == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(currentToken));
}
IAsyncRequestChannel channel = null;
try
{
channel = CreateChannel(operation, target, via);
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
await channel.OpenAsync(timeoutHelper.RemainingTime());
object requestState;
GenericXmlSecurityToken issuedToken;
using (Message requestMessage = CreateRequest(operation, target, currentToken, out requestState))
{
EventTraceActivity eventTraceActivity = null;
TraceUtility.ProcessOutgoingMessage(requestMessage, eventTraceActivity);
using (Message reply = await channel.RequestAsync(requestMessage, timeoutHelper.RemainingTime()))
{
if (reply == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(SR.FailToRecieveReplyFromNegotiation));
}
TraceUtility.ProcessIncomingMessage(reply, eventTraceActivity);
ThrowIfFault(reply, _targetAddress);
issuedToken = ProcessReply(reply, operation, requestState);
ValidateKeySize(issuedToken);
}
}
await channel.CloseAsync(timeoutHelper.RemainingTime());
OnOperationSuccess(operation, target, issuedToken, currentToken);
return(issuedToken);
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
if (e is TimeoutException)
{
e = new TimeoutException(SR.Format(SR.ClientSecuritySessionRequestTimeout, timeout), e);
}
OnOperationFailure(operation, target, currentToken, e, channel);
throw;
}
}
private void OnOperationSuccess(SecuritySessionOperation operation, EndpointAddress target, SecurityToken issuedToken, SecurityToken currentToken)
{
}
