public override bool Equals(object obj)
{
PieceMessage msg = obj as PieceMessage;
return((msg == null) ? false : (this.pieceIndex == msg.pieceIndex &&
this.startOffset == msg.startOffset &&
this.requestLength == msg.requestLength));
}
public void PieceEncoding()
{
var message = new PieceMessage(15, 10, Piece.BlockSize);
message.Data = new byte[Piece.BlockSize];
message.Encode(buffer, offset);
}
public void PieceDecoding()
{
var message = new PieceMessage(15, 10, Piece.BlockSize);
message.Data = new byte[Piece.BlockSize];
EncodeDecode(message);
}
protected virtual void HandleRequestMessage(PeerId id, RequestMessage message)
{
// If we are not on the last piece and the user requested a stupidly big/small amount of data
// we will close the connection
if (manager.Torrent.Pieces.Count != (message.PieceIndex + 1))
if (message.RequestLength > RequestMessage.MaxSize || message.RequestLength < RequestMessage.MinSize)
throw new MessageException("Illegal piece request received. Peer requested " + message.RequestLength.ToString() + " byte");
PieceMessage m = new PieceMessage(message.PieceIndex, message.StartOffset, message.RequestLength);
// If we're not choking the peer, enqueue the message right away
if (!id.AmChoking)
{
id.IsRequestingPiecesCount++;
id.PieceReads.Add(m);
id.TryProcessAsyncReads();
}
// If the peer supports fast peer and the requested piece is one of the allowed pieces, enqueue it
// otherwise send back a reject request message
else if (id.SupportsFastPeer && ClientEngine.SupportsFastPeer)
{
if (id.AmAllowedFastPieces.Contains(message.PieceIndex))
{
id.IsRequestingPiecesCount++;
id.PieceReads.Add(m);
id.TryProcessAsyncReads();
}
else
id.Enqueue(new RejectRequestMessage(m));
}
}
protected virtual void HandlePieceMessage(PeerId id, PieceMessage message)
{
id.PiecesReceived++;
manager.PieceManager.PieceDataReceived(id, message);
// Keep adding new piece requests to this peers queue until we reach the max pieces we're allowed queue
manager.PieceManager.AddPieceRequests(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
{
}
}
public HttpRequestData(RequestMessage request)
{
Request = request;
PieceMessage m = new PieceMessage(null, request.PieceIndex, request.StartOffset, request.RequestLength);
TotalToReceive = m.ByteLength;
}
public RejectRequestMessage(PieceMessage message)
: this(message.PieceIndex, message.StartOffset, message.RequestLength)
{
}
