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); }