async void ReceiveAsync(UdpClient client, CancellationToken token)
{
while (!token.IsCancellationRequested)
{
try {
var result = await client.ReceiveAsync().ConfigureAwait(false);
var receiveString = Encoding.ASCII.GetString(result.Buffer);
var match = RegexMatcher.Match(receiveString);
if (!match.Success)
{
return;
}
int portcheck = Convert.ToInt32(match.Groups["port"].Value);
if (portcheck <= 0 || portcheck > 65535)
{
return;
}
var infoHash = InfoHash.FromHex(match.Groups["hash"].Value);
var uri = new Uri("ipv4://" + result.RemoteEndPoint.Address + ':' + portcheck);
PeerFound?.Invoke(this, new LocalPeerFoundEventArgs(infoHash, uri));
} catch {
}
}
}
public CustomTrackable(string pName, string pInfoHash)
{
name = pName;
var hash = InfoHash.FromHex(pInfoHash.Replace("-", ""));
infoHash = hash;
}
public override async void OnNavigatedTo(object parameter, NavigationMode mode, Dictionary <string, object> state)
{
if (mode == NavigationMode.Back)
{
_navigationService.GoBack();
return;
}
PlaybackTorrent = (PlaybackTorrent)parameter;
if (!string.IsNullOrEmpty(PlaybackTorrent.TorrentUrl))
{
State = TorrentStreamManager.State.Metadata;
var torrent = await Torrent.LoadAsync(new Uri(PlaybackTorrent.TorrentUrl), "");
_torrentStreamService.CreateManager(torrent);
}
else if (!string.IsNullOrEmpty(PlaybackTorrent.MagnetLink))
{
var magnetLink = new MagnetLink(PlaybackTorrent.MagnetLink);
_torrentStreamService.CreateManager(magnetLink);
}
else
{
var hash = InfoHash.FromHex(PlaybackTorrent.TorrentHash);
_torrentStreamService.CreateManager(hash);
}
_torrentStreamService.StreamManager.StreamProgress += StreamManagerOnStreamProgress;
_torrentStreamService.StreamManager.StreamReady += StreamManagerOnStreamReady;
_torrentStreamService.StreamManager.Error += StreamManagerOnError;
_torrentStreamService.StreamManager.StartDownload();
State = _torrentStreamService.StreamManager.CurrentState;
}
private void DatagramSocketOnMessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args)
{
try
{
var dataReader = args.GetDataReader();
var receiveBytes = new byte[dataReader.UnconsumedBufferLength];
dataReader.ReadBytes(receiveBytes);
var receiveString = Encoding.ASCII.GetString(receiveBytes);
var 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");
var match = exp.Match(receiveString);
if (!match.Success)
{
return;
}
var portcheck = Convert.ToInt32(match.Groups["port"].Value);
if (portcheck < 0 || portcheck > 65535)
{
return;
}
TorrentManager manager = null;
var matchHash = InfoHash.FromHex(match.Groups["hash"].Value);
for (var i = 0; manager == null && i < _engine.Torrents.Count; i++)
{
if (_engine.Torrents[i].InfoHash == matchHash)
{
manager = _engine.Torrents[i];
}
}
if (manager == null)
{
return;
}
var uri = new Uri("tcp://" + args.RemoteAddress.RawName + ':' + match.Groups["port"].Value);
var peer = new Peer("", uri, EncryptionTypes.All);
// Add new peer to matched Torrent
if (manager.HasMetadata && manager.Torrent.IsPrivate)
{
return;
}
ClientEngine.MainLoop.Queue(delegate
{
var count = manager.AddPeersCore(peer);
manager.RaisePeersFound(new LocalPeersAdded(manager, count, 1));
});
}
catch
{
// ignored
}
}
private void OnReceiveCallBack(IAsyncResult asyncResult)
{
var udpClient = (UdpClient) asyncResult.AsyncState;
var endPoint = new IPEndPoint(IPAddress.Any, 0);
try
{
var receiveBytes = udpClient.EndReceive(asyncResult, ref endPoint);
var receiveString = Encoding.ASCII.GetString(receiveBytes);
var 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");
var match = exp.Match(receiveString);
if (!match.Success)
return;
var portcheck = Convert.ToInt32(match.Groups["port"].Value);
if (portcheck < 0 || portcheck > 65535)
return;
TorrentManager manager = null;
var matchHash = InfoHash.FromHex(match.Groups["hash"].Value);
for (var i = 0; manager == null && i < _engine.Torrents.Count; i++)
if (_engine.Torrents[i].InfoHash == matchHash)
manager = _engine.Torrents[i];
if (manager == null)
return;
var uri = new Uri(string.Format("tcp://{0}{1}{2}", endPoint.Address, ':', match.Groups["port"].Value));
var peer = new Peer("", uri, EncryptionTypes.All);
// Add new peer to matched Torrent
if (!manager.HasMetadata || !manager.Torrent.IsPrivate)
{
ClientEngine.MainLoop.Queue(() =>
{
var count = manager.AddPeersCore(peer);
manager.RaisePeersFound(new LocalPeersAdded(manager, count, 1));
});
}
}
catch
{
// Failed to receive data, ignore
}
finally
{
try
{
udpClient.BeginReceive(OnReceiveCallBack, asyncResult.AsyncState);
}
catch
{
// It's closed
}
}
}
public void HexTest()
{
InfoHash hash = Create();
string hex = hash.ToHex();
Assert.AreEqual(40, hex.Length, "#1");
InfoHash other = InfoHash.FromHex(hex);
Assert.AreEqual(hash, other, "#2");
}
public static void Main(string[] args)
{
Listener listener = new UdpListener(new IPEndPoint(IPAddress.Any, 15000));
listener.Start();
DhtEngine engine = new DhtEngine(listener);
engine.PeersFound += EngineOnPeersFound;
engine.Start();
Thread.Sleep(25000);
engine.GetPeers(InfoHash.FromHex("b415c913643e5ff49fe37d304bbb5e6e11ad5101"));
Console.ReadLine();
}
async void ReceiveAsync(UdpClient client, CancellationToken token)
{
while (!token.IsCancellationRequested)
{
try {
UdpReceiveResult result = await client.ReceiveAsync().ConfigureAwait(false);
string[] receiveString = Encoding.ASCII.GetString(result.Buffer)
.Split(new[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
string portString = receiveString.FirstOrDefault(t => t.StartsWith("Port: ", StringComparison.Ordinal));
string hashString = receiveString.FirstOrDefault(t => t.StartsWith("Infohash: ", StringComparison.Ordinal));
string cookieString = receiveString.FirstOrDefault(t => t.StartsWith("cookie", StringComparison.Ordinal));
// An invalid response was received if these are missing.
if (portString == null || hashString == null)
{
continue;
}
// If we received our own cookie we can ignore the message.
if (cookieString != null && cookieString.Contains(Cookie))
{
continue;
}
// If the port is invalid, ignore it!
int portcheck = int.Parse(portString.Split(' ').Last());
if (portcheck <= 0 || portcheck > 65535)
{
continue;
}
var infoHash = InfoHash.FromHex(hashString.Split(' ').Last());
var uri = new Uri($"ipv4://{result.RemoteEndPoint.Address}{':'}{portcheck}");
PeerFound?.InvokeAsync(this, new LocalPeerFoundEventArgs(infoHash, uri));
} catch (FileNotFoundException) {
throw;
} catch {
}
}
}
public static void Main()
{
//https://wiki.theory.org/BitTorrentSpecification
Listener listener = new UdpListener(new IPEndPoint(IPAddress.Any, 15000));
listener.Start();
DhtEngine engine = new DhtEngine(listener);
engine.Start();
//Wait for the DHT to startup
Task.Delay(30000).Wait();
engine.PeersFound += EngineOnPeersFound;
engine.GetPeers(InfoHash.FromHex("0403FB4728BD788FBCB67E87D6FEB241EF38C75A"));
Console.ReadLine();
}
public static InfoHash ToInfoHash(this Magnet magnet)
{
if (string.IsNullOrEmpty(magnet.BTIH))
{
throw new InvalidDataException("Unable to create InfoHash. Expected bit torrent info hash but null or empty");
}
if (magnet.BTIH.Length == 40)
{
return(InfoHash.FromHex(magnet.BTIH));
}
if (magnet.BTIH.Length == 32)
{
return(InfoHash.FromBase32(magnet.BTIH));
}
throw new InvalidDataException("Unknown type of hash provided. Expected BTIH of length 32 or 40 chars");
}
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 void NullHex()
{
InfoHash.FromHex(null);
}
public void InvalidHex()
{
InfoHash.FromHex("123123123123123123123");
}
public void InvalidHex()
{
Assert.Throws <ArgumentException>(() => InfoHash.FromHex("123123123123123123123"));
}
public void NullHex()
{
Assert.Throws <ArgumentNullException>(() => InfoHash.FromHex(null));
}
public static string BuildPublicMagnetLink(string infoHash, string releaseTitle)
{
return(new MagnetLink(InfoHash.FromHex(infoHash), releaseTitle, _trackers).ToV1String());
}
static async Task MainAsync(string[] args, CancellationToken token)
{
// Give an example of how settings can be modified for the engine.
var settingBuilder = new EngineSettingsBuilder {
// Allow the engine to automatically forward ports using upnp/nat-pmp (if a compatible router is available)
AllowPortForwarding = true,
// Automatically save a cache of the DHT table when all torrents are stopped.
AutoSaveLoadDhtCache = true,
// Automatically save 'FastResume' data when TorrentManager.StopAsync is invoked, automatically load it
// before hash checking the torrent. Fast Resume data will be loaded as part of 'engine.AddAsync' if
// torrent metadata is available. Otherwise, if a magnetlink is used to download a torrent, fast resume
// data will be loaded after the metadata has been downloaded.
AutoSaveLoadFastResume = true,
// If a MagnetLink is used to download a torrent, the engine will try to load a copy of the metadata
// it's cache directory. Otherwise the metadata will be downloaded and stored in the cache directory
// so it can be reloaded later.
AutoSaveLoadMagnetLinkMetadata = true,
// Use a fixed port to accept incoming connections from other peers for testing purposes. Production usages should use a random port, 0, if possible.
ListenEndPoint = new IPEndPoint(IPAddress.Any, 55123),
// Use a fixed port for DHT communications for testing purposes. Production usages should use a random port, 0, if possible.
DhtEndPoint = new IPEndPoint(IPAddress.Any, 55123),
};
using var engine = new ClientEngine(settingBuilder.ToSettings());
Task task;
if (args.Length == 1 && args[0] == "--vlc")
{
task = new VLCStream(engine).StreamAsync(InfoHash.FromHex("AEE0F0082CC2F449412C1DD8AF4C58D9AAEE4B5C"), token);
}
else if (args.Length == 1 && MagnetLink.TryParse(args[0], out MagnetLink link))
{
task = new MagnetLinkStreaming(engine).DownloadAsync(link, token);
}
else
{
task = new StandardDownloader(engine).DownloadAsync(token);
}
if (engine.Settings.AllowPortForwarding)
{
Console.WriteLine("uPnP or NAT-PMP port mappings will be created for any ports needed by MonoTorrent");
}
try {
await task;
} catch (OperationCanceledException) {
}
foreach (var manager in engine.Torrents)
{
var stoppingTask = manager.StopAsync();
while (manager.State != TorrentState.Stopped)
{
Console.WriteLine("{0} is {1}", manager.Torrent.Name, manager.State);
await Task.WhenAll(stoppingTask, Task.Delay(250));
}
await stoppingTask;
if (engine.Settings.AutoSaveLoadFastResume)
{
Console.WriteLine($"FastResume data for {manager.Torrent?.Name ?? manager.InfoHash.ToHex ()} has been written to disk.");
}
}
if (engine.Settings.AutoSaveLoadDhtCache)
{
Console.WriteLine($"DHT cache has been written to disk.");
}
if (engine.Settings.AllowPortForwarding)
{
Console.WriteLine("uPnP and NAT-PMP port mappings have been removed");
}
}
