public void Int32_ToBytes_ReturnsExpectedValue(int input, int expectedResult)
{
// Act
var result = PackHelper.Int32(input);
// Assert
result.Should().ContainInOrder(BitConverter.GetBytes(expectedResult));
}
public bool OnHandshake(IPeerWireClient client)
{
BDict handshakeDict = new BDict();
BDict mDict = new BDict();
byte i = 1;
foreach (IBTExtension extension in this._protocolExtensions)
{
this._extOutgoing.Add(new ClientProtocolIDMap(client, extension.Protocol, i));
mDict.Add(extension.Protocol, new BInt(i));
i++;
}
handshakeDict.Add("m", mDict);
string handshakeEncoded = BencodingUtils.EncodeString(handshakeDict);
byte[] handshakeBytes = Encoding.ASCII.GetBytes(handshakeEncoded);
Int32 length = 2 + handshakeBytes.Length;
client.SendBytes((new byte[0]).Cat(PackHelper.Int32(length).Cat(new[] { (byte)20 }).Cat(new[] { (byte)0 }).Cat(handshakeBytes)));
return(true);
}
public void RequestMetaData(IPeerWireClient peerWireClient)
{
byte[] sendBuffer = new byte[0];
for (Int32 i = 0; i < this._pieceCount; i++)
{
BDict masterBDict = new BDict
{
{ "msg_type", (BInt)0 },
{ "piece", (BInt)i }
};
string encoded = BencodingUtils.EncodeString(masterBDict);
byte[] buffer = PackHelper.Int32(2 + encoded.Length);
buffer = buffer.Concat(new byte[] { 20 }).ToArray();
buffer = buffer.Concat(new[] { this._parent.GetOutgoingMessageID(peerWireClient, this) }).ToArray();
buffer = buffer.Concat(Encoding.GetEncoding(1252).GetBytes(encoded)).ToArray();
sendBuffer = sendBuffer.Concat(buffer).ToArray();
}
peerWireClient.SendBytes(sendBuffer);
}
public IDictionary <string, ScrapeInfo> Scrape(string url, String[] hashes)
{
Dictionary <string, ScrapeInfo> returnVal = new Dictionary <string, ScrapeInfo>();
this.ValidateInput(url, hashes, ScraperType.UDP);
Int32 transactionId = this.Random.Next(0, 65535);
UdpClient udpClient = new UdpClient(this.Tracker, this.Port)
{
Client =
{
SendTimeout = this.Timeout * 1000,
ReceiveTimeout = this.Timeout * 1000
}
};
byte[] sendBuf = this._currentConnectionId.Concat(PackHelper.Int32(0)).Concat(PackHelper.Int32(transactionId)).ToArray();
udpClient.Send(sendBuf, sendBuf.Length);
IPEndPoint endPoint = null;
byte[] recBuf = udpClient.Receive(ref endPoint);
if (recBuf == null)
{
throw new NoNullAllowedException("udpClient failed to receive");
}
if (recBuf.Length < 0)
{
throw new InvalidOperationException("udpClient received no response");
}
if (recBuf.Length < 16)
{
throw new InvalidOperationException("udpClient did not receive entire response");
}
UInt32 recAction = UnpackHelper.UInt32(recBuf, 0, UnpackHelper.Endianness.Big);
UInt32 recTrasactionId = UnpackHelper.UInt32(recBuf, 4, UnpackHelper.Endianness.Big);
if (recAction != 0 || recTrasactionId != transactionId)
{
throw new Exception("Invalid response from tracker");
}
this._currentConnectionId = CopyBytes(recBuf, 8, 8);
byte[] hashBytes = new byte[0];
hashBytes = hashes.Aggregate(hashBytes, (current, hash) => current.Concat(PackHelper.Hex(hash)).ToArray());
int expectedLength = 8 + (12 * hashes.Length);
sendBuf = this._currentConnectionId.Concat(PackHelper.Int32(2)).Concat(PackHelper.Int32(transactionId)).Concat(hashBytes).ToArray();
udpClient.Send(sendBuf, sendBuf.Length);
recBuf = udpClient.Receive(ref endPoint);
if (recBuf == null)
{
throw new NoNullAllowedException("udpClient failed to receive");
}
if (recBuf.Length < 0)
{
throw new InvalidOperationException("udpClient received no response");
}
if (recBuf.Length < expectedLength)
{
throw new InvalidOperationException("udpClient did not receive entire response");
}
recAction = UnpackHelper.UInt32(recBuf, 0, UnpackHelper.Endianness.Big);
recTrasactionId = UnpackHelper.UInt32(recBuf, 4, UnpackHelper.Endianness.Big);
this._currentConnectionId = CopyBytes(recBuf, 8, 8);
if (recAction != 2 || recTrasactionId != transactionId)
{
throw new Exception("Invalid response from tracker");
}
Int32 startIndex = 8;
foreach (string hash in hashes)
{
UInt32 seeders = UnpackHelper.UInt32(recBuf, startIndex, UnpackHelper.Endianness.Big);
UInt32 completed = UnpackHelper.UInt32(recBuf, startIndex + 4, UnpackHelper.Endianness.Big);
UInt32 Leechers = UnpackHelper.UInt32(recBuf, startIndex + 8, UnpackHelper.Endianness.Big);
returnVal.Add(hash, new ScrapeInfo(seeders, completed, Leechers, ScraperType.UDP));
startIndex += 12;
}
udpClient.Close();
return(returnVal);
}
public AnnounceInfo Announce(string url, string hash, string peerId, Int64 bytesDownloaded, Int64 bytesLeft, Int64 bytesUploaded,
Int32 eventTypeFilter, Int32 ipAddress, Int32 numWant, Int32 listenPort, Int32 extensions)
{
List <IPEndPoint> returnValue = new List <IPEndPoint>();
this.ValidateInput(url, new[] { hash }, ScraperType.UDP);
this._currentConnectionId = this.BaseCurrentConnectionId;
Int32 trasactionId = this.Random.Next(0, 65535);
UdpClient udpClient = new UdpClient(this.Tracker, this.Port)
{
DontFragment = true,
Client =
{
SendTimeout = this.Timeout * 1000,
ReceiveTimeout = this.Timeout * 1000
}
};
byte[] sendBuf = this._currentConnectionId.Concat(PackHelper.Int32(0)).Concat(PackHelper.Int32(trasactionId)).ToArray();
udpClient.Send(sendBuf, sendBuf.Length);
IPEndPoint endPoint = null;
byte[] recBuf;
try
{
recBuf = udpClient.Receive(ref endPoint);
}
catch (Exception)
{
return(null);
}
if (recBuf == null)
{
throw new NoNullAllowedException("udpClient failed to receive");
}
if (recBuf.Length < 0)
{
throw new InvalidOperationException("udpClient received no response");
}
if (recBuf.Length < 16)
{
throw new InvalidOperationException("udpClient did not receive entire response");
}
UInt32 recAction = UnpackHelper.UInt32(recBuf, 0, UnpackHelper.Endianness.Big);
UInt32 recTrasactionId = UnpackHelper.UInt32(recBuf, 4, UnpackHelper.Endianness.Big);
if (recAction != 0 || recTrasactionId != trasactionId)
{
throw new Exception("Invalid response from tracker");
}
this._currentConnectionId = CopyBytes(recBuf, 8, 8);
byte[] hashBytes = PackHelper.Hex(hash).ToArray();
Int32 key = this.Random.Next(0, 65535);
sendBuf = this._currentConnectionId. /*connection id*/
Concat(PackHelper.Int32(1)). /*action*/
Concat(PackHelper.Int32(trasactionId)). /*trasaction Id*/
Concat(hashBytes). /*hash*/
Concat(Encoding.ASCII.GetBytes(peerId)). /*my peer id*/
Concat(PackHelper.Int64(bytesDownloaded)). /*bytes downloaded*/
Concat(PackHelper.Int64(bytesLeft)). /*bytes left*/
Concat(PackHelper.Int64(bytesUploaded)). /*bytes uploaded*/
Concat(PackHelper.Int32(eventTypeFilter)). /*event, 0 for none, 2 for just started*/
Concat(PackHelper.Int32(ipAddress)). /*ip, 0 for this one*/
Concat(PackHelper.Int32(key)). /*unique key*/
Concat(PackHelper.Int32(numWant)). /*num want, -1 for as many as pos*/
Concat(PackHelper.Int32(listenPort)). /*listen port*/
Concat(PackHelper.Int32(extensions)).ToArray(); /*extensions*/
udpClient.Send(sendBuf, sendBuf.Length);
try
{
recBuf = udpClient.Receive(ref endPoint);
}
catch (Exception)
{
return(null);
}
recAction = UnpackHelper.UInt32(recBuf, 0, UnpackHelper.Endianness.Big);
recTrasactionId = UnpackHelper.UInt32(recBuf, 4, UnpackHelper.Endianness.Big);
int waitTime = (int)UnpackHelper.UInt32(recBuf, 8, UnpackHelper.Endianness.Big);
int Leechers = (int)UnpackHelper.UInt32(recBuf, 12, UnpackHelper.Endianness.Big);
int seeders = (int)UnpackHelper.UInt32(recBuf, 16, UnpackHelper.Endianness.Big);
if (recAction != 1 || recTrasactionId != trasactionId)
{
throw new Exception("Invalid response from tracker");
}
for (Int32 i = 20; i < recBuf.Length; i += 6)
{
UInt32 ip = UnpackHelper.UInt32(recBuf, i, UnpackHelper.Endianness.Big);
UInt16 port = UnpackHelper.UInt16(recBuf, i + 4, UnpackHelper.Endianness.Big);
returnValue.Add(new IPEndPoint(ip, port));
}
udpClient.Close();
return(new AnnounceInfo(returnValue, waitTime, seeders, Leechers));
}
public bool SendKeepAlive()
{
int sent = this.Socket.Send(PackHelper.Int32(0));
return(sent == 4);
}
