public JobPusher()
{
_nodesList = new List <string>();
_nListLock = new ReaderWriterLockSlim();
_index = -1;
_aT = new AsyncTransfer <Job>();
}
private void AcquireTransferCancellationHandler(object _acquireNode, bool canceling)
{
LinkedListNode <Message> acquireNode = (LinkedListNode <Message>)_acquireNode;
AsyncTransfer acquire = acquireNode.Value.transfer;
if (acquire.TryLock())
{
// To access shared mutable state we must acquire the lock
lock (theLock)
{
pendingMessages.Remove(acquireNode);
}
// Release the resources associated with the async acquire.
acquire.Dispose(canceling);
// Complete the TaskCompletionSource to RanToCompletion (timeout)
// or Canceled final state.
if (canceling)
{
acquire.SetCanceled();
}
else
{
acquire.SetResult(false);
}
}
}
/// <summary>
/// Runs this instance.
/// </summary>
public void Run()
{
try
{
var listener = new TcpListener(IPAddress.Parse("127.0.0.1"), _serverPort);
listener.Start();
while (true)
{
if (listener.Pending())
{
var trans = new AsyncTransfer <T>(listener.AcceptTcpClient());
var newActor = _actor.NewActor(trans);
(new Thread(newActor.Act)).Start();
}
else
{
Thread.Sleep(1000);
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
internal Message(T message, AsyncTransfer transfer = null)
{
this.message = message;
this.transfer = transfer;
}
/// <summary>
///
/// </summary>
/// <param name="settings"></param>
public ConnectionManager(ClientEngine engine)
{
this.engine = engine;
this.endCheckEncryptionCallback = delegate(IAsyncResult result) { ClientEngine.MainLoop.Queue(delegate { EndCheckEncryption(result); }); };
this.endSendMessageCallback = delegate(bool s, int c, object o) { ClientEngine.MainLoop.Queue(delegate { EndSendMessage(s, c, o); }); };
this.endCreateConnectionCallback = delegate(bool succeeded, object state) { ClientEngine.MainLoop.Queue(delegate { EndCreateConnection(succeeded, state); }); };
this.incomingConnectionAcceptedCallback = delegate(bool s, int c, object o) { ClientEngine.MainLoop.Queue(delegate { IncomingConnectionAccepted(s, c, o); }); };
this.bitfieldSentCallback = new MessagingCallback(PeerBitfieldSent);
this.handshakeSentCallback = new MessagingCallback(this.PeerHandshakeSent);
this.handshakeReceievedCallback = delegate(bool s, int c, object o) { ClientEngine.MainLoop.Queue(delegate { PeerHandshakeReceived(s, c, o); }); };
this.messageSentCallback = new MessagingCallback(this.PeerMessageSent);
this.torrents = new MonoTorrentCollection<TorrentManager>();
}
public AsyncIO(IConnection connection, byte[] buffer, int offset, int total, AsyncTransfer callback, object state, RateLimiter limiter, ConnectionMonitor managerMonitor, ConnectionMonitor peerMonitor)
{
Connection = connection;
Buffer = buffer;
Offset = offset;
Count = 0;
Callback = callback;
ManagerMonitor = managerMonitor;
PeerMonitor = peerMonitor;
RateLimiter = limiter;
State = state;
Total = total;
}
internal static void EnqueueSend(IConnection connection, byte[] buffer, int offset, int count, AsyncTransfer callback, object state, RateLimiter limiter, ConnectionMonitor managerMonitor, ConnectionMonitor peerMonitor)
{
AsyncIO io = new AsyncIO(connection, buffer, offset, count, callback, state, limiter, managerMonitor, peerMonitor);
EnqueueSend(io);
}
internal static void EnqueueSend(IConnection connection, byte[] buffer, int offset, int count, AsyncTransfer callback, object state)
{
EnqueueSend(connection, buffer, offset, count, callback, state, null, null, null);
}
internal static void EnqueueSend(IConnection connection, ArraySegment<byte> buffer, int offset, int count, AsyncTransfer callback, object state, RateLimiter limiter, ConnectionMonitor managerMonitor, ConnectionMonitor peerMonitor)
{
EnqueueSend(connection, buffer.Array, buffer.Offset + offset, count, callback, state, limiter, managerMonitor, peerMonitor);
}
internal static void EnqueueReceive(IConnection connection, ArraySegment<byte> buffer, int offset, int count, AsyncTransfer callback, object state)
{
EnqueueReceive(connection, buffer, offset, count, callback, state, null, null, null);
}
private byte[] Y; // 2^X mod P
#endregion Fields
#region Constructors
public EncryptedSocket(EncryptionTypes allowedEncryption)
{
random = RNGCryptoServiceProvider.Create();
hasher = SHA1.Create();
GenerateX();
GenerateY();
InitialPayload = new byte[0];
RemoteInitialPayload = new byte[0];
doneSendCallback = doneSend;
doneReceiveCallback = doneReceive;
doneReceiveYCallback = delegate { doneReceiveY(); };
doneSynchronizeCallback = delegate { doneSynchronize(); };
fillSynchronizeBytesCallback = fillSynchronizeBytes;
bytesReceived = 0;
SetMinCryptoAllowed(allowedEncryption);
}
public AsyncReceiver(TcpClient tclient, AsyncTransfer <T> parent)
{
_tClient = tclient;
_parent = parent;
}
