public void Process() { if (m_UploadStatistics.Count == 60) { m_UploadStatistics.RemoveAt(59); } m_UploadStatistics.Insert(0, m_Uploaded); m_Uploaded = 0; long upstream = 0; foreach (int n in m_UploadStatistics) { upstream += n; } m_Upstream = (int)(upstream / m_UploadStatistics.Count); m_UpstreamString = Core.TransferVolumeToString(m_Upstream); }
public static void Load() { SetUILanguage(); m_ShareManager = new ShareManager(); Constants.SetMaximumDownloadsCount(int.Parse(Settings.Instance["MaximumDownloadsCount"])); if (!Directory.Exists(Settings.Instance["PreferencesDirectory"])) Directory.CreateDirectory(Settings.Instance["PreferencesDirectory"]); Settings.Instance["PreferencesDirectory"] = new DirectoryInfo(Settings.Instance["PreferencesDirectory"]).FullName; if (!Directory.Exists(Settings.Instance["LogDirectory"])) Directory.CreateDirectory(Settings.Instance["LogDirectory"]); Settings.Instance["LogDirectory"] = new DirectoryInfo(Settings.Instance["LogDirectory"]).FullName; if (!Directory.Exists(Settings.Instance["IncomingDirectory"])) Directory.CreateDirectory(Settings.Instance["IncomingDirectory"]); Settings.Instance["IncomingDirectory"] = new DirectoryInfo(Settings.Instance["IncomingDirectory"]).FullName; if (!Directory.Exists(Settings.Instance["TemporaryDirectory"])) Directory.CreateDirectory(Settings.Instance["TemporaryDirectory"]); Settings.Instance["TemporaryDirectory"] = new DirectoryInfo(Settings.Instance["TemporaryDirectory"]).FullName; if (!Directory.Exists(Settings.Instance["CorruptDirectory"])) Directory.CreateDirectory(Settings.Instance["CorruptDirectory"]); Settings.Instance["CorruptDirectory"] = new DirectoryInfo(Settings.Instance["CorruptDirectory"]).FullName; m_WebCachesFilePath = Path.Combine(Settings.Instance["PreferencesDirectory"], m_WebCachesFilePath); //2009-01-25 Nochbaer m_SearchDBFilePath = Path.Combine(Settings.Instance["PreferencesDirectory"], m_SearchDBFilePath); m_SharedDirectoriesFilePath = Path.Combine(Settings.Instance["PreferencesDirectory"], m_SharedDirectoriesFilePath); m_SharedFilesFilePath = Path.Combine(Settings.Instance["PreferencesDirectory"], m_SharedFilesFilePath); m_SharedFilesStatsFilePath = Path.Combine(Settings.Instance["PreferencesDirectory"], m_SharedFilesStatsFilePath); m_MetaDataFilePath = Path.Combine(Settings.Instance["PreferencesDirectory"], m_MetaDataFilePath); m_CommentsFilePath = Path.Combine(Settings.Instance["PreferencesDirectory"], m_CommentsFilePath); m_RatingsFilePath = Path.Combine(Settings.Instance["PreferencesDirectory"], m_RatingsFilePath); m_StatisticsFilePath = Path.Combine(Settings.Instance["PreferencesDirectory"], m_StatisticsFilePath); m_DownloadsFilePath = Path.Combine(Settings.Instance["PreferencesDirectory"], m_DownloadsFilePath); // initialize logger with log directory // Changed 2007-05-06 by T.Norad if (bool.Parse(Settings.Instance["WriteLogfile"])) { Logger.Instance.initialize(Settings.Instance["LogDirectory"]); } // 2007-05-16 T.Norad ResumeDownloads(); m_Logger.Log(Properties.Resources_Core.StealthNetLoading, String.Format(Constants.Software, Core.Version)); m_Logger.Log(Properties.Resources_Core.DownloadSourcesAllowed, Constants.MaximumDownloadsCount, Constants.MaximumSourcesCount); m_Logger.Log(Properties.Resources_Core.NETFrameworkVersion, Environment.Version.ToString()); m_Logger.Log(Properties.Resources_Core.OSVersion, Environment.OSVersion.ToString()); m_DropChainTailCount = 0; if (GenerateIDOrHash()[47] > 192) while (GenerateIDOrHash()[47] <= 128) m_DropChainTailCount++; m_PeerID = GenerateIDOrHash(); try { UpdateWebServiceProxy update = new UpdateWebServiceProxy(); if (bool.Parse(Settings.Instance["SynchronizeWebCaches"])) { string webCaches = update.GetWebCaches(); if (File.Exists(m_WebCachesFilePath)) { string backupFilePath = string.Format("{0}.bak", m_WebCachesFilePath); if (File.Exists(backupFilePath)) { string backupBackupFilePath = string.Format("{0}.bak", backupFilePath); if (File.Exists(backupBackupFilePath)) File.Delete(backupBackupFilePath); File.Move(backupFilePath, backupBackupFilePath); } File.Move(m_WebCachesFilePath, backupFilePath); } StreamWriter webCachesFileStreamWriter = new StreamWriter(new FileStream(m_WebCachesFilePath, FileMode.Create, FileAccess.Write, FileShare.None)); webCachesFileStreamWriter.Write(webCaches); webCachesFileStreamWriter.Flush(); webCachesFileStreamWriter.Close(); } m_IsUpdateAvailable = update.IsUpdateAvailable(String.Format(Constants.Software, Core.Version)); update.Dispose(); } catch (Exception ex) { m_Logger.Log(ex, "An exception was thrown while updating the list of WebCaches!"); } m_Keys = RSAGenerateKeys(); try { if (File.Exists(m_WebCachesFilePath)) { XmlDocument webCachesXmlDocument = new XmlDocument(); webCachesXmlDocument.Load(m_WebCachesFilePath); foreach (XmlNode webCacheNode in webCachesXmlDocument.SelectSingleNode("webcaches").SelectNodes("webcache")) m_WebCaches.Add(webCacheNode.Attributes["url"].Value); } else if (bool.Parse(Settings.Instance["SynchronizeWebCaches"])) { m_WebCaches.Add("http://rshare.de/rshare.asmx"); m_WebCaches.Add("http://webcache.stealthnet.at/rwpmws.php"); } } catch (Exception ex) { m_Logger.Log(ex, "An exception was thrown while reading WebCaches file!"); } m_ShareManager.LoadConfiguration(m_SharedDirectoriesFilePath, m_SharedFilesFilePath, m_SharedFilesStatsFilePath, m_MetaDataFilePath, m_CommentsFilePath, m_RatingsFilePath); //2009-01-25 Nochbaer if (bool.Parse(Settings.Instance["ActivateSearchDB"])) { m_SearchDBManager = new SearchDBManager(m_SearchDBFilePath); } try { if (File.Exists(m_StatisticsFilePath)) { XmlDocument statisticsXmlDocument = new XmlDocument(); statisticsXmlDocument.Load(m_StatisticsFilePath); XmlNode statisticsXmlNode = statisticsXmlDocument.SelectSingleNode("statistics"); m_CumulativeDownloaded = long.Parse(statisticsXmlNode.SelectSingleNode("downloaded").InnerText); m_CumulativeUploaded = long.Parse(statisticsXmlNode.SelectSingleNode("uploaded").InnerText); m_CumulativeUptime = TimeSpan.Parse(statisticsXmlNode.SelectSingleNode("uptime").InnerText); } } catch (Exception ex) { m_Logger.Log(ex, "An exception was thrown while reading statistics file!"); } // [MONO] the variable 'downloadsXmlNode' seems to be never used /* try { if (File.Exists(m_DownloadsFilePath)) { XmlDocument downloadsXmlDocument = new XmlDocument(); downloadsXmlDocument.Load(m_DownloadsFilePath); XmlNode downloadsXmlNode = downloadsXmlDocument.SelectSingleNode("downloads"); } } catch (Exception ex) { m_Logger.Log(ex, "An exception was thrown while reading downloads file!"); } */ Thread statisticsThread = new Thread(delegate() { RList<int> downloadStatistics = new RList<int>(); int downloadStatisticsRestCount = 0; long downloadStatisticsRest = 0; long averageDownloadStatistics; RList<int> uploadStatistics = new RList<int>(); int uploadStatisticsRestCount = 0; long uploadStatisticsRest = 0; long averageUploadStatistics; while (!m_IsClosing) { m_Downstream = m_CurrentDownstream; m_CurrentDownstream = 0; m_Upstream = m_CurrentUpstream; m_CurrentUpstream = 0; int downstream = m_Downstream; int upstream = m_Upstream; m_Downloaded += downstream; m_Uploaded += upstream; m_CumulativeDownloaded += downstream; m_CumulativeUploaded += upstream; m_Uptime = m_Uptime.Add(TimeSpan.FromSeconds(1)); m_CumulativeUptime = m_CumulativeUptime.Add(TimeSpan.FromSeconds(1)); if (downloadStatistics.Count == 300) { downloadStatisticsRestCount++; downloadStatisticsRest += downloadStatistics[downloadStatistics.Count - 1]; downloadStatistics.RemoveAt(downloadStatistics.Count - 1); } downloadStatistics.Insert(0, downstream); if (m_MinuteAverageDownloadStatistics.Count != 0) { averageDownloadStatistics = 0; for (int n = 0; n < Math.Min(60, downloadStatistics.Count); n++) averageDownloadStatistics += downloadStatistics[n]; if (m_MinuteAverageDownloadStatistics.Count == 300) m_MinuteAverageDownloadStatistics.RemoveAt(m_MinuteAverageDownloadStatistics.Count - 1); m_MinuteAverageDownloadStatistics.Insert(0, (int)(averageDownloadStatistics / Math.Min(60, m_MinuteAverageDownloadStatistics.Count))); } else m_MinuteAverageDownloadStatistics.Insert(0, 0); averageDownloadStatistics = 0; foreach (int item in downloadStatistics) averageDownloadStatistics += item; if (m_AverageDownloadStatistics.Count == 300) m_AverageDownloadStatistics.RemoveAt(m_AverageDownloadStatistics.Count - 1); m_AverageDownloadStatistics.Insert(0, (int)((averageDownloadStatistics + downloadStatisticsRest) / (downloadStatistics.Count + downloadStatisticsRestCount))); if (uploadStatistics.Count == 300) { uploadStatisticsRestCount++; uploadStatisticsRest += uploadStatistics[uploadStatistics.Count - 1]; uploadStatistics.RemoveAt(uploadStatistics.Count - 1); } uploadStatistics.Insert(0, upstream); if (m_MinuteAverageUploadStatistics.Count != 0) { averageUploadStatistics = 0; for (int n = 0; n < Math.Min(60, uploadStatistics.Count); n++) averageUploadStatistics += uploadStatistics[n]; if (m_MinuteAverageUploadStatistics.Count == 300) m_MinuteAverageUploadStatistics.RemoveAt(m_MinuteAverageUploadStatistics.Count - 1); m_MinuteAverageUploadStatistics.Insert(0, (int)(averageUploadStatistics / Math.Min(60, m_MinuteAverageUploadStatistics.Count))); } else m_MinuteAverageUploadStatistics.Insert(0, 0); averageUploadStatistics = 0; foreach (int item in uploadStatistics) averageUploadStatistics += item; if (m_AverageUploadStatistics.Count == 300) m_AverageUploadStatistics.RemoveAt(m_AverageUploadStatistics.Count - 1); m_AverageUploadStatistics.Insert(0, (int)((averageUploadStatistics + uploadStatisticsRest) / (uploadStatistics.Count + uploadStatisticsRestCount))); if (m_ConnectionsStatistics.Count == 300) m_ConnectionsStatistics.RemoveAt(m_ConnectionsStatistics.Count - 1); m_ConnectionsStatistics.Insert(0, m_Connections.Count); Thread.Sleep(1000); } }); statisticsThread.Name = "statisticsThread"; statisticsThread.IsBackground = true; statisticsThread.Start(); Thread lastCommandIDThread = new Thread(delegate() { while (!m_IsClosing) { try { m_LastCommandID.Lock(); for (int n = m_LastCommandID.Count - 1; n >= 0; n--) if (DateTime.Now.Subtract(m_LastCommandID[n].Value).TotalSeconds >= Constants.LastCommandIDTimeout) m_LastCommandID.RemoveAt(n); } catch { } finally { m_LastCommandID.Unlock(); } Thread.Sleep(1000); } }); lastCommandIDThread.Name = "lastCommandIDThread"; lastCommandIDThread.IsBackground = true; lastCommandIDThread.Start(); Thread connectionsThread = new Thread(delegate() { while (!m_IsClosing) { try { m_Connections.Lock(); Connection connection; /* Sum up the total bandwidth used during the last second and * calculate an adjustment, so that the predicted bandwidth for this second * will not exceeded the allowed bandwidth limit. */ int uploadAdjustment = 0; int downloadAdjustment = 0; if ((bool.Parse(Settings.Instance["HasUploadLimit"]) || bool.Parse(Settings.Instance["HasDownloadLimit"])) && Core.Connections.Count != 0) { int totalUp = 0; int totalDown = 0; for (int n = m_Connections.Count - 1; n >= 0; n--) { connection = m_Connections[n].Value; totalUp += connection.UploadLimitUsed; totalDown += connection.DownloadLimitUsed; } uploadAdjustment = (int)((float)(int.Parse(Settings.Instance["UploadLimit"]) - totalUp) / Core.Connections.Count); downloadAdjustment = (int)((float)(int.Parse(Settings.Instance["DownloadLimit"]) - totalDown) / Core.Connections.Count); } for (int n = m_Connections.Count - 1; n >= 0; n--) { connection = m_Connections[n].Value; if (connection.IsDisconnected) m_Connections.RemoveAt(n); else { connection.UploadAdjustment = uploadAdjustment; connection.DownloadAdjustment = downloadAdjustment; connection.Process(); } } } catch { } finally { m_Connections.Unlock(); } Thread.Sleep(1000); } }); connectionsThread.Name = "connectionsThread"; connectionsThread.IsBackground = true; connectionsThread.Start(); Thread peersThread = new Thread(delegate() { while (!m_IsClosing) { try { m_Peers.Lock(); Peer peer; for (int n = m_Peers.Count - 1; n >= 0; n--) { peer = m_Peers[n].Value; if (DateTime.Now.Subtract(peer.LastReceived).TotalSeconds >= Constants.PeerTimeout) m_Peers.RemoveAt(n); else peer.Process(); } } catch { } finally { m_Peers.Unlock(); } Thread.Sleep(1000); } }); peersThread.Name = "peersThread"; peersThread.IsBackground = true; peersThread.Start(); Thread searchesThread = new Thread(delegate() { while (!m_IsClosing) { try { foreach (Search search in m_Searches.Values) search.Process(); } catch { } Thread.Sleep(1000); } }); searchesThread.Name = "searchesThread"; searchesThread.IsBackground = true; searchesThread.Start(); // 06.07.2009 Auto-Move re-implemented (Lars) Thread downloadsThread = new Thread(delegate() { int moveIntervall = 60; bool moveDownloads = false; try { moveIntervall = Int32.Parse(Settings.Instance["AutoMoveDownloadsIntervall"]); if (moveIntervall < 60) moveIntervall = 60; moveDownloads = bool.Parse(Settings.Instance["AutoMoveDownloads"]); } catch (Exception ex) { m_Logger.Log(ex, "An exception was thrown while initializing Auto-Move!"); } while (!m_IsClosing) { try { m_DownloadsAndQueue.Lock(); Download download; for (int n = Math.Min(m_DownloadsAndQueue.Count, Constants.MaximumDownloadsCount) - 1; n >= 0; n--) { download = m_DownloadsAndQueue[n].Value; if (moveDownloads) { // Wir verschieben Downloads if ((download.LastReception == null || !download.LastReception.HasValue || DateTime.Now.Subtract(download.LastReception.Value).TotalMinutes >= moveIntervall) && (download.QueueStart != null && download.QueueStart.HasValue && DateTime.Now.Subtract(download.QueueStart.Value).TotalMinutes >= moveIntervall)) { // Unser Download hat länger als moveIntervall nichts empfangen und // ist bereits länger als moveIntervall gestartet bool flag = false; foreach (Download.Source source in download.Sources.Values) if (source.State == Download.SourceState.Active || source.State == Download.SourceState.Requested) { flag = true; break; } if (!flag && m_DownloadsAndQueue.Count > Constants.MaximumDownloadsCount) { // Der Download wird in die Queue verschoben MoveDownloadToQueue(download.DownloadIDString); m_Logger.Log("Auto-Move: The download of \"{0}\" has been moved to the queue!", download.FileName); } else { // Der Download hat geeignete Quellen und wird daher nicht verschoben download.Process(); } } else { // Unser Download empfängt oder das moveIntervall wurde noch nicht erreicht download.Process(); } } else { // Wir verschieben keine Downloads download.Process(); } } } catch (Exception ex) { m_Logger.Log(ex, "An exception was thrown while processing downloads!"); } finally { m_DownloadsAndQueue.Unlock(); } Thread.Sleep(1000); } }); downloadsThread.Name = "downloadsThread"; downloadsThread.IsBackground = true; downloadsThread.Start(); Thread uploadsThread = new Thread(delegate() { while (!m_IsClosing) { try { m_Uploads.Lock(); Upload upload; for (int n = m_Uploads.Count - 1; n >= 0; n--) { upload = m_Uploads[n].Value; if (DateTime.Now.Subtract(upload.LastRequest).TotalSeconds >= Constants.UploadTimeout) m_Uploads.RemoveAt(n); upload.Process(); } } catch { } finally { m_Uploads.Unlock(); } Thread.Sleep(1000); } }); uploadsThread.Name = "uploadsThread"; uploadsThread.IsBackground = true; uploadsThread.Start(); Thread listeningThread = new Thread(delegate() { try { Socket listeningSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); listeningSocket.Bind(new IPEndPoint(IPAddress.Any, int.Parse(Settings.Instance["Port"]))); listeningSocket.Listen(5); while (!m_IsClosing) { try { Connection connection = new Connection(listeningSocket.Accept()); m_IsAccessible = true; //2008-09-17 : Nochbaer int avgConCount = int.Parse(Settings.Instance["AverageConnectionsCount"]); if (avgConCount > 10) avgConCount = 10; if (m_Connections.Count < (int)((float)avgConCount * 1.25F) && !m_Connections.ContainsKey(connection.RemoteEndPoint.Address)) { m_Connections.Add(connection.RemoteEndPoint.Address, connection); (new Command10(m_Keys)).Send(connection); } else connection.Disconnect(); } catch { } } try { listeningSocket.Shutdown(SocketShutdown.Both); } catch { } try { listeningSocket.Close(); } catch { } } catch (Exception ex) { m_Logger.Log(ex, "An exception was thrown while binding socket at port {0}!", Settings.Instance["Port"]); } }); listeningThread.Name = "listeningThread"; listeningThread.IsBackground = true; listeningThread.Start(); if (!m_WebCaches.IsEmpty) { try { WebCacheProvider webCacheProvider = new WebCacheProvider(m_WebCaches); try { webCacheProvider.RemovePeer(); } catch { } Thread webCacheAddOrRemovePeerThread = new Thread(delegate() { while (!m_IsClosing) { try { //2009-06-02 : Lars int avgConCount = int.Parse(Settings.Instance["AverageConnectionsCount"]); if (avgConCount > 10) avgConCount = 10; if (m_Connections.Count < avgConCount) webCacheProvider.AddPeer(int.Parse(Settings.Instance["Port"])); } catch { } for (int n = 0; !m_IsClosing && n < 120; n++) Thread.Sleep(500); } try { webCacheProvider.RemovePeer(); } catch { } }); webCacheAddOrRemovePeerThread.Name = "webCacheAddOrRemovePeerThread"; webCacheAddOrRemovePeerThread.Start(); Thread webCacheGetPeerThread = new Thread(delegate() { while (!m_IsClosing) { try { //2008-09-17 : Nochbaer int avgConCount = int.Parse(Settings.Instance["AverageConnectionsCount"]); if (avgConCount > 10) avgConCount = 10; while (m_Connections.Count < avgConCount && !m_IsClosing) { string node = webCacheProvider.GetPeer(); if (node == string.Empty) break; string[] endPoint = node.Split(':'); AddConnection(new IPEndPoint(IPAddress.Parse(endPoint[0]), Convert.ToInt32(endPoint[1]))); if (m_Connections.Count < avgConCount - 1) Thread.Sleep(15000); else break; } } catch { } Thread.Sleep(60000); } }); webCacheGetPeerThread.Name = "webCacheGetPeerThread"; webCacheGetPeerThread.IsBackground = true; webCacheGetPeerThread.Start(); } catch (Exception ex) { m_Logger.Log("The WebCache's client could not be initialized properly!", ex); } } Thread OnlineSignatureThread = new Thread(delegate() { SetUILanguage(); while (bool.Parse(Settings.Instance["ActivateOnlineSignature"])) { try { XmlWriterSettings onlineSignatureXmlWriterSettings = new XmlWriterSettings(); onlineSignatureXmlWriterSettings.CloseOutput = true; onlineSignatureXmlWriterSettings.Indent = true; MemoryStream memoryStream = new MemoryStream(); XmlWriter onlineSignatureXmlWriter = XmlWriter.Create(memoryStream, onlineSignatureXmlWriterSettings); onlineSignatureXmlWriter.WriteStartDocument(); onlineSignatureXmlWriter.WriteStartElement("onlinesignature"); onlineSignatureXmlWriter.WriteStartElement("software"); onlineSignatureXmlWriter.WriteValue(String.Format(Constants.Software, Core.Version)); onlineSignatureXmlWriter.WriteEndElement(); onlineSignatureXmlWriter.WriteStartElement("connections"); onlineSignatureXmlWriter.WriteValue(m_Connections.Count); onlineSignatureXmlWriter.WriteEndElement(); onlineSignatureXmlWriter.WriteStartElement("downloads"); onlineSignatureXmlWriter.WriteValue(m_DownloadsAndQueue.Count); onlineSignatureXmlWriter.WriteEndElement(); onlineSignatureXmlWriter.WriteStartElement("downloadqueue"); onlineSignatureXmlWriter.WriteValue("0"); onlineSignatureXmlWriter.WriteEndElement(); onlineSignatureXmlWriter.WriteStartElement("activeuploads"); onlineSignatureXmlWriter.WriteValue(m_Uploads.Count > Constants.MaximumUploadsCount ? Constants.MaximumUploadsCount : m_Uploads.Count); onlineSignatureXmlWriter.WriteEndElement(); onlineSignatureXmlWriter.WriteStartElement("uploads"); onlineSignatureXmlWriter.WriteValue(m_Uploads.Count); onlineSignatureXmlWriter.WriteEndElement(); onlineSignatureXmlWriter.WriteStartElement("sharedfiles"); onlineSignatureXmlWriter.WriteValue(m_ShareManager.SharedFiles.Count); onlineSignatureXmlWriter.WriteEndElement(); onlineSignatureXmlWriter.WriteStartElement("downloadcapacity"); onlineSignatureXmlWriter.WriteValue(Settings.Instance["DownloadCapacity"]); onlineSignatureXmlWriter.WriteEndElement(); onlineSignatureXmlWriter.WriteStartElement("uploadcapacity"); onlineSignatureXmlWriter.WriteValue(Settings.Instance["UploadCapacity"]); onlineSignatureXmlWriter.WriteEndElement(); onlineSignatureXmlWriter.WriteStartElement("downloadlimit"); onlineSignatureXmlWriter.WriteValue(bool.Parse(Settings.Instance["HasDownloadLimit"]) ? Settings.Instance["DownloadLimit"] : "0"); onlineSignatureXmlWriter.WriteEndElement(); onlineSignatureXmlWriter.WriteStartElement("uploadlimit"); onlineSignatureXmlWriter.WriteValue(bool.Parse(Settings.Instance["HasUploadLimit"]) ? Settings.Instance["UploadLimit"] : "0"); onlineSignatureXmlWriter.WriteEndElement(); onlineSignatureXmlWriter.WriteStartElement("language"); onlineSignatureXmlWriter.WriteValue(Settings.Instance["UICulture"]); onlineSignatureXmlWriter.WriteEndElement(); onlineSignatureXmlWriter.WriteStartElement("cumulativedownloaded"); onlineSignatureXmlWriter.WriteValue(m_CumulativeDownloaded); onlineSignatureXmlWriter.WriteEndElement(); onlineSignatureXmlWriter.WriteStartElement("cumulativeuploaded"); onlineSignatureXmlWriter.WriteValue(m_CumulativeUploaded); onlineSignatureXmlWriter.WriteEndElement(); onlineSignatureXmlWriter.WriteStartElement("downloaded"); onlineSignatureXmlWriter.WriteValue(m_Downloaded); onlineSignatureXmlWriter.WriteEndElement(); onlineSignatureXmlWriter.WriteStartElement("uploaded"); onlineSignatureXmlWriter.WriteValue(m_Uploaded); onlineSignatureXmlWriter.WriteEndElement(); onlineSignatureXmlWriter.WriteStartElement("downstream"); onlineSignatureXmlWriter.WriteValue(m_MinuteAverageDownloadStatistics[0].ToString()); onlineSignatureXmlWriter.WriteEndElement(); onlineSignatureXmlWriter.WriteStartElement("upstream"); onlineSignatureXmlWriter.WriteValue(m_MinuteAverageUploadStatistics[0].ToString()); onlineSignatureXmlWriter.WriteEndElement(); onlineSignatureXmlWriter.WriteStartElement("cumulativeuptime"); onlineSignatureXmlWriter.WriteValue(m_CumulativeUptime.ToString()); onlineSignatureXmlWriter.WriteEndElement(); onlineSignatureXmlWriter.WriteStartElement("uptime"); onlineSignatureXmlWriter.WriteValue(m_Uptime.ToString()); onlineSignatureXmlWriter.WriteEndElement(); onlineSignatureXmlWriter.WriteEndElement(); onlineSignatureXmlWriter.Flush(); FileStream fileStream = new FileStream(Path.Combine(Settings.Instance["PreferencesDirectory"], "onlinesignature.xml"), FileMode.Create, FileAccess.Write, FileShare.Read); byte[] buffer = memoryStream.ToArray(); fileStream.Write(buffer, 0, buffer.Length); onlineSignatureXmlWriter.Close(); fileStream.Flush(); fileStream.Close(); } catch (Exception ex) { m_Logger.Log(ex, Properties.Resources_Core.Exception_OnlineSignature); } Thread.Sleep(int.Parse(Settings.Instance["OnlineSignatureUpdateIntervall"]) * 60 * 1000); } }); OnlineSignatureThread.Name = "onlineSignatureThread"; OnlineSignatureThread.IsBackground = true; OnlineSignatureThread.Start(); //2008-05-22-Eroli: Writing downloads.xml every 5 minutes to prevent loosing the sectorsMap if StealthNet crashes //2009-02-16 Nochbaer: Also statistics.xml Thread backupThread = new Thread(delegate() { DateTime lastDownloads = DateTime.MinValue; DateTime lastStatistics = DateTime.MinValue; while (!m_IsClosing) { if (DownloadsXmlWriter.IsReady && DateTime.Now.Subtract(lastDownloads).TotalMinutes >= 5) { DownloadsXmlWriter.Write(m_DownloadsFilePath, m_DownloadsAndQueue); lastDownloads = DateTime.Now; } if (DateTime.Now.Subtract(lastStatistics).TotalMinutes >= 5) { try { StatisticsXmlWriter.write(m_StatisticsFilePath, m_CumulativeDownloaded.ToString(), m_CumulativeUploaded.ToString(), m_CumulativeUptime.ToString()); } catch (Exception ex) { m_Logger.Log(ex, "An exception was thrown while writing statistics.xml!"); } if (m_ShareManager.IsReady) { try { m_ShareManager.SaveConfiguration(m_SharedDirectoriesFilePath, m_SharedFilesFilePath, m_SharedFilesStatsFilePath, m_MetaDataFilePath, m_CommentsFilePath, m_RatingsFilePath); } catch (Exception ex) { m_Logger.Log(ex, "An exception was thrown while writing shared files index!"); } } lastStatistics = DateTime.Now; } Thread.Sleep(60000); } }); backupThread.Name = "backupThread"; backupThread.IsBackground = true; backupThread.Start(); Thread collectingThread = new Thread(delegate() { while (!m_IsClosing) { GC.Collect(); GC.WaitForPendingFinalizers(); GC.Collect(); GC.WaitForPendingFinalizers(); Thread.Sleep(60000); } }); collectingThread.Name = "collectingThread"; collectingThread.IsBackground = true; collectingThread.Start(); m_Logger.Log(Properties.Resources_Core.StealthNetLoaded, String.Format(Constants.Software, Core.Version)); }
private static void SendBroadcast(IRequestCommand command, IPAddress excludedConnection, int dropChainTailCount) { if (command == null) throw new ArgumentNullException("command"); try { m_Connections.Lock(); RList<Connection> connections = new RList<Connection>(); foreach (Connection connection in m_Connections.Values) if (connection.IsEstablished && !connection.RemoteEndPoint.Address.Equals(excludedConnection)) connections.Add(connection); dropChainTailCount = Math.Min(dropChainTailCount, connections.Count); for (int n = 0; n < dropChainTailCount; n++) { int index = Randomizer.GenerateNumber(0, connections.Count); command.Send(connections[index]); connections.RemoveAt(index); } } finally { m_Connections.Unlock(); } }