public async Task<bool> ConnectAsGuestAsync(string domain, CancellationToken cancellationToken)
{
var tcpClient = new TcpClient();
#if DEBUG
ITraceWriter traceWriter = new DebugTraceWriter("Client");
#else
ITraceWriter traceWriter = new FileTraceWriter("client.log");
#endif
var transport = new TcpTransport(
new TcpClientAdapter(tcpClient),
new EnvelopeSerializer(),
hostName: _clientUri.Host,
traceWriter: traceWriter
);
Channel = new ClientChannel(transport, TimeSpan.FromSeconds(60), autoReplyPings: true, autoNotifyReceipt: true);
await Channel.Transport.OpenAsync(_clientUri, cancellationToken);
var identity = new Identity()
{
Name = Guid.NewGuid().ToString(),
Domain = domain
};
var resultSession = await Channel.EstablishSessionAsync(
c => c.First(),
e => SessionEncryption.TLS,
identity,
(s, r) => new GuestAuthentication(),
Environment.MachineName,
cancellationToken);
if (resultSession.State != SessionState.Established)
{
return false;
}
return true;
}
private async Task OpenTransportAsync()
{
await ExecuteAsync(async () =>
{
AddStatusMessage("Connecting...");
var timeoutCancellationToken = _operationTimeout.ToCancellationToken();
X509Certificate2 clientCertificate = null;
if (!string.IsNullOrWhiteSpace(ClientCertificateThumbprint))
{
ClientCertificateThumbprint = ClientCertificateThumbprint
.Replace(" ", "")
.Replace("", "");
var store = new X509Store(StoreName.My, StoreLocation.CurrentUser);
try
{
store.Open(OpenFlags.ReadOnly);
var certificates = store.Certificates.Find(X509FindType.FindByThumbprint, ClientCertificateThumbprint, false);
if (certificates.Count > 0)
{
clientCertificate = certificates[0];
var identity = clientCertificate.GetIdentity();
if (identity != null)
{
var fromVariableViewModel = this.Variables.FirstOrDefault(v => v.Name.Equals("from", StringComparison.OrdinalIgnoreCase));
if (fromVariableViewModel == null)
{
fromVariableViewModel = new VariableViewModel()
{
Name = "from"
};
this.Variables.Add(fromVariableViewModel);
}
fromVariableViewModel.Value = identity.ToString();
}
}
else
{
AddStatusMessage("The specified certificate was not found", true);
}
}
finally
{
store.Close();
}
}
TcpClient = new TcpClientAdapter(new TcpClient());
Transport = new TcpTransport(
TcpClient,
new EnvelopeSerializer(),
_hostUri.Host,
clientCertificate: clientCertificate,
traceWriter: this);
await Transport.OpenAsync(_hostUri, timeoutCancellationToken);
_connectionCts = new CancellationTokenSource();
var dispatcher = Dispatcher.CurrentDispatcher;
_receiveTask = ReceiveAsync(
Transport,
(e) => ReceiveEnvelopeAsync(e, dispatcher),
_connectionCts.Token)
.ContinueWith(t =>
{
IsConnected = false;
if (t.Exception != null)
{
AddStatusMessage(string.Format("Disconnected with errors: {0}", t.Exception.InnerException.Message.RemoveCrLf()), true);
}
else
{
AddStatusMessage("Disconnected");
}
}, TaskScheduler.FromCurrentSynchronizationContext());
IsConnected = true;
CanSendAsRaw = true;
AddStatusMessage("Connected");
});
}
private static async Task<IClientChannel> ConnectAsync()
{
var transport = new TcpTransport ();
await transport.OpenAsync (
new Uri ("net.tcp://iris.limeprotocol.org:55321"),
CancellationToken.None);
var channel = new ClientChannel (
transport,
TimeSpan.FromSeconds (60));
return channel;
}
public async Task<bool> ConnectWithPasswordAsync(Identity identity, string password, CancellationToken cancellationToken)
{
var tcpClient = new TcpClient();
#if DEBUG
ITraceWriter traceWriter = new DebugTraceWriter("Client");
#else
ITraceWriter traceWriter = new FileTraceWriter("client.log");
#endif
var transport = new TcpTransport(
new TcpClientAdapter(tcpClient),
new EnvelopeSerializer(),
hostName: _clientUri.Host,
traceWriter: traceWriter
);
Channel = new ClientChannel(transport, TimeSpan.FromSeconds(60), autoReplyPings: true, autoNotifyReceipt: true);
await Channel.Transport.OpenAsync(_clientUri, cancellationToken);
var resultSession = await Channel.EstablishSessionAsync(
c => c.First(),
e => SessionEncryption.TLS,
identity,
(s, r) => { var auth = new PlainAuthentication(); auth.SetToBase64Password(password); return auth; },
Environment.MachineName,
cancellationToken);
if (resultSession.State != SessionState.Established)
{
return false;
}
return true;
}
public async Task LoginAsync()
{
IClientChannel client = null;
ITraceWriter traceWriter = null;
if (ShowTraceWindow)
{
traceWriter = Owner.TraceViewModel;
base.MessengerInstance.Send<OpenWindowMessage>(
new OpenWindowMessage()
{
WindowName = "Trace",
DataContext = Owner.TraceViewModel
});
}
IsBusy = true;
this.ErrorMessage = string.Empty;
try
{
var cancellationToken = _loginTimeout.ToCancellationToken();
var transport = new TcpTransport(traceWriter: traceWriter);
await transport.OpenAsync(_serverAddressUri, cancellationToken);
client = new ClientChannel(
transport,
_sendTimeout,
fillEnvelopeRecipients: true,
autoReplyPings: true,
autoNotifyReceipt: true);
if (RegisterUser)
{
var guestSessionResult = await client.EstablishSessionAsync(
compressionOptions => compressionOptions.First(),
encryptionOptions => SessionEncryption.TLS,
new Identity() { Name = Guid.NewGuid().ToString(), Domain = _userNameNode.Domain },
(schemeOptions, roundtrip) => new GuestAuthentication(),
null,
cancellationToken
);
if (guestSessionResult.State == SessionState.Established)
{
// Creates the account
var account = new Account()
{
Password = this.Password.ToBase64()
};
await client.SetResourceAsync<Account>(
LimeUri.Parse(UriTemplates.ACCOUNT),
account,
_userNameNode,
cancellationToken);
await client.SendFinishingSessionAsync();
await client.ReceiveFinishedSessionAsync(cancellationToken);
client.DisposeIfDisposable();
transport = new TcpTransport(traceWriter: traceWriter);
await transport.OpenAsync(_serverAddressUri, cancellationToken);
client = new ClientChannel(
transport,
_sendTimeout,
fillEnvelopeRecipients: true,
autoReplyPings: true,
autoNotifyReceipt: true);
}
else if (guestSessionResult.Reason != null)
{
this.ErrorMessage = guestSessionResult.Reason.Description;
}
else
{
this.ErrorMessage = "Could not establish a guest session with the server";
}
}
var authentication = new PlainAuthentication();
authentication.SetToBase64Password(this.Password);
var sessionResult = await client.EstablishSessionAsync(
compressionOptions => compressionOptions.First(),
encryptionOptions => SessionEncryption.TLS,
new Identity() { Name = _userNameNode.Name, Domain = _userNameNode.Domain },
(schemeOptions, roundtrip) => authentication,
_userNameNode.Instance,
cancellationToken);
if (sessionResult.State == SessionState.Established)
{
var rosterViewModel = new RosterViewModel(client, this);
base.Owner.ContentViewModel = rosterViewModel;
}
else if (sessionResult.Reason != null)
{
this.ErrorMessage = sessionResult.Reason.Description;
}
else
{
this.ErrorMessage = "Could not connect to the server";
}
}
catch (Exception ex)
{
ErrorMessage = ex.Message;
client.DisposeIfDisposable();
}
finally
{
IsBusy = false;
}
}
