private void HandshakeMessageReceived(IMessageReceivedContext context)
{
var data = context.Reader.ReadBytes(context.MessageLength - 1);
var handshake = new ExtensionProtocolHandshake();
handshake.Deserialize(data);
context.SetValue(ExtensionProtocolMessageIds, handshake.MessageIds);
}
private void BlockReceived(IMessageReceivedContext context, PeerConnection peer, Block block)
{
peer.Requested.Remove(block.AsRequest());
context.BlockRequests.BlockReceived(block);
long dataOffset = context.Metainfo.PieceSize * block.PieceIndex + block.Offset;
context.DataHandler.WriteBlockData(dataOffset, block.Data);
}
private void SetPeerBitfield(IMessageReceivedContext context, PeerConnection peer, int pieceIndex, bool available)
{
peer.Available.SetPieceAvailable(pieceIndex, available);
if (!peer.IsInterestedInRemotePeer &&
IsBitfieldInteresting(context, peer.Available))
{
peer.IsInterestedInRemotePeer = true;
peer.SendMessage(new InterestedMessage());
}
}
void IModule.OnMessageReceived(IMessageReceivedContext context)
{
// We only registered to receive extension protocol messages
// so we should only receive messages of this type.
if (context.MessageId != ExtensionProtocolMessageId)
{
throw new InvalidOperationException("Unsupported message type.");
}
var messageTypeId = context.Reader.ReadByte();
if (messageTypeId == 0)
{
HandshakeMessageReceived(context);
foreach (var rh in registeredHandlers)
{
rh.PeerConnected(new ExtensionProtocolPeerContext(context, reply => SendExtensionMessage(context, reply)));
}
return;
}
// Non-handshake message
var handler = messageHandlers[messageTypeId];
string messageTypeName = reverseSupportedMessages[messageTypeId];
// Deserialize
var message = handler.SupportedMessageTypes[messageTypeName]();
message.Deserialize(context.Reader.ReadBytes(context.MessageLength - 1));
var extensionMessageContext =
new ExtensionProtocolMessageReceivedContext(message,
context,
reply => SendExtensionMessage(context, reply));
handler.MessageReceived(extensionMessageContext);
}
public void OnMessageReceived(IMessageReceivedContext context)
{
// Read message
CommonPeerMessage message = MessageHandler.ReadMessage(context.Metainfo, context.Reader, context.MessageLength, (byte)context.MessageId);
if (message == null)
{
// Something went wrong
context.Peer.Disconnect();
return;
}
var peer = context.Peer;
// Process message
switch (message.ID)
{
case ChokeMessage.MessageID:
SetChokedByPeer(peer, true);
break;
case UnchokeMessage.MessageID:
SetChokedByPeer(peer, false);
break;
case InterestedMessage.MessageID:
SetPeerInterested(peer, true);
UnchokePeer(peer);
break;
case NotInterestedMessage.MessageID:
SetPeerInterested(peer, false);
break;
case HaveMessage.MessageId:
{
HaveMessage haveMessage = message as HaveMessage;
SetPeerBitfield(context, peer, haveMessage.Piece.Index, true);
break;
}
case BitfieldMessage.MessageId:
{
BitfieldMessage bitfieldMessage = message as BitfieldMessage;
SetPeerBitfield(peer, bitfieldMessage.Bitfield);
if (IsBitfieldInteresting(context, bitfieldMessage.Bitfield))
{
peer.IsInterestedInRemotePeer = true;
peer.SendMessage(new InterestedMessage());
}
break;
}
case RequestMessage.MessageID:
{
RequestMessage requestMessage = message as RequestMessage;
SetBlockRequestedByPeer(peer, requestMessage.Block);
break;
}
case CancelMessage.MessageID:
{
CancelMessage cancelMessage = message as CancelMessage;
SetBlockCancelledByPeer(peer, cancelMessage.Block);
break;
}
case PieceMessage.MessageId:
{
PieceMessage pieceMessage = message as PieceMessage;
BlockReceived(context, peer, pieceMessage.Block);
break;
}
}
}
private bool IsBitfieldInteresting(IMessageReceivedContext context, Bitfield bitfield)
{
var clientBitfield = new Bitfield(context.Metainfo.Pieces.Count, context.DataHandler.CompletedPieces);
return(Bitfield.NotSubset(bitfield, clientBitfield));
}
