Example #1
0
        public DhtEngine(DhtListener listener)
        {
            if (listener == null)
                throw new ArgumentNullException("listener");

            messageLoop = new MessageLoop(this, listener);
            timeout = TimeSpan.FromSeconds(15); // 15 second message timeout by default
            tokenManager = new TokenManager();
        }
Example #2
0
 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;
     });
 }
Example #3
0
        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);
            }
        }
Example #4
0
        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 StartDht(ClientEngine engine, int port)
        {
            IPEndPoint listenAddress = new IPEndPoint(IPAddress.Any, port);

            this.listener = new DhtListener(listenAddress);
            DhtEngine dht = new DhtEngine(this.listener);

            engine.RegisterDht(dht);
            listener.Start();
            byte[] nodes = null;
            string path  = Path.Combine(this.parent.localAppDataFolder, "nodes");

            if (File.Exists(path))
            {
                nodes = File.ReadAllBytes(path);
            }
            engine.DhtEngine.Start(nodes);
        }
Example #6
0
        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();
        }
Example #7
0
        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;
            });
        }
Example #8
0
 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;
     }
 }
Example #9
0
        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();
        }
        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;
            }
        }
Example #13
0
    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);
    }
Example #14
0
        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;
        }
Example #15
0
        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);
        }
Example #16
0
        /// <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);
            }
        }
Example #17
0
        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();
            }
        }
Example #18
0
        public void Start()
        {
            // Create an instance of the engine.
            Engine = new ClientEngine (new EngineSettings
            {
                PreferEncryption = false,
                AllowedEncryption = EncryptionTypes.All
            });
            Engine.ChangeListenEndpoint (new IPEndPoint (IPAddress.Any, Port));

            // Setup DHT listener.
            byte[] nodes = null;
            try
            {
                nodes = File.ReadAllBytes(DHTNodeFile);
            }
            catch
            {
            }
            var dhtListner = new DhtListener (new IPEndPoint (IPAddress.Any, Port));
            Engine.RegisterDht (new DhtEngine (dhtListner));
            dhtListner.Start ();
            Engine.DhtEngine.Start (nodes);

            // Fast resume.
            try
            {
                FastResume = BEncodedValue.Decode<BEncodedDictionary>(File.ReadAllBytes(FastResumeFile));
            }
            catch
            {
                FastResume = new BEncodedDictionary();
            }

            // Try load the cache file.
            try
            {
                TorrentMappingsCache.Load();
            }
            catch
            {
            }

            // Cross reference torrent files against cache entries (sync).
            var torrents = Directory.GetFiles (TorrentFileDirectory, "*.torrent").Select (Torrent.Load).ToList();
            TorrentMappingsCache.RemoveAll (tmc => !torrents.Any (t => t.InfoHash.ToString () == tmc.InfoHash));
            TorrentMappingsCache.Save ();
            torrents.Where (t => !TorrentMappingsCache.Any (tmc => tmc.InfoHash == t.InfoHash.ToString ()))
                    .ToList ().ForEach (t => File.Delete(t.TorrentPath));

            // Reload the torrents and add them.
            Directory.GetFiles (TorrentFileDirectory, "*.torrent").ToList ().ForEach (torrentFile =>
            {
                var torrent = Torrent.Load(torrentFile);
                var outputDirectoryPath = TorrentMappingsCache.First(tmc => tmc.InfoHash == torrent.InfoHash.ToString()).OutputDirectoryPath;
                try
                {
                    Add(torrent, outputDirectoryPath);
                }
                catch
                {
                    var brokenTorrentFileName = Path.GetFileName(torrentFile);
                    var brokenTorrentFilePath = System.IO.Path.Combine(BrokenTorrentFileDirectory, brokenTorrentFileName);
                    File.Copy(torrentFile, brokenTorrentFilePath, true);
                    Remove(torrent.InfoHash.ToString());
                }
            });
        }
Example #19
0
 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;
     }
 }
        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);
            }
        }
Example #21
0
        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);
            }
        }
Example #22
0
        /// <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 { }

                }
            }
        }