public MessageHandlingTests()
{
listener = new TestListener();
node = new Node(NodeId.Create(), new IPEndPoint(IPAddress.Any, 0));
engine = new DhtEngine(listener);
//engine.Add(node);
}
static void Main(string[] args)
{
UdpListener listener = new UdpListener(new IPEndPoint(IPAddress.Parse("192.168.0.6"), 15000));
DhtEngine engine = new DhtEngine(listener);
byte[] nodes = null;
if (File.Exists("mynodes"))
nodes = File.ReadAllBytes("mynodes");
listener.Start();
engine.PeersFound += delegate(object o, PeersFoundEventArgs e) {
Console.WriteLine("I FOUND PEERS: {0}", e.Peers.Count);
engine.Start(nodes);
Random random = new Random(5);
byte[] b = new byte[20];
lock (random)
random.NextBytes(b);
while(Console.ReadLine() != "q")
{
for (int i = 0; i < 30; i++)
{
Console.WriteLine("Waiting: {0} seconds left", (30 - i));
System.Threading.Thread.Sleep(1000);
}
// Get some peers for the torrent
engine.GetPeers(b);
random.NextBytes(b);
}
File.WriteAllBytes("mynodes", engine.SaveNodes());
}
}
public void Setup()
{
listener = new TestListener();
node = new Node(NodeId.Create(), new IPEndPoint(IPAddress.Any, 0));
engine = new DhtEngine(listener);
//engine.Add(node);
}
public void Setup()
{
counter = 0;
listener = new TestListener();
engine = new DhtEngine(listener);
node = new Node(NodeId.Create(), new IPEndPoint(IPAddress.Any, 4));
handle = new ManualResetEvent(false);
}
public Dht()
{
listener = new DhtListener (new IPEndPoint (IPAddress.Any, 35800));
engine = new DhtEngine (listener);
engine.StateChanged += delegate { UpdateText (); };
GLib.Timeout.Add (5000, delegate {
UpdateText ();
return true;
});
}
public DhtBasedSwarm(InfoHash hash, int port, string nodeSavePath)
: base(hash,port)
{
_nodeSavePath = nodeSavePath;
_listener = new DhtListener(new IPEndPoint(IPAddress.Any, Port));
_engine = new DhtEngine(_listener);
_engine.PeersFound += EnginePeersFound;
_engine.StateChanged += EngineStateChanged;
_listener.MessageReceived += ListenerMessageReceived;
if (!String.IsNullOrWhiteSpace(_nodeSavePath) && File.Exists(_nodeSavePath))
{
Log("Node File Found.");
_nodes = File.ReadAllBytes(_nodeSavePath);
}
}
public MessageLoop(DhtEngine engine, DhtListener listener)
{
this.engine = engine;
this.listener = listener;
listener.MessageReceived += new MessageReceived(MessageReceived);
DhtEngine.MainLoop.QueueTimeout(TimeSpan.FromMilliseconds(5), delegate {
if (engine.Disposed)
return false;
SendMessage();
ReceiveMessage();
TimeoutMessage();
return !engine.Disposed;
});
}
public void Initialize()
{
Torrents = new ObservableCollection<PeriodicTorrent>();
// TODO: Customize most of these settings
var settings = new EngineSettings(Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "Downloads"), 22239);
settings.PreferEncryption = true;
settings.AllowedEncryption = EncryptionTypes.RC4Full | EncryptionTypes.RC4Header;
Client = new ClientEngine(settings);
Client.ChangeListenEndpoint(new IPEndPoint(IPAddress.Any, 22239));
var listener = new DhtListener(new IPEndPoint(IPAddress.Any, 22239));
var dht = new DhtEngine(listener);
Client.RegisterDht(dht);
listener.Start();
if (File.Exists(SettingsManager.DhtCachePath))
dht.Start(File.ReadAllBytes(SettingsManager.DhtCachePath));
else
dht.Start();
}
public MessageLoop(DhtEngine engine, DhtListener listener)
{
this.engine = engine;
this.listener = listener;
listener.MessageReceived += new MessageReceived(MessageReceived);
DhtEngine.MainLoop.QueueTimeout(TimeSpan.FromMilliseconds(5), delegate {
if (engine.Disposed)
return false;
try
{
SendMessage();
ReceiveMessage();
TimeoutMessage();
}
catch (Exception ex)
{
Debug.WriteLine("Error in DHT main loop:");
Debug.WriteLine(ex);
}
return !engine.Disposed;
});
}
/// <summary>
///
/// </summary>
private void InitializeEngine()
{
int port = 60606;
EngineSettings engineSettings = new EngineSettings(downloadDir, port)
{
PreferEncryption = false,
AllowedEncryption = MonoTorrent.Client.Encryption.EncryptionTypes.All
};
this.clientEngine = new ClientEngine(engineSettings);
// Change to loopback, perhaps?
this.clientEngine.ChangeListenEndpoint(new IPEndPoint(IPAddress.Any, port));
byte[] nodes = null;
try
{
nodes = File.ReadAllBytes(dhtNodeFile);
}
catch (Exception e)
{
Console.WriteLine("No existing DHT nodes could be loaded: {0}", e.Message);
}
DhtListener dhtListener = new DhtListener(new IPEndPoint(IPAddress.Any, port));
DhtEngine dhtEngine = new DhtEngine(dhtListener);
this.clientEngine.RegisterDht(dhtEngine);
dhtListener.Start();
this.clientEngine.DhtEngine.Start(nodes);
// If the SavePath does not exist, we want to create it.
if (!Directory.Exists(this.clientEngine.Settings.SavePath))
{
Directory.CreateDirectory(this.clientEngine.Settings.SavePath);
}
}
private void DownloaderWorker_DoWork(object sender, DoWorkEventArgs e)
{
try
{
if (e.Argument == null)
return;
basePath = Environment.CurrentDirectory;
dhtNodeFile = System.IO.Path.Combine(basePath, "DhtNodes");
downloadsPath = System.IO.Path.Combine(basePath, "Downloads");
torrentsPath = System.IO.Path.Combine(basePath, "Torrents");
fastResumeFile = System.IO.Path.Combine(torrentsPath, "fastresume.data");
torrents = new List<TorrentManager>(); // The list where all the torrentManagers will be stored that the engine gives us
listener = new Top10Listener(10);
string torrentpath = e.Argument.ToString();
int port = 6969;
Torrent torrent = null;
// Create the settings which the engine will use
// downloadsPath - this is the path where we will save all the files to
// port - this is the port we listen for connections on
EngineSettings engineSettings = new EngineSettings(downloadsPath, port);
engineSettings.PreferEncryption = false;
engineSettings.AllowedEncryption = EncryptionTypes.All;
//engineSettings.GlobalMaxUploadSpeed = 30 * 1024;
//engineSettings.GlobalMaxDownloadSpeed = 100 * 1024;
//engineSettings.MaxReadRate = 1 * 1024 * 1024;
// Create the default settings which a torrent will have.
// 4 Upload slots - a good ratio is one slot per 5kB of upload speed
// 50 open connections - should never really need to be changed
// Unlimited download speed - valid range from 0 -> int.Max
// Unlimited upload speed - valid range from 0 -> int.Max
TorrentSettings torrentDefaults = new TorrentSettings(4, 150, 0, 0);
// Create an instance of the engine.
engine = new ClientEngine(engineSettings);
engine.ChangeListenEndpoint(new IPEndPoint(IPAddress.Any, port));
byte[] nodes = null;
try
{
nodes = File.ReadAllBytes(dhtNodeFile);
}
catch
{
Console.WriteLine("No existing dht nodes could be loaded");
}
DhtListener dhtListner = new DhtListener(new IPEndPoint(IPAddress.Any, port));
DhtEngine dht = new DhtEngine(dhtListner);
engine.RegisterDht(dht);
dhtListner.Start();
engine.DhtEngine.Start(nodes);
// If the SavePath does not exist, we want to create it.
if (!Directory.Exists(engine.Settings.SavePath))
Directory.CreateDirectory(engine.Settings.SavePath);
// If the torrentsPath does not exist, we want to create it
if (!Directory.Exists(torrentsPath))
Directory.CreateDirectory(torrentsPath);
BEncodedDictionary fastResume;
try
{
fastResume = BEncodedValue.Decode<BEncodedDictionary>(File.ReadAllBytes(fastResumeFile));
}
catch
{
fastResume = new BEncodedDictionary();
}
// Load the .torrent from the file into a Torrent instance
// You can use this to do preprocessing should you need to
torrent = Torrent.Load(torrentpath);
// When any preprocessing has been completed, you create a TorrentManager
// which you then register with the engine.
TorrentManager manager = new TorrentManager(torrent, downloadsPath, torrentDefaults);
//if (fastResume.ContainsKey(torrent.InfoHash.ToHex()))
// manager.LoadFastResume(new FastResume((BEncodedDictionary)fastResume[torrent.infoHash.ToHex()]));
engine.Register(manager);
// Store the torrent manager in our list so we can access it later
torrents.Add(manager);
manager.PeersFound += new EventHandler<PeersAddedEventArgs>(manager_PeersFound);
// Every time a piece is hashed, this is fired.
manager.PieceHashed += delegate (object o, PieceHashedEventArgs ec)
{
lock (listener)
listener.WriteLine(string.Format("Piece Hashed: {0} - {1}", ec.PieceIndex, ec.HashPassed ? "Pass" : "Fail"));
};
// Every time the state changes (Stopped -> Seeding -> Downloading -> Hashing) this is fired
manager.TorrentStateChanged += delegate (object o, TorrentStateChangedEventArgs ev)
{
lock (listener)
listener.WriteLine("OldState: " + ev.OldState.ToString() + " NewState: " + ev.NewState.ToString());
};
// Every time the tracker's state changes, this is fired
//foreach (TrackerTier tier in manager.TrackerManager)
//{
// //foreach (MonoTorrent.Client.Tracker.Tracker t in tier.Trackers)
// //{
// // t.AnnounceComplete += delegate (object sender, AnnounceResponseEventArgs e)
// // {
// // listener.WriteLine(string.Format("{0}: {1}", e.Successful, e.Tracker.ToString()));
// // };
// //}
//}
// Start the torrentmanager. The file will then hash (if required) and begin downloading/seeding
manager.Start();
// While the torrents are still running, print out some stats to the screen.
// Details for all the loaded torrent managers are shown.
bool running = true;
StringBuilder sb = new StringBuilder(1024);
while (running)
{
//if ((i++) % 10 == 0)
//{
sb.Remove(0, sb.Length);
running = torrents.Exists(delegate (TorrentManager m) { return m.State != TorrentState.Stopped; });
//AppendFormat(sb, "Total Download Rate: {0:0.00}kB/sec", engine.TotalDownloadSpeed / 1024.0);
downloadspeed = (engine.TotalDownloadSpeed / 1024.0).ToString();
//AppendFormat(sb, "Total Upload Rate: {0:0.00}kB/sec", engine.TotalUploadSpeed / 1024.0);
//AppendFormat(sb, "Disk Read Rate: {0:0.00} kB/s", engine.DiskManager.ReadRate / 1024.0);
//AppendFormat(sb, "Disk Write Rate: {0:0.00} kB/s", engine.DiskManager.WriteRate / 1024.0);
//AppendFormat(sb, "Total Read: {0:0.00} kB", engine.DiskManager.TotalRead / 1024.0);
//AppendFormat(sb, "Total Written: {0:0.00} kB", engine.DiskManager.TotalWritten / 1024.0);
//AppendFormat(sb, "Open Connections: {0}", engine.ConnectionManager.OpenConnections);
//AppendSeperator(sb);
//AppendFormat(sb, "State: {0}", manager.State);
//AppendFormat(sb, "Name: {0}", manager.Torrent == null ? "MetaDataMode" : manager.Torrent.Name);
//AppendFormat(sb, "Progress: {0:0.00}", manager.Progress);
//progress = manager.Progress.ToString();
//AppendFormat(sb, "Download Speed: {0:0.00} kB/s", manager.Monitor.DownloadSpeed / 1024.0);
//AppendFormat(sb, "Upload Speed: {0:0.00} kB/s", manager.Monitor.UploadSpeed / 1024.0);
//AppendFormat(sb, "Total Downloaded: {0:0.00} MB", manager.Monitor.DataBytesDownloaded / (1024.0 * 1024.0));
//AppendFormat(sb, "Total Uploaded: {0:0.00} MB", manager.Monitor.DataBytesUploaded / (1024.0 * 1024.0));
MonoTorrent.Client.Tracker.Tracker tracker = manager.TrackerManager.CurrentTracker;
//AppendFormat(sb, "Tracker Status: {0}", tracker == null ? "<no tracker>" : tracker.State.ToString());
//AppendFormat(sb, "Warning Message: {0}", tracker == null ? "<no tracker>" : tracker.WarningMessage);
//AppendFormat(sb, "Failure Message: {0}", tracker == null ? "<no tracker>" : tracker.FailureMessage);
//if (manager.PieceManager != null)
// AppendFormat(sb, "Current Requests: {0}", manager.PieceManager.CurrentRequestCount());
//foreach (PeerId p in manager.GetPeers())
// AppendFormat(sb, "\t{2} - {1:0.00}/{3:0.00}kB/sec - {0}", p.Peer.ConnectionUri,
// p.Monitor.DownloadSpeed / 1024.0,
// p.AmRequestingPiecesCount,
// p.Monitor.UploadSpeed / 1024.0);
//AppendFormat(sb, "", null);
//if (manager.Torrent != null)
// foreach (TorrentFile file in manager.Torrent.Files)
// AppendFormat(sb, "{1:0.00}% - {0}", file.Path, file.BitField.PercentComplete);
//Console.Clear();
//Console.WriteLine(sb.ToString());
//listener.ExportTo(Console.Out);
//}
DownloaderWorker.ReportProgress(Convert.ToInt32(manager.Progress), manager.State.ToString());
System.Threading.Thread.Sleep(500);
}
}
catch (Exception ex)
{
}
}
private void RunTorrents()
{
TorrentOptions tOpts = UserSettings.Current.TorrentOptions;
if (globalEngine == null)
{
int listenPort = tOpts.ListeningPort;
string mainDownloadsPath = UserSettings.ContentDataPath;
// Create the settings which the engine will use
// downloadsPath - this is the path where we will save all the files to
// port - this is the port we listen for connections on
var engineSettings = new EngineSettings(mainDownloadsPath, listenPort);
engineSettings.PreferEncryption = true;
engineSettings.AllowedEncryption = EncryptionTypes.All;
engineSettings.GlobalMaxConnections = tOpts.MaxDLConnsNormalized;
engineSettings.GlobalMaxDownloadSpeed = tOpts.MaxDLSpeed*1024;
engineSettings.GlobalMaxHalfOpenConnections = 10;
engineSettings.GlobalMaxUploadSpeed = tOpts.MaxULSpeed*1024;
// Create an instance of the engine.
globalEngine = new ClientEngine(engineSettings);
globalEngine.ChangeListenEndpoint(new IPEndPoint(IPAddress.Any, listenPort));
engineListenPort = listenPort;
EngineStartedOnPort(engineListenPort);
//create a DHT engine and register it with the main engine
{
var dhtListener = new DhtListener(new IPEndPoint(IPAddress.Any, listenPort));
var dhtEngine = new DhtEngine(dhtListener);
dhtListener.Start();
string dhtNodesFileName = "";
byte[] dhtNodesData = null;
try
{
dhtNodesFileName = GetDhtNodesFileName();
if (File.Exists(dhtNodesFileName))
dhtNodesData = File.ReadAllBytes(dhtNodesFileName);
}
catch (Exception ex)
{
Console.WriteLine("Error loading dht nodes file '{0}', reason: {1}", dhtNodesFileName, ex.Message);
dhtNodesData = null;
}
dhtEngine.Start(dhtNodesData);
globalEngine.RegisterDht(dhtEngine);
// We need to cleanup correctly when the user closes the window by using ctrl-c
// or an unhandled exception happens
Console.CancelKeyPress += delegate { EngineShutdown(); };
AppDomain.CurrentDomain.ProcessExit += delegate { EngineShutdown(); };
AppDomain.CurrentDomain.UnhandledException += delegate(object sender, UnhandledExceptionEventArgs e)
{
Console.WriteLine(e.ExceptionObject);
EngineShutdown();
};
Thread.GetDomain().UnhandledException += delegate(object sender, UnhandledExceptionEventArgs e)
{
Console.WriteLine(e.ExceptionObject);
EngineShutdown();
};
}
}
else
StopAllTorrents();
// Create the default settings which a torrent will have.
var torrentDefaults = new TorrentSettings(tOpts.NumULSlotsNormalized);
torrentDefaults.UseDht = true;
torrentDefaults.EnablePeerExchange = true;
// For each file in the torrents path that is a .torrent file, load it into the engine.
var managers = new List<TorrentManager>();
foreach (AddOnTorrent newAddOn in addOnTorrents)
{
Torrent torrent = null;
try
{
torrent = Torrent.Load(File.ReadAllBytes(newAddOn.torrentFileName));
}
catch (Exception ex)
{
updater.Status = "Error loading torrent file";
downloader.Status = ex.Message;
downloader.IsRunning = false;
return;
}
try
{
var fullFilePaths = new List<String>();
{
TorrentFile[] torrentFiles = torrent.Files;
foreach (TorrentFile theFile in torrentFiles)
fullFilePaths.Add(Path.Combine(newAddOn.torrentSavePath, theFile.Path));
}
if (Directory.Exists(newAddOn.torrentSavePath))
{
string[] actualFilePaths = Directory.GetFiles(newAddOn.torrentSavePath, "*.*", SearchOption.AllDirectories);
foreach (string realPath in actualFilePaths)
{
var fileInfo = new FileInfo(realPath);
if (
fullFilePaths.Count(
path => { return path.Equals(fileInfo.FullName, StringComparison.InvariantCultureIgnoreCase); }) < 1)
{
//this is an unwanted file
if (fileInfo.IsReadOnly)
{
fileInfo.IsReadOnly = false;
fileInfo.Refresh();
}
fileInfo.Delete();
}
}
}
}
catch (Exception ex)
{
updater.Status = "Error deleting unwanted file";
downloader.Status = ex.Message;
downloader.IsRunning = false;
return;
}
TorrentManager tm = null;
try
{
tm = new TorrentManager(torrent, globalEngine.Settings.SavePath, torrentDefaults, newAddOn.torrentSavePath);
if (!fullSystemCheck && !UserSettings.Current.TorrentOptions.DisableFastResume)
//load the fast resume file for this torrent
{
string fastResumeFilepath = GetFastResumeFileName(tm);
if (File.Exists(fastResumeFilepath))
{
var bencoded = BEncodedValue.Decode<BEncodedDictionary>(File.ReadAllBytes(fastResumeFilepath));
tm.LoadFastResume(new FastResume(bencoded));
}
}
}
catch (Exception ex)
{
if (tm == null) //only if critical failure
{
updater.Status = "Error creating torrent manager";
downloader.Status = ex.Message;
downloader.IsRunning = false;
return;
}
}
managers.Add(tm);
}
// If we loaded no torrents, just stop.
if (managers.Count < 1)
{
updater.Status = "Torrent engine error";
downloader.Status = "No torrents have been found";
downloader.IsRunning = false;
return;
}
try
{
File.WriteAllText(UserSettings.ContentCurrentTagFile, versionString);
CalculatedGameSettings.Current.Update();
}
catch (Exception ex)
{
updater.Status = "Tag file write error";
downloader.Status = ex.Message;
downloader.IsRunning = false;
return;
}
// Before starting all the managers, clear out the fastresume data
// The torrents currently running already have it loaded, and will save it out on stop/finish
// So this only clears out fastresume for torrents we aren't currently running, which is what we want
IEnumerable<string> staleFastResume = Directory.EnumerateFiles(UserSettings.TorrentJunkPath, "fastresume_*.benc",
SearchOption.TopDirectoryOnly);
foreach (string sfr in staleFastResume)
{
try
{
File.Delete(sfr);
}
catch (Exception)
{
}
}
foreach (TorrentManager manager in managers)
{
// Add this manager to the global torrent engine
globalEngine.Register(manager);
// Every time a new peer is added, this is fired.
manager.PeersFound += delegate { };
// Every time a piece is hashed, this is fired.
manager.PieceHashed += delegate { };
// Every time the state changes (Stopped -> Seeding -> Downloading -> Hashing) this is fired
manager.TorrentStateChanged += OnTorrentStateChanged;
// Every time the tracker's state changes, this is fired
foreach (TrackerTier tier in manager.TrackerManager)
{
}
manager.Start();
}
// While the torrents are still running, print out some stats to the screen.
// Details for all the loaded torrent managers are shown.
int i = 0;
bool running = true;
var sb = new StringBuilder(1024);
DateTime lastAnnounce = DateTime.Now;
bool firstRun = true;
while (running && globalEngine != null)
{
IList<TorrentManager> engineTorrents = globalEngine.Torrents;
if (firstRun || lastAnnounce < DateTime.Now.AddMinutes(-1))
{
foreach (TorrentManager tm in engineTorrents)
tm.TrackerManager.Announce();
lastAnnounce = DateTime.Now;
firstRun = false;
}
if ((i++)%2 == 0)
{
sb.Remove(0, sb.Length);
running = engineTorrents.Count(m => { return m.State != TorrentState.Stopped; }) > 0;
var totalState = TorrentState.Stopped;
if (engineTorrents.Count(m => m.State == TorrentState.Hashing) > 0)
totalState = TorrentState.Hashing;
else if (engineTorrents.Count(m => m.State == TorrentState.Downloading) > 0)
totalState = TorrentState.Downloading;
else if (engineTorrents.Count(m => m.State == TorrentState.Seeding) > 0)
totalState = TorrentState.Seeding;
string status = "";
try
{
switch (totalState)
{
case TorrentState.Hashing:
{
double totalHashingBytes = 0;
double totalHashedBytes = 0;
foreach (TorrentManager m in engineTorrents)
{
totalHashingBytes += m.Torrent.Size;
if (m.State == TorrentState.Hashing)
totalHashedBytes += m.Torrent.Size*(m.Progress/100);
else
totalHashedBytes += m.Torrent.Size;
}
double totalHashProgress = totalHashedBytes/totalHashingBytes;
status = String.Format("Checking files ({0:0.00}%)", totalHashProgress*100);
StatusCallbacks(TorrentState.Hashing, totalHashProgress);
}
break;
case TorrentState.Downloading:
{
double totalToDownload = 0;
double totalDownloaded = 0;
double totalDownloadSpeed = 0;
double totalUploadSpeed = 0;
int totalDownloadConns = 0;
int totalUploadConns = 0;
foreach (TorrentManager m in engineTorrents)
{
totalToDownload += m.Torrent.Size;
totalDownloaded += m.Torrent.Size*(m.Progress/100);
totalDownloadSpeed += m.Monitor.DownloadSpeed;
totalUploadSpeed += m.Monitor.UploadSpeed;
totalDownloadConns += m.OpenConnections;
totalUploadConns += m.UploadingTo;
}
double totalDownloadProgress = totalDownloaded/totalToDownload;
status = "Status: " +
((engineTorrents.Count(m => m.State == TorrentState.Downloading && m.GetPeers().Count > 0) > 0)
? "Downloading"
: "Finding peers");
status += "\n" + String.Format("Progress: {0:0.00}%", totalDownloadProgress*100);
status += "\n" + String.Format("Download({1}): {0:0.00} KiB/s", totalDownloadSpeed/1024.0, totalDownloadConns);
status += "\n" + String.Format("Upload({1}): {0:0.00} KiB/s", totalUploadSpeed/1024.0, totalUploadConns);
StatusCallbacks(TorrentState.Downloading, totalDownloadProgress);
}
break;
case TorrentState.Seeding:
{
double totalUploadSpeed = 0;
int totalUploadPeers = 0;
foreach (TorrentManager tm in engineTorrents)
{
totalUploadSpeed += tm.Monitor.UploadSpeed;
totalUploadPeers += tm.UploadingTo;
}
status = String.Format("Seeding({1}): {0:0.00} KiB/s", totalUploadSpeed/1024.0, totalUploadPeers);
StatusCallbacks(TorrentState.Seeding, 1);
if (UserSettings.Current.TorrentOptions.StopSeeding)
globalEngine.StopAll();
}
break;
default:
status = totalState.ToString();
break;
}
}
catch (Exception ex)
{
status = ex.Message;
}
if (downloader != null)
downloader.Status = status;
}
Thread.Sleep(50);
}
}
public static void ReconfigureEngine()
{
if (globalEngine != null)
{
TorrentOptions tOpts = UserSettings.Current.TorrentOptions;
if (engineListenPort != tOpts.ListeningPort)
{
byte[] dhtNodesData = null;
{
IDhtEngine oldDhtEngine = globalEngine.DhtEngine;
if (oldDhtEngine != null)
{
dhtNodesData = oldDhtEngine.SaveNodes();
oldDhtEngine.Stop();
globalEngine.RegisterDht(null);
if (!oldDhtEngine.Disposed)
oldDhtEngine.Dispose();
}
oldDhtEngine = null;
}
EngineStoppedOnPort(engineListenPort);
engineListenPort = tOpts.ListeningPort;
globalEngine.ChangeListenEndpoint(new IPEndPoint(IPAddress.Any, engineListenPort));
var dhtListener = new DhtListener(new IPEndPoint(IPAddress.Any, engineListenPort));
var dhtEngine = new DhtEngine(dhtListener);
dhtEngine.Start(dhtNodesData);
globalEngine.RegisterDht(dhtEngine);
EngineStartedOnPort(engineListenPort);
}
else if (!portsMapped.Contains(engineListenPort) && !portsToMap.Contains(engineListenPort) &&
UserSettings.Current.TorrentOptions.EnableUpnp) //we just enabled upnp
{
EngineStartedOnPort(engineListenPort);
}
else if (!UserSettings.Current.TorrentOptions.EnableUpnp) //we just disabled upnp
{
EngineStoppedOnPort(engineListenPort);
}
EngineSettings engSets = globalEngine.Settings;
engSets.GlobalMaxConnections = tOpts.MaxDLConnsNormalized;
engSets.GlobalMaxDownloadSpeed = tOpts.MaxDLSpeed*1024;
engSets.GlobalMaxUploadSpeed = tOpts.MaxULSpeed*1024;
IList<TorrentManager> engineTorrents = globalEngine.Torrents;
foreach (TorrentManager tm in engineTorrents)
tm.Settings.UploadSlots = tOpts.NumULSlotsNormalized;
}
}
public void StartDht( int port)
{
// Send/receive DHT messages on the specified port
IPEndPoint listenAddress = new IPEndPoint (IPAddress.Any, port);
// Create a listener which will process incoming/outgoing dht messages
listener = new MonoTorrent.Dht.Listeners.DhtListener(listenAddress);
// Create the dht engine
DhtEngine de = new DhtEngine (listener);
de.StateChanged += HandleDeStateChanged;
// Connect the Dht engine to the MonoTorrent engine
engine.RegisterDht (de);
// Start listening for dht messages and activate the DHT engine
listener.Start ();
// If there are existing DHT nodes stored on disk, load them
// into the DHT engine so we can try and avoid a (very slow)
// full bootstrap
byte[] nodes = null;
if (File.Exists (dhtpath))
nodes = File.ReadAllBytes (dhtpath);
de.Start (nodes);
}
public ClientEngine(EngineSettings settings, PeerListener listener, PieceWriter writer)
{
Check.Settings(settings);
Check.Listener(listener);
Check.Writer(writer);
this.listener = listener;
this.settings = settings;
this.connectionManager = new ConnectionManager(this);
this.dhtListener = new UdpListener(new IPEndPoint(IPAddress.Any, settings.ListenPort));
this.dhtEngine = new DhtEngine(dhtListener);
this.diskManager = new DiskManager(this, writer);
this.listenManager = new ListenManager(this);
MainLoop.QueueTimeout(TimeSpan.FromMilliseconds(TickLength), delegate {
if (IsRunning && !disposed)
LogicTick();
return !disposed;
});
this.torrents = new MonoTorrentCollection<TorrentManager>();
this.downloadLimiter = new RateLimiter();
this.uploadLimiter = new RateLimiter();
this.peerId = GeneratePeerId();
listenManager.Register(listener);
dhtEngine.StateChanged += delegate {
if (dhtEngine.State != State.Ready)
return;
MainLoop.Queue(delegate {
foreach (TorrentManager manager in torrents)
{
if (!manager.CanUseDht)
continue;
dhtEngine.Announce(manager.Torrent.infoHash, Listener.Endpoint.Port);
dhtEngine.GetPeers(manager.Torrent.infoHash);
}
});
};
// This means we created the listener in the constructor
if (listener.Endpoint.Port == 0)
listener.ChangeEndpoint(new IPEndPoint(IPAddress.Any, settings.ListenPort));
listener.Start();
}
void SettingsManager_PropertyChanged(object sender, PropertyChangedEventArgs e)
{
switch (e.PropertyName)
{
case "IncomingPort":
Client.Listener.ChangeEndpoint(new IPEndPoint(IPAddress.Any, SettingsManager.IncomingPort));
break;
case "MapWithUPnP":
// TODO: UPnP
break;
case "MaxUploadSpeed":
Client.Settings.GlobalMaxUploadSpeed = SettingsManager.MaxUploadSpeed * 1024;
break;
case "MaxDownloadSpeed":
Client.Settings.GlobalMaxDownloadSpeed = SettingsManager.MaxDownloadSpeed * 1024;
break;
case "MaxConnections":
Client.Settings.GlobalMaxConnections = SettingsManager.MaxConnections;
break;
case "EnableDHT":
if (SettingsManager.EnableDHT)
{
var port = SettingsManager.IncomingPort;
if (SettingsManager.UseRandomPort)
port = new Random().Next(1, 65536);
var listener = new DhtListener(new IPEndPoint(IPAddress.Any, port));
var dht = new DhtEngine(listener);
Client.RegisterDht(dht);
listener.Start();
if (File.Exists(SettingsManager.DhtCachePath))
dht.Start(File.ReadAllBytes(SettingsManager.DhtCachePath));
else
dht.Start();
}
else
Client.DhtEngine.Stop();
break;
case "EncryptionSettings":
Client.Settings.AllowedEncryption = SettingsManager.EncryptionSettings;
break;
}
}
public override void Handle(DhtEngine engine, Node node)
{
base.Handle(engine, node);
throw new MessageException(ErrorCode, Message);
}
void Start()
{
//Start Torrent Engine
torrents = new List<TorrentManager>();
messages = new List<SimpleMessage>();
//Torrents to remove
seedingLimitTorrents = new List<Tuple<DateTime, TorrentManager>>();
Console.WriteLine("simpletorrent: version {0}", VERSION);
Console.WriteLine("simpletorrent: Reading configuration file (simple.cfg)...");
config = new SimpleConfiguration("simple.cfg");
string basePath = Path.GetDirectoryName(System.Reflection.Assembly.GetEntryAssembly().Location);
Console.WriteLine("simpletorrent: ApplicationPath (derived) {0}", basePath);
if (config.HasValue("Debug"))
{
debugWriter = new DebugWriter(true);
Console.WriteLine("simpletorrent: Debugging Enabled!");
}
else
{
debugWriter = new DebugWriter(false);
}
PlatformID os = Environment.OSVersion.Platform;
if (os == PlatformID.MacOSX)
{
Console.WriteLine("simpletorrent: We think we're on MacOSX");
simpleOperatingSystem = SimpleTorrentOperatingMode.MacOSX;
}
else if (os == PlatformID.Unix)
{
Console.WriteLine("simpletorrent: We think we're on *nix");
simpleOperatingSystem = SimpleTorrentOperatingMode.StarNix;
}
else
{
Console.WriteLine("simpletorrent: We think we're on Windows");
simpleOperatingSystem = SimpleTorrentOperatingMode.Windows;
}
torrentsPath = Path.GetFullPath(config.GetValue("TorrentPath", Path.Combine(basePath, "Torrents")));
downloadsPath = Path.GetFullPath(config.GetValue("DownloadPath", Path.Combine(basePath, "Downloads")));
sslCertificatePath = Path.GetFullPath(config.GetValue("SslCertificatePath", Path.Combine(basePath, "simple.pfx")));
useECDSA = config.HasValue("SslCertificateECDSA");
fastResumeFile = Path.Combine(torrentsPath, "fastresume.data");
dhtNodeFile = Path.Combine(torrentsPath, "dht.data");
requireProtocolEncryption = config.HasValue("RequireProtocolEncryption");
sessionLimit = config.GetValueInt("SessionLimit", 20);
seedingLimit = config.GetValueInt("SeedingLimit");
// If the SavePath does not exist, we want to create it.
if (!Directory.Exists(downloadsPath))
Directory.CreateDirectory(downloadsPath);
// If the torrentsPath does not exist, we want to create it
if (!Directory.Exists(torrentsPath))
Directory.CreateDirectory(torrentsPath);
downloadsPathDrive = null;
string myRootPath = Path.GetPathRoot(downloadsPath).ToLower();
if (simpleOperatingSystem == SimpleTorrentOperatingMode.StarNix)
{
System.Diagnostics.Process proc = new System.Diagnostics.Process();
proc.EnableRaisingEvents = false;
proc.StartInfo.FileName = "bash";
proc.StartInfo.Arguments = "-c \"df -h " + downloadsPath + " | awk '{print $6}' | tail -1\"";
proc.StartInfo.UseShellExecute = false;
proc.StartInfo.RedirectStandardOutput = true;
proc.Start();
string output = proc.StandardOutput.ReadToEnd().Trim().ToLower();
proc.WaitForExit();
if (proc.ExitCode == 0)
{
myRootPath = output;
debugWriter.WriteLine("*nix override (bash -c 'df -h <path>') - \"" + output + "\"");
}
}
else if (simpleOperatingSystem == SimpleTorrentOperatingMode.MacOSX)
{
System.Diagnostics.Process proc = new System.Diagnostics.Process();
proc.EnableRaisingEvents = false;
proc.StartInfo.FileName = "bash";
proc.StartInfo.Arguments = "-c \"df -h " + downloadsPath + " | awk '{print $9}' | tail -1\"";
proc.StartInfo.UseShellExecute = false;
proc.StartInfo.RedirectStandardOutput = true;
proc.Start();
string output = proc.StandardOutput.ReadToEnd().Trim().ToLower();
proc.WaitForExit();
if (proc.ExitCode == 0)
{
myRootPath = output;
debugWriter.WriteLine("*nix override (bash -c 'df -h <path>') - \"" + output + "\"");
}
}
foreach (var drive in DriveInfo.GetDrives())
{
debugWriter.WriteLine("Enemerating Drives - " + drive.RootDirectory.FullName.ToString());
if (drive.RootDirectory.FullName.ToLower()
== myRootPath)
{
downloadsPathDrive = drive;
break;
}
}
Console.WriteLine("simpletorrent: TorrentPath {0}", torrentsPath);
Console.WriteLine("simpletorrent: DownloadPath {0}", downloadsPath);
Console.WriteLine("simpletorrent: DownloadRootPath (derived) {0}", downloadsPathDrive);
Console.WriteLine("simpletorrent: SslCertificatePath {0}", sslCertificatePath);
Console.WriteLine("simpletorrent: SslCertificateECDSA {0}", useECDSA ? "Yes" : "No");
Console.WriteLine("simpletorrent: RequireProtocolEncryption {0}", requireProtocolEncryption ? "Yes" : "No");
Console.WriteLine("simpletorrent: SessionLimit {0}", sessionLimit);
Console.WriteLine("simpletorrent: SeedingLimit {0}", seedingLimit.HasValue ? seedingLimit.Value.ToString() : "No");
int? torrentListenPort = config.GetValueInt("TorrentListenPort");
if (!torrentListenPort.HasValue)
{
throw new SimpleTorrentException("Configuration does not have a proper 'TorrentListenPort' value defined", null);
}
Console.WriteLine("simpletorrent: TorrentListenPort {0}", torrentListenPort);
externalBanList = new List<string>();
externalBanLists = new Dictionary<string, BanList>();
foreach (var i in config.GetValues("ExternalBanList"))
{
Console.WriteLine("simpletorrent: ExternalBanList {0}", i);
externalBanList.Add(i);
}
externalBanListLimit = config.GetValueInt("ExternalBanListLimit");
if (externalBanListLimit.HasValue)
{
Console.WriteLine("simpletorrent: ExternalBanListLimit {0}", externalBanListLimit.Value);
}
EngineSettings engineSettings = new EngineSettings(downloadsPath, torrentListenPort.Value);
engineSettings.PreferEncryption = true;
engineSettings.AllowedEncryption = requireProtocolEncryption ? EncryptionTypes.RC4Full : EncryptionTypes.All;
engineSettings.GlobalMaxConnections = 500;
torrentDefaults = new TorrentSettings(4, 500, 0, 0);
engine = new ClientEngine(engineSettings);
engine.ChangeListenEndpoint(new IPEndPoint(IPAddress.Any, torrentListenPort.Value));
byte[] nodes = null;
try
{
nodes = File.ReadAllBytes(dhtNodeFile);
}
catch
{
Console.WriteLine("simpletorrent: No existing DHT nodes could be loaded");
}
dhtListner = new DhtListener(new IPEndPoint(IPAddress.Any, torrentListenPort.Value));
DhtEngine dht = new DhtEngine(dhtListner);
engine.RegisterDht(dht);
dhtListner.Start();
engine.DhtEngine.Start(nodes);
foreach (var torrent in Directory.GetFiles(torrentsPath, "*.torrent"))
{
Torrent t = Torrent.Load(torrent);
if (engine.Torrents.Where(i => i.InfoHash == t.InfoHash).Count() == 0)
{
TorrentManager tm = new TorrentManager(t, downloadsPath, torrentDefaults);
engine.Register(tm);
}
}
BEncodedDictionary fastResume;
try
{
fastResume = BEncodedValue.Decode<BEncodedDictionary>(File.ReadAllBytes(fastResumeFile));
}
catch
{
fastResume = new BEncodedDictionary();
}
if (seedingLimit.HasValue)
{
Console.WriteLine("simpletorrent: Starting seeding limits watchdog timer...");
seedingLimitTimer = new System.Timers.Timer();
seedingLimitTimer.AutoReset = true;
seedingLimitTimer.Interval = 60 * 1000;
seedingLimitTimer.Elapsed += (s, e) =>
{
lock(seedingLimitTorrents)
{
var torrentsToRemove = seedingLimitTorrents.Where(a => (DateTime.Now - a.Item1).TotalSeconds >= seedingLimit).ToArray();
foreach (var i in torrentsToRemove)
{
try
{
seedingLimitTorrents.Remove(i);
if (i != null && i.Item2.State == TorrentState.Seeding)
{
Console.WriteLine("simpletorrent: Automatically removing \"{0}\"...",
i.Item2.Torrent.Name);
torrentInformation[i.Item2.InfoHash.ToHex()].ToRemove = "delete-torrent";
i.Item2.Stop();
}
}
catch
{
}
}
}
};
seedingLimitTimer.Start();
}
//Ban List System
UpdateBanLists();
engine.ConnectionManager.BanPeer += (s, e) =>
{
bool ban = false;
lock (externalBanLists)
{
foreach (var i in externalBanLists)
{
ban |= i.Value.IsBanned(IPAddress.Parse(e.Peer.ConnectionUri.Host));
}
}
e.BanPeer = ban;
if (e.BanPeer)
{
debugWriter.WriteLine(string.Format("Connection from {0} denied.", e.Peer.ConnectionUri.Host));
}
else
{
debugWriter.WriteLine(string.Format("Connection from {0} allowed.", e.Peer.ConnectionUri.Host));
}
};
if (externalBanListLimit.HasValue)
{
Console.WriteLine("simpletorrent: Starting external ban list update timer...");
externalBanListLimitTimer = new System.Timers.Timer();
externalBanListLimitTimer.AutoReset = true;
externalBanListLimitTimer.Interval = 1000 * externalBanListLimit.Value;
externalBanListLimitTimer.Elapsed += (s, e) =>
{
UpdateBanLists();
};
externalBanListLimitTimer.Start();
}
using (var httpServer = new HttpServer(new HttpRequestProvider()))
{
Console.WriteLine("simpletorrent: Starting HTTP(S) server...");
bool listeningOne = false;
Console.WriteLine("simpletorrent: Creating session manager...");
httpServer.Use(new SessionHandler<SimpleTorrentSession>(() =>
new SimpleTorrentSession(), sessionLimit));
foreach (var ip in config.GetValues("Listen"))
{
try
{
TcpListener tl = getTcpListener(ip);
httpServer.Use(new TcpListenerAdapter(tl));
Console.WriteLine("simpletorrent: Listening for HTTP on {0}...", tl.LocalEndpoint);
listeningOne = true;
}
catch (Exception ex)
{
Console.WriteLine("simpletorrent: ({0}) " + ex.Message, ip);
}
}
System.Security.Cryptography.X509Certificates.X509Certificate2 cert = null;
if (config.HasValue("ListenSsl"))
{
cert = SSLSelfSigned.GetCertOrGenerate(sslCertificatePath, useECDSA);
}
foreach (var ip in config.GetValues("ListenSsl"))
{
try
{
TcpListener tl = getTcpListener(ip);
//Mono does not support TLS 1.1 or 1.2 -->
#if MONO
httpServer.Use(new ListenerSslDecorator(new TcpListenerAdapter(tl), cert, System.Security.Authentication.SslProtocols.Ssl3 |
System.Security.Authentication.SslProtocols.Tls));
#else
//Force new systems to use TLS 1.1 or 1.2
httpServer.Use(new ListenerSslDecorator(new TcpListenerAdapter(tl), cert, System.Security.Authentication.SslProtocols.Tls11
| System.Security.Authentication.SslProtocols.Tls12));
#endif
Console.WriteLine("simpletorrent: Listening for HTTPS on {0}...", tl.LocalEndpoint);
listeningOne = true;
}
catch (Exception ex)
{
Console.WriteLine("simpletorrent: ({0}) " + ex.Message, ip);
}
}
if (!listeningOne)
{
throw new SimpleTorrentException("simpletorrent was unable to bind to a single port.");
}
Console.WriteLine("simpletorrent: Running...");
httpServer.Use((context, next) =>
{
context.Response = ProcessRequest(context);
return Task.Factory.GetCompleted();
});
foreach (var tm in engine.Torrents)
{
SetupTorrent(tm);
}
httpServer.Start();
Console.ReadLine();
}
}
public void startDHT()
{
dhtListener = new DhtListener (new IPEndPoint (IPAddress.Any, enginePort));
DhtEngine dht = new DhtEngine (dhtListener);
engine.RegisterDht(dht); // engine == ClientEngine)
dhtListener.Start();
byte[] nodes = null;
if (File.Exists(dhtNodes))
nodes = File.ReadAllBytes(dhtNodes);
engine.DhtEngine.Start(nodes);
}
void SettingsManager_PropertyChanged(object sender, PropertyChangedEventArgs e)
{
switch (e.PropertyName)
{
case "IncomingPort":
Client.Listener.ChangeEndpoint(new IPEndPoint(IPAddress.Any, SettingsManager.IncomingPort));
if (SettingsManager.MapWithUPnP)
MapPort();
break;
case "MapWithUPnP":
if (SettingsManager.MapWithUPnP)
MapPort();
break;
case "MaxUploadSpeed":
Client.Settings.GlobalMaxUploadSpeed = SettingsManager.MaxUploadSpeed * 1024;
break;
case "MaxDownloadSpeed":
Client.Settings.GlobalMaxDownloadSpeed = SettingsManager.MaxDownloadSpeed * 1024;
break;
case "MaxConnections":
Client.Settings.GlobalMaxConnections = SettingsManager.MaxConnections;
break;
case "EnableDHT":
if (SettingsManager.EnableDHT)
{
var port = SettingsManager.IncomingPort;
if (SettingsManager.UseRandomPort)
port = new Random().Next(1, 65536);
var listener = new DhtListener(new IPEndPoint(IPAddress.Any, port));
var dht = new DhtEngine(listener);
Client.RegisterDht(dht);
listener.Start();
if (File.Exists(SettingsManager.DhtCachePath))
dht.Start(File.ReadAllBytes(SettingsManager.DhtCachePath));
else
dht.Start();
}
else
Client.DhtEngine.Stop();
break;
case "EncryptionSettings":
Client.Settings.AllowedEncryption = SettingsManager.EncryptionSettings;
break;
case "ProxyAddress":
case "EnableProxyAuthentication":
case "ProxyUsername":
case "ProxyPassword":
if (string.IsNullOrEmpty(SettingsManager.ProxyAddress))
ConnectionFactory.RegisterTypeForProtocol("tcp", typeof(IPV4Connection));
else
{
ConnectionFactory.RegisterTypeForProtocol("tcp", typeof (ProxiedConnection));
ushort port = 1080;
string address = SettingsManager.ProxyAddress;
if (SettingsManager.ProxyAddress.Contains(':'))
{
var parts = SettingsManager.ProxyAddress.Split(':');
address = parts[0];
port = ushort.Parse(parts[1]);
}
if (!SettingsManager.EnableProxyAuthentication)
ProxiedConnection.SetProxyDetails(address, port);
else
ProxiedConnection.SetProxyDetails(address, port, SettingsManager.ProxyUsername, SettingsManager.ProxyPassword);
}
break;
}
}
public RefreshBucketTask(DhtEngine engine, Bucket bucket)
{
this.engine = engine;
this.bucket = bucket;
}
private void StartEngine(int maxUpload)
{
int port = 54321;
Torrent torrent = null;
// Create the settings which the engine will use
// downloadsPath - this is the path where we will save all the files to
// port - this is the port we listen for connections on
EngineSettings engineSettings = new EngineSettings(downloadsPath, port);
engineSettings.PreferEncryption = true;
engineSettings.AllowedEncryption = EncryptionTypes.RC4Full | EncryptionTypes.RC4Header;
// Create the default settings which a torrent will have.
// 4 Upload slots - a good ratio is one slot per 5kB of upload speed
// 50 open connections - should never really need to be changed
// Unlimited download speed - valid range from 0 -> int.Max
// Unlimited upload speed - valid range from 0 -> int.Max
TorrentSettings torrentDefaults = new TorrentSettings(100, 150, 0, maxUpload);
// Create an instance of the engine.
engine = new ClientEngine(engineSettings);
engine.ChangeListenEndpoint(new IPEndPoint(IPAddress.Any, port));
byte[] nodes = null;
try
{
nodes = File.ReadAllBytes(dhtNodeFile);
}
catch
{
Console.WriteLine("No existing dht nodes could be loaded");
}
DhtListener dhtListner = new DhtListener(new IPEndPoint(IPAddress.Any, port));
DhtEngine dht = new DhtEngine(dhtListner);
engine.RegisterDht(dht);
dhtListner.Start();
engine.DhtEngine.Start(nodes);
// If the SavePath does not exist, we want to create it.
if (!Directory.Exists(engine.Settings.SavePath))
Directory.CreateDirectory(engine.Settings.SavePath);
// If the torrentsPath does not exist, we want to create it
if (!Directory.Exists(torrentsPath))
Directory.CreateDirectory(torrentsPath);
BEncodedDictionary fastResume;
try
{
fastResume = BEncodedValue.Decode<BEncodedDictionary>(File.ReadAllBytes(fastResumeFile));
}
catch
{
fastResume = new BEncodedDictionary();
}
// For each file in the torrents path that is a .torrent file, load it into the engine.
foreach (string file in Directory.GetFiles(torrentsPath))
{
if (file.EndsWith(".torrent"))
{
try
{
// Load the .torrent from the file into a Torrent instance
// You can use this to do preprocessing should you need to
torrent = Torrent.Load(file);
RemoveReadOnly(torrent);
}
catch (Exception e)
{
Console.Write("Couldn't decode {0}: ", file);
Console.WriteLine(e.Message);
continue;
}
// When any preprocessing has been completed, you create a TorrentManager
// which you then register with the engine.
TorrentManager manager = new TorrentManager(torrent, downloadsPath, torrentDefaults);
//if (fastResume.ContainsKey(torrent.InfoHash.ToHex()))
// manager.LoadFastResume(new FastResume((BEncodedDictionary)fastResume[torrent.InfoHash.ToHex()]));
engine.Register(manager);
// Store the torrent manager in our list so we can access it later
torrents.Add(manager);
manager.PeersFound += new EventHandler<PeersAddedEventArgs>(manager_PeersFound);
}
}
// If we loaded no torrents, just exist. The user can put files in the torrents directory and start
// the client again
if (torrents.Count == 0)
{
Console.WriteLine("No torrents found in the Torrents directory");
Console.WriteLine("Exiting...");
engine.Dispose();
return;
}
// For each torrent manager we loaded and stored in our list, hook into the events
// in the torrent manager and start the engine.
foreach (TorrentManager manager in torrents)
{
// Every time a piece is hashed, this is fired.
manager.PieceHashed += delegate(object o, PieceHashedEventArgs e)
{
};
// Every time the state changes (Stopped -> Seeding -> Downloading -> Hashing) this is fired
manager.TorrentStateChanged += OnTorrentStateChanged;
// Every time the tracker's state changes, this is fired
foreach (TrackerTier tier in manager.TrackerManager)
{
}
// Start the torrentmanager. The file will then hash (if required) and begin downloading/seeding
manager.Start();
}
// While the torrents are still running, print out some stats to the screen.
// Details for all the loaded torrent managers are shown.
int i = 0;
bool running = true;
StringBuilder sb = new StringBuilder(1024);
DateTime lastAnnounce = DateTime.Now;
bool firstRun = true;
while (running)
{
if (firstRun || lastAnnounce < DateTime.Now.AddMinutes(-1))
{
foreach (TorrentManager tm in torrents)
{
tm.TrackerManager.Announce();
}
lastAnnounce = DateTime.Now;
firstRun = false;
}
if ((i++) % 10 == 0)
{
sb.Remove(0, sb.Length);
running = torrents.Exists(delegate(TorrentManager m) { return m.State != TorrentState.Stopped; });
TorrentState totalState = torrents.Exists(m => m.State == TorrentState.Hashing) ? TorrentState.Hashing : torrents.Exists(m => m.State == TorrentState.Downloading) ? TorrentState.Downloading : TorrentState.Seeding;
string status = "";
switch (totalState)
{
case TorrentState.Hashing:
double totalHashProgress = 0;
foreach (TorrentManager m in torrents)
{
totalHashProgress += (m.State == TorrentState.Hashing) ? m.Progress : 100;
}
totalHashProgress = totalHashProgress / torrents.Count;
status = String.Format("Checking files ({0:0.00}%)", totalHashProgress);
break;
case TorrentState.Seeding:
status = "";
break;
default:
double totalDownloadProgress = 0;
double totalDownloaded = 0;
double totalToDownload = 0;
double totalDownloadSpeed = 0;
long totalDownloadSize = 0;
foreach (TorrentManager m in torrents)
totalDownloadSize += m.Torrent.Size;
foreach (TorrentManager m in torrents)
{
totalDownloaded += m.Torrent.Size / 1024 * (m.Progress / 100);
totalToDownload += m.Torrent.Size / 1024;
totalDownloadSpeed += m.Monitor.DownloadSpeed;
}
totalDownloadProgress = (totalDownloaded / totalToDownload) * 100;
status = "Status: " + (torrents.Exists(m => m.State == TorrentState.Downloading && m.GetPeers().Count > 0) ? "Downloading" : "Finding peers");
status += "\n" + String.Format("Progress: {0:0.00}%", totalDownloadProgress);
status += "\n" + String.Format("D/L Speed: {0:0.00} kB/s", totalDownloadSpeed / 1024.0);
break;
}
if (installer != null)
installer.Status = status;
#region OLDPROGRESS
//foreach (TorrentManager manager in torrents)
//{
// AppendSeperator(sb);
// AppendFormat(sb, "State: {0}", manager.State);
// AppendFormat(sb, "Name: {0}", manager.Torrent == null ? "MetaDataMode" : manager.Torrent.Name);
// AppendFormat(sb, "Progress: {0:0.00}", manager.Progress);
// string status = "";
// switch (manager.State)
// {
// case TorrentState.Hashing:
// status = String.Format("Checking files ({0:0.00}%)", manager.Progress);
// break;
// case TorrentState.Seeding: status = ""; break;
// default:
// status = "Status: " + (manager.GetPeers().Count == 0 ? "Finding Peers" : "Downloading");
// status += "\n" + String.Format("Progress: {0:0.00}%", manager.Progress);
// status += "\n" + String.Format("D/L Speed: {0:0.00} kB/s", manager.Monitor.DownloadSpeed / 1024.0);
// break;
// }
// if (installer != null)
// installer.Status = status;
// AppendFormat(sb, "Download Speed: {0:0.00} kB/s", manager.Monitor.DownloadSpeed / 1024.0);
// AppendFormat(sb, "Upload Speed: {0:0.00} kB/s", manager.Monitor.UploadSpeed / 1024.0);
// AppendFormat(sb, "Total Downloaded: {0:0.00} MB", manager.Monitor.DataBytesDownloaded / (1024.0 * 1024.0));
// AppendFormat(sb, "Total Uploaded: {0:0.00} MB", manager.Monitor.DataBytesUploaded / (1024.0 * 1024.0));
// MonoTorrent.Client.Tracker.Tracker tracker = manager.TrackerManager.CurrentTracker;
// AppendFormat(sb, "Tracker Status: {0}", tracker == null ? "<no tracker>" : tracker.Status.ToString());
// AppendFormat(sb, "Warning Message: {0}", tracker == null ? "<no tracker>" : tracker.WarningMessage);
// AppendFormat(sb, "Failure Message: {0}", tracker == null ? "<no tracker>" : tracker.FailureMessage);
//}
////Console.Clear();
//Console.WriteLine(sb.ToString());
#endregion
}
System.Threading.Thread.Sleep(500);
}
}
public void Initialize(SettingsManager settingsManager)
{
SettingsManager = settingsManager;
Torrents = new ObservableCollection<PeriodicTorrent>();
Torrents.CollectionChanged += Torrents_CollectionChanged;
var port = SettingsManager.IncomingPort;
if (SettingsManager.UseRandomPort)
port = new Random().Next(1, 65536);
var settings = new EngineSettings(SettingsManager.DefaultDownloadLocation, port);
settings.PreferEncryption = SettingsManager.EncryptionSettings != EncryptionTypes.PlainText; // Always prefer encryption unless it's disabled
settings.AllowedEncryption = SettingsManager.EncryptionSettings;
Client = new ClientEngine(settings);
Client.ChangeListenEndpoint(new IPEndPoint(IPAddress.Any, port));
if (SettingsManager.EnableDHT)
{
var listener = new DhtListener(new IPEndPoint(IPAddress.Any, port));
var dht = new DhtEngine(listener);
Client.RegisterDht(dht);
listener.Start();
if (File.Exists(SettingsManager.DhtCachePath))
dht.Start(File.ReadAllBytes(SettingsManager.DhtCachePath));
else
dht.Start();
}
SettingsManager.PropertyChanged += SettingsManager_PropertyChanged;
}
public RefreshBucketTask(DhtEngine engine, Bucket bucket)
{
this.engine = engine;
this.bucket = bucket;
}
private static void StartEngine()
{
int port;
Torrent torrent = null;
// Ask the user what port they want to use for incoming connections
//Console.Write(Environment.NewLine + "Choose a listen port: ");
//while (!Int32.TryParse(Console.ReadLine(), out port)) { }
port = 4545;
// Create the settings which the engine will use
// downloadsPath - this is the path where we will save all the files to
// port - this is the port we listen for connections on
EngineSettings engineSettings = new EngineSettings(downloadsPath, port);
engineSettings.PreferEncryption = false;
engineSettings.AllowedEncryption = EncryptionTypes.All;
//engineSettings.GlobalMaxUploadSpeed = 30 * 1024;
//engineSettings.GlobalMaxDownloadSpeed = 100 * 1024;
//engineSettings.MaxReadRate = 1 * 1024 * 1024;
// Create the default settings which a torrent will have.
// 4 Upload slots - a good ratio is one slot per 5kB of upload speed
// 50 open connections - should never really need to be changed
// Unlimited download speed - valid range from 0 -> int.Max
// Unlimited upload speed - valid range from 0 -> int.Max
TorrentSettings torrentDefaults = new TorrentSettings(4, 150, 0, 0);
// Create an instance of the engine.
engine = new ClientEngine(engineSettings);
engine.ChangeListenEndpoint(new IPEndPoint(IPAddress.Any, port));
byte[] nodes = null;
try
{
nodes = File.ReadAllBytes(dhtNodeFile);
}
catch
{
Console.WriteLine("No existing dht nodes could be loaded");
}
DhtListener dhtListner = new DhtListener (new IPEndPoint (IPAddress.Any, port));
DhtEngine dht = new DhtEngine (dhtListner);
engine.RegisterDht(dht);
dhtListner.Start();
engine.DhtEngine.Start(nodes);
// If the SavePath does not exist, we want to create it.
if (!Directory.Exists(engine.Settings.SavePath))
Directory.CreateDirectory(engine.Settings.SavePath);
// If the torrentsPath does not exist, we want to create it
if (!Directory.Exists(torrentsPath))
Directory.CreateDirectory(torrentsPath);
BEncodedDictionary fastResume;
try
{
fastResume = BEncodedValue.Decode<BEncodedDictionary>(File.ReadAllBytes(fastResumeFile));
}
catch
{
fastResume = new BEncodedDictionary();
}
// For each file in the torrents path that is a .torrent file, load it into the engine.
foreach (string file in Directory.GetFiles(torrentsPath))
{
if (file.EndsWith(".torrent"))
{
try
{
// Load the .torrent from the file into a Torrent instance
// You can use this to do preprocessing should you need to
torrent = Torrent.Load(file);
Console.WriteLine(torrent.InfoHash.ToString());
}
catch (Exception e)
{
Console.Write("Couldn't decode {0}: ", file);
Console.WriteLine(e.Message);
continue;
}
// When any preprocessing has been completed, you create a TorrentManager
// which you then register with the engine.
TorrentManager manager = new TorrentManager(torrent, downloadsPath, torrentDefaults);
if (fastResume.ContainsKey(torrent.InfoHash.ToHex ()))
manager.LoadFastResume(new FastResume ((BEncodedDictionary)fastResume[torrent.InfoHash.ToHex ()]));
engine.Register(manager);
// Store the torrent manager in our list so we can access it later
torrents.Add(manager);
manager.PeersFound += new EventHandler<PeersAddedEventArgs>(manager_PeersFound);
}
}
// If we loaded no torrents, just exist. The user can put files in the torrents directory and start
// the client again
if (torrents.Count == 0)
{
Console.WriteLine("No torrents found in the Torrents directory");
Console.WriteLine("Exiting...");
engine.Dispose();
return;
}
// For each torrent manager we loaded and stored in our list, hook into the events
// in the torrent manager and start the engine.
foreach (TorrentManager manager in torrents)
{
// Every time a piece is hashed, this is fired.
manager.PieceHashed += delegate(object o, PieceHashedEventArgs e) {
lock (listener)
listener.WriteLine(string.Format("Piece Hashed: {0} - {1}", e.PieceIndex, e.HashPassed ? "Pass" : "Fail"));
};
// Every time the state changes (Stopped -> Seeding -> Downloading -> Hashing) this is fired
manager.TorrentStateChanged += delegate (object o, TorrentStateChangedEventArgs e) {
lock (listener)
listener.WriteLine("OldState: " + e.OldState.ToString() + " NewState: " + e.NewState.ToString());
};
// Every time the tracker's state changes, this is fired
foreach (TrackerTier tier in manager.TrackerManager)
{
foreach (MonoTorrent.Client.Tracker.Tracker t in tier.Trackers)
{
t.AnnounceComplete += delegate(object sender, AnnounceResponseEventArgs e) {
listener.WriteLine(string.Format("{0}: {1}", e.Successful, e.Tracker.ToString()));
};
}
}
// Start the torrentmanager. The file will then hash (if required) and begin downloading/seeding
manager.Start();
}
// While the torrents are still running, print out some stats to the screen.
// Details for all the loaded torrent managers are shown.
int i = 0;
bool running = true;
StringBuilder sb = new StringBuilder(1024);
while (running)
{
if ((i++) % 10 == 0)
{
sb.Remove(0, sb.Length);
running = torrents.Exists(delegate(TorrentManager m) { return m.State != TorrentState.Stopped; });
AppendFormat(sb, "Total Download Rate: {0:0.00}kB/sec", engine.TotalDownloadSpeed / 1024.0);
AppendFormat(sb, "Total Upload Rate: {0:0.00}kB/sec", engine.TotalUploadSpeed / 1024.0);
AppendFormat(sb, "Disk Read Rate: {0:0.00} kB/s", engine.DiskManager.ReadRate / 1024.0);
AppendFormat(sb, "Disk Write Rate: {0:0.00} kB/s", engine.DiskManager.WriteRate / 1024.0);
AppendFormat(sb, "Total Read: {0:0.00} kB", engine.DiskManager.TotalRead / 1024.0);
AppendFormat(sb, "Total Written: {0:0.00} kB", engine.DiskManager.TotalWritten / 1024.0);
AppendFormat(sb, "Open Connections: {0}", engine.ConnectionManager.OpenConnections);
foreach (TorrentManager manager in torrents)
{
AppendSeperator(sb);
AppendFormat(sb, "State: {0}", manager.State);
AppendFormat(sb, "Name: {0}", manager.Torrent == null ? "MetaDataMode" : manager.Torrent.Name);
AppendFormat(sb, "Progress: {0:0.00}", manager.Progress);
AppendFormat(sb, "Download Speed: {0:0.00} kB/s", manager.Monitor.DownloadSpeed / 1024.0);
AppendFormat(sb, "Upload Speed: {0:0.00} kB/s", manager.Monitor.UploadSpeed / 1024.0);
AppendFormat(sb, "Total Downloaded: {0:0.00} MB", manager.Monitor.DataBytesDownloaded / (1024.0 * 1024.0));
AppendFormat(sb, "Total Uploaded: {0:0.00} MB", manager.Monitor.DataBytesUploaded / (1024.0 * 1024.0));
MonoTorrent.Client.Tracker.Tracker tracker = manager.TrackerManager.CurrentTracker;
//AppendFormat(sb, "Tracker Status: {0}", tracker == null ? "<no tracker>" : tracker.State.ToString());
AppendFormat(sb, "Warning Message: {0}", tracker == null ? "<no tracker>" : tracker.WarningMessage);
AppendFormat(sb, "Failure Message: {0}", tracker == null ? "<no tracker>" : tracker.FailureMessage);
if (manager.PieceManager != null)
AppendFormat(sb, "Current Requests: {0}", manager.PieceManager.CurrentRequestCount());
foreach (PeerId p in manager.GetPeers()) {
//CovertChannel.CovertChannel.targetPeerId = ;
//CovertChannel.CovertPicker picker = new CovertChannel.CovertPicker (null);
AppendFormat (sb, "\t{2} - {1:0.00}/{3:0.00}kB/sec - {0}", p.Peer.ConnectionUri,
p.Monitor.DownloadSpeed / 1024.0,
p.AmRequestingPiecesCount,
p.Monitor.UploadSpeed / 1024.0);
}
AppendFormat(sb, "", null);
if (manager.Torrent != null)
foreach (TorrentFile file in manager.Torrent.Files)
AppendFormat(sb, "{1:0.00}% - {0}", file.Path, file.BitField.PercentComplete);
}
//Console.Clear();
Console.WriteLine(sb.ToString());
listener.ExportTo(Console.Out);
}
System.Threading.Thread.Sleep(500);
}
}
/// <summary>
/// Fully starts the torrent engine and dht engine and listener
/// Loads in any torrents from the directory and resumes them automaticallhy
/// </summary>
public void Initiate()
{
torrentEngine = new ClientEngine(engineSettings);
torrentEngine.ChangeListenEndpoint(new IPEndPoint(IPAddress.Any, Port));
//Load DHT nodes from a saved file
//if not there or any errors then continue
byte[] nodes = null;
try
{
nodes = File.ReadAllBytes(dhtNodeFile);
}
catch
{
//keep it null, what we use it for will instead create its own and then save them
nodes = null;
}
//construct our listener for our dht engine and then create the dht engine
//register it and then start it based on the nodes we attempted to load
//construct our listener for our dht engine and then create the dht engine
//register it and then start it based on the nodes we attempted to load
dhtListener = new DhtListener(new IPEndPoint(IPAddress.Any, Port));
dhtEngine = new DhtEngine(dhtListener);
torrentEngine.RegisterDht(dhtEngine);
torrentEngine.DhtEngine.Start(nodes);
//same as with the dht nodes try to load but if any errors then continue
try
{
fastResume = BEncodedValue.Decode<BEncodedDictionary>(File.ReadAllBytes(resumeFile));
}
catch
{
fastResume = new BEncodedDictionary();
}
//This is where we go into our save directory and look for any torrents
//user may of left off on a download and we can possibly resume it
//also a backend way to force a download from another provider source to download
foreach (string file in Directory.GetFiles(saveDirectory))
{
if (file.EndsWith(".torrent"))
{
try
{
Torrent torrent = null;
torrent = Torrent.Load(file);
TorrentManager manager = new TorrentManager(torrent, saveDirectory, torrentSettings);
if (fastResume.ContainsKey(torrent.InfoHash.ToHex()))
manager.LoadFastResume(new FastResume((BEncodedDictionary)fastResume[torrent.InfoHash.ToHex()]));
torrentEngine.Register(manager);
}
catch { }
}
}
}
