public ListenPortController()
{
settings = SettingsManager.EngineSettings;
devices = new List<INatDevice> ();
tcpMapping = new Mapping (Protocol.Tcp, settings.ListenPort, settings.ListenPort);
tcpMapping.Description = Defines.ApplicationName;
udpMapping = new Mapping (Protocol.Udp, settings.ListenPort, settings.ListenPort);
udpMapping.Description = Defines.ApplicationName;
IPAddress[] addresses = null;
try
{
addresses = NatUtility.GetLocalAddresses (false);
}
catch (Exception)
{
logger.Warn ("Could not resolve hostname, port forwarding may not work");
addresses = new IPAddress[] { IPAddress.Loopback };
}
NatUtility.DeviceFound += OnDeviceFound;
}
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 TorrentController(MainWindow mainWindow)
{
this.userTorrentSettings = mainWindow.userTorrentSettings;
this.userEngineSettings = mainWindow.userEngineSettings;
this.prefSettings = mainWindow.prefSettings;
this.labels = mainWindow.labels;
this.torrentListStore = mainWindow.torrentListStore;
this.torrents = mainWindow.torrents;
this.mainWindow = mainWindow;
this.pieces = mainWindow.pieces;
this.torrentPreviousUpload = new Dictionary<MonoTorrent.Client.TorrentManager,long>();
this.torrentPreviousDownload = new Dictionary<MonoTorrent.Client.TorrentManager,long>();
engineSettings = new EngineSettings(userEngineSettings.SavePath, userEngineSettings.ListenPort, userEngineSettings.GlobalMaxConnections, userEngineSettings.GlobalMaxHalfOpenConnections, userEngineSettings.GlobalMaxDownloadSpeed, userEngineSettings.GlobalMaxUploadSpeed, EngineSettings.DefaultSettings().MinEncryptionLevel, userEngineSettings.AllowLegacyConnections);
torrentSettings = new TorrentSettings(userTorrentSettings.UploadSlots, userTorrentSettings.MaxConnections, userTorrentSettings.MaxDownloadSpeed, userTorrentSettings.MaxUploadSpeed, userTorrentSettings.FastResumeEnabled);
engine = new ClientEngine(engineSettings);
engine.ConnectionManager.PeerMessageTransferred += OnPeerMessageTransferred;
hashProgress = new Dictionary<MonoTorrent.Client.TorrentManager,int>();
torrentSwarm = new Dictionary<MonoTorrent.Client.TorrentManager,int>();
torrentsDownloading = new ArrayList();
torrentsSeeding = new ArrayList();
allTorrents = new ArrayList();
}
public TorrentServer(string downloadsPath, int listenPort)
{
this.downloadsPath = downloadsPath;
var engineSettings = new EngineSettings(downloadsPath, listenPort);
engine = new ClientEngine(engineSettings);
}
public PreferencesDialog(MainWindow mainWindow)
{
this.engineSettings = SettingsManager.EngineSettings;
this.prefSettings = SettingsManager.Preferences;
this.labelController = mainWindow.LabelController;
this.trayIcon = mainWindow.TrayIcon;
this.interfaceSettings = mainWindow.InterfaceSettings;
Build();
buildFoldersPanel();
buildImportPanel();
buildLabelPage();
buildConnectionPage();
restorePreferences();
BuildGeneralPage();
SetNames ();
upnpCheckBox.Toggled += OnUpnpCheckBoxToggled;
spinMaxActive.Sensitive = false;
spinMaxSeed.Sensitive = false;
// spinMaxActive.ValueChanged += delegate {
// DownloadQueueService queue = ServiceManager.Get <DownloadQueueService> ();
// queue.MaxActive = spinMaxActive.ValueAsInt;
// };
spinMaxDownload.ValueChanged += delegate {
DownloadQueueService queue = ServiceManager.Get <DownloadQueueService> ();
queue.MaxDownloads = spinMaxActive.ValueAsInt;
};
// spinMaxSeed.ValueChanged += delegate {
// DownloadQueueService queue = ServiceManager.Get <DownloadQueueService> ();
// queue.MaxSeeds = spinMaxActive.ValueAsInt;
// };
}
public GuiGeneralSettings()
{
if (string.IsNullOrEmpty(StartDirectory))
StartDirectory = Environment.CurrentDirectory;
settings = new EngineSettings();
savePath = Path.Combine(StartDirectory, "Downloads");
torrentsPath = Path.Combine(StartDirectory, "Torrents");
}
static void Main(string[] args)
{
var traceListener = new ConsoleTraceListener();
Debug.Listeners.Add(traceListener);
var torrentDefaults = new TorrentSettings(4, 150, 0, 0);
torrentDefaults.UseDht = false;
var engineSettings = new EngineSettings();
engineSettings.PreferEncryption = false;
engineSettings.AllowedEncryption = EncryptionTypes.All;
var clientEngine = new ClientEngine(engineSettings);
StartDownload(clientEngine, torrentDefaults);
}
public static void Main(string[] args)
{
BasicConfigurator.Configure(new ConsoleAppender() {
Layout = new PatternLayout(
"%timestamp [%thread] %-5level %logger{1} - %message%newline")
});
var torrentDefaults = new TorrentSettings(4, 150, 0, 0);
torrentDefaults.UseDht = false;
var engineSettings = new EngineSettings();
engineSettings.PreferEncryption = false;
engineSettings.AllowedEncryption = EncryptionTypes.All;
var clientEngine = new ClientEngine(engineSettings);
StartDownload(clientEngine, torrentDefaults);
}
void SetupEngine()
{
EngineSettings settings = new EngineSettings();
settings.AllowedEncryption = ChooseEncryption();
// If both encrypted and unencrypted connections are supported, an encrypted connection will be attempted
// first if this is true. Otherwise an unencrypted connection will be attempted first.
settings.PreferEncryption = true;
// Torrents will be downloaded here by default when they are registered with the engine
settings.SavePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), "Torrents");
// The maximum upload speed is 200 kilobytes per second, or 204,800 bytes per second
settings.GlobalMaxUploadSpeed = 200 * 1024;
engine = new ClientEngine(settings);
// Tell the engine to listen at port 6969 for incoming connections
engine.ChangeListenEndpoint(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 6969));
}
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 static void TestDownloadFile(string db, string torrentPath, string savePath)
{
//System.Diagnostics.Debugger.Launch();
var dbs = new ChunkDbService(db, false);
var ds = new DeduplicationService(dbs);
var writer = new DedupDiskWriter(ds);
var engineSettings = new EngineSettings();
engineSettings.PreferEncryption = false;
engineSettings.AllowedEncryption = EncryptionTypes.All;
int port = 33123;
var ip = NetUtil.GetLocalIPByInterface("Local Area Connection");
engineSettings.ReportedAddress = new IPEndPoint(ip, port);
var engine = new ClientEngine(engineSettings, new DedupDiskWriter(ds));
var vd = new VirtualDiskDownloadService(engine, new FileInfoTable<TorrentManager>());
var torrent = Torrent.Load(torrentPath);
logger.DebugFormat("Loaded torrent file: {0}, piece length: {1}.",
torrent.Name, torrent.PieceLength);
var filePath = Path.Combine(savePath, torrent.Name);
vd.StartDownloadingFile(torrent, savePath, dbs.GetManagedFile(filePath).ChunkMap.LastPieceInProfile);
Console.Read();
}
public BitTorrentFileTransferProvider()
{
MonoTorrent.Client.Logger.AddListener(new System.Diagnostics.ConsoleTraceListener());
string downloadPath = Core.Settings.IncompleteDownloadDir;
EngineSettings settings = new EngineSettings (downloadPath, 1);
torrentDefaults = new TorrentSettings (4, 60, 0, 0);
listener = new MeshworkPeerConnectionListener ();
engine = new ClientEngine(settings, listener);
Core.FinishedLoading += delegate {
Core.FileTransferManager.FileTransferRemoved += Core_FileTransferRemoved;
};
#if RIDICULOUS_DEBUG_OUTPUT
engine.ConnectionManager.PeerMessageTransferred += delegate (object sender, PeerMessageEventArgs e) {
LoggingService.LogDebug("{0}: {1}", e.Direction, e.Message.GetType().Name);
};
#endif
}
/// <summary>
/// Initializes the Torrent client and its basic core members
/// </summary>
public TorrentClient()
{
saveDirectory = GlobalSettings.DownloadDirectory;
metaSaveDirectory = GlobalSettings.DEFAULT_METADATA_DIRECTORY;
dhtNodeFile = GlobalSettings.DHT_FILE;
resumeFile = GlobalSettings.RESUME_FILE;
Port = GlobalSettings.IncomingPort;
CreateDir(saveDirectory);
CreateDir(metaSaveDirectory);
//initialize engine settings
engineSettings = new EngineSettings();
engineSettings = new EngineSettings(saveDirectory, Port);
engineSettings.AllowedEncryption = MonoTorrent.Client.Encryption.EncryptionTypes.All;
engineSettings.PreferEncryption = GlobalSettings.UseEncryption;
engineSettings.GlobalMaxConnections = GlobalSettings.GlobalMaxConnections;
//initialize torrent settings
torrentSettings = new TorrentSettings();
torrentSettings.EnablePeerExchange = GlobalSettings.UsePeerExchange;
torrentSettings.UseDht = GlobalSettings.UseDht;
torrentSettings.MaxConnections = GlobalSettings.TorrentMaxConnections;
}
public Transfer(string path)
{
this.basePath = Path.GetFullPath(path);
this.torrentsPath = Path.Combine(basePath, "Torrents");
this.fastResumePath = Path.Combine(basePath, "fastresume.data");
this.dhtNodes = Path.Combine(basePath, "dhtNodes.data");
this.downloadsPath = Path.Combine(basePath, "Downloads");
EngineSettings settings = new EngineSettings(downloadsPath, enginePort);
settings.AllowedEncryption = MonoTorrent.Client.Encryption.EncryptionTypes.All;
settings.PreferEncryption = false;
this.engine = new ClientEngine(settings);
engine.ConnectionManager.PeerMessageTransferred += delegate(object o, PeerMessageEventArgs e)
{
Console.WriteLine( e.Message);
};
this.managerCollection = new List<TorrentManager>();
this.defaultSettings = new TorrentSettings(50, 100, 100000, 100000, false);
defaultSettings.UseDht = false;
defaultSettings.EnablePeerExchange = true;
this.startDHT();
}
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);
RegisterDht (new NullDhtEngine());
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>();
CreateRateLimiters();
this.peerId = GeneratePeerId();
localPeerListener = new LocalPeerListener(this);
localPeerManager = new LocalPeerManager();
LocalPeerSearchEnabled = SupportsLocalPeerDiscovery;
listenManager.Register(listener);
// This means we created the listener in the constructor
if (listener.Endpoint.Port == 0)
listener.ChangeEndpoint(new IPEndPoint(IPAddress.Any, settings.ListenPort));
}
public ClientEngine(EngineSettings settings, PeerListener listener)
: this (settings, listener, new DiskWriter())
{
}
public ClientEngine(EngineSettings settings, PieceWriter writer)
: this(settings, new SocketListener(new IPEndPoint(IPAddress.Any, 0)), writer)
{
}
public ClientEngine(EngineSettings settings)
: this (settings, new DiskWriter())
{
}
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();
}
}
static void InitMonoTorrent ()
{
queue = new ArrayList ();
engine_settings = new EngineSettings (config.DownloadDir, config.ListenPort);
torrent_settings = new TorrentSettings (config.UploadSlots, config.MaxConnections,
(int) config.UploadSpeed, (int) config.DownloadSpeed);
engine = new ClientEngine (engine_settings);
// Our store
torrent_list = new TorrentList ();
foreach (TorrentDesc td in config.Torrents){
if (File.Exists (td.Filename)){
torrent_list.Add (td.Filename);
}
}
}
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 ConfigureUnityContainer(IUnityContainer container)
{
#region Common
var dhtTrackerListenerPort =
Int32.Parse(ConfigurationManager.AppSettings["DhtTrackerListeningPort"]);
var infoServerListeningPort = Int32.Parse(ConfigurationManager.AppSettings[
"HttpPieceInfoServerListeningPort"]); // listeningPort
#endregion
#region TorrentSettings
// 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);
container.RegisterInstance<TorrentSettings>(torrentDefaults);
#endregion
#region ClientEngine
// DefaultListenPort = 52138;
var engineSettings = new EngineSettings();
engineSettings.PreferEncryption = false;
engineSettings.AllowedEncryption = EncryptionTypes.All;
var clientEngine = new ClientEngine(engineSettings);
container.RegisterInstance<ClientEngine>(clientEngine);
#endregion
#region DhtProxy
var peerTtlSecs = 60 * 50;
container.RegisterType<DictionaryServiceProxy>(
new InjectionConstructor(typeof(DictionaryServiceBase),
peerTtlSecs));
#endregion
#region DhtTracker
// Singleton.
container.RegisterType<DictionaryServiceTracker>(new ContainerControlledLifetimeManager(),
new InjectionConstructor(
typeof(DictionaryServiceProxy),
string.Format("http://*:{0}/", dhtTrackerListenerPort))); // listeningPrefix
#endregion
#region TorrentHelper
// Singleton.
var cacheBaseDirPath =
ConfigurationManager.AppSettings["BitTorrentManagerBaseDirPath"];
IPAddress ip = NetUtil.GetLocalIPByInterface(
ConfigurationManager.AppSettings["DhtTrackerIface"]);
int gsserverPort = Int32.Parse(ConfigurationManager.AppSettings["GSServerPort"]);
var bittorrentCache = new BitTorrentCache(cacheBaseDirPath);
container.RegisterInstance<BitTorrentCache>(bittorrentCache);
var torrentHelper = new TorrentHelper(
bittorrentCache, ip, dhtTrackerListenerPort, gsserverPort);
container.RegisterInstance<TorrentHelper>(torrentHelper);
#endregion
#region BitTorrentManager
// Singleton.
container.RegisterType<BitTorrentManager>(
new ContainerControlledLifetimeManager(),
new InjectionConstructor(
typeof(BitTorrentCache),
ConfigurationManager.AppSettings["BitTorrentManagerSelfNamespace"],
typeof(DictionaryServiceProxy),
typeof(DictionaryServiceTracker),
typeof(ClientEngine),
typeof(TorrentSettings),
typeof(TorrentHelper),
Boolean.Parse(ConfigurationManager.AppSettings[
"BitTorrentManagerStartSeedingAtStartup"])
));
#endregion
#region IPieceInfoServer
// Singleton.
//container.RegisterType<IPieceInfoServer, HttpPieceInfoServer>(
// new ContainerControlledLifetimeManager(),
// new InjectionConstructor(
// infoServerListeningPort,
// typeof(PieceLevelTorrentManager)));
#endregion
#region PieceLevelTorrentManager
container.RegisterType<PieceLevelTorrentManager>(
new ContainerControlledLifetimeManager(),
new InjectionConstructor(
typeof(BitTorrentManager),
typeof(BitTorrentCache),
typeof(DictionaryServiceProxy),
typeof(TorrentHelper),
infoServerListeningPort));
#endregion
}
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 static void TestReadFile(string db, string torrentPath, string baseDir, string filePath, string origianlFile)
{
//System.Diagnostics.Debugger.Launch();
var kernel = new StandardKernel();
kernel.Load(new ServiceNinjectModule());
kernel.Bind<FileInfoTable<TorrentManager>>().ToSelf().InSingletonScope();
var dbs = new ChunkDbService(db, false);
var ds = new DeduplicationService(dbs);
kernel.Bind<DeduplicationService>().ToConstant(ds).InSingletonScope();
var writer = new DedupDiskWriter(ds);
var engineSettings = new EngineSettings();
engineSettings.PreferEncryption = false;
engineSettings.AllowedEncryption = EncryptionTypes.All;
int port = 33123;
var ip = NetUtil.GetLocalIPByInterface("Local Area Connection");
engineSettings.ReportedAddress = new IPEndPoint(ip, port);
var engine = new ClientEngine(engineSettings, new DedupDiskWriter(ds));
kernel.Bind<DiskManager>().ToConstant(engine.DiskManager).InSingletonScope();
kernel.Bind<ClientEngine>().ToConstant(engine).InSingletonScope();
kernel.Bind<DistributedDiskManager>().ToSelf();
kernel.Bind<FileService>().ToSelf().WithConstructorArgument("baseDir", baseDir);
kernel.Bind<VirtualDiskDownloadService>().ToSelf();
var vd = kernel.Get<VirtualDiskDownloadService>();
var torrent = Torrent.Load(torrentPath);
logger.DebugFormat("Loaded torrent file: {0}, piece length: {1}.",
torrent.Name, torrent.PieceLength);
vd.StartDownloadingFile(torrent, baseDir, -1);
KernelContainer.Kernel = kernel;
var m = new HurricaneServiceManager();
m.Start();
var url = string.Format("http://{0}:18081/FileService/", ip.ToString());
logger.DebugFormat("Contacting service at {0}", url);
var client = new ManualFileServiceClient(url);
string tstmsg = "tstmsg";
var resp = client.Echo(tstmsg);
Assert.AreEqual(resp, tstmsg);
byte[] resultData = null;
try {
var pathStatus = client.GetPathStatus(filePath);
logger.DebugFormat("File size: {0}", pathStatus.FileSize);
} catch (Exception ex) {
logger.Error(ex);
}
try {
// can only read 49352.
resultData = client.Read(filePath, 0, 49253);
} catch (Exception ex) {
logger.Error(ex);
}
var actualData = IOUtil.Read(origianlFile, 0, 49252);
try {
Assert.IsTrue(actualData.SequenceEqual(resultData),
"File part should match.");
logger.Debug("Read succeeded.");
} catch (Exception ex) {
logger.Error(ex);
}
Console.Read();
}
private void LoadEngine()
{
string defaultSavePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "Downloads");
string savePath = _kvs.Get<string>("paths.defaultSavePath", defaultSavePath);
int listenPort = _kvs.Get<int>("bt.listenPort", 6998);
var settings = new EngineSettings
{
AllowedEncryption = EncryptionTypes.All,
GlobalMaxConnections = _kvs.Get("bandwidth.globalMaxConnections", 200),
GlobalMaxDownloadSpeed = _kvs.Get("bandwidth.globalMaxDlSpeed", 0),
GlobalMaxHalfOpenConnections = _kvs.Get("bandwidth.globalMaxHalfConnections", 100),
GlobalMaxUploadSpeed = _kvs.Get("bandwidth.globalMaxUpSpeed", 0),
//HaveSupressionEnabled
MaxOpenFiles = _kvs.Get("diskio.maxOpenFiles", 0),
MaxReadRate = _kvs.Get("diskio.maxReadRate", 0),
MaxWriteRate = _kvs.Get("diskio.maxWriteRate", 0),
PreferEncryption = _kvs.Get("bt.preferEncryption", true),
//ReportedAddress = _kvs.Get<string>("bt.reportedAddress")
SavePath = savePath
};
_clientEngine = new ClientEngine(settings);
_clientEngine.ChangeListenEndpoint(new IPEndPoint(IPAddress.Any, listenPort));
}
public EngineSettingsAdapter(EngineSettings settings, ObjectPath path)
{
this.path = path;
this.settings = settings;
}
/// <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);
}
}
/// <summary>
/// Start listening on specific port
/// </summary>
private void StartEngine()
{
var engineSettings = new EngineSettings(DownloadPath, Port);
engineSettings.PreferEncryption = false;
engineSettings.AllowedEncryption = EncryptionTypes.All;
_engine = new ClientEngine(engineSettings);
_engine.ChangeListenEndpoint(new IPEndPoint(IPAddress.Any, Port));
foreach (string file in from t in Directory.GetFiles(TorrentPath)
where t.EndsWith(".torrent")
select t)
{
AddTorrent(file);
}
}
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 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);
}
}
public void Initialize()
{
string downloadsPath = Client.Settings.StorageAutoSelect ? StorageHelper.GetBestSaveDirectory() : Client.Settings.StoragePath;
if (Client.Settings.TorrentTcpPort == 0)
{
var r = new Random();
int port;
while (!TcpConnectionListener.IsPortFree(port = r.Next(6881, 7000)))
{
}
logger.Info("Auto selected torrent port: {0}", port);
Client.Settings.TorrentTcpPort = port;
}
var engineSettings = new EngineSettings(downloadsPath, Client.Settings.TorrentTcpPort)
{
PreferEncryption = false,
AllowedEncryption = EncryptionTypes.All
};
_torrentDefaults = new TorrentSettings(4, 50, 0, 0);
_engine = new ClientEngine(engineSettings);
_engine.ChangeListenEndpoint(new IPEndPoint(IPAddress.Any, Client.Settings.TorrentTcpPort));
byte[] nodes = null;
try
{
nodes = File.ReadAllBytes(TorrentDhtNodesPath);
}
catch
{
logger.Info("No existing dht nodes could be loaded");
}
var dhtListner = new DhtListener(new IPEndPoint(IPAddress.Any, Client.Settings.TorrentTcpPort));
var 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(TorrentsFolder))
{
Directory.CreateDirectory(TorrentsFolder);
}
BEncodedDictionary fastResume;
try
{
if (File.Exists(TorrentFastResumePath))
{
fastResume = BEncodedValue.Decode <BEncodedDictionary>(File.ReadAllBytes(TorrentFastResumePath));
}
else
{
fastResume = new BEncodedDictionary();
}
}
catch
{
fastResume = new BEncodedDictionary();
}
var knownTorrentsPaths = Directory.GetFiles(TorrentsFolder, "*.torrent");
logger.Info("Loading {0} saved torrents", knownTorrentsPaths.Length);
foreach (var file in knownTorrentsPaths)
{
Torrent torrent;
try
{
torrent = Torrent.Load(file);
}
catch (Exception e)
{
logger.Error("Couldn't decode {0}: ", file);
logger.Error(e.Message);
continue;
}
var manager = new TorrentManager(torrent, downloadsPath, TorrentDefaults);
if (fastResume.ContainsKey(torrent.InfoHash.ToHex()))
{
manager.LoadFastResume(new FastResume((BEncodedDictionary)fastResume[torrent.InfoHash.ToHex()]));
}
RegisterTorrent(manager);
manager.Start();
}
#if DEBUG
FrmDebug = new FrmDownloadDebug();
FrmDebug.Width = Screen.PrimaryScreen.WorkingArea.Width;
FrmDebug.Show();
#endif
}
