public MetadataMode(TorrentManager manager, string savePath)
: base(manager)
{
this.savePath = savePath;
}
protected virtual void RaiseConnectionReceived(Peer peer, IConnection connection, TorrentManager manager)
{
if (ConnectionReceived != null)
{
Toolbox.RaiseAsyncEvent <NewConnectionEventArgs>(ConnectionReceived, this, new NewConnectionEventArgs(peer, connection, manager));
}
}
/// <summary>
/// Creates a new TorrentStateChangedEventArgs
/// </summary>
/// <param name="oldState">The old state of the Torrent</param>
/// <param name="newState">The new state of the Torrent</param>
public TorrentStateChangedEventArgs(TorrentManager manager, TorrentState oldState, TorrentState newState)
: base(manager)
{
this.oldState = oldState;
this.newState = newState;
}
public static void EnqueueReceiveMessage(IConnection connection, IEncryption decryptor, IRateLimiter rateLimiter, ConnectionMonitor monitor, TorrentManager manager, AsyncMessageReceivedCallback callback, object state)
{
// FIXME: Hardcoded number
int count = 4;
var buffer = ClientEngine.BufferManager.GetBuffer(count);
var data = receiveCache.Dequeue().Initialise(connection, decryptor, rateLimiter, monitor, manager, buffer, callback, state);
NetworkIO.EnqueueReceive(connection, buffer, 0, count, rateLimiter, monitor, data.ManagerMonitor, MessageLengthReceivedCallback, data);
}
public DownloadMode(TorrentManager manager)
: base(manager)
{
state = manager.Complete ? TorrentState.Seeding : TorrentState.Downloading;
}
/// <summary>
/// Creates a new PieceHashedEventArgs
/// </summary>
/// <param name="pieceIndex">The index of the piece that was hashed</param>
/// <param name="hashPassed">True if the piece passed the hashcheck, false otherwise</param>
public PieceHashedEventArgs(TorrentManager manager, int pieceIndex, bool hashPassed)
: base(manager)
{
this.pieceIndex = pieceIndex;
this.hashPassed = hashPassed;
}
protected Mode(TorrentManager manager)
{
CanAcceptConnections = true;
this.manager = manager;
manager.chokeUnchoker = new ChokeUnchokeManager(manager, manager.Settings.MinimumTimeBetweenReviews, manager.Settings.PercentOfMaxRateToSkipReview);
}
public ReceiveMessageState Initialise(IConnection connection, IEncryption decryptor, IRateLimiter limiter, ConnectionMonitor peerMonitor, TorrentManager manager, byte[] buffer, AsyncMessageReceivedCallback callback, object state)
{
Connection = connection;
Decryptor = decryptor;
Manager = manager;
Buffer = buffer;
PeerMonitor = peerMonitor;
RateLimiter = limiter;
ManagerMonitor = manager == null ? null : manager.Monitor;
Callback = callback;
State = state;
return(this);
}
public ErrorMode(TorrentManager manager)
: base(manager)
{
CanAcceptConnections = false;
CloseConnections();
}
public static PeerMessage ReceiveMessage(CustomConnection connection, IEncryption decryptor, TorrentManager manager)
{
byte[] buffer = new byte[4];
Receive(connection, buffer, 0, buffer.Length);
decryptor.Decrypt(buffer);
int count = IPAddress.HostToNetworkOrder(BitConverter.ToInt32(buffer, 0));
byte[] message = new byte[count + 4];
Buffer.BlockCopy(buffer, 0, message, 0, 4);
Receive(connection, message, 4, count);
decryptor.Decrypt(message, 4, count);
return(PeerMessage.DecodeMessage(message, 0, message.Length, manager));
}
public StoppedMode(TorrentManager manager)
: base(manager)
{
CanAcceptConnections = false;
}
public AsyncConnectState(TorrentManager manager, Peer peer, IConnection connection)
{
Manager = manager;
Peer = peer;
Connection = connection;
}
/// <summary>
/// Creates a new PeersAddedEventArgs
/// </summary>
/// <param name="peersAdded">The number of peers just added</param>
public PeerAddedEventArgs(TorrentManager manager, Peer peerAdded)
: base(manager)
{
this.peer = peerAdded;
}
public PauseLimiter(TorrentManager manager)
{
this.manager = manager;
}
/// <summary>
/// Creates a new PeersAddedEventArgs
/// </summary>
/// <param name="peersAdded">The number of peers just added</param>
protected PeersAddedEventArgs(TorrentManager manager, int peersAdded, int total)
: base(manager)
{
this.count = peersAdded;
this.total = total;
}
/// <summary>
/// Creates a new choke/unchoke manager for a torrent manager
/// </summeary>
/// <param name="TorrentManager">The torrent manager this choke/unchoke manager belongs to</param>
public ChokeUnchokeManager(TorrentManager TorrentManager, int MinimumTimeBetweenReviews, int PercentOfMaxRateToSkipReview)
{
owningTorrent = TorrentManager;
minimumTimeBetweenReviews = MinimumTimeBetweenReviews;
percentOfMaxRateToSkipReview = PercentOfMaxRateToSkipReview;
}
public LocalPeersAdded(TorrentManager manager, int peersAdded, int total)
: base(manager, peersAdded, total)
{
}
public void Add(TorrentManager manager, IConnection connection)
{
System.Net.BitTorrent.Client.Peer p = new System.Net.BitTorrent.Client.Peer("", new Uri("tcp://12.123.123.1:2342"), EncryptionTypes.All);
base.RaiseConnectionReceived(p, connection, manager);
}
private void OnReceiveCallBack(IAsyncResult ar)
{
UdpClient u = (UdpClient)ar.AsyncState;
IPEndPoint e = new IPEndPoint(IPAddress.Any, 0);
try
{
byte[] receiveBytes = u.EndReceive(ar, ref e);
string receiveString = Encoding.ASCII.GetString(receiveBytes);
Regex exp = new Regex("BT-SEARCH \\* HTTP/1.1\\r\\nHost: 239.192.152.143:6771\\r\\nPort: (?<port>[^@]+)\\r\\nInfohash: (?<hash>[^@]+)\\r\\n\\r\\n\\r\\n");
Match match = exp.Match(receiveString);
if (!match.Success)
{
return;
}
int portcheck = Convert.ToInt32(match.Groups["port"].Value);
if (portcheck < 0 || portcheck > 65535)
{
return;
}
TorrentManager manager = null;
InfoHash matchHash = InfoHash.FromHex(match.Groups["hash"].Value);
for (int i = 0; manager == null && i < engine.Torrents.Count; i++)
{
if (engine.Torrents [i].InfoHash == matchHash)
{
manager = engine.Torrents [i];
}
}
if (manager == null)
{
return;
}
Uri uri = new Uri("tcp://" + e.Address.ToString() + ':' + match.Groups["port"].Value);
Peer peer = new Peer("", uri, EncryptionTypes.All);
// Add new peer to matched Torrent
if (!manager.HasMetadata || !manager.Torrent.IsPrivate)
{
ClientEngine.MainLoop.Queue(delegate {
int count = manager.AddPeersCore(peer);
manager.RaisePeersFound(new LocalPeersAdded(manager, count, 1));
});
}
}
catch
{
// Failed to receive data, ignore
}
finally
{
try
{
u.BeginReceive(OnReceiveCallBack, ar.AsyncState);
}
catch
{
// It's closed
}
}
}
public EndGameSwitcher(StandardPicker standard, EndGamePicker endgame, int blocksPerPiece, TorrentManager torrentManager)
: base(null)
{
this.standard = standard;
this.endgame = endgame;
this.blocksPerPiece = blocksPerPiece;
this.torrentManager = torrentManager;
}
private void handleHandshake(PeerId id, HandshakeMessage message)
{
TorrentManager man = null;
try
{
if (message.ProtocolString != VersionInfo.ProtocolStringV100)
{
throw new ProtocolException("Invalid protocol string in handshake");
}
}
catch (Exception ex)
{
Logger.Log(id.Connection, ex.Message);
id.Connection.Dispose();
return;
}
ClientEngine.MainLoop.QueueWait((MainLoopTask) delegate {
for (int i = 0; i < engine.Torrents.Count; i++)
{
if (message.infoHash == engine.Torrents[i].InfoHash)
{
man = engine.Torrents[i];
}
}
});
//FIXME: #warning FIXME: Don't stop the message loop until Dispose() and track all incoming connections
if (man == null) // We're not hosting that torrent
{
Logger.Log(id.Connection, "ListenManager - Handshake requested nonexistant torrent");
id.Connection.Dispose();
return;
}
if (man.State == TorrentState.Stopped)
{
Logger.Log(id.Connection, "ListenManager - Handshake requested for torrent which is not running");
id.Connection.Dispose();
return;
}
if (!man.Mode.CanAcceptConnections)
{
Logger.Log(id.Connection, "ListenManager - Current mode does not support connections");
id.Connection.Dispose();
return;
}
id.Peer.PeerId = message.PeerId;
id.TorrentManager = man;
// If the handshake was parsed properly without encryption, then it definitely was not encrypted. If this is not allowed, abort
if ((id.Encryptor is PlainTextEncryption && !Toolbox.HasEncryption(engine.Settings.AllowedEncryption, EncryptionTypes.PlainText)) && ClientEngine.SupportsEncryption)
{
Logger.Log(id.Connection, "ListenManager - Encryption is required but was not active");
id.Connection.Dispose();
return;
}
message.Handle(id);
Logger.Log(id.Connection, "ListenManager - Handshake successful handled");
id.ClientApp = new Software(message.PeerId);
message = new HandshakeMessage(id.TorrentManager.InfoHash, engine.PeerId, VersionInfo.ProtocolStringV100);
var callback = engine.ConnectionManager.incomingConnectionAcceptedCallback;
PeerIO.EnqueueSendMessage(id.Connection, id.Encryptor, message, id.TorrentManager.UploadLimiter,
id.Monitor, id.TorrentManager.Monitor, callback, id);
}
public void PieceDataReceived(PeerId peer, PieceMessage message)
{
Piece piece;
if (picker.ValidatePiece(peer, message.PieceIndex, message.StartOffset, message.RequestLength, out piece))
{
PeerId id = peer;
TorrentManager manager = id.TorrentManager;
Block block = piece.Blocks [message.StartOffset / Piece.BlockSize];
long offset = (long)message.PieceIndex * id.TorrentManager.Torrent.PieceLength + message.StartOffset;
id.LastBlockReceived = DateTime.Now;
id.TorrentManager.PieceManager.RaiseBlockReceived(new BlockEventArgs(manager, block, piece, id));
id.TorrentManager.Engine.DiskManager.QueueWrite(manager, offset, message.Data, message.RequestLength, delegate {
piece.Blocks[message.StartOffset / Piece.BlockSize].Written = true;
ClientEngine.BufferManager.FreeBuffer(ref message.Data);
// If we haven't written all the pieces to disk, there's no point in hash checking
if (!piece.AllBlocksWritten)
{
return;
}
// Hashcheck the piece as we now have all the blocks.
id.Engine.DiskManager.BeginGetHash(id.TorrentManager, piece.Index, delegate(object o) {
byte[] hash = (byte[])o;
bool result = hash == null ? false : id.TorrentManager.Torrent.Pieces.IsValid(hash, piece.Index);
id.TorrentManager.Bitfield[message.PieceIndex] = result;
ClientEngine.MainLoop.Queue(delegate
{
id.TorrentManager.PieceManager.UnhashedPieces[piece.Index] = false;
id.TorrentManager.HashedPiece(new PieceHashedEventArgs(id.TorrentManager, piece.Index, result));
List <PeerId> peers = new List <PeerId>(piece.Blocks.Length);
for (int i = 0; i < piece.Blocks.Length; i++)
{
if (piece.Blocks[i].RequestedOff != null && !peers.Contains(piece.Blocks[i].RequestedOff))
{
peers.Add(piece.Blocks[i].RequestedOff);
}
}
for (int i = 0; i < peers.Count; i++)
{
if (peers[i].Connection != null)
{
peers[i].Peer.HashedPiece(result);
if (peers [i].Peer.TotalHashFails == 5)
{
peers[i].ConnectionManager.CleanupSocket(id, "Too many hash fails");
}
}
}
// If the piece was successfully hashed, enqueue a new "have" message to be sent out
if (result)
{
id.TorrentManager.finishedPieces.Enqueue(piece.Index);
}
});
});
});
if (piece.AllBlocksReceived)
{
this.unhashedPieces[message.PieceIndex] = true;
}
}
else
{
}
}
/// <summary>
/// Creates a new PeerMessageEventArgs
/// </summary>
/// <param name="message">The peer message involved</param>
/// <param name="direction">The direction of the message</param>
internal BlockEventArgs(TorrentManager manager, Block block, Piece piece, PeerId id)
: base(manager)
{
Init(block, piece, id);
}
public TorrentEventArgs(TorrentManager manager)
{
torrentManager = manager;
}
/// <summary>
/// Creates a new inactive peer manager for a torrent manager
/// </summary>
/// <param name="TorrentManager">The torrent manager this choke/unchoke manager belongs to</param>
/// <param name="TimeToWaitBeforeIdle">Number of seconds to protect a peer from being marked as inactive</param>
public InactivePeerManager(TorrentManager TorrentManager)
{
owningTorrent = TorrentManager;
}
