public SendMessageState Initialise (byte[] buffer, AsyncIOCallback callback, object state)
{
Buffer = buffer;
Callback = callback;
State = state;
return this;
}
public AsyncConnectState Initialise(IConnection connection, AsyncIOCallback callback, object state)
{
Connection = connection;
Callback = callback;
State = state;
return(this);
}
public SendMessageState Initialise(byte[] buffer, AsyncIOCallback callback, object state)
{
Buffer = buffer;
Callback = callback;
State = state;
return(this);
}
public AsyncConnectState Initialise(IConnection connection, AsyncIOCallback callback, object state)
{
Connection = connection;
Callback = callback;
State = state;
return this;
}
public EncryptedSocket(EncryptionTypes allowedEncryption)
{
#if NETSTANDARD1_5
random = RandomNumberGenerator.Create();
hasher = SHA1.Create();
#else
random = RNGCryptoServiceProvider.Create();
hasher = HashAlgoFactory.Create <SHA1>();
#endif
GenerateX();
GenerateY();
InitialPayload = BufferManager.EmptyBuffer;
RemoteInitialPayload = BufferManager.EmptyBuffer;
doneSendCallback = doneSend;
doneReceiveCallback = doneReceive;
doneReceiveYCallback = delegate { doneReceiveY(); };
doneSynchronizeCallback = delegate { doneSynchronize(); };
fillSynchronizeBytesCallback = fillSynchronizeBytes;
bytesReceived = 0;
SetMinCryptoAllowed(allowedEncryption);
}
public static void EnqueueSendMessage (IConnection connection, IEncryption encryptor, PeerMessage message, IRateLimiter rateLimiter, ConnectionMonitor peerMonitor, ConnectionMonitor managerMonitor, AsyncIOCallback callback, object state)
{
int count = message.ByteLength;
var buffer = ClientEngine.BufferManager.GetBuffer (count);
message.Encode (buffer, 0);
encryptor.Encrypt (buffer, 0, count);
var data = sendCache.Dequeue ().Initialise (buffer, callback, state);
NetworkIO.EnqueueSend (connection, buffer, 0, count, rateLimiter, peerMonitor, managerMonitor, EndSendCallback, data);
}
public static void EnqueueSend(IConnection connection, byte[] buffer, int offset, int count,
IRateLimiter rateLimiter, ConnectionMonitor peerMonitor, ConnectionMonitor managerMonitor,
AsyncIOCallback callback, object state)
{
var data = TransferCache.Dequeue()
.Initialise(connection, buffer, offset, count, callback, state, rateLimiter, peerMonitor, managerMonitor);
lock (SendQueue)
SendOrEnqueue(data);
}
public static void EnqueueSendMessage(IConnection connection, IEncryption encryptor, PeerMessage message,
IRateLimiter rateLimiter, ConnectionMonitor peerMonitor, ConnectionMonitor managerMonitor,
AsyncIOCallback callback, object state)
{
var count = message.ByteLength;
var buffer = ClientEngine.BufferManager.GetBuffer(count);
message.Encode(buffer, 0);
encryptor.Encrypt(buffer, 0, count);
var data = SendCache.Dequeue().Initialise(buffer, callback, state);
NetworkIO.EnqueueSend(connection, buffer, 0, count, rateLimiter, peerMonitor, managerMonitor,
EndSendCallback, data);
}
/// <summary>
///
/// </summary>
/// <param name="settings"></param>
public ConnectionManager(ClientEngine engine)
{
this.engine = engine;
this.endCheckEncryptionCallback = ClientEngine.MainLoop.Wrap(EndCheckEncryption);
this.endSendMessageCallback = (a, b, c) => ClientEngine.MainLoop.Queue(() => EndSendMessage(a, b, c));
this.endCreateConnectionCallback = (a, b, c) => ClientEngine.MainLoop.Queue(() => EndCreateConnection(a, b, c));
this.incomingConnectionAcceptedCallback = (a, b, c) => ClientEngine.MainLoop.Queue(() => IncomingConnectionAccepted(a, b, c));
this.handshakeSentCallback = PeerHandshakeSent;
this.peerHandshakeReceivedCallback = (a, b, c) => ClientEngine.MainLoop.Queue(() => PeerHandshakeReceived(a, b, c));
this.messageSentCallback = PeerMessageSent;
this.messageReceivedCallback = (a, b, c) => ClientEngine.MainLoop.Queue(() => MessageReceived(a, b, c));
this.pendingConnects = new List <AsyncConnectState>();
}
public AsyncIOState Initialise(IConnection connection, byte[] buffer, int offset, int count,
AsyncIOCallback callback,
object state, IRateLimiter limiter,
ConnectionMonitor peerMonitor, ConnectionMonitor managerMonitor)
{
Connection = connection;
Buffer = buffer;
Count = count;
Callback = callback;
Offset = offset;
ManagerMonitor = managerMonitor;
PeerMonitor = peerMonitor;
RateLimiter = limiter;
Remaining = count;
State = state;
return this;
}
/// <summary>
/// </summary>
/// <param name="settings"></param>
public ConnectionManager(ClientEngine engine)
{
this.engine = engine;
endCheckEncryptionCallback = ClientEngine.MainLoop.Wrap(EndCheckEncryption);
endSendMessageCallback = (a, b, c) => ClientEngine.MainLoop.Queue(() => EndSendMessage(a, b, c));
endCreateConnectionCallback = (a, b, c) => ClientEngine.MainLoop.Queue(() => EndCreateConnection(a, b, c));
incomingConnectionAcceptedCallback =
(a, b, c) => ClientEngine.MainLoop.Queue(() => IncomingConnectionAccepted(a, b, c));
handshakeSentCallback = PeerHandshakeSent;
peerHandshakeReceivedCallback = (a, b, c) => ClientEngine.MainLoop.Queue(() => PeerHandshakeReceived(a, b, c));
messageSentCallback = PeerMessageSent;
messageReceivedCallback = (a, b, c) => ClientEngine.MainLoop.Queue(() => MessageReceived(a, b, c));
pendingConnects = new List<AsyncConnectState>();
}
public AsyncIOState Initialise(IConnection connection, byte[] buffer, int offset, int count,
AsyncIOCallback callback,
object state, IRateLimiter limiter,
ConnectionMonitor peerMonitor, ConnectionMonitor managerMonitor)
{
Connection = connection;
Buffer = buffer;
Count = count;
Callback = callback;
Offset = offset;
ManagerMonitor = managerMonitor;
PeerMonitor = peerMonitor;
RateLimiter = limiter;
Remaining = count;
State = state;
return(this);
}
public static void EnqueueConnect(IConnection connection, AsyncIOCallback callback, object state)
{
var data = connectCache.Dequeue().Initialise(connection, callback, state);
try {
var result = connection.BeginConnect(EndConnectCallback, data);
Interlocked.Increment(ref halfOpens);
ClientEngine.MainLoop.QueueTimeout(TimeSpan.FromSeconds(10), delegate {
if (!result.IsCompleted)
{
connection.Dispose();
}
return(false);
});
} catch {
callback(false, 0, state);
connectCache.Enqueue(data);
}
}
public static async void EnqueueConnect(IConnection connection, AsyncIOCallback callback, object state)
{
var data = ConnectCache.Dequeue().Initialise(connection, callback, state);
try
{
using (var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(30.0)))
{
Interlocked.Increment(ref _halfOpens);
await connection.ConnectAsync(cancellationTokenSource.Token).ConfigureAwait(false);
}
FinishConnect(data);
}
catch
{
Interlocked.Decrement(ref _halfOpens);
callback(false, 0, state);
ConnectCache.Enqueue(data);
}
}
public static void EnqueueConnect(IConnection connection, AsyncIOCallback callback, object state)
{
var data = connectCache.Dequeue().Initialise(connection, callback, state);
try
{
var result = connection.BeginConnect(EndConnectCallback, data);
Interlocked.Increment(ref halfOpens);
ClientEngine.MainLoop.QueueTimeout(TimeSpan.FromSeconds(10), delegate
{
if (!result.IsCompleted)
connection.Dispose();
return false;
});
}
catch
{
callback(false, 0, state);
connectCache.Enqueue(data);
}
}
private byte[] Y; // 2^X mod P
#endregion Fields
#region Constructors
public EncryptedSocket(EncryptionTypes allowedEncryption)
{
random = RandomNumberGenerator.Create();
hasher = HashAlgoFactory.Create<SHA1>();
GenerateX();
GenerateY();
InitialPayload = BufferManager.EmptyBuffer;
RemoteInitialPayload = BufferManager.EmptyBuffer;
doneSendCallback = doneSend;
doneReceiveCallback = doneReceive;
doneReceiveYCallback = delegate { doneReceiveY(); };
doneSynchronizeCallback = delegate { doneSynchronize(); };
fillSynchronizeBytesCallback = fillSynchronizeBytes;
bytesReceived = 0;
SetMinCryptoAllowed(allowedEncryption);
}
public static async void EnqueueConnect(IConnection connection, AsyncIOCallback callback, object state)
{
var data = ConnectCache.Dequeue().Initialise(connection, callback, state);
try
{
using (var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(30.0)))
{
Interlocked.Increment(ref _halfOpens);
await connection.ConnectAsync(cancellationTokenSource.Token).ConfigureAwait(false);
}
FinishConnect(data);
}
catch
{
Interlocked.Decrement(ref _halfOpens);
callback(false, 0, state);
ConnectCache.Enqueue(data);
}
}
public static void EnqueueSend(IConnection connection, byte[] buffer, int offset, int count, IRateLimiter rateLimiter, ConnectionMonitor peerMonitor, ConnectionMonitor managerMonitor, AsyncIOCallback callback, object state)
{
var data = transferCache.Dequeue ().Initialise (connection, buffer, offset, count, callback, state, rateLimiter, peerMonitor, managerMonitor);
lock (sendQueue)
SendOrEnqueue (data);
}
