version 0.3.0

AUTHORS

@@ -1,4 +1,4 @@
 nzbget:
 	Sven Henkel <sidddy@users.sourceforge.net>				(versions 0.1.0 - ?)
 	Bo Cordes Petersen <placebodk@users.sourceforge.net>	(versions ? - 0.2.3)
-	Andrey Prygunkov <hugbug@users.sourceforge.net>		    (versions 0.3.0 and later)
+	Andrei Prygounkov <hugbug@users.sourceforge.net>		(versions 0.3.0 - 0.3.*)

ArticleDownloader.cpp

@@ -0,0 +1,719 @@
+/*
+ *  This file if part of nzbget
+ *
+ *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef WIN32
+#include "win32.h"
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#ifdef WIN32
+#include <direct.h>
+#else
+#include <unistd.h>
+#include <sys/time.h>
+#endif
+#include <sys/stat.h>
+
+#include "nzbget.h"
+#include "ArticleDownloader.h"
+#include "Decoder.h"
+#include "Log.h"
+#include "Options.h"
+#include "ServerPool.h"
+#include "Util.h"
+
+extern DownloadSpeedMeter* g_pDownloadSpeedMeter;
+extern Options* g_pOptions;
+extern ServerPool* g_pServerPool;
+
+const char* ArticleDownloader::m_szJobStatus[] = { "WAITING", "RUNNING", "FINISHED", "FAILED", "DECODING", "JOINING", "NOT_FOUND", "FATAL_ERROR" };
+
+ArticleDownloader::ArticleDownloader()
+{
+	debug("Creating ArticleDownloader");
+
+	m_szResultFilename	= NULL;
+	m_szTempFilename	= NULL;
+	m_szArticleFilename	= NULL;
+	m_szInfoName		= NULL;
+	m_pConnection		= NULL;
+	m_pDecoder			= NULL;
+	m_eStatus			= adUndefined;
+	m_iBytes			= 0;
+	memset(&m_tStartTime, 0, sizeof(m_tStartTime));
+	SetLastUpdateTimeNow();
+}
+
+ArticleDownloader::~ArticleDownloader()
+{
+	debug("Destroying ArticleDownloader");
+
+	if (m_szTempFilename)
+	{
+		free(m_szTempFilename);
+	}
+	if (m_szArticleFilename)
+	{
+		free(m_szArticleFilename);
+	}
+	if (m_szInfoName)
+	{
+		free(m_szInfoName);
+	}
+	if (m_pDecoder)
+	{
+		delete m_pDecoder;
+	}
+}
+
+void ArticleDownloader::SetTempFilename(const char* v)
+{
+	m_szTempFilename = strdup(v);
+}
+
+void ArticleDownloader::SetInfoName(const char * v)
+{
+	m_szInfoName = strdup(v);
+}
+
+void ArticleDownloader::SetStatus(EStatus eStatus)
+{
+	m_eStatus = eStatus;
+	Notify(NULL);
+}
+
+void ArticleDownloader::Run()
+{
+	debug("Entering ArticleDownloader-loop");
+
+	SetStatus(adRunning);
+	m_szResultFilename = m_pArticleInfo->GetResultFilename();
+
+	if (g_pOptions->GetContinuePartial())
+	{
+		struct stat buffer;
+		bool fileExists = !stat(m_szResultFilename, &buffer);
+		if (fileExists)
+		{
+			// file exists from previous program's start
+			info("Article %s already downloaded, skipping", m_szInfoName);
+			m_semInitialized.Post();
+			m_semWaited.Wait();
+			SetStatus(adFinished);
+			return;
+		}
+	}
+
+	info("Downloading %s", m_szInfoName);
+
+	int retry = g_pOptions->GetRetries();
+
+	EStatus Status = adFailed;
+	int iMaxLevel = g_pServerPool->GetMaxLevel();
+	int* LevelStatus = (int*)malloc((iMaxLevel + 1) * sizeof(int));
+	for (int i = 0; i <= iMaxLevel; i++)
+	{
+		LevelStatus[i] = 0;
+	}
+	int level = 0;
+
+	m_semInitialized.Post();
+	m_semWaited.Wait();
+
+	//while (true) usleep(10); // DEBUG TEST
+
+	while (!IsStopped() && (retry > 0))
+	{
+		SetLastUpdateTimeNow();
+
+		Status = adFailed;
+
+		if (!m_pConnection)
+		{
+			m_pConnection = g_pServerPool->GetConnection(level);
+		}
+
+		if (IsStopped())
+		{
+			Status = adFailed;
+			break;
+		}
+
+		if (!m_pConnection)
+		{
+			debug("m_pConnection is NULL");
+			error("Serious error: Connection is NULL");
+		}
+		
+		// test connection
+		bool connected = m_pConnection && m_pConnection->Connect() >= 0;
+		if (connected && !IsStopped())
+		{
+			// Okay, we got a Connection. Now start downloading!!
+			Status = Download();
+		}
+
+		if (connected)
+		{
+			// freeing connection allows other threads to start.
+			// we doing this only if the problem was with article or group.
+			// if the problem occurs by Connect() we do not free the connection,
+			// to prevent starting of thousands of threads (cause each of them
+			// will also free it's connection after the same connect-error).
+			FreeConnection();
+		}
+
+		if ((Status == adFailed) && ((retry > 1) || !connected) && !IsStopped())
+		{
+			info("Waiting %i sec to retry", g_pOptions->GetRetryInterval());
+			int msec = 0;
+			while (!IsStopped() && (msec < g_pOptions->GetRetryInterval() * 1000))
+			{
+				usleep(100 * 1000);
+				msec += 100;
+			}
+		}
+
+		if (IsStopped())
+		{
+			Status = adFailed;
+			break;
+		}
+
+		if ((Status == adFinished) || (Status == adFatalError))
+		{
+			break;
+		}
+
+		LevelStatus[level] = Status;
+
+		bool bAllLevelNotFound = true;
+		for (int lev = 0; lev <= iMaxLevel; lev++)
+		{
+			if (LevelStatus[lev] != adNotFound)
+			{
+				bAllLevelNotFound = false;
+				break;
+			}
+		}
+		if (bAllLevelNotFound)
+		{
+			if (iMaxLevel > 0)
+			{
+				warn("Aticle %s @ all servers failed: Article not found", m_szInfoName);
+			}
+			break;
+		}
+
+		// do not count connect-errors, only article- and group-errors
+		if (connected)
+		{
+			level++;
+			if (level > iMaxLevel)
+			{
+				level = 0;
+			}
+			retry--;
+		}
+	}
+
+	FreeConnection();
+
+	free(LevelStatus);
+
+	if (Status != adFinished)
+	{
+		Status = adFailed;
+	}
+
+	if (Status == adFailed)
+	{
+		if (IsStopped())
+		{
+			info("Download %s cancelled", m_szInfoName);
+		}
+		else
+		{
+			warn("Download %s failed", m_szInfoName);
+		}
+	}
+
+	SetStatus(Status);
+
+	debug("Existing ArticleDownloader-loop");
+}
+
+ArticleDownloader::EStatus ArticleDownloader::Download()
+{
+	// at first, change group! dryan's level wants it this way... ;-)
+	bool grpchanged = false;
+	for (FileInfo::Groups::iterator it = m_pFileInfo->GetGroups()->begin(); it != m_pFileInfo->GetGroups()->end(); it++)
+	{
+		grpchanged = m_pConnection->JoinGroup(*it) == 0;
+		if (grpchanged)
+		{
+			break;
+		}
+	}
+
+	if (!grpchanged)
+	{
+		warn("Article %s @ %s failed: Could not join group", m_szInfoName, m_pConnection->GetServer()->GetHost());
+		return adFailed;
+	}
+
+	// now, let's begin!
+	char tmp[1024];
+	snprintf(tmp, 1024, "ARTICLE %s\r\n", m_pArticleInfo->GetMessageID());
+	tmp[1024-1] = '\0';
+
+	char* answer = NULL;
+
+	for (int retry = 3; retry > 0; retry--)
+	{
+		answer = m_pConnection->Request(tmp);
+		if (answer && (!strncmp(answer, "2", 1)))
+		{
+			break;
+		}
+	}
+
+	if (!answer)
+	{
+		warn("Article %s @ %s failed: Connection closed by remote host", m_szInfoName, m_pConnection->GetServer()->GetHost());
+		return adFailed;
+	}
+	if (strncmp(answer, "2", 1))
+	{
+		warn("Article %s @ %s failed: %s", m_szInfoName, m_pConnection->GetServer()->GetHost(), answer);
+		return adNotFound;
+	}
+
+	// positive answer!
+
+	const char* dnfilename = m_szTempFilename;
+	FILE* outfile = fopen(dnfilename, "w");
+                                                                        
+	if (!outfile)
+	{
+		error("Could not create file %s", dnfilename);
+		return adFatalError;
+	}
+
+	gettimeofday(&m_tStartTime, 0);
+	m_iBytes = 0;
+
+	EStatus Status = adRunning;
+	const int LineBufSize = 1024*10;
+	char* szLineBuf = (char*)malloc(LineBufSize);
+
+	while (!IsStopped())
+	{
+		SetLastUpdateTimeNow();
+
+		// Throttle the bandwidth
+		while (!IsStopped() && (g_pOptions->GetDownloadRate() > 0.0f) &&
+		        (g_pDownloadSpeedMeter->CalcCurrentDownloadSpeed() > g_pOptions->GetDownloadRate()))
+		{
+			SetLastUpdateTimeNow();
+			usleep(200 * 1000);
+		}
+
+		struct _timeval tSpeedReadingStartTime;
+		gettimeofday(&tSpeedReadingStartTime, 0);
+
+		char* line = m_pConnection->ReadLine(szLineBuf, LineBufSize);
+
+		// Have we encountered a timeout?
+		if (!line)
+		{
+			Status = adFailed;
+			break;
+		}
+
+		//detect end of article
+		if ((!strcmp(line, ".\r\n")) || (!strcmp(line, ".\n")))
+		{
+			break;
+		}
+
+		// Did we meet an unexpected need for authorization?
+		if (!strncmp(line, "480", 3))
+		{
+			m_pConnection->Authenticate();
+		}
+
+		//detect lines starting with "." (marked as "..")
+		if (!strncmp(line, "..", 2))
+		{
+			line++;
+		}
+
+		int wrcnt = (int)fwrite(line, 1, strlen(line), outfile);
+		if (wrcnt > 0)
+		{
+			m_iBytes += wrcnt;
+		}
+	}
+
+	free(szLineBuf);
+	fflush(outfile);
+	fclose(outfile);
+
+	if (IsStopped())
+	{
+		remove(dnfilename);
+		return adFailed;
+	}
+
+	if (Status == adFailed)
+	{
+		warn("Unexpected end of %s", m_szInfoName);
+		remove(dnfilename);
+		return adFailed;
+	}
+
+	FreeConnection();
+
+	if ((g_pOptions->GetDecoder() == Options::dcUulib) ||
+	        (g_pOptions->GetDecoder() == Options::dcYenc))
+	{
+		// Give time to other threads. Help to avoid hangs on Asus WL500g router.
+		usleep(10 * 1000);
+
+		SetStatus(adDecoding);
+		struct _timeval StartTime, EndTime;
+		gettimeofday(&StartTime, 0);
+		bool OK = false;
+		if (g_pOptions->GetDecoder() == Options::dcUulib)
+		{
+			m_pDecoder = new Decoder();
+			m_pDecoder->SetKind(Decoder::dcUulib);
+		}
+		else if (g_pOptions->GetDecoder() == Options::dcYenc)
+		{
+			m_pDecoder = new Decoder();
+			m_pDecoder->SetKind(Decoder::dcYenc);
+		}
+		if (m_pDecoder)
+		{
+			m_pDecoder->SetSrcFilename(dnfilename);
+
+			char tmpdestfile[1024];
+			snprintf(tmpdestfile, 1024, "%s.dec", m_szResultFilename);
+			tmpdestfile[1024-1] = '\0';
+					
+			m_pDecoder->SetDestFilename(tmpdestfile);
+			OK = m_pDecoder->Execute();
+			if (OK)
+			{
+				rename(tmpdestfile, m_szResultFilename);
+			}
+			else
+			{
+				remove(tmpdestfile);
+			}
+			if (m_pDecoder->GetArticleFilename())
+			{
+				m_szArticleFilename = strdup(m_pDecoder->GetArticleFilename());
+			}
+			delete m_pDecoder;
+			m_pDecoder = NULL;
+		}
+
+		gettimeofday(&EndTime, 0);
+		remove(dnfilename);
+#ifdef WIN32
+		float fDeltaTime = (float)((EndTime.time - StartTime.time) * 1000 + (EndTime.millitm - StartTime.millitm));
+#else
+		float fDeltaTime = ((EndTime.tv_sec - StartTime.tv_sec) * 1000000 + (EndTime.tv_usec - StartTime.tv_usec)) / 1000.0;
+#endif
+		if (OK)
+		{
+			info("Successfully downloaded %s", m_szInfoName);
+			debug("Decode time %.1f ms", fDeltaTime);
+			return adFinished;
+		}
+		else
+		{
+			warn("Decoding %s failed", m_szInfoName);
+			remove(m_szResultFilename);
+			return adFailed;
+		}
+	}
+	else if (g_pOptions->GetDecoder() == Options::dcNone)
+	{
+		// rawmode
+		rename(dnfilename, m_szResultFilename);
+		info("Article %s successfully downloaded", m_szInfoName);
+		return adFinished;
+	}
+	else
+	{
+		// should not occur
+		error("Internal error: Decoding %s failed", m_szInfoName);
+		return adFatalError;
+	}
+}
+
+void ArticleDownloader::LogDebugInfo()
+{
+	char szTime[50];
+#ifdef HAVE_CTIME_R_3
+		ctime_r(&m_tLastUpdateTime, szTime, 50);
+#else
+		ctime_r(&m_tLastUpdateTime, szTime);
+#endif
+
+	debug("      Download: status=%s, LastUpdateTime=%s, filename=%s", GetStatusText(), szTime, BaseFileName(GetTempFilename()));
+	if (m_pDecoder)
+	{
+		m_pDecoder->LogDebugInfo();
+	}
+}
+
+void ArticleDownloader::Stop()
+{
+	debug("Trying to stop ArticleDownloader");
+	Thread::Stop();
+	m_mutexConnection.Lock();
+	if (m_pConnection)
+	{
+		m_pConnection->Cancel();
+	}
+	m_mutexConnection.Unlock();
+	debug("ArticleDownloader stopped successfuly");
+}
+
+void ArticleDownloader::FreeConnection()
+{
+	if (m_pConnection)
+	{
+		debug("Releasing connection");
+		m_mutexConnection.Lock();
+		m_pConnection->Disconnect();
+		g_pServerPool->FreeConnection(m_pConnection);
+		m_pConnection = NULL;
+		m_mutexConnection.Unlock();
+	}
+}
+
+void ArticleDownloader::CompleteFileParts()
+{
+	debug("Completing file parts");
+	debug("ArticleFilename: %s", m_pFileInfo->GetFilename());
+	SetStatus(adJoining);
+
+	char ofn[1024];
+	snprintf(ofn, 1024, "%s%c%s", m_pFileInfo->GetDestDir(), (int)PATH_SEPARATOR, m_pFileInfo->GetFilename());
+	ofn[1024-1] = '\0';
+
+	char szNZBNiceName[1024];
+	m_pFileInfo->GetNiceNZBName(szNZBNiceName, 1024);
+	
+	char InfoFilename[1024];
+	snprintf(InfoFilename, 1024, "%s%c%s", szNZBNiceName, (int)PATH_SEPARATOR, m_pFileInfo->GetFilename());
+	InfoFilename[1024-1] = '\0';
+
+	// Ensure the DstDir is created
+	mkdir(m_pFileInfo->GetDestDir(), S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
+
+	if (g_pOptions->GetDecoder() == Options::dcNone)
+	{
+		info("Moving articles for %s", InfoFilename);
+	}
+	else
+	{
+		info("Joining articles for %s", InfoFilename);
+	}
+
+	// prevent overwriting existing files
+	struct stat statbuf;
+	int dupcount = 0;
+	while (!stat(ofn, &statbuf))
+	{
+		dupcount++;
+		snprintf(ofn, 1024, "%s%c%s_duplicate%d", m_pFileInfo->GetDestDir(), (int)PATH_SEPARATOR, m_pFileInfo->GetFilename(), dupcount);
+		ofn[1024-1] = '\0';
+	}
+
+	FILE* outfile = NULL;
+
+	char tmpdestfile[1024];
+	snprintf(tmpdestfile, 1024, "%s.tmp", ofn);
+	tmpdestfile[1024-1] = '\0';
+	remove(tmpdestfile);
+
+	if ((g_pOptions->GetDecoder() == Options::dcUulib) ||
+	        (g_pOptions->GetDecoder() == Options::dcYenc))
+	{
+		outfile = fopen(tmpdestfile, "w+");
+		if (!outfile)
+		{
+			error("Could not create file %s!", tmpdestfile);
+			SetStatus(adFinished);
+			return;
+		}
+	}
+	else if (g_pOptions->GetDecoder() == Options::dcNone)
+	{
+		mkdir(ofn, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
+	}
+
+	bool complete = true;
+	int iBrokenCount = 0;
+	static const int BUFFER_SIZE = 1024 * 50;
+	char* buffer = (char*)malloc(BUFFER_SIZE);
+
+	for (FileInfo::Articles::iterator it = m_pFileInfo->GetArticles()->begin(); it != m_pFileInfo->GetArticles()->end(); it++)
+	{
+		ArticleInfo* pa = *it;
+		if (pa->GetStatus() != ArticleInfo::aiFinished)
+		{
+			iBrokenCount++;
+			complete = false;
+		}
+		else if ((g_pOptions->GetDecoder() == Options::dcUulib) ||
+		         (g_pOptions->GetDecoder() == Options::dcYenc))
+		{
+			FILE* infile;
+			const char* fn = pa->GetResultFilename();
+
+			infile = fopen(fn, "r");
+			if (infile)
+			{
+				int cnt = BUFFER_SIZE;
+
+				while (cnt == BUFFER_SIZE)
+				{
+					cnt = (int)fread(buffer, 1, BUFFER_SIZE, infile);
+					fwrite(buffer, 1, cnt, outfile);
+					SetLastUpdateTimeNow();
+					usleep(10); // give time to other threads
+				}
+
+				fclose(infile);
+			}
+			else
+			{
+				complete = false;
+				iBrokenCount++;
+				info("Could not find file %s. Status is broken", fn);
+			}
+		}
+		else if (g_pOptions->GetDecoder() == Options::dcNone)
+		{
+			const char* fn = pa->GetResultFilename();
+			char dstFileName[1024];
+			snprintf(dstFileName, 1024, "%s%c%03i", ofn, (int)PATH_SEPARATOR, pa->GetPartNumber());
+			dstFileName[1024-1] = '\0';
+			rename(fn, dstFileName);
+		}
+	}
+	free(buffer);
+
+	if ((g_pOptions->GetDecoder() == Options::dcUulib) ||
+	        (g_pOptions->GetDecoder() == Options::dcYenc))
+	{
+		fclose(outfile);
+		rename(tmpdestfile, ofn);
+	}
+
+	for (FileInfo::Articles::iterator it = m_pFileInfo->GetArticles()->begin(); it != m_pFileInfo->GetArticles()->end(); it++)
+	{
+		ArticleInfo* pa = *it;
+		remove(pa->GetResultFilename());
+	}
+
+	if (complete)
+	{
+		info("Successfully downloaded %s", InfoFilename);
+	}
+	else
+	{
+		warn("%i of %i article downloads failed for \"%s\"", iBrokenCount, m_pFileInfo->GetArticles()->size(), InfoFilename);
+
+		if (g_pOptions->GetRenameBroken())
+		{
+			char brokenfn[1024];
+			snprintf(brokenfn, 1024, "%s_broken", ofn);
+			brokenfn[1024-1] = '\0';
+			bool OK = rename(ofn, brokenfn) == 0;
+			if (OK)
+			{
+				info("Renaming broken file from %s to %s", ofn, brokenfn);
+			}
+			else
+			{
+				warn("Renaming broken file from %s to %s failed", ofn, brokenfn);
+			}
+		}
+		else
+		{
+			info("Not renaming broken file %s", ofn);
+		}
+
+		if (g_pOptions->GetCreateBrokenLog())
+		{
+			char szBrokenLogName[1024];
+			snprintf(szBrokenLogName, 1024, "%s%c_brokenlog.txt", m_pFileInfo->GetDestDir(), (int)PATH_SEPARATOR);
+			szBrokenLogName[1024-1] = '\0';
+			FILE* file = fopen(szBrokenLogName, "a");
+			fprintf(file, "%s (%i/%i)\n", m_pFileInfo->GetFilename(), m_pFileInfo->GetArticles()->size() - iBrokenCount, m_pFileInfo->GetArticles()->size());
+			fclose(file);
+		}
+
+		warn("%s is incomplete!", InfoFilename);
+	}
+
+	SetStatus(adFinished);
+}
+
+bool ArticleDownloader::Terminate()
+{
+	NNTPConnection* pConnection = m_pConnection;
+	bool terminated = Kill();
+	if (terminated && pConnection)
+	{
+		debug("Terminating connection");
+		pConnection->Cancel();
+		g_pServerPool->FreeConnection(pConnection);
+	}
+	return terminated;
+}
+
+void ArticleDownloader::WaitInit()
+{
+	// waiting until the download becomes ready to catch connection,
+	// but no longer then 30 seconds
+	m_semInitialized.TimedWait(30000);
+	m_semWaited.Post();
+}

ArticleDownloader.h

@@ -1,8 +1,8 @@
 /*
- *  This file is part of nzbget
+ *  This file if part of nzbget
  *
- *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
- *  Copyright (C) 2007-2014 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -16,7 +16,7 @@
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  *
  * $Revision$
  * $Date$
@@ -28,6 +28,9 @@
 #define ARTICLEDOWNLOADER_H
 
 #include <time.h>
+#ifdef WIN32
+#include <sys/timeb.h>
+#endif
 
 #include "Observer.h"
 #include "DownloadInfo.h"
@@ -42,16 +45,11 @@ public:
 	{
 		adUndefined,
 		adRunning,
-		adWaiting,
 		adFinished,
 		adFailed,
-		adRetry,
-		adCrcError,
 		adDecoding,
 		adJoining,
-		adJoined,
 		adNotFound,
-		adConnectError,
 		adFatalError
 	};
 			
@@ -65,50 +63,58 @@ private:
 	char*				m_szTempFilename;
 	char*				m_szArticleFilename;
 	char*				m_szInfoName;
-	char*				m_szOutputFilename;
 	time_t				m_tLastUpdateTime;
-	Decoder::EFormat	m_eFormat;
-	YDecoder			m_YDecoder;
-	UDecoder			m_UDecoder;
-	FILE*				m_pOutFile;
-	bool				m_bDuplicate;
-	ServerStatList		m_ServerStats;
+	Decoder*			m_pDecoder;
+	Semaphore			m_semInitialized;
+	Semaphore			m_semWaited;
+	static const char*	m_szJobStatus[];
+#ifdef WIN32
+	struct _timeb		m_tStartTime;
+#else
+	struct timeval		m_tStartTime;
+#endif
+	int					m_iBytes;
 
 	EStatus				Download();
-	bool				Write(char* szLine, int iLen);
-	bool				PrepareFile(char* szLine);
-	bool				CreateOutputFile(int iSize);
-	void				BuildOutputFilename();
-	EStatus				DecodeCheck();
-	void				FreeConnection(bool bKeepConnected);
-	EStatus				CheckResponse(const char* szResponse, const char* szComment);
-	void				SetStatus(EStatus eStatus) { m_eStatus = eStatus; }
-	const char* 		GetTempFilename() { return m_szTempFilename; }
-	void 				SetTempFilename(const char* v);
-	void 				SetOutputFilename(const char* v);
+	void				FreeConnection();
 
 public:
 						ArticleDownloader();
-	virtual				~ArticleDownloader();
+						~ArticleDownloader();
 	void				SetFileInfo(FileInfo* pFileInfo) { m_pFileInfo = pFileInfo; }
 	FileInfo*			GetFileInfo() { return m_pFileInfo; }
 	void				SetArticleInfo(ArticleInfo* pArticleInfo) { m_pArticleInfo = pArticleInfo; }
 	ArticleInfo*		GetArticleInfo() { return m_pArticleInfo; }
+	void				SetStatus(EStatus eStatus);
 	EStatus				GetStatus() { return m_eStatus; }
-	ServerStatList*		GetServerStats() { return &m_ServerStats; }
+	const char*			GetStatusText() { return m_szJobStatus[m_eStatus]; }
 	virtual void		Run();
 	virtual void		Stop();
 	bool				Terminate();
 	time_t				GetLastUpdateTime() { return m_tLastUpdateTime; }
 	void				SetLastUpdateTimeNow() { m_tLastUpdateTime = ::time(NULL); }
+	const char* 		GetTempFilename() { return m_szTempFilename; }
+	void 				SetTempFilename(const char* v);
 	const char* 		GetArticleFilename() { return m_szArticleFilename; }
 	void				SetInfoName(const char* v);
 	const char*			GetInfoName() { return m_szInfoName; }
 	void				CompleteFileParts();
-	static bool			MoveCompletedFiles(NZBInfo* pNZBInfo, const char* szOldDestDir);
-	void				SetConnection(NNTPConnection* pConnection) { m_pConnection = pConnection; }
+	void				WaitInit();
+#ifdef WIN32
+	struct _timeb*		GetStartTime() { return &m_tStartTime; }
+#else
+	struct timeval*		GetStartTime() { return &m_tStartTime; }
+#endif
+	int					GetBytes() { return m_iBytes; }
 
 	void				LogDebugInfo();
 };
 
+class DownloadSpeedMeter
+{
+public:
+	virtual				~DownloadSpeedMeter() {};
+	virtual float		CalcCurrentDownloadSpeed() = 0;
+};
+                      
 #endif

ColoredFrontend.cpp

@@ -1,8 +1,8 @@
 /*
  *  This file if part of nzbget
  *
- *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
- *  Copyright (C) 2007-2010 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -16,7 +16,7 @@
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  *
  * $Revision$
  * $Date$
@@ -41,7 +41,6 @@
 
 #include "nzbget.h"
 #include "ColoredFrontend.h"
-#include "Util.h"
 
 ColoredFrontend::ColoredFrontend()
 {
@@ -74,49 +73,52 @@ void ColoredFrontend::PrintStatus()
 	char tmp[1024];
 	char timeString[100];
 	timeString[0] = '\0';
-	int iCurrentDownloadSpeed = m_bStandBy ? 0 : m_iCurrentDownloadSpeed;
 
-	if (iCurrentDownloadSpeed > 0 && !m_bPauseDownload)
+	if (m_fCurrentDownloadSpeed > 0.0f)
 	{
-		long long remain_sec = (long long)(m_lRemainingSize / iCurrentDownloadSpeed);
-		int h = (int)(remain_sec / 3600);
-		int m = (int)((remain_sec % 3600) / 60);
-		int s = (int)(remain_sec % 60);
-		sprintf(timeString, " (~ %.2d:%.2d:%.2d)", h, m, s);
+		long long remain_sec = m_lRemainingSize / ((long long int)(m_fCurrentDownloadSpeed * 1024));
+		int h = 0;
+		int m = 0;
+		int s = 0;
+		while (remain_sec > 3600)
+		{
+			h++;
+			remain_sec -= 3600;
+		}
+
+		while (remain_sec > 60)
+		{
+			m++;
+			remain_sec -= 60;
+		}
+
+		s = remain_sec;
+
+		sprintf(timeString, "(~ %.2d:%.2d:%.2d)", h, m, s);
 	}
 
+	const char* szPause[] = { "Paused", "" };
+	int iPauseIdx = m_bPause ? 0 : 1;
+
 	char szDownloadLimit[128];
-	if (m_iDownloadLimit > 0)
+	if (m_fDownloadLimit > 0.0f)
 	{
-		sprintf(szDownloadLimit, ", Limit %.0f KB/s", (float)m_iDownloadLimit / 1024.0);
+		sprintf(szDownloadLimit, "Limit %.0f KB/S", m_fDownloadLimit);
 	}
 	else
 	{
 		szDownloadLimit[0] = 0;
 	}
 
-    char szPostStatus[128];
-    if (m_iPostJobCount > 0)
-    {
-        sprintf(szPostStatus, ", %i post-job%s", m_iPostJobCount, m_iPostJobCount > 1 ? "s" : "");
-    }
-    else
-    {
-        szPostStatus[0] = 0;
-    }
-
 #ifdef WIN32
 	char* szControlSeq = "";
 #else
 	printf("\033[s");
-	const char* szControlSeq = "\033[K";
+	char* szControlSeq = "\033[K";
 #endif
-
-	snprintf(tmp, 1024, " %d threads, %.*f KB/s, %.2f MB remaining%s%s%s%s%s\n", 
-		m_iThreadCount, (iCurrentDownloadSpeed >= 10*1024 ? 0 : 1), (float)iCurrentDownloadSpeed / 1024.0, 
-		(float)(Util::Int64ToFloat(m_lRemainingSize) / 1024.0 / 1024.0), timeString, szPostStatus, 
-		m_bPauseDownload ? (m_bStandBy ? ", Paused" : ", Pausing") : "",
-		szDownloadLimit, szControlSeq);
+	snprintf(tmp, 1024, "%d threads running, %.0f KB/s, %.2f MB remaining %s %s %s%s\n", 
+		m_iThreadCount, m_fCurrentDownloadSpeed, (float)(m_lRemainingSize / 1024.0 / 1024.0), 
+		timeString, szPause[iPauseIdx], szDownloadLimit, szControlSeq);
 	tmp[1024-1] = '\0';
 	printf("%s", tmp);
 	m_bNeedGoBack = true;
@@ -124,6 +126,7 @@ void ColoredFrontend::PrintStatus()
 
 void ColoredFrontend::PrintMessage(Message * pMessage)
 {
+	const char* msg = pMessage->GetText();
 #ifdef WIN32
 	switch (pMessage->GetKind())
 	{
@@ -143,18 +146,10 @@ void ColoredFrontend::PrintMessage(Message * pMessage)
 			SetConsoleTextAttribute(m_hConsole, 2);
 			printf("[INFO]");
 			break;
-		case Message::mkDetail:
-			SetConsoleTextAttribute(m_hConsole, 2);
-			printf("[DETAIL]");
-			break;
 	}
 	SetConsoleTextAttribute(m_hConsole, 7);
-	char* msg = strdup(pMessage->GetText());
-	CharToOem(msg, msg);
 	printf(" %s\n", msg);
-	free(msg);
 #else
-	const char* msg = pMessage->GetText();
 	switch (pMessage->GetKind())
 	{
 		case Message::mkDebug:
@@ -169,9 +164,6 @@ void ColoredFrontend::PrintMessage(Message * pMessage)
 		case Message::mkInfo:
 			printf("\033[32m[INFO]\033[39m %s\033[K\n", msg);
 			break;
-		case Message::mkDetail:
-			printf("\033[32m[DETAIL]\033[39m %s\033[K\n", msg);
-			break;
 	}
 #endif
 }

ColoredFrontend.h

@@ -2,7 +2,7 @@
  *  This file if part of nzbget
  *
  *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
- *  Copyright (C) 2007  Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -16,7 +16,7 @@
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  *
  * $Revision$
  * $Date$

Connection.cpp

@@ -0,0 +1,507 @@
+/*
+ *  This file if part of nzbget
+ *
+ *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef WIN32
+#include "win32.h"
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#ifndef WIN32
+#include <netdb.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#endif
+
+#include "nzbget.h"
+#include "Connection.h"
+#include "Log.h"
+
+void Connection::Init()
+{
+	debug("Intiializing global connection data");
+
+#ifdef WIN32
+	WSADATA wsaData;
+	int err = WSAStartup(MAKEWORD(2, 0), &wsaData);
+	if (err != 0) 
+	{
+		error("Could not initialize socket library");
+		return;
+	}
+	if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE( wsaData.wVersion ) != 0) 
+	{
+		error("Could not initialize socket library");
+		WSACleanup();
+		return; 
+	}
+#endif
+}
+
+void Connection::Final()
+{
+	debug("Finalizing global connection data");
+
+#ifdef WIN32
+	WSACleanup();
+#endif
+}
+
+
+Connection::Connection(NetAddress* pNetAddress)
+{
+	debug("Creating Connection");
+
+	m_pNetAddress		= pNetAddress;
+	m_eStatus			= csDisconnected;
+	m_iSocket			= INVALID_SOCKET;
+	m_iBufAvail			= 0;
+	m_bCanceling		= false;
+	m_iTimeout			= 60;
+}
+
+Connection::~Connection()
+{
+	debug("Destroying Connection");
+
+	if (m_eStatus == csConnected)
+	{
+		Disconnect();
+	}
+}
+
+int Connection::Connect()
+{
+	debug("Connecting");
+
+	if (m_eStatus == csConnected)
+		return 0;
+
+	int iRes = DoConnect();
+
+	if (iRes >= 0)
+		m_eStatus = csConnected;
+	else
+		Connection::DoDisconnect();
+
+	return iRes;
+}
+
+int Connection::Disconnect()
+{
+	debug("Disconnecting");
+
+	if (m_eStatus == csDisconnected)
+		return 0;
+
+	int iRes = DoDisconnect();
+
+	m_eStatus = csDisconnected;
+
+	return iRes;
+}
+
+int Connection::Bind()
+{
+	debug("Binding");
+
+	if (m_eStatus == csListening)
+	{
+		return 0;
+	}
+
+	int iRes = DoBind();
+
+	m_eStatus = csListening;
+
+	return iRes;
+}
+
+int Connection::WriteLine(char* line)
+{
+	//debug("Connection::write(char* line)");
+
+	if (m_eStatus != csConnected)
+	{
+		return -1;
+	}
+
+	int iRes = DoWriteLine(line);
+
+	if (iRes == EOF)
+		Connection::DoDisconnect();
+
+	return iRes;
+}
+
+int Connection::Send(char* pBuffer, int iSize)
+{
+	debug("Sending data");
+
+	if (m_eStatus != csConnected)
+	{
+		return -1;
+	}
+
+	int iRes = send(m_iSocket, pBuffer, iSize, 0);
+
+	return iRes;
+}
+
+char* Connection::ReadLine(char* pBuffer, int iSize)
+{
+	if (m_eStatus != csConnected)
+	{
+		return NULL;
+	}
+
+	char* res = DoReadLine(pBuffer, iSize);
+
+	if (res == NULL)
+		Connection::DoDisconnect();
+
+	return res;
+}
+
+SOCKET Connection::Accept()
+{
+	debug("Accepting connection");
+
+	if (m_eStatus != csListening)
+	{
+		return INVALID_SOCKET;
+	}
+
+	SOCKET iRes = DoAccept();
+
+	return iRes;
+}
+
+int Connection::Recv(char* pBuffer, int iSize)
+{
+	debug("Receiving data");
+
+	memset(pBuffer, 0, iSize);
+
+	int iReceived = recv(m_iSocket, pBuffer, iSize, 0);
+
+	if (iReceived < 0)
+	{
+		ReportError("Could not receive data on socket", NULL, 0);
+	}
+
+	return iReceived;
+}
+
+bool Connection::RecvAll(char * pBuffer, int iSize)
+{
+	debug("Receiving data (full buffer)");
+
+	memset(pBuffer, 0, iSize);
+
+	char* pBufPtr = (char*)pBuffer;
+	int NeedBytes = iSize;
+	// Read from the socket until nothing remains
+	while (NeedBytes > 0)
+	{
+		int iReceived = recv(m_iSocket, pBufPtr, NeedBytes, 0);
+		// Did the recv succeed?
+		if (iReceived <= 0)
+		{
+			ReportError("Could not receive data on socket", NULL, 0);
+			return false;
+		}
+		pBufPtr += iReceived;
+		NeedBytes -= iReceived;
+	}
+	return true;
+}
+
+int Connection::DoConnect()
+{
+	debug("Do connecting");
+
+	struct sockaddr_in	sSocketAddress;
+	memset(&sSocketAddress, '\0', sizeof(sSocketAddress));
+	sSocketAddress.sin_family = AF_INET;
+	sSocketAddress.sin_port = htons(m_pNetAddress->GetPort());
+	sSocketAddress.sin_addr.s_addr = ResolveHostAddr(m_pNetAddress->GetHost());
+	if (sSocketAddress.sin_addr.s_addr == (unsigned int)-1)
+	{
+		return -1;
+	}
+
+	m_iSocket = socket(PF_INET, SOCK_STREAM, 0);
+
+	if (m_iSocket == INVALID_SOCKET)
+	{
+		ReportError("Socket creation failed for %s!", m_pNetAddress->GetHost(), 0);
+		return -1;
+	}
+
+	int res = connect(m_iSocket , (struct sockaddr *) & sSocketAddress, sizeof(sSocketAddress));
+
+	if (res < 0)
+	{
+		ReportError("Connection to %s failed!", m_pNetAddress->GetHost(), 0);
+		return -1;
+	}
+
+#ifdef WIN32
+	int MSecVal = m_iTimeout * 1000;
+	int err = setsockopt(m_iSocket, SOL_SOCKET, SO_RCVTIMEO, (char*)&MSecVal, sizeof(MSecVal));
+#else
+	struct timeval TimeVal;
+	TimeVal.tv_sec = m_iTimeout;
+	TimeVal.tv_usec = 0;
+	int err = setsockopt(m_iSocket, SOL_SOCKET, SO_RCVTIMEO, (char*)&TimeVal, sizeof(TimeVal));
+#endif
+	if (err != 0)
+	{
+		ReportError("setsockopt failed", NULL, 0);
+	}
+
+	return 0;
+}
+
+unsigned int Connection::ResolveHostAddr(const char* szHost)
+{
+	unsigned int uaddr = inet_addr(szHost);
+	if (uaddr == (unsigned int)-1)
+	{
+		struct hostent* hinfo;
+		bool err = false;
+		int h_errnop;
+#ifdef WIN32
+		hinfo = gethostbyname(szHost);
+		err = hinfo == NULL;
+		h_errnop = WSAGetLastError();
+#else
+		struct hostent hinfobuf;
+		static const int strbuflen = 1024;
+		char* strbuf = (char*)malloc(strbuflen);
+#ifdef HAVE_GETHOSTBYNAME_R_6
+		err = gethostbyname_r(szHost, &hinfobuf, strbuf, strbuflen, &hinfo, &h_errnop);
+#else
+		hinfo = gethostbyname_r(szHost, &hinfobuf, strbuf, strbuflen, &h_errnop);
+		err = hinfo == NULL;
+#endif			
+#endif
+		if (err)
+		{
+			ReportError("Could not resolve hostname %s", szHost, h_errnop);
+#ifndef WIN32
+			free(strbuf);
+#endif
+			return (unsigned int)-1;
+		}
+
+		memcpy(&uaddr, hinfo->h_addr_list[0], sizeof(uaddr));
+#ifndef WIN32
+		free(strbuf);
+#endif
+	}
+	return uaddr;
+}
+
+int Connection::DoDisconnect()
+{
+	debug("Do disconnecting");
+
+	if (m_iSocket > 0)
+	{
+		closesocket(m_iSocket);
+		m_iSocket = INVALID_SOCKET;
+	}
+
+	m_eStatus = csDisconnected;
+	return 0;
+}
+
+int Connection::DoWriteLine(char* szText)
+{
+	//debug("Connection::doWrite()");
+	return send(m_iSocket, szText, strlen(szText), 0);
+}
+
+char* Connection::DoReadLine(char* pBuffer, int iSize)
+{
+	//debug( "Connection::DoReadLine()" );
+	char* pBufPtr = pBuffer;
+	iSize--; // for trailing '0'
+	int iBufAvail = m_iBufAvail; // local variable is faster
+	char* szBufPtr = m_szBufPtr; // local variable is faster
+	while (iSize)
+	{
+		if (!iBufAvail)
+		{
+			iBufAvail = recv(m_iSocket, m_szReadBuf, ReadBufLen, 0);
+			if (iBufAvail < 0)
+			{
+				ReportError("Could not receive data on socket", NULL, 0);
+				break;
+			}
+			else if (iBufAvail == 0)
+			{
+				break;
+			}
+			szBufPtr = m_szReadBuf;
+			m_szReadBuf[iBufAvail] = '\0';
+		}
+
+		int len = 0;
+		char* p = (char*)memchr(szBufPtr, '\n', iBufAvail);
+		if (p)
+		{
+			len = p - szBufPtr + 1;
+		}
+		else
+		{
+			len = iBufAvail;
+		}
+
+		if (len > iSize)
+		{
+			len = iSize;
+		}
+		
+		memcpy(pBufPtr, szBufPtr, len);
+		pBufPtr += len;
+		szBufPtr += len;
+		iBufAvail -= len;
+		
+		if (p)
+		{
+			break;
+		}
+		iSize--;
+	}
+	*pBufPtr = '\0';
+
+	m_iBufAvail = iBufAvail > 0 ? iBufAvail : 0; // copy back to member
+	m_szBufPtr = szBufPtr; // copy back to member
+	
+	if (pBufPtr == pBuffer)
+	{
+		return NULL;
+	}
+	return pBuffer;
+}
+
+int Connection::DoBind()
+{
+	debug("Do binding");
+
+	m_iSocket = socket(PF_INET, SOCK_STREAM, 0);
+	if (m_iSocket == INVALID_SOCKET)
+	{
+		ReportError("Socket creation failed for %s!", m_pNetAddress->GetHost(), 0);
+		return -1;
+	}
+
+	struct sockaddr_in	sSocketAddress;
+	memset(&sSocketAddress, '\0', sizeof(sSocketAddress));
+	sSocketAddress.sin_family = AF_INET;
+	sSocketAddress.sin_addr.s_addr = htonl(INADDR_ANY);
+	sSocketAddress.sin_port = htons(m_pNetAddress->GetPort());
+	int opt = 1;
+	setsockopt(m_iSocket, SOL_SOCKET, SO_REUSEADDR, (char*)&opt, sizeof(opt));
+
+	if (bind(m_iSocket, (struct sockaddr *) &sSocketAddress, sizeof(sSocketAddress)) < 0)
+	{
+		ReportError("Binding socket failed for %s", m_pNetAddress->GetHost(), 0);
+		return -1;
+	}
+
+	if (listen(m_iSocket, 10) < 0)
+	{
+		ReportError("Listen on socket failed for %s", m_pNetAddress->GetHost(), 0);
+		return -1;
+	}
+
+	return 0;
+}
+
+SOCKET Connection::DoAccept()
+{
+	struct sockaddr_in ClientAddress;
+	socklen_t SockLen;
+
+	SockLen = sizeof(ClientAddress);
+
+	SOCKET iSocket = accept(GetSocket(), (struct sockaddr *) & ClientAddress, &SockLen);
+
+	if (iSocket == INVALID_SOCKET && !m_bCanceling)
+	{
+		ReportError("Could not accept connection", NULL, 0);
+	}
+
+	return iSocket;
+}
+
+void Connection::Cancel()
+{
+	debug("Cancelling connection");
+	m_bCanceling = true;
+	if (m_iSocket != INVALID_SOCKET)
+	{
+		int r = shutdown(m_iSocket, SHUT_RDWR);
+		if (r == -1)
+		{
+			ReportError("Could not shutdown connection", NULL, 0);
+		}
+		m_eStatus = csCancelled;
+	}
+}
+
+void Connection::ReportError(const char* szMsgPrefix, const char* szMsgArg, int ErrCode)
+{
+	if (ErrCode == 0)
+	{
+#ifdef WIN32
+		ErrCode = WSAGetLastError();
+#else
+		ErrCode = errno;
+#endif
+	}
+
+	char szErrPrefix[1024];
+	snprintf(szErrPrefix, 1024, szMsgPrefix, szMsgArg);
+	szErrPrefix[1024-1] = '\0';
+#ifdef WIN32
+	debug("%s: ErrNo %i", szErrPrefix, ErrCode);
+#else
+	const char* szErrMsg = hstrerror(ErrCode);
+	debug("%s: ErrNo %i, %s", szErrPrefix, ErrCode, szErrMsg);
+#endif
+}

Connection.h

@@ -0,0 +1,84 @@
+/*
+ *  This file if part of nzbget
+ *
+ *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifndef CONNECTION_H
+#define CONNECTION_H
+
+#include "NetAddress.h"
+
+class Connection
+{
+public:
+	enum EStatus
+	{
+		csConnected,
+		csDisconnected,
+		csListening,
+		csCancelled
+	};
+	
+protected:
+	NetAddress* 		m_pNetAddress;
+	SOCKET				m_iSocket;
+	static const int	ReadBufLen = 1024;
+	char				m_szReadBuf[ReadBufLen + 1];
+	int					m_iBufAvail;
+	char*				m_szBufPtr;
+	EStatus				m_eStatus;
+	bool				m_bCanceling;
+	int					m_iTimeout;
+	unsigned int		ResolveHostAddr(const char* szHost);
+	void				ReportError(const char* szMsgPrefix, const char* szMsgArg, int ErrCode);
+
+public:
+						Connection(NetAddress* pNetAddress);
+	virtual 			~Connection();
+	static void			Init();
+	static void			Final();
+	int 				Connect();
+	int					Disconnect();
+	int					Bind();
+	int					Send(char* pBuffer, int iSize);
+	int					Recv(char* pBuffer, int iSize);
+	bool				RecvAll(char* pBuffer, int iSize);
+	char*				ReadLine(char* pBuffer, int iSize);
+	int					WriteLine(char* text);
+	SOCKET				Accept();
+	void				Cancel();
+	NetAddress*			GetServer() { return m_pNetAddress; }
+	SOCKET				GetSocket() { return m_iSocket; }
+	void				SetTimeout(int iTimeout) { m_iTimeout = iTimeout; }
+
+protected:
+	virtual int 		DoConnect();
+	virtual int			DoDisconnect();
+	int					DoBind();
+	int					DoWriteLine(char* text);
+	char*				DoReadLine(char* pBuffer, int iSize);
+	SOCKET				DoAccept();
+};
+
+#endif

Decoder.cpp

@@ -0,0 +1,383 @@
+/*
+ *  This file if part of nzbget
+ *
+ *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef WIN32
+#include "win32.h"
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#ifndef WIN32
+#include <unistd.h>
+#endif
+
+#include "nzbget.h"
+
+#ifdef ENABLE_UULIB
+#ifndef PROTOTYPES
+#define PROTOTYPES
+#endif
+#include <uudeview.h>
+#endif
+
+//#define USEEXTERNALDECODER	// not working
+//#define DEBUGDECODER
+
+#include "Decoder.h"
+#include "Log.h"
+#include "Options.h"
+#include "Util.h"
+
+#ifdef DEBUGDECODER
+int g_iDecoderID = 0;
+#endif
+
+Mutex Decoder::m_mutexDecoder;
+unsigned int Decoder::crc_tab[256];
+
+void Decoder::Init()
+{
+	debug("Initializing global decoder");
+	crc32gentab();
+}
+
+void Decoder::Final()
+{
+	debug("Finalizing global Decoder");
+}
+
+Decoder::Decoder()
+{
+	debug("Creating Decoder");
+
+	m_szSrcFilename		= NULL;
+	m_szDestFilename	= NULL;
+	m_szArticleFilename	= NULL;
+	m_eKind				= dcYenc;
+	m_iDebugStatus		= 0;
+	m_iDebugLines		= 0;
+}
+
+Decoder::~ Decoder()
+{
+	debug("Destroying Decoder");
+
+	if (m_szArticleFilename)
+	{
+		free(m_szArticleFilename);
+	}
+}
+
+bool Decoder::Execute()
+{
+	if (m_eKind == dcUulib)
+	{
+		return DecodeUulib();
+	}
+	else
+	{
+		return DecodeYenc();
+	}
+}
+
+bool Decoder::DecodeUulib()
+{
+	bool res = false;
+
+#ifndef ENABLE_UULIB
+	error("Program was compiled without option ENABLE_UULIB defined. uulib-Decoder is not available.");
+#else
+
+	m_mutexDecoder.Lock();
+
+#ifdef DEBUGDECODER
+	debug("Decoding ID %i (%s)", g_iDecoderID, szSrcFilename);
+#endif
+
+#ifndef USEEXTERNALDECODER
+	UUInitialize();
+
+	UUSetOption(UUOPT_DESPERATE, 1, NULL);
+	//  UUSetOption(UUOPT_DUMBNESS,1,NULL);
+	// UUSetOption( UUOPT_SAVEPATH, 1, szDestDir );
+
+	UULoadFile((char*) m_szSrcFilename, NULL, 0);
+
+	// choose right attachment
+
+	uulist* attachment = NULL;
+
+	for (int i = 0; ; i++)
+	{
+		uulist* att_tmp = UUGetFileListItem(i);
+
+		if (!att_tmp)
+		{
+			break;
+		}
+
+		if ((att_tmp) && (att_tmp->haveparts))
+		{
+			if (!attachment)
+			{
+				attachment = att_tmp;
+			}
+			else
+			{
+				//f**k, multiple attachments!? Can't handle this.
+				attachment = NULL;
+				break;
+			}
+		}
+	}
+
+	if (attachment)
+	{
+		// okay, we got only one attachment, perfect!
+		if ((attachment->haveparts) && (attachment->haveparts[0])) //  && (!attachment->haveparts[1]))  FUCK UULIB
+		{
+			int r = UUDecodeFile(attachment, (char*)m_szDestFilename);
+
+			if (r == UURET_OK)
+			{
+				// we did it!
+				res = true;
+				m_szArticleFilename = strdup(attachment->filename);
+			}
+		}
+		else
+		{
+			error("[ERROR] Wrong number of parts!\n");
+		}
+	}
+	else
+	{
+		error("[ERROR] Wrong number of attachments!\n");
+	}
+
+	UUCleanUp();
+#else
+	execl("/usr/local/bin", "uudeview", szSrcFilename, szDestFilename);
+#endif
+
+#ifdef DEBUGDECODER
+	debug("Finished decoding ID %i (%s)", g_iDecoderID++, szDestFilename);
+#endif
+
+	m_mutexDecoder.Unlock();
+
+#endif // ENABLE_UULIB
+
+	return res;
+}
+
+/**
+  * Very primitive (but fast) implementation of yEnc-Decoder
+  */
+bool Decoder::DecodeYenc()
+{
+	FILE* infile = fopen(m_szSrcFilename, "r");
+	if (!infile)
+	{
+		error("Could not open file \"%s\"", m_szSrcFilename);
+		return false;
+	}
+
+	FILE* outfile = fopen(m_szDestFilename, "w");
+	if (!outfile)
+	{
+		error("Could not create file \"%s\"", m_szDestFilename);
+		fclose(infile);
+		return false;
+	}
+
+	static const int MAX_LINE_LEN = 1024;
+	char buffer[MAX_LINE_LEN];
+	bool body = false;
+	bool end = false;
+	unsigned long expectedCRC = 0;
+	unsigned long calculatedCRC = 0xFFFFFFFF;
+	m_iDebugStatus = 1;
+	bool eof = !fgets(buffer, sizeof(buffer), infile);
+	m_iDebugLines++;
+	m_iDebugStatus = 2;
+	while (!eof)
+	{
+		if (body)
+		{
+			if (strstr(buffer, "=yend size="))
+			{
+				end = true;
+				m_iDebugStatus = 3;
+				char* pc = strstr(buffer, "pcrc32=");
+				if (pc)
+				{
+					pc += 7; //=strlen("pcrc32=")
+					expectedCRC = strtoul(pc, NULL, 16);
+				}
+				break;
+			}
+			m_iDebugStatus = 4;
+			char* iptr = buffer;
+			char* optr = buffer;
+			while (*iptr)
+			{
+				switch (*iptr)
+				{
+					case '=':	//escape-sequence
+						iptr++;
+						*optr = *iptr - 64 - 42;
+						*optr++;
+						break;
+					case '\n':	// ignored char
+					case '\r':	// ignored char
+						break;
+					default:	// normal char
+						*optr = *iptr - 42;
+						*optr++;
+						break;
+				}
+				iptr++;
+			}
+			m_iDebugStatus = 5;
+			calculatedCRC = crc32m(calculatedCRC, (unsigned char *)buffer, optr - buffer);
+			fwrite(buffer, 1, optr - buffer, outfile);
+			m_iDebugStatus = 6;
+		}
+		else
+		{
+			if (strstr(buffer, "=ypart begin="))
+			{
+				m_iDebugStatus = 7;
+				body = true;
+			}
+			else if (strstr(buffer, "=ybegin part="))
+			{
+				m_iDebugStatus = 8;
+				char* pb = strstr(buffer, "name=");
+				if (pb)
+				{
+					m_iDebugStatus = 9;
+					pb += 5; //=strlen("name=")
+					char* pe;
+					for (pe = pb; *pe != '\0' && *pe != '\n' && *pe != '\r'; pe++) ;
+					m_szArticleFilename = (char*)malloc(pe - pb + 1);
+					strncpy(m_szArticleFilename, pb, pe - pb);
+					m_szArticleFilename[pe - pb] = '\0';
+					m_iDebugStatus = 10;
+				}
+				m_iDebugStatus = 11;
+			}
+		}
+		m_iDebugStatus = 12;
+		eof = !fgets(buffer, sizeof(buffer), infile);
+		m_iDebugStatus = 13;
+		m_iDebugLines++;
+	}
+	m_iDebugStatus = 14;
+
+	calculatedCRC ^= 0xFFFFFFFF;
+
+	debug("Expected pcrc32=%x", expectedCRC);
+	debug("Calculated pcrc32=%x", calculatedCRC);
+	if (expectedCRC != calculatedCRC)
+	{
+		warn("CRC-Error for \"%s\"", m_szDestFilename);
+	}
+
+	fclose(infile);
+	fclose(outfile);
+
+	return body && end;
+}
+
+/* from crc32.c (http://www.koders.com/c/fid699AFE0A656F0022C9D6B9D1743E697B69CE5815.aspx)
+ *
+ * (c) 1999,2000 Krzysztof Dabrowski
+ * (c) 1999,2000 ElysiuM deeZine
+ * Released under GPL (thanks)
+ *
+ * chksum_crc32gentab() --      to a global crc_tab[256], this one will
+ *				calculate the crcTable for crc32-checksums.
+ *				it is generated to the polynom [..]
+ */
+void Decoder::crc32gentab()
+{
+	unsigned long crc, poly;
+	int i, j;
+
+	poly = 0xEDB88320L;
+	for (i = 0; i < 256; i++)
+	{
+		crc = i;
+		for (j = 8; j > 0; j--)
+		{
+			if (crc & 1)
+			{
+				crc = (crc >> 1) ^ poly;
+			}
+			else
+			{
+				crc >>= 1;
+			}
+		}
+		crc_tab[i] = crc;
+	}
+}
+
+/* This is modified version of chksum_crc() from
+ * crc32.c (http://www.koders.com/c/fid699AFE0A656F0022C9D6B9D1743E697B69CE5815.aspx)
+ * (c) 1999,2000 Krzysztof Dabrowski
+ * (c) 1999,2000 ElysiuM deeZine
+ *
+ * chksum_crc() -- to a given block, this one calculates the
+ *				crc32-checksum until the length is
+ *				reached. the crc32-checksum will be
+ *				the result.
+ */
+unsigned long Decoder::crc32m(unsigned long startCrc, unsigned char *block, unsigned int length)
+{
+	register unsigned long crc;
+	unsigned long i;
+
+	crc = startCrc;
+	for (i = 0; i < length; i++)
+	{
+		crc = ((crc >> 8) & 0x00FFFFFF) ^ crc_tab[(crc ^ *block++) & 0xFF];
+	}
+	return crc;
+}
+
+void Decoder::LogDebugInfo()
+{
+	debug("        Decoder: status=%i, lines=%i, filename=%s, ArticleFileName=%s",
+	      m_iDebugStatus, m_iDebugLines, BaseFileName(m_szSrcFilename), m_szArticleFilename);
+}

Decoder.h

@@ -0,0 +1,72 @@
+/*
+ *  This file if part of nzbget
+ *
+ *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifndef DECODER_H
+#define DECODER_H
+
+#include "Thread.h"
+
+//#define DECODER_INTERNAL_FGETS
+
+class Decoder
+{
+public:
+	enum EKind
+	{
+	    dcUulib,
+	    dcYenc
+	};
+
+private:
+	static Mutex	m_mutexDecoder;
+	static unsigned int		crc_tab[256];
+	EKind			m_eKind;
+	const char*		m_szSrcFilename;
+	const char*		m_szDestFilename;
+	char*			m_szArticleFilename;
+	int				m_iDebugStatus;
+	int				m_iDebugLines;
+
+	bool			DecodeUulib();
+	bool			DecodeYenc();
+	static void		crc32gentab();
+	unsigned long		crc32m(unsigned long startCrc, unsigned char *block, unsigned int length);
+
+public:
+	Decoder();
+	~Decoder();
+	bool			Execute();
+	void			SetKind(EKind eKind) { m_eKind = eKind; }
+	void			SetSrcFilename(const char* szSrcFilename) { m_szSrcFilename = szSrcFilename; }
+	void			SetDestFilename(const char* szDestFilename) { m_szDestFilename = szDestFilename; }
+	const char*		GetArticleFilename() { return m_szArticleFilename; }
+	void			LogDebugInfo();
+
+	static void		Init();
+	static void		Final();
+};
+
+#endif

DiskState.cpp

@@ -0,0 +1,381 @@
+/*
+ *  This file if part of nzbget
+ *
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef WIN32
+#include "win32.h"
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+
+#include "nzbget.h"
+#include "DiskState.h"
+#include "Options.h"
+#include "Log.h"
+#include "Util.h"
+
+extern Options* g_pOptions;
+
+/* Save Download Queue to Disk.
+ * The Disk State consists of file "queue", which contains the order of files
+ * and of one diskstate-file for each file in download queue.
+ * If parameter "OnlyOrder" is set to true, only the file "queue" will
+ * be written to disk (It useful, if only the order of files in queue was changed).
+ */
+bool DiskState::Save(DownloadQueue* pDownloadQueue, bool OnlyOrder)
+{
+	debug("Saving queue to disk");
+
+	char fileName[1024];
+	snprintf(fileName, 1024, "%s%s", g_pOptions->GetQueueDir(), "queue");
+	fileName[1024-1] = '\0';
+
+	FILE* outfile = fopen(fileName, "w");
+
+	if (!outfile)
+	{
+		error("Could not create file %s", fileName);
+		perror(fileName);
+		return false;
+	}
+
+	fprintf(outfile, "nzbget diskstate file version 1\n");
+
+	int cnt = 0;
+	for (DownloadQueue::iterator it = pDownloadQueue->begin(); it != pDownloadQueue->end(); it++)
+	{
+		FileInfo* pFileInfo = *it;
+		if (!pFileInfo->GetDeleted())
+		{
+			char fileName[1024];
+			snprintf(fileName, 1024, "%s%i", g_pOptions->GetQueueDir(), pFileInfo->GetID());
+			fileName[1024-1] = '\0';
+			fprintf(outfile, "%i,%i\n", pFileInfo->GetID(), (int)pFileInfo->GetPaused());
+			if (!OnlyOrder)
+			{
+				SaveFileInfo(pFileInfo, fileName);
+			}
+			cnt++;
+		}
+	}
+	fclose(outfile);
+
+	if (cnt == 0)
+	{
+		remove(fileName);
+	}
+
+	return true;
+}
+
+bool DiskState::Load(DownloadQueue* pDownloadQueue)
+{
+	debug("Loading queue from disk");
+
+	char fileName[1024];
+	snprintf(fileName, 1024, "%s%s", g_pOptions->GetQueueDir(), "queue");
+	fileName[1024-1] = '\0';
+
+	FILE* infile = fopen(fileName, "r");
+
+	if (!infile)
+	{
+		error("Could not open file %s", fileName);
+		return false;
+	}
+
+	bool res = false;
+	char FileSignatur[128];
+	fgets(FileSignatur, sizeof(FileSignatur), infile);
+	if (!strcmp(FileSignatur, "nzbget diskstate file version 1\n"))
+	{
+		int id, paused;
+		while (fscanf(infile, "%i,%i\n", &id, &paused) != EOF)
+		{
+			char fileName[1024];
+			snprintf(fileName, 1024, "%s%i", g_pOptions->GetQueueDir(), id);
+			fileName[1024-1] = '\0';
+			FileInfo* pFileInfo = new FileInfo();
+			bool res = LoadFileInfo(pFileInfo, fileName);
+			if (res)
+			{
+				pFileInfo->SetID(id);
+				pFileInfo->SetPaused(paused);
+				pDownloadQueue->push_back(pFileInfo);
+			}
+			else
+			{
+				warn("Could not load diskstate for file %s", fileName);
+				delete pFileInfo;
+			}
+		}
+		res = true;
+	}
+	else
+	{
+		error("Could not load diskstate due file version mismatch");
+		res = false;
+	}
+
+	fclose(infile);
+
+	return res;
+}
+
+bool DiskState::SaveFileInfo(FileInfo* pFileInfo, const char* szFilename)
+{
+	debug("Saving FileInfo to disk");
+
+	FILE* outfile = fopen(szFilename, "w");
+
+	if (!outfile)
+	{
+		error("Could not create file %s", szFilename);
+		return false;
+	}
+
+	fprintf(outfile, "%s\n", pFileInfo->GetNZBFilename());
+	fprintf(outfile, "%s\n", pFileInfo->GetSubject());
+	fprintf(outfile, "%s\n", pFileInfo->GetDestDir());
+	fprintf(outfile, "%s\n", pFileInfo->GetFilename());
+	fprintf(outfile, "%i\n", pFileInfo->GetFilenameConfirmed());
+
+	fprintf(outfile, "%lu,%lu\n", (unsigned long)(pFileInfo->GetSize() >> 32), (unsigned long)(pFileInfo->GetSize()));
+
+	fprintf(outfile, "%i\n", pFileInfo->GetGroups()->size());
+	for (FileInfo::Groups::iterator it = pFileInfo->GetGroups()->begin(); it != pFileInfo->GetGroups()->end(); it++)
+	{
+		fprintf(outfile, "%s\n", *it);
+	}
+
+	fprintf(outfile, "%i\n", pFileInfo->GetArticles()->size());
+	for (FileInfo::Articles::iterator it = pFileInfo->GetArticles()->begin(); it != pFileInfo->GetArticles()->end(); it++)
+	{
+		ArticleInfo* pArticleInfo = *it;
+		fprintf(outfile, "%i,%i\n", pArticleInfo->GetPartNumber(), pArticleInfo->GetSize());
+		fprintf(outfile, "%s\n", pArticleInfo->GetMessageID());
+	}
+
+	fclose(outfile);
+	return true;
+}
+
+bool DiskState::LoadFileInfo(FileInfo* pFileInfo, const char * szFilename)
+{
+	debug("Loading FileInfo from disk");
+
+	FILE* infile = fopen(szFilename, "r");
+
+	if (!infile)
+	{
+		error("Could not open file %s", szFilename);
+		return false;
+	}
+
+	char buf[1024];
+
+	if (!fgets(buf, sizeof(buf), infile)) goto error;
+	if (buf[0] != 0) buf[strlen(buf)-1] = 0; // remove traling '\n'
+	pFileInfo->SetNZBFilename(buf);
+
+	if (!fgets(buf, sizeof(buf), infile)) goto error;
+	if (buf[0] != 0) buf[strlen(buf)-1] = 0; // remove traling '\n'
+	pFileInfo->SetSubject(buf);
+
+	if (!fgets(buf, sizeof(buf), infile)) goto error;
+	if (buf[0] != 0) buf[strlen(buf)-1] = 0; // remove traling '\n'
+	pFileInfo->SetDestDir(buf);
+
+	if (!fgets(buf, sizeof(buf), infile)) goto error;
+	if (buf[0] != 0) buf[strlen(buf)-1] = 0; // remove traling '\n'
+	pFileInfo->SetFilename(buf);
+
+	int iFilenameConfirmed;
+	if (fscanf(infile, "%i\n", &iFilenameConfirmed) != 1) goto error;
+	pFileInfo->SetFilenameConfirmed(iFilenameConfirmed);
+	
+	unsigned long High, Low;
+	if (fscanf(infile, "%lu,%lu\n", &High, &Low) != 2) goto error;
+	pFileInfo->SetSize((((unsigned long long)High) << 32) + Low);
+	pFileInfo->SetRemainingSize(pFileInfo->GetSize());
+
+	int size;
+	if (fscanf(infile, "%i\n", &size) != 1) goto error;
+	for (int i = 0; i < size; i++)
+	{
+		if (!fgets(buf, sizeof(buf), infile)) goto error;
+		if (buf[0] != 0) buf[strlen(buf)-1] = 0; // remove traling '\n'
+		pFileInfo->GetGroups()->push_back(strdup(buf));
+	}
+
+	if (fscanf(infile, "%i\n", &size) != 1) goto error;
+	for (int i = 0; i < size; i++)
+	{
+		int PartNumber, PartSize;
+		if (fscanf(infile, "%i,%i\n", &PartNumber, &PartSize) != 2) goto error;
+
+		if (!fgets(buf, sizeof(buf), infile)) goto error;
+		if (buf[0] != 0) buf[strlen(buf)-1] = 0; // remove traling '\n'
+
+		ArticleInfo* pArticleInfo = new ArticleInfo();
+		pArticleInfo->SetPartNumber(PartNumber);
+		pArticleInfo->SetSize(PartSize);
+		pArticleInfo->SetMessageID(buf);
+		pFileInfo->GetArticles()->push_back(pArticleInfo);
+	}
+
+	fclose(infile);
+	return true;
+
+error:
+	fclose(infile);
+	error("Error reading diskstate for file %s", szFilename);
+	return false;
+}
+
+/*
+ * Delete all files from Queue.
+ * Returns true if successful, false if not
+ */
+bool DiskState::Discard()
+{
+	debug("Discarding queue");
+
+	char fileName[1024];
+	snprintf(fileName, 1024, "%s%s", g_pOptions->GetQueueDir(), "queue");
+	fileName[1024-1] = '\0';
+
+	FILE* infile = fopen(fileName, "r");
+
+	if (!infile)
+	{
+		error("Could not open file %s", fileName);
+		return false;
+	}
+
+	bool res = false;
+	char FileSignatur[128];
+	fgets(FileSignatur, sizeof(FileSignatur), infile);
+	if (!strcmp(FileSignatur, "nzbget diskstate file version 1\n"))
+	{
+		int id, paused;
+		while (fscanf(infile, "%i,%i\n", &id, &paused) == 2)
+		{
+			char fileName[1024];
+			snprintf(fileName, 1024, "%s%i", g_pOptions->GetQueueDir(), id);
+			fileName[1024-1] = '\0';
+			remove(fileName);
+		}
+		res = true;
+	}
+	else
+	{
+		error("Could not discard diskstate due file version mismatch");
+		res = false;
+	}
+
+	fclose(infile);
+	if (res)
+	{
+		remove(fileName);
+	}
+
+	return res;
+}
+
+bool DiskState::Exists()
+{
+	debug("Checking if a saved queue exists on disk");
+
+	char fileName[1024];
+	snprintf(fileName, 1024, "%s%s", g_pOptions->GetQueueDir(), "queue");
+	fileName[1024-1] = '\0';
+	struct stat buffer;
+	bool fileExists = !stat(fileName, &buffer);
+	return fileExists;
+}
+
+bool DiskState::DiscardFileInfo(DownloadQueue* pDownloadQueue, FileInfo * pFileInfo)
+{
+	// delete diskstate-file
+	char fileName[1024];
+	snprintf(fileName, 1024, "%s%i", g_pOptions->GetQueueDir(), pFileInfo->GetID());
+	fileName[1024-1] = '\0';
+	remove(fileName);
+
+	return Save(pDownloadQueue, true);
+}
+
+void DiskState::CleanupTempDir(DownloadQueue* pDownloadQueue)
+{
+	// build array of IDs of files in queue for faster access
+	int* ids = (int*)malloc(sizeof(int) * (pDownloadQueue->size() + 1));
+	int* ptr = ids;
+	for (DownloadQueue::iterator it = pDownloadQueue->begin(); it != pDownloadQueue->end(); it++)
+	{
+		FileInfo* pFileInfo = *it;
+		*ptr++ = pFileInfo->GetID();
+	}
+	*ptr = 0;
+
+	// read directory
+	DirBrowser dir(g_pOptions->GetTempDir());
+	while (const char* filename = dir.Next())
+	{
+		bool del = strstr(filename, ".tmp") || strstr(filename, ".dec");
+		if (!del)
+		{
+			int id, part;
+			if (sscanf(filename, "%i.%i", &id, &part) == 2)
+			{
+				del = true;
+				ptr = ids;
+				while (*ptr)
+				{
+					if (*ptr == id)
+					{
+						del = false;
+						break;
+					}
+					ptr++;
+				}
+			}
+		}
+		if (del)
+		{
+			char szFullFilename[1024];
+			snprintf(szFullFilename, 1024, "%s%s", g_pOptions->GetTempDir(), filename);
+			szFullFilename[1024-1] = '\0';
+			remove(szFullFilename);
+		}
+	}
+     
+	free(ids);
+}

DiskState.h

@@ -0,0 +1,46 @@
+/*
+ *  This file if part of nzbget
+ *
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Revision$
+ * $Date$
+ *                                                          
+ */
+
+
+#ifndef DISKSTATE_H
+#define DISKSTATE_H
+
+#include "DownloadInfo.h"
+
+class DiskState
+{
+private:
+	bool				SaveFileInfo(FileInfo* pFileInfo, const char* szFilename);
+	bool				LoadFileInfo(FileInfo* pFileInfo, const char* szFilename);
+	
+public:
+	bool				Exists();
+	bool				Save(DownloadQueue* pDownloadQueue, bool OnlyOrder);
+	bool				Load(DownloadQueue* pDownloadQueue);
+	bool				Discard();
+	bool				DiscardFileInfo(DownloadQueue* pDownloadQueue, FileInfo* pFileInfo);
+	void				CleanupTempDir(DownloadQueue* pDownloadQueue);
+};
+
+#endif

DownloadInfo.cpp

@@ -0,0 +1,272 @@
+/*
+ *  This file if part of nzbget
+ *
+ *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef WIN32
+#include "win32.h"
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#ifndef WIN32
+#include <unistd.h>
+#endif
+
+#include "nzbget.h"
+#include "DownloadInfo.h"
+#include "Options.h"
+#include "Log.h"
+#include "Util.h"
+
+extern Options* g_pOptions;
+
+int FileInfo::m_iIDGen = 0;
+
+ArticleInfo::ArticleInfo()
+{
+	//debug("Creating ArticleInfo");
+	m_szMessageID		= NULL;
+	m_iSize 			= 0;
+	m_eStatus			= aiUndefined;
+	m_szResultFilename	= NULL;
+}
+
+ArticleInfo::~ ArticleInfo()
+{
+	//debug("Destroying ArticleInfo");
+
+	if (m_szMessageID)
+	{
+		free(m_szMessageID);
+	}
+	if (m_szResultFilename)
+	{
+		free(m_szResultFilename);
+	}
+}
+
+void ArticleInfo::SetMessageID(const char * szMessageID)
+{
+	m_szMessageID = strdup(szMessageID);
+}
+
+void ArticleInfo::SetResultFilename(const char * v)
+{
+	m_szResultFilename = strdup(v);
+}
+
+
+FileInfo::FileInfo()
+{
+	debug("Creating FileInfo");
+
+	m_Articles.clear();
+	m_Groups.clear();
+	m_szSubject = NULL;
+	m_szFilename = NULL;
+	m_bFilenameConfirmed = false;
+	m_szDestDir = NULL;
+	m_szNZBFilename = NULL;
+	m_lSize = 0;
+	m_lRemainingSize = 0;
+	m_bPaused = false;
+	m_bDeleted = false;
+	m_iCompleted = 0;
+	m_iIDGen++;
+	m_iID = m_iIDGen;
+}
+
+FileInfo::~ FileInfo()
+{
+	debug("Destroying FileInfo");
+
+	if (m_szSubject)
+	{
+		free(m_szSubject);
+	}
+	if (m_szFilename)
+	{
+		free(m_szFilename);
+	}
+	if (m_szDestDir)
+	{
+		free(m_szDestDir);
+	}
+	if (m_szNZBFilename)
+	{
+		free(m_szNZBFilename);
+	}
+
+	for (Articles::iterator it = m_Articles.begin(); it != m_Articles.end() ;it++)
+	{
+		delete *it;
+	}
+	m_Articles.clear();
+
+	for (Groups::iterator it = m_Groups.begin(); it != m_Groups.end() ;it++)
+	{
+		free(*it);
+	}
+	m_Groups.clear();
+}
+
+void FileInfo::SetID(int s)
+{
+	m_iID = s;
+	if (m_iIDGen < m_iID)
+	{
+		m_iIDGen = m_iID;
+	}
+}
+
+void FileInfo::SetSubject(const char* szSubject)
+{
+	m_szSubject = strdup(szSubject);
+}
+
+void FileInfo::SetDestDir(const char* szDestDir)
+{
+	m_szDestDir = strdup(szDestDir);
+}
+
+void FileInfo::SetNZBFilename(const char * szNZBFilename)
+{
+	m_szNZBFilename = strdup(szNZBFilename);
+}
+
+void FileInfo::GetNiceNZBName(char* szBuffer, int iSize)
+{
+	MakeNiceNZBName(m_szNZBFilename, szBuffer, iSize);
+}
+
+void FileInfo::MakeNiceNZBName(const char * szNZBFilename, char * szBuffer, int iSize)
+{
+	strncpy(szBuffer, BaseFileName(szNZBFilename), iSize);
+	szBuffer[iSize-1] = '\0';
+	if (char* p = strrchr(szBuffer, '.')) *p = '\0';
+}
+
+void FileInfo::ParseSubject()
+{
+	char* fnstart = strstr(m_szSubject, "\"");
+	char* fnend = NULL;
+	if (fnstart)
+	{
+		fnstart++;
+		fnend = strstr(fnstart, "\"");
+	}
+	if (fnend)
+	{
+		char fn[1024];
+		strncpy(fn, fnstart, fnend - fnstart);
+		fn[fnend - fnstart] = '\0';
+		m_szFilename = strdup(fn);
+	}
+	else
+	{
+		debug("Could not extract Filename from Subject: %s. Using Subject as Filename", m_szSubject);
+		m_szFilename = strdup(m_szSubject);
+	}
+
+	//replace bad chars in filename
+	char* p = m_szFilename;
+	while (*p)
+	{
+		if (strchr("\\/:*?\"><'\n\r\t", *p))
+		{
+			*p = '_';
+		}
+		p++;
+	}
+}
+
+void FileInfo::SetFilename(const char* szFilename)
+{
+	if (m_szFilename)
+	{
+		free(m_szFilename);
+	}
+	m_szFilename = strdup(szFilename);
+}
+
+void FileInfo::BuildDestDirName(const char* szNZBFilename)
+{
+	char szBuffer[1024];
+
+	if (g_pOptions->GetAppendNZBDir())
+	{
+		char postname[1024];
+		const char* szBaseName = BaseFileName(szNZBFilename);
+
+		// if .nzb file has a certain structure, try to strip out certain elements
+		if (sscanf(szBaseName, "msgid_%*d_%1023s", postname) == 1)
+		{
+			// wipe out certain structure
+			memset(strrchr(postname, '.'), 0, postname + strlen(postname) - strrchr(postname, '.'));
+		}
+		else
+		{
+			strncpy(postname, szBaseName, 1024);
+			postname[1024-1] = '\0';
+		}
+		// wipe out ".nzb"
+		memset(strrchr(postname, '.'), 0, postname + strlen(postname) - strrchr(postname, '.'));
+		snprintf(szBuffer, 1024, "%s%s", g_pOptions->GetDestDir(), postname);
+		szBuffer[1024-1] = '\0';
+	}
+	else
+	{
+		strncpy(szBuffer, g_pOptions->GetDestDir(), 1024);
+		szBuffer[1024-1] = '\0'; // trim the last slash, always returned by GetDestDir()
+	}
+
+	m_szDestDir = strdup(szBuffer);
+}
+
+bool FileInfo::IsDupe()
+{
+	debug("Checking if the file was already downloaded or queued");
+
+	struct stat buffer;
+	char fileName[1024];
+	bool exists = false;
+
+	snprintf(fileName, 1024, "%s%c%s", GetDestDir(), (int)PATH_SEPARATOR, GetFilename());
+	fileName[1024-1] = '\0';
+	exists = !stat(fileName, &buffer);
+	if (!exists)
+	{
+		snprintf(fileName, 1024, "%s%c%s_broken", GetDestDir(), (int)PATH_SEPARATOR, GetFilename());
+		fileName[1024-1] = '\0';
+		exists = !stat(fileName, &buffer);
+	}
+
+	return exists;
+}

DownloadInfo.h

@@ -0,0 +1,125 @@
+/*
+ *  This file if part of nzbget
+ *
+ *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifndef DOWNLOADINFO_H
+#define DOWNLOADINFO_H
+
+#include <vector>
+#include <deque>
+
+class ArticleInfo
+{
+public:
+	enum EStatus
+	{
+		aiUndefined,
+		aiRunning,
+		aiFinished,
+		aiFailed
+	};
+	
+private:
+	int					m_iPartNumber;
+	char*				m_szMessageID;
+	int					m_iSize;
+	EStatus				m_eStatus;
+	char*				m_szResultFilename;
+
+public:
+						ArticleInfo();
+						~ArticleInfo();
+	void 				SetPartNumber(int s) { m_iPartNumber = s; }
+	int 				GetPartNumber() { return m_iPartNumber; }
+	const char* 		GetMessageID() { return m_szMessageID; }
+	void 				SetMessageID(const char* szMessageID);
+	void 				SetSize(int s) { m_iSize = s; }
+	int 				GetSize() { return m_iSize; }
+	EStatus				GetStatus() { return m_eStatus; }
+	void				SetStatus(EStatus Status) { m_eStatus = Status; }
+	const char*			GetResultFilename() { return m_szResultFilename; }
+	void 				SetResultFilename(const char* v);
+};
+
+class FileInfo
+{
+public:
+	typedef std::vector<ArticleInfo*>	Articles;
+	typedef std::vector<char*>			Groups;
+
+private:
+	int					m_iID;
+	Articles			m_Articles;
+	Groups				m_Groups;
+	char* 				m_szNZBFilename;
+	char* 				m_szSubject;
+	char*				m_szFilename;
+	char*				m_szDestDir;
+	long long 			m_lSize;
+	long long 			m_lRemainingSize;
+	bool				m_bPaused;
+	bool				m_bDeleted;
+	bool				m_bFilenameConfirmed;
+	int					m_iCompleted;
+
+	static int			m_iIDGen;
+
+public:
+						FileInfo();
+						~FileInfo();
+	int					GetID() { return m_iID; }
+	void				SetID(int s);
+	Articles* 			GetArticles() { return &m_Articles; }
+	Groups* 			GetGroups() { return &m_Groups; }
+	const char*			GetNZBFilename() { return m_szNZBFilename; }
+	void 				SetNZBFilename(const char* szNZBFilename);
+	void				GetNiceNZBName(char* szBuffer, int iSize);
+	static void			MakeNiceNZBName(const char* szNZBFilename, char* szBuffer, int iSize);
+	const char*			GetSubject() { return m_szSubject; }
+	void 				SetSubject(const char* szSubject);
+	const char*			GetFilename() { return m_szFilename; }
+	void 				SetFilename(const char* szFilename);
+	bool				GetFilenameConfirmed() { return m_bFilenameConfirmed; }
+	void				SetFilenameConfirmed(bool bFilenameConfirmed) { m_bFilenameConfirmed = bFilenameConfirmed; }
+	void 				SetSize(long long s) { m_lSize = s; m_lRemainingSize = s; }
+	long long 			GetSize() { return m_lSize; }
+	long long 			GetRemainingSize() { return m_lRemainingSize; }
+	void 				SetRemainingSize(long long s) { m_lRemainingSize = s; }
+	bool				GetPaused() { return m_bPaused; }
+	void				SetPaused(bool Paused) { m_bPaused = Paused; }
+	bool				GetDeleted() { return m_bDeleted; }
+	void				SetDeleted(bool Deleted) { m_bDeleted = Deleted; }
+	void				BuildDestDirName(const char* szNZBFilename);
+	const char*			GetDestDir() { return m_szDestDir; }
+	void				SetDestDir(const char* szDestDir);
+	int					GetCompleted() { return m_iCompleted; }
+	void				SetCompleted(int s) { m_iCompleted = s; }
+	void				ParseSubject();
+	bool				IsDupe();
+};
+                              
+typedef std::deque<FileInfo*> DownloadQueue;
+
+#endif

Frontend.cpp

@@ -0,0 +1,446 @@
+/*
+ *  This file if part of nzbget
+ *
+ *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef WIN32
+#include "win32.h"
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#ifndef WIN32
+#include <unistd.h>
+#endif
+
+#include "nzbget.h"
+#include "Options.h"
+#include "Frontend.h"
+#include "Log.h"
+#include "Connection.h"
+#include "MessageBase.h"
+#include "QueueCoordinator.h"
+#include "RemoteClient.h"
+
+extern QueueCoordinator* g_pQueueCoordinator;
+extern Options* g_pOptions;
+
+Frontend::Frontend()
+{
+	debug("Creating Frontend");
+
+	m_iNeededLogFirstID = 0;
+	m_iNeededLogEntries = 0;
+	m_bSummary = false;
+	m_bFileList = false;
+	m_fCurrentDownloadSpeed = 0;
+	m_lRemainingSize = 0;
+	m_bPause = false;
+	m_fDownloadLimit = 0;
+	m_iThreadCount = 0;
+	m_RemoteMessages.clear();
+	m_RemoteQueue.clear();
+}
+
+bool Frontend::PrepareData()
+{
+	if (IsRemoteMode())
+	{
+		if (IsStopped())
+		{
+			return false;
+		}
+		if (!RequestMessages() || ((m_bSummary || m_bFileList) && !RequestFileList()))
+		{
+			printf("Unable to send request to nzbserver at %s (port %i)    \n", g_pOptions->GetServerIP(), g_pOptions->GetServerPort());
+			Stop();
+			return false;
+		}
+	}
+	else
+	{
+		if (m_bSummary)
+		{
+			m_fCurrentDownloadSpeed = g_pQueueCoordinator->CalcCurrentDownloadSpeed();
+			m_lRemainingSize = g_pQueueCoordinator->CalcRemainingSize();
+			m_bPause = g_pOptions->GetPause();
+			m_fDownloadLimit = g_pOptions->GetDownloadRate();
+			m_iThreadCount = Thread::GetThreadCount();
+		}
+	}
+	return true;
+}
+
+void Frontend::FreeData()
+{
+	if (IsRemoteMode())
+	{
+		for (Log::Messages::iterator it = m_RemoteMessages.begin(); it != m_RemoteMessages.end(); it++)
+		{
+			delete *it;
+		}
+		m_RemoteMessages.clear();
+
+		for (DownloadQueue::iterator it = m_RemoteQueue.begin(); it != m_RemoteQueue.end(); it++)
+		{
+			delete *it;
+		}
+		m_RemoteQueue.clear();
+	}
+}
+
+Log::Messages * Frontend::LockMessages()
+{
+	if (IsRemoteMode())
+	{
+		return &m_RemoteMessages;
+	}
+	else
+	{
+		return g_pLog->LockMessages();
+	}
+}
+
+void Frontend::UnlockMessages()
+{
+	if (!IsRemoteMode())
+	{
+		g_pLog->UnlockMessages();
+	}
+}
+
+DownloadQueue * Frontend::LockQueue()
+{
+	if (IsRemoteMode())
+	{
+		return &m_RemoteQueue;
+	}
+	else
+	{
+		return g_pQueueCoordinator->LockQueue();
+	}
+}
+
+void Frontend::UnlockQueue()
+{
+	if (!IsRemoteMode())
+	{
+		g_pQueueCoordinator->UnlockQueue();
+	}
+}
+
+bool Frontend::IsRemoteMode()
+{
+	return g_pOptions->GetRemoteClientMode();
+}
+
+void Frontend::ServerPauseUnpause(bool bPause)
+{
+	if (IsRemoteMode())
+	{
+		RequestPauseUnpause(bPause);
+	}
+	else
+	{
+		g_pOptions->SetPause(bPause);
+	}
+}
+
+void Frontend::ServerSetDownloadRate(float fRate)
+{
+	if (IsRemoteMode())
+	{
+		RequestSetDownloadRate(fRate);
+	}
+	else
+	{
+		g_pOptions->SetDownloadRate(fRate);
+	}
+}
+
+void Frontend::ServerDumpDebug()
+{
+	if (IsRemoteMode())
+	{
+		RequestDumpDebug();
+	}
+	else
+	{
+		g_pQueueCoordinator->LogDebugInfo();
+	}
+}
+
+bool Frontend::ServerEditQueue(EEditAction eAction, int iEntry)
+{
+	DownloadQueue* pDownloadQueue = LockQueue();
+	int ID = 0;
+	bool bPause = false;
+	if (iEntry >= 0 && iEntry < (int)pDownloadQueue->size())
+	{
+		FileInfo* pFileInfo = (*pDownloadQueue)[iEntry];
+		ID = pFileInfo->GetID();
+		bPause = !pFileInfo->GetPaused();
+	}
+	UnlockQueue();
+
+	if (ID == 0)
+	{
+		return false;
+	}
+	
+	if (IsRemoteMode())
+	{
+		switch (eAction)
+		{
+			case eaPauseUnpause:
+				return RequestEditQueue(bPause ? NZBMessageRequest::eActionPause : NZBMessageRequest::eActionResume, 0, ID, ID);
+			case eaDelete:
+				return RequestEditQueue(NZBMessageRequest::eActionDelete, 0, ID, ID);
+			case eaMoveUp:
+				return RequestEditQueue(NZBMessageRequest::eActionMoveOffset, -1, ID, ID);
+			case eaMoveDown:
+				return RequestEditQueue(NZBMessageRequest::eActionMoveOffset, +1, ID, ID);
+			case eaMoveTop:
+				return RequestEditQueue(NZBMessageRequest::eActionMoveTop, 0, ID, ID);
+			case eaMoveBottom:
+				return RequestEditQueue(NZBMessageRequest::eActionMoveBottom, 0, ID, ID);
+		}
+	}
+	else
+	{
+		switch (eAction)
+		{
+			case eaPauseUnpause:
+				return g_pQueueCoordinator->EditQueuePauseUnpauseEntry(ID, bPause);
+			case eaDelete:
+				return g_pQueueCoordinator->EditQueueDeleteEntry(ID);
+			case eaMoveUp:
+				return g_pQueueCoordinator->EditQueueMoveEntry(ID, -1, false);
+			case eaMoveDown:
+				return g_pQueueCoordinator->EditQueueMoveEntry(ID, +1, false);
+			case eaMoveTop:
+				return g_pQueueCoordinator->EditQueueMoveEntry(ID, -1000000, true);
+			case eaMoveBottom:
+				return g_pQueueCoordinator->EditQueueMoveEntry(ID, +1000000, true);
+		}
+	}
+	return false;
+}
+
+void Frontend::InitMessageBase(SNZBMessageBase* pMessageBase, int iRequest, int iSize)
+{
+	pMessageBase->m_iId	= NZBMESSAGE_SIGNATURE;
+	pMessageBase->m_iType = iRequest;
+	pMessageBase->m_iSize = iSize;
+	strncpy(pMessageBase->m_szPassword, g_pOptions->GetServerPassword(), NZBREQUESTPASSWORDSIZE);
+	pMessageBase->m_szPassword[NZBREQUESTPASSWORDSIZE - 1] = '\0';
+}
+
+bool Frontend::RequestMessages()
+{
+	NetAddress netAddress(g_pOptions->GetServerIP(), g_pOptions->GetServerPort());
+	Connection connection(&netAddress);
+
+	bool OK = connection.Connect() >= 0;
+	if (!OK)
+	{
+		return false;
+	}
+
+	SNZBLogRequest LogRequest;
+	InitMessageBase(&LogRequest.m_MessageBase, NZBMessageRequest::eRequestLog, sizeof(LogRequest));
+	LogRequest.m_iLines = m_iNeededLogEntries;
+	if (m_iNeededLogEntries == 0)
+	{
+		LogRequest.m_iIDFrom = m_iNeededLogFirstID > 0 ? m_iNeededLogFirstID : 1;
+	}
+	else
+	{
+		LogRequest.m_iIDFrom = 0;
+	}
+
+	if (connection.Send((char*)(&LogRequest), sizeof(LogRequest)) < 0)
+	{
+		return false;
+	}
+
+	// Now listen for the returned log
+	SNZBLogRequestAnswer LogRequestAnswer;
+	if (connection.Recv((char*) &LogRequestAnswer, sizeof(LogRequestAnswer)) < 0)
+	{
+		return false;
+	}
+
+	char* pBuf = NULL;
+	if (LogRequestAnswer.m_iTrailingDataLength > 0)
+	{
+		pBuf = (char*)malloc(LogRequestAnswer.m_iTrailingDataLength);
+		if (!connection.RecvAll(pBuf, LogRequestAnswer.m_iTrailingDataLength))
+		{
+			free(pBuf);
+			return false;
+		}
+	}
+
+	connection.Disconnect();
+
+	if (LogRequestAnswer.m_iTrailingDataLength > 0)
+	{
+		char* pBufPtr = (char*)pBuf;
+		for (int i = 0; i < LogRequestAnswer.m_iNrTrailingEntries; i++)
+		{
+			SNZBLogRequestAnswerEntry* pLogAnswer = (SNZBLogRequestAnswerEntry*) pBufPtr;
+
+			char* szText = pBufPtr + sizeof(SNZBLogRequestAnswerEntry);
+
+			Message* pMessage = new Message(pLogAnswer->m_iID, (Message::EKind)pLogAnswer->m_iKind, pLogAnswer->m_tTime, szText);
+			m_RemoteMessages.push_back(pMessage);
+
+			pBufPtr += sizeof(SNZBLogRequestAnswerEntry) + pLogAnswer->m_iTextLen;
+		}
+
+		free(pBuf);
+	}
+
+	return true;
+}
+
+bool Frontend::RequestFileList()
+{
+	NetAddress netAddress(g_pOptions->GetServerIP(), g_pOptions->GetServerPort());
+	Connection connection(&netAddress);
+
+	bool OK = connection.Connect() >= 0;
+	if (!OK)
+	{
+		return false;
+	}
+
+	SNZBListRequest ListRequest;
+	InitMessageBase(&ListRequest.m_MessageBase, NZBMessageRequest::eRequestList, sizeof(ListRequest));
+	ListRequest.m_bFileList = m_bFileList;
+	ListRequest.m_bServerState = m_bSummary;
+
+	if (connection.Send((char*)(&ListRequest), sizeof(ListRequest)) < 0)
+	{
+		return false;
+	}
+
+	// Now listen for the returned list
+	SNZBListRequestAnswer ListRequestAnswer;
+	if (connection.Recv((char*) &ListRequestAnswer, sizeof(ListRequestAnswer)) < 0)
+	{
+		return false;
+	}
+
+	char* pBuf = NULL;
+	if (ListRequestAnswer.m_iTrailingDataLength > 0)
+	{
+		pBuf = (char*)malloc(ListRequestAnswer.m_iTrailingDataLength);
+		if (!connection.RecvAll(pBuf, ListRequestAnswer.m_iTrailingDataLength))
+		{
+			free(pBuf);
+			return false;
+		}
+	}
+
+	connection.Disconnect();
+
+	if (m_bSummary)
+	{
+		m_bPause = ListRequestAnswer.m_bServerPaused;
+		m_lRemainingSize = ListRequestAnswer.m_lRemainingSize;
+		m_fCurrentDownloadSpeed = ListRequestAnswer.m_fDownloadRate;
+		m_fDownloadLimit = ListRequestAnswer.m_fDownloadLimit;
+		m_iThreadCount = ListRequestAnswer.m_iThreadCount;
+	}
+
+	if (m_bFileList && ListRequestAnswer.m_iTrailingDataLength > 0)
+	{
+		char* pBufPtr = (char*)pBuf;
+		for (int i = 0; i < ListRequestAnswer.m_iNrTrailingEntries; i++)
+		{
+			SNZBListRequestAnswerEntry* pListAnswer = (SNZBListRequestAnswerEntry*) pBufPtr;
+
+			char* szNZBFilename = pBufPtr + sizeof(SNZBListRequestAnswerEntry);
+			char* szSubject = pBufPtr + sizeof(SNZBListRequestAnswerEntry) + pListAnswer->m_iNZBFilenameLen;
+			char* szFileName = pBufPtr + sizeof(SNZBListRequestAnswerEntry) + pListAnswer->m_iNZBFilenameLen + pListAnswer->m_iSubjectLen;
+			char* szDestDir = pBufPtr + sizeof(SNZBListRequestAnswerEntry) + pListAnswer->m_iNZBFilenameLen + pListAnswer->m_iSubjectLen + pListAnswer->m_iFilenameLen;
+			
+			FileInfo* pFileInfo = new FileInfo();
+			pFileInfo->SetID(pListAnswer->m_iID);
+			pFileInfo->SetSize(pListAnswer->m_iFileSize);
+			pFileInfo->SetRemainingSize(pListAnswer->m_iRemainingSize);
+			pFileInfo->SetPaused(pListAnswer->m_bPaused);
+			pFileInfo->SetNZBFilename(szNZBFilename);
+			pFileInfo->SetSubject(szSubject);
+			pFileInfo->SetFilename(szFileName);
+			pFileInfo->SetFilenameConfirmed(pListAnswer->m_bFilenameConfirmed);
+			pFileInfo->SetDestDir(szDestDir);
+
+			m_RemoteQueue.push_back(pFileInfo);
+
+			pBufPtr += sizeof(SNZBListRequestAnswerEntry) + pListAnswer->m_iNZBFilenameLen + pListAnswer->m_iSubjectLen +
+			           pListAnswer->m_iFilenameLen + pListAnswer->m_iDestDirLen;
+		}
+	}
+	if (pBuf)
+	{
+		free(pBuf);
+	}
+
+	return true;
+}
+
+bool Frontend::RequestPauseUnpause(bool bPause)
+{
+	RemoteClient client;
+	client.SetVerbose(false);
+	return client.RequestServerPauseUnpause(bPause);
+}
+
+bool Frontend::RequestSetDownloadRate(float fRate)
+{
+	RemoteClient client;
+	client.SetVerbose(false);
+	return client.RequestServerSetDownloadRate(fRate);
+}
+
+bool Frontend::RequestDumpDebug()
+{
+	RemoteClient client;
+	client.SetVerbose(false);
+	return client.RequestServerDumpDebug();
+}
+
+bool Frontend::RequestEditQueue(int iAction, int iOffset, int iIDFrom, int iIDTo)
+{
+	RemoteClient client;
+	client.SetVerbose(false);
+	return client.RequestServerEditQueue(iAction, iOffset, iIDFrom, iIDTo);
+}

Frontend.h

@@ -1,8 +1,8 @@
 /*
- *  This file is part of nzbget
+ *  This file if part of nzbget
  *
- *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
- *  Copyright (C) 2007-2014 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -16,7 +16,7 @@
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  *
  * $Revision$
  * $Date$
@@ -31,12 +31,23 @@
 #include "Log.h"
 #include "DownloadInfo.h"
 #include "MessageBase.h"
-#include "QueueEditor.h"
 
 class Frontend : public Thread
 {
+public:
+	enum EEditAction
+	{
+		eaPauseUnpause,
+		eaDelete,
+		eaMoveUp,
+		eaMoveDown,
+		eaMoveTop,
+		eaMoveBottom
+	};
+	
 private:
 	Log::Messages		m_RemoteMessages;
+	DownloadQueue		m_RemoteQueue;
 
 	bool				RequestMessages();
 	bool				RequestFileList();
@@ -44,21 +55,15 @@ private:
 protected:
 	bool				m_bSummary;
 	bool				m_bFileList;
-	unsigned int		m_iNeededLogEntries;
-	unsigned int		m_iNeededLogFirstID;
-	int					m_iUpdateInterval;
+	unsigned int				m_iNeededLogEntries;
+	unsigned int				m_iNeededLogFirstID;
 
 	// summary
-	int					m_iCurrentDownloadSpeed;
+	float				m_fCurrentDownloadSpeed;
 	long long 			m_lRemainingSize;
-	bool				m_bPauseDownload;
-	int					m_iDownloadLimit;
+	bool				m_bPause;
+	float				m_fDownloadLimit;
 	int					m_iThreadCount;
-	int					m_iPostJobCount;
-	int					m_iUpTimeSec;
-	int					m_iDnTimeSec;
-	long long			m_iAllBytes;
-	bool				m_bStandBy;
 
 	bool				PrepareData();
 	void				FreeData();
@@ -67,13 +72,15 @@ protected:
 	DownloadQueue*		LockQueue();
 	void				UnlockQueue();
 	bool				IsRemoteMode();
-	void				InitMessageBase(SNZBRequestBase* pMessageBase, int iRequest, int iSize);
+	void				InitMessageBase(SNZBMessageBase* pMessageBase, int iRequest, int iSize);
 	void				ServerPauseUnpause(bool bPause);
 	bool				RequestPauseUnpause(bool bPause);
-	void				ServerSetDownloadRate(int iRate);
-	bool				RequestSetDownloadRate(int iRate);
-	bool 				ServerEditQueue(DownloadQueue::EEditAction eAction, int iOffset, int iEntry);
-	bool 				RequestEditQueue(DownloadQueue::EEditAction eAction, int iOffset, int iID);
+	void				ServerSetDownloadRate(float fRate);
+	bool				RequestSetDownloadRate(float fRate);
+	void				ServerDumpDebug();
+	bool				RequestDumpDebug();
+	bool 				ServerEditQueue(EEditAction eAction, int iEntry);
+	bool 				RequestEditQueue(int iAction, int iOffset, int iIDFrom, int iIDTo);
 
 public:
 						Frontend();

Log.cpp

@@ -1,8 +1,8 @@
 /*
- *  This file is part of nzbget
+ *  This file if part of nzbget
  *
- *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
- *  Copyright (C) 2007-2013 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -16,7 +16,7 @@
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  *
  * $Revision$
  * $Date$
@@ -30,15 +30,12 @@
 
 #ifdef WIN32
 #include "win32.h"
-#else
-#include <pthread.h>
 #endif
 
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <stdarg.h>
-#include <stdio.h>
 
 #include "nzbget.h"
 #include "Options.h"
@@ -53,37 +50,38 @@ Log::Log()
 	m_iIDGen = 0;
 	m_szLogFilename = NULL;
 #ifdef DEBUG
-	m_bExtraDebug = Util::FileExists("extradebug");
+	struct stat buffer;
+	m_bExtraDebug = !stat("extradebug", &buffer);
 #endif
 }
 
 Log::~Log()
 {
-	Clear();
-	free(m_szLogFilename);
-}
-
-void Log::LogDebugInfo()
-{
-	info("--------------------------------------------");
-	info("Dumping debug info to log");
-	info("--------------------------------------------");
-	
-	m_mutexDebug.Lock();
-	for (Debuggables::iterator it = m_Debuggables.begin(); it != m_Debuggables.end(); it++)
+	for (Messages::iterator it = m_Messages.begin(); it != m_Messages.end(); it++)
 	{
-        Debuggable* pDebuggable = *it;
-		pDebuggable->LogDebugInfo();
+		delete *it;
+	}
+	m_Messages.clear();
+	if (m_szLogFilename)
+	{
+		free(m_szLogFilename);
 	}
-	m_mutexDebug.Unlock();
-
-	info("--------------------------------------------");
 }
 
 void Log::Filelog(const char* msg, ...)
 {
-	if (m_szLogFilename)
+	if (
+		(g_pOptions && g_pOptions->GetCreateLog() && g_pOptions->GetLogFile())
+#ifdef DEBUG
+		|| (m_szLogFilename && m_bExtraDebug)
+#endif
+		)
 	{
+		if (!m_szLogFilename)
+		{
+			m_szLogFilename = strdup(g_pOptions->GetLogFile());
+		}
+
 		char tmp2[1024];
 
 		va_list ap;
@@ -94,7 +92,6 @@ void Log::Filelog(const char* msg, ...)
 
 		time_t rawtime;
 		time(&rawtime);
-		rawtime += g_pOptions->GetTimeCorrection();
 		
 		char szTime[50];
 #ifdef HAVE_CTIME_R_3
@@ -105,7 +102,7 @@ void Log::Filelog(const char* msg, ...)
 		szTime[50-1] = '\0';
 		szTime[strlen(szTime) - 1] = '\0'; // trim LF
 
-		FILE* file = fopen(m_szLogFilename, FOPEN_ABP);
+		FILE* file = fopen(m_szLogFilename, "a+");
 		if (file)
 		{
 #ifdef WIN32
@@ -114,9 +111,9 @@ void Log::Filelog(const char* msg, ...)
 			unsigned long iThreadId = (unsigned long)pthread_self();
 #endif
 #ifdef DEBUG
-			fprintf(file, "%s\t%lu\t%s%s", szTime, iThreadId, tmp2, LINE_ENDING);
+			fprintf(file, "%s\t%lu\t%s\n", szTime, iThreadId, tmp2);
 #else
-			fprintf(file, "%s\t%s%s", szTime, tmp2, LINE_ENDING);
+			fprintf(file, "%s\t%s\n", szTime, tmp2);
 #endif
 			fclose(file);
 		}
@@ -127,7 +124,6 @@ void Log::Filelog(const char* msg, ...)
 	}
 }
 
-#ifdef DEBUG
 #undef debug
 #ifdef HAVE_VARIADIC_MACROS
 void debug(const char* szFilename, const char* szFuncname, int iLineNr, const char* msg, ...)
@@ -135,6 +131,7 @@ void debug(const char* szFilename, const char* szFuncname, int iLineNr, const ch
 void debug(const char* msg, ...)
 #endif
 {
+#ifdef DEBUG
 	char tmp1[1024];
 
 	va_list ap;
@@ -147,11 +144,11 @@ void debug(const char* msg, ...)
 #ifdef HAVE_VARIADIC_MACROS
 	if (szFuncname)
 	{
-		snprintf(tmp2, 1024, "%s (%s:%i:%s)", tmp1, Util::BaseFileName(szFilename), iLineNr, szFuncname);
+		snprintf(tmp2, 1024, "%s (%s:%i:%s)", tmp1, BaseFileName(szFilename), iLineNr, szFuncname);
 	}
 	else
 	{
-		snprintf(tmp2, 1024, "%s (%s:%i)", tmp1, Util::BaseFileName(szFilename), iLineNr);
+		snprintf(tmp2, 1024, "%s (%s:%i)", tmp1, BaseFileName(szFilename), iLineNr);
 	}
 #else
 	snprintf(tmp2, 1024, "%s", tmp1);
@@ -160,12 +157,18 @@ void debug(const char* msg, ...)
 
 	g_pLog->m_mutexLog.Lock();
 
-	if (!g_pOptions && g_pLog->m_bExtraDebug)
+	if (!g_pOptions)
 	{
-		printf("%s\n", tmp2);
+		if (g_pLog->m_bExtraDebug)
+		{
+			printf("%s\n", tmp2);
+			g_pLog->Filelog("DEBUG\t%s", tmp2);
+		}
+		g_pLog->m_mutexLog.Unlock();
+		return;
 	}
 
-	Options::EMessageTarget eMessageTarget = g_pOptions ? g_pOptions->GetDebugTarget() : Options::mtScreen;
+	Options::EMessageTarget eMessageTarget = g_pOptions->GetDebugTarget();
 	if (eMessageTarget == Options::mtLog || eMessageTarget == Options::mtBoth)
 	{
 		g_pLog->Filelog("DEBUG\t%s", tmp2);
@@ -176,8 +179,8 @@ void debug(const char* msg, ...)
 	}
 
 	g_pLog->m_mutexLog.Unlock();
-}
 #endif
+}
 
 void error(const char* msg, ...)
 {
@@ -191,7 +194,7 @@ void error(const char* msg, ...)
 
 	g_pLog->m_mutexLog.Lock();
 
-	Options::EMessageTarget eMessageTarget = g_pOptions ? g_pOptions->GetErrorTarget() : Options::mtBoth;
+	Options::EMessageTarget eMessageTarget = g_pOptions->GetErrorTarget();
 	if (eMessageTarget == Options::mtLog || eMessageTarget == Options::mtBoth)
 	{
 		g_pLog->Filelog("ERROR\t%s", tmp2);
@@ -216,7 +219,7 @@ void warn(const char* msg, ...)
 
 	g_pLog->m_mutexLog.Lock();
 
-	Options::EMessageTarget eMessageTarget = g_pOptions ? g_pOptions->GetWarningTarget() : Options::mtScreen;
+	Options::EMessageTarget eMessageTarget = g_pOptions->GetWarningTarget();
 	if (eMessageTarget == Options::mtLog || eMessageTarget == Options::mtBoth)
 	{
 		g_pLog->Filelog("WARNING\t%s", tmp2);
@@ -241,7 +244,7 @@ void info(const char* msg, ...)
 
 	g_pLog->m_mutexLog.Lock();
 
-	Options::EMessageTarget eMessageTarget = g_pOptions ? g_pOptions->GetInfoTarget() : Options::mtScreen;
+	Options::EMessageTarget eMessageTarget = g_pOptions->GetInfoTarget();
 	if (eMessageTarget == Options::mtLog || eMessageTarget == Options::mtBoth)
 	{
 		g_pLog->Filelog("INFO\t%s", tmp2);
@@ -254,31 +257,6 @@ void info(const char* msg, ...)
 	g_pLog->m_mutexLog.Unlock();
 }
 
-void detail(const char* msg, ...)
-{
-	char tmp2[1024];
-
-	va_list ap;
-	va_start(ap, msg);
-	vsnprintf(tmp2, 1024, msg, ap);
-	tmp2[1024-1] = '\0';
-	va_end(ap);
-
-	g_pLog->m_mutexLog.Lock();
-
-	Options::EMessageTarget eMessageTarget = g_pOptions ? g_pOptions->GetDetailTarget() : Options::mtScreen;
-	if (eMessageTarget == Options::mtLog || eMessageTarget == Options::mtBoth)
-	{
-		g_pLog->Filelog("DETAIL\t%s", tmp2);
-	}
-	if (eMessageTarget == Options::mtScreen || eMessageTarget == Options::mtBoth)
-	{
-		g_pLog->AppendMessage(Message::mkDetail, tmp2);
-	}
-
-	g_pLog->m_mutexLog.Unlock();
-}
-
 void abort(const char* msg, ...)
 {
 	char tmp2[1024];
@@ -291,7 +269,7 @@ void abort(const char* msg, ...)
 
 	g_pLog->m_mutexLog.Lock();
 
-	printf("\n%s", tmp2);
+	printf("%s", tmp2);
 
 	g_pLog->Filelog(tmp2);
 
@@ -320,18 +298,10 @@ Message::Message(unsigned int iID, EKind eKind, time_t tTime, const char* szText
 
 Message::~ Message()
 {
-	free(m_szText);
-}
-
-void Log::Clear()
-{
-	m_mutexLog.Lock();
-	for (Messages::iterator it = m_Messages.begin(); it != m_Messages.end(); it++)
+	if (m_szText)
 	{
-		delete *it;
+		free(m_szText);
 	}
-	m_Messages.clear();
-	m_mutexLog.Unlock();
 }
 
 void Log::AppendMessage(Message::EKind eKind, const char * szText)
@@ -339,14 +309,11 @@ void Log::AppendMessage(Message::EKind eKind, const char * szText)
 	Message* pMessage = new Message(++m_iIDGen, eKind, time(NULL), szText);
 	m_Messages.push_back(pMessage);
 
-	if (g_pOptions)
+	while (m_Messages.size() > (unsigned int)g_pOptions->GetLogBufferSize())
 	{
-		while (m_Messages.size() > (unsigned int)g_pOptions->GetLogBufferSize())
-		{
-			Message* pMessage = m_Messages.front();
-			delete pMessage;
-			m_Messages.pop_front();
-		}
+		Message* pMessage = m_Messages.front();
+		delete pMessage;
+		m_Messages.pop_front();
 	}
 }
 
@@ -365,81 +332,3 @@ void Log::ResetLog()
 {
 	remove(g_pOptions->GetLogFile());
 }
-
-/*
-* During intializing stage (when options were not read yet) all messages
-* are saved in screen log, even if they shouldn't (according to options).
-* Method "InitOptions()" check all messages added to screen log during
-* intializing stage and does three things:
-* 1) save the messages to log-file (if they should according to options);
-* 2) delete messages from screen log (if they should not be saved in screen log).
-* 3) renumerate IDs
-*/
-void Log::InitOptions()
-{
-	const char* szMessageType[] = { "INFO", "WARNING", "ERROR", "DEBUG", "DETAIL"};
-
-	if (g_pOptions->GetCreateLog() && g_pOptions->GetLogFile())
-	{
-		m_szLogFilename = strdup(g_pOptions->GetLogFile());
-#ifdef WIN32
-		WebUtil::Utf8ToAnsi(m_szLogFilename, strlen(m_szLogFilename) + 1);
-#endif
-	}
-
-	m_iIDGen = 0;
-
-	for (unsigned int i = 0; i < m_Messages.size(); )
-	{
-		Message* pMessage = m_Messages.at(i);
-		Options::EMessageTarget eTarget = Options::mtNone;
-		switch (pMessage->GetKind())
-		{
-			case Message::mkDebug:
-				eTarget = g_pOptions->GetDebugTarget();
-				break;
-			case Message::mkDetail:
-				eTarget = g_pOptions->GetDetailTarget();
-				break;
-			case Message::mkInfo:
-				eTarget = g_pOptions->GetInfoTarget();
-				break;
-			case Message::mkWarning:
-				eTarget = g_pOptions->GetWarningTarget();
-				break;
-			case Message::mkError:
-				eTarget = g_pOptions->GetErrorTarget();
-				break;
-		}
-
-		if (eTarget == Options::mtLog || eTarget == Options::mtBoth)
-		{
-			Filelog("%s\t%s", szMessageType[pMessage->GetKind()], pMessage->GetText());
-		}
-
-		if (eTarget == Options::mtLog || eTarget == Options::mtNone)
-		{
-			delete pMessage;
-			m_Messages.erase(m_Messages.begin() + i);
-		}
-		else
-		{
-			pMessage->m_iID = ++m_iIDGen;
-			i++;
-		}
-	}
-}
-
-void Log::RegisterDebuggable(Debuggable* pDebuggable)
-{
-	m_mutexDebug.Lock();
-	m_Debuggables.push_back(pDebuggable);
-	m_mutexDebug.Unlock();
-}
-
-void Log::UnregisterDebuggable(Debuggable* pDebuggable)
-{
-	m_mutexDebug.Lock();
-	m_Debuggables.remove(pDebuggable);
-	m_mutexDebug.Unlock();
-}

Log.h

@@ -1,8 +1,8 @@
 /*
- *  This file is part of nzbget
+ *  This file if part of nzbget
  *
- *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
- *  Copyright (C) 2007-2014 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -16,7 +16,7 @@
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  *
  * $Revision$
  * $Date$
@@ -28,7 +28,6 @@
 #define LOG_H
 
 #include <deque>
-#include <list>
 #include <time.h>
 
 #include "Thread.h"
@@ -36,27 +35,24 @@
 void error(const char* msg, ...);
 void warn(const char* msg, ...);
 void info(const char* msg, ...);
-void detail(const char* msg, ...);
 void abort(const char* msg, ...);
 
-#ifdef DEBUG
 #ifdef HAVE_VARIADIC_MACROS
 	void debug(const char* szFilename, const char* szFuncname, int iLineNr, const char* msg, ...);
 #else
 	void debug(const char* msg, ...);
 #endif
-#endif
+
 
 class Message
 {
 public:
 	enum EKind
 	{
-		mkInfo,
+	    mkInfo,
 	    mkWarning,
 	    mkError,
-	    mkDebug,
-	    mkDetail
+	    mkDebug
 	};
 
 private:
@@ -65,35 +61,23 @@ private:
 	time_t				m_tTime;
 	char*				m_szText;
 
-	friend class Log;
-
 public:
-						Message(unsigned int iID, EKind eKind, time_t tTime, const char* szText);
-						~Message();
+	Message(unsigned int iID, EKind eKind, time_t tTime, const char* szText);
+	~Message();
 	unsigned int		GetID() { return m_iID; }
 	EKind				GetKind() { return m_eKind; }
 	time_t				GetTime() { return m_tTime; }
 	const char*			GetText() { return m_szText; }
 };
 
-class Debuggable
-{
-protected:
-	virtual void		LogDebugInfo() = 0;
-	friend class Log;
-};
-
 class Log
 {
 public:
 	typedef std::deque<Message*>	Messages;
-	typedef std::list<Debuggable*>	Debuggables;
 
 private:
 	Mutex				m_mutexLog;
 	Messages			m_Messages;
-	Debuggables			m_Debuggables;
-	Mutex				m_mutexDebug;
 	char*				m_szLogFilename;
 	unsigned int		m_iIDGen;
 #ifdef DEBUG
@@ -107,34 +91,26 @@ private:
 	friend void warn(const char* msg, ...);
 	friend void info(const char* msg, ...);
 	friend void abort(const char* msg, ...);
-	friend void detail(const char* msg, ...);
-#ifdef DEBUG
 #ifdef HAVE_VARIADIC_MACROS
 	friend void debug(const char* szFilename, const char* szFuncname, int iLineNr, const char* msg, ...);
 #else	
 	friend void debug(const char* msg, ...);
 #endif
-#endif
 	
 public:
-						Log();
-						~Log();
+	Log();
+	~Log();
 	Messages*			LockMessages();
 	void				UnlockMessages();
-	void				Clear();
 	void				ResetLog();
-	void				InitOptions();
-	void				RegisterDebuggable(Debuggable* pDebuggable);
-	void				UnregisterDebuggable(Debuggable* pDebuggable);
-	void				LogDebugInfo();
 };
 
-#ifdef DEBUG
 #ifdef HAVE_VARIADIC_MACROS
-#define debug(...)   debug(__FILE__, FUNCTION_MACRO_NAME, __LINE__, __VA_ARGS__)
-#endif
-#else
-#define debug(...)   do { } while(0)
+	#ifdef DEBUG
+		#define debug(...)   debug(__FILE__, FUNCTION_MACRO_NAME, __LINE__, __VA_ARGS__)
+	#else
+		#define debug(...)   do { } while(0)
+	#endif
 #endif
 
 extern Log* g_pLog;

LoggableFrontend.cpp

@@ -2,7 +2,7 @@
  *  This file if part of nzbget
  *
  *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
- *  Copyright (C) 2007  Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -16,7 +16,7 @@
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  *
  * $Revision$
  * $Date$
@@ -59,7 +59,7 @@ void LoggableFrontend::Run()
 	while (!IsStopped())
 	{
 		Update();
-		usleep(m_iUpdateInterval * 1000);
+		usleep(200 * 1000);
 	}
 	// Printing the last messages
 	Update();
@@ -106,36 +106,25 @@ void LoggableFrontend::Update()
 
 void LoggableFrontend::PrintMessage(Message * pMessage)
 {
-#ifdef WIN32
-	char* msg = strdup(pMessage->GetText());
-	CharToOem(msg, msg);
-#else
 	const char* msg = pMessage->GetText();
-#endif
 	switch (pMessage->GetKind())
 	{
 		case Message::mkDebug:
-			printf("[DEBUG] %s\n", msg);
+			fprintf(stdout, "[DEBUG] %s\n", msg);
 			break;
 		case Message::mkError:
-			printf("[ERROR] %s\n", msg);
+			fprintf(stdout, "[ERROR] %s\n", msg);
 			break;
 		case Message::mkWarning:
-			printf("[WARNING] %s\n", msg);
+			fprintf(stdout, "[WARNING] %s\n", msg);
 			break;
 		case Message::mkInfo:
-			printf("[INFO] %s\n", msg);
-			break;
-		case Message::mkDetail:
-			printf("[DETAIL] %s\n", msg);
+			fprintf(stdout, "[INFO] %s\n", msg);
 			break;
 	}
-#ifdef WIN32
-	free(msg);
-#endif
 }
 
 void LoggableFrontend::PrintSkip()
 {
-	printf(".....\n");
+	fprintf(stdout, ".....\n");
 }

LoggableFrontend.h

@@ -2,7 +2,7 @@
  *  This file if part of nzbget
  *
  *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
- *  Copyright (C) 2007  Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -16,7 +16,7 @@
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  *
  * $Revision$
  * $Date$

Makefile.am

@@ -1,320 +1,18 @@
-#
-#  This file if part of nzbget
-#
-# Copyright (C) 2008-2014 Andrey Prygunkov <hugbug@users.sourceforge.net>
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-#
-#
-
 bin_PROGRAMS = nzbget
+nzbget_SOURCES = ArticleDownloader.cpp ArticleDownloader.h ColoredFrontend.cpp \
+	ColoredFrontend.h Connection.cpp Connection.h Decoder.cpp Decoder.h DiskState.cpp \
+	DiskState.h DownloadInfo.cpp DownloadInfo.h Frontend.cpp Frontend.h Log.cpp Log.h \
+	LoggableFrontend.cpp LoggableFrontend.h MessageBase.h RemoteServer.cpp RemoteServer.h \
+	NCursesFrontend.cpp NCursesFrontend.h NNTPConnection.cpp NNTPConnection.h RemoteClient.cpp \
+	RemoteClient.h NZBFile.cpp NZBFile.h NetAddress.cpp NetAddress.h NewsServer.cpp \
+	NewsServer.h Observer.cpp Observer.h Options.cpp Options.h ParChecker.cpp \
+	ParChecker.h PrePostProcessor.cpp PrePostProcessor.h QueueCoordinator.cpp \
+	QueueCoordinator.h ServerPool.cpp ServerPool.h Thread.cpp Thread.h Util.cpp Util.h \
+	nzbget.cpp nzbget.h
 
-nzbget_SOURCES = \
-	daemon/connect/Connection.cpp \
-	daemon/connect/Connection.h \
-	daemon/connect/TLS.cpp \
-	daemon/connect/TLS.h \
-	daemon/connect/WebDownloader.cpp \
-	daemon/connect/WebDownloader.h \
-	daemon/feed/FeedCoordinator.cpp \
-	daemon/feed/FeedCoordinator.h \
-	daemon/feed/FeedFile.cpp \
-	daemon/feed/FeedFile.h \
-	daemon/feed/FeedFilter.cpp \
-	daemon/feed/FeedFilter.h \
-	daemon/feed/FeedInfo.cpp \
-	daemon/feed/FeedInfo.h \
-	daemon/frontend/ColoredFrontend.cpp \
-	daemon/frontend/ColoredFrontend.h \
-	daemon/frontend/Frontend.cpp \
-	daemon/frontend/Frontend.h \
-	daemon/frontend/LoggableFrontend.cpp \
-	daemon/frontend/LoggableFrontend.h \
-	daemon/frontend/NCursesFrontend.cpp \
-	daemon/frontend/NCursesFrontend.h \
-	daemon/main/Maintenance.cpp \
-	daemon/main/Maintenance.h \
-	daemon/main/nzbget.cpp \
-	daemon/main/nzbget.h \
-	daemon/main/Options.cpp \
-	daemon/main/Options.h \
-	daemon/main/Scheduler.cpp \
-	daemon/main/Scheduler.h \
-	daemon/nntp/ArticleDownloader.cpp \
-	daemon/nntp/ArticleDownloader.h \
-	daemon/nntp/Decoder.cpp \
-	daemon/nntp/Decoder.h \
-	daemon/nntp/NewsServer.cpp \
-	daemon/nntp/NewsServer.h \
-	daemon/nntp/NNTPConnection.cpp \
-	daemon/nntp/NNTPConnection.h \
-	daemon/nntp/ServerPool.cpp \
-	daemon/nntp/ServerPool.h \
-	daemon/nntp/StatMeter.cpp \
-	daemon/nntp/StatMeter.h \
-	daemon/postprocess/ParChecker.cpp \
-	daemon/postprocess/ParChecker.h \
-	daemon/postprocess/ParCoordinator.cpp \
-	daemon/postprocess/ParCoordinator.h \
-	daemon/postprocess/ParRenamer.cpp \
-	daemon/postprocess/ParRenamer.h \
-	daemon/postprocess/PostScript.cpp \
-	daemon/postprocess/PostScript.h \
-	daemon/postprocess/PrePostProcessor.cpp \
-	daemon/postprocess/PrePostProcessor.h \
-	daemon/postprocess/Unpack.cpp \
-	daemon/postprocess/Unpack.h \
-	daemon/queue/DiskState.cpp \
-	daemon/queue/DiskState.h \
-	daemon/queue/DownloadInfo.cpp \
-	daemon/queue/DownloadInfo.h \
-	daemon/queue/DupeCoordinator.cpp \
-	daemon/queue/DupeCoordinator.h \
-	daemon/queue/HistoryCoordinator.cpp \
-	daemon/queue/HistoryCoordinator.h \
-	daemon/queue/NZBFile.cpp \
-	daemon/queue/NZBFile.h \
-	daemon/queue/QueueCoordinator.cpp \
-	daemon/queue/QueueCoordinator.h \
-	daemon/queue/QueueEditor.cpp \
-	daemon/queue/QueueEditor.h \
-	daemon/queue/QueueScript.cpp \
-	daemon/queue/QueueScript.h \
-	daemon/queue/Scanner.cpp \
-	daemon/queue/Scanner.h \
-	daemon/queue/UrlCoordinator.cpp \
-	daemon/queue/UrlCoordinator.h \
-	daemon/remote/BinRpc.cpp \
-	daemon/remote/BinRpc.h \
-	daemon/remote/MessageBase.h \
-	daemon/remote/RemoteClient.cpp \
-	daemon/remote/RemoteClient.h \
-	daemon/remote/RemoteServer.cpp \
-	daemon/remote/RemoteServer.h \
-	daemon/remote/WebServer.cpp \
-	daemon/remote/WebServer.h \
-	daemon/remote/XmlRpc.cpp \
-	daemon/remote/XmlRpc.h \
-	daemon/util/Log.cpp \
-	daemon/util/Log.h \
-	daemon/util/Observer.cpp \
-	daemon/util/Observer.h \
-	daemon/util/Script.cpp \
-	daemon/util/Script.h \
-	daemon/util/Thread.cpp \
-	daemon/util/Thread.h \
-	daemon/util/Util.cpp \
-	daemon/util/Util.h \
-	svn_version.cpp
-
-AM_CPPFLAGS = \
-	-I$(srcdir)/daemon/connect \
-	-I$(srcdir)/daemon/feed \
-	-I$(srcdir)/daemon/frontend \
-	-I$(srcdir)/daemon/main \
-	-I$(srcdir)/daemon/nntp \
-	-I$(srcdir)/daemon/postprocess \
-	-I$(srcdir)/daemon/queue \
-	-I$(srcdir)/daemon/remote \
-	-I$(srcdir)/daemon/util
-
-EXTRA_DIST = \
-	Makefile.cvs \
-	nzbgetd \
-	$(windows_FILES) \
-	$(osx_FILES)
-
-windows_FILES = \
-	daemon/windows/NTService.cpp \
-	daemon/windows/NTService.h \
-	daemon/windows/win32.h \
-	nzbget.sln \
-	nzbget.vcproj \
-	nzbget-shell.bat
-
-osx_FILES = \
-	osx/App_Prefix.pch \
-	osx/NZBGet-Info.plist \
-	osx/DaemonController.h \
-	osx/DaemonController.m \
-	osx/MainApp.h \
-	osx/MainApp.m \
-	osx/MainApp.xib \
-	osx/PFMoveApplication.h \
-	osx/PFMoveApplication.m \
-	osx/PreferencesDialog.h \
-	osx/PreferencesDialog.m \
-	osx/PreferencesDialog.xib \
-	osx/RPC.h \
-	osx/RPC.m \
-	osx/WebClient.h \
-	osx/WebClient.m \
-	osx/WelcomeDialog.h \
-	osx/WelcomeDialog.m \
-	osx/WelcomeDialog.xib \
-	osx/NZBGet.xcodeproj/project.pbxproj \
-	osx/Resources/Images/mainicon.icns \
-	osx/Resources/Images/statusicon.png \
-	osx/Resources/Images/statusicon@2x.png \
-	osx/Resources/Images/statusicon-inv.png \
-	osx/Resources/Images/statusicon-inv@2x.png \
-	osx/Resources/licenses/license-bootstrap.txt \
-	osx/Resources/licenses/license-jquery-GPL.txt \
-	osx/Resources/licenses/license-jquery-MIT.txt \
-	osx/Resources/Credits.rtf \
-	osx/Resources/Localizable.strings \
-	osx/Resources/Welcome.rtf
-
-doc_FILES = \
-	README \
-	ChangeLog \
-	COPYING
-
-exampleconf_FILES = \
-	nzbget.conf
-
-webui_FILES = \
-	webui/index.html \
-	webui/index.js \
-	webui/downloads.js \
-	webui/edit.js \
-	webui/fasttable.js \
-	webui/history.js \
-	webui/messages.js \
-	webui/status.js \
-	webui/style.css \
-	webui/upload.js \
-	webui/util.js \
-	webui/config.js \
-	webui/feed.js \
-	webui/lib/bootstrap.js \
-	webui/lib/bootstrap.min.js \
-	webui/lib/bootstrap.css  \
-	webui/lib/jquery.js \
-	webui/lib/jquery.min.js \
-	webui/lib/raphael.js \
-	webui/lib/raphael.min.js \
-	webui/lib/elycharts.js \
-	webui/lib/elycharts.min.js \
-	webui/img/icons.png \
-	webui/img/icons-2x.png \
-	webui/img/transmit.gif \
-	webui/img/transmit-file.gif \
-	webui/img/favicon.ico \
-	webui/img/download-anim-green-2x.png \
-	webui/img/download-anim-orange-2x.png \
-	webui/img/transmit-reload-2x.gif
-
-scripts_FILES = \
-	scripts/EMail.py \
-	scripts/Logger.py
-
-# Install
-sbin_SCRIPTS = nzbgetd
-dist_doc_DATA = $(doc_FILES)
-exampleconfdir = $(datadir)/nzbget
-dist_exampleconf_DATA = $(exampleconf_FILES)
-webuidir = $(datadir)/nzbget
-nobase_dist_webui_DATA = $(webui_FILES)
-scriptsdir = $(datadir)/nzbget
-nobase_dist_scripts_SCRIPTS = $(scripts_FILES)
-
-# Note about "sed": 
-# We need to make some changes in installed files.
-# On Linux "sed" has option "-i" for in-place-edit. Unfortunateley the BSD version of "sed"
-# has incompatible syntax. To solve the problem we perform in-place-edit in three steps:
-# 1) copy the original file to original.temp (delete existing original.temp, if any);
-# 2) sed < original.temp > original
-# 3) delete original.temp
-# These steps ensure that the output file has the same permissions as the original file.
-
-# Configure installed script
-install-exec-hook:
-	rm -f "$(DESTDIR)$(sbindir)/nzbgetd.temp"
-	cp "$(DESTDIR)$(sbindir)/nzbgetd" "$(DESTDIR)$(sbindir)/nzbgetd.temp"
-	sed 's?/usr/local/bin?$(bindir)?' < "$(DESTDIR)$(sbindir)/nzbgetd.temp" > "$(DESTDIR)$(sbindir)/nzbgetd"
-	rm "$(DESTDIR)$(sbindir)/nzbgetd.temp"
-
-# Prepare example configuration file
-install-data-hook:
-	rm -f "$(DESTDIR)$(exampleconfdir)/nzbget.conf.temp"
-	cp "$(DESTDIR)$(exampleconfdir)/nzbget.conf" "$(DESTDIR)$(exampleconfdir)/nzbget.conf.temp"
-	sed 's:^ConfigTemplate=:ConfigTemplate=$(exampleconfdir)/nzbget.conf:' < "$(DESTDIR)$(exampleconfdir)/nzbget.conf.temp" > "$(DESTDIR)$(exampleconfdir)/nzbget.conf"
-	sed 's:configuration file (typically installed:configuration file (installed:' < "$(DESTDIR)$(exampleconfdir)/nzbget.conf" > "$(DESTDIR)$(exampleconfdir)/nzbget.conf.temp"
-	sed 's:/usr/local/share/nzbget/nzbget.conf):$(exampleconfdir)/nzbget.conf):' < "$(DESTDIR)$(exampleconfdir)/nzbget.conf.temp" > "$(DESTDIR)$(exampleconfdir)/nzbget.conf"
-	sed 's:^WebDir=:WebDir=$(webuidir)/webui:' < "$(DESTDIR)$(exampleconfdir)/nzbget.conf" > "$(DESTDIR)$(exampleconfdir)/nzbget.conf.temp"
-	sed 's:typically installed to /usr/local/share/nzbget/scripts:installed to $(scriptsdir)/scripts:' < "$(DESTDIR)$(exampleconfdir)/nzbget.conf.temp" > "$(DESTDIR)$(exampleconfdir)/nzbget.conf"
-	rm "$(DESTDIR)$(exampleconfdir)/nzbget.conf.temp"
-
-# Install configuration files into /etc
-# (only if they do not exist there to prevent override by update)
-install-conf:
-	if test ! -f "$(DESTDIR)$(sysconfdir)/nzbget.conf" ; then \
-		$(mkinstalldirs) "$(DESTDIR)$(sysconfdir)" ; \
-		cp "$(DESTDIR)$(exampleconfdir)/nzbget.conf" "$(DESTDIR)$(sysconfdir)/nzbget.conf" ; \
-	fi
-
-uninstall-conf:
-	rm -f "$(DESTDIR)$(sysconfdir)/nzbget.conf"
-
-# Determining subversion revision:
-# 1) If directory ".svn" exists we take revision from it using program svnversion (part of subversion package)
-#    File is recreated only if revision number was changed.
-# 2) If directory ".svn" doesn't exists we keep and reuse file "svn_version.cpp",
-#    which was possibly created early.
-# 3) If neither directory ".svn" nor file "svn_version.cpp" are available
-#    we create new file "svn_version.c" with empty revision number.
-svn_version.cpp: FORCE
-	@ if test -d ./.svn ; then \
-		V="$(shell svnversion -n .)"; \
-		H="$(shell test -f ./svn_version.cpp && head -n 1 svn_version.cpp)"; \
-		if test "/* $$V */" != "$$H" ; then \
-			( \
-			echo "/* $$V */" ;\
-			echo "/* This file is automatically regenerated on each build. Do not edit it. */" ;\
-			echo "const char* svn_version(void)" ;\
-			echo "{" ;\
-			echo "	const char* SVN_Version = \"$$V\";" ;\
-			echo "	return SVN_Version;" ;\
-			echo "}" ;\
-			) > svn_version.cpp ; \
-		fi \
-	elif test -f ./svn_version.cpp ; then \
-		test "ok, reuse existing file"; \
-	else \
-		( \
-		echo "/*  */" ;\
-		echo "/* This file is automatically regenerated on each build. Do not edit it. */" ;\
-		echo "const char* svn_version(void)" ;\
-		echo "{" ;\
-		echo "	const char* SVN_Version = \"\";" ;\
-		echo "	return SVN_Version;" ;\
-		echo "}" ;\
-		) > svn_version.cpp ; \
-	fi
-FORCE:
-
-# Ignore "svn_version.cpp" in distcleancheck
-distcleancheck_listfiles = \
-	find . -type f -exec sh -c 'test -f $(srcdir)/$$1 || echo $$1' \
-	sh '{}' ';'
+EXTRA_DIST = nzbget.conf.example \
+	win32.h NTService.cpp NTService.h \
+	libpar2-0.2-MSVC8.patch libsigc++-2.0.18-MSVC8.patch \
+	nzbget.kdevelop nzbget.sln nzbget.vcproj
 
 clean-bak: rm *~
-
-# Fix premissions
-dist-hook:
-	find $(distdir)/daemon -type f -print -exec chmod -x {} \;
-	find $(distdir)/webui -type f -print -exec chmod -x {} \;
-

Makefile.cvs

@@ -1,8 +0,0 @@
-default: all
-
-all:
-	aclocal
-	autoheader
-	automake
-	autoconf
-

MessageBase.h

@@ -0,0 +1,187 @@
+/*
+ *  This file if part of nzbget
+ *
+ *  Copyright (C) 2005  Bo Cordes Petersen <placebodk@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifndef MESSAGEBASE_H
+#define MESSAGEBASE_H
+
+static const int32_t NZBMESSAGE_SIGNATURE = 0x6E7A6201; // = "nzb"-version-1
+static const int NZBREQUESTFILENAMESIZE = 512;
+static const int NZBREQUESTPASSWORDSIZE = 32;
+
+// The pack-directive prevents aligning of structs.
+// This makes them more portable and allows to use together servers and clients
+// compiled on different cpu architectures
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack(1)
+#endif
+
+namespace NZBMessageRequest
+{
+enum
+{
+    eRequestDownload = 1,
+    eRequestPauseUnpause,
+    eRequestList,
+    eRequestSetDownloadRate,
+    eRequestDumpDebug,
+    eRequestEditQueue,
+    eRequestLog,
+    eRequestShutdown
+};
+
+// Possible values for field "m_iAction" of struct "SNZBEditQueueRequest":
+enum
+{
+    eActionMoveOffset = 1,	// move to m_iOffset relative to the current position in queue
+    eActionMoveTop,			// move to top of queue
+    eActionMoveBottom,		// move to bottom of queue
+    eActionPause,			// pause
+    eActionResume,			// resume (unpause)
+    eActionDelete			// delete
+};
+}
+
+// The basic NZBMessageBase struct
+struct SNZBMessageBase
+{
+	int32_t					m_iId;		// Id must be 'nzbg' in integer-value
+	int32_t					m_iType;	// message type, must be > 0
+	int32_t					m_iSize;	// Size of the entire struct
+	char					m_szPassword[ NZBREQUESTPASSWORDSIZE ];	// Password needs to be in every request
+};
+
+// A download request
+struct SNZBDownloadRequest
+{
+	SNZBMessageBase			m_MessageBase;	// Must be the first in the struct
+	char					m_szFilename[ NZBREQUESTFILENAMESIZE ];
+	int32_t					m_bAddFirst;
+	int32_t					m_iTrailingDataLength;
+};
+
+// A list request
+struct SNZBListRequest
+{
+	SNZBMessageBase			m_MessageBase;	// Must be the first in the struct
+	int32_t					m_bFileList;
+	int32_t					m_bServerState;
+};
+
+// A list request-answer
+struct SNZBListRequestAnswer
+{
+	int32_t					m_iSize;	// Size of the entire struct
+	int32_t					m_iEntrySize;	// Size of the SNZBListRequestAnswerEntry-struct
+	long long 				m_lRemainingSize;
+	float					m_fDownloadRate;
+	float					m_fDownloadLimit;
+	int32_t					m_bServerPaused;
+	int32_t					m_iThreadCount;
+	int32_t					m_iNrTrailingEntries;
+	int32_t					m_iTrailingDataLength;
+};
+
+// A list request-answer entry
+struct SNZBListRequestAnswerEntry
+{
+	int32_t					m_iNZBFilenameLen;
+	int32_t					m_iSubjectLen;
+	int32_t					m_iFilenameLen;
+	int32_t					m_iDestDirLen;
+	int32_t					m_iFileSize;
+	int32_t					m_bFilenameConfirmed;
+	int32_t					m_iRemainingSize;
+	int32_t					m_iID;
+	int32_t					m_bPaused;
+	//char					m_szNZBFilename[0]; // variable sized
+	//char					m_szSubject[0]; // variable sized
+	//char					m_szFilename[0]; // variable sized
+	//char					m_szDestDir[0]; // variable sized
+};
+
+// A log request
+struct SNZBLogRequest
+{
+	SNZBMessageBase			m_MessageBase;	// Must be the first in the struct
+	int32_t					m_iIDFrom;      // Only one of these two parameters
+	int32_t					m_iLines;		// can be set. The another one must be set to "0".
+};
+
+// A log request-answer
+struct SNZBLogRequestAnswer
+{
+	int32_t					m_iSize;	// Size of the entire struct
+	int32_t					m_iEntrySize;	// Size of the SNZBLogRequestAnswerEntry-struct
+	int32_t					m_iNrTrailingEntries;
+	int32_t					m_iTrailingDataLength;
+};
+
+// A log request-answer entry
+struct SNZBLogRequestAnswerEntry
+{
+	int32_t					m_iTextLen;
+	int32_t					m_iID;
+	int32_t					m_iKind;     // see Message::Kind in "Log.h"
+	time_t					m_tTime;
+	//char					m_szText[0]; // variable sized
+};
+
+// A Pause/Unpause request
+struct SNZBPauseUnpauseRequest
+{
+	SNZBMessageBase			m_MessageBase;	// Must be the first in the struct
+	int32_t					m_bPause;		// The value g_bPause should be set to
+};
+
+// Request setting the download rate
+struct SNZBSetDownloadRateRequest
+{
+	SNZBMessageBase			m_MessageBase;		// Must be the first in the struct
+	float					m_fDownloadRate;
+};
+
+// A download request
+struct SNZBEditQueueRequest
+{
+	SNZBMessageBase			m_MessageBase;	// Must be the first in the struct
+	int32_t					m_iIDFrom;			// ID of the first file in the range
+	int32_t					m_iIDTo;			// ID of the last file in the range, not used yet, must be same as m_iIDFrom
+	int32_t					m_iAction;			// action to be done, see later
+	int32_t					m_iOffset;			// Offset to move (for m_iAction = 0)
+};
+
+// Request dumping of debug info
+struct SNZBDumpDebugRequest
+{
+	SNZBMessageBase			m_MessageBase;		// Must be the first in the struct
+	int32_t					m_iLevel;			// Future use
+};
+
+#ifdef HAVE_PRAGMA_PACK
+#pragma pack()
+#endif
+
+#endif

NCursesFrontend.cpp

@@ -0,0 +1,975 @@
+/*
+ *  This file if part of nzbget
+ *
+ *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef WIN32
+#include "win32.h"
+#endif
+
+#ifndef DISABLE_CURSES
+
+#ifdef HAVE_NCURSES_H
+#include <ncurses.h>
+#endif
+#ifdef HAVE_NCURSES_NCURSES_H
+#include <ncurses/ncurses.h>
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#ifndef WIN32
+#include <unistd.h>
+#endif
+
+#include "nzbget.h"
+#include "NCursesFrontend.h"
+
+#ifdef HAVE_CURSES_H
+// curses.h header must be included last to avoid problems on Solaris
+// (and possibly other systems, that uses curses.h (not ncurses.h)
+#include <curses.h>
+// "#undef erase" is neccessary on Solaris
+#undef erase
+#endif
+
+extern void ExitProc();
+
+static const int NCURSES_COLORPAIR_TEXT			= 1;
+static const int NCURSES_COLORPAIR_INFO			= 2;
+static const int NCURSES_COLORPAIR_WARNING		= 3;
+static const int NCURSES_COLORPAIR_ERROR		= 4;
+static const int NCURSES_COLORPAIR_DEBUG		= 5;
+static const int NCURSES_COLORPAIR_STATUS		= 6;
+static const int NCURSES_COLORPAIR_KEYBAR		= 7;
+static const int NCURSES_COLORPAIR_INFOLINE		= 8;
+static const int NCURSES_COLORPAIR_TEXTHIGHL	= 9;
+static const int NCURSES_COLORPAIR_CURSOR		= 10;
+
+static const int MAX_SCREEN_WIDTH				= 512;
+
+#ifdef WIN32
+static const int COLOR_BLACK	= 0;
+static const int COLOR_BLUE		= FOREGROUND_BLUE;
+static const int COLOR_RED		= FOREGROUND_RED;
+static const int COLOR_GREEN	= FOREGROUND_GREEN;
+static const int COLOR_WHITE	= FOREGROUND_BLUE | FOREGROUND_RED | FOREGROUND_GREEN;
+static const int COLOR_MAGENTA	= FOREGROUND_RED | FOREGROUND_BLUE;
+static const int COLOR_CYAN		= FOREGROUND_BLUE | FOREGROUND_GREEN;
+static const int COLOR_YELLOW	= FOREGROUND_RED | FOREGROUND_GREEN;
+
+static const int READKEY_EMPTY = 0;
+
+#define KEY_DOWN VK_DOWN
+#define KEY_UP VK_UP
+#define KEY_PPAGE VK_PRIOR
+#define KEY_NPAGE VK_NEXT
+#define KEY_END VK_END
+#define KEY_HOME VK_HOME
+#define KEY_BACKSPACE VK_BACK
+
+#else
+
+static const int READKEY_EMPTY = ERR;
+
+#endif
+
+NCursesFrontend::NCursesFrontend()
+{
+    m_iScreenHeight = 0;
+    m_iScreenWidth = 0;
+    m_iInputNumberIndex = 0;
+    m_eInputMode = eNormal;
+    m_bSummary = true;
+    m_bFileList = true;
+    m_iNeededLogEntries = 0;
+    m_iSkipUpdateData = 0;
+	m_iQueueWinTop = 0;
+	m_iQueueWinHeight = 0;
+	m_iQueueWinClientHeight = 0;
+	m_iMessagesWinTop = 0;
+	m_iMessagesWinHeight = 0;
+	m_iMessagesWinClientHeight = 0;
+    m_iSelectedQueueEntry = 0;
+	m_iQueueScrollOffset = 0;
+	m_bShowNZBname = true;
+	m_QueueWindowPercentage = 0.5f;
+
+    // Setup curses
+#ifdef WIN32
+	HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
+	m_pScreenBuffer = NULL;
+	m_pOldScreenBuffer = NULL;
+	m_ColorAttr.clear();
+
+	CONSOLE_CURSOR_INFO ConsoleCursorInfo;
+	GetConsoleCursorInfo(hConsole, &ConsoleCursorInfo);
+	ConsoleCursorInfo.bVisible = false;
+	SetConsoleCursorInfo(hConsole, &ConsoleCursorInfo);
+	if (IsRemoteMode())
+	{
+		SetConsoleTitle("NZBGet - remote mode");
+	}
+	else
+	{
+		SetConsoleTitle("NZBGet");
+	}
+
+	m_bUseColor = true;
+#else
+    m_pWindow = initscr();
+    if (m_pWindow == NULL)
+    {
+        printf("ERROR: m_pWindow == NULL\n");
+        exit(-1);
+    }
+	keypad(stdscr, true);
+    nodelay((WINDOW*)m_pWindow, true);
+    noecho();
+    curs_set(0);
+    m_bUseColor = has_colors();
+#endif
+
+    if (m_bUseColor)
+    {
+#ifndef WIN32
+        start_color();
+#endif
+        init_pair(0,							COLOR_WHITE,	COLOR_BLUE);
+        init_pair(NCURSES_COLORPAIR_TEXT,		COLOR_WHITE,	COLOR_BLACK);
+        init_pair(NCURSES_COLORPAIR_INFO,		COLOR_GREEN,	COLOR_BLACK);
+        init_pair(NCURSES_COLORPAIR_WARNING,	COLOR_MAGENTA,	COLOR_BLACK);
+        init_pair(NCURSES_COLORPAIR_ERROR,		COLOR_RED,		COLOR_BLACK);
+        init_pair(NCURSES_COLORPAIR_DEBUG,		COLOR_WHITE,	COLOR_BLACK);
+        init_pair(NCURSES_COLORPAIR_STATUS,		COLOR_BLUE,		COLOR_WHITE);
+        init_pair(NCURSES_COLORPAIR_KEYBAR,		COLOR_WHITE,	COLOR_BLUE);
+        init_pair(NCURSES_COLORPAIR_INFOLINE,	COLOR_WHITE,	COLOR_BLUE);
+        init_pair(NCURSES_COLORPAIR_TEXTHIGHL,	COLOR_BLACK,	COLOR_CYAN);
+        init_pair(NCURSES_COLORPAIR_CURSOR,		COLOR_BLACK,	COLOR_YELLOW);
+    }
+}
+
+NCursesFrontend::~NCursesFrontend()
+{
+#ifdef WIN32
+	if (m_pScreenBuffer)
+	{
+		free(m_pScreenBuffer);
+	}
+	if (m_pOldScreenBuffer)
+	{
+		free(m_pOldScreenBuffer);
+	}
+	m_ColorAttr.clear();
+
+	HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
+	CONSOLE_CURSOR_INFO ConsoleCursorInfo;
+	GetConsoleCursorInfo(hConsole, &ConsoleCursorInfo);
+	ConsoleCursorInfo.bVisible = true;
+	SetConsoleCursorInfo(hConsole, &ConsoleCursorInfo);
+#else
+    keypad(stdscr, false);
+    echo();
+    curs_set(1);
+    endwin();
+#endif
+    printf("\n");
+}
+
+void NCursesFrontend::Run()
+{
+    debug("Entering NCursesFrontend-loop");
+
+    while (!IsStopped())
+    {
+        // The data (queue and log) is updated each 200 msec,
+        // but the window is updated more often for better reaction on user's input
+        Update();
+        usleep(25 * 1000);
+        m_iSkipUpdateData -= 25;
+        if (m_iSkipUpdateData < 0)
+        {
+            m_iSkipUpdateData = 200;
+        }
+    }
+
+    FreeData();
+	
+    debug("Exiting NCursesFrontend-loop");
+}
+
+void NCursesFrontend::Update()
+{
+    // Figure out how big the screen is
+	CalcWindowSizes();
+
+    if (!m_iSkipUpdateData)
+    {
+        FreeData();
+		m_iNeededLogEntries = m_iMessagesWinClientHeight;
+        if (!PrepareData())
+        {
+            return;
+        }
+    }
+	
+    //------------------------------------------
+    // Print Current NZBQueue
+    //------------------------------------------
+	if (m_iQueueWinHeight > 0)
+	{
+		PrintQueue();
+	}
+
+    //------------------------------------------
+    // Print Messages
+    //------------------------------------------
+	if (m_iMessagesWinHeight > 0)
+	{
+		PrintMessages();
+	}
+
+    PrintStatus();
+
+	PrintKeyInputBar();
+
+    // Update the input
+    UpdateInput();
+
+	RefreshScreen();
+}
+
+void NCursesFrontend::CalcWindowSizes()
+{
+    int iNrRows, iNrColumns;
+#ifdef WIN32
+	HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
+	CONSOLE_SCREEN_BUFFER_INFO BufInfo;
+	GetConsoleScreenBufferInfo(hConsole, &BufInfo);
+	iNrRows = BufInfo.srWindow.Bottom - BufInfo.srWindow.Top + 1;
+	iNrColumns = BufInfo.srWindow.Right - BufInfo.srWindow.Left + 1;
+#else
+    getmaxyx(stdscr, iNrRows, iNrColumns);
+#endif
+    if (iNrRows != m_iScreenHeight || iNrColumns != m_iScreenWidth)
+    {
+#ifdef WIN32
+		m_iScreenBufferSize = iNrRows * iNrColumns * sizeof(CHAR_INFO);
+		m_pScreenBuffer = (CHAR_INFO*)malloc(m_iScreenBufferSize);
+		memset(m_pScreenBuffer, 0, m_iScreenBufferSize);
+		m_pOldScreenBuffer = (CHAR_INFO*)malloc(m_iScreenBufferSize);
+		memset(m_pOldScreenBuffer, 0, m_iScreenBufferSize);
+#else
+        clear();
+#endif
+        m_iScreenHeight = iNrRows;
+        m_iScreenWidth = iNrColumns;
+    }
+
+	DownloadQueue* pDownloadQueue = LockQueue();
+    int iQueueSize = pDownloadQueue->size();
+    UnlockQueue();
+    
+	m_iQueueWinTop = 0;
+	m_iQueueWinHeight = (int)((float) (m_iScreenHeight - 2) * m_QueueWindowPercentage);
+	if (m_iQueueWinHeight - 1 > iQueueSize)
+	{
+		m_iQueueWinHeight = iQueueSize > 0 ? iQueueSize + 1 : 1 + 1;
+	}
+	m_iQueueWinClientHeight = m_iQueueWinHeight - 1;
+	if (m_iQueueWinClientHeight < 0)
+	{
+		m_iQueueWinClientHeight = 0;
+	}
+
+	m_iMessagesWinTop = m_iQueueWinTop + m_iQueueWinHeight;
+	m_iMessagesWinHeight = m_iScreenHeight - m_iQueueWinHeight - 2;
+	m_iMessagesWinClientHeight = m_iMessagesWinHeight - 1;
+	if (m_iMessagesWinClientHeight < 0)
+	{
+		m_iMessagesWinClientHeight = 0;
+	}
+}
+
+void NCursesFrontend::PlotLine(const char * szString, int iRow, int iPos, int iColorPair)
+{
+    char szBuffer[MAX_SCREEN_WIDTH];
+    snprintf(szBuffer, sizeof(szBuffer), "%-*s", m_iScreenWidth, szString);
+	szBuffer[MAX_SCREEN_WIDTH - 1] = '\0';
+	int iLen = strlen(szBuffer);
+	if (iLen > m_iScreenWidth - iPos && m_iScreenWidth - iPos < MAX_SCREEN_WIDTH)
+	{
+		szBuffer[m_iScreenWidth - iPos] = '\0';
+	}
+
+	PlotText(szBuffer, iRow, iPos, iColorPair, false);
+}
+
+void NCursesFrontend::PlotText(const char * szString, int iRow, int iPos, int iColorPair, bool bBlink)
+{
+#ifdef WIN32
+	int iBufPos = iRow * m_iScreenWidth + iPos;
+	int len = strlen(szString);
+	for (int i = 0; i < len; i++)
+	{
+		m_pScreenBuffer[iBufPos + i].Char.AsciiChar = szString[i];
+		m_pScreenBuffer[iBufPos + i].Attributes = m_ColorAttr[iColorPair];
+	}
+#else
+	if( m_bUseColor ) 
+	{
+		attron(COLOR_PAIR(iColorPair));
+		if (bBlink)
+		{
+			attron(A_BLINK);
+		}
+	}
+    mvaddstr(iRow, iPos, (char*)szString);
+	if( m_bUseColor ) 
+	{
+		attroff(COLOR_PAIR(iColorPair));
+		if (bBlink)
+		{
+			attroff(A_BLINK);
+		}
+	}
+#endif
+}
+
+void NCursesFrontend::RefreshScreen()
+{
+#ifdef WIN32
+	bool bBufChanged = memcmp(m_pScreenBuffer, m_pOldScreenBuffer, m_iScreenBufferSize);
+	if (bBufChanged)
+	{
+		COORD BufSize;
+		BufSize.X = m_iScreenWidth;
+		BufSize.Y = m_iScreenHeight;
+
+		COORD BufCoord;
+		BufCoord.X = 0;
+		BufCoord.Y = 0;
+
+		HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
+		CONSOLE_SCREEN_BUFFER_INFO BufInfo;
+		GetConsoleScreenBufferInfo(hConsole, &BufInfo);
+		WriteConsoleOutput(hConsole, m_pScreenBuffer, BufSize, BufCoord, &BufInfo.srWindow);
+
+		BufInfo.dwCursorPosition.X = BufInfo.srWindow.Right;
+		BufInfo.dwCursorPosition.Y = BufInfo.srWindow.Bottom;
+		SetConsoleCursorPosition(hConsole, BufInfo.dwCursorPosition);
+
+		memcpy(m_pOldScreenBuffer, m_pScreenBuffer, m_iScreenBufferSize);
+	}
+#else
+    // Cursor placement
+    wmove((WINDOW*)m_pWindow, m_iScreenHeight, m_iScreenWidth);
+
+    // NCurses refresh
+    refresh();
+#endif
+}
+
+#ifdef WIN32
+void NCursesFrontend::init_pair(int iColorNumber, WORD wForeColor, WORD wBackColor)
+{
+	m_ColorAttr.resize(iColorNumber + 1);
+	m_ColorAttr[iColorNumber] = wForeColor | (wBackColor << 4);
+}
+#endif
+
+void NCursesFrontend::PrintMessages()
+{
+	int iLineNr = m_iMessagesWinTop;
+
+	char szBuffer[MAX_SCREEN_WIDTH];
+	snprintf(szBuffer, sizeof(szBuffer), "%s Messages", m_bUseColor ? "" : "*** ");
+	szBuffer[MAX_SCREEN_WIDTH - 1] = '\0';
+    PlotLine(szBuffer, iLineNr++, 0, NCURSES_COLORPAIR_INFOLINE);
+	
+    int iLine = iLineNr + m_iMessagesWinClientHeight - 1;
+	int iLinesToPrint = m_iMessagesWinClientHeight;
+
+    Log::Messages* pMessages = LockMessages();
+    
+	// print messages from bottom
+	for (int i = (int)pMessages->size() - 1; i >= 0 && iLinesToPrint > 0; i--)
+    {
+        int iPrintedLines = PrintMessage((*pMessages)[i], iLine, iLinesToPrint);
+		iLine -= iPrintedLines;
+		iLinesToPrint -= iPrintedLines;
+    }
+
+	if (iLinesToPrint > 0)
+	{
+		// too few messages, print them again from top
+    	iLine = iLineNr + m_iMessagesWinClientHeight - 1;
+		while (iLinesToPrint-- > 0)
+		{
+			PlotLine("", iLine--, 0, NCURSES_COLORPAIR_TEXT);
+		}
+		int iLinesToPrint2 = m_iMessagesWinClientHeight;
+		for (int i = (int)pMessages->size() - 1; i >= 0 && iLinesToPrint2 > 0; i--)
+		{
+			int iPrintedLines = PrintMessage((*pMessages)[i], iLine, iLinesToPrint2);
+			iLine -= iPrintedLines;
+			iLinesToPrint2 -= iPrintedLines;
+		}
+	}
+	
+    UnlockMessages();
+}
+
+int NCursesFrontend::PrintMessage(Message* Msg, int iRow, int iMaxLines)
+{
+    char* szMessageType[] = { "INFO    ", "WARNING ", "ERROR   ", "DEBUG   "};
+    const int iMessageTypeColor[] = { NCURSES_COLORPAIR_INFO, NCURSES_COLORPAIR_WARNING,
+    	NCURSES_COLORPAIR_ERROR, NCURSES_COLORPAIR_DEBUG };
+
+	const char* szText = Msg->GetText();
+	int iLen = strlen(szText);
+	int iWinWidth = m_iScreenWidth - 8;
+	int iMsgLines = iLen / iWinWidth;
+	if (iLen % iWinWidth > 0)
+	{
+		iMsgLines++;
+	}
+	
+	int iLines = 0;
+	for (int i = iMsgLines - 1; i >= 0 && iLines < iMaxLines; i--)
+	{
+		int iR = iRow - iMsgLines + i + 1;
+		PlotLine(szText + iWinWidth * i, iR, 8, NCURSES_COLORPAIR_TEXT);
+		if (i == 0)
+		{
+			PlotText(szMessageType[Msg->GetKind()], iR, 0, iMessageTypeColor[Msg->GetKind()], false);
+		}
+		else
+		{
+			PlotText("        ", iR, 0, iMessageTypeColor[Msg->GetKind()], false);
+		}
+		iLines++;
+	}
+	
+	return iLines;
+}
+
+void NCursesFrontend::PrintStatus()
+{
+    char tmp[MAX_SCREEN_WIDTH];
+    int iStatusRow = m_iScreenHeight - 2;
+
+    char timeString[100];
+    timeString[0] = '\0';
+
+    if (m_fCurrentDownloadSpeed > 0.0)
+    {
+        long long remain_sec = (long long)(m_lRemainingSize / (m_fCurrentDownloadSpeed * 1024));
+        int h = 0;
+        int m = 0;
+        int s = 0;
+        while (remain_sec > 3600)
+        {
+            h++;
+            remain_sec -= 3600;
+        }
+        while (remain_sec > 60)
+        {
+            m++;
+            remain_sec -= 60;
+        }
+        s = remain_sec;
+
+        sprintf(timeString, "(~ %.2d:%.2d:%.2d)", h, m, s);
+    }
+
+    char szDownloadLimit[128];
+    if (m_fDownloadLimit > 0.0f)
+    {
+        sprintf(szDownloadLimit, "Limit %.0f KB/S", m_fDownloadLimit);
+    }
+    else
+    {
+        szDownloadLimit[0] = 0;
+    }
+
+    snprintf(tmp, MAX_SCREEN_WIDTH, " %d threads running, %.0f KB/s, %.2f MB remaining %s %s %s", m_iThreadCount, m_fCurrentDownloadSpeed, (float)(m_lRemainingSize / 1024.0 / 1024.0), timeString, m_bPause ? "Paused" : "", szDownloadLimit);
+	tmp[MAX_SCREEN_WIDTH - 1] = '\0';
+    PlotLine(tmp, iStatusRow, 0, NCURSES_COLORPAIR_STATUS);
+}
+
+void NCursesFrontend::PrintKeyInputBar()
+{
+    DownloadQueue* pDownloadQueue = LockQueue();
+    int iQueueSize = pDownloadQueue->size();
+    UnlockQueue();
+
+	int iInputBarRow = m_iScreenHeight - 1;
+	
+    switch (m_eInputMode)
+    {
+    case eNormal:
+        PlotLine("(Q)uit | (E)dit | (P)ause | (R)ate | n(Z)b | (W)indow", iInputBarRow, 0, NCURSES_COLORPAIR_KEYBAR);
+        break;
+    case eEditQueue:
+    {
+        char* szStatus = NULL;
+        if (m_iSelectedQueueEntry > 0 && iQueueSize > 1 && m_iSelectedQueueEntry == iQueueSize - 1)
+        {
+            szStatus = "(Q)uit | (E)xit | (P)ause | (D)elete | (U)p/(T)op";
+        }
+        else if (iQueueSize > 1 && m_iSelectedQueueEntry == 0)
+        {
+            szStatus = "(Q)uit | (E)xit | (P)ause | (D)elete | dow(N)/(B)ottom";
+        }
+        else if (iQueueSize > 1)
+        {
+            szStatus = "(Q)uit | (E)xit | (P)ause | (D)elete | (U)p/dow(N)/(T)op/(B)ottom";
+        }
+        else
+        {
+            szStatus = "(Q)uit";
+        }
+
+        PlotLine(szStatus, iInputBarRow, 0, NCURSES_COLORPAIR_KEYBAR);
+        break;
+    }
+    case eDownloadRate:
+        char szString[128];
+        snprintf(szString, 128, "Download rate: %i", m_iInputValue);
+		szString[128-1] = '\0';
+        PlotLine(szString, iInputBarRow, 0, NCURSES_COLORPAIR_KEYBAR);
+        // Print the cursor
+		PlotText(" ", iInputBarRow, 15 + m_iInputNumberIndex, NCURSES_COLORPAIR_CURSOR, true);
+        break;
+    }
+}
+
+void NCursesFrontend::PrintQueue()
+{
+	int iLineNr = m_iQueueWinTop;
+			
+    DownloadQueue* pDownloadQueue = LockQueue();
+	if (pDownloadQueue->empty())
+    {
+		char szBuffer[MAX_SCREEN_WIDTH];
+		snprintf(szBuffer, sizeof(szBuffer), "%s Files for downloading", m_bUseColor ? "" : "*** ");
+		szBuffer[MAX_SCREEN_WIDTH - 1] = '\0';
+	    PlotLine(szBuffer, iLineNr++, 0, NCURSES_COLORPAIR_INFOLINE);
+        PlotLine("Ready to receive nzb-job", iLineNr++, 0, NCURSES_COLORPAIR_TEXT);
+    }
+    else
+    {
+		iLineNr++;
+		long long lRemaining = 0;
+		long long lPaused = 0;
+		int iPausedFiles = 0;
+		int i = 0;
+        for (DownloadQueue::iterator it = pDownloadQueue->begin(); it != pDownloadQueue->end(); it++, i++)
+        {
+            FileInfo* pFileInfo = *it;
+
+			if (i >= m_iQueueScrollOffset && i < m_iQueueScrollOffset + m_iQueueWinHeight -1)
+			{
+				PrintFilename(pFileInfo, iLineNr++, i == m_iSelectedQueueEntry);
+			}
+
+			if (pFileInfo->GetPaused())
+			{
+				iPausedFiles++;
+				lPaused += pFileInfo->GetRemainingSize();
+			}
+			lRemaining += pFileInfo->GetRemainingSize();
+        }
+		
+		char szRemaining[20];
+		FormatFileSize(szRemaining, sizeof(szRemaining), lRemaining);
+
+		char szUnpaused[20];
+		FormatFileSize(szUnpaused, sizeof(szUnpaused), lRemaining - lPaused);
+		
+		char szBuffer[MAX_SCREEN_WIDTH];
+		snprintf(szBuffer, sizeof(szBuffer), " %sFiles for downloading - %i / %i files in queue - %s / %s", 
+			m_bUseColor ? "" : "*** ", pDownloadQueue->size(), pDownloadQueue->size() - iPausedFiles, szRemaining, szUnpaused);
+		szBuffer[MAX_SCREEN_WIDTH - 1] = '\0';
+		PlotLine(szBuffer, m_iQueueWinTop, 0, NCURSES_COLORPAIR_INFOLINE);
+    }
+    UnlockQueue();
+}
+
+void NCursesFrontend::PrintFilename(FileInfo * pFileInfo, int iRow, bool bSelected)
+{
+	int color = 0;
+	const char* Brace1 = "[";
+	const char* Brace2 = "]";
+	if (m_eInputMode == eEditQueue && bSelected)
+	{
+		color = NCURSES_COLORPAIR_TEXTHIGHL;
+		if (!m_bUseColor)
+		{
+			Brace1 = "<";
+			Brace2 = ">";
+		}
+	}
+	else
+	{
+		color = NCURSES_COLORPAIR_TEXT;
+	}
+
+	char szCompleted[20];
+	szCompleted[0] = '\0';
+	if (pFileInfo->GetRemainingSize() < pFileInfo->GetSize())
+	{
+		sprintf(szCompleted, ", %i%%", (int)(100 - pFileInfo->GetRemainingSize() * 100.0 / pFileInfo->GetSize()));
+	}
+
+	char szNZBNiceName[1024];
+	if (m_bShowNZBname)
+	{
+		pFileInfo->GetNiceNZBName(szNZBNiceName, 1023);
+		int len = strlen(szNZBNiceName);
+		szNZBNiceName[len] = PATH_SEPARATOR;
+		szNZBNiceName[len + 1] = '\0';
+	}
+	else
+	{
+		szNZBNiceName[0] = '\0';
+	}
+
+	char szBuffer[MAX_SCREEN_WIDTH];
+	snprintf(szBuffer, MAX_SCREEN_WIDTH, "%s%i%s %s%s (%.2f MB%s)%s", Brace1, pFileInfo->GetID(), Brace2, szNZBNiceName, pFileInfo->GetFilename(), pFileInfo->GetSize() / 1024.0 / 1024.0, szCompleted, pFileInfo->GetPaused() ? " (paused)" : "");
+	szBuffer[MAX_SCREEN_WIDTH - 1] = '\0';
+
+	PlotLine(szBuffer, iRow, 0, color);
+}
+
+void NCursesFrontend::FormatFileSize(char * szBuffer, int iBufLen, long long lFileSize)
+{
+	if (lFileSize > 1024 * 1024 * 1024)
+	{
+		snprintf(szBuffer, iBufLen, "%.2f GB", (float)lFileSize / 1024 / 1024 / 1024);
+	}
+	else if (lFileSize > 1024 * 1024)
+	{
+		snprintf(szBuffer, iBufLen, "%.2f MB", (float)lFileSize / 1024 / 1024);
+	}
+	else if (lFileSize > 1024)
+	{
+		snprintf(szBuffer, iBufLen, "%.2f KB", (float)lFileSize / 1024);
+	}
+	else 
+	{
+		snprintf(szBuffer, iBufLen, "%i", (int)lFileSize);
+	}
+	szBuffer[iBufLen - 1] = '\0';
+}
+
+void NCursesFrontend::SetCurrentQueueEntry(int iEntry)
+{
+    DownloadQueue* pDownloadQueue = LockQueue();
+    int iQueueSize = pDownloadQueue->size();
+    UnlockQueue();
+
+	if (iEntry < 0)
+	{
+		iEntry = 0;
+	}
+	else if (iEntry > iQueueSize - 1)
+	{
+		iEntry = iQueueSize - 1;
+	}
+
+	if (iEntry > m_iQueueScrollOffset + m_iQueueWinClientHeight ||
+	   iEntry < m_iQueueScrollOffset - m_iQueueWinClientHeight)
+	{
+		m_iQueueScrollOffset = iEntry - m_iQueueWinClientHeight / 2;
+	}
+	else if (iEntry < m_iQueueScrollOffset)
+	{
+		m_iQueueScrollOffset -= m_iQueueWinClientHeight;
+	}
+	else if (iEntry >= m_iQueueScrollOffset + m_iQueueWinClientHeight)
+	{
+		m_iQueueScrollOffset += m_iQueueWinClientHeight;
+	}
+	
+	if (m_iQueueScrollOffset > iQueueSize - m_iQueueWinClientHeight)
+	{
+		m_iQueueScrollOffset = iQueueSize - m_iQueueWinClientHeight;
+	}
+	if (m_iQueueScrollOffset < 0)
+	{
+		m_iQueueScrollOffset = 0;
+	}
+	
+	m_iSelectedQueueEntry = iEntry;
+}
+
+void NCursesFrontend::UpdateInput()
+{
+    int iKey;
+    while ((iKey = ReadConsoleKey()) != READKEY_EMPTY)
+    {
+		DownloadQueue* pDownloadQueue = LockQueue();
+		int iQueueSize = pDownloadQueue->size();
+		UnlockQueue();
+
+		// Normal or edit queue mode
+		if (m_eInputMode == eNormal || m_eInputMode == eEditQueue)
+		{
+			switch (iKey)
+			{
+				// Key 'q' for quit
+			case 'q':
+				ExitProc();
+				break;
+				// show/hide NZBFilename
+			case 'z':
+				m_bShowNZBname = !m_bShowNZBname;
+				break;
+				// swicth window sizes
+			case 'w':
+				if (m_QueueWindowPercentage == 0.5)
+				{
+					m_QueueWindowPercentage = 1;
+				}
+				else if (m_QueueWindowPercentage == 1 && m_eInputMode != eEditQueue)
+				{
+					m_QueueWindowPercentage = 0;
+				}
+				else 
+				{
+					m_QueueWindowPercentage = 0.5;
+				}
+				CalcWindowSizes();
+				SetCurrentQueueEntry(m_iSelectedQueueEntry);
+				break;
+			}
+		}
+		
+		// Normal mode
+		if (m_eInputMode == eNormal)
+		{
+			switch (iKey)
+			{
+				// Key 'p' for pause
+			case 'p':
+				if (!IsRemoteMode())
+				{
+					info(m_bPause ? "Unpausing download" : "Pausing download");
+				}
+				ServerPauseUnpause(!m_bPause);
+				break;
+			case '\'':
+				ServerDumpDebug();
+				break;
+			case 'e':
+			case 10: // return
+			case 13: // enter
+				if (iQueueSize > 0)
+				{
+					m_eInputMode = eEditQueue;
+					if (m_QueueWindowPercentage == 0)
+					{
+						m_QueueWindowPercentage = 0.5;
+					}
+				}
+				break;
+				// Download rate
+			case 'r':
+				m_eInputMode = eDownloadRate;
+				m_iInputNumberIndex = 0;
+				m_iInputValue = 0;
+				break;
+			}
+		}
+
+		// Edit Queue mode
+		else if (m_eInputMode == eEditQueue)
+		{
+			switch (iKey)
+			{
+				// Key 'p' for pause
+			case 'p':
+				ServerEditQueue(eaPauseUnpause, m_iSelectedQueueEntry);
+				break;
+				// Delete entry
+			case 'd':
+				if (ServerEditQueue(eaDelete, m_iSelectedQueueEntry))
+				{
+					if (iQueueSize == 0)
+					{
+						m_iSelectedQueueEntry = 0;
+						m_eInputMode = eNormal;
+					}
+					else
+					{
+						SetCurrentQueueEntry(m_iSelectedQueueEntry);
+					}
+				}
+				break;
+			case 'u':
+				if (ServerEditQueue(eaMoveUp, m_iSelectedQueueEntry))
+				{
+					SetCurrentQueueEntry(m_iSelectedQueueEntry - 1);
+				}
+				break;
+			case 'n':
+				if (ServerEditQueue(eaMoveDown, m_iSelectedQueueEntry))
+				{
+					SetCurrentQueueEntry(m_iSelectedQueueEntry + 1);
+				}
+				break;
+			case 't':
+				if (ServerEditQueue(eaMoveTop, m_iSelectedQueueEntry))
+				{
+					SetCurrentQueueEntry(0);
+				}
+				break;
+			case 'b':
+				if (ServerEditQueue(eaMoveBottom, m_iSelectedQueueEntry))
+				{
+					SetCurrentQueueEntry(iQueueSize > 0 ? iQueueSize - 1 : 0);
+				}
+				break;
+			case 'e':
+			case 10: // return
+			case 13: // enter
+				m_eInputMode = eNormal;
+				break;
+			case KEY_DOWN:
+				if (m_iSelectedQueueEntry < iQueueSize - 1)
+				{
+					SetCurrentQueueEntry(m_iSelectedQueueEntry + 1);
+				}
+				break;
+			case KEY_UP:
+				if (m_iSelectedQueueEntry > 0)
+				{
+					SetCurrentQueueEntry(m_iSelectedQueueEntry - 1);
+				}
+				break;
+			case KEY_PPAGE:
+				if (m_iSelectedQueueEntry > 0)
+				{
+					if (m_iSelectedQueueEntry == m_iQueueScrollOffset)
+					{
+						m_iQueueScrollOffset -= m_iQueueWinClientHeight;
+						SetCurrentQueueEntry(m_iSelectedQueueEntry - m_iQueueWinClientHeight);
+					}
+					else
+					{
+						SetCurrentQueueEntry(m_iQueueScrollOffset);
+					}
+				}
+				break;
+			case KEY_NPAGE:
+				if (m_iSelectedQueueEntry < iQueueSize - 1)
+				{
+					if (m_iSelectedQueueEntry == m_iQueueScrollOffset + m_iQueueWinClientHeight - 1)
+					{
+						m_iQueueScrollOffset += m_iQueueWinClientHeight;
+						SetCurrentQueueEntry(m_iSelectedQueueEntry + m_iQueueWinClientHeight);
+					}
+					else
+					{
+						SetCurrentQueueEntry(m_iQueueScrollOffset + m_iQueueWinClientHeight - 1);
+					}
+				}
+				break;
+			case KEY_HOME:
+				SetCurrentQueueEntry(0);
+				break;
+			case KEY_END:
+				SetCurrentQueueEntry(iQueueSize > 0 ? iQueueSize - 1 : 0);
+				break;
+			}
+		}
+
+		// Edit download rate input mode
+		else if (m_eInputMode == eDownloadRate)
+		{
+			// Numbers
+			if (m_iInputNumberIndex < 5 && iKey >= '0' && iKey <= '9')
+			{
+				m_iInputValue = (m_iInputValue * 10) + (iKey - '0');
+				m_iInputNumberIndex++;
+			}
+			// Enter
+			else if (iKey == 10 || iKey == 13)
+			{
+				ServerSetDownloadRate((float)m_iInputValue);
+				m_eInputMode = eNormal;
+				return;
+			}
+			// Escape
+			else if (iKey == 27)
+			{
+				m_eInputMode = eNormal;
+				return;
+			}
+			// Backspace
+			else if (m_iInputNumberIndex > 0 && iKey == KEY_BACKSPACE)
+			{
+				int iRemain = m_iInputValue % 10;
+
+				m_iInputValue = (m_iInputValue - iRemain) / 10;
+				m_iInputNumberIndex--;
+			}
+		}
+	}
+}
+
+int NCursesFrontend::ReadConsoleKey()
+{
+#ifdef WIN32
+	HANDLE hConsole = GetStdHandle(STD_INPUT_HANDLE);
+	DWORD NumberOfEvents;
+	BOOL bOK = GetNumberOfConsoleInputEvents(hConsole, &NumberOfEvents);
+	if (bOK && NumberOfEvents > 0)
+	{
+		while (NumberOfEvents--)
+		{
+			INPUT_RECORD InputRecord;
+			DWORD NumberOfEventsRead;
+			if (ReadConsoleInput(hConsole, &InputRecord, 1, &NumberOfEventsRead) && 
+				NumberOfEventsRead > 0 &&
+				InputRecord.EventType == KEY_EVENT &&
+				InputRecord.Event.KeyEvent.bKeyDown)
+			{
+				return tolower(InputRecord.Event.KeyEvent.wVirtualKeyCode);
+			}
+		}
+	}
+	return READKEY_EMPTY;
+#else
+	return getch();
+#endif
+}
+
+#endif

NCursesFrontend.h

@@ -1,8 +1,8 @@
 /*
- *  This file is part of nzbget
+ *  This file if part of nzbget
  *
- *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
- *  Copyright (C) 2007-2014 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -16,7 +16,7 @@
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  *
  * $Revision$
  * $Date$
@@ -30,7 +30,6 @@
 #ifndef DISABLE_CURSES
 
 #include <vector>
-#include <time.h>
 
 #include "Frontend.h"
 #include "Log.h"
@@ -47,30 +46,22 @@ private:
 	    eDownloadRate
 	};
 
-	bool				m_bUseColor;
-	int					m_iDataUpdatePos;
-    bool				m_bUpdateNextTime;
-	int					m_iScreenHeight;
-	int					m_iScreenWidth;
-	int					m_iQueueWinTop;
-	int					m_iQueueWinHeight;
-	int					m_iQueueWinClientHeight;
-	int					m_iMessagesWinTop;
-	int					m_iMessagesWinHeight;
-	int					m_iMessagesWinClientHeight;
-	int					m_iSelectedQueueEntry;
-	int					m_iLastEditEntry;
-	bool				m_bLastPausePars;
-	int					m_iQueueScrollOffset;
-	char*				m_szHint;
-	time_t				m_tStartHint;
-	int					m_iColWidthFiles;
-	int					m_iColWidthTotal;
-	int					m_iColWidthLeft;
+	bool			m_bUseColor;
+	int				m_iSkipUpdateData;
+	int				m_iScreenHeight;
+	int				m_iScreenWidth;
+	int				m_iQueueWinTop;
+	int				m_iQueueWinHeight;
+	int				m_iQueueWinClientHeight;
+	int				m_iMessagesWinTop;
+	int				m_iMessagesWinHeight;
+	int				m_iMessagesWinClientHeight;
+	int				m_iSelectedQueueEntry;
+	int				m_iQueueScrollOffset;
 
-	// Inputting numbers
-	int					m_iInputNumberIndex;
-	int					m_iInputValue;
+	// Inputting numbres
+	int				m_iInputNumberIndex;
+	int				m_iInputValue;
 
 #ifdef WIN32
 	CHAR_INFO*			m_pScreenBuffer;
@@ -78,14 +69,12 @@ private:
 	int					m_iScreenBufferSize;
 	std::vector<WORD>	m_ColorAttr;
 #else
-	void* 				m_pWindow;  //  WINDOW*
+	void* 			m_pWindow;  //  WINDOW*
 #endif
 
-	EInputMode			m_eInputMode;
-	bool				m_bShowNZBname;
-	bool				m_bShowTimestamp;
-	bool				m_bGroupFiles;
-	float				m_QueueWindowPercentage;
+	EInputMode		m_eInputMode;
+	bool			m_bShowNZBname;
+	float			m_QueueWindowPercentage;
 
 #ifdef WIN32
 	void			init_pair(int iColorNumber, WORD wForeColor, WORD wBackColor);
@@ -94,25 +83,17 @@ private:
 	void			PlotText(const char * szString, int iRow, int iPos, int iColorPair, bool bBlink);
 	void			PrintMessages();
 	void			PrintQueue();
-	void			PrintFileQueue();
 	void			PrintFilename(FileInfo* pFileInfo, int iRow, bool bSelected);
-	void			PrintGroupQueue();
-	void			ResetColWidths();
-	void			PrintGroupname(NZBInfo* pNZBInfo, int iRow, bool bSelected, bool bCalcColWidth);
-	void			PrintTopHeader(char* szHeader, int iLineNr, bool bUpTime);
 	int				PrintMessage(Message* Msg, int iRow, int iMaxLines);
 	void			PrintKeyInputBar();
 	void 			PrintStatus();
-	void			UpdateInput(int initialKey);
-	void			Update(int iKey);
+	void			UpdateInput();
+	void			Update();
 	void			SetCurrentQueueEntry(int iEntry);
 	void			CalcWindowSizes();
+	void			FormatFileSize(char* szBuffer, int iBufLen, long long lFileSize);
 	void			RefreshScreen();
 	int				ReadConsoleKey();
-	int				CalcQueueSize();
-	void			NeedUpdateData();
-	bool			EditQueue(DownloadQueue::EEditAction eAction, int iOffset);
-	void			SetHint(const char* szHint);
 
 protected:
 	virtual void 	Run();

NNTPConnection.cpp

@@ -0,0 +1,274 @@
+/*
+ *  This file if part of nzbget
+ *
+ *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef WIN32
+#include "win32.h"
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "nzbget.h"
+#include "Log.h"
+#include "NNTPConnection.h"
+#include "Connection.h"
+#include "NewsServer.h"
+
+NNTPConnection::NNTPConnection(NewsServer* server) : Connection(server)
+{
+	m_UnavailableGroups.clear();
+	m_szActiveGroup = NULL;
+	m_szLineBuf = (char*)malloc(LineBufSize);
+}
+
+NNTPConnection::~NNTPConnection()
+{
+	for (unsigned int i = 0; i < m_UnavailableGroups.size(); i++)
+	{
+		free(m_UnavailableGroups[i]);
+		m_UnavailableGroups[i] = NULL;
+	}
+	m_UnavailableGroups.clear();
+
+	if (m_szActiveGroup)
+	{
+		free(m_szActiveGroup);
+	}
+	if (m_szLineBuf)
+	{
+		free(m_szLineBuf);
+	}
+}
+
+char* NNTPConnection::Request(char* req)
+{
+	if (!req)
+	{
+		return NULL;
+	}
+
+	WriteLine(req);
+
+	char* answer = ReadLine(m_szLineBuf, LineBufSize);
+
+	if (!answer)
+	{
+		return NULL;
+	}
+
+	if (!strncmp(answer, "480", 3))
+	{
+		debug("%s requested authorization", m_pNetAddress->GetHost());
+
+		//authentication required!
+		if (Authenticate() < 0)
+		{
+			return NULL;
+		}
+
+		//try again
+		WriteLine(req);
+		answer = ReadLine(m_szLineBuf, LineBufSize);
+		return answer;
+	}
+
+	return answer;
+}
+
+int NNTPConnection::Authenticate()
+{
+	if ((!((NewsServer*)m_pNetAddress)->GetUser()) ||
+	        (!((NewsServer*)m_pNetAddress)->GetPassword()))
+	{
+		return -1;
+	}
+
+	return AuthInfoUser();
+}
+
+int NNTPConnection::AuthInfoUser(int iRecur)
+{
+	if (iRecur > 10)
+	{
+		return -1;
+	}
+
+	char tmp[1024];
+
+	snprintf(tmp, 1024, "AUTHINFO USER %s\r\n", ((NewsServer*)m_pNetAddress)->GetUser());
+	tmp[1024-1] = '\0';
+
+	WriteLine(tmp);
+
+	char* answer = ReadLine(m_szLineBuf, LineBufSize);
+
+	if (!answer)
+	{
+		return -1;
+	}
+
+	if (!strncmp(answer, "281", 3))
+	{
+		debug("authorization for %s successful", m_pNetAddress->GetHost());
+		return 0;
+	}
+	else if (!strncmp(answer, "381", 3))
+	{
+		return AuthInfoPass(++iRecur);
+	}
+	else if (!strncmp(answer, "480", 3))
+	{
+		return AuthInfoUser();
+	}
+
+	return -1;
+}
+
+int NNTPConnection::AuthInfoPass(int iRecur)
+{
+	if (iRecur > 10)
+	{
+		return -1;
+	}
+
+	char tmp[1024];
+
+	snprintf(tmp, 1024, "AUTHINFO PASS %s\r\n", ((NewsServer*)m_pNetAddress)->GetPassword());
+	tmp[1024-1] = '\0';
+
+	WriteLine(tmp);
+
+	char* szAnswer = ReadLine(m_szLineBuf, LineBufSize);
+	if (!szAnswer)
+	{
+		ReportError("authorization for %s failed: Connection closed by remote host.", m_pNetAddress->GetHost(), 0);
+		return -1;
+	}
+	else if (!strncmp(szAnswer, "2", 1))
+	{
+		debug("authorization for %s successful", m_pNetAddress->GetHost());
+		return 0;
+	}
+	else if (!strncmp(szAnswer, "381", 3))
+	{
+		return AuthInfoPass(++iRecur);
+	}
+
+	error("authorization for %s failed (Answer: %s)", m_pNetAddress->GetHost(), szAnswer);
+	return -1;
+}
+
+int NNTPConnection::DoConnect()
+{
+	debug("Opening connection to %s", GetServer()->GetHost());
+	int res = Connection::DoConnect();
+	if (res < 0)
+		return res;
+	char* answer = DoReadLine(m_szLineBuf, LineBufSize);
+
+	if (!answer)
+	{
+		ReportError("Connection to %s failed: Connection closed by remote host.", m_pNetAddress->GetHost(), 0);
+		return -1;
+	}
+
+
+	if (strncmp(answer, "2", 1))
+	{
+		error("Connection to %s failed. Answer: ", m_pNetAddress->GetHost(), answer);
+		return -1;
+	}
+
+	debug("Connection to %s established", GetServer()->GetHost());
+	return 0;
+}
+
+int NNTPConnection::DoDisconnect()
+{
+	if (m_eStatus == csConnected)
+	{
+		Request("quit\r\n");
+	}
+	return Connection::DoDisconnect();
+}
+
+
+int NNTPConnection::JoinGroup(char* grp)
+{
+	if (!grp)
+	{
+		debug("joinGroup called with NULL-pointer!!");
+		return -1;
+	}
+
+	if ((m_szActiveGroup) && (!strcmp(m_szActiveGroup, grp)))
+		return 0;
+
+	for (unsigned int i = 0; i < m_UnavailableGroups.size(); i++)
+	{
+		if (!strcmp(grp, m_UnavailableGroups[i]))
+		{
+			debug("Group %s unavailable on %s.", grp, this->GetServer()->GetHost());
+			return -1;
+		}
+	}
+
+	char tmp[1024];
+	snprintf(tmp, 1024, "GROUP %s\r\n", grp);
+	tmp[1024-1] = '\0';
+
+	char* answer = Request(tmp);
+
+	if ((answer) && (!strncmp(answer, "2", 1)))
+	{
+		debug("Changed group to %s on %s", grp, GetServer()->GetHost());
+
+		if (m_szActiveGroup)
+			free(m_szActiveGroup);
+
+		m_szActiveGroup = strdup(grp);
+		return 0;
+	}
+
+	if (!answer)
+	{
+		warn("Error changing group on %s: Connection closed by remote host.",
+		     GetServer()->GetHost());
+		return -1;
+	}
+	else
+	{
+		warn("Error changing group on %s to %s: Answer was \"%s\".",
+		     GetServer()->GetHost(), grp, answer);
+		m_UnavailableGroups.push_back(strdup(grp));
+	}
+
+	return -1;
+}

NNTPConnection.h

@@ -0,0 +1,60 @@
+/*
+ *  This file if part of nzbget
+ *
+ *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifndef NNTPCONNECTION_H
+#define NNTPCONNECTION_H
+
+#include <stdio.h>
+#include <vector>
+
+#include "NewsServer.h"
+#include "Connection.h"
+
+class NNTPConnection : public Connection
+{
+private:
+	std::vector <char*> 	m_UnavailableGroups;
+	char* 					m_szActiveGroup;
+	static const int		LineBufSize = 1024*10;
+	char*					m_szLineBuf;
+
+	virtual int 			DoConnect();
+	virtual int 			DoDisconnect();
+
+public:
+							NNTPConnection(NewsServer* server);
+							~NNTPConnection();
+	NewsServer*				GetNewsServer() { return(NewsServer*)m_pNetAddress; }
+	char* 					Request(char* req);
+	int 					Authenticate();
+	int 					AuthInfoUser(int iRecur = 0);
+	int 					AuthInfoPass(int iRecur = 0);
+	int 					JoinGroup(char* grp);
+};
+
+
+#endif
+

NTService.cpp

@@ -1,7 +1,7 @@
 /*
- *  This file is part of nzbget
+ *  This file if part of nzbget
  *
- *  Copyright (C) 2007  Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -15,7 +15,7 @@
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  *
  * $Revision$
  * $Date$
@@ -38,152 +38,148 @@
 extern void ExitProc();
 RunProc Run = NULL;
 
-char* strServiceName = "NZBGet";
-SERVICE_STATUS_HANDLE nServiceStatusHandle; 
-DWORD nServiceCurrentStatus;
+char* strServiceName = "NZBGet";
+SERVICE_STATUS_HANDLE nServiceStatusHandle; 
+DWORD nServiceCurrentStatus;
 
-BOOL UpdateServiceStatus(DWORD dwCurrentState, DWORD dwWaitHint)
-{
-	BOOL success;
-	SERVICE_STATUS nServiceStatus;
-	nServiceStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
-	nServiceStatus.dwCurrentState = dwCurrentState;
-	if (dwCurrentState == SERVICE_START_PENDING)
-	{
-		nServiceStatus.dwControlsAccepted = 0;
-	}
-	else
-	{
-		nServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN;
-	}
-	nServiceStatus.dwWin32ExitCode = NO_ERROR;
-	nServiceStatus.dwServiceSpecificExitCode = 0;
-	nServiceStatus.dwCheckPoint = 0;
-	nServiceStatus.dwWaitHint = dwWaitHint;
+BOOL UpdateServiceStatus(DWORD dwCurrentState, DWORD dwWaitHint)
+{
+	BOOL success;
+	SERVICE_STATUS nServiceStatus;
+	nServiceStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
+	nServiceStatus.dwCurrentState = dwCurrentState;
+	if (dwCurrentState == SERVICE_START_PENDING)
+	{
+		nServiceStatus.dwControlsAccepted = 0;
+	}
+	else
+	{
+		nServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN;
+	}
+	nServiceStatus.dwWin32ExitCode = NO_ERROR;
+	nServiceStatus.dwServiceSpecificExitCode = 0;
+	nServiceStatus.dwCheckPoint = 0;
+	nServiceStatus.dwWaitHint = dwWaitHint;
+
+	success = SetServiceStatus(nServiceStatusHandle, &nServiceStatus);
+
+	return success;
+}
 
-	success = SetServiceStatus(nServiceStatusHandle, &nServiceStatus);
-
-	return success;
+void ServiceCtrlHandler(DWORD nControlCode)
+{
+	switch(nControlCode)
+	{	
+	case SERVICE_CONTROL_SHUTDOWN:
+	case SERVICE_CONTROL_STOP:
+		nServiceCurrentStatus = SERVICE_STOP_PENDING;
+		UpdateServiceStatus(SERVICE_STOP_PENDING, 10000);
+		ExitProc();
+		return;
+	default:
+		break;
+	}
+	UpdateServiceStatus(nServiceCurrentStatus, 0);
 }
 
-void ServiceCtrlHandler(DWORD nControlCode)
-{
-	switch(nControlCode)
-	{	
-	case SERVICE_CONTROL_SHUTDOWN:
-	case SERVICE_CONTROL_STOP:
-		nServiceCurrentStatus = SERVICE_STOP_PENDING;
-		UpdateServiceStatus(SERVICE_STOP_PENDING, 10000);
-		ExitProc();
-		return;
-	default:
-		break;
-	}
-	UpdateServiceStatus(nServiceCurrentStatus, 0);
-}
-
-void ServiceMain(DWORD argc, LPTSTR *argv)
-{
-	BOOL success;
-	nServiceStatusHandle = RegisterServiceCtrlHandler(strServiceName,
-		(LPHANDLER_FUNCTION)ServiceCtrlHandler);
-	if(!nServiceStatusHandle)
-	{
-		return;
-	}
-	success = UpdateServiceStatus(SERVICE_START_PENDING, 10000);
-	if(!success)
-	{
-		return;
-	}
-	nServiceCurrentStatus=SERVICE_RUNNING;
-	success=UpdateServiceStatus(SERVICE_RUNNING, 0);
-	if(!success)
-	{
-		return;
-	}
-	
-	Run();
-
-	UpdateServiceStatus(SERVICE_STOPPED, 0);
-}
+void ServiceMain(DWORD argc, LPTSTR *argv)
+{
+	BOOL success;
+	nServiceStatusHandle = RegisterServiceCtrlHandler(strServiceName,
+		(LPHANDLER_FUNCTION)ServiceCtrlHandler);
+	if(!nServiceStatusHandle)
+	{
+		return;
+	}
+	success = UpdateServiceStatus(SERVICE_START_PENDING, 10000);
+	if(!success)
+	{
+		return;
+	}
+	nServiceCurrentStatus=SERVICE_RUNNING;
+	success=UpdateServiceStatus(SERVICE_RUNNING, 0);
+	if(!success)
+	{
+		return;
+	}
+	
+	Run();
+
+	UpdateServiceStatus(SERVICE_STOPPED, 0);
+}
 
 void StartService(RunProc RunProcPtr)
 {
 	Run = RunProcPtr;
 
-	SERVICE_TABLE_ENTRY servicetable[]=
-	{
-		{strServiceName,(LPSERVICE_MAIN_FUNCTION)ServiceMain},
-		{NULL,NULL}
-	};
-	BOOL success = StartServiceCtrlDispatcher(servicetable);
-	if(!success)
-	{
-		error("Could not start service");
-	}
+	SERVICE_TABLE_ENTRY servicetable[]=
+	{
+		{strServiceName,(LPSERVICE_MAIN_FUNCTION)ServiceMain},
+		{NULL,NULL}
+	};
+	BOOL success = StartServiceCtrlDispatcher(servicetable);
+	if(!success)
+	{
+		error("Could not start service");
+	}
 }
 
 void InstallService(int argc, char *argv[])
 {
-	SC_HANDLE scm = OpenSCManager(0,0,SC_MANAGER_CREATE_SERVICE);
-	if(!scm)
-	{
-		printf("Could not install service\n");
-		return;
-	}
-	
-	char szExeName[1024];
-	GetModuleFileName(NULL, szExeName, 1024);
-	szExeName[1024-1] = '\0';
-
-	char szCmdLine[1024];
-	snprintf(szCmdLine, 1024, "%s -D", szExeName);
-	szCmdLine[1024-1] = '\0';
-
-	SC_HANDLE hService = CreateService(scm, strServiceName,
-		strServiceName,
-		SERVICE_ALL_ACCESS,SERVICE_WIN32_OWN_PROCESS,SERVICE_DEMAND_START,
-		SERVICE_ERROR_NORMAL,
-		szCmdLine,
-		0,0,0,0,0);
-	if(!hService)
-	{
-		CloseServiceHandle(scm);
-		printf("Could not install service\n");
-		return;
-	}
-	CloseServiceHandle(hService);
-	CloseServiceHandle(scm);
-	printf("Service \"%s\" sucessfully installed\n", strServiceName);
+	SC_HANDLE scm = OpenSCManager(0,0,SC_MANAGER_CREATE_SERVICE);
+	if(!scm)
+	{
+		printf("Could not install service\n");
+		return;
+	}
+	
+	char szCmdLine[1024];
+	snprintf(szCmdLine, 1024, "%s -D", argv[0]);
+	szCmdLine[1024-1] = '\0';
+
+	SC_HANDLE hService = CreateService(scm, strServiceName,
+		strServiceName,
+		SERVICE_ALL_ACCESS,SERVICE_WIN32_OWN_PROCESS,SERVICE_DEMAND_START,
+		SERVICE_ERROR_NORMAL,
+		szCmdLine,
+		0,0,0,0,0);
+	if(!hService)
+	{
+		CloseServiceHandle(scm);
+		printf("Could not install service\n");
+		return;
+	}
+	CloseServiceHandle(hService);
+	CloseServiceHandle(scm);
+	printf("Service \"%s\" sucessfully installed\n", strServiceName);
 }
 
 void UnInstallService()
 {
-	BOOL success;
-	SC_HANDLE scm = OpenSCManager(0,0,SC_MANAGER_CONNECT);
-	if(!scm)
-	{
-		printf("Could not uninstall service\n");
-		return;
-	}
-	
-	SC_HANDLE hService = OpenService(scm, strServiceName, STANDARD_RIGHTS_REQUIRED);
-	if(!hService)
-	{
-		CloseServiceHandle(scm);
-		printf("Could not uninstall service\n");
-		return;
-	}
-
-	success = DeleteService(hService);
-	if(!success)
-	{
-		error("Could not uninstall service");
-	}
-	CloseServiceHandle(hService);
-	CloseServiceHandle(scm);
-	printf("Service \"%s\" sucessfully uninstalled\n", strServiceName);
+	BOOL success;
+	SC_HANDLE scm = OpenSCManager(0,0,SC_MANAGER_CONNECT);
+	if(!scm)
+	{
+		printf("Could not uninstall service\n");
+		return;
+	}
+	
+	SC_HANDLE hService = OpenService(scm, strServiceName, STANDARD_RIGHTS_REQUIRED);
+	if(!hService)
+	{
+		CloseServiceHandle(scm);
+		printf("Could not uninstall service\n");
+		return;
+	}
+
+	success = DeleteService(hService);
+	if(!success)
+	{
+		error("Could not uninstall service");
+	}
+	CloseServiceHandle(hService);
+	CloseServiceHandle(scm);
+	printf("Service \"%s\" sucessfully uninstalled\n", strServiceName);
 }
 
 void InstallUninstallServiceCheck(int argc, char *argv[])

NTService.h

@@ -1,7 +1,7 @@
 /*
- *  This file is part of nzbget
+ *  This file if part of nzbget
  *
- *  Copyright (C) 2007  Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -15,7 +15,7 @@
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  *
  * $Revision$
  * $Date$

NZBFile.cpp

@@ -0,0 +1,425 @@
+/*
+ *  This file if part of nzbget
+ *
+ *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef WIN32
+#include "win32.h"
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#include <algorithm>
+#ifdef WIN32
+#include <comutil.h>
+#import "MSXML.dll" named_guids 
+using namespace MSXML;
+#else
+#include <libxml/parser.h>
+#include <libxml/xmlreader.h>
+#endif
+
+#include "nzbget.h"
+#include "NZBFile.h"
+#include "Log.h"
+#include "DownloadInfo.h"
+
+bool ArticleGreater(ArticleInfo* elem1, ArticleInfo* elem2)
+{
+	return elem1->GetPartNumber() > elem2->GetPartNumber();
+}
+
+NZBFile::NZBFile(const char* szFileName)
+{
+    debug("Creating NZBFile");
+
+    m_szFileName = strdup(szFileName);
+
+    m_FileInfos.clear();
+}
+
+NZBFile::~NZBFile()
+{
+    debug("Destroying NZBFile");
+
+    // Cleanup
+    if (m_szFileName)
+    {
+        free(m_szFileName);
+    }
+
+    for (std::vector<FileInfo*>::iterator it = m_FileInfos.begin(); it != m_FileInfos.end(); it++)
+    {
+        delete *it;
+    }
+    m_FileInfos.clear();
+}
+
+void NZBFile::LogDebugInfo()
+{
+    debug(" NZBFile %s", m_szFileName);
+}
+
+void NZBFile::DetachFileInfos()
+{
+    m_FileInfos.clear();
+}
+
+bool NZBFile::LoadFileIntoBuffer(const char* szFileName, char** pBuffer, int* pBufferLength)
+{
+    FILE* pFile = fopen(szFileName, "r");
+    if (!pFile)
+    {
+        return false;
+    }
+
+    // obtain file size.
+    fseek(pFile , 0 , SEEK_END);
+    int iSize  = ftell(pFile);
+    rewind(pFile);
+
+    // allocate memory to contain the whole file.
+    *pBuffer = (char*) malloc(iSize + 1);
+    if (!*pBuffer)
+    {
+        return false;
+    }
+
+    // copy the file into the buffer.
+    fread(*pBuffer, 1, iSize, pFile);
+
+    fclose(pFile);
+
+    (*pBuffer)[iSize] = 0;
+
+    *pBufferLength = iSize + 1;
+
+    return true;
+}
+
+NZBFile* NZBFile::CreateFromBuffer(const char* szFileName, const char* szBuffer, int iSize)
+{
+	return Create(szFileName, szBuffer, iSize, true);
+}
+
+NZBFile* NZBFile::CreateFromFile(const char* szFileName)
+{
+	//return Create(szFileName, NULL, 0, false);
+
+//	/*
+	//TEST
+	int iBufferLength	= 0;
+	char* szBuffer		= NULL;
+
+	if (!NZBFile::LoadFileIntoBuffer(szFileName, &szBuffer, &iBufferLength))
+	{
+		return false;
+	}
+	return Create(szFileName, szBuffer, iBufferLength, true);
+//	*/
+}
+
+void NZBFile::AddArticle(FileInfo* pFileInfo, ArticleInfo* pArticleInfo)
+{
+	// make Article-List big enough
+	while ((int)pFileInfo->GetArticles()->size() < pArticleInfo->GetPartNumber())
+		pFileInfo->GetArticles()->push_back(NULL);
+
+	(*pFileInfo->GetArticles())[pArticleInfo->GetPartNumber() - 1] = pArticleInfo;
+}
+
+void NZBFile::DeleteEmptyArticles(FileInfo* pFileInfo)
+{
+	FileInfo::Articles* pArticles = pFileInfo->GetArticles();
+	int i = 0;
+	for (FileInfo::Articles::iterator it = pArticles->begin(); it != pArticles->end();)
+	{
+		if (*it == NULL)
+		{
+			pArticles->erase(it);
+			it = pArticles->begin() + i;
+		}
+		else
+		{
+			it++;
+			i++;
+		}
+	}
+}
+
+#ifdef WIN32
+NZBFile* NZBFile::Create(const char* szFileName, const char* szBuffer, int iSize, bool bFromBuffer)
+{
+    CoInitialize(NULL);
+
+	HRESULT hr;
+
+	MSXML::IXMLDOMDocumentPtr doc;
+	hr = doc.CreateInstance(MSXML::CLSID_DOMDocument);
+    if (FAILED(hr))
+    {
+        return NULL;
+    }
+
+    // Load the XML document file...
+	doc->put_resolveExternals(VARIANT_FALSE);
+	doc->put_validateOnParse(VARIANT_FALSE);
+	doc->put_async(VARIANT_FALSE);
+	VARIANT_BOOL success;
+	if (bFromBuffer)
+	{
+		success = doc->loadXML(szBuffer);
+	}
+	else
+	{
+		_variant_t v(szFileName);
+		success = doc->load(v);
+	} 
+	if (success == VARIANT_FALSE)
+	{
+		_bstr_t r(doc->GetparseError()->reason);
+		const char* szErrMsg = r;
+		error("Error parsing nzb-file: %s", szErrMsg);
+		return NULL;
+	}
+
+    NZBFile* pFile = new NZBFile(szFileName);
+    if (!pFile->parseNZB(doc))
+	{
+		delete pFile;
+		pFile = NULL;
+	}
+
+    return pFile;
+}
+
+bool NZBFile::parseNZB(IUnknown* nzb)
+{
+	MSXML::IXMLDOMDocumentPtr doc = nzb;
+	MSXML::IXMLDOMNodePtr root = doc->documentElement;
+
+	MSXML::IXMLDOMNodeListPtr fileList = root->selectNodes("/nzb/file");
+	for (int i = 0; i < fileList->Getlength(); i++)
+	{
+		MSXML::IXMLDOMNodePtr node = fileList->Getitem(i);
+		MSXML::IXMLDOMNodePtr attribute = node->Getattributes()->getNamedItem("subject");
+		if (!attribute) return false;
+		_bstr_t subject(attribute->Gettext());
+        FileInfo* pFileInfo = new FileInfo();
+        pFileInfo->SetNZBFilename(m_szFileName);
+		pFileInfo->SetSubject(subject);
+		pFileInfo->ParseSubject();
+
+		MSXML::IXMLDOMNodeListPtr groupList = node->selectNodes("groups/group");
+		for (int g = 0; g < groupList->Getlength(); g++)
+		{
+			MSXML::IXMLDOMNodePtr node = groupList->Getitem(g);
+			_bstr_t group = node->Gettext();
+			pFileInfo->GetGroups()->push_back(strdup((const char*)group));
+		}
+
+		MSXML::IXMLDOMNodeListPtr segmentList = node->selectNodes("segments/segment");
+		for (int g = 0; g < segmentList->Getlength(); g++)
+		{
+			MSXML::IXMLDOMNodePtr node = segmentList->Getitem(g);
+			_bstr_t id = node->Gettext();
+            char szId[2048];
+            snprintf(szId, 2048, "<%s>", (const char*)id);
+
+			MSXML::IXMLDOMNodePtr attribute = node->Getattributes()->getNamedItem("number");
+			if (!attribute) return false;
+			_bstr_t number(attribute->Gettext());
+
+			attribute = node->Getattributes()->getNamedItem("bytes");
+			if (!attribute) return false;
+			_bstr_t bytes(attribute->Gettext());
+
+			int partNumber = atoi(number);
+			int lsize = atoi(bytes);
+
+			ArticleInfo* pArticle = new ArticleInfo();
+			pArticle->SetPartNumber(partNumber);
+			pArticle->SetMessageID(szId);
+			pArticle->SetSize(lsize);
+			AddArticle(pFileInfo, pArticle);
+
+            if (lsize > 0)
+            {
+                pFileInfo->SetSize(pFileInfo->GetSize() + lsize);
+            }
+		}
+
+		DeleteEmptyArticles(pFileInfo);
+		m_FileInfos.push_back(pFileInfo);
+	}
+	return true;
+}
+
+#else
+
+NZBFile* NZBFile::Create(const char* szFileName, const char* szBuffer, int iSize, bool bFromBuffer)
+{
+    xmlTextReaderPtr doc;
+	if (bFromBuffer)
+	{
+		doc = xmlReaderForMemory(szBuffer,iSize-1, "", NULL, 0);
+	}
+	else
+	{
+		doc = xmlReaderForFile(szFileName, NULL, 0);
+	}
+    if (!doc)
+    {
+        return NULL;
+    }
+
+    NZBFile* pFile = new NZBFile(szFileName);
+    if (!pFile->parseNZB(doc))
+	{
+		delete pFile;
+		pFile = NULL;
+	}
+
+    xmlFreeTextReader(doc);
+
+    return pFile;
+}
+
+bool NZBFile::parseNZB(void* nzb)
+{
+	FileInfo* pFileInfo = NULL;
+	xmlTextReaderPtr node = (xmlTextReaderPtr)nzb;
+    // walk through whole doc and search for segments-tags
+    int ret = xmlTextReaderRead(node);
+    while (ret == 1)
+    {
+        if (node)
+        {
+            xmlChar *name, *value;
+
+            name = xmlTextReaderName(node);
+            if (name == NULL)
+            {
+                name = xmlStrdup(BAD_CAST "--");
+            }
+            value = xmlTextReaderValue(node);
+
+            if (xmlTextReaderNodeType(node) == 1)
+            {
+                if (!strcmp("file", (char*)name))
+                {
+                    pFileInfo = new FileInfo();
+                    pFileInfo->SetNZBFilename(m_szFileName);
+
+                    while (xmlTextReaderMoveToNextAttribute(node))
+                    {
+						xmlFree(name);
+            			name = xmlTextReaderName(node);
+                        if (!strcmp("subject",(char*)name))
+                        {
+							xmlFree(value);
+							value = xmlTextReaderValue(node);
+                            pFileInfo->SetSubject((char*)value);
+                            pFileInfo->ParseSubject();
+                        }
+                    }
+                }
+                else if (!strcmp("segment",(char*)name))
+                {
+                    long long lsize = -1;
+                    int partNumber = -1;
+
+                    while (xmlTextReaderMoveToNextAttribute(node))
+                    {
+						xmlFree(name);
+						name = xmlTextReaderName(node);
+						xmlFree(value);
+						value = xmlTextReaderValue(node);
+                        if (!strcmp("bytes",(char*)name))
+                        {
+                            lsize = atol((char*)value);
+                        }
+                        if (!strcmp("number",(char*)name))
+                        {
+                            partNumber = atol((char*)value);
+                        }
+                    }
+                    if (lsize > 0)
+                    {
+                        pFileInfo->SetSize(pFileInfo->GetSize() + lsize);
+                    }
+                    
+					/* Get the #text part */
+                    ret = xmlTextReaderRead(node);
+
+                    if (partNumber > 0)
+                    {
+                        // new segment, add it!
+						xmlFree(value);
+						value = xmlTextReaderValue(node);
+                        char tmp[2048];
+                        snprintf(tmp, 2048, "<%s>", (char*)value);
+                        ArticleInfo* pArticle = new ArticleInfo();
+                        pArticle->SetPartNumber(partNumber);
+                        pArticle->SetMessageID(tmp);
+                        pArticle->SetSize(lsize);
+						AddArticle(pFileInfo, pArticle);
+                    }
+                }
+                else if (!strcmp("group",(char*)name))
+                {
+                    ret = xmlTextReaderRead(node);
+					xmlFree(value);
+					value = xmlTextReaderValue(node);
+                    pFileInfo->GetGroups()->push_back(strdup((char*)value));
+                }
+            }
+
+            if (xmlTextReaderNodeType(node) == 15)
+            {
+                /* Close the file element, add the new file to file-list */
+                if (!strcmp("file",(char*)name))
+                {
+					DeleteEmptyArticles(pFileInfo);
+                    m_FileInfos.push_back(pFileInfo);
+                }
+            }
+
+            xmlFree(name);
+            xmlFree(value);
+        }
+        ret = xmlTextReaderRead(node);
+    }
+    if (ret != 0)
+    {
+        error("Failed to parse nzb-file\n");
+		return false;
+    }
+	return true;
+}
+#endif

NZBFile.h

@@ -0,0 +1,65 @@
+/*
+ *  This file if part of nzbget
+ *
+ *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifndef NZBFILE_H
+#define NZBFILE_H
+
+#include <vector>
+
+#include "DownloadInfo.h"
+
+class NZBFile
+{
+public:
+	typedef std::vector<FileInfo*>	FileInfos;
+
+private:
+	FileInfos			m_FileInfos;
+	char*				m_szFileName;
+
+						NZBFile(const char* szFileName);
+	void				AddArticle(FileInfo* pFileInfo, ArticleInfo* pArticleInfo);
+	void				DeleteEmptyArticles(FileInfo* pFileInfo);
+#ifdef WIN32
+    bool 				parseNZB(IUnknown* nzb);
+#else
+    bool 				parseNZB(void* nzb);
+#endif
+	static NZBFile*		Create(const char* szFileName, const char* szBuffer, int iSize, bool bFromBuffer);
+
+public:
+	virtual 			~NZBFile();
+	static NZBFile*		CreateFromBuffer(const char* szFileName, const char* szBuffer, int iSize);
+	static NZBFile*		CreateFromFile(const char* szFileName);
+	static bool			LoadFileIntoBuffer(const char* szFileName, char** pBuffer, int* pBufferLength);
+	const char* 		GetFileName() const { return m_szFileName; }
+	FileInfos*			GetFileInfos() { return &m_FileInfos; }
+	void				DetachFileInfos();
+
+	void				LogDebugInfo();
+};
+
+#endif

NetAddress.cpp

@@ -1,7 +1,8 @@
 /*
- *  This file is part of nzbget
+ *  This file if part of nzbget
  *
- *  Copyright (C) 2007-2013 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -15,23 +16,38 @@
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  *
  * $Revision$
  * $Date$
  *
  */
 
-#import <Cocoa/Cocoa.h>
 
-@interface PreferencesDialog : NSWindowController {
-	IBOutlet NSButton *autostartButton;
-	IBOutlet NSButton *showStatusIconButton;
-	IBOutlet NSTextField *generalText;
-	IBOutlet NSTextField *appearanceText;
-	IBOutlet NSButton *autoShowWebUI;
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef WIN32
+#include "win32.h"
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "NetAddress.h"
+
+NetAddress::NetAddress(const char* szHost, int iPort)
+{
+	m_szHost = NULL;
+	m_iPort = iPort;
+	if (szHost)
+		m_szHost = strdup(szHost);
 }
 
-- (IBAction)autostartButtonClicked:(id)sender;
-
-@end
+NetAddress::~NetAddress()
+{
+	if (m_szHost)
+		free(m_szHost);
+	m_szHost = NULL;
+}

NetAddress.h

@@ -1,7 +1,8 @@
 /*
- *  This file is part of nzbget
+ *  This file if part of nzbget
  *
- *  Copyright (C) 2007-2013 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -15,24 +16,29 @@
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  *
  * $Revision$
  * $Date$
  *
  */
 
-#import <Cocoa/Cocoa.h>
-#import "WebClient.h"
 
-@interface RPC : WebClient {
-}
+#ifndef NETADDRESS_H
+#define NETADDRESS_H
 
-- (id)initWithMethod:(NSString*)method
-			receiver:(id)receiver
-			 success:(SEL)successCallback
-			 failure:(SEL)failureCallback;
+class NetAddress
+{
+private:
+	char*			m_szHost;
+	int				m_iPort;
 
-+ (void)setRpcUrl:(NSString*)url;
+public:
+	NetAddress(const char* szHost, int iPort);
+	virtual 		~NetAddress();
+	const char*		GetHost() { return m_szHost; }
+	int				GetPort() { return m_iPort; }
+};
 
-@end
+
+#endif

NewsServer.cpp

@@ -0,0 +1,64 @@
+/*
+ *  This file if part of nzbget
+ *
+ *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef WIN32
+#include "win32.h"
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "NewsServer.h"
+#include "Log.h"
+
+NewsServer::NewsServer(const char* host, int port, const char* user, const char* pass, int maxConnections, int level) : NetAddress(host, port)
+{
+	m_szUser = NULL;
+	m_szPassword = NULL;
+	m_iLevel = level;
+	m_iMaxConnections = maxConnections;
+
+	if (pass)
+	{
+		m_szPassword = strdup(pass);
+	}
+	if (user)
+	{
+		m_szUser = strdup(user);
+	}
+}
+
+NewsServer::~NewsServer()
+{
+	free(m_szUser);
+	m_szUser = NULL;
+	free(m_szPassword);
+	m_szPassword = NULL;
+}

NewsServer.h

@@ -0,0 +1,49 @@
+/*
+ *  This file if part of nzbget
+ *
+ *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifndef NEWSSERVER_H
+#define NEWSSERVER_H
+
+#include "NetAddress.h"
+
+class NewsServer : public NetAddress
+{
+private:
+	char*		m_szUser;
+	char*		m_szPassword;
+	int			m_iMaxConnections;
+	int			m_iLevel;
+
+public:
+	NewsServer(const char* host, int port, const char* user, const char* pass, int maxConnections, int level);
+	virtual			~NewsServer();
+	const char*		GetUser() { return m_szUser; }
+	const char*		GetPassword() { return m_szPassword; }
+	int				GetMaxConnections() { return m_iMaxConnections; }
+	int				GetLevel() { return m_iLevel; }
+};
+
+#endif

Observer.cpp

@@ -2,7 +2,7 @@
  *  This file if part of nzbget
  *
  *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
- *  Copyright (C) 2007-2014  Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -16,7 +16,7 @@
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  *
  * $Revision$
  * $Date$
@@ -25,7 +25,7 @@
 
 
 #ifdef HAVE_CONFIG_H
-#include "config.h"
+#include <config.h>
 #endif
 
 #ifdef WIN32
@@ -40,23 +40,23 @@ Subject::Subject()
 	m_Observers.clear();
 }
 
-void Subject::Attach(Observer* pObserver)
+void Subject::Attach(Observer* Observer)
 {
-	m_Observers.push_back(pObserver);
+	m_Observers.push_back(Observer);
 }
 
-void Subject::Detach(Observer* pObserver)
+void Subject::Detach(Observer* Observer)
 {
-	m_Observers.remove(pObserver);
+	m_Observers.remove(Observer);
 }
 
-void Subject::Notify(void* pAspect)
+void Subject::Notify(void* Aspect)
 {
 	debug("Notifying observers");
 	
 	for (std::list<Observer*>::iterator it = m_Observers.begin(); it != m_Observers.end(); it++)
 	{
         Observer* Observer = *it;
-		Observer->Update(this, pAspect);
+		Observer->Update(this, Aspect);
 	}
 }

Observer.h

@@ -2,7 +2,7 @@
  *  This file if part of nzbget
  *
  *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
- *  Copyright (C) 2007-2014  Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -16,7 +16,7 @@
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  *
  * $Revision$
  * $Date$
@@ -38,16 +38,16 @@ private:
 
 public:
 					Subject();
-	void 			Attach(Observer* pObserver);
-	void 			Detach(Observer* pObserver);
-	void 			Notify(void* pAspect);
+	void 			Attach(Observer* Observer);
+	void 			Detach(Observer* Observer);
+	void 			Notify(void* Aspect);
 };
 
 class Observer
 {
-protected:
-	virtual void	Update(Subject* pCaller, void* pAspect) = 0;
-	friend class Subject;
+public:
+	virtual			~Observer() {};
+	virtual void	Update(Subject* Caller, void* Aspect) = 0;
 };
 
 #endif

Options.h

@@ -0,0 +1,221 @@
+/*
+ *  This file if part of nzbget
+ *
+ *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifndef OPTIONS_H
+#define OPTIONS_H
+
+#include <vector>
+
+class Options
+{
+public:
+	enum EClientOperation
+	{
+	    opClientNoOperation,
+	    opClientRequestDownload,
+	    opClientRequestList,
+	    opClientRequestPause,
+	    opClientRequestUnpause,
+	    opClientRequestSetRate,
+	    opClientRequestDumpDebug,
+	    opClientRequestEditQueue,
+	    opClientRequestLog,
+	    opClientRequestShutdown
+	};
+	enum EMessageTarget
+	{
+	    mtNone,
+	    mtScreen,
+	    mtLog,
+	    mtBoth
+	};
+	enum EDecoder
+	{
+	    dcNone,
+	    dcUulib,
+	    dcYenc
+	};
+	enum EOutputMode
+	{
+	    omLoggable,
+	    omColored,
+	    omNCurses
+	};
+	enum ELoadPars
+	{
+	    plNone,
+	    plOne,
+	    plAll
+	};
+
+private:
+	struct OptEntry
+	{
+		char* name;
+		char* value;
+	};
+	
+	std::vector< struct OptEntry >	optEntries;
+
+	// Options
+	char*				m_szConfigFilename;
+	char*				m_szDestDir;
+	char*				m_szTempDir;
+	char*				m_szQueueDir;
+	char*				m_szNzbDir;
+	EMessageTarget		m_eInfoTarget;
+	EMessageTarget		m_eWarningTarget;
+	EMessageTarget		m_eErrorTarget;
+	EMessageTarget		m_eDebugTarget;
+	EDecoder			m_eDecoder;
+	bool				m_bCreateBrokenLog;
+	bool				m_bResetLog;
+	int					m_iConnectionTimeout;
+	int					m_iTerminateTimeout;
+	bool				m_bAppendNZBDir;
+	bool				m_bContinuePartial;
+	bool				m_bRenameBroken;
+	int					m_iRetries;
+	int					m_iRetryInterval;
+	bool				m_bSaveQueue;
+	bool				m_bDupeCheck;
+	char*				m_szServerIP;
+	char*				m_szServerPassword;
+	int					m_szServerPort;
+	char*				m_szLockFile;
+	EOutputMode			m_eOutputMode;
+	bool				m_bReloadQueue;
+	int					m_iLogBufferSize;
+	bool				m_bCreateLog;
+	char*				m_szLogFile;
+	ELoadPars			m_eLoadPars;
+	bool				m_bParCheck;
+	bool				m_bParRepair;
+	char*				m_szPostProcess;
+	bool				m_bStrictParName;
+	bool				m_bNoConfig;
+
+	// Parsed command-line parameters
+	bool				m_bServerMode;
+	bool				m_bDaemonMode;
+	bool				m_bRemoteClientMode;
+	int					m_iEditQueueAction;
+	int					m_iEditQueueOffset;
+	int					m_iEditQueueIDFrom;
+	int					m_iEditQueueIDTo;
+	char*				m_szArgFilename;
+	bool				m_bPrintOptions;
+	bool				m_bAddTop;
+	float				m_fSetRate;
+	int					m_iLogLines;
+	bool				m_bTest;
+
+	// Current state
+	bool				m_bPause;
+	float				m_fDownloadRate;
+	EClientOperation	m_eClientOperation;
+
+	void				InitDefault();
+	void				InitOptFile(int argc, char* argv[]);
+	void				InitCommandLine(int argc, char* argv[]);
+	void				InitOptions();
+	void				InitFileArg(int argc, char* argv[]);
+	void				InitServers();
+	void				CheckOptions();
+	void				PrintUsage(char* com);
+	void				Dump();
+	int					ParseOptionValue(const char* OptName, int argc, const char* argn[], const int argv[]);
+	const char*			GetOption(const char* optname);
+	void				DelOption(const char* optname);
+	void				SetOption(const char* optname, const char* value);
+	bool				SetOptionString(const char* option);
+	bool				ValidateOptionName(const char* optname);
+	void				LoadConfig(const char* configfile);
+	void				CheckDir(char** dir, const char* szOptionName);
+
+public:
+	Options(int argc, char* argv[]);
+	~Options();
+
+	// Options
+	const char*			GetDestDir() { return m_szDestDir; }
+	const char*			GetTempDir() { return m_szTempDir; }
+	const char*			GetQueueDir() { return m_szQueueDir; }
+	const char*			GetNzbDir() { return m_szNzbDir; }
+	bool				GetCreateBrokenLog() const { return m_bCreateBrokenLog; }
+	bool				GetResetLog() const { return m_bResetLog; }
+	EMessageTarget		GetInfoTarget() const { return m_eInfoTarget; }
+	EMessageTarget		GetWarningTarget() const { return m_eWarningTarget; }
+	EMessageTarget		GetErrorTarget() const { return m_eErrorTarget; }
+	EMessageTarget		GetDebugTarget() const { return m_eDebugTarget; }
+	int					GetConnectionTimeout() { return m_iConnectionTimeout; }
+	int					GetTerminateTimeout() { return m_iTerminateTimeout; }
+	EDecoder			GetDecoder() { return m_eDecoder; };
+	bool				GetAppendNZBDir() { return m_bAppendNZBDir; }
+	bool				GetContinuePartial() { return m_bContinuePartial; }
+	bool				GetRenameBroken() { return m_bRenameBroken; }
+	int					GetRetries() { return m_iRetries; }
+	int					GetRetryInterval() { return m_iRetryInterval; }
+	bool				GetSaveQueue() { return m_bSaveQueue; }
+	bool				GetDupeCheck() { return m_bDupeCheck; }
+	char*				GetServerIP() { return m_szServerIP; }
+	char*				GetServerPassword() { return m_szServerPassword; }
+	int					GetServerPort() { return m_szServerPort; }
+	char*				GetLockFile() { return m_szLockFile; }
+	EOutputMode			GetOutputMode() { return m_eOutputMode; }
+	bool				GetReloadQueue() { return m_bReloadQueue; }
+	int					GetLogBufferSize() { return m_iLogBufferSize; }
+	bool				GetCreateLog() { return m_bCreateLog; }
+	char*				GetLogFile() { return m_szLogFile; }
+	ELoadPars			GetLoadPars() { return m_eLoadPars; }
+	bool				GetParCheck() { return m_bParCheck; }
+	bool				GetParRepair() { return m_bParRepair; }
+	const char*			GetPostProcess() { return m_szPostProcess; }
+	bool				GetStrictParName() { return m_bStrictParName; }
+
+	// Parsed command-line parameters
+	bool				GetServerMode() { return m_bServerMode; }
+	bool				GetDaemonMode() { return m_bDaemonMode; }
+	bool				GetRemoteClientMode() { return m_bRemoteClientMode; }
+	EClientOperation	GetClientOperation() { return 	m_eClientOperation; }
+	int					GetEditQueueAction() { return m_iEditQueueAction; }
+	int					GetEditQueueOffset() { return m_iEditQueueOffset; }
+	int					GetEditQueueIDFrom() { return m_iEditQueueIDFrom; }
+	int					GetEditQueueIDTo() { return m_iEditQueueIDTo; }
+	const char*			GetArgFilename() { return m_szArgFilename; }
+	bool				GetAddTop() { return m_bAddTop; }
+	float				GetSetRate() { return m_fSetRate; }
+	int					GetLogLines() { return m_iLogLines; }
+	bool				GetTest() { return m_bTest; }
+
+	// Current state
+	void				SetPause(bool bOnOff) { m_bPause = bOnOff; }
+	bool				GetPause() const { return m_bPause; }
+	void				SetDownloadRate(float fRate) { m_fDownloadRate = fRate; }
+	float				GetDownloadRate() const { return m_fDownloadRate; }
+};
+
+#endif

ParChecker.cpp

@@ -0,0 +1,532 @@
+/*
+ *  This file if part of nzbget
+ *
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef WIN32
+#include "win32.h"
+#endif
+
+#ifndef DISABLE_PARCHECK
+
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#ifdef WIN32
+#include <par2cmdline.h>
+#include <par2repairer.h>
+#else
+#include <libpar2/par2cmdline.h>
+#include <libpar2/par2repairer.h>
+#endif
+
+#include "nzbget.h"
+#include "ParChecker.h"
+#include "Log.h"
+#include "QueueCoordinator.h"
+#include "Options.h"
+#include "Util.h"
+
+extern QueueCoordinator* g_pQueueCoordinator;
+extern Options* g_pOptions;
+
+const char* Par2CmdLineErrStr[] = { "OK",
+	"data files are damaged and there is enough recovery data available to repair them",
+	"data files are damaged and there is insufficient recovery data available to be able to repair them",
+	"there was something wrong with the command line arguments",
+	"the PAR2 files did not contain sufficient information about the data files to be able to verify them",
+	"repair completed but the data files still appear to be damaged",
+	"an error occured when accessing files",
+	"internal error occurred",
+	"out of memory" };
+
+class Repairer : public Par2Repairer
+{
+	friend class ParChecker;
+};
+
+ParChecker::ParChecker()
+{
+    debug("Creating ParChecker");
+
+	m_eStatus = psUndefined;
+	m_szParFilename = NULL;
+	m_szNZBFilename = NULL;
+	m_szInfoName = NULL;
+	m_szErrMsg = NULL;
+	m_QueuedParFiles.clear();
+}
+
+ParChecker::~ParChecker()
+{
+    debug("Destroying ParChecker");
+
+	if (m_szParFilename)
+	{
+		free(m_szParFilename);
+	}
+	if (m_szNZBFilename)
+	{
+		free(m_szNZBFilename);
+	}
+	if (m_szInfoName)
+	{
+		free(m_szInfoName);
+	}
+	if (m_szErrMsg)
+	{
+		free(m_szErrMsg);
+	}
+
+	for (QueuedParFiles::iterator it = m_QueuedParFiles.begin(); it != m_QueuedParFiles.end() ;it++)
+	{
+		free(*it);
+	}
+	m_QueuedParFiles.clear();
+}
+
+void ParChecker::SetParFilename(const char * szParFilename)
+{
+	if (m_szParFilename)
+	{
+		free(m_szParFilename);
+	}
+	m_szParFilename = strdup(szParFilename);
+}
+
+void ParChecker::SetInfoName(const char * szInfoName)
+{
+	if (m_szInfoName)
+	{
+		free(m_szInfoName);
+	}
+	m_szInfoName = strdup(szInfoName);
+}
+
+void ParChecker::SetNZBFilename(const char * szNZBFilename)
+{
+	if (m_szNZBFilename)
+	{
+		free(m_szNZBFilename);
+	}
+	m_szNZBFilename = strdup(szNZBFilename);
+}
+
+void ParChecker::SetStatus(EStatus eStatus)
+{
+	m_eStatus = eStatus;
+	Notify(NULL);
+}
+
+void ParChecker::Run()
+{
+    info("Verifying %s", m_szInfoName);
+	SetStatus(psWorking);
+	
+    debug("par: %s", m_szParFilename);
+    CommandLine commandLine;
+    const char* argv[] = { "par2", "r", "-q", "-q", m_szParFilename };
+    if (!commandLine.Parse(5, (char**)argv))
+    {
+        error("Could not start par-check for %s. Par-file: %s", m_szInfoName, m_szParFilename);
+		SetStatus(psFailed);
+        return;
+    }
+
+    Result res;
+    Repairer* repairer = new Repairer();
+#ifdef ENABLE_PARPROGRESS
+	repairer->sig_filename.connect(sigc::mem_fun(*this, &ParChecker::signal_filename));
+#endif
+	
+    res = repairer->PreProcess(commandLine);
+    debug("ParChecker: PreProcess-result=%i", res);
+
+	if (res != eSuccess || IsStopped())
+	{
+       	error("Could not verify %s: ", m_szInfoName, IsStopped() ? "due stopping" : "par2-file could not be processed");
+		SetStatus(psFailed);
+		delete repairer;
+		return;
+	}
+
+	char BufReason[1024];
+	BufReason[0] = '\0';
+	if (m_szErrMsg)
+	{
+		free(m_szErrMsg);
+	}
+	m_szErrMsg = NULL;
+	
+	m_bRepairNotNeeded = false;
+	m_bRepairing = false;
+    res = repairer->Process(commandLine, false);
+    debug("ParChecker: Process-result=%i", res);
+	
+	while (!IsStopped() && res == eRepairNotPossible)
+	{
+		int missingblockcount = repairer->missingblockcount - repairer->recoverypacketmap.size();
+		info("Need more %i par-block(s) for %s", missingblockcount, m_szInfoName);
+		
+		m_mutexQueuedParFiles.Lock();
+        bool hasMorePars = !m_QueuedParFiles.empty();
+		m_mutexQueuedParFiles.Unlock();
+		
+		if (!hasMorePars)
+		{
+			int iBlockFound = 0;
+			bool requested = RequestMorePars(missingblockcount, &iBlockFound);
+			
+			m_mutexQueuedParFiles.Lock();
+			hasMorePars = !m_QueuedParFiles.empty();
+			m_mutexQueuedParFiles.Unlock();
+			
+			if (!requested && !hasMorePars)
+			{
+				snprintf(BufReason, 1024, "not enough par-blocks, %i block(s) needed, but %i block(s) available", missingblockcount, iBlockFound);
+                BufReason[1024-1] = '\0';
+				m_szErrMsg = strdup(BufReason);
+				break;
+			}
+			
+			if (!hasMorePars)
+			{
+				m_semNeedMoreFiles.Wait();
+			}
+		}
+
+		if (IsStopped())
+		{
+			break;
+		}
+
+		LoadMorePars(repairer);
+		repairer->UpdateVerificationResults();
+				
+		m_bRepairing = false;
+		res = repairer->Process(commandLine, false);
+		debug("ParChecker: Process-result=%i", res);
+	}
+
+	if (IsStopped())
+	{
+		SetStatus(psFailed);
+		delete repairer;
+		return;
+	}
+	
+	if (res == eSuccess)
+	{
+    	info("Repair not needed for %s", m_szInfoName);
+		m_bRepairNotNeeded = true;
+	}
+	else if (res == eRepairPossible)
+	{
+		if (g_pOptions->GetParRepair())
+		{
+    		info("Repairing %s", m_szInfoName);
+			m_bRepairing = true;
+    		res = repairer->Process(commandLine, true);
+    		debug("ParChecker: Process-result=%i", res);
+			if (res == eSuccess)
+			{
+    			info("Successfully repaired %s", m_szInfoName);
+			}
+		}
+		else
+		{
+    		info("Repair possible for %s", m_szInfoName);
+			res = eSuccess;
+		}
+	}
+	
+	if (res == eSuccess)
+	{
+		SetStatus(psFinished);
+	}
+	else
+	{
+		if (!m_szErrMsg && (int)res >= 0 && (int)res <= 8)
+		{
+			m_szErrMsg = strdup(Par2CmdLineErrStr[res]);
+		}
+		error("Repair failed for %s: %s", m_szInfoName, m_szErrMsg ? m_szErrMsg : "");
+		SetStatus(psFailed);
+	}
+	
+	delete repairer;
+}
+
+bool ParChecker::ParseParFilename(const char * szParFilename, int* iBaseNameLen, int* iBlocks)
+{
+	char szFilename[1024];
+	strncpy(szFilename, szParFilename, 1024);
+	szFilename[1024-1] = '\0';
+	for (char* p = szFilename; *p; p++) *p = tolower(*p); // convert string to lowercase
+
+	int iLen = strlen(szFilename);
+	if (iLen < 6)
+	{
+		return false;
+	}
+
+	// find last occurence of ".par2" and trim filename after it
+	char* szEnd = szFilename;
+	while (char* p = strstr(szEnd, ".par2")) szEnd = p + 5;
+	*szEnd = '\0';
+	iLen = strlen(szFilename);
+	
+	if (strcasecmp(szFilename + iLen - 5, ".par2"))
+	{
+		return false;
+	}
+	*(szFilename + iLen - 5) = '\0';
+
+	int blockcnt = 0;
+	char* p = strrchr(szFilename, '.');
+	if (p && !strncasecmp(p, ".vol", 4))
+	{
+		char* b = strchr(p, '+');
+		if (!b)
+		{
+			b = strchr(p, '-');
+		}
+		if (b)
+		{
+			blockcnt = atoi(b+1);
+			*p = '\0';
+		}
+	}
+
+	if (iBaseNameLen)
+	{
+		*iBaseNameLen = strlen(szFilename);
+	}
+	if (iBlocks)
+	{
+		*iBlocks = blockcnt;
+	}
+	
+	return true;
+}
+
+/**
+* Unpause par2-files
+* returns true, if the files with required number of blocks were unpaused,
+* or false if there are no more files in queue for this collection or not enough blocks
+*/
+bool ParChecker::RequestMorePars(int iBlockNeeded, int* pBlockFound)
+{
+	DownloadQueue* pDownloadQueue = g_pQueueCoordinator->LockQueue();
+	
+	Blocks blocks;
+	blocks.clear();
+	int iBlockFound = 0;
+
+	FindPars(pDownloadQueue, &blocks, true, &iBlockFound);
+	if (iBlockFound == 0 && !g_pOptions->GetStrictParName())
+	{
+		FindPars(pDownloadQueue, &blocks, false, &iBlockFound);
+	}
+
+	if (iBlockFound >= iBlockNeeded)
+	{
+		char szNZBNiceName[1024];
+		FileInfo::MakeNiceNZBName(m_szNZBFilename, szNZBNiceName, 1024);
+
+		// 1. first unpause all files with par-blocks less or equal iBlockNeeded
+		// starting from the file with max block count.
+		// if par-collection was built exponentially and all par-files present,
+		// this step selects par-files with exact number of blocks we need.
+		while (iBlockNeeded > 0)
+		{               
+			BlockInfo* pBestBlockInfo = NULL;
+			for (Blocks::iterator it = blocks.begin(); it != blocks.end(); it++)
+			{
+				BlockInfo* pBlockInfo = *it;
+				if (pBlockInfo->m_iBlockCount <= iBlockNeeded &&
+				   (!pBestBlockInfo || pBestBlockInfo->m_iBlockCount < pBlockInfo->m_iBlockCount))
+				{
+					pBestBlockInfo = pBlockInfo;
+				}
+			}
+			if (pBestBlockInfo)
+			{
+				if (pBestBlockInfo->m_pFileInfo->GetPaused())
+				{
+					info("Unpausing %s%c%s for par-recovery", szNZBNiceName, (int)PATH_SEPARATOR, pBestBlockInfo->m_pFileInfo->GetFilename());
+					pBestBlockInfo->m_pFileInfo->SetPaused(false);
+				}
+				iBlockNeeded -= pBestBlockInfo->m_iBlockCount;
+			}
+			else
+			{
+				break;
+			}
+		}
+			
+		// 2. then unpause other files
+		// this step only needed if the par-collection was built not exponentially 
+		// or not all par-files present (or some of them were corrupted)
+		// this step is not optimal, but we hope, that the first step will work good 
+		// in most cases and we will not need the second step often
+		while (iBlockNeeded > 0)
+		{
+			BlockInfo* pBlockInfo = blocks.front();
+			if (pBlockInfo->m_pFileInfo->GetPaused())
+			{
+				info("Unpausing %s%c%s for par-recovery", szNZBNiceName, (int)PATH_SEPARATOR, pBlockInfo->m_pFileInfo->GetFilename());
+				pBlockInfo->m_pFileInfo->SetPaused(false);
+			}
+			iBlockNeeded -= pBlockInfo->m_iBlockCount;
+		}
+	}
+
+	g_pQueueCoordinator->UnlockQueue();
+
+	if (pBlockFound)
+	{
+		*pBlockFound = iBlockFound;
+	}
+
+	for (Blocks::iterator it = blocks.begin(); it != blocks.end(); it++)
+	{
+		delete *it;
+	}
+	blocks.clear();
+	
+	return iBlockNeeded <= 0;
+}
+
+void ParChecker::FindPars(DownloadQueue * pDownloadQueue, Blocks * pBlocks, bool bStrictParName, int* pBlockFound)
+{
+    *pBlockFound = 0;
+	
+	// extract base name from m_szParFilename (trim .par2-extension and possible .vol-part)
+	char* szBaseParFilename = BaseFileName(m_szParFilename);
+	char szMainBaseFilename[1024];
+	int iMainBaseLen = 0;
+	if (!ParseParFilename(szBaseParFilename, &iMainBaseLen, NULL))
+	{
+		// should not happen
+        error("Internal error: could not parse filename %s", szBaseParFilename);
+		return;
+	}
+	int maxlen = iMainBaseLen < 1024 ? iMainBaseLen : 1024 - 1;
+	strncpy(szMainBaseFilename, szBaseParFilename, maxlen);
+	szMainBaseFilename[maxlen] = '\0';
+	for (char* p = szMainBaseFilename; *p; p++) *p = tolower(*p); // convert string to lowercase
+
+	for (DownloadQueue::iterator it = pDownloadQueue->begin(); it != pDownloadQueue->end(); it++)
+	{
+		FileInfo* pFileInfo = *it;
+		int iBlocks = 0;
+		if (!strcmp(pFileInfo->GetNZBFilename(), m_szNZBFilename) &&
+			ParseParFilename(pFileInfo->GetFilename(), NULL, &iBlocks) &&
+			iBlocks > 0)
+		{
+			if (bStrictParName)
+			{
+				// the pFileInfo->GetFilename() may be not confirmed and may contain
+				// additional texts if Subject could not be parsed correctly
+
+				char szLoFileName[1024];
+				strncpy(szLoFileName, pFileInfo->GetFilename(), 1024);
+				szLoFileName[1024-1] = '\0';
+				for (char* p = szLoFileName; *p; p++) *p = tolower(*p); // convert string to lowercase
+				
+				char szCandidateFileName[1024];
+				snprintf(szCandidateFileName, 1024, "%s.par2", szMainBaseFilename);
+				szCandidateFileName[1024-1] = '\0';
+				if (!strstr(szLoFileName, szCandidateFileName))
+				{
+					snprintf(szCandidateFileName, 1024, "%s.vol", szMainBaseFilename);
+					szCandidateFileName[1024-1] = '\0';
+					if (!strstr(szLoFileName, szCandidateFileName))
+					{
+						continue;
+					}
+				}
+			}
+
+			// if it is a par2-file with blocks and it was from the same NZB-request
+			// and it belongs to the same file collection (same base name),
+			// then OK, we can use it
+			BlockInfo* pBlockInfo = new BlockInfo();
+			pBlockInfo->m_pFileInfo = pFileInfo;
+			pBlockInfo->m_iBlockCount = iBlocks;
+			pBlocks->push_back(pBlockInfo);
+			*pBlockFound += iBlocks;
+		}
+	}
+}
+
+void ParChecker::LoadMorePars(void* repairer)
+{
+	m_mutexQueuedParFiles.Lock();
+	QueuedParFiles moreFiles;
+	moreFiles.assign(m_QueuedParFiles.begin(), m_QueuedParFiles.end());
+	m_QueuedParFiles.clear();
+	m_mutexQueuedParFiles.Unlock();
+	
+	for (QueuedParFiles::iterator it = moreFiles.begin(); it != moreFiles.end() ;it++)
+	{
+		char* szParFilename = *it;
+		bool loadedOK = ((Repairer*)repairer)->LoadPacketsFromFile(szParFilename);
+		if (loadedOK)
+		{
+			info("File %s successfully loaded for par-check", BaseFileName(szParFilename), m_szInfoName);
+		}
+		else
+		{
+			info("Could not load file %s for par-check", BaseFileName(szParFilename), m_szInfoName);
+		}
+		free(szParFilename);
+	}
+}
+
+void ParChecker::AddParFile(const char * szParFilename)
+{
+	m_mutexQueuedParFiles.Lock();
+	m_QueuedParFiles.push_back(strdup(szParFilename));
+	m_semNeedMoreFiles.Post();
+	m_mutexQueuedParFiles.Unlock();
+}
+
+void ParChecker::QueueChanged()
+{
+	m_mutexQueuedParFiles.Lock();
+	m_semNeedMoreFiles.Post();
+	m_mutexQueuedParFiles.Unlock();
+}
+
+void ParChecker::signal_filename(std::string str)
+{
+	info("%s file %s", m_bRepairing ? "Repairing" : "Verifying", str.c_str());
+}
+
+#endif

ParChecker.h

@@ -0,0 +1,94 @@
+/*
+ *  This file if part of nzbget
+ *
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifndef PARCHECKER_H
+#define PARCHECKER_H
+
+#ifndef DISABLE_PARCHECK
+
+#include <deque>
+
+#include "Thread.h"
+#include "Observer.h"
+#include "DownloadInfo.h"
+
+class ParChecker : public Thread, public Subject
+{
+public:
+	enum EStatus
+	{
+        psUndefined,
+		psWorking,
+		psFailed,
+		psFinished
+	};
+	struct BlockInfo
+	{
+		FileInfo*	m_pFileInfo;
+		int		    m_iBlockCount;
+	};
+	
+	typedef std::deque<char*>		QueuedParFiles;
+	typedef std::deque<BlockInfo*> 	Blocks;
+	
+private:
+	char*				m_szInfoName;
+	char*				m_szNZBFilename;
+	char*				m_szParFilename;
+	EStatus				m_eStatus;
+	char*				m_szErrMsg;
+	bool				m_bRepairNotNeeded;
+	QueuedParFiles		m_QueuedParFiles;
+	Mutex			 	m_mutexQueuedParFiles;
+	Semaphore			m_semNeedMoreFiles;
+	bool				m_bRepairing;
+
+	bool				RequestMorePars(int iBlockNeeded, int* pBlockFound);
+	void				FindPars(DownloadQueue* pDownloadQueue, Blocks* pBlocks, bool bStrictParName, int* pBlockFound);
+	void				LoadMorePars(void* repairer);
+	void				signal_filename(std::string str);
+	
+public:
+						ParChecker();
+	virtual				~ParChecker();
+	virtual void		Run();
+	const char*			GetParFilename() { return m_szParFilename; }
+	void				SetParFilename(const char* szParFilename);
+	const char*			GetNZBFilename() { return m_szNZBFilename; }
+	void				SetNZBFilename(const char* szNZBFilename);
+	const char*			GetInfoName() { return m_szInfoName; }
+	void				SetInfoName(const char* szInfoName);
+	void				SetStatus(EStatus eStatus);
+	EStatus				GetStatus() { return m_eStatus; }
+	const char*			GetErrMsg() { return m_szErrMsg; }
+	bool				GetRepairNotNeeded() { return m_bRepairNotNeeded; }
+	void				AddParFile(const char* szParFilename);
+	void				QueueChanged();
+	static bool			ParseParFilename(const char* szParFilename, int* iBaseNameLen, int* iBlocks);
+};
+
+#endif
+
+#endif

PrePostProcessor.cpp

@@ -0,0 +1,635 @@
+/*
+ *  This file if part of nzbget
+ *
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef WIN32
+#include "win32.h"
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#ifndef WIN32
+#include <unistd.h>
+#endif
+#include <sys/stat.h>
+#include <errno.h>
+#include <fcntl.h>
+
+#include "nzbget.h"
+#include "PrePostProcessor.h"
+#include "Options.h"
+#include "Log.h"
+#include "QueueCoordinator.h"
+#include "Util.h"
+
+extern QueueCoordinator* g_pQueueCoordinator;
+extern Options* g_pOptions;
+
+PrePostProcessor::PrePostProcessor()
+{
+	debug("Creating PrePostProcessor");
+
+	struct stat buffer;
+	m_bCheckIncomingNZBs = !stat(g_pOptions->GetNzbDir(), &buffer) && S_ISDIR(buffer.st_mode);
+	m_bHasMoreJobs = false;
+
+	m_QueueCoordinatorObserver.owner = this;
+	g_pQueueCoordinator->Attach(&m_QueueCoordinatorObserver);
+
+#ifndef DISABLE_PARCHECK
+	m_ParQueue.clear();
+	
+	m_ParCheckerObserver.owner = this;
+	m_ParChecker.Attach(&m_ParCheckerObserver);
+#endif
+}
+
+PrePostProcessor::~PrePostProcessor()
+{
+	debug("Destroying PrePostProcessor");
+	
+#ifndef DISABLE_PARCHECK
+	for (ParQueue::iterator it = m_ParQueue.begin(); it != m_ParQueue.end(); it++)
+	{
+		delete *it;
+	}
+#endif
+}
+
+void PrePostProcessor::Run()
+{
+	debug("Entering PrePostProcessor-loop");
+
+	int iNZBDirInterval = 0;
+#ifndef DISABLE_PARCHECK
+	int iParQueueInterval = 0;
+#endif
+	while (!IsStopped())
+	{
+		if (m_bCheckIncomingNZBs && iNZBDirInterval == 5000)
+		{
+			// check nzbdir every 5 seconds
+			CheckIncomingNZBs();
+			iNZBDirInterval = 0;
+		}
+		iNZBDirInterval += 200;
+#ifndef DISABLE_PARCHECK
+		if (iParQueueInterval == 1000 && g_pOptions->GetParCheck())
+		{
+			// check par-queue every 1 second
+			CheckParQueue();
+			iParQueueInterval = 0;
+		}
+		iParQueueInterval += 200;
+#endif
+		usleep(200 * 1000);
+	}
+
+	debug("Exiting PrePostProcessor-loop");
+}
+
+void PrePostProcessor::Stop()
+{
+	Thread::Stop();
+#ifndef DISABLE_PARCHECK
+	m_mutexParChecker.Lock();
+	if (m_ParChecker.IsRunning())
+	{
+		m_ParChecker.Stop();
+		int iMSecWait = 5000;
+		while (m_ParChecker.IsRunning() && iMSecWait > 0)
+		{
+			usleep(50 * 1000);
+			iMSecWait -= 50;
+		}
+		if (m_ParChecker.IsRunning())
+		{
+			warn("Terminating par-check for %s", m_ParChecker.GetInfoName());
+			m_ParChecker.Kill();
+		}
+	}
+	
+	m_mutexParChecker.Unlock();
+#endif
+}
+
+void PrePostProcessor::QueueCoordinatorUpdate(Subject * Caller, void * Aspect)
+{
+	if (IsStopped())
+	{
+		return;
+	}
+
+	QueueCoordinator::Aspect* pAspect = (QueueCoordinator::Aspect*)Aspect;
+	if (pAspect->eAction == QueueCoordinator::eaNZBFileAdded &&
+		g_pOptions->GetLoadPars() != Options::plAll)
+	{
+		PausePars(pAspect->pDownloadQueue, pAspect->szNZBFilename);
+	}
+	else if ((pAspect->eAction == QueueCoordinator::eaFileCompleted ||
+		pAspect->eAction == QueueCoordinator::eaFileDeleted))
+	{
+		if (
+#ifndef DISABLE_PARCHECK
+			!AddPar(pAspect->pFileInfo, pAspect->eAction == QueueCoordinator::eaFileDeleted) &&
+#endif
+			WasLastUnpausedInCollection(pAspect->pDownloadQueue, pAspect->pFileInfo))
+		{
+			char szNZBNiceName[1024];
+			pAspect->pFileInfo->GetNiceNZBName(szNZBNiceName, 1024);
+			info("Collection %s completely downloaded", szNZBNiceName);
+#ifndef DISABLE_PARCHECK
+			if (g_pOptions->GetParCheck())
+			{
+				CheckPars(pAspect->pDownloadQueue, pAspect->pFileInfo);
+			}
+			else
+#endif
+			{
+				ExecPostScript(pAspect->pFileInfo->GetDestDir(), pAspect->pFileInfo->GetNZBFilename(), "", false);
+			}
+		}
+	}
+}
+
+/**
+* If the option "loadpars" is set to "none", then we pause all par2-files.
+* If the option "loadpars" is set to "one", we use the following strategy:
+* Firstly we find all par-files, which do not have "vol" in their names, then we pause
+* all vols and download all just-pars.
+* In a case, if there are no just-pars, but only vols, we find the smallest vol-file
+* and download only it.
+*/
+void PrePostProcessor::PausePars(DownloadQueue* pDownloadQueue, const char* szNZBFilename)
+{
+	debug("Pausing pars");
+	
+	DownloadQueue Pars, Vols;
+	Pars.clear();
+	Vols.clear();
+			
+	char szNZBNiceName[1024];
+	FileInfo::MakeNiceNZBName(szNZBFilename, szNZBNiceName, 1024);
+	
+	for (DownloadQueue::iterator it = pDownloadQueue->begin(); it != pDownloadQueue->end(); it++)
+	{
+		FileInfo* pFileInfo = *it;
+		if (!strcmp(pFileInfo->GetNZBFilename(), szNZBFilename))
+		{
+			char szLoFileName[1024];
+			strncpy(szLoFileName, pFileInfo->GetFilename(), 1024);
+			szLoFileName[1024-1] = '\0';
+			for (char* p = szLoFileName; *p; p++) *p = tolower(*p); // convert string to lowercase
+			
+			if (strstr(szLoFileName, ".par2"))
+			{
+				if (g_pOptions->GetLoadPars() == Options::plNone)
+				{
+					info("Pausing %s%c%s", szNZBNiceName, (int)PATH_SEPARATOR, pFileInfo->GetFilename());
+					pFileInfo->SetPaused(true);
+				}
+				else
+				{
+					if (strstr(szLoFileName, ".vol"))
+					{
+						Vols.push_back(pFileInfo);
+					}
+					else
+					{
+						Pars.push_back(pFileInfo);
+					}
+				}
+			}
+		}
+	}
+	
+	if (g_pOptions->GetLoadPars() == Options::plOne ||
+	   (g_pOptions->GetLoadPars() == Options::plNone && g_pOptions->GetParCheck()))
+	{
+		if (!Pars.empty())
+		{
+			for (DownloadQueue::iterator it = Vols.begin(); it != Vols.end(); it++)
+			{
+				FileInfo* pFileInfo = *it;
+				info("Pausing %s%c%s", szNZBNiceName, (int)PATH_SEPARATOR, pFileInfo->GetFilename());
+				pFileInfo->SetPaused(true);
+			}
+		}
+		else
+		{
+			// pausing all Vol-files except the smallest one
+			FileInfo* pSmallest = NULL;
+			for (DownloadQueue::iterator it = Vols.begin(); it != Vols.end(); it++)
+			{
+				FileInfo* pFileInfo = *it;
+				if (!pSmallest)
+				{
+					pSmallest = pFileInfo;
+				}
+				else if (pSmallest->GetSize() > pFileInfo->GetSize())
+				{
+					info("Pausing %s%c%s", szNZBNiceName, (int)PATH_SEPARATOR, pSmallest->GetFilename());
+					pSmallest->SetPaused(true);
+					pSmallest = pFileInfo;
+				}
+				else 
+				{
+					info("Pausing %s%c%s", szNZBNiceName, (int)PATH_SEPARATOR, pFileInfo->GetFilename());
+					pFileInfo->SetPaused(true);
+				}
+			}
+		}
+	}
+}
+
+/**
+* Check if there are files in directory for incoming nzb-files
+* and add them to download queue
+*/
+void PrePostProcessor::CheckIncomingNZBs()
+{
+	DirBrowser dir(g_pOptions->GetNzbDir());
+	while (const char* filename = dir.Next())
+	{
+		int len = strlen(filename);
+		if (len > 4 && !strcasecmp(filename + len - 4, ".nzb"))
+		{
+			// file found, checking modification-time
+			struct stat buffer;
+			char fullfilename[1024];
+			snprintf(fullfilename, 1024, "%s%c%s", g_pOptions->GetNzbDir(), (int)PATH_SEPARATOR, filename);
+			fullfilename[1024-1] = '\0';
+			if (!stat(fullfilename, &buffer) &&
+				time(NULL) - buffer.st_mtime > 60 &&
+				time(NULL) - buffer.st_ctime > 60)
+			{
+				// the file is at least 60 seconds old, we can process it
+				info("Collection %s found", filename);
+				char bakname[1024];
+				if (g_pQueueCoordinator->AddFileToQueue(fullfilename))
+				{
+					info("Collection %s added to queue", filename);
+					snprintf(bakname, 1024, "%s.queued", fullfilename);
+					bakname[1024-1] = '\0';
+				}
+				else
+				{
+					error("Could not add collection %s to queue", filename);
+					snprintf(bakname, 1024, "%s.error", fullfilename);
+					bakname[1024-1] = '\0';
+				}
+
+				char bakname2[1024];
+				strcpy(bakname2, bakname);
+				int i = 2;
+				while (!stat(bakname2, &buffer))
+				{
+					snprintf(bakname2, 1024, "%s%i", bakname, i++);
+					bakname2[1024-1] = '\0';
+				}
+				
+				rename(fullfilename, bakname2);
+			}
+		}
+	}
+}
+
+/**
+* Check if the completed file was last unpaused file in nzb-collection
+*/
+bool PrePostProcessor::WasLastUnpausedInCollection(DownloadQueue* pDownloadQueue, FileInfo * pFileInfo)
+{
+	debug("File %s completed or deleted", pFileInfo->GetFilename());
+
+	for (DownloadQueue::iterator it = pDownloadQueue->begin(); it != pDownloadQueue->end(); it++)
+	{
+		FileInfo* pFileInfo2 = *it;
+		if (pFileInfo2 != pFileInfo && !pFileInfo2->GetPaused() &&
+			!strcmp(pFileInfo2->GetNZBFilename(), pFileInfo->GetNZBFilename()))
+		{
+			return false;
+		}
+	}
+
+	return true;
+}
+
+#ifndef DISABLE_PARCHECK
+
+PrePostProcessor::QueuedFile::QueuedFile(const char * szNZBFilename, const char * szParFilename, const char * szInfoName)
+{
+	m_szNZBFilename = strdup(szNZBFilename);
+	m_szParFilename = strdup(szParFilename);
+	m_szInfoName = strdup(szInfoName);
+}
+
+PrePostProcessor::QueuedFile::~ QueuedFile()
+{
+	if (m_szNZBFilename)
+	{
+		free(m_szNZBFilename);
+	}
+	if (m_szParFilename)
+	{
+		free(m_szParFilename);
+	}
+	if (m_szInfoName)
+	{
+		free(m_szInfoName);
+	}
+}
+
+void PrePostProcessor::CheckPars(DownloadQueue * pDownloadQueue, FileInfo * pFileInfo)
+{
+	char szNZBNiceName[1024];
+	pFileInfo->GetNiceNZBName(szNZBNiceName, 1024);
+
+	m_mutexParChecker.Lock();
+
+	FileList fileList;
+	if (FindMainPars(pFileInfo->GetDestDir(), &fileList))
+	{
+		for (FileList::iterator it = fileList.begin(); it != fileList.end(); it++)
+		{
+			char* szParFilename = *it;
+			debug("Found par: %s", szParFilename);
+			
+			char szFullFilename[1024];
+			snprintf(szFullFilename, 1024, "%s%c%s", pFileInfo->GetDestDir(), (int)PATH_SEPARATOR, szParFilename);
+			szFullFilename[1024-1] = '\0';
+
+			char szInfoName[1024];
+			int iBaseLen = 0;
+			ParChecker::ParseParFilename(szParFilename, &iBaseLen, NULL);
+			int maxlen = iBaseLen < 1024 ? iBaseLen : 1024 - 1;
+			strncpy(szInfoName, szParFilename, maxlen);
+			szInfoName[maxlen] = '\0';
+			
+			char szParInfoName[1024];
+			snprintf(szParInfoName, 1024, "%s%c%s", szNZBNiceName, (int)PATH_SEPARATOR, szInfoName);
+			szParInfoName[1024-1] = '\0';
+			
+			info("Queueing %s%c%s for par-check", szNZBNiceName, (int)PATH_SEPARATOR, szInfoName);
+			QueuedFile* pQueuedFile = new QueuedFile(pFileInfo->GetNZBFilename(), szFullFilename, szParInfoName);
+			m_ParQueue.push_back(pQueuedFile);
+			m_bHasMoreJobs = true;
+
+			free(szParFilename);
+		}
+	}
+
+	m_mutexParChecker.Unlock();
+}
+
+bool PrePostProcessor::FindMainPars(const char * szPath, FileList * pFileList)
+{
+	pFileList->clear();
+	DirBrowser dir(szPath);
+	while (const char* filename = dir.Next())
+	{
+		int iBaseLen = 0;
+		if (ParChecker::ParseParFilename(filename, &iBaseLen, NULL))
+		{
+			// check if the base file already added to list
+			bool exists = false;
+			for (FileList::iterator it = pFileList->begin(); it != pFileList->end(); it++)
+			{
+				const char* filename2 = *it;
+				exists = SameParCollection(filename, filename2);
+				if (exists)
+				{
+					break;
+				}
+			}
+			if (!exists)
+			{
+				pFileList->push_back(strdup(filename));
+			}
+		}
+	}
+	return !pFileList->empty();
+}
+
+bool PrePostProcessor::AddPar(FileInfo * pFileInfo, bool bDeleted)
+{
+	m_mutexParChecker.Lock();
+	bool bSameCollection = m_ParChecker.IsRunning() &&
+		!strcmp(pFileInfo->GetNZBFilename(), m_ParChecker.GetNZBFilename()) &&
+		SameParCollection(pFileInfo->GetFilename(), BaseFileName(m_ParChecker.GetParFilename()));
+	if (bSameCollection)
+	{
+		if (!bDeleted)
+		{
+			char szFullFilename[1024];
+			snprintf(szFullFilename, 1024, "%s%c%s", pFileInfo->GetDestDir(), (int)PATH_SEPARATOR, pFileInfo->GetFilename());
+			szFullFilename[1024-1] = '\0';
+			m_ParChecker.AddParFile(szFullFilename);
+		}
+		else
+		{
+			m_ParChecker.QueueChanged();
+		}
+	}
+	m_mutexParChecker.Unlock();
+	return bSameCollection;
+}
+
+bool PrePostProcessor::SameParCollection(const char* szFilename1, const char* szFilename2)
+{
+	int iBaseLen1 = 0, iBaseLen2 = 0;
+	return ParChecker::ParseParFilename(szFilename1, &iBaseLen1, NULL) &&
+		ParChecker::ParseParFilename(szFilename2, &iBaseLen2, NULL) &&
+		iBaseLen1 == iBaseLen2 &&
+		!strncasecmp(szFilename1, szFilename2, iBaseLen1);
+}
+
+void PrePostProcessor::CheckParQueue()
+{
+	m_mutexParChecker.Lock();
+
+	if (!m_ParChecker.IsRunning() && !m_ParQueue.empty())
+	{
+		QueuedFile* pQueuedFile = m_ParQueue.front();
+
+		info("Checking pars for %s", pQueuedFile->GetInfoName());
+		m_ParChecker.SetNZBFilename(pQueuedFile->GetNZBFilename());
+		m_ParChecker.SetParFilename(pQueuedFile->GetParFilename());
+		m_ParChecker.SetInfoName(pQueuedFile->GetInfoName());
+		m_ParChecker.Start();
+		
+		m_ParQueue.pop_front();
+		delete pQueuedFile;
+	}
+	
+	m_mutexParChecker.Unlock();
+}
+
+void PrePostProcessor::ParCheckerUpdate(Subject * Caller, void * Aspect)
+{
+	if (m_ParChecker.GetStatus() == ParChecker::psFinished ||
+		m_ParChecker.GetStatus() == ParChecker::psFailed)
+	{
+		char szPath[1024];
+		strncpy(szPath, m_ParChecker.GetParFilename(), 1024);
+		szPath[1024-1] = '\0';
+		if (char* p = strrchr(szPath, PATH_SEPARATOR)) *p = '\0';
+
+		if (g_pOptions->GetCreateBrokenLog())
+		{
+			char szBrokenLogName[1024];
+			snprintf(szBrokenLogName, 1024, "%s%c_brokenlog.txt", szPath, (int)PATH_SEPARATOR);
+			szBrokenLogName[1024-1] = '\0';
+			
+			bool bExists = false;
+			if (m_ParChecker.GetRepairNotNeeded())
+			{
+				struct stat buffer;
+				bExists = !stat(szBrokenLogName, &buffer);
+			}
+			if (!m_ParChecker.GetRepairNotNeeded() || bExists)
+			{
+				FILE* file = fopen(szBrokenLogName, "a");
+				if (m_ParChecker.GetStatus() == ParChecker::psFailed)
+				{
+					fprintf(file, "Repair failed for %s: %s\n", m_ParChecker.GetInfoName(), m_ParChecker.GetErrMsg() ? m_ParChecker.GetErrMsg() : "");
+				}
+				else if (m_ParChecker.GetRepairNotNeeded())
+				{
+					fprintf(file, "Repair not needed for %s\n", m_ParChecker.GetInfoName());
+				}
+				else
+				{
+					if (g_pOptions->GetParRepair())
+					{
+						fprintf(file, "Successfully repaired %s\n", m_ParChecker.GetInfoName());
+					}
+					else
+					{
+						fprintf(file, "Repair possible for %s\n", m_ParChecker.GetInfoName());
+					}
+				}
+				fclose(file);
+			}
+		}
+		
+		ExecPostScript(szPath, m_ParChecker.GetNZBFilename(), m_ParChecker.GetParFilename(),
+			m_ParChecker.GetStatus() == ParChecker::psFinished);
+
+		m_mutexParChecker.Lock();
+		m_bHasMoreJobs = !m_ParQueue.empty();
+		m_mutexParChecker.Unlock();
+	}
+}
+
+#endif
+
+void PrePostProcessor::ExecPostScript(const char * szPath, const char * szNZBFilename, const char * szParFilename, bool bParOK)
+{
+	const char* szScript = g_pOptions->GetPostProcess();
+	if (!szScript || strlen(szScript) == 0)
+	{
+		return;
+	}
+		
+	info("Executing post-process for %s (%s)", szPath, BaseFileName(szNZBFilename));
+	struct stat buffer;
+	bool bExists = !stat(szScript, &buffer);
+	if (!bExists)
+	{
+		error("Could not start post-process: could not find file %s", szScript);
+		return;
+	}
+
+	bool bCollectionCompleted = true;
+	DownloadQueue* pDownloadQueue = g_pQueueCoordinator->LockQueue();
+	for (DownloadQueue::iterator it = pDownloadQueue->begin(); it != pDownloadQueue->end(); it++)
+	{
+		FileInfo* pFileInfo2 = *it;
+		if (!pFileInfo2->GetPaused() &&
+			!strcmp(pFileInfo2->GetNZBFilename(), szNZBFilename))
+		{
+			bCollectionCompleted = false;
+			break;
+		}
+	}
+	g_pQueueCoordinator->UnlockQueue();
+		
+#ifndef DISABLE_PARCHECK
+	if (bCollectionCompleted)
+	{
+		m_mutexParChecker.Lock();
+		bCollectionCompleted = m_ParQueue.empty();
+		m_mutexParChecker.Unlock();
+	}
+#endif
+
+	int iParStatus = 0;
+	if (strlen(szParFilename) != 0)
+	{
+		iParStatus = (int)bParOK + 1;
+	}
+	char szParStatus[10];
+	snprintf(szParStatus, 10, "%i", iParStatus);
+	szParStatus[10-1] = '\0';
+
+	char szCollectionCompleted[10];
+	snprintf(szCollectionCompleted, 10, "%i", (int)bCollectionCompleted);
+	szCollectionCompleted[10-1] = '\0';
+
+#ifdef WIN32
+	char szCmdLine[2048];
+	snprintf(szCmdLine, 2048, "%s \"%s\" \"%s\" \"%s\" %s %s", szScript, szPath, szNZBFilename, szParFilename, szParStatus, szCollectionCompleted);
+	szCmdLine[2048-1] = '\0';
+	UINT ErrCode = WinExec(szCmdLine, SW_HIDE);
+	if (ErrCode < 32)
+	{
+		char szErrMsg[255];
+		szErrMsg[255-1] = '\0';
+		FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM || FORMAT_MESSAGE_IGNORE_INSERTS || FORMAT_MESSAGE_ARGUMENT_ARRAY, 
+			NULL, ErrCode, 0, szErrMsg, 255, NULL);
+		error("Could not start post-process: %s", szErrMsg);
+	}
+#else
+	if (fork())
+	{
+		// continue the first instance
+		return;
+	}
+
+	// here goes the second instance
+		
+	int h;
+	for (h = getdtablesize(); h >= 0;--h) close(h); /* close all descriptors */
+	h = open("/dev/null", O_RDWR); dup(h); dup(h); /* handle standart I/O */
+	
+	execlp(szScript, szScript, szPath, szNZBFilename, szParFilename, szParStatus, szCollectionCompleted, NULL);
+	error("Could not start post-process: %s", strerror(errno));
+	exit(-1);
+#endif
+}

PrePostProcessor.h

@@ -0,0 +1,110 @@
+/*
+ *  This file if part of nzbget
+ *
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifndef PREPOSTPROCESSOR_H
+#define PREPOSTPROCESSOR_H
+
+#include <deque>
+
+#include "Thread.h"
+#include "Observer.h"
+#include "DownloadInfo.h"
+
+#ifndef DISABLE_PARCHECK
+#include "ParChecker.h"
+#endif
+
+class PrePostProcessor : public Thread
+{
+private:
+	typedef std::deque<char*>		FileList;
+
+	class QueueCoordinatorObserver: public Observer
+	{
+	public:
+		PrePostProcessor* owner;
+		virtual void	Update(Subject* Caller, void* Aspect) { owner->QueueCoordinatorUpdate(Caller, Aspect); }
+	};
+
+#ifndef DISABLE_PARCHECK
+	class ParCheckerObserver: public Observer
+	{
+	public:
+		PrePostProcessor* owner;
+		virtual void	Update(Subject* Caller, void* Aspect) { owner->ParCheckerUpdate(Caller, Aspect); }
+	};
+	
+	class QueuedFile
+	{
+	private:
+		char*			m_szNZBFilename;
+		char*			m_szParFilename;
+		char*			m_szInfoName;
+		
+	public:
+						QueuedFile(const char* szNZBFilename, const char* szParFilename, const char* szInfoName);
+						~QueuedFile();
+		const char*		GetNZBFilename() { return m_szNZBFilename; }
+		const char*		GetParFilename() { return m_szParFilename; }
+		const char*		GetInfoName() { return m_szInfoName; }
+	};
+	
+	typedef std::deque<QueuedFile*>		ParQueue;
+#endif
+	
+private:
+	bool				m_bCheckIncomingNZBs;
+	QueueCoordinatorObserver	m_QueueCoordinatorObserver;
+	bool				m_bHasMoreJobs;
+
+	void				PausePars(DownloadQueue* pDownloadQueue, const char* szNZBFilename);
+	void				CheckIncomingNZBs();
+	bool				WasLastUnpausedInCollection(DownloadQueue* pDownloadQueue, FileInfo* pFileInfo);
+	void				ExecPostScript(const char* szPath, const char* szNZBFilename, const char * szParFilename, bool bParOK);
+	
+#ifndef DISABLE_PARCHECK
+	ParChecker			m_ParChecker;
+	Mutex			 	m_mutexParChecker;
+	ParQueue			m_ParQueue;
+	ParCheckerObserver	m_ParCheckerObserver;
+
+	void				ParCheckerUpdate(Subject* Caller, void* Aspect);
+	void				CheckParQueue();
+	void				CheckPars(DownloadQueue* pDownloadQueue, FileInfo* pFileInfo);
+	bool				AddPar(FileInfo* pFileInfo, bool bDeleted);
+	bool				SameParCollection(const char* szFilename1, const char* szFilename2);
+	bool				FindMainPars(const char* szPath, FileList* pFileList);
+#endif
+	
+public:
+						PrePostProcessor();
+	virtual				~PrePostProcessor();
+	virtual void		Run();
+	virtual void		Stop();
+	void				QueueCoordinatorUpdate(Subject* Caller, void* Aspect);
+	bool				HasMoreJobs() { return m_bHasMoreJobs; }
+};
+
+#endif

QueueCoordinator.cpp

@@ -0,0 +1,728 @@
+/*
+ *  This file if part of nzbget
+ *
+ *  Copyright (C) 2005  Bo Cordes Petersen <placebodk@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef WIN32
+#include "win32.h"
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#ifndef WIN32
+#include <unistd.h>
+#include <sys/time.h>
+#endif
+
+#include "nzbget.h"
+#include "QueueCoordinator.h"
+#include "Options.h"
+#include "ServerPool.h"
+#include "ArticleDownloader.h"
+#include "Log.h"
+#include "Util.h"
+
+extern Options* g_pOptions;
+extern ServerPool* g_pServerPool;
+
+QueueCoordinator::QueueCoordinator()
+{
+	debug("Creating QueueCoordinator");
+
+	m_bHasMoreJobs = true;
+	m_DownloadQueue.clear();
+	m_ActiveDownloads.clear();
+
+	Decoder::Init();
+}
+
+QueueCoordinator::~QueueCoordinator()
+{
+	debug("Destroying QueueCoordinator");
+	// Cleanup
+
+	debug("Deleting DownloadQueue");
+	for (DownloadQueue::iterator it = m_DownloadQueue.begin(); it != m_DownloadQueue.end(); it++)
+	{
+		delete *it;
+	}
+	m_DownloadQueue.clear();
+
+	debug("Deleting ArticleDownloaders");
+	for (ActiveDownloads::iterator it = m_ActiveDownloads.begin(); it != m_ActiveDownloads.end(); it++)
+	{
+		delete *it;
+	}
+	m_ActiveDownloads.clear();
+
+	Decoder::Final();
+
+	debug("QueueCoordinator destroyed");
+}
+
+void QueueCoordinator::Run()
+{
+	debug("Entering QueueCoordinator-loop");
+
+	m_mutexDownloadQueue.Lock();
+
+	m_DiskState.CleanupTempDir(&m_DownloadQueue);
+
+	if (g_pOptions->GetServerMode() && g_pOptions->GetSaveQueue() && m_DiskState.Exists())
+	{
+		if (g_pOptions->GetReloadQueue())
+		{
+			m_DiskState.Load(&m_DownloadQueue);
+		}
+		else
+		{
+			m_DiskState.Discard();
+		}
+	}
+
+	m_mutexDownloadQueue.Unlock();
+
+	while (!IsStopped())
+	{
+		while (g_pOptions->GetPause() && !IsStopped())
+		{
+			// Sleep for a while
+			usleep(500 * 1000);
+		}
+
+		if (g_pServerPool->HasFreeConnection())
+		{
+			// start download for next article
+			FileInfo* pFileInfo;
+			ArticleInfo* pArticleInfo;
+
+			m_mutexDownloadQueue.Lock();
+			bool bHasMoreArticles = GetNextArticle(pFileInfo, pArticleInfo);
+			m_bHasMoreJobs = bHasMoreArticles || !m_ActiveDownloads.empty();
+			if (bHasMoreArticles && !IsStopped())
+			{
+				StartArticleDownload(pFileInfo, pArticleInfo);
+			}
+			m_mutexDownloadQueue.Unlock();
+
+			if (!IsStopped())
+			{
+				// two possibilities:
+				// 1) hasMoreArticles==false: there are no jobs, waiting for a while
+				// 2) hasMoreArticles==true: the pause prevents starting of many threads, before the download-thread locks the connection
+				usleep(100 * 1000);
+			}
+		}
+		else
+		{
+			// there are no free connection available, waiting for a while
+			usleep(100 * 1000);
+		}
+
+		ResetHangingDownloads();
+	}
+
+	// waiting for downloads
+	debug("QueueCoordinator: waiting for Downloads to complete");
+	bool completed = false;
+	while (!completed)
+	{
+		m_mutexDownloadQueue.Lock();
+		completed = m_ActiveDownloads.size() == 0;
+		m_mutexDownloadQueue.Unlock();
+		usleep(100 * 1000);
+		ResetHangingDownloads();
+	}
+	debug("QueueCoordinator: Downloads are completed");
+
+	debug("Exiting QueueCoordinator-loop");
+}
+
+void QueueCoordinator::AddNZBFileToQueue(NZBFile* pNZBFile, bool bAddFirst)
+{
+	debug("Adding NZBFile to queue");
+
+	m_mutexDownloadQueue.Lock();
+
+	DownloadQueue tmpDownloadQueue;
+
+	for (NZBFile::FileInfos::iterator it = pNZBFile->GetFileInfos()->begin(); it != pNZBFile->GetFileInfos()->end(); it++)
+	{
+		FileInfo* pFileInfo = *it;
+		pFileInfo->BuildDestDirName(pNZBFile->GetFileName());
+		if (g_pOptions->GetDupeCheck() && IsDupe(pFileInfo))
+		{
+			warn("File \"%s\" seems to be duplicate, skipping", pFileInfo->GetFilename());
+		}
+		else
+		{
+			if (bAddFirst)
+			{
+				tmpDownloadQueue.push_front(pFileInfo);
+			}
+			else
+			{
+				m_DownloadQueue.push_back(pFileInfo);
+			}
+		}
+	}
+
+	if (bAddFirst)
+	{
+		for (DownloadQueue::iterator it = tmpDownloadQueue.begin(); it != tmpDownloadQueue.end(); it++)
+		{
+			m_DownloadQueue.push_front(*it);
+		}
+	}
+
+	pNZBFile->DetachFileInfos();
+
+	Aspect aspect = { eaNZBFileAdded, NULL, &m_DownloadQueue, pNZBFile->GetFileName() };
+	Notify(&aspect);
+	
+	if (g_pOptions->GetSaveQueue() && g_pOptions->GetServerMode())
+	{
+		m_DiskState.Save(&m_DownloadQueue, false);
+	}
+
+	m_mutexDownloadQueue.Unlock();
+}
+
+bool QueueCoordinator::AddFileToQueue(const char* szFileName)
+{
+	// Parse the buffer and make it into a NZBFile
+	NZBFile* pNZBFile = NZBFile::CreateFromFile(szFileName);
+
+	// Did file parse correctly?
+	if (!pNZBFile)
+	{
+		return false;
+	}
+
+	// Add NZBFile to Qeue
+	AddNZBFileToQueue(pNZBFile, false);
+
+	delete pNZBFile;
+
+	return true;
+}
+
+float QueueCoordinator::CalcCurrentDownloadSpeed()
+{
+	float fSpeedAllDownloads = 0;
+
+	m_mutexDownloadQueue.Lock();
+
+	struct _timeval curtime; 
+	gettimeofday(&curtime, 0);
+
+	for (ActiveDownloads::iterator it = m_ActiveDownloads.begin(); it != m_ActiveDownloads.end(); it++)
+	{
+		ArticleDownloader* pArticleDownloader = *it;
+
+		float fSpeed = 0.0f;
+		struct _timeval* arttime = pArticleDownloader->GetStartTime();
+
+#ifdef WIN32
+		if (arttime->time != 0)
+#else
+		if (arttime->tv_sec != 0)
+#endif
+		{
+#ifdef WIN32
+			float tdiff = (float)((curtime.time - arttime->time) + (curtime.millitm - arttime->millitm) / 1000.0);
+#else
+			float tdiff = (float)((curtime.tv_sec - arttime->tv_sec) + (curtime.tv_usec - arttime->tv_usec) / 1000000.0);
+#endif
+			if (tdiff > 0)
+			{
+				fSpeed = (pArticleDownloader->GetBytes() / tdiff / 1024);
+			}
+		}
+
+		fSpeedAllDownloads += fSpeed;
+	}
+
+	m_mutexDownloadQueue.Unlock();
+
+	return fSpeedAllDownloads;
+}
+
+long long QueueCoordinator::CalcRemainingSize()
+{
+	long long lRemainingSize = 0;
+
+	m_mutexDownloadQueue.Lock();
+	for (DownloadQueue::iterator it = m_DownloadQueue.begin(); it != m_DownloadQueue.end(); it++)
+	{
+		FileInfo* pFileInfo = *it;
+		if (!pFileInfo->GetPaused() && !pFileInfo->GetDeleted())
+		{
+			lRemainingSize += pFileInfo->GetRemainingSize();
+		}
+	}
+	m_mutexDownloadQueue.Unlock();
+
+	return lRemainingSize;
+}
+
+int QueueCoordinator::GetFileInfoID(unsigned int iEntry)
+{
+	int ID = 0;
+	m_mutexDownloadQueue.Lock();
+
+	if (iEntry < m_DownloadQueue.size())
+	{
+		ID = m_DownloadQueue[iEntry]->GetID();
+	}
+
+	m_mutexDownloadQueue.Unlock();
+	return ID;
+}
+
+FileInfo* QueueCoordinator::FindFileInfo(int iID)
+{
+	for (DownloadQueue::iterator it = m_DownloadQueue.begin(); it != m_DownloadQueue.end(); it++)
+	{
+		FileInfo* pFileInfo = *it;
+		if (pFileInfo->GetID() == iID)
+		{
+			return pFileInfo;
+		}
+	}
+	return NULL;
+}
+
+int QueueCoordinator::GetFileInfoEntry(int iID)
+{
+	int iEntry = 0;
+	for (DownloadQueue::iterator it = m_DownloadQueue.begin(); it != m_DownloadQueue.end(); it++)
+	{
+		FileInfo* pFileInfo = *it;
+		if (pFileInfo->GetID() == iID)
+		{
+			return iEntry;
+		}
+		iEntry ++;
+	}
+	return -1;
+}
+
+/*
+ * Set the pause flag of the specific entry in the queue
+ * returns true if successful, false if operation is not possible
+ */
+bool QueueCoordinator::EditQueuePauseUnpauseEntry(int iID, bool bPause)
+{
+	bool res = false;
+	m_mutexDownloadQueue.Lock();
+
+	FileInfo* pFileInfo = FindFileInfo(iID);
+
+	if (pFileInfo)
+	{
+		pFileInfo->SetPaused(bPause);
+		res = true;
+	}
+
+	if (g_pOptions->GetSaveQueue() && g_pOptions->GetServerMode())
+	{
+		m_DiskState.Save(&m_DownloadQueue, true);
+	}
+
+	m_mutexDownloadQueue.Unlock();
+	return res;
+}
+
+/*
+ * Removes entry with index iEntry
+ * returns true if successful, false if operation is not possible
+ */
+bool QueueCoordinator::EditQueueDeleteEntry(int iID)
+{
+	debug("Deleting queue entry");
+
+	bool res = false;
+	m_mutexDownloadQueue.Lock();
+
+	FileInfo* pFileInfo = FindFileInfo(iID);
+	if (pFileInfo)
+	{
+		info("Deleting file %s from download queue", pFileInfo->GetFilename());
+		pFileInfo->SetDeleted(true);
+		bool hasDownloads = false;
+		for (ActiveDownloads::iterator it = m_ActiveDownloads.begin(); it != m_ActiveDownloads.end(); it++)
+		{
+			ArticleDownloader* pArticleDownloader = *it;
+			if (pArticleDownloader->GetFileInfo() == pFileInfo)
+			{
+				hasDownloads = true;
+				pArticleDownloader->Stop();
+			}
+		}
+		if (!hasDownloads)
+		{
+			DeleteFileInfo(pFileInfo);
+		}
+		res = true;
+	}
+
+	m_mutexDownloadQueue.Unlock();
+
+	debug("Queue entry deleted");
+
+	return res;
+}
+
+/*
+ * Moves entry identified with iID in the queue
+ * returns true if successful, false if operation is not possible
+ */
+bool QueueCoordinator::EditQueueMoveEntry(int iID, int iOffset, bool bAutoCorrection)
+{
+	bool res = false;
+	m_mutexDownloadQueue.Lock();
+
+	int iEntry = GetFileInfoEntry(iID);
+	if (iEntry >= 0)
+	{
+		int iNewEntry = iEntry + iOffset;
+
+		if (bAutoCorrection && iNewEntry < 0)
+		{
+			iNewEntry = 0;
+		}
+		if (bAutoCorrection && (unsigned int)iNewEntry > m_DownloadQueue.size() - 1)
+		{
+			iNewEntry = (int)m_DownloadQueue.size() - 1;
+		}
+
+		if (iNewEntry >= 0 && (unsigned int)iNewEntry <= m_DownloadQueue.size() - 1)
+		{
+			FileInfo* fi =  m_DownloadQueue[iEntry];
+			m_DownloadQueue.erase(m_DownloadQueue.begin() + iEntry);
+			m_DownloadQueue.insert(m_DownloadQueue.begin() + iNewEntry, fi);
+			res = true;
+		}
+	}
+
+	if (g_pOptions->GetSaveQueue() && g_pOptions->GetServerMode())
+	{
+		m_DiskState.Save(&m_DownloadQueue, true);
+	}
+
+	m_mutexDownloadQueue.Unlock();
+	return res;
+}
+
+void QueueCoordinator::Stop()
+{
+	Thread::Stop();
+
+	debug("Stopping ArticleDownloads");
+	m_mutexDownloadQueue.Lock();
+	for (ActiveDownloads::iterator it = m_ActiveDownloads.begin(); it != m_ActiveDownloads.end(); it++)
+	{
+		(*it)->Stop();
+	}
+	m_mutexDownloadQueue.Unlock();
+	debug("ArticleDownloads are notified");
+}
+
+bool QueueCoordinator::GetNextArticle(FileInfo* &pFileInfo, ArticleInfo* &pArticleInfo)
+{
+	//debug("QueueCoordinator::GetNextArticle()");
+
+	for (DownloadQueue::iterator it = m_DownloadQueue.begin(); it != m_DownloadQueue.end(); it++)
+	{
+		pFileInfo = *it;
+		if (!pFileInfo->GetPaused() && !pFileInfo->GetDeleted())
+		{
+			for (FileInfo::Articles::iterator at = pFileInfo->GetArticles()->begin(); at != pFileInfo->GetArticles()->end(); at++)
+			{
+				pArticleInfo = *at;
+				if (pArticleInfo->GetStatus() == 0)
+				{
+					return true;
+				}
+			}
+		}
+	}
+
+	return false;
+}
+
+void QueueCoordinator::StartArticleDownload(FileInfo* pFileInfo, ArticleInfo* pArticleInfo)
+{
+	debug("Starting new ArticleDownloader");
+
+	ArticleDownloader* pArticleDownloader = new ArticleDownloader();
+	pArticleDownloader->SetAutoDestroy(true);
+	pArticleDownloader->Attach(this);
+	pArticleDownloader->SetFileInfo(pFileInfo);
+	pArticleDownloader->SetArticleInfo(pArticleInfo);
+	BuildArticleFilename(pArticleDownloader, pFileInfo, pArticleInfo);
+
+	pArticleInfo->SetStatus(ArticleInfo::aiRunning);
+
+	m_ActiveDownloads.push_back(pArticleDownloader);
+	pArticleDownloader->Start();
+	pArticleDownloader->WaitInit();
+}
+
+void QueueCoordinator::BuildArticleFilename(ArticleDownloader* pArticleDownloader, FileInfo* pFileInfo, ArticleInfo* pArticleInfo)
+{
+	char name[1024];
+	
+	snprintf(name, 1024, "%s%i.%03i", g_pOptions->GetTempDir(), pFileInfo->GetID(), pArticleInfo->GetPartNumber());
+	name[1024-1] = '\0';
+	pArticleInfo->SetResultFilename(name);
+	
+	char tmpname[1024];
+	snprintf(tmpname, 1024, "%s.tmp", name);
+	tmpname[1024-1] = '\0';
+	pArticleDownloader->SetTempFilename(tmpname);
+
+	char szNZBNiceName[1024];
+	pFileInfo->GetNiceNZBName(szNZBNiceName, 1024);
+	
+	snprintf(name, 1024, "%s%c%s [%i/%i]", szNZBNiceName, (int)PATH_SEPARATOR, pFileInfo->GetFilename(), pArticleInfo->GetPartNumber(), pFileInfo->GetArticles()->size());
+	name[1024-1] = '\0';
+	pArticleDownloader->SetInfoName(name);
+}
+
+DownloadQueue* QueueCoordinator::LockQueue()
+{
+	m_mutexDownloadQueue.Lock();
+	return &m_DownloadQueue;
+}
+
+void QueueCoordinator::UnlockQueue()
+{
+	m_mutexDownloadQueue.Unlock();
+}
+
+void QueueCoordinator::Update(Subject* Caller, void* Aspect)
+{
+	debug("Notification from ArticleDownloader received");
+
+	ArticleDownloader* pArticleDownloader = (ArticleDownloader*) Caller;
+	if ((pArticleDownloader->GetStatus() == ArticleDownloader::adFinished) ||
+	        (pArticleDownloader->GetStatus() == ArticleDownloader::adFailed))
+	{
+		ArticleCompleted(pArticleDownloader);
+	}
+}
+
+void QueueCoordinator::ArticleCompleted(ArticleDownloader* pArticleDownloader)
+{
+	debug("Article downloaded");
+
+	FileInfo* pFileInfo = pArticleDownloader->GetFileInfo();
+	ArticleInfo* pArticleInfo = pArticleDownloader->GetArticleInfo();
+
+	m_mutexDownloadQueue.Lock();
+
+	if (pArticleDownloader->GetStatus() == ArticleDownloader::adFinished)
+	{
+		pArticleInfo->SetStatus(ArticleInfo::aiFinished);
+	}
+	else if (pArticleDownloader->GetStatus() == ArticleDownloader::adFailed)
+	{
+		pArticleInfo->SetStatus(ArticleInfo::aiFailed);
+	}
+
+	pFileInfo->SetRemainingSize(pFileInfo->GetRemainingSize() - pArticleInfo->GetSize());
+	pFileInfo->SetCompleted(pFileInfo->GetCompleted() + 1);
+	bool fileCompleted = (int)pFileInfo->GetArticles()->size() == pFileInfo->GetCompleted();
+
+	if (!pFileInfo->GetFilenameConfirmed() &&
+	        pArticleDownloader->GetStatus() == ArticleDownloader::adFinished &&
+	        pArticleDownloader->GetArticleFilename())
+	{
+		pFileInfo->SetFilename(pArticleDownloader->GetArticleFilename());
+		pFileInfo->SetFilenameConfirmed(true);
+	}
+
+	m_mutexDownloadQueue.Unlock();
+
+	bool deleteFileObj = false;
+
+	if (fileCompleted && !IsStopped() && !pFileInfo->GetDeleted())
+	{
+		// all jobs done
+		pArticleDownloader->CompleteFileParts();
+		deleteFileObj = true;
+	}
+	else if (pFileInfo->GetDeleted())
+	{
+		m_mutexDownloadQueue.Lock();
+		int cnt = 0;
+		for (ActiveDownloads::iterator it = m_ActiveDownloads.begin(); it != m_ActiveDownloads.end(); it++)
+		{
+			if ((*it)->GetFileInfo() == pFileInfo)
+			{
+				cnt++;
+			}
+		}
+		m_mutexDownloadQueue.Unlock();
+		if (cnt == 1)
+		{
+			// this was the last Download for a file deleted from queue
+			deleteFileObj = true;
+		}
+	}
+
+	// delete Download from Queue
+	m_mutexDownloadQueue.Lock();
+	for (ActiveDownloads::iterator it = m_ActiveDownloads.begin(); it != m_ActiveDownloads.end(); it++)
+	{
+		ArticleDownloader* pa = *it;
+		if (pa == pArticleDownloader)
+		{
+			m_ActiveDownloads.erase(it);
+			break;
+		}
+	}
+	if (deleteFileObj)
+	{
+		// delete File from Queue
+		pFileInfo->SetDeleted(true);
+
+		Aspect aspect = { fileCompleted ? eaFileCompleted : eaFileDeleted, pFileInfo, &m_DownloadQueue, NULL };
+		Notify(&aspect);
+		
+		DeleteFileInfo(pFileInfo);
+	}
+	m_mutexDownloadQueue.Unlock();
+}
+
+void QueueCoordinator::DeleteFileInfo(FileInfo* pFileInfo)
+{
+	for (DownloadQueue::iterator it = m_DownloadQueue.begin(); it != m_DownloadQueue.end(); it++)
+	{
+		FileInfo* pa = *it;
+		if (pa == pFileInfo)
+		{
+			m_DownloadQueue.erase(it);
+			break;
+		}
+	}
+
+	if (g_pOptions->GetSaveQueue() && g_pOptions->GetServerMode())
+	{
+		m_DiskState.DiscardFileInfo(&m_DownloadQueue, pFileInfo);
+	}
+
+	delete pFileInfo;
+}
+
+bool QueueCoordinator::IsDupe(FileInfo* pFileInfo)
+{
+	debug("Checking if the file is already queued");
+
+	if (pFileInfo->IsDupe())
+	{
+		return true;
+	}
+
+	for (DownloadQueue::iterator it = m_DownloadQueue.begin(); it != m_DownloadQueue.end(); it++)
+	{
+		FileInfo* pQueueEntry = *it;
+		if (!strcmp(pFileInfo->GetDestDir(), pQueueEntry->GetDestDir()) &&
+		        !strcmp(pFileInfo->GetFilename(), pQueueEntry->GetFilename()))
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
+void QueueCoordinator::LogDebugInfo()
+{
+	debug("--------------------------------------------");
+	debug("Dumping debug info to log");
+	debug("--------------------------------------------");
+
+	debug("   QueueCoordinator");
+	debug("   ----------------");
+
+	m_mutexDownloadQueue.Lock();
+	debug("    Active Downloads: %i", m_ActiveDownloads.size());
+	for (ActiveDownloads::iterator it = m_ActiveDownloads.begin(); it != m_ActiveDownloads.end(); it++)
+	{
+		ArticleDownloader* pArticleDownloader = *it;
+		pArticleDownloader->LogDebugInfo();
+	}
+	m_mutexDownloadQueue.Unlock();
+
+	debug("");
+
+	g_pServerPool->LogDebugInfo();
+}
+
+void QueueCoordinator::ResetHangingDownloads()
+{
+	const int TimeOut = g_pOptions->GetTerminateTimeout();
+	if (TimeOut == 0)
+	{
+		return;
+	}
+
+	m_mutexDownloadQueue.Lock();
+	time_t tm = ::time(NULL);
+
+	for (ActiveDownloads::iterator it = m_ActiveDownloads.begin(); it != m_ActiveDownloads.end();)
+	{
+		ArticleDownloader* pArticleDownloader = *it;
+		if (tm - pArticleDownloader->GetLastUpdateTime() > TimeOut &&
+		   pArticleDownloader->GetStatus() == ArticleDownloader::adRunning)
+		{
+			ArticleInfo* pArticleInfo = pArticleDownloader->GetArticleInfo();
+			debug("Terminating hanging download %s", pArticleDownloader->GetInfoName());
+			if (pArticleDownloader->Terminate())
+			{
+				error("Terminated hanging download %s", pArticleDownloader->GetInfoName());
+				pArticleInfo->SetStatus(ArticleInfo::aiUndefined);
+			}
+			else
+			{
+				error("Could not terminate hanging download %s", BaseFileName(pArticleInfo->GetResultFilename()));
+			}
+			m_ActiveDownloads.erase(it);
+			// it's not safe to destroy pArticleDownloader, because the state of object is unknown
+			delete pArticleDownloader;
+			it = m_ActiveDownloads.begin();
+			continue;
+		}
+		it++;
+	}                                              
+
+	m_mutexDownloadQueue.Unlock();
+}

QueueCoordinator.h

@@ -0,0 +1,98 @@
+/*
+ *  This file if part of nzbget
+ *
+ *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifndef QUEUECOORDINATOR_H
+#define QUEUECOORDINATOR_H
+
+#include <deque>
+#include <list>
+
+#include "Thread.h"
+#include "NZBFile.h"
+#include "ArticleDownloader.h"
+#include "DownloadInfo.h"
+#include "Observer.h"
+#include "DiskState.h"
+                                            
+class QueueCoordinator : public Thread, public Observer, public Subject, public DownloadSpeedMeter
+{
+public:
+	typedef std::list<ArticleDownloader*>	ActiveDownloads;
+	typedef enum EAspectAction
+	{
+		eaNZBFileAdded,
+		eaFileCompleted,
+		eaFileDeleted
+	};
+	typedef struct Aspect
+	{
+		EAspectAction eAction;
+		FileInfo* pFileInfo;
+		DownloadQueue* pDownloadQueue;
+		const char* szNZBFilename;
+	};
+
+private:
+	DownloadQueue			m_DownloadQueue;
+	ActiveDownloads			m_ActiveDownloads;
+	DiskState				m_DiskState;
+	Mutex			 		m_mutexDownloadQueue;
+	bool					m_bHasMoreJobs;
+
+	bool					GetNextArticle(FileInfo* &pFileInfo, ArticleInfo* &pArticleInfo);
+	void					StartArticleDownload(FileInfo* pFileInfo, ArticleInfo* pArticleInfo);
+	void					BuildArticleFilename(ArticleDownloader* pArticleDownloader, FileInfo* pFileInfo, ArticleInfo* pArticleInfo);
+	bool					IsDupe(FileInfo* pFileInfo);
+	void					ArticleCompleted(ArticleDownloader* pArticleDownloader);
+	FileInfo*				FindFileInfo(int iID);
+	int						GetFileInfoEntry(int iID);
+	void					DeleteFileInfo(FileInfo* pFileInfo);
+	void					ResetHangingDownloads();
+
+public:
+							QueueCoordinator();                
+	virtual					~QueueCoordinator();
+	virtual void			Run();
+	virtual void 			Stop();
+	long long 				CalcRemainingSize();                      
+	virtual float			CalcCurrentDownloadSpeed();
+	void					Update(Subject* Caller, void* Aspect);
+
+	// Editing the queue
+	DownloadQueue*			LockQueue();
+	void					UnlockQueue() ;
+	void					AddNZBFileToQueue(NZBFile* pNZBQueue, bool bAddFirst);
+	bool					AddFileToQueue(const char* szFileName);
+	bool					EditQueuePauseUnpauseEntry(int iID, bool bPause);
+	bool					EditQueueDeleteEntry(int iID);
+	bool					EditQueueMoveEntry(int iID, int iOffset, bool bAutoCorrection);
+	int						GetFileInfoID(unsigned int iEntry);
+	bool					HasMoreJobs() { return m_bHasMoreJobs; }
+	
+	void					LogDebugInfo();
+};
+
+#endif

README

@@ -2,10 +2,6 @@
            NZBGet ReadMe
 =====================================
 
-This is a short documentation. For more information please
-visit NZBGet home page at 
-  http://nzbget.net
-
 Contents          
 --------
 1. About NZBGet
@@ -33,36 +29,33 @@ In server/client mode NZBGet runs as server in background.
 Then you use client to send requests to server. The sample requests
 are: download nzb-file, list files in queue, etc.
 
-There is also a built-in web-interface. The server has RPC-support
-and can be controlled from third party applications too.
-
 Standalone-tool, server and client are all contained in only one 
-executable file "nzbget". The mode in which the program works 
+executable file "NZBGet". The mode in which the program works 
 depends on command-line parameters passed to the program.
 
 =====================================
 2. Supported OS
 =====================================
 
-NZBGet is written in C++ and was initialy developed on Linux.
+NZBGet is written in C++ and was initialy developen on Linux.
 It was ported to Windows later and tested for compatibility with
 several POSIX-OS'es.
 
-It should run at least on:
-  - Linux Debian 5.0 on x86;
-  - Linux with uClibc on MIPSEL and ARM;
-  - OpenBSD 5.0 on x86;
-  - Mac OS X 10.7 Lion on x64;
-  - Windows XP SP3 on x86 and Windows 7 on x64.
+The current version (0.3.0) should run at least on: 
+
+  - Linux Debian 3.1 on x86;
+  - Linux BusyBox with uClibc on MIPSEL;
+  - PC-BSD 1.4 (based on FreeBSD 6.2) on x86;
+  - Solaris 10 on x86;
+  - Windows XP SP2 on x86.
 
 Clients and servers running on different OS'es may communicate with
 each other. For example, you can use NZBGet as client on Windows to 
 control your NZBGet-server running on Linux.
 
 The download-section of NZBGet web-site provides binary files
-for Windows. The binary packages for many routers and NAS devices are 
-also available in OPTWARE repository (http://www.nslu2-linux.org), 
-but for most POSIX-systems you need to compile the program yourself. 
+for few platforms (including Windows), but for most POSIX-systems
+you need to compile the program yourself.
 
 If you have downloaded binaries you can just jump to section 
 "Configuration".
@@ -72,7 +65,8 @@ If you have downloaded binaries you can just jump to section
 =====================================
 
 NZBGet is developed on a linux-system, but it should run on other
-POSIX platforms (see the list of tested platforms above).
+POSIX platforms (tested on FreeBSD and Solaris for x86; although
+the par-support and uulib were not tested).
 
 NZBGet absolutely needs the following libraries:
 
@@ -81,100 +75,124 @@ NZBGet absolutely needs the following libraries:
 
 And the following libraries are optional:
 
- - for curses-output-mode (enabled by default):
+ - for curses-output-mode:
    - libcurses   (usually part of commercial systems)
      or (better)
    - libncurses  (http://invisible-island.net/ncurses)
    
- - for par-check and -repair (enabled by default):
-   - libpar2     (http://launchpad.net/libpar2,
-                  http://parchive.sourceforge.net)
+ - for par-check and -repair:
+   - libpar2     (http://parchive.sourceforge.net)
    - libsigc++   (http://libsigc.sourceforge.net)
- 
- - for encrypted connections (TLS/SSL):
-   - OpenSSL     (http://www.openssl.org)
-     or
-   - GnuTLS      (http://www.gnu.org/software/gnutls)
 
- - for gzip support in web-server and web-client (enabled by default):
-   - zlib     (http://www.zlib.net)
+ - for support of encoding-formats other than yEnc:
+   - libuu       (http://www.fpx.de/fp/Software/UUDeview)
 
 All these libraries are included in modern Linux distributions and
-should be available as installable packages. Please note that you also 
-need the developer packages for these libraries too, they package names 
-have often suffix "dev" or "devel". On other systems you may need to 
-download the libraries at the given URLs and compile them (see hints below).
+should be available as installable packages. On other systems you
+may need to download the libraries at the given URLs and compile
+them (see hints below).
 
 =====================================
 4. Installation on POSIX
 =====================================
 
-Installation from the source distribution archive (nzbget-VERSION.tar.gz):
+Well, the usual stuff:
 
  - untar the nzbget-source via
      tar -zxf nzbget-VERSION.tar.gz
-
  - change into nzbget-directory via
      cd nzbget-VERSION
-
  - configure it via
      ./configure
-
    (maybe you have to tell configure, where to find some libraries.
-       ./configure --help is your friend!
-    also see "Configure-options" later)
-
- - in a case you don't have root access or want to install the program
-   in your home directory use the configure parameter --prefix, e. g.:
-
-  ./configure --prefix ~/usr
-
+       ./configure --help is your friend! ;-)
+    also see "Configure-options" later.)
  - compile it via
      make
-
- - to install system wide become root via:
+   (you may get some warnings concerning 'mktemp', simply ignore them!)
+ - become root via
      su
-
- - install it via:
+ - install it via
      make install
 
- - install configuration files into <prefix>/etc via:
-     make install-conf
-
-   (you can skip this step if you intend to store configuration
-    files in a non-standard location)
-
 Configure-options
 -----------------
 You may run configure with additional arguments:
 
+  --enable-uulib - to make with uulib-library, in a case you want it
+    (see later section "Optional package: uulib"). This option is not
+    enabled by default.
+    
   --disable-curses - to make without curses-support. Use this option
     if you can not use curses/ncurses.
     
   --disable-parcheck - to make without parcheck-support. Use this option
     if you can not use libpar2 or libsigc++.
-
-  --with-tlslib=(OpenSSL, GnuTLS) - to select which TLS/SSL library
-    should be used for encrypted server connections.
-      
-  --disable-tls - to make without TLS/SSL support. Use this option if
-    you can not neither OpenSSL nor GnuTLS.
-
-  --disable-gzip - to make without gzip support. Use this option
-    if you can not use zlib.
        
+  --disable-parprogress - to not show progress during par-check. This option
+    may be needed on some systems, where sigc++ does not work very well
+    (uClibc on MIPSEL is one of them). If par-check segfaults right after
+    start, then you probably need this option.
+    
   --enable-debug - to build in debug-mode, if you want to see and log
     debug-messages.
-    
+
+Optional package: uulib
+-----------------------
+uulib is not required to compile and run nzbget, because nzbget includes
+internal decoder for yEnc-format. However, uulib supports many other formats,
+you may possibly want to have support for. In this case you can build the
+program with uulib-support enabled.
+
+NOTE: enabling uulib does not disable internal decoder. The program built with
+uulib-support can use both decoders (internal and uulib), depending on option
+"decoder" in program's configuration file.
+
+To build with uulib use option "--enable-uulib" while running configure:
+  
+  ./configure --enable-uulib
+
+The uulib must be installed on your system. On most linux distributions 
+the package uulib-dev is available. So you only need to install this package
+and run configure with parameter "--enable-uulib".
+If you do not have this package you can compile uulib yourself:
+  
+  - download source code of uudeview from 
+    http://www.fpx.de/fp/Software/UUDeview;
+  - build uudeview as usually:
+      /.confugure
+      make
+  - start nzbget's configure-script with following parameters:
+      ./configure --enable-uulib \
+         --with-uulib-includes=<path to uudeview>/uulib \
+         --with-uulib-libraries=<path to uudeview>/uulib
+    for example:
+      ./configure --enable-uulib \
+         --with-uulib-includes=/home/user/uudeview-0.5.20/uulib \
+         --with-uulib-libraries=/home/user/uudeview-0.5.20/uulib
+  - now you can compile nzbget.
+
+NOTE: after nzbget is compiled, the code of uulib-library is built into
+nzbget's executable. You do not need to have uulib on target system
+to run nzbget.
+
 Optional package: par-check
 ---------------------------
 NZBGet can check and repair downloaded files for you. For this purpose
 it uses library par2 (libpar2), which needs sigc++ on its part.
 
+To build with par-check use option "--enable-parcheck" while running 
+configure:
+  
+  ./configure --enable-parcheck
+
 The libpar2 and libsigc++ (version 2 or later) must be installed on your
 system. On most linux distributions these libraries are available as packages.
-If you do not have these packages you can compile them yourself. 
-Following configure-parameters may be usefull:
+So you only need to install theme and run configure with parameter
+"--enable-parcheck".
+If you do not have these package you can compile them yourself. Please
+refer to section "Optional package: uulib" for an example on how to
+compile additional library. Following configure-parameters may be usefull:
 
   --with-libpar2-includes
   --with-libpar2-libraries
@@ -183,28 +201,12 @@ Following configure-parameters may be usefull:
   
 The library libsigc++ must be installed first, since libpar2 requires it.
 
-Official project libpar2 (http://parchive.sourceforge.net) has not been
-updated for many years. The last official version of libpar 0.2 contains
-known bugs which may crash the program during par-check. These bugs
-have been fixed in the semi-official fork maintained by Debian/Ubuntu
-team (http://launchpad.net/libpar2). It is highly recommended to use this
-version of libpar2 (version 0.4 or newer) instead of the last official
-version 0.2. Recent releases of Debian/Ubuntu include this libpar2 version.
-
-NZBGets configure script checks the installed version of libpar2 and prints
-an error if it is older than 0.4. The check can be suppressed if the update
-of libpar2 is not possible.
-
-If you are not able to use libpar2 or libsigc++ or do not want them you can
-make nzbget without support for par-check using option "--disable-parcheck":
-
-  ./configure --disable-parcheck
-
 Optional package: curses
 -------------------------
 For curses-outputmode you need ncurses or curses on your system.
 If you do not have one of them you can download and compile ncurses yourself.
-Following configure-parameters may be usefull:
+Please refer to section "Optional package: uulib" for an example on how to
+compile additional library. Following configure-parameters may be usefull:
 
   --with-libcurses-includes
   --with-libcurses-libraries
@@ -214,29 +216,6 @@ make the program without support for curses using option "--disable-curses":
 
   ./configure --disable-curses
 
-Optional package: TLS
--------------------------
-To enable encrypted server connections (TLS/SSL) you need to build the program
-with TLS/SSL support. NZBGet can use two libraries: OpenSSL or GnuTLS.
-Configure-script checks which library is installed and use it. If both are
-available it gives the precedence to OpenSSL. You may override that with
-the option --with-tlslib=(OpenSSL, GnuTLS). For example to build with GnuTLS:
-
-  ./configure --with-tlslib= GnuTLS
-  
-Following configure-parameters may be useful:
-
-  --with-libtls-includes
-  --with-libtls-libraries
-
-  --with-openssl-includes
-  --with-openssl-libraries
-
-If none of these libraries is available you can make the program without 
-TLS/SSL support using option "--disable-tls":
-
-  ./configure --disable-tls
-  
 =====================================
 5. Compiling on Windows
 =====================================
@@ -249,45 +228,32 @@ To compile the program with par-check-support you also need the following
 libraries:
 
    - libsigc++   (http://libsigc.sourceforge.net)
-   - libpar2     (http://launchpad.net/libpar2,
-                  http://parchive.sourceforge.net)
-
+   - libpar2     (http://parchive.sourceforge.net)
+   
 Download these libaries, then use patch-files provided with NZBGet to create
 preconfigured project files and solutions for each library. 
 Look at http://gnuwin32.sourceforge.net/packages/patch.htm for info on how
 to use patch-files, if you do not familiar with this technique.
 
-To compile the program with TLS/SSL support you also need the library:
-
-   - OpenSSL  (http://www.openssl.org)
-   or
-   - GnuTLS   (http://www.gnu.org/software/gnutls)
+After libsigc++ and libpar2 are compiled in static libraries (.lib) 
+and include- and libraries-paths are configured in MS Visual C++ 2005 you
+should be able to compile NZBGet.   
 
 =====================================
 6. Configuration
 =====================================
 
-NZBGet needs a configuration file. 
+NZBGet needs a configuration-file to work properly. 
 
-An example configuration file is provided in "nzbget.conf", which
-is installed into "<prefix>/share/nzbget" (where <prefix> depends on
-system configuration and configure options - typically "/usr/local",
-"/usr" or "/opt"). The installer adjusts the file according to your
-system paths. If you have performed the installation step 
-"make install-conf" this file is already copied to "<prefix>/etc" and
-NZBGet finds it automatically. If you install the program manually
-from a binary archive you have to copy the file from "<prefix>/share/nzbget"
-to one of the locations listed below.
-
-Open the file in a text editor and modify it accodring to your needs.
-
-You need to set at least the option "MAINDIR" and one news server in
-configuration file. The file has comments on how to use each option.
+You need to set at least the option "MAINDIR" and one newsserver in
+configuration file. Have a look at the example in nzbget.conf.example, 
+it has comments on how to use each option.
 
 The program looks for configuration file in following standard 
 locations (in this order):
 
 On POSIX systems:
+
   ~/.nzbget
   /etc/nzbget.conf
   /usr/etc/nzbget.conf
@@ -311,12 +277,6 @@ options via command-line.
 NZBGet can be used in either standalone mode which downloads a single file 
 or as a server which is able to queue up numerous download requests.
 
-TIP for Windows users: NZBGet is controlled via various command line
-parameters. For easier using there is a simple shell script included
-in "nzbget-shell.bat". Start this script from Windows Explorer and you will
-be running a command shell with PATH adjusted to find NZBGet executable.
-Then you can type all commands without full path to nzbget.exe.
-
 Standalone mode:
 ----------------
 
@@ -344,70 +304,41 @@ To stop server use:
 
   nzbget -Q  
 
-TIP for POSIX users: with included script "nzbgetd" you can use standard
-commands to control daemon:
-
-  nzbgetd start
-  nzbgetd stop
-  etc.
-
-When NZBGet is started in console server mode it displays a message that
-it is ready to receive download requests. In daemon mode it doesn't print any
-messages to console since it runs in background.
+Depending on which frontend has been selected in the nzbget.conf file
+(option "outputmode") the server should display a message that
+it is ready to receive download requests (this applies only to console
+mode, not to daemon mode).
 
 When the server is running it is possible to queue up downloads. This can be
 done either in terminal with "nzbget -A <nzb-file>" or by uploading
-a nzb-file into server's monitor-directory (<MAINDIR>/nzb by default).
+a nzb-file into server's monitor-directory (<MAINDIR>/nzb by default, the
+directory must exist on server's start; otherwise it will not be monitored).
 
 To check the status of server start client and connect it to server:
   
   nzbget -C
 
-The client have three different (display) outputmodes, which you can select
-in configuration file (on client computer) or in command line. Try them:
-
-  nzbget -o outputmode=log -C
-
-  nzbget -o outputmode=color -C
-
-  nzbget -o outputmode=curses -C
-
 To list files in server's queue:
 
   nzbget -L
   
 It prints something like:
 
-  [1] nzbname\filename1.rar (50.00 MB)
-  [2] nzbname\filename1.r01 (50.00 MB)
-  [3] another-nzb\filename3.r01 (100.00 MB)
-  [4] another-nzb\filename3.r02 (100.00 MB)
+  [1] nzbname\filename1.rar (50.00 MB)
+  [2] nzbname\filename1.r01 (50.00 MB)
 
-This is the list of individual files listed within nzb-file. To print
-the list of nzb-files (without content) add G-modifier to the list command:
+The numbers in square braces are ID's of files in queue. They can be used
+in edit-command. For example to move file with ID 2 to the top of queue:
 
-  [1] nzbname (4.56 GB)
-  [2] another-nzb (4.20 GB)
-
-The numbers in square braces are ID's of files or groups in queue.
-They can be used in edit-command. For example to move file with
-ID 2 to the top of queue:
-
-  nzbget -E T 2
+  nzbget -E T -I 2
   
 or to pause files with IDs from 10 to 20:
 
-  nzbget -E P 10-20
+  nzbget -E P -I 10-20
 
-or to delete files from queue:
+or to delete file from queue:
 
-  nzbget -E D 3 10-15 20-21 16
-
-The edit-command has also a group-mode which affects all files from the
-same nzb-file. You need to pass an ID of the group. For example to delete
-the whole group 1:
-
-  nzbget -E G D 1
+  nzbget -E D -I 3
 
 The switch "o" is useful to override options in configuration files. 
 For example:
@@ -424,7 +355,7 @@ Running client & server on seperate machines:
 Since nzbget communicates via TCP/IP it's possible to have a server running on
 one computer and adding downloads via a client on another computer.
 
-Do this by setting the "ControlIP" option in the nzbget.conf file to point to the
+Do this by setting the "serverip" option in the nzbget.conf file to point to the
 IP of the server (default is localhost which means client and server runs on 
 same computer)
 
@@ -440,83 +371,36 @@ If you need to control server from WAN it is better to connect to server's
 terminal via SSH (POSIX) or remote desktop (Windows) and then run
 nzbget-client-commands in this terminal.
 
-Post processing scripts
------------------------
-
-After the download of nzb-file is completed nzbget can call post-processing
-scripts, defined in configuration file.
-
-Example post-processing scripts are provided in directory "scripts".
-
-To use the scripts copy them into your local directory and set options
-<ScriptDir>, <PostScript> and <ScriptOrder>.
-
-For information on writing your own post-processing scripts please
-visit NZBGet web site.
-
-Web-interface
--------------
-
-NZBGet has a built-in web-server providing the access to the program
-functions via web-interface.
-
-To activate web-interface set the option "WebDir" to the path with
-web-interface files. If you install using "make install-conf" as
-described above the option is set automatically. If you install using
-binary files you should check if the option is set correctly.
-
-To access web-interface from your web-browser use the server address
-and port defined in NZBGet configuration file in options "ControlIP" and
-"ControlPort". For example:
-
-  http://localhost:6789/
-
-For login credentials type username and the password defined by
-options "ControlUsername" (default "nzbget") and "ControlPassword"
-(default "tegbzn6789").
-
-In a case your browser forget credentials, to prevent typing them each
-time, there is a workaround - use URL in the form:
-
-  http://localhost:6789/username:password/
-
-Please note, that in this case the password is saved in a bookmark or in
-browser history in plain text and is easy to find by persons having
-access to your computer. 
-
 =====================================
 8. Authors
 =====================================
 
-NZBGet is developed and maintained by Andrey Prygunkov
-(hugbug@users.sourceforge.net).
-
-The original project was initially created by Sven Henkel
-(sidddy@users.sourceforge.net) in 2004 and later developed by
-Bo Cordes Petersen (placebodk@users.sourceforge.net) until 2005.
-In 2007 the abandoned project was overtaken by Andrey Prygunkov.
-Since then the program has been completely rewritten.
+NZBGet was initialiy written by Sven Henkel (sidddy@users.sourceforge.net).
+Up to version 0.2.3 it was been developed and maintained by Bo Cordes Petersen 
+(placebodk@users.sourceforge.net). Beginning at version 0.3.0 the program is 
+being developed by Andrei Prygounkov (hugbug@users.sourceforge.net).
 
 =====================================
 9. Copyright
 =====================================
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
+NZBGet is distributed under GNU General Pubic License Version 2.
 The complete content of license is provided in file COPYING.
 
-Additional exemption: compiling, linking, and/or using OpenSSL is allowed.
+Binary distribution for Windows contains code from the following libraries:
+
+   - libpar2     (http://parchive.sourceforge.net)
+   - libsigc++   (http://libsigc.sourceforge.net)
+
+libpar2 is distributed under GPL and libsigc++ under LGPL.
 
 =====================================
 10. Contact
 =====================================
 
-If you encounter any problem, feel free to use the forum
+If you encounter any problem, feel free to use tracker/forums on
 
-    nzbget.net/forum
+    sourceforge.net/projects/nzbget
 
 or contact me at
 

RemoteClient.cpp

@@ -0,0 +1,489 @@
+/*
+ *  This file if part of nzbget
+ *
+ *  Copyright (C) 2005  Bo Cordes Petersen <placebodk@sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef WIN32
+#include "win32.h"
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#ifdef WIN32
+#include <windows.h>
+#else
+#include <unistd.h>
+#endif
+#include <stdarg.h>
+
+#include "nzbget.h"
+#include "RemoteClient.h"
+#include "Options.h"
+#include "NZBFile.h"
+#include "Log.h"
+#include "Util.h"
+
+extern Options* g_pOptions;
+
+RemoteClient::RemoteClient()
+{
+	m_pConnection	= NULL;
+	m_pNetAddress	= NULL;
+	m_bVerbose		= true;
+
+	/*
+	printf("sizeof(SNZBMessageBase)=%i\n", sizeof(SNZBMessageBase));
+	printf("sizeof(SNZBDownloadRequest)=%i\n", sizeof(SNZBDownloadRequest));
+	printf("sizeof(SNZBListRequest)=%i\n", sizeof(SNZBListRequest));
+	printf("sizeof(SNZBListRequestAnswer)=%i\n", sizeof(SNZBListRequestAnswer));
+	printf("sizeof(SNZBListRequestAnswerEntry)=%i\n", sizeof(SNZBListRequestAnswerEntry));
+	printf("sizeof(SNZBLogRequest)=%i\n", sizeof(SNZBLogRequest));
+	printf("sizeof(SNZBLogRequestAnswer)=%i\n", sizeof(SNZBLogRequestAnswer));
+	printf("sizeof(SNZBLogRequestAnswerEntry)=%i\n", sizeof(SNZBLogRequestAnswerEntry));
+	printf("sizeof(SNZBPauseUnpauseRequest)=%i\n", sizeof(SNZBPauseUnpauseRequest));
+	printf("sizeof(SNZBSetDownloadRateRequest)=%i\n", sizeof(SNZBSetDownloadRateRequest));
+	printf("sizeof(SNZBEditQueueRequest)=%i\n", sizeof(SNZBEditQueueRequest));
+	printf("sizeof(SNZBDumpDebugRequest)=%i\n", sizeof(SNZBDumpDebugRequest));
+	*/
+}
+
+RemoteClient::~RemoteClient()
+{
+	if (m_pConnection)
+	{
+		delete m_pConnection;
+	}
+
+	if (m_pNetAddress)
+	{
+		delete m_pNetAddress;
+	}
+}
+
+void RemoteClient::printf(char * msg,...)
+{
+	if (m_bVerbose)
+	{
+		va_list ap;
+		va_start(ap, msg);
+		::vprintf(msg, ap);
+		va_end(ap);
+	}
+}
+
+void RemoteClient::perror(char * msg)
+{
+	if (m_bVerbose)
+	{
+		::perror(msg);
+	}
+}
+
+bool RemoteClient::InitConnection()
+{
+	// Create a connection to the server
+	m_pNetAddress	= new NetAddress(g_pOptions->GetServerIP(), g_pOptions->GetServerPort());
+	m_pConnection	= new Connection(m_pNetAddress);
+
+	bool OK = m_pConnection->Connect() >= 0;
+	if (!OK)
+	{
+		printf("Unable to send request to nzbserver at %s (port %i)\n", g_pOptions->GetServerIP(), g_pOptions->GetServerPort());
+	}
+	return OK;
+}
+
+void RemoteClient::InitMessageBase(SNZBMessageBase* pMessageBase, int iRequest, int iSize)
+{
+	pMessageBase->m_iId	= NZBMESSAGE_SIGNATURE;
+	pMessageBase->m_iType = iRequest;
+	pMessageBase->m_iSize = iSize;
+	strncpy(pMessageBase->m_szPassword, g_pOptions->GetServerPassword(), NZBREQUESTPASSWORDSIZE - 1);
+	pMessageBase->m_szPassword[NZBREQUESTPASSWORDSIZE - 1] = '\0';
+}
+
+void RemoteClient::ReceiveCommandResult()
+{
+	char szAnswer[1024];
+	strcpy(szAnswer, "N/A");
+	printf("request sent\n");
+	m_pConnection->Recv(szAnswer, 1024);
+	printf("nzbserver returned: %s\n", szAnswer);
+}
+
+/*
+ * Sends a message to the running nzbget process.
+ */
+bool RemoteClient::RequestServerDownload(const char* szName, bool bAddFirst)
+{
+	// Read the file into the buffer
+	char* szBuffer	= NULL;
+	int iLength		= 0;
+	if (!NZBFile::LoadFileIntoBuffer(szName, &szBuffer, &iLength))
+	{
+		printf("Could not load file %s\n", szName);
+		return false;
+	}
+
+	bool OK = InitConnection();
+	if (OK)
+	{
+		SNZBDownloadRequest DownloadRequest;
+		InitMessageBase(&DownloadRequest.m_MessageBase, NZBMessageRequest::eRequestDownload, sizeof(DownloadRequest));
+		DownloadRequest.m_bAddFirst = bAddFirst;
+		DownloadRequest.m_iTrailingDataLength = iLength;
+
+		strncpy(DownloadRequest.m_szFilename, szName, NZBREQUESTFILENAMESIZE - 1);
+		DownloadRequest.m_szFilename[NZBREQUESTFILENAMESIZE-1] = '\0';
+
+		if (m_pConnection->Send((char*)(&DownloadRequest), sizeof(DownloadRequest)) < 0)
+		{
+			perror("m_pConnection->Send");
+			OK = false;
+		}
+		else
+		{
+			m_pConnection->Send(szBuffer, iLength);
+			ReceiveCommandResult();
+			m_pConnection->Disconnect();
+		}
+	}
+
+	// Cleanup
+	if (szBuffer)
+	{
+		free(szBuffer);
+	}
+
+	return OK;
+}
+
+bool RemoteClient::RequestServerList()
+{
+	if (!InitConnection()) return false;
+
+	SNZBListRequest ListRequest;
+	InitMessageBase(&ListRequest.m_MessageBase, NZBMessageRequest::eRequestList, sizeof(ListRequest));
+	ListRequest.m_bFileList = true;
+	ListRequest.m_bServerState = true;
+
+	if (m_pConnection->Send((char*)(&ListRequest), sizeof(ListRequest)) < 0)
+	{
+		perror("m_pConnection->Send");
+		return false;
+	}
+
+	// Now listen for the returned list
+	SNZBListRequestAnswer ListRequestAnswer;
+	if (m_pConnection->Recv((char*) &ListRequestAnswer, sizeof(ListRequestAnswer)) < 0)
+	{
+		return false;
+	}
+
+	char* pBuf = NULL;
+	if (ListRequestAnswer.m_iTrailingDataLength > 0)
+	{
+		pBuf = (char*)malloc(ListRequestAnswer.m_iTrailingDataLength);
+		if (!m_pConnection->RecvAll(pBuf, ListRequestAnswer.m_iTrailingDataLength))
+		{
+			free(pBuf);
+			return false;
+		}
+	}
+
+	m_pConnection->Disconnect();
+
+	if (ListRequestAnswer.m_iTrailingDataLength == 0)
+	{
+		printf("Server has no files queued for download\n");
+	}
+	else
+	{
+		printf("Queue List\n");
+		printf("-----------------------------------\n");
+
+		long long lRemaining = 0;
+		long long lPaused = 0;
+		char* pBufPtr = (char*)pBuf;
+		for (int i = 0; i < ListRequestAnswer.m_iNrTrailingEntries; i++)
+		{
+			SNZBListRequestAnswerEntry* pListAnswer = (SNZBListRequestAnswerEntry*) pBufPtr;
+
+			char szCompleted[100];
+			szCompleted[0] = '\0';
+			if (pListAnswer->m_iRemainingSize < pListAnswer->m_iFileSize)
+			{
+				sprintf(szCompleted, ", %i%s", (int)(100 - pListAnswer->m_iRemainingSize * 100.0 / pListAnswer->m_iFileSize), "\%");
+			}
+			char szStatus[100];
+			if (pListAnswer->m_bPaused)
+			{
+				sprintf(szStatus, " (paused)");
+				lPaused += pListAnswer->m_iRemainingSize;
+			}
+			else
+			{
+				szStatus[0] = '\0';
+				lRemaining += pListAnswer->m_iRemainingSize;
+			}
+			char* szNZBFilename = pBufPtr + sizeof(SNZBListRequestAnswerEntry);
+			char* szFilename = pBufPtr + sizeof(SNZBListRequestAnswerEntry) + pListAnswer->m_iNZBFilenameLen + pListAnswer->m_iSubjectLen;
+			
+			char szNZBNiceName[1024];
+			strncpy(szNZBNiceName, BaseFileName(szNZBFilename), 1024);
+			szNZBNiceName[1024-1] = '\0';
+			if (char* p = strrchr(szNZBNiceName, '.')) *p = '\0';
+			
+			printf("[%i] %s%c%s (%.2f MB%s)%s\n", pListAnswer->m_iID, szNZBNiceName, (int)PATH_SEPARATOR, szFilename, pListAnswer->m_iFileSize / 1024.0 / 1024.0, szCompleted, szStatus);
+
+			pBufPtr += sizeof(SNZBListRequestAnswerEntry) + pListAnswer->m_iNZBFilenameLen + pListAnswer->m_iSubjectLen +
+			           pListAnswer->m_iFilenameLen + pListAnswer->m_iDestDirLen;
+		}
+
+		printf("-----------------------------------\n");
+		printf("Files: %i\n", ListRequestAnswer.m_iNrTrailingEntries);
+		if (lPaused > 0)
+		{
+			printf("Remaining size: %.2f MB (+%.2f MB paused)\n", lRemaining / 1024.0 / 1024.0, lPaused / 1024.0 / 1024.0);
+		}
+		else
+		{
+			printf("Remaining size: %.2f MB\n", lRemaining / 1024.0 / 1024.0);
+		}
+		printf("Download rate: %.1f KB/s\n", ListRequestAnswer.m_fDownloadRate);
+
+		free(pBuf);
+	}
+
+	printf("Threads running: %i\n", ListRequestAnswer.m_iThreadCount);
+	printf("Server state: %s\n", ListRequestAnswer.m_bServerPaused ? "Paused" : "Running");
+
+	if (ListRequestAnswer.m_fDownloadLimit > 0)
+	{
+		printf("Speed limit: %.1f KB/s\n", ListRequestAnswer.m_fDownloadLimit);
+	}
+	else
+	{
+		printf("Speed limit: Unlimited\n");
+	}
+
+	return true;
+}
+
+bool RemoteClient::RequestServerLog(int iLines)
+{
+	if (!InitConnection()) return false;
+
+	SNZBLogRequest LogRequest;
+	InitMessageBase(&LogRequest.m_MessageBase, NZBMessageRequest::eRequestLog, sizeof(LogRequest));
+	LogRequest.m_iLines = iLines;
+	LogRequest.m_iIDFrom = 0;
+
+	if (m_pConnection->Send((char*)(&LogRequest), sizeof(LogRequest)) < 0)
+	{
+		perror("m_pConnection->Send");
+		return false;
+	}
+
+	// Now listen for the returned log
+	SNZBLogRequestAnswer LogRequestAnswer;
+	if (m_pConnection->Recv((char*) &LogRequestAnswer, sizeof(LogRequestAnswer)) < 0)
+	{
+		return false;
+	}
+
+	char* pBuf = NULL;
+	if (LogRequestAnswer.m_iTrailingDataLength > 0)
+	{
+		pBuf = (char*)malloc(LogRequestAnswer.m_iTrailingDataLength);
+		if (!m_pConnection->RecvAll(pBuf, LogRequestAnswer.m_iTrailingDataLength))
+		{
+			free(pBuf);
+			return false;
+		}
+	}
+
+	m_pConnection->Disconnect();
+
+	if (LogRequestAnswer.m_iTrailingDataLength == 0)
+	{
+		printf("Log is empty\n");
+	}
+	else
+	{
+		printf("Log (last %i entries)\n", LogRequestAnswer.m_iNrTrailingEntries);
+		printf("-----------------------------------\n");
+
+		char* pBufPtr = (char*)pBuf;
+		for (int i = 0; i < LogRequestAnswer.m_iNrTrailingEntries; i++)
+		{
+			SNZBLogRequestAnswerEntry* pLogAnswer = (SNZBLogRequestAnswerEntry*) pBufPtr;
+
+			char* szText = pBufPtr + sizeof(SNZBLogRequestAnswerEntry);
+			switch (pLogAnswer->m_iKind)
+			{
+				case Message::mkDebug:
+					printf("[DEBUG] %s\n", szText);
+					break;
+				case Message::mkError:
+					printf("[ERROR] %s\n", szText);
+					break;
+				case Message::mkWarning:
+					printf("[WARNING] %s\n", szText);
+					break;
+				case Message::mkInfo:
+					printf("[INFO] %s\n", szText);
+					break;
+			}
+
+			pBufPtr += sizeof(SNZBLogRequestAnswerEntry) + pLogAnswer->m_iTextLen;
+		}
+
+		printf("-----------------------------------\n");
+
+		free(pBuf);
+	}
+
+	return true;
+}
+
+bool RemoteClient::RequestServerPauseUnpause(bool bPause)
+{
+	if (!InitConnection()) return false;
+
+	SNZBPauseUnpauseRequest PauseUnpauseRequest;
+	InitMessageBase(&PauseUnpauseRequest.m_MessageBase, NZBMessageRequest::eRequestPauseUnpause, sizeof(PauseUnpauseRequest));
+	PauseUnpauseRequest.m_bPause = bPause;
+
+	if (m_pConnection->Send((char*)(&PauseUnpauseRequest), sizeof(PauseUnpauseRequest)) < 0)
+	{
+		perror("m_pConnection->Send");
+		m_pConnection->Disconnect();
+		return false;
+	}
+
+	ReceiveCommandResult();
+	m_pConnection->Disconnect();
+
+	return true;
+}
+
+bool RemoteClient::RequestServerSetDownloadRate(float fRate)
+{
+	if (!InitConnection()) return false;
+
+	SNZBSetDownloadRateRequest SetDownloadRateRequest;
+	InitMessageBase(&SetDownloadRateRequest.m_MessageBase, NZBMessageRequest::eRequestSetDownloadRate, sizeof(SetDownloadRateRequest));
+	SetDownloadRateRequest.m_fDownloadRate = fRate;
+
+	if (m_pConnection->Send((char*)(&SetDownloadRateRequest), sizeof(SetDownloadRateRequest)) < 0)
+	{
+		perror("m_pConnection->Send");
+		m_pConnection->Disconnect();
+		return false;
+	}
+
+	ReceiveCommandResult();
+	m_pConnection->Disconnect();
+
+	return true;
+}
+
+bool RemoteClient::RequestServerDumpDebug()
+{
+	if (!InitConnection()) return false;
+
+	SNZBDumpDebugRequest DumpDebugInfo;
+	InitMessageBase(&DumpDebugInfo.m_MessageBase, NZBMessageRequest::eRequestDumpDebug, sizeof(DumpDebugInfo));
+	DumpDebugInfo.m_iLevel = 0;
+
+	if (m_pConnection->Send((char*)(&DumpDebugInfo), sizeof(DumpDebugInfo)) < 0)
+	{
+		perror("m_pConnection->Send");
+		m_pConnection->Disconnect();
+		return false;
+	}
+
+	ReceiveCommandResult();
+	m_pConnection->Disconnect();
+
+	return true;
+}
+
+bool RemoteClient::RequestServerEditQueue(int iAction, int iOffset, int iIDFrom, int iIDTo)
+{
+	if (iIDTo <= 0)
+	{
+		printf("File(s) not specified (use option -I)\n");
+		return false;
+	}
+
+	if (!InitConnection()) return false;
+
+	SNZBEditQueueRequest EditQueueRequest;
+	InitMessageBase(&EditQueueRequest.m_MessageBase, NZBMessageRequest::eRequestEditQueue, sizeof(EditQueueRequest));
+	EditQueueRequest.m_iAction = iAction;
+	EditQueueRequest.m_iOffset = iOffset;
+	EditQueueRequest.m_iIDFrom = iIDFrom;
+	EditQueueRequest.m_iIDTo = iIDTo;
+
+	bool OK = m_pConnection->Send((char*)(&EditQueueRequest), sizeof(EditQueueRequest)) >= 0;
+	if (OK)
+	{
+		ReceiveCommandResult();
+	}
+	else
+	{
+		perror("m_pConnection->Send");
+	}
+
+	m_pConnection->Disconnect();
+	return OK;
+}
+
+bool RemoteClient::RequestServerShutdown()
+{
+	if (!InitConnection()) return false;
+
+	SNZBMessageBase QuitRequest;
+
+	InitMessageBase(&QuitRequest, NZBMessageRequest::eRequestShutdown, sizeof(QuitRequest));
+
+	bool OK = m_pConnection->Send((char*)(&QuitRequest), sizeof(QuitRequest)) >= 0;
+	if (OK)
+	{
+		ReceiveCommandResult();
+	}
+	else
+	{
+		perror("m_pConnection->Send");
+	}
+
+	m_pConnection->Disconnect();
+	return OK;
+}

RemoteClient.h

@@ -0,0 +1,61 @@
+/*
+ *  This file if part of nzbget
+ *
+ *  Copyright (C) 2005  Bo Cordes Petersen <placebodk@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifndef REMOTECLIENT_H
+#define REMOTECLIENT_H
+
+#include "Options.h"
+#include "MessageBase.h"
+#include "Connection.h"
+
+class RemoteClient
+{
+private:
+	Connection* 	m_pConnection;
+	NetAddress*		m_pNetAddress;
+	bool			m_bVerbose;
+
+	bool			InitConnection();
+	void			InitMessageBase(SNZBMessageBase* pMessageBase, int iRequest, int iSize);
+	void			ReceiveCommandResult();
+	void			printf(char* msg, ...);
+	void			perror(char* msg);
+
+public:
+	RemoteClient();
+	~RemoteClient();
+	void			SetVerbose(bool bVerbose) { m_bVerbose = bVerbose; };
+	bool 			RequestServerDownload(const char* szName, bool bAddFirst);
+	bool			RequestServerList();
+	bool			RequestServerPauseUnpause(bool bPause);
+	bool			RequestServerSetDownloadRate(float fRate);
+	bool			RequestServerDumpDebug();
+	bool 			RequestServerEditQueue(int iAction, int iOffset, int iIDFrom, int iIDTo);
+	bool			RequestServerLog(int iLines);
+	bool			RequestServerShutdown();
+};
+
+#endif

RemoteServer.cpp

@@ -0,0 +1,527 @@
+/*
+ *  This file if part of nzbget
+ *
+ *  Copyright (C) 2005  Bo Cordes Petersen <placebodk@sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef WIN32
+#include "win32.h"
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#ifndef WIN32
+#include <unistd.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#endif
+
+#include "nzbget.h"
+#include "RemoteServer.h"
+#include "Log.h"
+#include "Options.h"
+#include "QueueCoordinator.h"
+#include "Util.h"
+
+extern Options* g_pOptions;
+extern QueueCoordinator* g_pQueueCoordinator;
+extern void ExitProc();
+
+const char* g_szMessageRequests[] =
+    { "N/A", "Download", "Pause/Unpause", "List",
+      "Set download rate", "Dump debug", "Edit queue", "Log", "Quit"
+    };
+
+//*****************************************************************
+// RemoteServer
+
+RemoteServer::RemoteServer()
+{
+	debug("Creating RemoteServer");
+
+	m_pNetAddress = new NetAddress(g_pOptions->GetServerIP(), g_pOptions->GetServerPort());
+	m_pConnection = new Connection(m_pNetAddress);
+	m_pConnection->SetTimeout(g_pOptions->GetConnectionTimeout());
+}
+
+RemoteServer::~RemoteServer()
+{
+	debug("Destroying RemoteServer");
+
+	delete m_pNetAddress;
+	delete m_pConnection;
+}
+
+void RemoteServer::Run()
+{
+	debug("Entering RemoteServer-loop");
+
+	m_pConnection->Bind();
+
+	while (!IsStopped())
+	{
+		// Accept connections and store the "new" socket value
+		SOCKET iSocket = m_pConnection->Accept();
+		if (iSocket == INVALID_SOCKET)
+		{
+			if (IsStopped())
+			{
+				break; 
+			}
+			// error binding on port. wait 0.5 sec. and retry
+			usleep(500 * 1000);
+			delete m_pConnection;
+			m_pConnection = new Connection(m_pNetAddress);
+			m_pConnection->SetTimeout(g_pOptions->GetConnectionTimeout());
+			m_pConnection->Bind();
+			continue;
+		}
+
+		MessageCommand* commandThread = new MessageCommand();
+		commandThread->SetAutoDestroy(true);
+		commandThread->SetSocket(iSocket);
+		commandThread->Start();
+	}
+	m_pConnection->Disconnect();
+
+	debug("Exiting RemoteServer-loop");
+}
+
+void RemoteServer::Stop()
+{
+	Thread::Stop();
+	m_pConnection->Cancel();
+#ifdef WIN32
+	m_pConnection->Disconnect();
+#endif
+}
+
+//*****************************************************************
+// MessageCommand
+
+void MessageCommand::SendResponse(char* szAnswer)
+{
+	send(m_iSocket, szAnswer, strlen(szAnswer), 0);
+}
+
+void MessageCommand::ProcessRequest()
+{
+	SNZBMessageBase* pMessageBase = (SNZBMessageBase*) & m_RequestBuffer;
+
+	switch (pMessageBase->m_iType)
+	{
+		case NZBMessageRequest::eRequestDownload:
+			{
+				RequestDownload();
+				break;
+			}
+
+		case NZBMessageRequest::eRequestList:
+			{
+				RequestList();
+				break;
+			}
+
+		case NZBMessageRequest::eRequestLog:
+			{
+				RequestLog();
+				break;
+			}
+
+		case NZBMessageRequest::eRequestPauseUnpause:
+			{
+				SNZBPauseUnpauseRequest* pPauseUnpauseRequest = (SNZBPauseUnpauseRequest*) & m_RequestBuffer;
+				g_pOptions->SetPause(pPauseUnpauseRequest->m_bPause);
+				SendResponse("Pause-/Unpause-Command completed successfully");
+				break;
+			}
+
+		case NZBMessageRequest::eRequestEditQueue:
+			{
+				RequestEditQueue();
+				break;
+			}
+
+		case NZBMessageRequest::eRequestSetDownloadRate:
+			{
+				SNZBSetDownloadRateRequest* pSetDownloadRequest = (SNZBSetDownloadRateRequest*) & m_RequestBuffer;
+				g_pOptions->SetDownloadRate(pSetDownloadRequest->m_fDownloadRate);
+				SendResponse("Rate-Command completed successfully");
+				break;
+			}
+
+		case NZBMessageRequest::eRequestDumpDebug:
+			{
+				g_pQueueCoordinator->LogDebugInfo();
+				SendResponse("Debug-Command completed successfully");
+				break;
+			}
+
+		case NZBMessageRequest::eRequestShutdown:
+			{
+				SendResponse("Stopping server");
+				ExitProc();
+				break;
+			}
+
+		default:
+			error("NZB-Request not yet supported");
+			break;
+	}
+}
+
+void MessageCommand::RequestDownload()
+{
+	SNZBDownloadRequest* pDownloadRequest = (SNZBDownloadRequest*) & m_RequestBuffer;
+	const char* pExtraData = (m_iExtraDataLength > 0) ? ((char*)pDownloadRequest + pDownloadRequest->m_MessageBase.m_iSize) : NULL;
+	int NeedBytes = pDownloadRequest->m_iTrailingDataLength - m_iExtraDataLength;
+	char* pRecvBuffer = (char*)malloc(pDownloadRequest->m_iTrailingDataLength + 1);
+	memcpy(pRecvBuffer, pExtraData, m_iExtraDataLength);
+	char* pBufPtr = pRecvBuffer + m_iExtraDataLength;
+
+	// Read from the socket until nothing remains
+	int iResult = 0;
+	while (NeedBytes > 0)
+	{
+		iResult = recv(m_iSocket, pBufPtr, NeedBytes, 0);
+		// Did the recv succeed?
+		if (iResult <= 0)
+		{
+			error("invalid request");
+			break;
+		}
+		pBufPtr += iResult;
+		NeedBytes -= iResult;
+	}
+
+	if (NeedBytes == 0)
+	{
+		NZBFile* pNZBFile = NZBFile::CreateFromBuffer(pDownloadRequest->m_szFilename, pRecvBuffer, pDownloadRequest->m_iTrailingDataLength);
+
+		if (pNZBFile)
+		{
+			info("Request: Queue collection %s", pDownloadRequest->m_szFilename);
+			g_pQueueCoordinator->AddNZBFileToQueue(pNZBFile, pDownloadRequest->m_bAddFirst);
+			delete pNZBFile;
+
+			char tmp[1024];
+			snprintf(tmp, 1024, "Collection %s added to queue", BaseFileName(pDownloadRequest->m_szFilename));
+			tmp[1024-1] = '\0';
+			SendResponse(tmp);
+		}
+		else
+		{
+			char tmp[1024];
+			snprintf(tmp, 1024, "Download Request failed for %s", BaseFileName(pDownloadRequest->m_szFilename));
+			tmp[1024-1] = '\0';
+			SendResponse(tmp);
+		}
+	}
+
+	free(pRecvBuffer);
+}
+
+void MessageCommand::RequestList()
+{
+	SNZBListRequest* pListRequest = (SNZBListRequest*) & m_RequestBuffer;
+
+	SNZBListRequestAnswer ListRequestAnswer;
+	memset(&ListRequestAnswer, 0, sizeof(ListRequestAnswer));
+	ListRequestAnswer.m_iSize = sizeof(ListRequestAnswer);
+	ListRequestAnswer.m_iEntrySize = sizeof(SNZBListRequestAnswerEntry);
+
+	char* buf = NULL;
+	int bufsize = 0;
+
+	if (pListRequest->m_bFileList)
+	{
+		// Make a data structure and copy all the elements of the list into it
+		DownloadQueue* pDownloadQueue = g_pQueueCoordinator->LockQueue();
+
+		int NrEntries = pDownloadQueue->size();
+
+		// calculate required buffer size
+		bufsize = NrEntries * sizeof(SNZBListRequestAnswerEntry);
+		for (DownloadQueue::iterator it = pDownloadQueue->begin(); it != pDownloadQueue->end(); it++)
+		{
+			FileInfo* pFileInfo = *it;
+			bufsize += strlen(pFileInfo->GetNZBFilename()) + 1;
+			bufsize += strlen(pFileInfo->GetSubject()) + 1;
+			bufsize += strlen(pFileInfo->GetFilename()) + 1;
+			bufsize += strlen(pFileInfo->GetDestDir()) + 1;
+		}
+
+		buf = (char*) malloc(bufsize);
+		char* bufptr = buf;
+		for (DownloadQueue::iterator it = pDownloadQueue->begin(); it != pDownloadQueue->end(); it++)
+		{
+			FileInfo* pFileInfo = *it;
+			SNZBListRequestAnswerEntry* pListAnswer = (SNZBListRequestAnswerEntry*) bufptr;
+			pListAnswer->m_iID				= pFileInfo->GetID();
+			pListAnswer->m_iFileSize		= (int)pFileInfo->GetSize();
+			pListAnswer->m_bFilenameConfirmed = pFileInfo->GetFilenameConfirmed();
+			pListAnswer->m_iRemainingSize	= (int)pFileInfo->GetRemainingSize();
+			pListAnswer->m_bPaused			= pFileInfo->GetPaused();
+			pListAnswer->m_iNZBFilenameLen	= strlen(pFileInfo->GetNZBFilename()) + 1;
+			pListAnswer->m_iSubjectLen		= strlen(pFileInfo->GetSubject()) + 1;
+			pListAnswer->m_iFilenameLen		= strlen(pFileInfo->GetFilename()) + 1;
+			pListAnswer->m_iDestDirLen		= strlen(pFileInfo->GetDestDir()) + 1;
+			bufptr += sizeof(SNZBListRequestAnswerEntry);
+			strcpy(bufptr, pFileInfo->GetNZBFilename());
+			bufptr += pListAnswer->m_iNZBFilenameLen;
+			strcpy(bufptr, pFileInfo->GetSubject());
+			bufptr += pListAnswer->m_iSubjectLen;
+			strcpy(bufptr, pFileInfo->GetFilename());
+			bufptr += pListAnswer->m_iFilenameLen;
+			strcpy(bufptr, pFileInfo->GetDestDir());
+			bufptr += pListAnswer->m_iDestDirLen;
+		}
+
+		g_pQueueCoordinator->UnlockQueue();
+
+		ListRequestAnswer.m_iNrTrailingEntries = NrEntries;
+		ListRequestAnswer.m_iTrailingDataLength = bufsize;
+	}
+
+	if (pListRequest->m_bServerState)
+	{
+		ListRequestAnswer.m_fDownloadRate = g_pQueueCoordinator->CalcCurrentDownloadSpeed();
+		ListRequestAnswer.m_lRemainingSize = g_pQueueCoordinator->CalcRemainingSize();
+		ListRequestAnswer.m_fDownloadLimit = g_pOptions->GetDownloadRate();
+		ListRequestAnswer.m_bServerPaused = g_pOptions->GetPause();
+		ListRequestAnswer.m_iThreadCount = Thread::GetThreadCount() - 1; // not counting itself
+	}
+
+	// Send the request answer
+	send(m_iSocket, (char*) &ListRequestAnswer, sizeof(ListRequestAnswer), 0);
+
+	// Send the data
+	if (bufsize > 0)
+	{
+		send(m_iSocket, buf, bufsize, 0);
+	}
+
+	if (buf)
+	{
+		free(buf);
+	}
+}
+
+void MessageCommand::RequestLog()
+{
+	SNZBLogRequest* pLogRequest = (SNZBLogRequest*) & m_RequestBuffer;
+
+	Log::Messages* pMessages = g_pLog->LockMessages();
+
+	int iNrEntries = pLogRequest->m_iLines;
+	unsigned int iIDFrom = pLogRequest->m_iIDFrom;
+	int iStart = pMessages->size();
+	if (iNrEntries > 0)
+	{
+		if (iNrEntries > (int)pMessages->size())
+		{
+			iNrEntries = pMessages->size();
+		}
+		iStart = pMessages->size() - iNrEntries;
+	}
+	if (iIDFrom > 0 && !pMessages->empty())
+	{
+		iStart = iIDFrom - pMessages->front()->GetID();
+		if (iStart < 0)
+		{
+			iStart = 0;
+		}
+		iNrEntries = pMessages->size() - iStart;
+		if (iNrEntries < 0)
+		{
+			iNrEntries = 0;
+		}
+	}
+
+	// calculate required buffer size
+	int bufsize = iNrEntries * sizeof(SNZBLogRequestAnswerEntry);
+	for (unsigned int i = (unsigned int)iStart; i < pMessages->size(); i++)
+	{
+		Message* pMessage = (*pMessages)[i];
+		bufsize += strlen(pMessage->GetText()) + 1;
+	}
+
+	char* buf = (char*) malloc(bufsize);
+	char* bufptr = buf;
+	for (unsigned int i = (unsigned int)iStart; i < pMessages->size(); i++)
+	{
+		Message* pMessage = (*pMessages)[i];
+		SNZBLogRequestAnswerEntry* pLogAnswer = (SNZBLogRequestAnswerEntry*) bufptr;
+		pLogAnswer->m_iID = pMessage->GetID();
+		pLogAnswer->m_iKind = pMessage->GetKind();
+		pLogAnswer->m_tTime = pMessage->GetTime();
+		pLogAnswer->m_iTextLen = strlen(pMessage->GetText()) + 1;
+		bufptr += sizeof(SNZBLogRequestAnswerEntry);
+		strcpy(bufptr, pMessage->GetText());
+		bufptr += pLogAnswer->m_iTextLen;
+	}
+
+	g_pLog->UnlockMessages();
+
+	SNZBLogRequestAnswer LogRequestAnswer;
+	LogRequestAnswer.m_iSize = sizeof(LogRequestAnswer);
+	LogRequestAnswer.m_iEntrySize = sizeof(SNZBLogRequestAnswerEntry);
+	LogRequestAnswer.m_iNrTrailingEntries = iNrEntries;
+	LogRequestAnswer.m_iTrailingDataLength = bufsize;
+
+	// Send the request answer
+	send(m_iSocket, (char*) &LogRequestAnswer, sizeof(LogRequestAnswer), 0);
+
+	// Send the data
+	if (bufsize > 0)
+	{
+		send(m_iSocket, buf, bufsize, 0);
+	}
+
+	free(buf);
+}
+
+void MessageCommand::RequestEditQueue()
+{
+	SNZBEditQueueRequest* pEditQueueRequest = (SNZBEditQueueRequest*) & m_RequestBuffer;
+
+	int From = pEditQueueRequest->m_iIDFrom;
+	int To = pEditQueueRequest->m_iIDTo;
+	int Step = 1;
+	if ((pEditQueueRequest->m_iAction == NZBMessageRequest::eActionMoveTop) ||
+	        ((pEditQueueRequest->m_iAction == NZBMessageRequest::eActionMoveOffset) &&
+	         (pEditQueueRequest->m_iOffset < 0)))
+	{
+		Step = -1;
+		int tmp = From; From = To; To = tmp;
+	}
+
+	for (int ID = From; ID != To + Step; ID += Step)
+	{
+		switch (pEditQueueRequest->m_iAction)
+		{
+			case NZBMessageRequest::eActionPause:
+			case NZBMessageRequest::eActionResume:
+				{
+					g_pQueueCoordinator->EditQueuePauseUnpauseEntry(ID, pEditQueueRequest->m_iAction == NZBMessageRequest::eActionPause);
+					break;
+				}
+
+			case NZBMessageRequest::eActionMoveOffset:
+				{
+					g_pQueueCoordinator->EditQueueMoveEntry(ID, pEditQueueRequest->m_iOffset, true);
+					break;
+				}
+
+			case NZBMessageRequest::eActionMoveTop:
+				{
+					g_pQueueCoordinator->EditQueueMoveEntry(ID, -1000000, true);
+					break;
+				}
+
+			case NZBMessageRequest::eActionMoveBottom:
+				{
+					g_pQueueCoordinator->EditQueueMoveEntry(ID, + 1000000, true);
+					break;
+				}
+
+			case NZBMessageRequest::eActionDelete:
+				{
+					g_pQueueCoordinator->EditQueueDeleteEntry(ID);
+					break;
+				}
+		}
+	}
+	SendResponse("Edit-Command completed successfully");
+}
+
+void MessageCommand::SetSocket(SOCKET iSocket)
+{
+	m_iSocket = iSocket;
+}
+
+void MessageCommand::Run()
+{
+	int iRequestReceived = 0;
+
+	// Read the first package which needs to be a request
+
+	iRequestReceived = recv(m_iSocket, (char*) & m_RequestBuffer, sizeof(m_RequestBuffer), 0);
+	if (iRequestReceived < 0)
+	{
+		return;
+	}
+
+	SNZBMessageBase* pMessageBase = (SNZBMessageBase*) & m_RequestBuffer;
+
+	// Make sure this is a nzbget request from a client
+	if (pMessageBase->m_iId != NZBMESSAGE_SIGNATURE)
+	{
+		warn("Non-nzbget request received on port %i", g_pOptions->GetServerPort());
+
+		if (m_iSocket > -1)
+		{
+			closesocket(m_iSocket);
+		}
+
+		return;
+	}
+
+	if (strcmp(pMessageBase->m_szPassword, g_pOptions->GetServerPassword()))
+	{
+		warn("nzbget request received on port %i, but password invalid", g_pOptions->GetServerPort());
+
+		if (m_iSocket > -1)
+		{
+			closesocket(m_iSocket);
+		}
+
+		return;
+	}
+
+	// Info - connection received
+	struct sockaddr_in PeerName;
+	int iPeerNameLength = sizeof(PeerName);
+	if (getpeername(m_iSocket, (struct sockaddr*)&PeerName, (socklen_t*) &iPeerNameLength) >= 0)
+	{
+#ifdef WIN32
+		char* ip = inet_ntoa(PeerName.sin_addr);
+#else
+		char ip[20];
+		inet_ntop(AF_INET, &PeerName.sin_addr, ip, sizeof(ip));
+#endif
+		debug("%s request received from %s", g_szMessageRequests[pMessageBase->m_iType], ip);
+	}
+
+	m_iExtraDataLength = iRequestReceived - pMessageBase->m_iSize;
+
+	ProcessRequest();
+
+	// Close the socket
+	closesocket(m_iSocket);
+}

RemoteServer.h

@@ -1,8 +1,8 @@
 /*
- *  This file is part of nzbget
+ *  This file if part of nzbget
  *
- *  Copyright (C) 2005 Bo Cordes Petersen <placebodk@users.sourceforge.net>
- *  Copyright (C) 2007-2013 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *  Copyright (C) 2005  Bo Cordes Petersen <placebodk@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -16,7 +16,7 @@
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  *
  * $Revision$
  * $Date$
@@ -28,32 +28,42 @@
 #define REMOTESERVER_H
 
 #include "Thread.h"
+#include "NetAddress.h"
 #include "Connection.h"
+#include "MessageBase.h"
+
+static int const REQUESTBUFFERSIZE = 8192;
 
 class RemoteServer : public Thread
 {
 private:
-	bool				m_bTLS;
+	NetAddress*			m_pNetAddress;
 	Connection*			m_pConnection;
 
 public:
-						RemoteServer(bool bTLS);
+						RemoteServer();
 						~RemoteServer();
 	virtual void		Run();
 	virtual void 		Stop();
 };
 
-class RequestProcessor : public Thread
+class MessageCommand : public Thread
 {
 private:
-	bool				m_bTLS;
-	Connection*			m_pConnection;
+	SOCKET				m_iSocket;
+	char				m_RequestBuffer[REQUESTBUFFERSIZE];
+	int					m_iExtraDataLength;
+
+	void				ProcessRequest();
+	void				RequestDownload();
+	void				RequestList();
+	void				RequestLog();
+	void				RequestEditQueue();
+	void				SendResponse(char* szAnswer);
 
 public:
-						~RequestProcessor();
+	void				SetSocket(SOCKET iSocket);
 	virtual void		Run();
-	void				SetTLS(bool bTLS) { m_bTLS = bTLS; }
-	void				SetConnection(Connection* pConnection) { m_pConnection = pConnection; }
 };
 
 #endif

ServerPool.cpp

@@ -0,0 +1,210 @@
+/*
+ *  This file if part of nzbget
+ *
+ *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+/*
+ *
+ * m_Semaphore Patch by Florian Penzkofer <f.penzkofer@sent.com>
+ * The queue of mutexes that was used did not work for every
+ * implementation of POSIX threads. Now a m_Semaphore is used.
+ *
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef WIN32
+#include "win32.h"
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#ifndef WIN32
+#include <unistd.h>
+#include <errno.h>
+#endif
+
+#include "nzbget.h"
+#include "ServerPool.h"
+#include "Log.h"
+
+ServerPool::ServerPool()
+{
+	debug("Creating ServerPool");
+
+	m_iMaxLevel = 0;
+	m_iTimeout = 60;
+	m_Servers.clear();
+	m_FreeConnections.clear();
+	m_Semaphores.clear();
+}
+
+ServerPool::~ ServerPool()
+{
+	debug("Destroying ServerPool");
+
+	m_FreeConnections.clear();
+
+	for (Semaphores::iterator it = m_Semaphores.begin(); it != m_Semaphores.end(); it++)
+	{
+		delete *it;
+	}
+	m_Semaphores.clear();
+
+	for (Servers::iterator it = m_Servers.begin(); it != m_Servers.end(); it++)
+	{
+		delete *it;
+	}
+	m_Servers.clear();
+}
+
+void ServerPool::AddServer(NewsServer* pNewsServer)
+{
+	debug("Adding server to ServerPool");
+
+	m_Servers.push_back(pNewsServer);
+}
+
+void ServerPool::InitConnections()
+{
+	debug("Initializing connections in ServerPool");
+
+	m_iMaxLevel = 0;
+	for (Servers::iterator it = m_Servers.begin(); it != m_Servers.end(); it++)
+	{
+		NewsServer* pNewsServer = *it;
+		if (m_iMaxLevel < pNewsServer->GetLevel())
+		{
+			m_iMaxLevel = pNewsServer->GetLevel();
+		}
+		for (int i = 0; i < pNewsServer->GetMaxConnections(); i++)
+		{
+			m_FreeConnections.push_back(pNewsServer);
+		}
+	}
+
+	for (int iLevel = 0; iLevel <= m_iMaxLevel; iLevel++)
+	{
+		int iMaxConnectionsForLevel = 0;
+		for (Servers::iterator it = m_Servers.begin(); it != m_Servers.end(); it++)
+		{
+			NewsServer* pNewsServer = *it;
+			if (iLevel == pNewsServer->GetLevel())
+			{
+				iMaxConnectionsForLevel += pNewsServer->GetMaxConnections();
+			}
+		}
+
+		Semaphore* sem = new Semaphore(iMaxConnectionsForLevel);
+		m_Semaphores.push_back(sem);
+	}
+}
+
+NNTPConnection* ServerPool::GetConnection(int level)
+{
+	debug("Getting connection");
+
+	debug("sem_wait...");
+	// decrease m_Semaphore counter or block
+	bool bWaitVal = m_Semaphores[level]->Wait();
+	debug("sem_wait...OK");
+
+	if (!bWaitVal)
+	{
+		debug("semaphore error: %i", errno);
+		return NULL;
+	}
+
+	m_mutexFree.Lock();
+
+	NNTPConnection* pConnection = NULL;
+	for (Servers::iterator it = m_FreeConnections.begin(); it != m_FreeConnections.end(); it++)
+	{
+		NewsServer* server = *it;
+		if (server->GetLevel() == level)
+		{
+			// free connection found, take it!
+			pConnection = new NNTPConnection(server);
+			pConnection->SetTimeout(m_iTimeout);
+			m_FreeConnections.erase(it);
+			break;
+		}
+	}
+
+	m_mutexFree.Unlock();
+
+	if (!pConnection)
+	{
+		error("ServerPool: serious error, no free connection found, but there should be one.");
+	}
+
+	return pConnection;
+}
+
+void ServerPool::FreeConnection(NNTPConnection* pConnection)
+{
+	debug("Freeing connection");
+
+	// give back free connection
+	m_mutexFree.Lock();
+	m_FreeConnections.push_back(pConnection->GetNewsServer());
+	m_Semaphores[pConnection->GetNewsServer()->GetLevel()]->Post();
+	m_mutexFree.Unlock();
+
+	delete pConnection;
+}
+
+bool ServerPool::HasFreeConnection()
+{
+	return !m_Semaphores[0]->IsLocked();
+}
+
+void ServerPool::LogDebugInfo()
+{
+	debug("   ServerPool");
+	debug("   ----------------");
+
+	debug("    Max-Level: %i", m_iMaxLevel);
+
+	m_mutexFree.Lock();
+
+	debug("    Free Connections: %i", m_FreeConnections.size());
+	for (Servers::iterator it = m_FreeConnections.begin(); it != m_FreeConnections.end(); it++)
+	{
+		debug("      Free Connection: level=%i", (*it)->GetLevel());
+	}
+/*
+	debug("    Semaphores: %i", m_Semaphores.size());
+	for (int iLevel = 0; iLevel <= m_iMaxLevel; iLevel++)
+	{
+		sem_t* sem = m_Semaphores[iLevel];
+		int iSemValue;
+		sem_getvalue(sem, &iSemValue);
+		debug("      Semaphore: level=%i, value=%i", iLevel, iSemValue);
+	}
+*/
+	m_mutexFree.Unlock();
+}

ServerPool.h

@@ -0,0 +1,64 @@
+/*
+ *  This file if part of nzbget
+ *
+ *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2005	Florian Penzkofer <f.penzkofer@sent.com>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifndef SERVERPOOL_H
+#define SERVERPOOL_H
+
+#include <list>
+
+#include "Thread.h"
+#include "NewsServer.h"
+#include "NNTPConnection.h"
+
+class ServerPool
+{
+private:
+	typedef std::vector<NewsServer*>		Servers;
+	typedef std::vector<Semaphore*>			Semaphores;
+
+	Servers				m_Servers;
+	Servers				m_FreeConnections;
+	Semaphores			m_Semaphores;
+	int					m_iMaxLevel;
+	Mutex			 	m_mutexFree;
+	int					m_iTimeout;
+
+public:
+	ServerPool();
+	~ServerPool();
+	void				SetTimeout(int iTimeout) { m_iTimeout = iTimeout; }
+	void 				AddServer(NewsServer *s);
+	void				InitConnections();
+	int					GetMaxLevel() { return m_iMaxLevel; }
+	NNTPConnection*		GetConnection(int level);
+	bool				HasFreeConnection();
+	void 				FreeConnection(NNTPConnection* con);
+
+	void				LogDebugInfo();
+};
+
+#endif

Thread.cpp

@@ -0,0 +1,280 @@
+/*
+ *  This file if part of nzbget
+ *
+ *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef WIN32
+#include "win32.h"
+#endif
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "Log.h"
+#include "Thread.h"
+
+int Thread::m_iThreadCount = 1; // take the main program thread into account
+Mutex Thread::m_mutexThread;
+
+Mutex::Mutex()
+{
+#ifdef WIN32
+	InitializeCriticalSection(&m_mutexObj);
+#else
+	pthread_mutex_init(&m_mutexObj, NULL);
+#endif
+}
+
+Mutex::~ Mutex()
+{
+#ifdef WIN32
+	DeleteCriticalSection(&m_mutexObj);
+#else
+	pthread_mutex_destroy(&m_mutexObj);
+#endif
+}
+
+void Mutex::Lock()
+{
+#ifdef WIN32
+	EnterCriticalSection(&m_mutexObj);
+#else
+	pthread_mutex_lock(&m_mutexObj);
+#endif
+}
+
+void Mutex::Unlock()
+{
+#ifdef WIN32
+	LeaveCriticalSection(&m_mutexObj);
+#else
+	pthread_mutex_unlock(&m_mutexObj);
+#endif
+}
+
+
+Semaphore::Semaphore()
+{
+#ifdef WIN32
+	m_semObj = CreateSemaphore(NULL, 0, 1, NULL);
+#else
+	sem_init(&m_semObj, 0, 0);
+#endif
+}
+
+Semaphore::Semaphore(int iValue)
+{
+#ifdef WIN32
+	m_semObj = CreateSemaphore(NULL, iValue, iValue, NULL);
+#else
+	sem_init(&m_semObj, 0, iValue);
+#endif
+}
+
+Semaphore::~ Semaphore()
+{
+#ifdef WIN32
+	CloseHandle(m_semObj);
+#else
+	sem_destroy(&m_semObj);
+#endif
+}
+
+void Semaphore::Post()
+{
+#ifdef WIN32
+	ReleaseSemaphore(m_semObj, 1, NULL);
+#else
+	sem_post(&m_semObj);
+#endif
+}
+
+bool Semaphore::Wait()
+{
+#ifdef WIN32
+	return WaitForSingleObject(m_semObj, INFINITE) == WAIT_OBJECT_0;
+#else
+	return sem_wait(&m_semObj) == 0;
+#endif
+}
+
+bool Semaphore::TimedWait(int iMSec)
+{
+#ifdef WIN32
+	return WaitForSingleObject(m_semObj, iMSec) == WAIT_OBJECT_0;
+#else
+	struct timespec alarm;
+	alarm.tv_sec = ::time(NULL) + iMSec / 1000;
+	alarm.tv_nsec = (iMSec % 1000) * 1000;
+	return sem_timedwait(&m_semObj, &alarm) == 0;
+#endif
+}
+
+bool Semaphore::IsLocked()
+{
+#ifdef WIN32
+	bool bCanLock = WaitForSingleObject(m_semObj, 0) == WAIT_OBJECT_0;
+	if (bCanLock)
+	{
+		ReleaseSemaphore(m_semObj, 1, NULL);
+	}
+	return !bCanLock;
+#else
+	int iSemValue;
+	sem_getvalue(&m_semObj, &iSemValue);
+	return iSemValue <= 0;
+#endif
+}
+
+
+void Thread::Init()
+{
+	debug("Initializing global thread data");
+}
+
+void Thread::Final()
+{
+	debug("Finalizing global thread data");
+}
+
+Thread::Thread()
+{
+	debug("Creating Thread");
+
+	m_Thread = 0;
+	m_bRunning = false;
+	m_bStopped = false;
+	m_bAutoDestroy = false;
+}
+
+Thread::~Thread()
+{
+	debug("Destroying Thread");
+}
+
+void Thread::Start()
+{
+	debug("Starting Thread");
+
+	m_bRunning = true;
+	
+	// NOTE: we must garantee, that in a time we setting m_bRunning
+	// to value returned from pthread_create, the thread-object still exists.
+	// This is not obviously!
+	// pthread_create could wait long enough before returning result
+	// back to allow the started thread to complete it job
+	// and terminate.
+	// We lock mutex m_mutexThread on calling pthread_create; the started thread
+	// then also try to lock the mutex (see thread_handler) and therefore
+	// must wait until we unlock it
+	m_mutexThread.Lock();
+
+#ifdef WIN32
+	DWORD ThreadId;
+	m_Thread = CreateThread(NULL, 0, Thread::thread_handler, (void *) this, 0, &ThreadId);
+	m_bRunning = m_Thread != NULL;
+#else
+	pthread_attr_t m_Attr;
+	pthread_attr_init(&m_Attr);
+	pthread_attr_setdetachstate(&m_Attr, PTHREAD_CREATE_DETACHED);
+	pthread_attr_setinheritsched(&m_Attr , PTHREAD_INHERIT_SCHED);
+	m_bRunning = !pthread_create(&m_Thread, &m_Attr, Thread::thread_handler, (void *) this);
+	pthread_attr_destroy(&m_Attr);
+#endif
+
+	m_mutexThread.Unlock();
+}
+
+void Thread::Stop()
+{
+	debug("Stopping Thread");
+
+	m_bStopped = true;
+} 
+
+bool Thread::Kill()
+{
+	debug("Killing Thread");
+
+	m_mutexThread.Lock();
+
+#ifdef WIN32
+	bool terminated = TerminateThread(m_Thread, 0) != 0;
+#else
+	bool terminated = pthread_cancel(m_Thread) == 0;
+#endif
+
+	if (terminated)
+	{
+		m_iThreadCount--;
+	}
+	m_mutexThread.Unlock();
+	return terminated;
+}
+
+#ifdef WIN32
+DWORD WINAPI Thread::thread_handler(void* pObject)
+#else
+void* Thread::thread_handler(void* pObject)
+#endif
+{
+	m_mutexThread.Lock();
+	m_iThreadCount++;
+	m_mutexThread.Unlock();
+
+	debug("Entering Thread-func");
+
+	Thread* pThread = (Thread*)pObject;
+
+	pThread->Run();
+
+	debug("Thread-func exited");
+	
+	pThread->m_bRunning = false;
+	
+	if (pThread->m_bAutoDestroy)
+	{
+		debug("Autodestroying Thread-object");
+		delete pThread;
+	}
+
+	m_mutexThread.Lock();
+	m_iThreadCount--;
+	m_mutexThread.Unlock();
+
+	return NULL;
+}
+
+int Thread::GetThreadCount()
+{
+	m_mutexThread.Lock();
+	int iThreadCount = m_iThreadCount;
+	m_mutexThread.Unlock();
+	return iThreadCount;
+}
+

Thread.h

@@ -1,8 +1,8 @@
 /*
- *  This file is part of nzbget
+ *  This file if part of nzbget
  *
- *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
- *  Copyright (C) 2007-2010 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -16,7 +16,7 @@
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  *
  * $Revision$
  * $Date$
@@ -27,10 +27,19 @@
 #ifndef THREAD_H
 #define THREAD_H
 
+#ifndef WIN32
+#include <pthread.h>
+#include <semaphore.h>
+#endif
+
 class Mutex
 {
 private:
-	void*					m_pMutexObj;
+#ifdef WIN32
+	CRITICAL_SECTION		m_mutexObj;
+#else
+	pthread_mutex_t			m_mutexObj;
+#endif
 	
 public:
 							Mutex();
@@ -39,45 +48,50 @@ public:
 	void					Unlock();
 };
 
-#ifdef HAVE_SPINLOCK
-class SpinLock
+
+class Semaphore
 {
 private:
 #ifdef WIN32
-	void*					m_pSpinLockObj;
+	HANDLE					m_semObj;
 #else
-	volatile void*			m_pSpinLockObj;
+	sem_t					m_semObj;
 #endif
 	
 public:
-							SpinLock();
-							~SpinLock();
-	void					Lock();
-	void					Unlock();
+							Semaphore();
+							Semaphore(int iValue);
+							~Semaphore();
+	void					Post();
+	bool					Wait();
+	bool					TimedWait(int iMSec);
+	bool					IsLocked();
 };
-#endif
+
 
 class Thread
 {
 private:
-	static Mutex*			m_pMutexThread;
+	static Mutex			m_mutexThread;
 	static int				m_iThreadCount;
-	void*	 				m_pThreadObj;
+#ifdef WIN32
+	HANDLE	 				m_Thread;
+#else
+	pthread_t 				m_Thread;
+#endif
 	bool 					m_bRunning;
 	bool					m_bStopped;
 	bool					m_bAutoDestroy;
 
 #ifdef WIN32
-	static void __cdecl 	thread_handler(void* pObject);
+	static DWORD WINAPI		thread_handler(void* pObject);
 #else
 	static void				*thread_handler(void* pObject);
 #endif
 
 public:
-							Thread();
+	Thread();
 	virtual 				~Thread();
-	static void				Init();
-	static void				Final();
 
 	virtual void 			Start();
 	virtual void 			Stop();
@@ -90,6 +104,9 @@ public:
 	void					SetAutoDestroy(bool bAutoDestroy) { m_bAutoDestroy = bAutoDestroy; }
 	static int				GetThreadCount();
 
+	static void				Init();
+	static void				Final();
+
 protected:
 	virtual void 			Run() {}; // Virtual function - override in derivatives
 };

Util.cpp

@@ -0,0 +1,219 @@
+/*
+ *  This file if part of nzbget
+ *
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <string.h>
+
+#ifdef WIN32
+#include "win32.h"
+#endif
+
+#include <string.h>
+
+#include "nzbget.h"
+#include "Util.h"
+
+char* BaseFileName(const char* filename)
+{
+	char* p = (char*)strrchr(filename, PATH_SEPARATOR);
+	char* p1 = (char*)strrchr(filename, ALT_PATH_SEPARATOR);
+	if (p1)
+	{
+		if ((p && p < p1) || !p)
+		{
+			p = p1;
+		}
+	}
+	if (p)
+	{
+		return p + 1;
+	}
+	else
+	{
+		return (char*)filename;
+	}
+}
+
+#ifdef WIN32
+
+// getopt for WIN32:
+// from http://www.codeproject.com/cpp/xgetopt.asp
+// Original Author:  Hans Dietrich (hdietrich2@hotmail.com)
+// Released to public domain from author (thanks)
+// Slightly modified by Andrei Prygounkov
+
+char	*optarg;		// global argument pointer
+int		optind = 0; 	// global argv index
+
+int getopt(int argc, char *argv[], char *optstring)
+{
+	static char *next = NULL;
+	if (optind == 0)
+		next = NULL;
+
+	optarg = NULL;
+
+	if (next == NULL || *next == '\0')
+	{
+		if (optind == 0)
+			optind++;
+
+		if (optind >= argc || argv[optind][0] != '-' || argv[optind][1] == '\0')
+		{
+			optarg = NULL;
+			if (optind < argc)
+				optarg = argv[optind];
+			return -1;
+		}
+
+		if (strcmp(argv[optind], "--") == 0)
+		{
+			optind++;
+			optarg = NULL;
+			if (optind < argc)
+				optarg = argv[optind];
+			return -1;
+		}
+
+		next = argv[optind];
+		next++;		// skip past -
+		optind++;
+	}
+
+	char c = *next++;
+	char *cp = strchr(optstring, c);
+
+	if (cp == NULL || c == ':')
+		return '?';
+
+	cp++;
+	if (*cp == ':')
+	{
+		if (*next != '\0')
+		{
+			optarg = next;
+			next = NULL;
+		}
+		else if (optind < argc)
+		{
+			optarg = argv[optind];
+			optind++;
+		}
+		else
+		{
+			return '?';
+		}
+	}
+
+	return c;
+}
+
+DirBrowser::DirBrowser(const char* szPath)
+{
+	char szMask[MAX_PATH + 1];
+	int len = strlen(szPath);
+	if (szPath[len] == '\\' || szPath[len] == '/')
+	{
+		snprintf(szMask, MAX_PATH + 1, "%s*.*", szPath);
+	}
+	else
+	{
+		snprintf(szMask, MAX_PATH + 1, "%s%c*.*", szPath, (int)PATH_SEPARATOR);
+	}
+	szMask[MAX_PATH] = '\0';
+	m_hFile = _findfirst(szMask, &m_FindData);
+	m_bFirst = true;
+}
+
+DirBrowser::~DirBrowser()
+{
+	if (m_hFile != -1L)
+	{
+		_findclose(m_hFile);
+	}
+}
+
+const char* DirBrowser::Next()
+{
+	bool bOK = false;
+	if (m_bFirst)
+	{
+		bOK = m_hFile != -1L;
+		m_bFirst = false;
+	}
+	else
+	{
+		bOK = _findnext(m_hFile, &m_FindData) == 0;
+	}
+	if (bOK)
+	{
+		return m_FindData.name;
+	}
+	return NULL;
+}
+
+#else
+
+DirBrowser::DirBrowser(const char* szPath)
+{
+	m_pDir = opendir(szPath);
+}
+
+DirBrowser::~DirBrowser()
+{
+	if (m_pDir)
+	{
+		closedir(m_pDir);
+	}
+}
+
+const char* DirBrowser::Next()
+{
+	if (m_pDir)
+	{
+		m_pFindData = readdir(m_pDir);
+		if (m_pFindData)
+		{
+			return m_pFindData->d_name;
+		}
+	}
+	return NULL;
+}
+
+#endif
+
+void NormalizePathSeparators(char* Path)
+{
+	for (char* p = Path; *p; p++) 
+	{
+		if (*p == ALT_PATH_SEPARATOR) 
+		{
+			*p = PATH_SEPARATOR;
+		}
+	}
+}

Util.h

@@ -0,0 +1,64 @@
+/*
+ *  This file if part of nzbget
+ *
+ *  Copyright (C) 2007  Andrei Prygounkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifndef UTIL_H
+#define UTIL_H
+
+#ifdef WIN32
+#include <stdio.h>
+#include <io.h>
+#else
+#include <dirent.h>
+#endif
+
+#ifdef WIN32
+extern int optind, opterr;
+extern char *optarg;
+int getopt(int argc, char *argv[], char *optstring);
+#endif
+
+class DirBrowser
+{
+private:
+#ifdef WIN32
+	struct _finddata_t	m_FindData;
+	intptr_t			m_hFile;
+	bool				m_bFirst;
+#else
+	DIR*				m_pDir;
+	struct dirent*		m_pFindData;
+#endif
+
+public:
+						DirBrowser(const char* szPath);
+						~DirBrowser();
+	const char*			Next();
+};
+
+char* BaseFileName(const char* filename);
+
+void NormalizePathSeparators(char* Path);
+
+#endif

aclocal.m4

@@ -1,4 +1,4 @@
-# generated automatically by aclocal 1.9.6 -*- Autoconf -*-
+# generated automatically by aclocal 1.9.5 -*- Autoconf -*-
 
 # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
 # 2005  Free Software Foundation, Inc.
@@ -11,164 +11,6 @@
 # even the implied warranty of MERCHANTABILITY or FITNESS FOR A
 # PARTICULAR PURPOSE.
 
-# pkg.m4 - Macros to locate and utilise pkg-config.            -*- Autoconf -*-
-# 
-# Copyright © 2004 Scott James Remnant <scott@netsplit.com>.
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-#
-# As a special exception to the GNU General Public License, if you
-# distribute this file as part of a program that contains a
-# configuration script generated by Autoconf, you may include it under
-# the same distribution terms that you use for the rest of that program.
-
-# PKG_PROG_PKG_CONFIG([MIN-VERSION])
-# ----------------------------------
-AC_DEFUN([PKG_PROG_PKG_CONFIG],
-[m4_pattern_forbid([^_?PKG_[A-Z_]+$])
-m4_pattern_allow([^PKG_CONFIG(_PATH)?$])
-AC_ARG_VAR([PKG_CONFIG], [path to pkg-config utility])dnl
-if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
-	AC_PATH_TOOL([PKG_CONFIG], [pkg-config])
-fi
-if test -n "$PKG_CONFIG"; then
-	_pkg_min_version=m4_default([$1], [0.9.0])
-	AC_MSG_CHECKING([pkg-config is at least version $_pkg_min_version])
-	if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then
-		AC_MSG_RESULT([yes])
-	else
-		AC_MSG_RESULT([no])
-		PKG_CONFIG=""
-	fi
-		
-fi[]dnl
-])# PKG_PROG_PKG_CONFIG
-
-# PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
-#
-# Check to see whether a particular set of modules exists.  Similar
-# to PKG_CHECK_MODULES(), but does not set variables or print errors.
-#
-#
-# Similar to PKG_CHECK_MODULES, make sure that the first instance of
-# this or PKG_CHECK_MODULES is called, or make sure to call
-# PKG_CHECK_EXISTS manually
-# --------------------------------------------------------------
-AC_DEFUN([PKG_CHECK_EXISTS],
-[AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl
-if test -n "$PKG_CONFIG" && \
-    AC_RUN_LOG([$PKG_CONFIG --exists --print-errors "$1"]); then
-  m4_ifval([$2], [$2], [:])
-m4_ifvaln([$3], [else
-  $3])dnl
-fi])
-
-
-# _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES])
-# ---------------------------------------------
-m4_define([_PKG_CONFIG],
-[if test -n "$PKG_CONFIG"; then
-    if test -n "$$1"; then
-        pkg_cv_[]$1="$$1"
-    else
-        PKG_CHECK_EXISTS([$3],
-                         [pkg_cv_[]$1=`$PKG_CONFIG --[]$2 "$3" 2>/dev/null`],
-			 [pkg_failed=yes])
-    fi
-else
-	pkg_failed=untried
-fi[]dnl
-])# _PKG_CONFIG
-
-# _PKG_SHORT_ERRORS_SUPPORTED
-# -----------------------------
-AC_DEFUN([_PKG_SHORT_ERRORS_SUPPORTED],
-[AC_REQUIRE([PKG_PROG_PKG_CONFIG])
-if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
-        _pkg_short_errors_supported=yes
-else
-        _pkg_short_errors_supported=no
-fi[]dnl
-])# _PKG_SHORT_ERRORS_SUPPORTED
-
-
-# PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND],
-# [ACTION-IF-NOT-FOUND])
-#
-#
-# Note that if there is a possibility the first call to
-# PKG_CHECK_MODULES might not happen, you should be sure to include an
-# explicit call to PKG_PROG_PKG_CONFIG in your configure.ac
-#
-#
-# --------------------------------------------------------------
-AC_DEFUN([PKG_CHECK_MODULES],
-[AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl
-AC_ARG_VAR([$1][_CFLAGS], [C compiler flags for $1, overriding pkg-config])dnl
-AC_ARG_VAR([$1][_LIBS], [linker flags for $1, overriding pkg-config])dnl
-
-pkg_failed=no
-AC_MSG_CHECKING([for $1])
-
-_PKG_CONFIG([$1][_CFLAGS], [cflags], [$2])
-_PKG_CONFIG([$1][_LIBS], [libs], [$2])
-
-m4_define([_PKG_TEXT], [Alternatively, you may set the environment variables $1[]_CFLAGS
-and $1[]_LIBS to avoid the need to call pkg-config.
-See the pkg-config man page for more details.])
-
-if test $pkg_failed = yes; then
-        _PKG_SHORT_ERRORS_SUPPORTED
-        if test $_pkg_short_errors_supported = yes; then
-	        $1[]_PKG_ERRORS=`$PKG_CONFIG --short-errors --errors-to-stdout --print-errors "$2"`
-        else 
-	        $1[]_PKG_ERRORS=`$PKG_CONFIG --errors-to-stdout --print-errors "$2"`
-        fi
-	# Put the nasty error message in config.log where it belongs
-	echo "$$1[]_PKG_ERRORS" >&AS_MESSAGE_LOG_FD
-
-	ifelse([$4], , [AC_MSG_ERROR(dnl
-[Package requirements ($2) were not met:
-
-$$1_PKG_ERRORS
-
-Consider adjusting the PKG_CONFIG_PATH environment variable if you
-installed software in a non-standard prefix.
-
-_PKG_TEXT
-])],
-		[AC_MSG_RESULT([no])
-                $4])
-elif test $pkg_failed = untried; then
-	ifelse([$4], , [AC_MSG_FAILURE(dnl
-[The pkg-config script could not be found or is too old.  Make sure it
-is in your PATH or set the PKG_CONFIG environment variable to the full
-path to pkg-config.
-
-_PKG_TEXT
-
-To get pkg-config, see <http://pkg-config.freedesktop.org/>.])],
-		[$4])
-else
-	$1[]_CFLAGS=$pkg_cv_[]$1[]_CFLAGS
-	$1[]_LIBS=$pkg_cv_[]$1[]_LIBS
-        AC_MSG_RESULT([yes])
-	ifelse([$3], , :, [$3])
-fi[]dnl
-])# PKG_CHECK_MODULES
-
 # Copyright (C) 2002, 2003, 2005  Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
@@ -186,7 +28,7 @@ AC_DEFUN([AM_AUTOMAKE_VERSION], [am__api_version="1.9"])
 # Call AM_AUTOMAKE_VERSION so it can be traced.
 # This function is AC_REQUIREd by AC_INIT_AUTOMAKE.
 AC_DEFUN([AM_SET_CURRENT_AUTOMAKE_VERSION],
-	 [AM_AUTOMAKE_VERSION([1.9.6])])
+	 [AM_AUTOMAKE_VERSION([1.9.5])])
 
 # AM_AUX_DIR_EXPAND                                         -*- Autoconf -*-
 

config.h.in

@@ -6,22 +6,20 @@
 /* Define to 1 to not use curses */
 #undef DISABLE_CURSES
 
-/* Define to 1 to disable gzip-support */
-#undef DISABLE_GZIP
-
 /* Define to 1 to disable smart par-verification and restoration */
 #undef DISABLE_PARCHECK
 
-/* Define to 1 to not use TLS/SSL */
-#undef DISABLE_TLS
+/* Define to 1 to show progress during par-check (it must be disabled if
+   sigc++ doesn't work correctly) */
+#undef ENABLE_PARPROGRESS
+
+/* Define to 1 to include support for uulib */
+#undef ENABLE_UULIB
 
 /* Define to the name of macro which returns the name of function being
    compiled */
 #undef FUNCTION_MACRO_NAME
 
-/* Define to 1 to create stacktrace on segmentation faults */
-#undef HAVE_BACKTRACE
-
 /* Define to 1 if ctime_r takes 2 arguments */
 #undef HAVE_CTIME_R_2
 
@@ -31,15 +29,6 @@
 /* Define to 1 if you have the <curses.h> header file. */
 #undef HAVE_CURSES_H
 
-/* Define to 1 if getaddrinfo is supported */
-#undef HAVE_GETADDRINFO
-
-/* Define to 1 if gethostbyname_r is supported */
-#undef HAVE_GETHOSTBYNAME_R
-
-/* Define to 1 if gethostbyname_r takes 3 arguments */
-#undef HAVE_GETHOSTBYNAME_R_3
-
 /* Define to 1 if gethostbyname_r takes 5 arguments */
 #undef HAVE_GETHOSTBYNAME_R_5
 
@@ -52,9 +41,6 @@
 /* Define to 1 if you have the <inttypes.h> header file. */
 #undef HAVE_INTTYPES_H
 
-/* Define to 1 to use GnuTLS library for TLS/SSL-support. */
-#undef HAVE_LIBGNUTLS
-
 /* Define to 1 if you have the <memory.h> header file. */
 #undef HAVE_MEMORY_H
 
@@ -64,20 +50,8 @@
 /* Define to 1 if you have the <ncurses/ncurses.h> header file. */
 #undef HAVE_NCURSES_NCURSES_H
 
-/* Define to 1 to use OpenSSL library for TLS/SSL-support. */
-#undef HAVE_OPENSSL
-
-/* Define to 1 if libpar2 has recent bugfixes-patch (version 2) */
-#undef HAVE_PAR2_BUGFIXES_V2
-
-/* Define to 1 if libpar2 supports cancelling (needs a special patch) */
-#undef HAVE_PAR2_CANCEL
-
-/* Define to 1 if you have the <regex.h> header file. */
-#undef HAVE_REGEX_H
-
-/* Define to 1 if spinlocks are supported */
-#undef HAVE_SPINLOCK
+/* Define to 1 to use pragma pack directive in MessageBase.h */
+#undef HAVE_PRAGMA_PACK
 
 /* Define to 1 if you have the <stdint.h> header file. */
 #undef HAVE_STDINT_H
@@ -91,9 +65,6 @@
 /* Define to 1 if you have the <string.h> header file. */
 #undef HAVE_STRING_H
 
-/* Define to 1 if you have the <sys/prctl.h> header file. */
-#undef HAVE_SYS_PRCTL_H
-
 /* Define to 1 if you have the <sys/stat.h> header file. */
 #undef HAVE_SYS_STAT_H
 
@@ -124,20 +95,8 @@
 /* Define to the version of this package. */
 #undef PACKAGE_VERSION
 
-/* Define to 1 to install an empty signal handler for SIGCHLD */
-#undef SIGCHLD_HANDLER
-
-/* Determine what socket length (socklen_t) data type is */
-#undef SOCKLEN_T
-
 /* Define to 1 if you have the ANSI C header files. */
 #undef STDC_HEADERS
 
 /* Version number of package */
 #undef VERSION
-
-/* Number of bits in a file offset, on hosts where this is settable. */
-#undef _FILE_OFFSET_BITS
-
-/* Define for large files, on AIX-style hosts. */
-#undef _LARGE_FILES

configure.ac

@@ -2,18 +2,41 @@
 # Process this file with autoconf to produce a configure script.
 
 AC_PREREQ(2.59)
-AC_INIT(nzbget, 13.0, hugbug@users.sourceforge.net)
-AC_CANONICAL_SYSTEM
-AM_INIT_AUTOMAKE(nzbget, 13.0)
-AC_CONFIG_SRCDIR([daemon/main/nzbget.cpp])
+AC_INIT(nzbget, 0.3.0, hugbug@users.sourceforge.net)
+AM_INIT_AUTOMAKE(nzbget, 0.3.0)
+AC_CONFIG_SRCDIR([nzbget.cpp])
 AC_CONFIG_HEADERS([config.h])
 
 
-dnl
-dnl Set default library path, if not specified in environment variable "LIBPREF".
-dnl
+dnl Architecture check
+AC_CANONICAL_HOST
+case "$host" in
+  *86-*-linux*)
+    LIBPREF1="/usr"
+    CFLAGS1="${CFLAGS} -m486"
+    CPPFLAGS1="${CPPFLAGS} -D_GNU_SOURCE"
+    ;;
+  *-linux*)
+    LIBPREF1="/usr"
+    CPPFLAGS1="${CPPFLAGS} -D_GNU_SOURCE"
+    ;;
+  *-freebsd*)
+    LIBPREF1="/usr/local"
+    ;;
+  *-solaris*)
+    LIBPREF1="/usr"
+    ;;
+esac
+
+
 if test "$LIBPREF" = ""; then
-	LIBPREF="/usr"
+	LIBPREF="$LIBPREF1"
+fi
+if test "$CFLAGS" = ""; then
+	CFLAGS="$CFLAGS1"
+fi
+if test "$CPPFLAGS" = ""; then
+	CPPFLAGS="$CPPFLAGS1"
 fi
 
 
@@ -21,23 +44,30 @@ dnl
 dnl Check for programs.
 dnl
 AC_PROG_CXX
+AC_PROG_CC
+AC_PROG_GCC_TRADITIONAL
+AC_PROG_RANLIB
+AC_PROG_MAKE_SET
+AC_PATH_PROG(FALSE, false, /usr/bin/false)
+AC_PATH_PROG(TRUE, true, /usr/bin/true)
+AC_PATH_PROG(RM, rm, $FALSE)
+AC_PATH_PROG(LN, ln, $FALSE)
 AC_PATH_PROG(TAR, tar, $FALSE)
+AC_PATH_PROG(AR, ar, $FALSE)
 AC_PATH_PROG(MAKE, make, $FALSE)
+AC_PATH_PROG(CXXCPP, cpp, $FALSE)
+AC_PATH_PROG(MV, mv, $FALSE)
+AC_PATH_PROG(MKDIR, mkdir, $FALSE)
+AC_PATH_PROG(CP, cp, $FALSE)
 AC_PROG_INSTALL
 
 
-dnl
-dnl Do all tests with c++ compiler.
-dnl
-AC_LANG(C++)
-
-
 dnl
 dnl Checks for header files.
 dnl
-AC_CHECK_HEADERS(sys/prctl.h)
-AC_CHECK_HEADERS(regex.h)
-
+dnl AC_CHECK_HEADERS(stdarg.h time.h stdlib.h stdio.h unistd.h errno.h string.h sys/stat.h sys/time.h)
+dnl AC_CHECK_HEADERS(libgen.h pwd.h getopt.h dirent.h fcntl.h pthread.h semaphore.h)
+dnl AC_CHECK_HEADERS(sys/socket.h sys/types.h netinet/in.h arpa/inet.h netdb.h)
 
 dnl
 dnl Check for libs
@@ -45,6 +75,7 @@ dnl
 AC_SEARCH_LIBS([pthread_create], [pthread])
 AC_SEARCH_LIBS([socket], [socket])
 AC_SEARCH_LIBS([inet_addr], [nsl])
+AC_SEARCH_LIBS([gethostbyname_r], [nsl])
 AC_SEARCH_LIBS([hstrerror], [resolv])
 
 
@@ -52,13 +83,8 @@ dnl
 dnl Getopt
 dnl
 AC_CHECK_FUNC(getopt_long,
-	[AC_DEFINE([HAVE_GETOPT_LONG], 1, [Define to 1 if getopt_long is supported])],)
-
-
-dnl
-dnl use 64-Bits for file sizes
-dnl
-AC_SYS_LARGEFILE
+	[AC_DEFINE([HAVE_GETOPT_LONG], 1, [Define to 1 if getopt_long is supported])],
+	[AC_LIBOBJ(getopt) AC_LIBOBJ(getopt1)])
 
 
 dnl
@@ -69,7 +95,6 @@ AC_TRY_COMPILE(
 	[#include <time.h>],
 	[ time_t clock; char buf[26];	ctime_r(&clock, buf, 26); ],
 	AC_MSG_RESULT([[yes, and it takes 3 arguments]])
-	FOUND="yes"
 	AC_DEFINE([HAVE_CTIME_R_3], 1, [Define to 1 if ctime_r takes 3 arguments]),
 	FOUND="no")
 if test "$FOUND" = "no"; then
@@ -83,125 +108,93 @@ AC_TRY_COMPILE(
 fi
 if test "$FOUND" = "no"; then
 	AC_MSG_RESULT([no])
-	AC_MSG_ERROR("function ctime_r not found")
+	AC_MSG_ERROR("function ctime_r not found.")
 fi
 
 
 dnl
-dnl check getaddrinfo
+dnl check gethostbyname_r
 dnl
-AC_CHECK_FUNC(getaddrinfo,
-	FOUND="yes"
-	[AC_DEFINE([HAVE_GETADDRINFO], 1, [Define to 1 if getaddrinfo is supported])]
-	AC_SEARCH_LIBS([getaddrinfo], [nsl]),
+AC_MSG_CHECKING(for gethostbyname_r)
+AC_TRY_COMPILE(
+	[#include <netdb.h>],
+	[	char* szHost; struct hostent hinfobuf; char* strbuf; int h_errnop;
+		struct hostent* hinfo = gethostbyname_r(szHost, &hinfobuf, strbuf, 1024, &h_errnop); ],
+	AC_MSG_RESULT([[yes, and it takes 5 arguments]])
+	FOUND="yes"                      
+	AC_DEFINE([HAVE_GETHOSTBYNAME_R_5], 1, [Define to 1 if gethostbyname_r takes 5 arguments]),
 	FOUND="no")
-
-
-dnl
-dnl check gethostbyname_r, if getaddrinfo is not available
-dnl
 if test "$FOUND" = "no"; then
-	AC_MSG_CHECKING(for gethostbyname_r)
-	
-	AC_TRY_COMPILE(
-		[#include <netdb.h>],
-		[	char* szHost; struct hostent hinfobuf; char* strbuf; int h_errnop;
-			struct hostent* hinfo = gethostbyname_r(szHost, &hinfobuf, strbuf, 1024, &h_errnop); ],
-		AC_MSG_RESULT([[yes, and it takes 5 arguments]])
-		FOUND="yes"                      
-		AC_DEFINE([HAVE_GETHOSTBYNAME_R_5], 1, [Define to 1 if gethostbyname_r takes 5 arguments]),
-		FOUND="no")
-	
-	if test "$FOUND" = "no"; then
-	AC_TRY_COMPILE(
-		[#include <netdb.h>],
-		[	char* szHost; struct hostent* hinfo; struct hostent hinfobuf; char* strbuf; int h_errnop;
-			int err = gethostbyname_r(szHost, &hinfobuf, strbuf, 1024, &hinfo, &h_errnop); ],
-		AC_MSG_RESULT([[yes, and it takes 6 arguments]])
-		FOUND="yes"
-		AC_DEFINE([HAVE_GETHOSTBYNAME_R_6], 1, [Define to 1 if gethostbyname_r takes 6 arguments]),
-		FOUND="no")
-	fi
-	
-	if test "$FOUND" = "no"; then
-	AC_TRY_COMPILE(
-		[#include <netdb.h>],
-		[	char* szHost; struct hostent hinfo; struct hostent_data hinfobuf; 
-			int err = gethostbyname_r(szHost, &hinfo, &hinfobuf); ],
-		AC_MSG_RESULT([[yes, and it takes 3 arguments]])
-		FOUND="yes"
-		AC_DEFINE([HAVE_GETHOSTBYNAME_R_3], 1, [Define to 1 if gethostbyname_r takes 3 arguments]),
-		AC_MSG_RESULT([[no]])
-		FOUND="no")
-	fi
-	
-	if test "$FOUND" = "yes"; then
-		AC_DEFINE([HAVE_GETHOSTBYNAME_R], 1, [Define to 1 if gethostbyname_r is supported])
-		AC_SEARCH_LIBS([gethostbyname_r], [nsl])
-	fi
+AC_TRY_COMPILE(
+	[#include <netdb.h>],
+	[	char* szHost; struct hostent* hinfo; struct hostent hinfobuf; char* strbuf; int h_errnop;
+		int err = gethostbyname_r(szHost, &hinfobuf, strbuf, 1024, &hinfo, &h_errnop); ],
+	AC_MSG_RESULT([[yes, and it takes 6 arguments]])
+	FOUND="yes"
+	AC_DEFINE([HAVE_GETHOSTBYNAME_R_6], 1, [Define to 1 if gethostbyname_r takes 6 arguments]),
+	FOUND="no")
+fi
+if test "$FOUND" = "no"; then
+	AC_MSG_RESULT([no])
+	AC_MSG_ERROR("function gethostbyname_r not found.")
 fi
 
 
 dnl
-dnl cCheck if spinlocks are available
+dnl check for __FUNCTION__ or __func__ macro
 dnl
-AC_CHECK_FUNC(pthread_spin_init,
-	[AC_DEFINE([HAVE_SPINLOCK], 1, [Define to 1 if spinlocks are supported])]
-	AC_SEARCH_LIBS([pthread_spin_init], [pthread]),)
+AC_MSG_CHECKING(for __FUNCTION__ macro)
+AC_LANG_PUSH(C++)
+AC_TRY_COMPILE([#include <stdio.h>], [printf("%s\n", __FUNCTION__);],
+	AC_MSG_RESULT([yes])
+	AC_DEFINE([FUNCTION_MACRO_NAME],[__FUNCTION__],[Define to the name of macro which returns the name of funtion being compiled])
+	HAVE_FUNCTION_MACRO=yes,
+	AC_MSG_RESULT([no]))
+AC_LANG_POP(C++)
+if test "$HAVE_FUNCTION_MACRO" != "yes"; then
+	AC_MSG_CHECKING(for __func__ macro)
+	AC_LANG_PUSH(C++)
+	AC_TRY_COMPILE([#include <stdio.h>], [printf("%s\n", __func__);],
+		AC_MSG_RESULT([yes])
+		AC_DEFINE([FUNCTION_MACRO_NAME],[__func__],[Define to the name of macro which returns the name of function being compiled])
+		HAVE_FUNCTION_MACRO=yes,
+		AC_MSG_RESULT([no]))
+	AC_LANG_POP(C++)
+fi
+if test "$HAVE_FUNCTION_MACRO" != "yes"; then
+	AC_DEFINE([FUNCTION_MACRO_NAME],[NULL],[Define to the name of macro which returns the name of function being compiled])
+fi
 
 
 dnl
-dnl Determine what socket length (socklen_t) data type is
+dnl check for pragma pack
 dnl
-AC_MSG_CHECKING([for type of socket length (socklen_t)])
-AC_TRY_COMPILE([
-#include <stddef.h>
-#include <sys/types.h>
-#include <sys/socket.h>],[
-(void)getsockopt (1, 1, 1, NULL, (socklen_t*)NULL)],[
-  AC_MSG_RESULT(socklen_t)
-  SOCKLEN_T=socklen_t],[
-  AC_TRY_COMPILE([
-#include <stddef.h>
-#include <sys/types.h>
-#include <sys/socket.h>],[
-(void)getsockopt (1, 1, 1, NULL, (size_t*)NULL)],[
-    AC_MSG_RESULT(size_t)
-    SOCKLEN_T=size_t],[
-    AC_TRY_COMPILE([
-#include <stddef.h>
-#include <sys/types.h>
-#include <sys/socket.h>],[
-(void)getsockopt (1, 1, 1, NULL, (int*)NULL)],[
-      AC_MSG_RESULT(int)
-      SOCKLEN_T=int],[
-      AC_MSG_WARN(could not determine)
-      SOCKLEN_T=int])])])
-AC_DEFINE_UNQUOTED(SOCKLEN_T, $SOCKLEN_T, [Determine what socket length (socklen_t) data type is])
+AC_MSG_CHECKING(for pragma pack)
+AC_TRY_COMPILE([#pragma pack(1)
+#pragma pack()],,
+	AC_MSG_RESULT([yes])
+	AC_DEFINE([HAVE_PRAGMA_PACK],1,[Define to 1 to use pragma pack directive in MessageBase.h]),
+	AC_MSG_RESULT([no]))
 
 
 dnl 
 dnl checks for libxml2 includes and libraries.
-dnl
+dnl 
+INCVAL="${LIBPREF}/include/libxml2"
+LIBVAL="${LIBPREF}/lib"
 AC_ARG_WITH(libxml2_includes,
-	[AS_HELP_STRING([--with-libxml2-includes=DIR], [libxml2 include directory])],
-	[CPPFLAGS="${CPPFLAGS} -I${withval}"]
-	[INCVAL="yes"],
-	[INCVAL="no"])
-AC_ARG_WITH(libxml2_libraries,
-	[AS_HELP_STRING([--with-libxml2-libraries=DIR], [libxml2 library directory])],
-	[LDFLAGS="${LDFLAGS} -L${withval}"]
-	[LIBVAL="yes"],
-	[LIBVAL="no"])
-if test "$INCVAL" = "no" -o "$LIBVAL" = "no"; then
-	PKG_CHECK_MODULES(libxml2, libxml-2.0,
-		[LIBS="${LIBS} $libxml2_LIBS"]
-		[CPPFLAGS="${CPPFLAGS} $libxml2_CFLAGS"])
-fi
+      [  --with-libxml2-includes=DIR	libxml2 include directory],
+      [INCVAL="$withval"])
+CPPFLAGS="${CPPFLAGS} -I${INCVAL}"
+CFLAGS="${CFLAGS} -I${INCVAL}"
 AC_CHECK_HEADER(libxml/tree.h,,
-	AC_MSG_ERROR("libxml2 header files not found"))
+	AC_MSG_ERROR("libxml2 header files were not found."))
+AC_ARG_WITH(libxml2_libraries,
+	[  --with-libxml2-libraries=DIR	libxml2 library directory],
+	[LIBVAL="$withval"])
+LDFLAGS="${LDFLAGS} -L${LIBVAL}"
 AC_SEARCH_LIBS([xmlNewNode], [xml2], ,
-	AC_MSG_ERROR("libxml2 library not found"))
+	AC_MSG_ERROR("libxml2 library not found in $LIBVAL."))
 
 
 dnl
@@ -209,19 +202,20 @@ dnl Use curses. Deafult: yes
 dnl
 AC_MSG_CHECKING(whether to use curses)
 AC_ARG_ENABLE(curses,
-	[AS_HELP_STRING([--disable-curses], [do not use curses (removes dependency from curses-library)])],
-	[USECURSES=$enableval],
-	[USECURSES=yes] )
+	[  --disable-curses		do not use curses (removes dependency from curses-library and makes executable smaller)],
+	[ USECURSES=$enableval ],
+	[ USECURSES=yes] )
 AC_MSG_RESULT($USECURSES)
 if test "$USECURSES" = "yes"; then
 	INCVAL="${LIBPREF}/include"
 	LIBVAL="${LIBPREF}/lib"
 	AC_ARG_WITH(libcurses_includes,
-		[AS_HELP_STRING([--with-libcurses-includes=DIR], [libcurses include directory])],
+		[  --with-libcurses-includes=DIR	libcurses include directory],
 		[INCVAL="$withval"])
 	CPPFLAGS="${CPPFLAGS} -I${INCVAL}"
+	CFLAGS="${CFLAGS} -I${INCVAL}"
 	AC_ARG_WITH(libcurses_libraries,
-		[AS_HELP_STRING([--with-libcurses-libraries=DIR], [libcurses library directory])],
+		[  --with-libcurses-libraries=DIR	libcurses library directory],
 		[LIBVAL="$withval"])
 	LDFLAGS="${LDFLAGS} -L${LIBVAL}"
 	
@@ -242,7 +236,7 @@ if test "$USECURSES" = "yes"; then
 			FOUND=no)
 	fi
 	if test "$FOUND" = "no"; then
-		AC_MSG_ERROR([Couldn't find curses headers (ncurses.h or curses.h)])
+		AC_MSG_ERROR([Couldn't find curses headers (ncurses.h or curses.h).])
 	fi
 	AC_SEARCH_LIBS([refresh], [ncurses curses],, 
 		AC_ERROR([Couldn't find curses library]))
@@ -252,11 +246,47 @@ fi
 
 
 dnl
-dnl Use libpar2 for par-checking. Deafult: no
+dnl Use uulib. Deafult: no
+dnl
+AC_MSG_CHECKING(whether to use uulib for decoding and joining)
+AC_ARG_ENABLE(uulib,
+	[  --enable-uulib		use uulib for decoding and joining],
+	[ ENABLEUULIB=$enableval ],
+	[ ENABLEUULIB=no] )
+AC_MSG_RESULT($ENABLEUULIB)
+if test "$ENABLEUULIB" = "yes"; then
+	AC_DEFINE([ENABLE_UULIB],1,[Define to 1 to include support for uulib])
+
+	dnl 
+	dnl checks for uulib includes and libraries.
+	dnl
+	INCVAL="${LIBPREF}/include"
+	LIBVAL="${LIBPREF}/lib"
+	AC_ARG_WITH(uulib_includes,
+		[  --with-uulib-includes=DIR	uulib include directory],
+		[INCVAL="$withval"])
+
+	CPPFLAGS="${CPPFLAGS} -I${INCVAL}"
+	AC_CHECK_HEADER($INCVAL/uudeview.h,,
+		AC_MSG_ERROR("uulib header files were not found in $INCVAL."))
+
+	AC_ARG_WITH(uulib_libraries,
+		[  --with-uulib-libraries=DIR	uulib library directory],
+		[LIBVAL="$withval"])
+
+	LDFLAGS="${LDFLAGS} -L${LIBVAL}"
+
+	AC_SEARCH_LIBS([UUInitialize], [uu],,
+		AC_MSG_ERROR("uulib library not found in $LIBVAL."))
+fi
+
+
+dnl
+dnl Use lib2par for par-checking. Deafult: no
 dnl
 AC_MSG_CHECKING(whether to include code for par-checking)
 AC_ARG_ENABLE(parcheck,
-	[AS_HELP_STRING([--disable-parcheck], [do not include par-check/-repair-support (removes dependency from libpar2- and libsigc-libraries)])],
+	[  --enable-parcheck		include code for par-checking],
 	[ ENABLEPARCHECK=$enableval ],
 	[ ENABLEPARCHECK=yes] )
 AC_MSG_RESULT($ENABLEPARCHECK)
@@ -265,26 +295,23 @@ if test "$ENABLEPARCHECK" = "yes"; then
 	dnl 
 	dnl checks for libsigc++ includes and libraries (required for libpar2).
 	dnl
-
+	INCVAL="${LIBPREF}/include/sigc++-2.0"
+	LIBVAL="${LIBPREF}/lib"
 	AC_ARG_WITH(libsigc_includes,
-		[AS_HELP_STRING([--with-libsigc-includes=DIR], [libsigc++-2.0 include directory])],
-		[CPPFLAGS="${CPPFLAGS} -I${withval}"]
-		[INCVAL="yes"],
-		[INCVAL="no"])
-	AC_ARG_WITH(libsigc_libraries,
-		[AS_HELP_STRING([--with-libsigc-libraries=DIR], [libsigc++-2.0 library directory])],
-		[LDFLAGS="${LDFLAGS} -L${withval}"]
-		[CPPFLAGS="${CPPFLAGS} -I${withval}/sigc++-2.0/include"]
-		[LIBVAL="yes"],
-		[LIBVAL="no"])
-	if test "$INCVAL" = "no" -o "$LIBVAL" = "no"; then
-		PKG_CHECK_MODULES(libsigc, sigc++-2.0,
-			[LIBS="${LIBS} $libsigc_LIBS"]
-			[CPPFLAGS="${CPPFLAGS} $libsigc_CFLAGS"])
-	fi
+		[  --with-libsigc-includes=DIR	libsigc++-2.0 include directory],
+		[INCVAL="$withval"])
 	
+	AC_ARG_WITH(libsigc_libraries,
+		[  --with-libsigc-libraries=DIR	libsigc++-2.0 library directory],
+		[LIBVAL="$withval"])
+
+	LDFLAGS="${LDFLAGS} -L${LIBVAL}"
+	CPPFLAGS="${CPPFLAGS} -I${INCVAL} -I${LIBVAL}/sigc++-2.0/include"
+
+	AC_LANG_PUSH(C++)
 	AC_CHECK_HEADER(sigc++/type_traits.h,,
-		AC_MSG_ERROR("libsigc++-2.0 header files not found"))
+		AC_MSG_ERROR("libsigc++-2.0 header files were not found in $INCVAL."))
+	AC_LANG_POP(C++)
 
 	dnl
 	dnl checks for libpar2 includes and libraries.
@@ -292,277 +319,65 @@ if test "$ENABLEPARCHECK" = "yes"; then
 	INCVAL="${LIBPREF}/include"
 	LIBVAL="${LIBPREF}/lib"
 	AC_ARG_WITH(libpar2_includes,
-		[AS_HELP_STRING([--with-libpar2-includes=DIR], [libpar2 include directory])],
+		[  --with-libpar2-includes=DIR	libpar2 include directory],
 		[INCVAL="$withval"])
 
 	CPPFLAGS="${CPPFLAGS} -I${INCVAL}"
 	
+	AC_LANG_PUSH(C++)
 	AC_CHECK_HEADER(libpar2/libpar2.h,,
-		AC_MSG_ERROR("libpar2 header files not found"))
+		AC_MSG_ERROR("libpar2 header files were not found in $INCVAL."))
+	AC_LANG_POP(C++)
 
 	AC_ARG_WITH(libpar2_libraries,
-		[AS_HELP_STRING([--with-libpar2-libraries=DIR], [libpar2 library directory])],
+		[  --with-libpar2-libraries=DIR	libpar2 library directory],
 		[LIBVAL="$withval"])
 
 	LDFLAGS="${LDFLAGS} -L${LIBVAL}"
 
-	AC_SEARCH_LIBS([_ZN12Par2RepairerC1Ev], [par2], ,
-		AC_MSG_ERROR("libpar2 library not found"))
+	dnl Q: How to check for c++-class in library?
+		LIBS="${LIBS} -lpar2"
+	dnl		AC_CHECK_LIB(par2, GenerateCRC32Table, , FOUND=no)
+	dnl		if test "$FOUND" = "no"; then
+	dnl			AC_MSG_ERROR("libpar2 library not found in $LIBVAL.")
+	dnl		fi
 
 	dnl
-	dnl check if libpar2 library is linkable
+	dnl Enable par-check-progress (via sigc++)? Deafult: yes
+	dnl It doesn't work on WL500gP (uClibc), so we need a way to disable it
 	dnl
-	AC_MSG_CHECKING(for libpar2 linking)
-	AC_TRY_LINK(
-		[#include <libpar2/par2cmdline.h>]
-		[#include <libpar2/par2repairer.h>]
-		[ class Repairer : public Par2Repairer { }; ],
-		[ Repairer* p = new Repairer(); ],
-		AC_MSG_RESULT([[yes]]),
-		AC_MSG_RESULT([[no]])
-		AC_MSG_ERROR("libpar2 library not found"))
-
-	dnl
-	dnl check if libpar2 has support for cancelling
-	dnl
-	AC_MSG_CHECKING(whether libpar2 supports cancelling)
-	AC_TRY_COMPILE(
-		[#include <libpar2/par2cmdline.h>]
-		[#include <libpar2/par2repairer.h>]
-		[ class Repairer : public Par2Repairer { void test() { cancelled = true; } }; ],
-		[],
-		AC_MSG_RESULT([[yes]])
-		AC_DEFINE([HAVE_PAR2_CANCEL], 1, [Define to 1 if libpar2 supports cancelling (needs a special patch)]),
-		AC_MSG_RESULT([[no]]))
-
-	dnl
-	dnl check if libpar2 has recent bugfixes-patch
-	dnl
-	AC_MSG_CHECKING(whether libpar2 has recent bugfixes)
-	AC_TRY_COMPILE(
-		[#include <libpar2/par2cmdline.h>]
-		[#include <libpar2/par2repairer.h>]
-		[ class Repairer : public Par2Repairer { void test() { BugfixesPatchVersion2(); } }; ],
-		[],
-		AC_MSG_RESULT([[yes]])
-		PAR2PATCHV2=yes
-		AC_DEFINE([HAVE_PAR2_BUGFIXES_V2], 1, [Define to 1 if libpar2 has recent bugfixes-patch (version 2)]),
-		AC_MSG_RESULT([[no]])
-		PAR2PATCHV2=no)
-
-	if test "$PAR2PATCHV2" = "no" ; then
-		AC_ARG_ENABLE(libpar2-bugfixes-check,
-			[AS_HELP_STRING([--disable-libpar2-bugfixes-check], [do not check libpar2 version])],
-			[ PAR2PATCHCHECK=$enableval ],
-			[ PAR2PATCHCHECK=yes] )
-		if test "$PAR2PATCHCHECK" = "yes"; then
-			AC_ERROR([Your version of libpar2 doesn't include the recent bugfixes. Please update libpar2 to version 0.4 or newer (http://launchpad.net/libpar2). If you cannot install a newer version of libpar2, you can use configure parameter --disable-libpar2-bugfixes-check to suppress the check. Please note however that in this case the program may crash during par-check/repair. The update is highly recommended!])
-		fi
+	AC_MSG_CHECKING(whether to show progress during par-check )
+	AC_ARG_ENABLE(parprogress,
+		[  --disable-parprogress		do not show progress during par-check (it must be disabled if sigc++ doesn't work correctly)],
+		[ USEPARPROGRESS=$enableval ],
+		[ USEPARPROGRESS=yes] )
+	AC_MSG_RESULT($USEPARPROGRESS)
+	if test "$USEPARPROGRESS" = "yes"; then
+		AC_DEFINE([ENABLE_PARPROGRESS],1,[Define to 1 to show progress during par-check (it must be disabled if sigc++ doesn't work correctly)])
 	fi
-
+	
 else
 	AC_DEFINE([DISABLE_PARCHECK],1,[Define to 1 to disable smart par-verification and restoration])
 fi
 
 
-dnl
-dnl Use TLS/SSL. Deafult: yes
-dnl
-AC_MSG_CHECKING(whether to use TLS/SSL)
-AC_ARG_ENABLE(tls,
-	[AS_HELP_STRING([--disable-tls], [do not use TLS/SSL (removes dependency from TLS/SSL-libraries)])],
-	[ USETLS=$enableval ],
-	[ USETLS=yes] )
-AC_MSG_RESULT($USETLS)
-if test "$USETLS" = "yes"; then
-	AC_ARG_WITH(tlslib,
-		[AS_HELP_STRING([--with-tlslib=(OpenSSL, GnuTLS)], [TLS/SSL library to use])],
-		[TLSLIB="$withval"])
-	if test "$TLSLIB" != "GnuTLS" -a "$TLSLIB" != "OpenSSL" -a "$TLSLIB" != ""; then
-		AC_MSG_ERROR([Invalid argument for option --with-tlslib])
-	fi
-
-	if test "$TLSLIB" = "OpenSSL" -o "$TLSLIB" = ""; then
-		AC_ARG_WITH(openssl_includes,
-			[AS_HELP_STRING([--with-openssl-includes=DIR], [OpenSSL include directory])],
-			[CPPFLAGS="${CPPFLAGS} -I${withval}"]
-			[INCVAL="yes"],
-			[INCVAL="no"])
-		AC_ARG_WITH(openssl_libraries,
-			[AS_HELP_STRING([--with-openssl-libraries=DIR], [OpenSSL library directory])],
-			[LDFLAGS="${LDFLAGS} -L${withval}"]
-			[LIBVAL="yes"],
-			[LIBVAL="no"])
-		if test "$INCVAL" = "no" -o "$LIBVAL" = "no"; then
-			PKG_CHECK_MODULES(openssl, openssl,
-				[LIBS="${LIBS} $openssl_LIBS"]
-				[CPPFLAGS="${CPPFLAGS} $openssl_CFLAGS"],
-				FOUND=yes
-				FOUND=no)
-		fi
-
-		AC_CHECK_HEADER(openssl/ssl.h,
-			FOUND=yes
-			TLSHEADERS=yes,
-			FOUND=no)
-		if test "$FOUND" = "no" -a "$TLSLIB" = "OpenSSL"; then
-			AC_MSG_ERROR([Couldn't find OpenSSL headers (ssl.h)])
-		fi
-		if test "$FOUND" = "yes"; then
-			AC_SEARCH_LIBS([CRYPTO_set_locking_callback], [crypto],
-				AC_SEARCH_LIBS([SSL_library_init], [ssl],
-					FOUND=yes,
-					FOUND=no),
-				FOUND=no)
-			if test "$FOUND" = "no" -a "$TLSLIB" = "OpenSSL"; then
-				AC_MSG_ERROR([Couldn't find OpenSSL library])
-			fi
-			if test "$FOUND" = "yes"; then
-				TLSLIB="OpenSSL"
-				AC_DEFINE([HAVE_OPENSSL],1,[Define to 1 to use OpenSSL library for TLS/SSL-support.])
-			fi
-		fi
-	fi
-
-	if test "$TLSLIB" = "GnuTLS" -o "$TLSLIB" = ""; then
-		INCVAL="${LIBPREF}/include"
-		LIBVAL="${LIBPREF}/lib"
-		AC_ARG_WITH(libgnutls_includes,
-			[AS_HELP_STRING([--with-libgnutls-includes=DIR], [GnuTLS include directory])],
-			[INCVAL="$withval"])
-		CPPFLAGS="${CPPFLAGS} -I${INCVAL}"
-		AC_ARG_WITH(libgnutls_libraries,
-			[AS_HELP_STRING([--with-libgnutls-libraries=DIR], [GnuTLS library directory])],
-			[LIBVAL="$withval"])
-		LDFLAGS="${LDFLAGS} -L${LIBVAL}"
-
-		AC_CHECK_HEADER(gnutls/gnutls.h,
-			FOUND=yes
-			TLSHEADERS=yes,
-			FOUND=no)
-		if test "$FOUND" = "no" -a "$TLSLIB" = "GnuTLS"; then
-			AC_MSG_ERROR([Couldn't find GnuTLS headers (gnutls.h)])
-		fi
-		if test "$FOUND" = "yes"; then
-			AC_SEARCH_LIBS([gnutls_global_init], [gnutls],
-				AC_SEARCH_LIBS([gcry_control], [gnutls gcrypt],
-					FOUND=yes,
-					FOUND=no),
-				FOUND=no)
-			if test "$FOUND" = "no" -a "$TLSLIB" = "GnuTLS"; then
-				AC_MSG_ERROR([Couldn't find GnuTLS library])
-			fi
-			if test "$FOUND" = "yes"; then
-				TLSLIB="GnuTLS"
-				AC_DEFINE([HAVE_LIBGNUTLS],1,[Define to 1 to use GnuTLS library for TLS/SSL-support.])
-			fi
-		fi
-	fi
-
-	if test "$TLSLIB" = ""; then
-		if test "$TLSHEADERS" = ""; then
-			AC_MSG_ERROR([Couldn't find neither OpenSSL nor GnuTLS headers (ssl.h or gnutls.h)])
-		else
-			AC_MSG_ERROR([Couldn't find neither OpenSSL nor GnuTLS library])
-		fi
-	fi
-else
-	AC_DEFINE([DISABLE_TLS],1,[Define to 1 to not use TLS/SSL])
-fi
-
-
-dnl 
-dnl checks for zlib includes and libraries.
-dnl
-AC_MSG_CHECKING(whether to use gzip)
-AC_ARG_ENABLE(gzip,
-	[AS_HELP_STRING([--disable-gzip], [disable gzip-compression/decompression (removes dependency from zlib-library)])],
-	[USEZLIB=$enableval],
-	[USEZLIB=yes] )
-AC_MSG_RESULT($USEZLIB)
-if test "$USEZLIB" = "yes"; then
-	INCVAL="${LIBPREF}/include"
-	LIBVAL="${LIBPREF}/lib"
-	AC_ARG_WITH(zlib_includes,
-		[AS_HELP_STRING([--with-zlib-includes=DIR], [zlib include directory])],
-		[INCVAL="$withval"])
-	CPPFLAGS="${CPPFLAGS} -I${INCVAL}"
-	AC_ARG_WITH(zlib_libraries,
-		[AS_HELP_STRING([--with-zlib-libraries=DIR], [zlib library directory])],
-		[LIBVAL="$withval"])
-	LDFLAGS="${LDFLAGS} -L${LIBVAL}"
-	
-	AC_CHECK_HEADER(zlib.h,,
-		AC_MSG_ERROR("zlib header files not found"))
-	AC_SEARCH_LIBS([deflateBound], [z], ,
-		AC_MSG_ERROR("zlib library not found"))
-else
-	AC_DEFINE([DISABLE_GZIP],1,[Define to 1 to disable gzip-support])
-fi
-
-
-dnl 
-dnl Some Linux systems require an empty signal handler for SIGCHLD
-dnl in order for exit codes to be correctly delivered to parent process.
-dnl Some 32-Bit BSD systems however may not function properly if the handler is installed.
-dnl The default behavior is to install the handler.
-dnl
-AC_MSG_CHECKING(whether to use an empty SIGCHLD handler)
-AC_ARG_ENABLE(sigchld-handler,
-	[AS_HELP_STRING([--disable-sigchld-handler], [do not use sigchld-handler (the disabling may be neccessary on 32-Bit BSD)])],
-	[SIGCHLDHANDLER=$enableval],
-	[SIGCHLDHANDLER=yes])
-AC_MSG_RESULT($SIGCHLDHANDLER)
-if test "$SIGCHLDHANDLER" = "yes"; then
-	AC_DEFINE([SIGCHLD_HANDLER], 1, [Define to 1 to install an empty signal handler for SIGCHLD])
-fi
-
-
 dnl 
 dnl Debugging. Default: no
 dnl 
 AC_MSG_CHECKING(whether to include all debugging code)
 AC_ARG_ENABLE(debug,
-	[AS_HELP_STRING([--enable-debug], [enable debugging])],
+	[  --enable-debug		enable debugging],
 	[ ENABLEDEBUG=$enableval ],
 	[ ENABLEDEBUG=no] )
-AC_MSG_RESULT($ENABLEDEBUG)
-
-
 if test "$ENABLEDEBUG" = "yes"; then
-
-dnl
-dnl Begin of debugging code
-dnl
-
-AC_DEFINE([DEBUG],1,Define to 1 to include debug-code)
-
-
-dnl
-dnl Set debug flags for gcc (if gcc is used)
-dnl
-if test "$CC" = "gcc"; then
-	CXXFLAGS="-g -Wall"
-else
-	CXXFLAGS=""
-fi
-
-
-dnl
-dnl check for __FUNCTION__ or __func__ macro
-dnl
-AC_MSG_CHECKING(for macro returning current function name)
-AC_TRY_COMPILE(
-	[#include <stdio.h>], [printf("%s\n", __FUNCTION__);],
-	AC_MSG_RESULT(__FUNCTION__)
-	FUNCTION_MACRO_NAME=__FUNCTION__,
-AC_TRY_COMPILE([#include <stdio.h>], [printf("%s\n", __func__);],
-	AC_MSG_RESULT(__func__)
-	FUNCTION_MACRO_NAME=__func__,
-	AC_MSG_RESULT(none)))
-if test "$FUNCTION_MACRO_NAME" != ""; then
-	AC_DEFINE_UNQUOTED(FUNCTION_MACRO_NAME, $FUNCTION_MACRO_NAME, [Define to the name of macro which returns the name of function being compiled])
+	AC_DEFINE([DEBUG],1,Define to 1 to include debug-code)
+	if test "$CC" = "gcc"; then
+		CXXFLAGS="-g -Wall"
+	else
+		CXXFLAGS=""
+	fi
 fi
+AC_MSG_RESULT($ENABLEDEBUG)
 
 
 dnl 
@@ -579,39 +394,14 @@ AC_COMPILE_IFELSE([
 	AC_MSG_RESULT([no]))
 
 
-dnl
-dnl Backtracing on segmentation faults
-dnl
-AC_MSG_CHECKING(for backtrace)
-AC_TRY_COMPILE(
-	[#include <execinfo.h>]
-	[#include <stdio.h>]
-	[#include <stdlib.h>],
-	[ void *array[100];	size_t size; char **strings; ]
-	[ size = backtrace(array, 100); ]
-	[ strings = backtrace_symbols(array, size); ],
-	FOUND=yes
-	AC_MSG_RESULT([[yes]])
-	AC_DEFINE([HAVE_BACKTRACE], 1, [Define to 1 to create stacktrace on segmentation faults]),
-	FOUND=no
-	AC_MSG_RESULT([[no]]))
-
-
-dnl
-dnl "rdynamic" linker flag
-dnl
-AC_MSG_CHECKING(for rdynamic linker flag)
-	old_LDFLAGS="$LDFLAGS"
-	LDFLAGS="$LDFLAGS -rdynamic"
-	AC_TRY_LINK([], [],
-		AC_MSG_RESULT([[yes]]),
-		AC_MSG_RESULT([[no]])
-		[LDFLAGS="$old_LDFLAGS"])
-		
-dnl
-dnl End of debugging code
-dnl
-fi
+dnl Substitute flags.
+AC_SUBST(CFLAGS)
+AC_SUBST(CPPFLAGS)
+AC_SUBST(LDFLAGS)
+AC_SUBST(CXXFLAGS)
+AC_SUBST(TAR)
+AC_SUBST(AR)
+AC_SUBST(ADDSRCS)
 
 
 AC_CONFIG_FILES([Makefile])

daemon/connect/Connection.cpp

@@ -1,870 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
- *  Copyright (C) 2007-2014 Andrey Prygunkov <hugbug@users.sourceforge.net>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- * $Revision$
- * $Date$
- *
- */
-
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#ifdef WIN32
-// SKIP_DEFAULT_WINDOWS_HEADERS prevents the including of <windows.h>, which includes "winsock.h",
-// but we need "winsock2.h" here (they conflicts with each other)
-#define SKIP_DEFAULT_WINDOWS_HEADERS
-#include "win32.h"
-#endif
-
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#ifdef WIN32
-#include <winsock2.h>
-#include <ws2tcpip.h>
-#else
-#include <netdb.h>
-#include <unistd.h>
-#include <errno.h>
-#include <sys/socket.h>
-#include <sys/time.h>
-#include <arpa/inet.h>
-#include <netinet/in.h>
-#endif
-
-#include "nzbget.h"
-#include "Connection.h"
-#include "Log.h"
-
-static const int CONNECTION_READBUFFER_SIZE = 1024;
-#ifndef HAVE_GETADDRINFO
-#ifndef HAVE_GETHOSTBYNAME_R
-Mutex* Connection::m_pMutexGetHostByName = NULL;
-#endif
-#endif
-
-
-void Connection::Init()
-{
-	debug("Initializing global connection data");
-
-#ifdef WIN32
-	WSADATA wsaData;
-	int err = WSAStartup(MAKEWORD(2, 0), &wsaData);
-	if (err != 0) 
-	{
-		error("Could not initialize socket library");
-		return;
-	}
-	if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE( wsaData.wVersion ) != 0) 
-	{
-		error("Could not initialize socket library");
-		WSACleanup();
-		return; 
-	}
-#endif
-
-#ifndef DISABLE_TLS
-	TLSSocket::Init();
-#endif
-
-#ifndef HAVE_GETADDRINFO
-#ifndef HAVE_GETHOSTBYNAME_R
-	m_pMutexGetHostByName = new Mutex();
-#endif
-#endif
-}
-
-void Connection::Final()
-{
-	debug("Finalizing global connection data");
-
-#ifdef WIN32
-	WSACleanup();
-#endif
-
-#ifndef DISABLE_TLS
-	TLSSocket::Final();
-#endif
-
-#ifndef HAVE_GETADDRINFO
-#ifndef HAVE_GETHOSTBYNAME_R
-	delete m_pMutexGetHostByName;
-#endif
-#endif
-}
-
-Connection::Connection(const char* szHost, int iPort, bool bTLS)
-{
-	debug("Creating Connection");
-
-	m_szHost = NULL;
-	m_iPort = iPort;
-	m_bTLS = bTLS;
-	m_szCipher = NULL;
-	m_eStatus = csDisconnected;
-	m_iSocket = INVALID_SOCKET;
-	m_iBufAvail = 0;
-	m_iTimeout = 60;
-	m_bSuppressErrors = true;
-	m_szReadBuf = (char*)malloc(CONNECTION_READBUFFER_SIZE + 1);
-	m_iTotalBytesRead = 0;
-#ifndef DISABLE_TLS
-	m_pTLSSocket = NULL;
-	m_bTLSError = false;
-#endif
-
-	if (szHost)
-	{
-		m_szHost = strdup(szHost);
-	}
-}
-
-Connection::Connection(SOCKET iSocket, bool bTLS)
-{
-	debug("Creating Connection");
-
-	m_szHost			= NULL;
-	m_iPort				= 0;
-	m_bTLS				= bTLS;
-	m_szCipher			= NULL;
-	m_eStatus			= csConnected;
-	m_iSocket			= iSocket;
-	m_iBufAvail			= 0;
-	m_iTimeout			= 60;
-	m_bSuppressErrors	= true;
-	m_szReadBuf			= (char*)malloc(CONNECTION_READBUFFER_SIZE + 1);
-#ifndef DISABLE_TLS
-	m_pTLSSocket		= NULL;
-	m_bTLSError			= false;
-#endif
-}
-
-Connection::~Connection()
-{
-	debug("Destroying Connection");
-
-	Disconnect();
-
-	free(m_szHost);
-	free(m_szCipher);
-	free(m_szReadBuf);
-#ifndef DISABLE_TLS
-	delete m_pTLSSocket;
-#endif
-}
-
-void Connection::SetSuppressErrors(bool bSuppressErrors)
-{
-	m_bSuppressErrors = bSuppressErrors;
-#ifndef DISABLE_TLS
-	if (m_pTLSSocket)
-	{
-		m_pTLSSocket->SetSuppressErrors(bSuppressErrors);
-	}
-#endif
-}
-
-void Connection::SetCipher(const char* szCipher)
-{
-	free(m_szCipher);
-	m_szCipher = szCipher ? strdup(szCipher) : NULL;
-}
-
-bool Connection::Connect()
-{
-	debug("Connecting");
-
-	if (m_eStatus == csConnected)
-	{
-		return true;
-	}
-
-	bool bRes = DoConnect();
-
-	if (bRes)
-	{
-		m_eStatus = csConnected;
-	}
-	else
-	{
-		DoDisconnect();
-	}
-
-	return bRes;
-}
-
-bool Connection::Disconnect()
-{
-	debug("Disconnecting");
-
-	if (m_eStatus == csDisconnected)
-	{
-		return true;
-	}
-
-	bool bRes = DoDisconnect();
-
-	m_eStatus = csDisconnected;
-	m_iSocket = INVALID_SOCKET;
-	m_iBufAvail = 0;
-
-	return bRes;
-}
-
-bool Connection::Bind()
-{
-	debug("Binding");
-
-	if (m_eStatus == csListening)
-	{
-		return true;
-	}
-
-#ifdef HAVE_GETADDRINFO
-	struct addrinfo addr_hints, *addr_list, *addr;
-	char iPortStr[sizeof(int) * 4 + 1]; // is enough to hold any converted int
-	
-	memset(&addr_hints, 0, sizeof(addr_hints));
-	addr_hints.ai_family = AF_UNSPEC;    // Allow IPv4 or IPv6
-	addr_hints.ai_socktype = SOCK_STREAM,
-	addr_hints.ai_flags = AI_PASSIVE;    // For wildcard IP address
-	
-	sprintf(iPortStr, "%d", m_iPort);
-	
-	int res = getaddrinfo(m_szHost, iPortStr, &addr_hints, &addr_list);
-	if (res != 0)
-	{
-		error("Could not resolve hostname %s", m_szHost);
-		return false;
-	}
-	
-	m_iSocket = INVALID_SOCKET;
-	for (addr = addr_list; addr != NULL; addr = addr->ai_next)
-	{
-		m_iSocket = socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
-		if (m_iSocket != INVALID_SOCKET)
-		{
-			int opt = 1;
-			setsockopt(m_iSocket, SOL_SOCKET, SO_REUSEADDR, (char*)&opt, sizeof(opt));
-			res = bind(m_iSocket, addr->ai_addr, addr->ai_addrlen);
-			if (res != -1)
-			{
-				// Connection established
-				break;
-			}
-			// Connection failed
-			closesocket(m_iSocket);
-			m_iSocket = INVALID_SOCKET;
-		}
-	}
-	
-	freeaddrinfo(addr_list);
-	
-#else
-	
-	struct sockaddr_in	sSocketAddress;
-	memset(&sSocketAddress, 0, sizeof(sSocketAddress));
-	sSocketAddress.sin_family = AF_INET;
-	if (!m_szHost || strlen(m_szHost) == 0)
-	{
-		sSocketAddress.sin_addr.s_addr = htonl(INADDR_ANY);
-	}
-	else
-	{
-		sSocketAddress.sin_addr.s_addr = ResolveHostAddr(m_szHost);
-		if (sSocketAddress.sin_addr.s_addr == (unsigned int)-1)
-		{
-			return false;
-		}
-	}
-	sSocketAddress.sin_port = htons(m_iPort);
-	
-	m_iSocket = socket(PF_INET, SOCK_STREAM, 0);
-	if (m_iSocket == INVALID_SOCKET)
-	{
-		ReportError("Socket creation failed for %s", m_szHost, true, 0);
-		return false;
-	}
-	
-	int opt = 1;
-	setsockopt(m_iSocket, SOL_SOCKET, SO_REUSEADDR, (char*)&opt, sizeof(opt));
-	
-	int res = bind(m_iSocket, (struct sockaddr *) &sSocketAddress, sizeof(sSocketAddress));
-	if (res == -1)
-	{
-		// Connection failed
-		closesocket(m_iSocket);
-		m_iSocket = INVALID_SOCKET;
-	}
-#endif
-	
-	if (m_iSocket == INVALID_SOCKET)
-	{
-		ReportError("Binding socket failed for %s", m_szHost, true, 0);
-		return false;
-	}
-	
-	if (listen(m_iSocket, 100) < 0)
-	{
-		ReportError("Listen on socket failed for %s", m_szHost, true, 0);
-		return false;
-	}
-	
-	m_eStatus = csListening;
-
-	return true;
-}
-
-int Connection::WriteLine(const char* pBuffer)
-{
-	//debug("Connection::WriteLine");
-
-	if (m_eStatus != csConnected)
-	{
-		return -1;
-	}
-
-	int iRes = send(m_iSocket, pBuffer, strlen(pBuffer), 0);
-
-	return iRes;
-}
-
-bool Connection::Send(const char* pBuffer, int iSize)
-{
-	debug("Sending data");
-
-	if (m_eStatus != csConnected)
-	{
-		return false;
-	}
-
-	int iBytesSent = 0;
-	while (iBytesSent < iSize)
-	{
-		int iRes = send(m_iSocket, pBuffer + iBytesSent, iSize-iBytesSent, 0);
-		if (iRes <= 0)
-		{
-			return false;
-		}
-		iBytesSent += iRes;
-	}
-
-	return true;
-}
-
-char* Connection::ReadLine(char* pBuffer, int iSize, int* pBytesRead)
-{
-	if (m_eStatus != csConnected)
-	{
-		return NULL;
-	}
-
-	char* pBufPtr = pBuffer;
-	iSize--; // for trailing '0'
-	int iBytesRead = 0;
-	int iBufAvail = m_iBufAvail; // local variable is faster
-	char* szBufPtr = m_szBufPtr; // local variable is faster
-	while (iSize)
-	{
-		if (!iBufAvail)
-		{
-			iBufAvail = recv(m_iSocket, m_szReadBuf, CONNECTION_READBUFFER_SIZE, 0);
-			if (iBufAvail < 0)
-			{
-				ReportError("Could not receive data on socket", NULL, true, 0);
-				break;
-			}
-			else if (iBufAvail == 0)
-			{
-				break;
-			}
-			szBufPtr = m_szReadBuf;
-			m_szReadBuf[iBufAvail] = '\0';
-		}
-		
-		int len = 0;
-		char* p = (char*)memchr(szBufPtr, '\n', iBufAvail);
-		if (p)
-		{
-			len = (int)(p - szBufPtr + 1);
-		}
-		else
-		{
-			len = iBufAvail;
-		}
-		
-		if (len > iSize)
-		{
-			len = iSize;
-		}
-		
-		memcpy(pBufPtr, szBufPtr, len);
-		pBufPtr += len;
-		szBufPtr += len;
-		iBufAvail -= len;
-		iBytesRead += len;
-		iSize -= len;
-		
-		if (p)
-		{
-			break;
-		}
-	}
-	*pBufPtr = '\0';
-	
-	m_iBufAvail = iBufAvail > 0 ? iBufAvail : 0; // copy back to member
-	m_szBufPtr = szBufPtr; // copy back to member
-	
-	if (pBytesRead)
-	{
-		*pBytesRead = iBytesRead;
-	}
-
-	m_iTotalBytesRead += iBytesRead;
-
-	if (pBufPtr == pBuffer)
-	{
-		return NULL;
-	}
-	
-	return pBuffer;
-}
-
-Connection* Connection::Accept()
-{
-	debug("Accepting connection");
-
-	if (m_eStatus != csListening)
-	{
-		return NULL;
-	}
-
-	SOCKET iSocket = accept(m_iSocket, NULL, NULL);
-	if (iSocket == INVALID_SOCKET && m_eStatus != csCancelled)
-	{
-		ReportError("Could not accept connection", NULL, true, 0);
-	}
-	if (iSocket == INVALID_SOCKET)
-	{
-		return NULL;
-	}
-	
-	Connection* pCon = new Connection(iSocket, m_bTLS);
-
-	return pCon;
-}
-
-int Connection::TryRecv(char* pBuffer, int iSize)
-{
-	debug("Receiving data");
-
-	memset(pBuffer, 0, iSize);
-
-	int iReceived = recv(m_iSocket, pBuffer, iSize, 0);
-
-	if (iReceived < 0)
-	{
-		ReportError("Could not receive data on socket", NULL, true, 0);
-	}
-
-	return iReceived;
-}
-
-bool Connection::Recv(char * pBuffer, int iSize)
-{
-	debug("Receiving data (full buffer)");
-
-	memset(pBuffer, 0, iSize);
-
-	char* pBufPtr = (char*)pBuffer;
-	int NeedBytes = iSize;
-
-	if (m_iBufAvail > 0)
-	{
-		int len = iSize > m_iBufAvail ? m_iBufAvail : iSize;
-		memcpy(pBufPtr, m_szBufPtr, len);
-		pBufPtr += len;
-		m_szBufPtr += len;
-		m_iBufAvail -= len;
-		NeedBytes -= len;
-	}
-
-	// Read from the socket until nothing remains
-	while (NeedBytes > 0)
-	{
-		int iReceived = recv(m_iSocket, pBufPtr, NeedBytes, 0);
-		// Did the recv succeed?
-		if (iReceived <= 0)
-		{
-			ReportError("Could not receive data on socket", NULL, true, 0);
-			return false;
-		}
-		pBufPtr += iReceived;
-		NeedBytes -= iReceived;
-	}
-	return true;
-}
-
-bool Connection::DoConnect()
-{
-	debug("Do connecting");
-
-	m_iSocket = INVALID_SOCKET;
-	
-#ifdef HAVE_GETADDRINFO
-	struct addrinfo addr_hints, *addr_list, *addr;
-	char iPortStr[sizeof(int) * 4 + 1]; //is enough to hold any converted int
-
-	memset(&addr_hints, 0, sizeof(addr_hints));
-	addr_hints.ai_family = AF_UNSPEC;    /* Allow IPv4 or IPv6 */
-	addr_hints.ai_socktype = SOCK_STREAM,
-
-	sprintf(iPortStr, "%d", m_iPort);
-
-	int res = getaddrinfo(m_szHost, iPortStr, &addr_hints, &addr_list);
-	if (res != 0)
-	{
-		ReportError("Could not resolve hostname %s", m_szHost, true, 0);
-		return false;
-	}
-
-	for (addr = addr_list; addr != NULL; addr = addr->ai_next)
-	{
-		bool bLastAddr = !addr->ai_next;
-		m_iSocket = socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
-		if (m_iSocket != INVALID_SOCKET)
-		{
-			res = connect(m_iSocket , addr->ai_addr, addr->ai_addrlen);
-			if (res != -1) 
-			{
-				// Connection established
-				break;
-			}
-			// Connection failed
-			if (bLastAddr)
-			{
-				ReportError("Connection to %s failed", m_szHost, true, 0);
-			}
-			closesocket(m_iSocket);
-			m_iSocket = INVALID_SOCKET;
-		}
-		else if (bLastAddr)
-		{
-			ReportError("Socket creation failed for %s", m_szHost, true, 0);
-		}
-	}
-
-	freeaddrinfo(addr_list);
-
-	if (m_iSocket == INVALID_SOCKET)
-	{
-		return false;
-	} 
-
-#else
-
-	struct sockaddr_in	sSocketAddress;
-	memset(&sSocketAddress, 0, sizeof(sSocketAddress));
-	sSocketAddress.sin_family = AF_INET;
-	sSocketAddress.sin_port = htons(m_iPort);
-	sSocketAddress.sin_addr.s_addr = ResolveHostAddr(m_szHost);
-	if (sSocketAddress.sin_addr.s_addr == (unsigned int)-1)
-	{
-		return false;
-	}
-
-	m_iSocket = socket(PF_INET, SOCK_STREAM, 0);
-	if (m_iSocket == INVALID_SOCKET)
-	{
-		ReportError("Socket creation failed for %s", m_szHost, true, 0);
-		return false;
-	}
-
-	int res = connect(m_iSocket , (struct sockaddr *) & sSocketAddress, sizeof(sSocketAddress));
-	if (res == -1)
-	{
-		ReportError("Connection to %s failed", m_szHost, true, 0);
-		closesocket(m_iSocket);
-		m_iSocket = INVALID_SOCKET;
-		return false;
-	}
-#endif
-
-#ifdef WIN32
-	int MSecVal = m_iTimeout * 1000;
-	int err = setsockopt(m_iSocket, SOL_SOCKET, SO_RCVTIMEO, (char*)&MSecVal, sizeof(MSecVal));
-#else
-	struct timeval TimeVal;
-	TimeVal.tv_sec = m_iTimeout;
-	TimeVal.tv_usec = 0;
-	int err = setsockopt(m_iSocket, SOL_SOCKET, SO_RCVTIMEO, (char*)&TimeVal, sizeof(TimeVal));
-#endif
-	if (err != 0)
-	{
-		ReportError("Socket initialization failed for %s", m_szHost, true, 0);
-	}
-
-#ifndef DISABLE_TLS
-	if (m_bTLS && !StartTLS(true, NULL, NULL))
-	{
-		return false;
-	}
-#endif
-
-	return true;
-}
-
-bool Connection::DoDisconnect()
-{
-	debug("Do disconnecting");
-
-	if (m_iSocket != INVALID_SOCKET)
-	{
-#ifndef DISABLE_TLS
-		CloseTLS();
-#endif
-		closesocket(m_iSocket);
-		m_iSocket = INVALID_SOCKET;
-	}
-
-	m_eStatus = csDisconnected;
-	return true;
-}
-
-void Connection::ReadBuffer(char** pBuffer, int *iBufLen)
-{
-	*iBufLen = m_iBufAvail;
-	*pBuffer = m_szBufPtr;
-	m_iBufAvail = 0;
-};
-
-void Connection::Cancel()
-{
-	debug("Cancelling connection");
-	if (m_iSocket != INVALID_SOCKET)
-	{
-		m_eStatus = csCancelled;
-		int r = shutdown(m_iSocket, SHUT_RDWR);
-		if (r == -1)
-		{
-			ReportError("Could not shutdown connection", NULL, true, 0);
-		}
-	}
-}
-
-void Connection::ReportError(const char* szMsgPrefix, const char* szMsgArg, bool PrintErrCode, int herrno)
-{
-#ifndef DISABLE_TLS
-	if (m_bTLSError)
-	{
-		// TLS-Error was already reported
-		m_bTLSError = false;
-		return;
-	}
-#endif
-
-	char szErrPrefix[1024];
-	snprintf(szErrPrefix, 1024, szMsgPrefix, szMsgArg);
-	szErrPrefix[1024-1] = '\0';
-	
-	if (PrintErrCode)
-	{
-#ifdef WIN32
-		int ErrCode = WSAGetLastError();
-		char szErrMsg[1024];
-		FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, ErrCode, 0, szErrMsg, 1024, NULL);
-		szErrMsg[1024-1] = '\0';
-#else
-		const char *szErrMsg = NULL;
-		int ErrCode = herrno;
-		if (herrno == 0)
-		{
-			ErrCode = errno;
-			szErrMsg = strerror(ErrCode);
-		}
-		else
-		{
-			szErrMsg = hstrerror(ErrCode);
-		}
-#endif
-		if (m_bSuppressErrors)
-		{
-			debug("%s: ErrNo %i, %s", szErrPrefix, ErrCode, szErrMsg);
-		}
-		else
-		{
-			error("%s: ErrNo %i, %s", szErrPrefix, ErrCode, szErrMsg);
-		}
-	}
-	else
-	{
-		if (m_bSuppressErrors)
-		{
-			debug(szErrPrefix);
-		}
-		else
-		{
-			error(szErrPrefix);
-		}
-	}
-}
-
-#ifndef DISABLE_TLS
-bool Connection::StartTLS(bool bIsClient, const char* szCertFile, const char* szKeyFile)
-{
-	debug("Starting TLS");
-
-	delete m_pTLSSocket;
-	m_pTLSSocket = new TLSSocket(m_iSocket, bIsClient, szCertFile, szKeyFile, m_szCipher);
-	m_pTLSSocket->SetSuppressErrors(m_bSuppressErrors);
-
-	return m_pTLSSocket->Start();
-}
-
-void Connection::CloseTLS()
-{
-	if (m_pTLSSocket)
-	{
-		m_pTLSSocket->Close();
-		delete m_pTLSSocket;
-		m_pTLSSocket = NULL;
-	}
-}
-
-int Connection::recv(SOCKET s, char* buf, int len, int flags)
-{
-	int iReceived = 0;
-	
-	if (m_pTLSSocket)
-	{
-		m_bTLSError = false;
-		iReceived = m_pTLSSocket->Recv(buf, len);
-		if (iReceived < 0)
-		{
-			m_bTLSError = true;
-			return -1;
-		}
-	}
-	else
-	{
-		iReceived = ::recv(s, buf, len, flags);
-	}
-	return iReceived;
-}
-
-int Connection::send(SOCKET s, const char* buf, int len, int flags)
-{
-	int iSent = 0;
-
-	if (m_pTLSSocket)
-	{
-		m_bTLSError = false;
-		iSent = m_pTLSSocket->Send(buf, len);
-		if (iSent < 0)
-		{
-			m_bTLSError = true;
-			return -1;
-		}
-		return iSent;
-	}
-	else
-	{
-		iSent = ::send(s, buf, len, flags);
-		return iSent;
-	}
-}
-#endif
-
-#ifndef HAVE_GETADDRINFO
-unsigned int Connection::ResolveHostAddr(const char* szHost)
-{
-	unsigned int uaddr = inet_addr(szHost);
-	if (uaddr == (unsigned int)-1)
-	{
-		struct hostent* hinfo;
-		bool err = false;
-		int h_errnop = 0;
-#ifdef HAVE_GETHOSTBYNAME_R
-		struct hostent hinfobuf;
-		char strbuf[1024];
-#ifdef HAVE_GETHOSTBYNAME_R_6
-		err = gethostbyname_r(szHost, &hinfobuf, strbuf, sizeof(strbuf), &hinfo, &h_errnop);
-		err = err || (hinfo == NULL); // error on null hinfo (means 'no entry')
-#endif			
-#ifdef HAVE_GETHOSTBYNAME_R_5
-		hinfo = gethostbyname_r(szHost, &hinfobuf, strbuf, sizeof(strbuf), &h_errnop);
-		err = hinfo == NULL;
-#endif			
-#ifdef HAVE_GETHOSTBYNAME_R_3
-		//NOTE: gethostbyname_r with three parameters were not tested
-		struct hostent_data hinfo_data;
-		hinfo = gethostbyname_r((char*)szHost, (struct hostent*)hinfobuf, &hinfo_data);
-		err = hinfo == NULL;
-#endif			
-#else
-		m_pMutexGetHostByName->Lock();
-		hinfo = gethostbyname(szHost);
-		err = hinfo == NULL;
-#endif
-		if (err)
-		{
-#ifndef HAVE_GETHOSTBYNAME_R
-			m_pMutexGetHostByName->Unlock();
-#endif
-			ReportError("Could not resolve hostname %s", szHost, true, h_errnop);
-			return (unsigned int)-1;
-		}
-
-		memcpy(&uaddr, hinfo->h_addr_list[0], sizeof(uaddr));
-		
-#ifndef HAVE_GETHOSTBYNAME_R
-		m_pMutexGetHostByName->Unlock();
-#endif
-	}
-	return uaddr;
-}
-#endif
-
-const char* Connection::GetRemoteAddr()
-{
-	struct sockaddr_in PeerName;
-	int iPeerNameLength = sizeof(PeerName);
-	if (getpeername(m_iSocket, (struct sockaddr*)&PeerName, (SOCKLEN_T*) &iPeerNameLength) >= 0)
-	{
-#ifdef WIN32
-		 strncpy(m_szRemoteAddr, inet_ntoa(PeerName.sin_addr), sizeof(m_szRemoteAddr));
-#else
-		inet_ntop(AF_INET, &PeerName.sin_addr, m_szRemoteAddr, sizeof(m_szRemoteAddr));
-#endif
-	}
-	m_szRemoteAddr[sizeof(m_szRemoteAddr)-1] = '\0';
-	
-	return m_szRemoteAddr;
-}
-
-int Connection::FetchTotalBytesRead()
-{
-	int iTotal = m_iTotalBytesRead;
-	m_iTotalBytesRead = 0;
-	return iTotal;
-}

daemon/connect/Connection.h

@@ -1,119 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
- *  Copyright (C) 2007-2014 Andrey Prygunkov <hugbug@users.sourceforge.net>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- * $Revision$
- * $Date$
- *
- */
-
-
-#ifndef CONNECTION_H
-#define CONNECTION_H
-
-#ifndef HAVE_GETADDRINFO
-#ifndef HAVE_GETHOSTBYNAME_R
-#include "Thread.h"
-#endif
-#endif
-#ifndef DISABLE_TLS
-#include "TLS.h"
-#endif
-
-class Connection
-{
-public:
-	enum EStatus
-	{
-		csConnected,
-		csDisconnected,
-		csListening,
-		csCancelled
-	};
-
-protected:
-	char*				m_szHost;
-	int					m_iPort;
-	SOCKET				m_iSocket;
-	bool				m_bTLS;
-	char*				m_szCipher;
-	char*				m_szReadBuf;
-	int					m_iBufAvail;
-	char*				m_szBufPtr;
-	EStatus				m_eStatus;
-	int					m_iTimeout;
-	bool				m_bSuppressErrors;
-	char				m_szRemoteAddr[20];
-	int					m_iTotalBytesRead;
-#ifndef DISABLE_TLS
-	TLSSocket*			m_pTLSSocket;
-	bool				m_bTLSError;
-#endif
-#ifndef HAVE_GETADDRINFO
-#ifndef HAVE_GETHOSTBYNAME_R
-	static Mutex*		m_pMutexGetHostByName;
-#endif
-#endif
-
-						Connection(SOCKET iSocket, bool bTLS);
-	void				ReportError(const char* szMsgPrefix, const char* szMsgArg, bool PrintErrCode, int herrno);
-	bool				DoConnect();
-	bool				DoDisconnect();
-#ifndef HAVE_GETADDRINFO
-	unsigned int		ResolveHostAddr(const char* szHost);
-#endif
-#ifndef DISABLE_TLS
-	int					recv(SOCKET s, char* buf, int len, int flags);
-	int					send(SOCKET s, const char* buf, int len, int flags);
-	void				CloseTLS();
-#endif
-
-public:
-						Connection(const char* szHost, int iPort, bool bTLS);
-	virtual 			~Connection();
-	static void			Init();
-	static void			Final();
-	virtual bool 		Connect();
-	virtual bool		Disconnect();
-	bool				Bind();
-	bool				Send(const char* pBuffer, int iSize);
-	bool				Recv(char* pBuffer, int iSize);
-	int					TryRecv(char* pBuffer, int iSize);
-	char*				ReadLine(char* pBuffer, int iSize, int* pBytesRead);
-	void				ReadBuffer(char** pBuffer, int *iBufLen);
-	int					WriteLine(const char* pBuffer);
-	Connection*			Accept();
-	void				Cancel();
-	const char*			GetHost() { return m_szHost; }
-	int					GetPort() { return m_iPort; }
-	bool				GetTLS() { return m_bTLS; }
-	const char*			GetCipher() { return m_szCipher; }
-	void				SetCipher(const char* szCipher);
-	void				SetTimeout(int iTimeout) { m_iTimeout = iTimeout; }
-	EStatus				GetStatus() { return m_eStatus; }
-	void				SetSuppressErrors(bool bSuppressErrors);
-	bool				GetSuppressErrors() { return m_bSuppressErrors; }
-	const char*			GetRemoteAddr();
-#ifndef DISABLE_TLS
-	bool				StartTLS(bool bIsClient, const char* szCertFile, const char* szKeyFile);
-#endif
-	int					FetchTotalBytesRead();
-};
-
-#endif

daemon/connect/TLS.cpp

@@ -1,553 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2008-2013 Andrey Prygunkov <hugbug@users.sourceforge.net>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- * $Revision$
- * $Date$
- *
- */
-
-#ifdef HAVE_CONFIG_H
-# include "config.h"
-#endif
-
-#ifdef WIN32
-#define SKIP_DEFAULT_WINDOWS_HEADERS
-#include "win32.h"
-#endif
-
-#ifndef DISABLE_TLS
-
-#include <stdlib.h>
-#include <string.h>
-#ifdef WIN32
-#include <winsock2.h>
-#include <ws2tcpip.h>
-#else
-#include <strings.h>
-#endif
-#include <ctype.h>
-#include <limits.h>
-#include <time.h>
-#include <errno.h>
-#include <list>
-
-#ifdef WIN32
-#include "nzbget.h"
-#endif
-
-#ifdef HAVE_LIBGNUTLS
-#include <gnutls/gnutls.h>
-#if GNUTLS_VERSION_NUMBER <= 0x020b00
-#define NEED_GCRYPT_LOCKING
-#endif
-#ifdef NEED_GCRYPT_LOCKING
-#include <gcrypt.h>
-#endif /* NEED_GCRYPT_LOCKING */
-#endif /* HAVE_LIBGNUTLS */
-#ifdef HAVE_OPENSSL
-#include <openssl/ssl.h>
-#include <openssl/err.h>
-#endif /* HAVE_OPENSSL */
-
-#ifndef WIN32
-#include "nzbget.h"
-#endif
-
-#include "TLS.h"
-#include "Thread.h"
-#include "Log.h"
-
-
-#ifdef HAVE_LIBGNUTLS
-#ifdef NEED_GCRYPT_LOCKING
-
-/**
- * Mutexes for gcryptlib
- */
-
-typedef std::list<Mutex*> Mutexes;
-Mutexes* g_pGCryptLibMutexes;
-
-static int gcry_mutex_init(void **priv)
-{
-	Mutex* pMutex = new Mutex();
-	g_pGCryptLibMutexes->push_back(pMutex);
-	*priv = pMutex;
-	return 0;
-}
-
-static int gcry_mutex_destroy(void **lock)
-{
-	Mutex* pMutex = ((Mutex*)*lock);
-	g_pGCryptLibMutexes->remove(pMutex);
-	delete pMutex;
-	return 0;
-}
-
-static int gcry_mutex_lock(void **lock)
-{
-	((Mutex*)*lock)->Lock();
-	return 0;
-}
-
-static int gcry_mutex_unlock(void **lock)
-{
-	((Mutex*)*lock)->Unlock();
-	return 0;
-}
-
-static struct gcry_thread_cbs gcry_threads_Mutex =
-{	GCRY_THREAD_OPTION_USER, NULL,
-	gcry_mutex_init, gcry_mutex_destroy,
-	gcry_mutex_lock, gcry_mutex_unlock,
-	NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
-};
-
-#endif /* NEED_GCRYPT_LOCKING */
-#endif /* HAVE_LIBGNUTLS */
-
-
-#ifdef HAVE_OPENSSL
-
-/**
- * Mutexes for OpenSSL
- */
-
-Mutex* *g_pOpenSSLMutexes;
-
-static void openssl_locking(int mode, int n, const char *file, int line)
-{
-	Mutex* mutex = g_pOpenSSLMutexes[n];
-	if (mode & CRYPTO_LOCK)
-	{
-		mutex->Lock();
-	}
-	else
-	{
-		mutex->Unlock();
-	}
-}
-
-/*
-static unsigned long openssl_thread_id(void)
-{
-#ifdef WIN32
-	return (unsigned long)GetCurrentThreadId();
-#else
-	return (unsigned long)pthread_self();
-#endif
-}
-*/
-
-static struct CRYPTO_dynlock_value* openssl_dynlock_create(const char *file, int line)
-{
-	return (CRYPTO_dynlock_value*)new Mutex();
-}
-
-static void openssl_dynlock_destroy(struct CRYPTO_dynlock_value *l, const char *file, int line)
-{
-	Mutex* mutex = (Mutex*)l;
-	delete mutex;
-}
-
-static void openssl_dynlock_lock(int mode, struct CRYPTO_dynlock_value *l, const char *file, int line)
-{
-	Mutex* mutex = (Mutex*)l;
-	if (mode & CRYPTO_LOCK)
-	{
-		mutex->Lock();
-	}
-	else
-	{
-		mutex->Unlock();
-	}
-}
-
-#endif /* HAVE_OPENSSL */
-
-
-void TLSSocket::Init()
-{
-	debug("Initializing TLS library");
-
-#ifdef HAVE_LIBGNUTLS
-#ifdef NEED_GCRYPT_LOCKING
-	g_pGCryptLibMutexes = new Mutexes();
-#endif /* NEED_GCRYPT_LOCKING */
-
-	int error_code;
-
-#ifdef NEED_GCRYPT_LOCKING
-	error_code = gcry_control(GCRYCTL_SET_THREAD_CBS, &gcry_threads_Mutex);
-	if (error_code != 0)
-	{
-		error("Could not initialize libcrypt");
-		return;
-	}
-#endif /* NEED_GCRYPT_LOCKING */
-
-	error_code = gnutls_global_init();
-	if (error_code != 0)
-	{
-		error("Could not initialize libgnutls");
-		return;
-	}
-
-#endif /* HAVE_LIBGNUTLS */
-
-#ifdef HAVE_OPENSSL
-	int iMaxMutexes = CRYPTO_num_locks();
-	g_pOpenSSLMutexes = (Mutex**)malloc(sizeof(Mutex*)*iMaxMutexes);
-	for (int i=0; i < iMaxMutexes; i++)
-	{
-		g_pOpenSSLMutexes[i] = new Mutex();
-	}
-	
-	SSL_load_error_strings();
-	SSL_library_init();
-	OpenSSL_add_all_algorithms();
-
-	CRYPTO_set_locking_callback(openssl_locking);
-	//CRYPTO_set_id_callback(openssl_thread_id);
-	CRYPTO_set_dynlock_create_callback(openssl_dynlock_create);
-	CRYPTO_set_dynlock_destroy_callback(openssl_dynlock_destroy);
-	CRYPTO_set_dynlock_lock_callback(openssl_dynlock_lock);
-	
-#endif /* HAVE_OPENSSL */
-}
-
-void TLSSocket::Final()
-{
-	debug("Finalizing TLS library");
-
-#ifdef HAVE_LIBGNUTLS
-	gnutls_global_deinit();
-
-#ifdef NEED_GCRYPT_LOCKING
-	// fixing memory leak in gcryptlib
-	for (Mutexes::iterator it = g_pGCryptLibMutexes->begin(); it != g_pGCryptLibMutexes->end(); it++)
-	{
-		delete *it;
-	}
-	delete g_pGCryptLibMutexes;
-#endif /* NEED_GCRYPT_LOCKING */
-#endif /* HAVE_LIBGNUTLS */
-
-#ifdef HAVE_OPENSSL
-	int iMaxMutexes = CRYPTO_num_locks();
-	for (int i=0; i < iMaxMutexes; i++)
-	{
-		delete g_pOpenSSLMutexes[i];
-	}
-	free(g_pOpenSSLMutexes);
-#endif /* HAVE_OPENSSL */
-}
-
-TLSSocket::TLSSocket(SOCKET iSocket, bool bIsClient, const char* szCertFile, const char* szKeyFile, const char* szCipher)
-{
-	m_iSocket = iSocket;
-	m_bIsClient = bIsClient;
-	m_szCertFile = szCertFile ? strdup(szCertFile) : NULL;
-	m_szKeyFile = szKeyFile ? strdup(szKeyFile) : NULL;
-	m_szCipher = szCipher && strlen(szCipher) > 0 ? strdup(szCipher) : NULL;
-	m_pContext = NULL;
-	m_pSession = NULL;
-	m_bSuppressErrors = false;
-	m_bInitialized = false;
-	m_bConnected = false;
-}
-
-TLSSocket::~TLSSocket()
-{
-	free(m_szCertFile);
-	free(m_szKeyFile);
-	free(m_szCipher);
-	Close();
-}
-
-void TLSSocket::ReportError(const char* szErrMsg)
-{
-#ifdef HAVE_LIBGNUTLS
-	const char* errstr = gnutls_strerror(m_iRetCode);
-	if (m_bSuppressErrors)
-	{
-		debug("%s: %s", szErrMsg, errstr);
-	}
-	else
-	{
-		error("%s: %s", szErrMsg, errstr);
-	}
-#endif /* HAVE_LIBGNUTLS */
-
-#ifdef HAVE_OPENSSL
-	int errcode;
-	do
-	{
-		errcode = ERR_get_error();
-
-		char errstr[1024];
-		ERR_error_string_n(errcode, errstr, sizeof(errstr));
-		errstr[1024-1] = '\0';
-		
-		if (m_bSuppressErrors)
-		{
-			debug("%s: %s", szErrMsg, errstr);
-		}
-		else if (errcode != 0)
-		{
-			error("%s: %s", szErrMsg, errstr);
-		}
-		else
-		{
-			error("%s", szErrMsg);
-		}
-	} while (errcode);
-#endif /* HAVE_OPENSSL */
-}
-
-bool TLSSocket::Start()
-{
-#ifdef HAVE_LIBGNUTLS
-	gnutls_certificate_credentials_t cred;
-	m_iRetCode = gnutls_certificate_allocate_credentials(&cred);
-	if (m_iRetCode != 0)
-	{
-		ReportError("Could not create TLS context");
-		return false;
-	}
-
-	m_pContext = cred;
-
-	if (m_szCertFile && m_szKeyFile)
-	{
-		m_iRetCode = gnutls_certificate_set_x509_key_file((gnutls_certificate_credentials_t)m_pContext,
-			m_szCertFile, m_szKeyFile, GNUTLS_X509_FMT_PEM);
-		if (m_iRetCode != 0)
-		{
-			ReportError("Could not load certificate or key file");
-			Close();
-			return false;
-		}
-	}
-
-	gnutls_session_t sess;
-	m_iRetCode = gnutls_init(&sess, m_bIsClient ? GNUTLS_CLIENT : GNUTLS_SERVER);
-	if (m_iRetCode != 0)
-	{
-		ReportError("Could not create TLS session");
-		Close();
-		return false;
-	}
-
-	m_pSession = sess;
-
-	m_bInitialized = true;
-
-	const char* szPriority = m_szCipher ? m_szCipher : "NORMAL";
-
-	m_iRetCode = gnutls_priority_set_direct((gnutls_session_t)m_pSession, szPriority, NULL);
-	if (m_iRetCode != 0)
-	{
-		ReportError("Could not select cipher for TLS session");
-		Close();
-		return false;
-	}
-
-	m_iRetCode = gnutls_credentials_set((gnutls_session_t)m_pSession, GNUTLS_CRD_CERTIFICATE, 
-		(gnutls_certificate_credentials_t*)m_pContext);
-	if (m_iRetCode != 0)
-	{
-		ReportError("Could not initialize TLS session");
-		Close();
-		return false;
-	}
-
-	gnutls_transport_set_ptr((gnutls_session_t)m_pSession, (gnutls_transport_ptr_t)(size_t)m_iSocket);
-
-	m_iRetCode = gnutls_handshake((gnutls_session_t)m_pSession);
-	if (m_iRetCode != 0)
-	{
-		ReportError("TLS handshake failed");
-		Close();
-		return false;
-	}
-
-	m_bConnected = true;
-	return true;
-#endif /* HAVE_LIBGNUTLS */
-
-#ifdef HAVE_OPENSSL
-	m_pContext = SSL_CTX_new(SSLv23_method());
-
-	if (!m_pContext)
-	{
-		ReportError("Could not create TLS context");
-		return false;
-	}
-
-	if (m_szCertFile && m_szKeyFile)
-	{
-		if (SSL_CTX_use_certificate_file((SSL_CTX*)m_pContext, m_szCertFile, SSL_FILETYPE_PEM) != 1)
-		{
-			ReportError("Could not load certificate file");
-			Close();
-			return false;
-		}
-		if (SSL_CTX_use_PrivateKey_file((SSL_CTX*)m_pContext, m_szKeyFile, SSL_FILETYPE_PEM) != 1)
-		{
-			ReportError("Could not load key file");
-			Close();
-			return false;
-		}
-	}
-	
-	m_pSession = SSL_new((SSL_CTX*)m_pContext);
-	if (!m_pSession)
-	{
-		ReportError("Could not create TLS session");
-		Close();
-		return false;
-	}
-
-	if (m_szCipher && !SSL_set_cipher_list((SSL*)m_pSession, m_szCipher))
-	{
-		ReportError("Could not select cipher for TLS");
-		Close();
-		return false;
-	}
-
-	if (!SSL_set_fd((SSL*)m_pSession, m_iSocket))
-	{
-		ReportError("Could not set the file descriptor for TLS");
-		Close();
-		return false;
-	}
-
-	int error_code = m_bIsClient ? SSL_connect((SSL*)m_pSession) : SSL_accept((SSL*)m_pSession);
-	if (error_code < 1)
-	{
-		ReportError("TLS handshake failed");
-		Close();
-		return false;
-	}
-
-	m_bConnected = true;
-	return true;
-#endif /* HAVE_OPENSSL */
-}
-
-void TLSSocket::Close()
-{
-	if (m_pSession)
-	{
-#ifdef HAVE_LIBGNUTLS
-		if (m_bConnected)
-		{
-			gnutls_bye((gnutls_session_t)m_pSession, GNUTLS_SHUT_WR);
-		}
-		if (m_bInitialized)
-		{
-			gnutls_deinit((gnutls_session_t)m_pSession);
-		}
-#endif /* HAVE_LIBGNUTLS */
-
-#ifdef HAVE_OPENSSL
-		if (m_bConnected)
-		{
-			SSL_shutdown((SSL*)m_pSession);
-		}
-		SSL_free((SSL*)m_pSession);
-#endif /* HAVE_OPENSSL */
-
-		m_pSession = NULL;
-	}
-
-	if (m_pContext)
-	{
-#ifdef HAVE_LIBGNUTLS
-		gnutls_certificate_free_credentials((gnutls_certificate_credentials_t)m_pContext);
-#endif /* HAVE_LIBGNUTLS */
-
-#ifdef HAVE_OPENSSL
-		SSL_CTX_free((SSL_CTX*)m_pContext);
-#endif /* HAVE_OPENSSL */
-
-		m_pContext = NULL;
-	}
-}
-
-int TLSSocket::Send(const char* pBuffer, int iSize)
-{
-	int ret;
-
-#ifdef HAVE_LIBGNUTLS
-	ret = gnutls_record_send((gnutls_session_t)m_pSession, pBuffer, iSize);
-#endif /* HAVE_LIBGNUTLS */
-
-#ifdef HAVE_OPENSSL
-	ret = SSL_write((SSL*)m_pSession, pBuffer, iSize);
-#endif /* HAVE_OPENSSL */
-
-	if (ret < 0)
-	{
-#ifdef HAVE_OPENSSL
-		if (ERR_peek_error() == 0)
-		{
-			ReportError("Could not write to TLS-Socket: Connection closed by remote host");
-		}
-		else
-#endif /* HAVE_OPENSSL */
-		ReportError("Could not write to TLS-Socket");
-		return -1;
-	}
-
-	return ret;
-}
-
-int TLSSocket::Recv(char* pBuffer, int iSize)
-{
-	int ret;
-
-#ifdef HAVE_LIBGNUTLS
-	ret = gnutls_record_recv((gnutls_session_t)m_pSession, pBuffer, iSize);
-#endif /* HAVE_LIBGNUTLS */
-
-#ifdef HAVE_OPENSSL
-	ret = SSL_read((SSL*)m_pSession, pBuffer, iSize);
-#endif /* HAVE_OPENSSL */
-
-	if (ret < 0)
-	{
-#ifdef HAVE_OPENSSL
-		if (ERR_peek_error() == 0)
-		{
-			ReportError("Could not read from TLS-Socket: Connection closed by remote host");
-		}
-		else
-#endif /* HAVE_OPENSSL */
-		{
-			ReportError("Could not read from TLS-Socket");
-		}
-		return -1;
-	}
-
-	return ret;
-}
-
-#endif

daemon/connect/TLS.h

@@ -1,62 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2008-2013 Andrey Prygunkov <hugbug@users.sourceforge.net>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- * $Revision$
- * $Date$
- *
- */
-
-#ifndef TLS_H
-#define TLS_H
-
-#ifndef DISABLE_TLS
-
-class TLSSocket
-{
-private:
-	bool				m_bIsClient;
-	char*				m_szCertFile;
-	char*				m_szKeyFile;
-	char*				m_szCipher;
-	SOCKET				m_iSocket;
-	bool				m_bSuppressErrors;
-	int					m_iRetCode;
-	bool				m_bInitialized;
-	bool				m_bConnected;
-
-	// using "void*" to prevent the including of GnuTLS/OpenSSL header files into TLS.h
-	void*				m_pContext;
-	void*				m_pSession;
-
-	void				ReportError(const char* szErrMsg);
-
-public:
-						TLSSocket(SOCKET iSocket, bool bIsClient, const char* szCertFile, const char* szKeyFile, const char* szCipher);
-						~TLSSocket();
-	static void			Init();
-	static void			Final();
-	bool				Start();
-	void				Close();
-	int					Send(const char* pBuffer, int iSize);
-	int					Recv(char* pBuffer, int iSize);
-	void				SetSuppressErrors(bool bSuppressErrors) { m_bSuppressErrors = bSuppressErrors; }
-};
-
-#endif
-#endif

daemon/connect/WebDownloader.cpp

@@ -1,730 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2012-2014 Andrey Prygunkov <hugbug@users.sourceforge.net>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- * $Revision$
- * $Date$
- *
- */
-
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#ifdef WIN32
-#include "win32.h"
-#endif
-
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#ifdef WIN32
-#include <direct.h>
-#else
-#include <unistd.h>
-#include <sys/time.h>
-#endif
-#include <sys/stat.h>
-#include <errno.h>
-
-#include "nzbget.h"
-#include "WebDownloader.h"
-#include "Log.h"
-#include "Options.h"
-#include "Util.h"
-
-extern Options* g_pOptions;
-
-WebDownloader::WebDownloader()
-{
-	debug("Creating WebDownloader");
-
-	m_szURL	= NULL;
-	m_szOutputFilename	= NULL;
-	m_pConnection = NULL;
-	m_szInfoName = NULL;
-	m_bConfirmedLength = false;
-	m_eStatus = adUndefined;
-	m_szOriginalFilename = NULL;
-	m_bForce = false;
-	m_bRetry = true;
-	SetLastUpdateTimeNow();
-}
-
-WebDownloader::~WebDownloader()
-{
-	debug("Destroying WebDownloader");
-
-	free(m_szURL);
-	free(m_szInfoName);
-	free(m_szOutputFilename);
-	free(m_szOriginalFilename);
-}
-
-void WebDownloader::SetOutputFilename(const char* v)
-{
-	m_szOutputFilename = strdup(v);
-}
-
-void WebDownloader::SetInfoName(const char* v)
-{
-	m_szInfoName = strdup(v);
-}
-
-void WebDownloader::SetURL(const char * szURL)
-{
-	free(m_szURL);
-	m_szURL = strdup(szURL);
-}
-
-void WebDownloader::SetStatus(EStatus eStatus)
-{
-	m_eStatus = eStatus;
-	Notify(NULL);
-}
-
-void WebDownloader::Run()
-{
-	debug("Entering WebDownloader-loop");
-
-	SetStatus(adRunning);
-
-	int iRemainedDownloadRetries = g_pOptions->GetRetries() > 0 ? g_pOptions->GetRetries() : 1;
-	int iRemainedConnectRetries = iRemainedDownloadRetries > 10 ? iRemainedDownloadRetries : 10;
-	if (!m_bRetry)
-	{
-		iRemainedDownloadRetries = 1;
-		iRemainedConnectRetries = 1;
-	}
-
-	m_iRedirects = 0;
-	EStatus Status = adFailed;
-
-	while (!IsStopped() && iRemainedDownloadRetries > 0 && iRemainedConnectRetries > 0)
-	{
-		SetLastUpdateTimeNow();
-
-		Status = Download();
-
-		if ((((Status == adFailed) && (iRemainedDownloadRetries > 1)) ||
-			((Status == adConnectError) && (iRemainedConnectRetries > 1)))
-			&& !IsStopped() && !(!m_bForce && g_pOptions->GetPauseDownload()))
-		{
-			detail("Waiting %i sec to retry", g_pOptions->GetRetryInterval());
-			int msec = 0;
-			while (!IsStopped() && (msec < g_pOptions->GetRetryInterval() * 1000) && 
-				!(!m_bForce && g_pOptions->GetPauseDownload()))
-			{
-				usleep(100 * 1000);
-				msec += 100;
-			}
-		}
-
-		if (IsStopped() || (!m_bForce && g_pOptions->GetPauseDownload()))
-		{
-			Status = adRetry;
-			break;
-		}
-
-		if (Status == adFinished || Status == adFatalError || Status == adNotFound)
-		{
-			break;
-		}
-
-		if (Status == adRedirect)
-		{
-			m_iRedirects++;
-			if (m_iRedirects > 5)
-			{
-				warn("Too many redirects for %s", m_szInfoName);
-				Status = adFailed;
-				break;
-			}
-		}
-
-		if (Status != adConnectError)
-		{
-			iRemainedDownloadRetries--;
-		}
-		else
-		{
-			iRemainedConnectRetries--;
-		}
-	}
-
-	if (Status != adFinished && Status != adRetry)
-	{
-		Status = adFailed;
-	}
-
-	if (Status == adFailed)
-	{
-		if (IsStopped())
-		{
-			detail("Download %s cancelled", m_szInfoName);
-		}
-		else
-		{
-			error("Download %s failed", m_szInfoName);
-		}
-	}
-
-	if (Status == adFinished)
-	{
-		detail("Download %s completed", m_szInfoName);
-	}
-
-	SetStatus(Status);
-
-	debug("Exiting WebDownloader-loop");
-}
-
-WebDownloader::EStatus WebDownloader::Download()
-{
-	EStatus Status = adRunning;
-
-	URL url(m_szURL);
-
-	Status = CreateConnection(&url);
-	if (Status != adRunning)
-	{
-		return Status;
-	}
-
-	m_pConnection->SetSuppressErrors(false);
-
-	// connection
-	bool bConnected = m_pConnection->Connect();
-	if (!bConnected || IsStopped())
-	{
-		FreeConnection();
-		return adConnectError;
-	}
-
-	// Okay, we got a Connection. Now start downloading.
-	detail("Downloading %s", m_szInfoName);
-
-	SendHeaders(&url);
-
-	Status = DownloadHeaders();
-
-	if (Status == adRunning)
-	{
-		Status = DownloadBody();
-	}
-
-	if (IsStopped())
-	{
-		Status = adFailed;
-	}
-
-	FreeConnection();
-
-	if (Status != adFinished)
-	{
-		// Download failed, delete broken output file
-		remove(m_szOutputFilename);
-	}
-
-	return Status;
-}
-
-
-WebDownloader::EStatus WebDownloader::CreateConnection(URL *pUrl)
-{
-	if (!pUrl->IsValid())
-	{
-		error("URL is not valid: %s", pUrl->GetAddress());
-		return adFatalError;
-	}
-
-	int iPort = pUrl->GetPort();
-	if (iPort == 0 && !strcasecmp(pUrl->GetProtocol(), "http"))
-	{
-		iPort = 80;
-	}
-	if (iPort == 0 && !strcasecmp(pUrl->GetProtocol(), "https"))
-	{
-		iPort = 443;
-	}
-
-	if (strcasecmp(pUrl->GetProtocol(), "http") && strcasecmp(pUrl->GetProtocol(), "https"))
-	{
-		error("Unsupported protocol in URL: %s", pUrl->GetAddress());
-		return adFatalError;
-	}
-
-#ifdef DISABLE_TLS
-	if (!strcasecmp(pUrl->GetProtocol(), "https"))
-	{
-		error("Program was compiled without TLS/SSL-support. Cannot download using https protocol. URL: %s", pUrl->GetAddress());
-		return adFatalError;
-	}
-#endif
-
-	bool bTLS = !strcasecmp(pUrl->GetProtocol(), "https");
-
-	m_pConnection = new Connection(pUrl->GetHost(), iPort, bTLS);
-
-	return adRunning;
-}
-
-void WebDownloader::SendHeaders(URL *pUrl)
-{
-	char tmp[1024];
-
-	// retrieve file
-	snprintf(tmp, 1024, "GET %s HTTP/1.0\r\n", pUrl->GetResource());
-	tmp[1024-1] = '\0';
-	m_pConnection->WriteLine(tmp);
-
-	snprintf(tmp, 1024, "User-Agent: nzbget/%s\r\n", Util::VersionRevision());
-	tmp[1024-1] = '\0';
-	m_pConnection->WriteLine(tmp);
-
-	if ((!strcasecmp(pUrl->GetProtocol(), "http") && (pUrl->GetPort() == 80 || pUrl->GetPort() == 0)) ||
-		(!strcasecmp(pUrl->GetProtocol(), "https") && (pUrl->GetPort() == 443 || pUrl->GetPort() == 0)))
-	{
-		snprintf(tmp, 1024, "Host: %s\r\n", pUrl->GetHost());
-	}
-	else
-	{
-		snprintf(tmp, 1024, "Host: %s:%i\r\n", pUrl->GetHost(), pUrl->GetPort());
-	}
-	tmp[1024-1] = '\0';
-	m_pConnection->WriteLine(tmp);
-
-	m_pConnection->WriteLine("Accept: */*\r\n");
-#ifndef DISABLE_GZIP
-	m_pConnection->WriteLine("Accept-Encoding: gzip\r\n");
-#endif
-	m_pConnection->WriteLine("Connection: close\r\n");
-	m_pConnection->WriteLine("\r\n");
-}
-
-WebDownloader::EStatus WebDownloader::DownloadHeaders()
-{
-	EStatus Status = adRunning;
-
-	m_bConfirmedLength = false;
-	const int LineBufSize = 1024*10;
-	char* szLineBuf = (char*)malloc(LineBufSize);
-	m_iContentLen = -1;
-	bool bFirstLine = true;
-	m_bGZip = false;
-	m_bRedirecting = false;
-	m_bRedirected = false;
-
-	// Headers
-	while (!IsStopped())
-	{
-		SetLastUpdateTimeNow();
-
-		int iLen = 0;
-		char* line = m_pConnection->ReadLine(szLineBuf, LineBufSize, &iLen);
-
-		if (bFirstLine)
-		{
-			Status = CheckResponse(szLineBuf);
-			if (Status != adRunning)
-			{
-				break;
-			}
-			bFirstLine = false;
-		}
-
-		// Have we encountered a timeout?
-		if (!line)
-		{
-			if (!IsStopped())
-			{
-				warn("URL %s failed: Unexpected end of file", m_szInfoName);
-			}
-			Status = adFailed;
-			break;
-		}
-
-		debug("Header: %s", line);
-
-		// detect body of response
-		if (*line == '\r' || *line == '\n')
-		{
-			if (m_iContentLen == -1 && !m_bGZip)
-			{
-				warn("URL %s: Content-Length is not submitted by server, cannot verify whether the file is complete", m_szInfoName);
-			}
-			break;
-		}
-
-		Util::TrimRight(line);
-		ProcessHeader(line);
-
-		if (m_bRedirected)
-		{
-			Status = adRedirect;
-			break;
-		}
-	}
-
-	free(szLineBuf);
-
-	return Status;
-}
-
-WebDownloader::EStatus WebDownloader::DownloadBody()
-{
-	EStatus Status = adRunning;
-
-	m_pOutFile = NULL;
-	bool bEnd = false;
-	const int LineBufSize = 1024*10;
-	char* szLineBuf = (char*)malloc(LineBufSize);
-	int iWrittenLen = 0;
-
-#ifndef DISABLE_GZIP
-	m_pGUnzipStream = NULL;
-	if (m_bGZip)
-	{
-		m_pGUnzipStream = new GUnzipStream(1024*10);
-	}
-#endif
-
-	// Body
-	while (!IsStopped())
-	{
-		SetLastUpdateTimeNow();
-
-		char* szBuffer;
-		int iLen;
-		m_pConnection->ReadBuffer(&szBuffer, &iLen);
-		if (iLen == 0)
-		{
-			iLen = m_pConnection->TryRecv(szLineBuf, LineBufSize);
-			szBuffer = szLineBuf;
-		}
-
-		// Have we encountered a timeout?
-		if (iLen <= 0)
-		{
-			if (m_iContentLen == -1 && iWrittenLen > 0)
-			{
-				bEnd = true;
-				break;
-			}
-
-			if (!IsStopped())
-			{
-				warn("URL %s failed: Unexpected end of file", m_szInfoName);
-			}
-			Status = adFailed;
-			break;
-		}
-
-		// write to output file
-		if (!Write(szBuffer, iLen))
-		{
-			Status = adFatalError;
-			break;
-		}
-		iWrittenLen += iLen;
-
-		//detect end of file
-		if (iWrittenLen == m_iContentLen || (m_iContentLen == -1 && m_bGZip && m_bConfirmedLength))
-		{
-			bEnd = true;
-			break;
-		}
-	}
-
-	free(szLineBuf);
-
-#ifndef DISABLE_GZIP
-	delete m_pGUnzipStream;
-#endif
-
-	if (m_pOutFile)
-	{
-		fclose(m_pOutFile);
-	}
-
-	if (!bEnd && Status == adRunning && !IsStopped())
-	{
-		warn("URL %s failed: file incomplete", m_szInfoName);
-		Status = adFailed;
-	}
-
-	if (bEnd)
-	{
-		Status = adFinished;
-	}
-
-	return Status;
-}
-
-WebDownloader::EStatus WebDownloader::CheckResponse(const char* szResponse)
-{
-	if (!szResponse)
-	{
-		if (!IsStopped())
-		{
-			warn("URL %s: Connection closed by remote host", m_szInfoName);
-		}
-		return adConnectError;
-	}
-
-	const char* szHTTPResponse = strchr(szResponse, ' ');
-	if (strncmp(szResponse, "HTTP", 4) || !szHTTPResponse)
-	{
-		warn("URL %s failed: %s", m_szInfoName, szResponse);
-		return adFailed;
-	}
-
-	szHTTPResponse++;
-
-	if (!strncmp(szHTTPResponse, "400", 3) || !strncmp(szHTTPResponse, "499", 3))
-	{
-		warn("URL %s failed: %s", m_szInfoName, szHTTPResponse);
-		return adConnectError;
-	}
-	else if (!strncmp(szHTTPResponse, "404", 3))
-	{
-		warn("URL %s failed: %s", m_szInfoName, szHTTPResponse);
-		return adNotFound;
-	}
-	else if (!strncmp(szHTTPResponse, "301", 3) || !strncmp(szHTTPResponse, "302", 3))
-	{
-		m_bRedirecting = true;
-		return adRunning;
-	}
-	else if (!strncmp(szHTTPResponse, "200", 3))
-	{
-		// OK
-		return adRunning;
-	}
-	else 
-	{
-		// unknown error, no special handling
-		warn("URL %s failed: %s", m_szInfoName, szResponse);
-		return adFailed;
-	}
-}
-
-void WebDownloader::ProcessHeader(const char* szLine)
-{
-	if (!strncasecmp(szLine, "Content-Length: ", 16))
-	{
-		m_iContentLen = atoi(szLine + 16);
-		m_bConfirmedLength = true;
-	}
-	else if (!strncasecmp(szLine, "Content-Encoding: gzip", 22))
-	{
-		m_bGZip = true;
-	}
-	else if (!strncasecmp(szLine, "Content-Disposition: ", 21))
-	{
-		ParseFilename(szLine);
-	}
-	else if (m_bRedirecting && !strncasecmp(szLine, "Location: ", 10))
-	{
-		ParseRedirect(szLine + 10);
-		m_bRedirected = true;
-	}
-}
-
-void WebDownloader::ParseFilename(const char* szContentDisposition)
-{
-	// Examples:
-	// Content-Disposition: attachment; filename="fname.ext"
-	// Content-Disposition: attachement;filename=fname.ext
-	// Content-Disposition: attachement;filename=fname.ext;
-	const char *p = strstr(szContentDisposition, "filename");
-	if (!p)
-	{
-		return;
-	}
-
-	p = strchr(p, '=');
-	if (!p)
-	{
-		return;
-	}
-
-	p++;
-
-	while (*p == ' ') p++;
-
-	char fname[1024];
-	strncpy(fname, p, 1024);
-	fname[1024-1] = '\0';
-
-	char *pe = fname + strlen(fname) - 1;
-	while ((*pe == ' ' || *pe == '\n' || *pe == '\r' || *pe == ';') && pe > fname) {
-		*pe = '\0';
-		pe--;
-	}
-
-	WebUtil::HttpUnquote(fname);
-
-	free(m_szOriginalFilename);
-	m_szOriginalFilename = strdup(Util::BaseFileName(fname));
-
-	debug("OriginalFilename: %s", m_szOriginalFilename);
-}
-
-void WebDownloader::ParseRedirect(const char* szLocation)
-{
-	const char* szNewURL = szLocation;
-	char szUrlBuf[1024];
-	URL newUrl(szNewURL);
-	if (!newUrl.IsValid())
-	{
-		// relative address
-		URL oldUrl(m_szURL);
-		if (oldUrl.GetPort() > 0)
-		{
-			snprintf(szUrlBuf, 1024, "%s://%s:%i%s", oldUrl.GetProtocol(), oldUrl.GetHost(), oldUrl.GetPort(), szNewURL);
-		}
-		else
-		{
-			snprintf(szUrlBuf, 1024, "%s://%s%s", oldUrl.GetProtocol(), oldUrl.GetHost(), szNewURL);
-		}
-		szUrlBuf[1024-1] = '\0';
-		szNewURL = szUrlBuf;
-	}
-	detail("URL %s redirected to %s", m_szURL, szNewURL);
-	SetURL(szNewURL);
-}
-
-bool WebDownloader::Write(void* pBuffer, int iLen)
-{
-	if (!m_pOutFile && !PrepareFile())
-	{
-		return false;
-	}
-
-#ifndef DISABLE_GZIP
-	if (m_bGZip)
-	{
-		m_pGUnzipStream->Write(pBuffer, iLen);
-		const void *pOutBuf;
-		int iOutLen = 1;
-		while (iOutLen > 0)
-		{
-			GUnzipStream::EStatus eGZStatus = m_pGUnzipStream->Read(&pOutBuf, &iOutLen);
-
-			if (eGZStatus == GUnzipStream::zlError)
-			{
-				error("URL %s: GUnzip failed", m_szInfoName);
-				return false;
-			}
-
-			if (iOutLen > 0 && fwrite(pOutBuf, 1, iOutLen, m_pOutFile) <= 0)
-			{
-				return false;
-			}
-
-			if (eGZStatus == GUnzipStream::zlFinished)
-			{
-				m_bConfirmedLength = true;
-				return true;
-			}
-		}
-		return true;
-	}
-	else
-#endif
-
-	return fwrite(pBuffer, 1, iLen, m_pOutFile) > 0;
-}
-
-bool WebDownloader::PrepareFile()
-{
-	// prepare file for writing
-
-	const char* szFilename = m_szOutputFilename;
-	m_pOutFile = fopen(szFilename, FOPEN_WB);
-	if (!m_pOutFile)
-	{
-		error("Could not %s file %s", "create", szFilename);
-		return false;
-	}
-	if (g_pOptions->GetWriteBufferSize() > 0)
-	{
-		setvbuf(m_pOutFile, (char *)NULL, _IOFBF, g_pOptions->GetWriteBufferSize());
-	}
-
-	return true;
-}
-
-void WebDownloader::LogDebugInfo()
-{
-	char szTime[50];
-#ifdef HAVE_CTIME_R_3
-		ctime_r(&m_tLastUpdateTime, szTime, 50);
-#else
-		ctime_r(&m_tLastUpdateTime, szTime);
-#endif
-
-	info("      Web-Download: status=%i, LastUpdateTime=%s, filename=%s", m_eStatus, szTime, Util::BaseFileName(m_szOutputFilename));
-}
-
-void WebDownloader::Stop()
-{
-	debug("Trying to stop WebDownloader");
-	Thread::Stop();
-	m_mutexConnection.Lock();
-	if (m_pConnection)
-	{
-		m_pConnection->SetSuppressErrors(true);
-		m_pConnection->Cancel();
-	}
-	m_mutexConnection.Unlock();
-	debug("WebDownloader stopped successfully");
-}
-
-bool WebDownloader::Terminate()
-{
-	Connection* pConnection = m_pConnection;
-	bool terminated = Kill();
-	if (terminated && pConnection)
-	{
-		debug("Terminating connection");
-		pConnection->SetSuppressErrors(true);
-		pConnection->Cancel();
-		pConnection->Disconnect();
-		delete pConnection;
-	}
-	return terminated;
-}
-
-void WebDownloader::FreeConnection()
-{
-	if (m_pConnection)							
-	{
-		debug("Releasing connection");
-		m_mutexConnection.Lock();
-		if (m_pConnection->GetStatus() == Connection::csCancelled)
-		{
-			m_pConnection->Disconnect();
-		}
-		delete m_pConnection;
-		m_pConnection = NULL;
-		m_mutexConnection.Unlock();
-	}
-}

daemon/connect/WebDownloader.h

@@ -1,112 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2012-2013 Andrey Prygunkov <hugbug@users.sourceforge.net>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- * $Revision$
- * $Date$
- *
- */
-
-
-#ifndef WEBDOWNLOADER_H
-#define WEBDOWNLOADER_H
-
-#include <time.h>
-
-#include "Observer.h"
-#include "Thread.h"
-#include "Connection.h"
-#include "Util.h"
-
-class WebDownloader : public Thread, public Subject
-{
-public:
-	enum EStatus
-	{
-		adUndefined,
-		adRunning,
-		adFinished,
-		adFailed,
-		adRetry,
-		adNotFound,
-		adRedirect,
-		adConnectError,
-		adFatalError
-	};
-			
-private:
-	char*				m_szURL;
-	char*				m_szOutputFilename;
-	Connection* 		m_pConnection;
-	Mutex			 	m_mutexConnection;
-	EStatus				m_eStatus;
-	time_t				m_tLastUpdateTime;
-	char*				m_szInfoName;
-	FILE*				m_pOutFile;
-	int					m_iContentLen;
-	bool				m_bConfirmedLength;
-	char*				m_szOriginalFilename;
-	bool				m_bForce;
-	bool				m_bRedirecting;
-	bool				m_bRedirected;
-	int					m_iRedirects;
-	bool				m_bGZip;
-	bool				m_bRetry;
-#ifndef DISABLE_GZIP
-	GUnzipStream*		m_pGUnzipStream;
-#endif
-
-	void				SetStatus(EStatus eStatus);
-	bool				Write(void* pBuffer, int iLen);
-	bool				PrepareFile();
-	void				FreeConnection();
-	EStatus				CheckResponse(const char* szResponse);
-	EStatus				CreateConnection(URL *pUrl);
-	void				ParseFilename(const char* szContentDisposition);
-	void				SendHeaders(URL *pUrl);
-	EStatus				DownloadHeaders();
-	EStatus				DownloadBody();
-	void				ParseRedirect(const char* szLocation); 
-
-protected:
-	virtual void		ProcessHeader(const char* szLine);
-
-public:
-						WebDownloader();
-	virtual				~WebDownloader();
-	EStatus				GetStatus() { return m_eStatus; }
-	virtual void		Run();
-	virtual void		Stop();
-	EStatus				Download();
-	bool				Terminate();
-	void				SetInfoName(const char* v);
-	const char*			GetInfoName() { return m_szInfoName; }
-	void 				SetURL(const char* szURL);
-	const char*			GetOutputFilename() { return m_szOutputFilename; }
-	void 				SetOutputFilename(const char* v);
-	time_t				GetLastUpdateTime() { return m_tLastUpdateTime; }
-	void				SetLastUpdateTimeNow() { m_tLastUpdateTime = ::time(NULL); }
-	bool				GetConfirmedLength() { return m_bConfirmedLength; }
-	const char*			GetOriginalFilename() { return m_szOriginalFilename; }
-	void				SetForce(bool bForce) { m_bForce = bForce; }
-	void				SetRetry(bool bRetry) { m_bRetry = bRetry; }
-
-	void				LogDebugInfo();
-};
-
-#endif

daemon/feed/FeedCoordinator.cpp

@@ -1,758 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2013-2014 Andrey Prygunkov <hugbug@users.sourceforge.net>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- * $Revision$
- * $Date$
- *
- */
-
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#ifdef WIN32
-#include "win32.h"
-#endif
-
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#include <sys/stat.h>
-#ifndef WIN32
-#include <unistd.h>
-#include <sys/time.h>
-#endif
-
-#include "nzbget.h"
-#include "FeedCoordinator.h"
-#include "Options.h"
-#include "WebDownloader.h"
-#include "Util.h"
-#include "FeedFile.h"
-#include "FeedFilter.h"
-#include "DiskState.h"
-
-extern Options* g_pOptions;
-extern DiskState* g_pDiskState;
-
-FeedCoordinator::FeedCacheItem::FeedCacheItem(const char* szUrl, int iCacheTimeSec,const char* szCacheId,
-	time_t tLastUsage, FeedItemInfos* pFeedItemInfos)
-{
-	m_szUrl = strdup(szUrl);
-	m_iCacheTimeSec = iCacheTimeSec;
-	m_szCacheId = strdup(szCacheId);
-	m_tLastUsage = tLastUsage;
-	m_pFeedItemInfos = pFeedItemInfos;
-	m_pFeedItemInfos->Retain();
-}
-
-FeedCoordinator::FeedCacheItem::~FeedCacheItem()
-{
-	free(m_szUrl);
-	free(m_szCacheId);
-	m_pFeedItemInfos->Release();
-}
-
-FeedCoordinator::FeedCoordinator()
-{
-	debug("Creating FeedCoordinator");
-	m_bForce = false;
-	m_bSave = false;
-
-	g_pLog->RegisterDebuggable(this);
-
-	m_DownloadQueueObserver.m_pOwner = this;
-	DownloadQueue* pDownloadQueue = DownloadQueue::Lock();
-	pDownloadQueue->Attach(&m_DownloadQueueObserver);
-	DownloadQueue::Unlock();
-}
-
-FeedCoordinator::~FeedCoordinator()
-{
-	debug("Destroying FeedCoordinator");
-	// Cleanup
-
-	g_pLog->UnregisterDebuggable(this);
-
-	debug("Deleting FeedDownloaders");
-	for (ActiveDownloads::iterator it = m_ActiveDownloads.begin(); it != m_ActiveDownloads.end(); it++)
-	{
-		delete *it;
-	}
-	m_ActiveDownloads.clear();
-
-	debug("Deleting Feeds");
-	for (Feeds::iterator it = m_Feeds.begin(); it != m_Feeds.end(); it++)
-	{
-		delete *it;
-	}
-	m_Feeds.clear();
-	
-	debug("Deleting FeedCache");
-	for (FeedCache::iterator it = m_FeedCache.begin(); it != m_FeedCache.end(); it++)
-	{
-		delete *it;
-	}
-	m_FeedCache.clear();
-
-	debug("FeedCoordinator destroyed");
-}
-
-void FeedCoordinator::AddFeed(FeedInfo* pFeedInfo)
-{
-	m_Feeds.push_back(pFeedInfo);
-}
-
-void FeedCoordinator::Run()
-{
-	debug("Entering FeedCoordinator-loop");
-
-	while (!DownloadQueue::IsLoaded())
-	{
-		usleep(20 * 1000);
-	}
-
-	if (g_pOptions->GetServerMode() && g_pOptions->GetSaveQueue() && g_pOptions->GetReloadQueue())
-	{
-		m_mutexDownloads.Lock();
-		g_pDiskState->LoadFeeds(&m_Feeds, &m_FeedHistory);
-		m_mutexDownloads.Unlock();
-	}
-
-	int iSleepInterval = 100;
-	int iUpdateCounter = 0;
-	int iCleanupCounter = 60000;
-
-	while (!IsStopped())
-	{
-		usleep(iSleepInterval * 1000);
-
-		iUpdateCounter += iSleepInterval;
-		if (iUpdateCounter >= 1000)
-		{
-			// this code should not be called too often, once per second is OK
-
-			if (!g_pOptions->GetPauseDownload() || m_bForce || g_pOptions->GetUrlForce())
-			{
-				m_mutexDownloads.Lock();
-				time_t tCurrent = time(NULL);
-				if ((int)m_ActiveDownloads.size() < g_pOptions->GetUrlConnections())
-				{
-					m_bForce = false;
-					// check feed list and update feeds
-					for (Feeds::iterator it = m_Feeds.begin(); it != m_Feeds.end(); it++)
-					{
-						FeedInfo* pFeedInfo = *it;
-						if (((pFeedInfo->GetInterval() > 0 &&
-							(tCurrent - pFeedInfo->GetLastUpdate() >= pFeedInfo->GetInterval() * 60 ||
-							 tCurrent < pFeedInfo->GetLastUpdate())) ||
-							pFeedInfo->GetFetch()) &&
-							pFeedInfo->GetStatus() != FeedInfo::fsRunning)
-						{
-							StartFeedDownload(pFeedInfo, pFeedInfo->GetFetch());
-						}
-						else if (pFeedInfo->GetFetch())
-						{
-							m_bForce = true;
-						}
-					}
-				}
-				m_mutexDownloads.Unlock();
-			}
-
-			CheckSaveFeeds();
-			ResetHangingDownloads();
-			iUpdateCounter = 0;
-		}
-
-		iCleanupCounter += iSleepInterval;
-		if (iCleanupCounter >= 60000)
-		{
-			// clean up feed history once a minute
-			CleanupHistory();
-			CleanupCache();
-			CheckSaveFeeds();
-			iCleanupCounter = 0;
-		}
-	}
-
-	// waiting for downloads
-	debug("FeedCoordinator: waiting for Downloads to complete");
-	bool completed = false;
-	while (!completed)
-	{
-		m_mutexDownloads.Lock();
-		completed = m_ActiveDownloads.size() == 0;
-		m_mutexDownloads.Unlock();
-		CheckSaveFeeds();
-		usleep(100 * 1000);
-		ResetHangingDownloads();
-	}
-	debug("FeedCoordinator: Downloads are completed");
-
-	debug("Exiting FeedCoordinator-loop");
-}
-
-void FeedCoordinator::Stop()
-{
-	Thread::Stop();
-
-	debug("Stopping UrlDownloads");
-	m_mutexDownloads.Lock();
-	for (ActiveDownloads::iterator it = m_ActiveDownloads.begin(); it != m_ActiveDownloads.end(); it++)
-	{
-		(*it)->Stop();
-	}
-	m_mutexDownloads.Unlock();
-	debug("UrlDownloads are notified");
-}
-
-void FeedCoordinator::ResetHangingDownloads()
-{
-	const int TimeOut = g_pOptions->GetTerminateTimeout();
-	if (TimeOut == 0)
-	{
-		return;
-	}
-
-	m_mutexDownloads.Lock();
-	time_t tm = ::time(NULL);
-
-	for (ActiveDownloads::iterator it = m_ActiveDownloads.begin(); it != m_ActiveDownloads.end();)
-	{
-		FeedDownloader* pFeedDownloader = *it;
-		if (tm - pFeedDownloader->GetLastUpdateTime() > TimeOut &&
-		   pFeedDownloader->GetStatus() == FeedDownloader::adRunning)
-		{
-			debug("Terminating hanging download %s", pFeedDownloader->GetInfoName());
-			if (pFeedDownloader->Terminate())
-			{
-				error("Terminated hanging download %s", pFeedDownloader->GetInfoName());
-				pFeedDownloader->GetFeedInfo()->SetStatus(FeedInfo::fsUndefined);
-			}
-			else
-			{
-				error("Could not terminate hanging download %s", pFeedDownloader->GetInfoName());
-			}
-			m_ActiveDownloads.erase(it);
-			// it's not safe to destroy pFeedDownloader, because the state of object is unknown
-			delete pFeedDownloader;
-			it = m_ActiveDownloads.begin();
-			continue;
-		}
-		it++;
-	}                                              
-
-	m_mutexDownloads.Unlock();
-}
-
-void FeedCoordinator::LogDebugInfo()
-{
-	info("   ---------- FeedCoordinator");
-
-	m_mutexDownloads.Lock();
-	info("    Active Downloads: %i", m_ActiveDownloads.size());
-	for (ActiveDownloads::iterator it = m_ActiveDownloads.begin(); it != m_ActiveDownloads.end(); it++)
-	{
-		FeedDownloader* pFeedDownloader = *it;
-		pFeedDownloader->LogDebugInfo();
-	}
-	m_mutexDownloads.Unlock();
-}
-
-void FeedCoordinator::StartFeedDownload(FeedInfo* pFeedInfo, bool bForce)
-{
-	debug("Starting new FeedDownloader for %s", pFeedInfo->GetName());
-
-	FeedDownloader* pFeedDownloader = new FeedDownloader();
-	pFeedDownloader->SetAutoDestroy(true);
-	pFeedDownloader->Attach(this);
-	pFeedDownloader->SetFeedInfo(pFeedInfo);
-	pFeedDownloader->SetURL(pFeedInfo->GetUrl());
-	if (strlen(pFeedInfo->GetName()) > 0)
-	{
-		pFeedDownloader->SetInfoName(pFeedInfo->GetName());
-	}
-	else
-	{
-		char szUrlName[1024];
-		NZBInfo::MakeNiceUrlName(pFeedInfo->GetUrl(), "", szUrlName, sizeof(szUrlName));
-		pFeedDownloader->SetInfoName(szUrlName);
-	}
-	pFeedDownloader->SetForce(bForce || g_pOptions->GetUrlForce());
-
-	char tmp[1024];
-
-	if (pFeedInfo->GetID() > 0)
-	{
-		snprintf(tmp, 1024, "%sfeed-%i.tmp", g_pOptions->GetTempDir(), pFeedInfo->GetID());
-	}
-	else
-	{
-		snprintf(tmp, 1024, "%sfeed-%i-%i.tmp", g_pOptions->GetTempDir(), (int)time(NULL), rand());
-	}
-
-	tmp[1024-1] = '\0';
-	pFeedDownloader->SetOutputFilename(tmp);
-
-	pFeedInfo->SetStatus(FeedInfo::fsRunning);
-	pFeedInfo->SetForce(bForce);
-	pFeedInfo->SetFetch(false);
-
-	m_ActiveDownloads.push_back(pFeedDownloader);
-	pFeedDownloader->Start();
-}
-
-void FeedCoordinator::Update(Subject* pCaller, void* pAspect)
-{
-	debug("Notification from FeedDownloader received");
-
-	FeedDownloader* pFeedDownloader = (FeedDownloader*) pCaller;
-	if ((pFeedDownloader->GetStatus() == WebDownloader::adFinished) ||
-		(pFeedDownloader->GetStatus() == WebDownloader::adFailed) ||
-		(pFeedDownloader->GetStatus() == WebDownloader::adRetry))
-	{
-		FeedCompleted(pFeedDownloader);
-	}
-}
-
-void FeedCoordinator::FeedCompleted(FeedDownloader* pFeedDownloader)
-{
-	debug("Feed downloaded");
-
-	FeedInfo* pFeedInfo = pFeedDownloader->GetFeedInfo();
-	bool bStatusOK = pFeedDownloader->GetStatus() == WebDownloader::adFinished;
-	if (bStatusOK)
-	{
-		pFeedInfo->SetOutputFilename(pFeedDownloader->GetOutputFilename());
-	}
-
-	// delete Download from Queue
-	m_mutexDownloads.Lock();
-	for (ActiveDownloads::iterator it = m_ActiveDownloads.begin(); it != m_ActiveDownloads.end(); it++)
-	{
-		FeedDownloader* pa = *it;
-		if (pa == pFeedDownloader)
-		{
-			m_ActiveDownloads.erase(it);
-			break;
-		}
-	}
-	m_mutexDownloads.Unlock();
-
-	if (bStatusOK)
-	{
-		if (!pFeedInfo->GetPreview())
-		{
-			FeedFile* pFeedFile = FeedFile::Create(pFeedInfo->GetOutputFilename());
-			remove(pFeedInfo->GetOutputFilename());
-
-			NZBList addedNZBs;
-
-			m_mutexDownloads.Lock();
-			if (pFeedFile)
-			{
-				ProcessFeed(pFeedInfo, pFeedFile->GetFeedItemInfos(), &addedNZBs);
-				delete pFeedFile;
-			}
-			pFeedInfo->SetLastUpdate(time(NULL));
-			pFeedInfo->SetForce(false);
-			m_bSave = true;
-			m_mutexDownloads.Unlock();
-
-			DownloadQueue* pDownloadQueue = DownloadQueue::Lock();
-			for (NZBList::iterator it = addedNZBs.begin(); it != addedNZBs.end(); it++)
-			{
-				NZBInfo* pNZBInfo = *it;
-				pDownloadQueue->GetQueue()->Add(pNZBInfo, false);
-			}
-			pDownloadQueue->Save();
-			DownloadQueue::Unlock();
-		}
-		pFeedInfo->SetStatus(FeedInfo::fsFinished);
-	}
-	else
-	{
-		pFeedInfo->SetStatus(FeedInfo::fsFailed);
-	}
-}
-
-void FeedCoordinator::FilterFeed(FeedInfo* pFeedInfo, FeedItemInfos* pFeedItemInfos)
-{
-	debug("Filtering feed %s", pFeedInfo->GetName());
-
-	FeedFilter* pFeedFilter = NULL;
-	if (pFeedInfo->GetFilter() && strlen(pFeedInfo->GetFilter()) > 0)
-	{
-		pFeedFilter = new FeedFilter(pFeedInfo->GetFilter());
-	}
-
-	for (FeedItemInfos::iterator it = pFeedItemInfos->begin(); it != pFeedItemInfos->end(); it++)
-    {
-        FeedItemInfo* pFeedItemInfo = *it;
-		pFeedItemInfo->SetMatchStatus(FeedItemInfo::msAccepted);
-		pFeedItemInfo->SetMatchRule(0);
-		pFeedItemInfo->SetPauseNzb(pFeedInfo->GetPauseNzb());
-		pFeedItemInfo->SetPriority(pFeedInfo->GetPriority());
-		pFeedItemInfo->SetAddCategory(pFeedInfo->GetCategory());
-		pFeedItemInfo->SetDupeScore(0);
-		pFeedItemInfo->SetDupeMode(dmScore);
-		pFeedItemInfo->BuildDupeKey(NULL, NULL);
-		if (pFeedFilter)
-		{
-			pFeedFilter->Match(pFeedItemInfo);
-		}
-    }
-
-	delete pFeedFilter;
-}
-
-void FeedCoordinator::ProcessFeed(FeedInfo* pFeedInfo, FeedItemInfos* pFeedItemInfos, NZBList* pAddedNZBs)
-{
-	debug("Process feed %s", pFeedInfo->GetName());
-
-	FilterFeed(pFeedInfo, pFeedItemInfos);
-
-	bool bFirstFetch = pFeedInfo->GetLastUpdate() == 0;
-	int iAdded = 0;
-
-    for (FeedItemInfos::iterator it = pFeedItemInfos->begin(); it != pFeedItemInfos->end(); it++)
-    {
-        FeedItemInfo* pFeedItemInfo = *it;
-		if (pFeedItemInfo->GetMatchStatus() == FeedItemInfo::msAccepted)
-		{
-			FeedHistoryInfo* pFeedHistoryInfo = m_FeedHistory.Find(pFeedItemInfo->GetUrl());
-			FeedHistoryInfo::EStatus eStatus = FeedHistoryInfo::hsUnknown;
-			if (bFirstFetch)
-			{
-				eStatus = FeedHistoryInfo::hsBacklog;
-			}
-			else if (!pFeedHistoryInfo)
-			{
-				NZBInfo* pNZBInfo = CreateNZBInfo(pFeedInfo, pFeedItemInfo);
-				pAddedNZBs->Add(pNZBInfo, false);
-				eStatus = FeedHistoryInfo::hsFetched;
-				iAdded++;
-			}
-
-			if (pFeedHistoryInfo)
-			{
-				pFeedHistoryInfo->SetLastSeen(time(NULL));
-			}
-			else
-			{
-				m_FeedHistory.Add(pFeedItemInfo->GetUrl(), eStatus, time(NULL));
-			}
-		}
-    }
-
-	if (iAdded)
-	{
-		info("%s has %i new item(s)", pFeedInfo->GetName(), iAdded);
-	}
-	else
-	{
-		detail("%s has no new items", pFeedInfo->GetName());
-	}
-}
-
-NZBInfo* FeedCoordinator::CreateNZBInfo(FeedInfo* pFeedInfo, FeedItemInfo* pFeedItemInfo)
-{
-	debug("Download %s from %s", pFeedItemInfo->GetUrl(), pFeedInfo->GetName());
-
-	NZBInfo* pNZBInfo = new NZBInfo();
-	pNZBInfo->SetKind(NZBInfo::nkUrl);
-	pNZBInfo->SetURL(pFeedItemInfo->GetUrl());
-
-	// add .nzb-extension if not present
-	char szNZBName[1024];
-	strncpy(szNZBName, pFeedItemInfo->GetFilename(), 1024);
-	szNZBName[1024-1] = '\0';
-	char* ext = strrchr(szNZBName, '.');
-	if (ext && !strcasecmp(ext, ".nzb"))
-	{
-		*ext = '\0';
-	}
-	char szNZBName2[1024];
-	snprintf(szNZBName2, 1024, "%s.nzb", szNZBName);
-	Util::MakeValidFilename(szNZBName2, '_', false);
-	if (strlen(szNZBName) > 0)
-	{
-		pNZBInfo->SetFilename(szNZBName2);
-	}
-
-	pNZBInfo->SetCategory(pFeedItemInfo->GetAddCategory());
-	pNZBInfo->SetPriority(pFeedItemInfo->GetPriority());
-	pNZBInfo->SetAddUrlPaused(pFeedItemInfo->GetPauseNzb());
-	pNZBInfo->SetDupeKey(pFeedItemInfo->GetDupeKey());
-	pNZBInfo->SetDupeScore(pFeedItemInfo->GetDupeScore());
-	pNZBInfo->SetDupeMode(pFeedItemInfo->GetDupeMode());
-
-	return pNZBInfo;
-}
-
-bool FeedCoordinator::ViewFeed(int iID, FeedItemInfos** ppFeedItemInfos)
-{
-	if (iID < 1 || iID > (int)m_Feeds.size())
-	{
-		return false;
-	}
-
-	FeedInfo* pFeedInfo = m_Feeds.at(iID - 1);
-
-	return PreviewFeed(pFeedInfo->GetName(), pFeedInfo->GetUrl(), pFeedInfo->GetFilter(), 
-		pFeedInfo->GetPauseNzb(), pFeedInfo->GetCategory(), pFeedInfo->GetPriority(),
-		0, NULL, ppFeedItemInfos);
-}
-
-bool FeedCoordinator::PreviewFeed(const char* szName, const char* szUrl, const char* szFilter,
-	bool bPauseNzb, const char* szCategory, int iPriority,
-	int iCacheTimeSec, const char* szCacheId, FeedItemInfos** ppFeedItemInfos)
-{
-	debug("Preview feed %s", szName);
-
-	FeedInfo* pFeedInfo = new FeedInfo(0, szName, szUrl, 0, szFilter, bPauseNzb, szCategory, iPriority);
-	pFeedInfo->SetPreview(true);
-	
-	FeedItemInfos* pFeedItemInfos = NULL;
-	bool bHasCache = false;
-	if (iCacheTimeSec > 0 && *szCacheId != '\0')
-	{
-		m_mutexDownloads.Lock();
-		for (FeedCache::iterator it = m_FeedCache.begin(); it != m_FeedCache.end(); it++)
-		{
-			FeedCacheItem* pFeedCacheItem = *it;
-			if (!strcmp(pFeedCacheItem->GetCacheId(), szCacheId))
-			{
-				pFeedCacheItem->SetLastUsage(time(NULL));
-				pFeedItemInfos = pFeedCacheItem->GetFeedItemInfos();
-				pFeedItemInfos->Retain();
-				bHasCache = true;
-				break;
-			}
-		}
-		m_mutexDownloads.Unlock();
-	}
-
-	if (!bHasCache)
-	{
-		m_mutexDownloads.Lock();
-
-		bool bFirstFetch = true;
-		for (Feeds::iterator it = m_Feeds.begin(); it != m_Feeds.end(); it++)
-		{
-			FeedInfo* pFeedInfo2 = *it;
-			if (!strcmp(pFeedInfo2->GetUrl(), pFeedInfo->GetUrl()) &&
-				!strcmp(pFeedInfo2->GetFilter(), pFeedInfo->GetFilter()) &&
-				pFeedInfo2->GetLastUpdate() > 0)
-			{
-				bFirstFetch = false;
-				break;
-			}
-		}
-
-		StartFeedDownload(pFeedInfo, true);
-		m_mutexDownloads.Unlock();
-
-		// wait until the download in a separate thread completes
-		while (pFeedInfo->GetStatus() == FeedInfo::fsRunning)
-		{
-			usleep(100 * 1000);
-		}
-
-		// now can process the feed
-
-		FeedFile* pFeedFile = NULL;
-
-		if (pFeedInfo->GetStatus() == FeedInfo::fsFinished)
-		{
-			pFeedFile = FeedFile::Create(pFeedInfo->GetOutputFilename());
-		}
-
-		remove(pFeedInfo->GetOutputFilename());
-
-		if (!pFeedFile)
-		{
-			delete pFeedInfo;
-			return false;
-		}
-
-		pFeedItemInfos = pFeedFile->GetFeedItemInfos();
-		pFeedItemInfos->Retain();
-		delete pFeedFile;
-
-		for (FeedItemInfos::iterator it = pFeedItemInfos->begin(); it != pFeedItemInfos->end(); it++)
-		{
-			FeedItemInfo* pFeedItemInfo = *it;
-			pFeedItemInfo->SetStatus(bFirstFetch ? FeedItemInfo::isBacklog : FeedItemInfo::isNew);
-			FeedHistoryInfo* pFeedHistoryInfo = m_FeedHistory.Find(pFeedItemInfo->GetUrl());
-			if (pFeedHistoryInfo)
-			{
-				pFeedItemInfo->SetStatus((FeedItemInfo::EStatus)pFeedHistoryInfo->GetStatus());
-			}
-		}
-	}
-
-	FilterFeed(pFeedInfo, pFeedItemInfos);
-	delete pFeedInfo;
-
-	if (iCacheTimeSec > 0 && *szCacheId != '\0' && !bHasCache)
-	{
-		FeedCacheItem* pFeedCacheItem = new FeedCacheItem(szUrl, iCacheTimeSec, szCacheId, time(NULL), pFeedItemInfos);
-		m_mutexDownloads.Lock();
-		m_FeedCache.push_back(pFeedCacheItem);
-		m_mutexDownloads.Unlock();
-	}
-	
-	*ppFeedItemInfos = pFeedItemInfos;
-
-	return true;
-}
-
-void FeedCoordinator::FetchFeed(int iID)
-{
-	debug("FetchFeeds");
-
-	m_mutexDownloads.Lock();
-	for (Feeds::iterator it = m_Feeds.begin(); it != m_Feeds.end(); it++)
-	{
-		FeedInfo* pFeedInfo = *it;
-		if (pFeedInfo->GetID() == iID || iID == 0)
-		{
-			pFeedInfo->SetFetch(true);
-			m_bForce = true;
-		}
-	}
-	m_mutexDownloads.Unlock();
-}
-
-void FeedCoordinator::DownloadQueueUpdate(Subject* pCaller, void* pAspect)
-{
-	debug("Notification from URL-Coordinator received");
-
-	DownloadQueue::Aspect* pQueueAspect = (DownloadQueue::Aspect*)pAspect;
-	if (pQueueAspect->eAction == DownloadQueue::eaUrlCompleted)
-	{
-		m_mutexDownloads.Lock();
-		FeedHistoryInfo* pFeedHistoryInfo = m_FeedHistory.Find(pQueueAspect->pNZBInfo->GetURL());
-		if (pFeedHistoryInfo)
-		{
-			pFeedHistoryInfo->SetStatus(FeedHistoryInfo::hsFetched);
-		}
-		else
-		{
-			m_FeedHistory.Add(pQueueAspect->pNZBInfo->GetURL(), FeedHistoryInfo::hsFetched, time(NULL));
-		}
-		m_bSave = true;
-		m_mutexDownloads.Unlock();
-	}
-}
-
-bool FeedCoordinator::HasActiveDownloads()
-{
-	m_mutexDownloads.Lock();
-	bool bActive = !m_ActiveDownloads.empty();
-	m_mutexDownloads.Unlock();
-	return bActive;
-}
-
-void FeedCoordinator::CheckSaveFeeds()
-{
-	debug("CheckSaveFeeds");
-	m_mutexDownloads.Lock();
-	if (m_bSave)
-	{
-		if (g_pOptions->GetSaveQueue() && g_pOptions->GetServerMode())
-		{
-			g_pDiskState->SaveFeeds(&m_Feeds, &m_FeedHistory);
-		}
-		m_bSave = false;
-	}
-	m_mutexDownloads.Unlock();
-}
-
-void FeedCoordinator::CleanupHistory()
-{
-	debug("CleanupHistory");
-
-	m_mutexDownloads.Lock();
-
-	time_t tOldestUpdate = time(NULL);
-
-	for (Feeds::iterator it = m_Feeds.begin(); it != m_Feeds.end(); it++)
-	{
-		FeedInfo* pFeedInfo = *it;
-		if (pFeedInfo->GetLastUpdate() < tOldestUpdate)
-		{
-			tOldestUpdate = pFeedInfo->GetLastUpdate();
-		}
-	}
-
-	time_t tBorderDate = tOldestUpdate - g_pOptions->GetFeedHistory() * 60*60*24;
-	int i = 0;
-	for (FeedHistory::iterator it = m_FeedHistory.begin(); it != m_FeedHistory.end(); )
-	{
-		FeedHistoryInfo* pFeedHistoryInfo = *it;
-		if (pFeedHistoryInfo->GetLastSeen() < tBorderDate)
-		{
-			detail("Deleting %s from feed history", pFeedHistoryInfo->GetUrl());
-			delete pFeedHistoryInfo;
-			m_FeedHistory.erase(it);
-			it = m_FeedHistory.begin() + i;
-			m_bSave = true;
-		}
-		else
-		{
-			it++;
-			i++;
-		}
-	}
-
-	m_mutexDownloads.Unlock();
-}
-
-void FeedCoordinator::CleanupCache()
-{
-	debug("CleanupCache");
-	
-	m_mutexDownloads.Lock();
-	
-	time_t tCurTime = time(NULL);
-	int i = 0;
-	for (FeedCache::iterator it = m_FeedCache.begin(); it != m_FeedCache.end(); )
-	{
-		FeedCacheItem* pFeedCacheItem = *it;
-		if (pFeedCacheItem->GetLastUsage() + pFeedCacheItem->GetCacheTimeSec() < tCurTime ||
-			pFeedCacheItem->GetLastUsage() > tCurTime)
-		{
-			debug("Deleting %s from feed cache", pFeedCacheItem->GetUrl());
-			delete pFeedCacheItem;
-			m_FeedCache.erase(it);
-			it = m_FeedCache.begin() + i;
-		}
-		else
-		{
-			it++;
-			i++;
-		}
-	}
-	
-	m_mutexDownloads.Unlock();
-}

daemon/feed/FeedCoordinator.h

@@ -1,127 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2013-2014 Andrey Prygunkov <hugbug@users.sourceforge.net>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- * $Revision$
- * $Date$
- *
- */
-
-
-#ifndef FEEDCOORDINATOR_H
-#define FEEDCOORDINATOR_H
-
-#include <deque>
-#include <list>
-#include <time.h>
-
-#include "Log.h"
-#include "Thread.h"
-#include "WebDownloader.h"
-#include "DownloadInfo.h"
-#include "FeedInfo.h"
-#include "Observer.h"
-
-
-class FeedDownloader;
-
-class FeedCoordinator : public Thread, public Observer, public Subject, public Debuggable
-{
-private:
-	class DownloadQueueObserver: public Observer
-	{
-	public:
-		FeedCoordinator*	m_pOwner;
-		virtual void		Update(Subject* pCaller, void* pAspect) { m_pOwner->DownloadQueueUpdate(pCaller, pAspect); }
-	};
-
-	class FeedCacheItem
-	{
-	private:
-		char*				m_szUrl;
-		int					m_iCacheTimeSec;
-		char*				m_szCacheId;
-		time_t				m_tLastUsage;
-		FeedItemInfos*		m_pFeedItemInfos;
-
-	public:
-							FeedCacheItem(const char* szUrl, int iCacheTimeSec,const char* szCacheId,
-								time_t tLastUsage, FeedItemInfos* pFeedItemInfos);
-							~FeedCacheItem();
-		const char*			GetUrl() { return m_szUrl; }
-		int					GetCacheTimeSec() { return m_iCacheTimeSec; }
-		const char*			GetCacheId() { return m_szCacheId; }
-		time_t				GetLastUsage() { return m_tLastUsage; }
-		void				SetLastUsage(time_t tLastUsage) { m_tLastUsage = tLastUsage; }
-		FeedItemInfos*		GetFeedItemInfos() { return m_pFeedItemInfos; }
-	};
-
-	typedef std::deque<FeedCacheItem*>	FeedCache;
-	typedef std::list<FeedDownloader*>	ActiveDownloads;
-
-private:
-	Feeds					m_Feeds;
-	ActiveDownloads			m_ActiveDownloads;
-	FeedHistory				m_FeedHistory;
-	Mutex					m_mutexDownloads;
-	DownloadQueueObserver	m_DownloadQueueObserver;
-	bool					m_bForce;
-	bool					m_bSave;
-	FeedCache				m_FeedCache;
-
-	void					StartFeedDownload(FeedInfo* pFeedInfo, bool bForce);
-	void					FeedCompleted(FeedDownloader* pFeedDownloader);
-	void					FilterFeed(FeedInfo* pFeedInfo, FeedItemInfos* pFeedItemInfos);
-	void					ProcessFeed(FeedInfo* pFeedInfo, FeedItemInfos* pFeedItemInfos, NZBList* pAddedNZBs);
-	NZBInfo*				CreateNZBInfo(FeedInfo* pFeedInfo, FeedItemInfo* pFeedItemInfo);
-	void					ResetHangingDownloads();
-	void					DownloadQueueUpdate(Subject* pCaller, void* pAspect);
-	void					CleanupHistory();
-	void					CleanupCache();
-	void					CheckSaveFeeds();
-
-protected:
-	virtual void			LogDebugInfo();
-
-public:
-							FeedCoordinator();                
-	virtual					~FeedCoordinator();
-	virtual void			Run();
-	virtual void 			Stop();
-	void					Update(Subject* pCaller, void* pAspect);
-	void					AddFeed(FeedInfo* pFeedInfo);
-	bool					PreviewFeed(const char* szName, const char* szUrl, const char* szFilter,
-								bool bPauseNzb, const char* szCategory, int iPriority,
-								int iCacheTimeSec, const char* szCacheId, FeedItemInfos** ppFeedItemInfos);
-	bool					ViewFeed(int iID, FeedItemInfos** ppFeedItemInfos);
-	void					FetchFeed(int iID);
-	bool					HasActiveDownloads();
-	Feeds*					GetFeeds() { return &m_Feeds; }
-};
-
-class FeedDownloader : public WebDownloader
-{
-private:
-	FeedInfo*				m_pFeedInfo;
-
-public:
-	void					SetFeedInfo(FeedInfo* pFeedInfo) { m_pFeedInfo = pFeedInfo; }
-	FeedInfo*				GetFeedInfo() { return m_pFeedInfo; }
-};
-
-#endif

daemon/feed/FeedFile.cpp

@@ -1,609 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2013-2014 Andrey Prygunkov <hugbug@users.sourceforge.net>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- * $Revision$
- * $Date$
- *
- */
-
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#ifdef WIN32
-#include "win32.h"
-#endif
-
-#include <string.h>
-#include <list>
-#ifdef WIN32
-#include <comutil.h>
-#import <msxml.tlb> named_guids 
-using namespace MSXML;
-#else
-#include <libxml/parser.h>
-#include <libxml/xmlreader.h>
-#include <libxml/xmlerror.h>
-#include <libxml/entities.h>
-#endif
-
-#include "nzbget.h"
-#include "FeedFile.h"
-#include "Log.h"
-#include "DownloadInfo.h"
-#include "Options.h"
-#include "Util.h"
-
-extern Options* g_pOptions;
-
-FeedFile::FeedFile(const char* szFileName)
-{
-    debug("Creating FeedFile");
-
-    m_szFileName = strdup(szFileName);
-	m_pFeedItemInfos = new FeedItemInfos();
-	m_pFeedItemInfos->Retain();
-
-#ifndef WIN32
-	m_pFeedItemInfo = NULL;
-	m_szTagContent = NULL;
-	m_iTagContentLen = 0;
-#endif
-}
-
-FeedFile::~FeedFile()
-{
-	debug("Destroying FeedFile");
-
-	// Cleanup
-	free(m_szFileName);
-	m_pFeedItemInfos->Release();
-
-#ifndef WIN32
-	delete m_pFeedItemInfo;
-	free(m_szTagContent);
-#endif
-}
-
-void FeedFile::LogDebugInfo()
-{
-    info(" FeedFile %s", m_szFileName);
-}
-
-void FeedFile::AddItem(FeedItemInfo* pFeedItemInfo)
-{
-	m_pFeedItemInfos->Add(pFeedItemInfo);
-}
-
-void FeedFile::ParseSubject(FeedItemInfo* pFeedItemInfo)
-{
-	// if title has quatation marks we use only part within quatation marks 
-	char* p = (char*)pFeedItemInfo->GetTitle();
-	char* start = strchr(p, '\"');
-	if (start)
-	{
-		start++;
-		char* end = strchr(start + 1, '\"');
-		if (end)
-		{
-			int len = (int)(end - start);
-			char* point = strchr(start + 1, '.');
-			if (point && point < end)
-			{
-				char* filename = (char*)malloc(len + 1);
-				strncpy(filename, start, len);
-				filename[len] = '\0';
-
-				char* ext = strrchr(filename, '.');
-				if (ext && !strcasecmp(ext, ".par2"))
-				{
-					*ext = '\0';
-				}
-
-				pFeedItemInfo->SetFilename(filename);
-				free(filename);
-				return;
-			}
-		}
-	}
-
-	pFeedItemInfo->SetFilename(pFeedItemInfo->GetTitle());
-}
-
-#ifdef WIN32
-FeedFile* FeedFile::Create(const char* szFileName)
-{
-    CoInitialize(NULL);
-
-	HRESULT hr;
-
-	MSXML::IXMLDOMDocumentPtr doc;
-	hr = doc.CreateInstance(MSXML::CLSID_DOMDocument);
-    if (FAILED(hr))
-    {
-        return NULL;
-    }
-
-    // Load the XML document file...
-	doc->put_resolveExternals(VARIANT_FALSE);
-	doc->put_validateOnParse(VARIANT_FALSE);
-	doc->put_async(VARIANT_FALSE);
-
-	// filename needs to be properly encoded
-	char* szURL = (char*)malloc(strlen(szFileName)*3 + 1);
-	EncodeURL(szFileName, szURL);
-	debug("url=\"%s\"", szURL);
-	_variant_t v(szURL);
-	free(szURL);
-
-	VARIANT_BOOL success = doc->load(v);
-	if (success == VARIANT_FALSE)
-	{
-		_bstr_t r(doc->GetparseError()->reason);
-		const char* szErrMsg = r;
-		error("Error parsing rss feed: %s", szErrMsg);
-		return NULL;
-	}
-
-    FeedFile* pFile = new FeedFile(szFileName);
-    if (!pFile->ParseFeed(doc))
-	{
-		delete pFile;
-		pFile = NULL;
-	}
-
-    return pFile;
-}
-
-void FeedFile::EncodeURL(const char* szFilename, char* szURL)
-{
-	while (char ch = *szFilename++)
-	{
-		if (('0' <= ch && ch <= '9') ||
-			('a' <= ch && ch <= 'z') ||
-			('A' <= ch && ch <= 'Z') )
-		{
-			*szURL++ = ch;
-		}
-		else
-		{
-			*szURL++ = '%';
-			int a = ch >> 4;
-			*szURL++ = a > 9 ? a - 10 + 'a' : a + '0';
-			a = ch & 0xF;
-			*szURL++ = a > 9 ? a - 10 + 'a' : a + '0';
-		}
-	}
-	*szURL = NULL;
-}
-
-bool FeedFile::ParseFeed(IUnknown* nzb)
-{
-	MSXML::IXMLDOMDocumentPtr doc = nzb;
-	MSXML::IXMLDOMNodePtr root = doc->documentElement;
-
-	MSXML::IXMLDOMNodeListPtr itemList = root->selectNodes("/rss/channel/item");
-	for (int i = 0; i < itemList->Getlength(); i++)
-	{
-		MSXML::IXMLDOMNodePtr node = itemList->Getitem(i);
-
-		FeedItemInfo* pFeedItemInfo = new FeedItemInfo();
-		AddItem(pFeedItemInfo);
-
-		MSXML::IXMLDOMNodePtr tag;
-		MSXML::IXMLDOMNodePtr attr;
-		
-		// <title>Debian 6</title> 
-		tag = node->selectSingleNode("title");
-		if (!tag)
-		{
-			// bad rss feed
-			return false;
-		}
-		_bstr_t title(tag->Gettext());
-		pFeedItemInfo->SetTitle(title);
-		ParseSubject(pFeedItemInfo);
-
-		// <pubDate>Wed, 26 Jun 2013 00:02:54 -0600</pubDate>
-		tag = node->selectSingleNode("pubDate");
-		if (tag)
-		{
-			_bstr_t time(tag->Gettext());
-			time_t unixtime = WebUtil::ParseRfc822DateTime(time);
-			if (unixtime > 0)
-			{
-				pFeedItemInfo->SetTime(unixtime);
-			}
-		}
-
-		// <category>Movies &gt; HD</category>
-		tag = node->selectSingleNode("category");
-		if (tag)
-		{
-			_bstr_t category(tag->Gettext());
-			pFeedItemInfo->SetCategory(category);
-		}
-
-		// <description>long text</description>
-		tag = node->selectSingleNode("description");
-		if (tag)
-		{
-			_bstr_t description(tag->Gettext());
-			pFeedItemInfo->SetDescription(description);
-		}
-
-		//<enclosure url="http://myindexer.com/fetch/9eeb264aecce961a6e0d" length="150263340" type="application/x-nzb" />
-		tag = node->selectSingleNode("enclosure");
-		if (tag)
-		{
-			attr = tag->Getattributes()->getNamedItem("url");
-			if (attr)
-			{
-				_bstr_t url(attr->Gettext());
-				pFeedItemInfo->SetUrl(url);
-			}
-
-			attr = tag->Getattributes()->getNamedItem("length");
-			if (attr)
-			{
-				_bstr_t size(attr->Gettext());
-				long long lSize = atoll(size);
-				pFeedItemInfo->SetSize(lSize);
-			}
-		}
-
-		if (!pFeedItemInfo->GetUrl())
-		{
-			// <link>https://nzb.org/fetch/334534ce/4364564564</link>
-			tag = node->selectSingleNode("link");
-			if (!tag)
-			{
-				// bad rss feed
-				return false;
-			}
-			_bstr_t link(tag->Gettext());
-			pFeedItemInfo->SetUrl(link);
-		}
-
-
-		// newznab special
-
-		//<newznab:attr name="size" value="5423523453534" />
-		if (pFeedItemInfo->GetSize() == 0)
-		{
-			tag = node->selectSingleNode("newznab:attr[@name='size']");
-			if (tag)
-			{
-				attr = tag->Getattributes()->getNamedItem("value");
-				if (attr)
-				{
-					_bstr_t size(attr->Gettext());
-					long long lSize = atoll(size);
-					pFeedItemInfo->SetSize(lSize);
-				}
-			}
-		}
-
-		//<newznab:attr name="imdb" value="1588173"/>
-		tag = node->selectSingleNode("newznab:attr[@name='imdb']");
-		if (tag)
-		{
-			attr = tag->Getattributes()->getNamedItem("value");
-			if (attr)
-			{
-				_bstr_t val(attr->Gettext());
-				int iVal = atoi(val);
-				pFeedItemInfo->SetImdbId(iVal);
-			}
-		}
-
-		//<newznab:attr name="rageid" value="33877"/>
-		tag = node->selectSingleNode("newznab:attr[@name='rageid']");
-		if (tag)
-		{
-			attr = tag->Getattributes()->getNamedItem("value");
-			if (attr)
-			{
-				_bstr_t val(attr->Gettext());
-				int iVal = atoi(val);
-				pFeedItemInfo->SetRageId(iVal);
-			}
-		}
-
-		//<newznab:attr name="episode" value="E09"/>
-		//<newznab:attr name="episode" value="9"/>
-		tag = node->selectSingleNode("newznab:attr[@name='episode']");
-		if (tag)
-		{
-			attr = tag->Getattributes()->getNamedItem("value");
-			if (attr)
-			{
-				_bstr_t val(attr->Gettext());
-				pFeedItemInfo->SetEpisode(val);
-			}
-		}
-
-		//<newznab:attr name="season" value="S03"/>
-		//<newznab:attr name="season" value="3"/>
-		tag = node->selectSingleNode("newznab:attr[@name='season']");
-		if (tag)
-		{
-			attr = tag->Getattributes()->getNamedItem("value");
-			if (attr)
-			{
-				_bstr_t val(attr->Gettext());
-				pFeedItemInfo->SetSeason(val);
-			}
-		}
-
-		MSXML::IXMLDOMNodeListPtr itemList = node->selectNodes("newznab:attr");
-		for (int i = 0; i < itemList->Getlength(); i++)
-		{
-			MSXML::IXMLDOMNodePtr node = itemList->Getitem(i);
-			MSXML::IXMLDOMNodePtr name = node->Getattributes()->getNamedItem("name");
-			MSXML::IXMLDOMNodePtr value = node->Getattributes()->getNamedItem("value");
-			if (name && value)
-			{
-				_bstr_t name(name->Gettext());
-				_bstr_t val(value->Gettext());
-				pFeedItemInfo->GetAttributes()->Add(name, val);
-			}
-		}
-	}
-	return true;
-}
-
-#else
-
-FeedFile* FeedFile::Create(const char* szFileName)
-{
-    FeedFile* pFile = new FeedFile(szFileName);
-
-	xmlSAXHandler SAX_handler = {0};
-	SAX_handler.startElement = reinterpret_cast<startElementSAXFunc>(SAX_StartElement);
-	SAX_handler.endElement = reinterpret_cast<endElementSAXFunc>(SAX_EndElement);
-	SAX_handler.characters = reinterpret_cast<charactersSAXFunc>(SAX_characters);
-	SAX_handler.error = reinterpret_cast<errorSAXFunc>(SAX_error);
-	SAX_handler.getEntity = reinterpret_cast<getEntitySAXFunc>(SAX_getEntity);
-
-	pFile->m_bIgnoreNextError = false;
-
-	int ret = xmlSAXUserParseFile(&SAX_handler, pFile, szFileName);
-    
-    if (ret != 0)
-	{
-        error("Failed to parse rss feed");
-		delete pFile;
-		pFile = NULL;
-	}
-	
-	return pFile;
-}
-
-void FeedFile::Parse_StartElement(const char *name, const char **atts)
-{
-	ResetTagContent();
-	
-	if (!strcmp("item", name))
-	{
-		delete m_pFeedItemInfo;
-		m_pFeedItemInfo = new FeedItemInfo();
-	}
-	else if (!strcmp("enclosure", name) && m_pFeedItemInfo)
-	{
-		//<enclosure url="http://myindexer.com/fetch/9eeb264aecce961a6e0d" length="150263340" type="application/x-nzb" />
-		for (; *atts; atts+=2)
-		{
-			if (!strcmp("url", atts[0]))
-			{
-				char* szUrl = strdup(atts[1]);
-				WebUtil::XmlDecode(szUrl);
-				m_pFeedItemInfo->SetUrl(szUrl);
-				free(szUrl);
-			}
-			else if (!strcmp("length", atts[0]))
-			{
-				long long lSize = atoll(atts[1]);
-				m_pFeedItemInfo->SetSize(lSize);
-			}
-		}
-	}
-	else if (m_pFeedItemInfo && !strcmp("newznab:attr", name) &&
-		atts[0] && atts[1] && atts[2] && atts[3] &&
-		!strcmp("name", atts[0]) && !strcmp("value", atts[2]))
-	{
-		m_pFeedItemInfo->GetAttributes()->Add(atts[1], atts[3]);
-
-		//<newznab:attr name="size" value="5423523453534" />
-		if (m_pFeedItemInfo->GetSize() == 0 &&
-			!strcmp("size", atts[1]))
-		{
-			long long lSize = atoll(atts[3]);
-			m_pFeedItemInfo->SetSize(lSize);
-		}
-
-		//<newznab:attr name="imdb" value="1588173"/>
-		else if (!strcmp("imdb", atts[1]))
-		{
-			m_pFeedItemInfo->SetImdbId(atoi(atts[3]));
-		}
-
-		//<newznab:attr name="rageid" value="33877"/>
-		else if (!strcmp("rageid", atts[1]))
-		{
-			m_pFeedItemInfo->SetRageId(atoi(atts[3]));
-		}
-
-		//<newznab:attr name="episode" value="E09"/>
-		//<newznab:attr name="episode" value="9"/>
-		else if (!strcmp("episode", atts[1]))
-		{
-			m_pFeedItemInfo->SetEpisode(atts[3]);
-		}
-
-		//<newznab:attr name="season" value="S03"/>
-		//<newznab:attr name="season" value="3"/>
-		else if (!strcmp("season", atts[1]))
-		{
-			m_pFeedItemInfo->SetSeason(atts[3]);
-		}
-	}
-}
-
-void FeedFile::Parse_EndElement(const char *name)
-{
-	if (!strcmp("item", name))
-	{
-		// Close the file element, add the new file to file-list
-		AddItem(m_pFeedItemInfo);
-		m_pFeedItemInfo = NULL;
-	}
-	else if (!strcmp("title", name) && m_pFeedItemInfo)
-	{
-		m_pFeedItemInfo->SetTitle(m_szTagContent);
-		ResetTagContent();
-		ParseSubject(m_pFeedItemInfo);
-	}
-	else if (!strcmp("link", name) && m_pFeedItemInfo &&
-		(!m_pFeedItemInfo->GetUrl() || strlen(m_pFeedItemInfo->GetUrl()) == 0))
-	{
-		m_pFeedItemInfo->SetUrl(m_szTagContent);
-		ResetTagContent();
-	}
-	else if (!strcmp("category", name) && m_pFeedItemInfo)
-	{
-		m_pFeedItemInfo->SetCategory(m_szTagContent);
-		ResetTagContent();
-	}
-	else if (!strcmp("description", name) && m_pFeedItemInfo)
-	{
-		m_pFeedItemInfo->SetDescription(m_szTagContent);
-		ResetTagContent();
-	}
-	else if (!strcmp("pubDate", name) && m_pFeedItemInfo)
-	{
-		time_t unixtime = WebUtil::ParseRfc822DateTime(m_szTagContent);
-		if (unixtime > 0)
-		{
-			m_pFeedItemInfo->SetTime(unixtime);
-		}
-		ResetTagContent();
-	}
-}
-
-void FeedFile::Parse_Content(const char *buf, int len)
-{
-	m_szTagContent = (char*)realloc(m_szTagContent, m_iTagContentLen + len + 1);
-	strncpy(m_szTagContent + m_iTagContentLen, buf, len);
-	m_iTagContentLen += len;
-	m_szTagContent[m_iTagContentLen] = '\0';
-}
-
-void FeedFile::ResetTagContent()
-{
-	free(m_szTagContent);
-	m_szTagContent = NULL;
-	m_iTagContentLen = 0;
-}
-
-void FeedFile::SAX_StartElement(FeedFile* pFile, const char *name, const char **atts)
-{
-	pFile->Parse_StartElement(name, atts);
-}
-
-void FeedFile::SAX_EndElement(FeedFile* pFile, const char *name)
-{
-	pFile->Parse_EndElement(name);
-}
-
-void FeedFile::SAX_characters(FeedFile* pFile, const char * xmlstr, int len)
-{
-	char* str = (char*)xmlstr;
-	
-	// trim starting blanks
-	int off = 0;
-	for (int i = 0; i < len; i++)
-	{
-		char ch = str[i];
-		if (ch == ' ' || ch == 10 || ch == 13 || ch == 9)
-		{
-			off++;
-		}
-		else
-		{
-			break;
-		}
-	}
-	
-	int newlen = len - off;
-	
-	// trim ending blanks
-	for (int i = len - 1; i >= off; i--)
-	{
-		char ch = str[i];
-		if (ch == ' ' || ch == 10 || ch == 13 || ch == 9)
-		{
-			newlen--;
-		}
-		else
-		{
-			break;
-		}
-	}
-	
-	if (newlen > 0)
-	{
-		// interpret tag content
-		pFile->Parse_Content(str + off, newlen);
-	}
-}
-
-void* FeedFile::SAX_getEntity(FeedFile* pFile, const char * name)
-{
-	xmlEntityPtr e = xmlGetPredefinedEntity((xmlChar* )name);
-	if (!e)
-	{
-		warn("entity not found");
-		pFile->m_bIgnoreNextError = true;
-	}
-
-	return e;
-}
-
-void FeedFile::SAX_error(FeedFile* pFile, const char *msg, ...)
-{
-	if (pFile->m_bIgnoreNextError)
-	{
-		pFile->m_bIgnoreNextError = false;
-		return;
-	}
-	
-    va_list argp;
-    va_start(argp, msg);
-    char szErrMsg[1024];
-    vsnprintf(szErrMsg, sizeof(szErrMsg), msg, argp);
-    szErrMsg[1024-1] = '\0';
-    va_end(argp);
-
-	// remove trailing CRLF
-	for (char* pend = szErrMsg + strlen(szErrMsg) - 1; pend >= szErrMsg && (*pend == '\n' || *pend == '\r' || *pend == ' '); pend--) *pend = '\0';
-    error("Error parsing rss feed: %s", szErrMsg);
-}
-#endif

daemon/feed/FeedFile.h

@@ -1,70 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2013 Andrey Prygunkov <hugbug@users.sourceforge.net>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- * $Revision$
- * $Date$
- *
- */
-
-
-#ifndef FEEDFILE_H
-#define FEEDFILE_H
-
-#include <vector>
-
-#include "FeedInfo.h"
-
-class FeedFile
-{
-private:
-	FeedItemInfos*		m_pFeedItemInfos;
-	char*				m_szFileName;
-
-						FeedFile(const char* szFileName);
-	void				AddItem(FeedItemInfo* pFeedItemInfo);
-	void				ParseSubject(FeedItemInfo* pFeedItemInfo);
-#ifdef WIN32
-    bool 				ParseFeed(IUnknown* nzb);
-	static void			EncodeURL(const char* szFilename, char* szURL);
-#else
-	FeedItemInfo*		m_pFeedItemInfo;
-	char*				m_szTagContent;
-	int					m_iTagContentLen;
-	bool				m_bIgnoreNextError;
-
-	static void			SAX_StartElement(FeedFile* pFile, const char *name, const char **atts);
-	static void			SAX_EndElement(FeedFile* pFile, const char *name);
-	static void			SAX_characters(FeedFile* pFile, const char * xmlstr, int len);
-	static void*		SAX_getEntity(FeedFile* pFile, const char * name);
-	static void			SAX_error(FeedFile* pFile, const char *msg, ...);
-	void				Parse_StartElement(const char *name, const char **atts);
-	void				Parse_EndElement(const char *name);
-	void				Parse_Content(const char *buf, int len);
-	void				ResetTagContent();
-#endif
-
-public:
-	virtual 			~FeedFile();
-	static FeedFile*	Create(const char* szFileName);
-	FeedItemInfos*		GetFeedItemInfos() { return m_pFeedItemInfos; }
-
-	void				LogDebugInfo();
-};
-
-#endif

daemon/feed/FeedFilter.h

@@ -1,186 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2013 Andrey Prygunkov <hugbug@users.sourceforge.net>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- * $Revision$
- * $Date$
- *
- */
-
-
-#ifndef FEEDFILTER_H
-#define FEEDFILTER_H
-
-#include "DownloadInfo.h"
-#include "FeedInfo.h"
-#include "Util.h"
-
-class FeedFilter
-{
-private:
-	typedef std::deque<char*> RefValues;
-
-	enum ETermCommand
-	{
-		fcText,
-		fcRegex,
-		fcEqual,
-		fcLess,
-		fcLessEqual,
-		fcGreater,
-		fcGreaterEqual,
-		fcOpeningBrace,
-		fcClosingBrace,
-		fcOrOperator
-	};
-	
-	class Term
-	{
-	private:
-		bool			m_bPositive;
-		char*			m_szField;
-		ETermCommand	m_eCommand;
-		char*			m_szParam;
-		long long		m_iIntParam;
-		double			m_fFloatParam;
-		bool			m_bFloat;
-		RegEx*			m_pRegEx;
-		RefValues*		m_pRefValues;
-
-		bool			GetFieldData(const char* szField, FeedItemInfo* pFeedItemInfo,
-							const char** StrValue, long long* IntValue);
-		bool			ParseParam(const char* szField, const char* szParam);
-		bool			ParseSizeParam(const char* szParam);
-		bool			ParseAgeParam(const char* szParam);
-		bool			ParseNumericParam(const char* szParam);
-		bool			MatchValue(const char* szStrValue, long long iIntValue);
-		bool			MatchText(const char* szStrValue);
-		bool			MatchRegex(const char* szStrValue);
-		void			FillWildMaskRefValues(const char* szStrValue, WildMask* pMask, int iRefOffset);
-		void			FillRegExRefValues(const char* szStrValue, RegEx* pRegEx);
-
-	public:
-						Term();
-						~Term();
-		void			SetRefValues(RefValues* pRefValues) { m_pRefValues = pRefValues; }
-		bool			Compile(char* szToken);
-		bool			Match(FeedItemInfo* pFeedItemInfo);
-		ETermCommand	GetCommand() { return m_eCommand; }
-	};
-
-	typedef std::deque<Term*> TermList;
-
-	enum ERuleCommand
-	{
-		frAccept,
-		frReject,
-		frRequire,
-		frOptions,
-		frComment
-	};
-
-	class Rule
-	{
-	private:
-		bool			m_bIsValid;
-		ERuleCommand	m_eCommand;
-		char*			m_szCategory;
-		int				m_iPriority;
-		int				m_iAddPriority;
-		bool			m_bPause;
-		int				m_iDupeScore;
-		int				m_iAddDupeScore;
-		char*			m_szDupeKey;
-		char*			m_szAddDupeKey;
-		EDupeMode		m_eDupeMode;
-		char*			m_szSeries;
-		char*			m_szRageId;
-		bool			m_bHasCategory;
-		bool			m_bHasPriority;
-		bool			m_bHasAddPriority;
-		bool			m_bHasPause;
-		bool			m_bHasDupeScore;
-		bool			m_bHasAddDupeScore;
-		bool			m_bHasDupeKey;
-		bool			m_bHasAddDupeKey;
-		bool			m_bHasDupeMode;
-		bool			m_bPatCategory;
-		bool			m_bPatDupeKey;
-		bool			m_bPatAddDupeKey;
-		bool			m_bHasSeries;
-		bool			m_bHasRageId;
-		char*			m_szPatCategory;
-		char*			m_szPatDupeKey;
-		char*			m_szPatAddDupeKey;
-		TermList		m_Terms;
-		RefValues		m_RefValues;
-
-		char*			CompileCommand(char* szRule);
-		char*			CompileOptions(char* szRule);
-		bool			CompileTerm(char* szTerm);
-		bool			MatchExpression(FeedItemInfo* pFeedItemInfo);
-
-	public:
-						Rule();
-						~Rule();
-		void			Compile(char* szRule);
-		bool			IsValid() { return m_bIsValid; }
-		ERuleCommand	GetCommand() { return m_eCommand; }
-		const char*		GetCategory() { return m_szCategory; }
-		int				GetPriority() { return m_iPriority; }
-		int				GetAddPriority() { return m_iAddPriority; }
-		bool			GetPause() { return m_bPause; }
-		const char*		GetDupeKey() { return m_szDupeKey; }
-		const char*		GetAddDupeKey() { return m_szAddDupeKey; }
-		int				GetDupeScore() { return m_iDupeScore; }
-		int				GetAddDupeScore() { return m_iAddDupeScore; }
-		EDupeMode		GetDupeMode() { return m_eDupeMode; }
-		const char*		GetRageId() { return m_szRageId; }
-		const char*		GetSeries() { return m_szSeries; }
-		bool			HasCategory() { return m_bHasCategory; }
-		bool			HasPriority() { return m_bHasPriority; }
-		bool			HasAddPriority() { return m_bHasAddPriority; }
-		bool			HasPause() { return m_bHasPause; }
-		bool			HasDupeScore() { return m_bHasDupeScore; }
-		bool			HasAddDupeScore() { return m_bHasAddDupeScore; }
-		bool			HasDupeKey() { return m_bHasDupeKey; }
-		bool			HasAddDupeKey() { return m_bHasAddDupeKey; }
-		bool			HasDupeMode() { return m_bHasDupeMode; }
-		bool			HasRageId() { return m_bHasRageId; }
-		bool			HasSeries() { return m_bHasSeries; }
-		bool			Match(FeedItemInfo* pFeedItemInfo);
-		void			ExpandRefValues(FeedItemInfo* pFeedItemInfo, char** pDestStr, char* pPatStr);
-		const char*		GetRefValue(FeedItemInfo* pFeedItemInfo, const char* szVarName);
-	};
-
-	typedef std::deque<Rule*> RuleList;
-
-private:
-	RuleList			m_Rules;
-
-	void				Compile(const char* szFilter);
-	void				CompileRule(char* szRule);
-	void				ApplyOptions(Rule* pRule, FeedItemInfo* pFeedItemInfo);
-
-public:
-						FeedFilter(const char* szFilter);
-						~FeedFilter();
-	void				Match(FeedItemInfo* pFeedItemInfo);
-};
-
-#endif

daemon/feed/FeedInfo.cpp

@@ -1,440 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2007-2013 Andrey Prygunkov <hugbug@users.sourceforge.net>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- * $Revision: 0 $
- * $Date$
- *
- */
-
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#ifdef WIN32
-#include "win32.h"
-#endif
-
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#include <ctype.h>
-#include <sys/stat.h>
-
-#include "nzbget.h"
-#include "FeedInfo.h"
-#include "Util.h"
-
-
-FeedInfo::FeedInfo(int iID, const char* szName, const char* szUrl, int iInterval,
-	const char* szFilter, bool bPauseNzb, const char* szCategory, int iPriority)
-{
-	m_iID = iID;
-	m_szName = strdup(szName ? szName : "");
-	m_szUrl = strdup(szUrl ? szUrl : "");
-	m_szFilter = strdup(szFilter ? szFilter : "");
-	m_iFilterHash = Util::HashBJ96(szFilter, strlen(szFilter), 0);
-	m_szCategory = strdup(szCategory ? szCategory : "");
-	m_iInterval = iInterval;
-	m_bPauseNzb = bPauseNzb;
-	m_iPriority = iPriority;
-	m_tLastUpdate = 0;
-	m_bPreview = false;
-	m_eStatus = fsUndefined;
-	m_szOutputFilename = NULL;
-	m_bFetch = false;
-	m_bForce = false;
-}
-
-FeedInfo::~FeedInfo()
-{
-	free(m_szName);
-	free(m_szUrl);
-	free(m_szFilter);
-	free(m_szCategory);
-	free(m_szOutputFilename);
-}
-
-void FeedInfo::SetOutputFilename(const char* szOutputFilename)
-{
-	free(m_szOutputFilename);
-	m_szOutputFilename = strdup(szOutputFilename);
-}
-
-
-FeedItemInfo::Attr::Attr(const char* szName, const char* szValue)
-{
-	m_szName = strdup(szName ? szName : "");
-	m_szValue = strdup(szValue ? szValue : "");
-}
-
-FeedItemInfo::Attr::~Attr()
-{
-	free(m_szName);
-	free(m_szValue);
-}
-
-
-FeedItemInfo::Attributes::~Attributes()
-{
-	for (iterator it = begin(); it != end(); it++)
-	{
-		delete *it;
-	}
-}
-
-void FeedItemInfo::Attributes::Add(const char* szName, const char* szValue)
-{
-	push_back(new Attr(szName, szValue));
-}
-
-FeedItemInfo::Attr* FeedItemInfo::Attributes::Find(const char* szName)
-{
-	for (iterator it = begin(); it != end(); it++)
-	{
-		Attr* pAttr = *it;
-		if (!strcasecmp(pAttr->GetName(), szName))
-		{
-			return pAttr;
-		}
-	}
-
-	return NULL;
-}
-
-
-FeedItemInfo::FeedItemInfo()
-{
-	m_pSharedFeedData = NULL;
-	m_szTitle = NULL;
-	m_szFilename = NULL;
-	m_szUrl = NULL;
-	m_szCategory = strdup("");
-	m_lSize = 0;
-	m_tTime = 0;
-	m_iImdbId = 0;
-	m_iRageId = 0;
-	m_szDescription = strdup("");
-	m_szSeason = NULL;
-	m_szEpisode = NULL;
-	m_iSeasonNum = 0;
-	m_iEpisodeNum = 0;
-	m_bSeasonEpisodeParsed = false;
-	m_szAddCategory = strdup("");
-	m_bPauseNzb = false;
-	m_iPriority = 0;
-	m_eStatus = isUnknown;
-	m_eMatchStatus = msIgnored;
-	m_iMatchRule = 0;
-	m_szDupeKey = NULL;
-	m_iDupeScore = 0;
-	m_eDupeMode = dmScore;
-}
-
-FeedItemInfo::~FeedItemInfo()
-{
-	free(m_szTitle);
-	free(m_szFilename);
-	free(m_szUrl);
-	free(m_szCategory);
-	free(m_szDescription);
-	free(m_szSeason);
-	free(m_szEpisode);
-	free(m_szAddCategory);
-	free(m_szDupeKey);
-}
-
-void FeedItemInfo::SetTitle(const char* szTitle)
-{
-	free(m_szTitle);
-	m_szTitle = szTitle ? strdup(szTitle) : NULL;
-}
-
-void FeedItemInfo::SetFilename(const char* szFilename)
-{
-	free(m_szFilename);
-	m_szFilename = szFilename ? strdup(szFilename) : NULL;
-}
-
-void FeedItemInfo::SetUrl(const char* szUrl)
-{
-	free(m_szUrl);
-	m_szUrl = szUrl ? strdup(szUrl) : NULL;
-}
-
-void FeedItemInfo::SetCategory(const char* szCategory)
-{
-	free(m_szCategory);
-	m_szCategory = strdup(szCategory ? szCategory: "");
-}
-
-void FeedItemInfo::SetDescription(const char* szDescription)
-{
-	free(m_szDescription);
-	m_szDescription = strdup(szDescription ? szDescription: "");
-}
-
-void FeedItemInfo::SetSeason(const char* szSeason)
-{
-	free(m_szSeason);
-	m_szSeason = szSeason ? strdup(szSeason) : NULL;
-	m_iSeasonNum = szSeason ? ParsePrefixedInt(szSeason) : 0;
-}
-
-void FeedItemInfo::SetEpisode(const char* szEpisode)
-{
-	free(m_szEpisode);
-	m_szEpisode = szEpisode ? strdup(szEpisode) : NULL;
-	m_iEpisodeNum = szEpisode ? ParsePrefixedInt(szEpisode) : 0;
-}
-
-int FeedItemInfo::ParsePrefixedInt(const char *szValue)
-{
-	const char* szVal = szValue;
-	if (!strchr("0123456789", *szVal))
-	{
-		szVal++;
-	}
-	return atoi(szVal);
-}
-
-void FeedItemInfo::SetAddCategory(const char* szAddCategory)
-{
-	free(m_szAddCategory);
-	m_szAddCategory = strdup(szAddCategory ? szAddCategory : "");
-}
-
-void FeedItemInfo::SetDupeKey(const char* szDupeKey)
-{
-	free(m_szDupeKey);
-	m_szDupeKey = strdup(szDupeKey ? szDupeKey : "");
-}
-
-void FeedItemInfo::AppendDupeKey(const char* szExtraDupeKey)
-{
-	if (!m_szDupeKey || *m_szDupeKey == '\0' || !szExtraDupeKey || *szExtraDupeKey == '\0')
-	{
-		return;
-	}
-
-	int iLen = (m_szDupeKey ? strlen(m_szDupeKey) : 0) + 1 + strlen(szExtraDupeKey) + 1;
-	char* szNewKey = (char*)malloc(iLen);
-	snprintf(szNewKey, iLen, "%s-%s", m_szDupeKey, szExtraDupeKey);
-	szNewKey[iLen - 1] = '\0';
-
-	free(m_szDupeKey);
-	m_szDupeKey = szNewKey;
-}
-
-void FeedItemInfo::BuildDupeKey(const char* szRageId, const char* szSeries)
-{
-	int iRageId = szRageId && *szRageId ? atoi(szRageId) : m_iRageId;
-
-	free(m_szDupeKey);
-
-	if (m_iImdbId != 0)
-	{
-		m_szDupeKey = (char*)malloc(20);
-		snprintf(m_szDupeKey, 20, "imdb=%i", m_iImdbId);
-	}
-	else if (szSeries && *szSeries && GetSeasonNum() != 0 && GetEpisodeNum() != 0)
-	{
-		int iLen = strlen(szSeries) + 50;
-		m_szDupeKey = (char*)malloc(iLen);
-		snprintf(m_szDupeKey, iLen, "series=%s-%s-%s", szSeries, m_szSeason, m_szEpisode);
-		m_szDupeKey[iLen-1] = '\0';
-	}
-	else if (iRageId != 0 && GetSeasonNum() != 0 && GetEpisodeNum() != 0)
-	{
-		m_szDupeKey = (char*)malloc(100);
-		snprintf(m_szDupeKey, 100, "rageid=%i-%s-%s", iRageId, m_szSeason, m_szEpisode);
-		m_szDupeKey[100-1] = '\0';
-	}
-	else
-	{
-		m_szDupeKey = strdup("");
-	}
-}
-
-int FeedItemInfo::GetSeasonNum()
-{
-	if (!m_szSeason && !m_bSeasonEpisodeParsed)
-	{
-		ParseSeasonEpisode();
-	}
-
-	return m_iSeasonNum;
-}
-
-int FeedItemInfo::GetEpisodeNum()
-{
-	if (!m_szEpisode && !m_bSeasonEpisodeParsed)
-	{
-		ParseSeasonEpisode();
-	}
-
-	return m_iEpisodeNum;
-}
-
-void FeedItemInfo::ParseSeasonEpisode()
-{
-	m_bSeasonEpisodeParsed = true;
-
-	RegEx* pRegEx = m_pSharedFeedData->GetSeasonEpisodeRegEx();
-
-	if (pRegEx->Match(m_szTitle))
-	{
-		char szRegValue[100];
-		char szValue[100];
-
-		snprintf(szValue, 100, "S%02d", atoi(m_szTitle + pRegEx->GetMatchStart(1)));
-		szValue[100-1] = '\0';
-		SetSeason(szValue);
-
-		int iLen = pRegEx->GetMatchLen(2);
-		iLen = iLen < 99 ? iLen : 99;
-		strncpy(szRegValue, m_szTitle + pRegEx->GetMatchStart(2), pRegEx->GetMatchLen(2));
-		szRegValue[iLen] = '\0';
-		snprintf(szValue, 100, "E%s", szRegValue);
-		szValue[100-1] = '\0';
-		Util::ReduceStr(szValue, "-", "");
-		for (char* p = szValue; *p; p++) *p = toupper(*p); // convert string to uppercase e02 -> E02
-		SetEpisode(szValue);
-	}
-}
-
-
-FeedHistoryInfo::FeedHistoryInfo(const char* szUrl, FeedHistoryInfo::EStatus eStatus, time_t tLastSeen)
-{
-	m_szUrl = szUrl ? strdup(szUrl) : NULL;
-	m_eStatus = eStatus;
-	m_tLastSeen = tLastSeen;
-}
-
-FeedHistoryInfo::~FeedHistoryInfo()
-{
-	free(m_szUrl);
-}
-
-
-FeedHistory::~FeedHistory()
-{
-	Clear();
-}
-
-void FeedHistory::Clear()
-{
-	for (iterator it = begin(); it != end(); it++)
-	{
-		delete *it;
-	}
-	clear();
-}
-
-void FeedHistory::Add(const char* szUrl, FeedHistoryInfo::EStatus eStatus, time_t tLastSeen)
-{
-	push_back(new FeedHistoryInfo(szUrl, eStatus, tLastSeen));
-}
-
-void FeedHistory::Remove(const char* szUrl)
-{
-	for (iterator it = begin(); it != end(); it++)
-	{
-		FeedHistoryInfo* pFeedHistoryInfo = *it;
-		if (!strcmp(pFeedHistoryInfo->GetUrl(), szUrl))
-		{
-			delete pFeedHistoryInfo;
-			erase(it);
-			break;
-		}
-	}
-}
-
-FeedHistoryInfo* FeedHistory::Find(const char* szUrl)
-{
-	for (iterator it = begin(); it != end(); it++)
-	{
-		FeedHistoryInfo* pFeedHistoryInfo = *it;
-		if (!strcmp(pFeedHistoryInfo->GetUrl(), szUrl))
-		{
-			return pFeedHistoryInfo;
-		}
-	}
-
-	return NULL;
-}
-
-
-FeedItemInfos::FeedItemInfos()
-{
-	debug("Creating FeedItemInfos");
-	
-	m_iRefCount = 0;
-}
-
-FeedItemInfos::~FeedItemInfos()
-{
-	debug("Destroing FeedItemInfos");
-	
-	for (iterator it = begin(); it != end(); it++)
-    {
-        delete *it;
-    }
-}
-
-void FeedItemInfos::Retain()
-{
-	m_iRefCount++;
-}
-
-void FeedItemInfos::Release()
-{
-	m_iRefCount--;
-	if (m_iRefCount <= 0)
-	{
-		delete this;
-	}
-}
-
-void FeedItemInfos::Add(FeedItemInfo* pFeedItemInfo)
-{
-	push_back(pFeedItemInfo);
-	pFeedItemInfo->SetSharedFeedData(&m_SharedFeedData);
-}
-
-
-SharedFeedData::SharedFeedData()
-{
-	m_pSeasonEpisodeRegEx = NULL;
-}
-
-SharedFeedData::~SharedFeedData()
-{
-	delete m_pSeasonEpisodeRegEx;
-}
-
-RegEx* SharedFeedData::GetSeasonEpisodeRegEx()
-{
-	if (!m_pSeasonEpisodeRegEx)
-	{
-		m_pSeasonEpisodeRegEx = new RegEx("[^[:alnum:]]s?([0-9]+)[ex]([0-9]+(-?e[0-9]+)?)[^[:alnum:]]", 10);
-	}
-
-	return m_pSeasonEpisodeRegEx;
-}

daemon/feed/FeedInfo.h

@@ -1,278 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2007-2013 Andrey Prygunkov <hugbug@users.sourceforge.net>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- * $Revision: 0 $
- * $Date$
- *
- */
-
-
-#ifndef FEEDINFO_H
-#define FEEDINFO_H
-
-#include <deque>
-#include <time.h>
-
-#include "Util.h"
-#include "DownloadInfo.h"
-
-
-class FeedInfo
-{
-public:
-	enum EStatus
-	{
-		fsUndefined,
-		fsRunning,
-		fsFinished,
-		fsFailed
-	};
-
-private:
-	int					m_iID;
-	char*				m_szName;
-	char*				m_szUrl;
-	int					m_iInterval;
-	char*				m_szFilter;
-	unsigned int		m_iFilterHash;
-	bool				m_bPauseNzb;
-	char*				m_szCategory;
-	int					m_iPriority;
-	time_t				m_tLastUpdate;
-	bool				m_bPreview;
-	EStatus				m_eStatus;
-	char*				m_szOutputFilename;
-	bool				m_bFetch;
-	bool				m_bForce;
-
-public:
-						FeedInfo(int iID, const char* szName, const char* szUrl, int iInterval,
-							const char* szFilter, bool bPauseNzb, const char* szCategory, int iPriority);
-						~FeedInfo();
-	int					GetID() { return m_iID; }
-	const char*			GetName() { return m_szName; }
-	const char*			GetUrl() { return m_szUrl; }
-	int					GetInterval() { return m_iInterval; }
-	const char*			GetFilter() { return m_szFilter; }
-	unsigned int		GetFilterHash() { return m_iFilterHash; }
-	bool				GetPauseNzb() { return m_bPauseNzb; }
-	const char*			GetCategory() { return m_szCategory; }
-	int					GetPriority() { return m_iPriority; }
-	time_t				GetLastUpdate() { return m_tLastUpdate; }
-	void				SetLastUpdate(time_t tLastUpdate) { m_tLastUpdate = tLastUpdate; }
-	bool				GetPreview() { return m_bPreview; }
-	void				SetPreview(bool bPreview) { m_bPreview = bPreview; }
-	EStatus				GetStatus() { return m_eStatus; }
-	void				SetStatus(EStatus Status) { m_eStatus = Status; }
-	const char*			GetOutputFilename() { return m_szOutputFilename; }
-	void 				SetOutputFilename(const char* szOutputFilename);
-	bool				GetFetch() { return m_bFetch; }
-	void				SetFetch(bool bFetch) { m_bFetch = bFetch; }
-	bool				GetForce() { return m_bForce; }
-	void				SetForce(bool bForce) { m_bForce = bForce; }
-};
-
-typedef std::deque<FeedInfo*> Feeds;
-
-class SharedFeedData
-{
-private:
-	RegEx*				m_pSeasonEpisodeRegEx;
-
-public:
-						SharedFeedData();
-						~SharedFeedData();
-	RegEx*				GetSeasonEpisodeRegEx();
-};
-
-class FeedItemInfo
-{
-public:
-	enum EStatus
-	{
-		isUnknown,
-		isBacklog,
-		isFetched,
-		isNew
-	};
-
-	enum EMatchStatus
-	{
-		msIgnored,
-		msAccepted,
-		msRejected
-	};
-
-	class Attr
-	{
-	private:
-		char*			m_szName;
-		char*			m_szValue;
-	public:
-						Attr(const char* szName, const char* szValue);
-						~Attr();
-		const char*		GetName() { return m_szName; }
-		const char*		GetValue() { return m_szValue; }
-	};
-	
-	typedef std::deque<Attr*>  AttributesBase;
-
-	class Attributes: public AttributesBase
-	{
-	public:
-						~Attributes();
-		void			Add(const char* szName, const char* szValue);
-		Attr*			Find(const char* szName);
-	};
-
-private:
-	char*				m_szTitle;
-	char*				m_szFilename;
-	char*				m_szUrl;
-	time_t				m_tTime;
-	long long			m_lSize;
-	char*				m_szCategory;
-	int					m_iImdbId;
-	int					m_iRageId;
-	char*				m_szDescription;
-	char*				m_szSeason;
-	char*				m_szEpisode;
-	int					m_iSeasonNum;
-	int					m_iEpisodeNum;
-	bool				m_bSeasonEpisodeParsed;
-	char*				m_szAddCategory;
-	bool				m_bPauseNzb;
-	int					m_iPriority;
-	EStatus				m_eStatus;
-	EMatchStatus		m_eMatchStatus;
-	int					m_iMatchRule;
-	char*				m_szDupeKey;
-	int					m_iDupeScore;
-	EDupeMode			m_eDupeMode;
-	SharedFeedData*		m_pSharedFeedData;
-	Attributes			m_Attributes;
-
-	int					ParsePrefixedInt(const char *szValue);
-	void				ParseSeasonEpisode();
-
-public:
-						FeedItemInfo();
-						~FeedItemInfo();
-	void				SetSharedFeedData(SharedFeedData* pSharedFeedData) { m_pSharedFeedData = pSharedFeedData; }
-	const char*			GetTitle() { return m_szTitle; }
-	void				SetTitle(const char* szTitle);
-	const char*			GetFilename() { return m_szFilename; }
-	void				SetFilename(const char* szFilename);
-	const char*			GetUrl() { return m_szUrl; }
-	void				SetUrl(const char* szUrl);
-	long long			GetSize() { return m_lSize; }
-	void				SetSize(long long lSize) { m_lSize = lSize; }
-	const char*			GetCategory() { return m_szCategory; }
-	void				SetCategory(const char* szCategory);
-	int					GetImdbId() { return m_iImdbId; }
-	void				SetImdbId(int iImdbId) { m_iImdbId = iImdbId; }
-	int					GetRageId() { return m_iRageId; }
-	void				SetRageId(int iRageId) { m_iRageId = iRageId; }
-	const char*			GetDescription() { return m_szDescription; }
-	void				SetDescription(const char* szDescription);
-	const char*			GetSeason() { return m_szSeason; }
-	void				SetSeason(const char* szSeason);
-	const char*			GetEpisode() { return m_szEpisode; }
-	void				SetEpisode(const char* szEpisode);
-	int					GetSeasonNum();
-	int					GetEpisodeNum();
-	const char*			GetAddCategory() { return m_szAddCategory; }
-	void				SetAddCategory(const char* szAddCategory);
-	bool				GetPauseNzb() { return m_bPauseNzb; }
-	void				SetPauseNzb(bool bPauseNzb) { m_bPauseNzb = bPauseNzb; }
-	int					GetPriority() { return m_iPriority; }
-	void				SetPriority(int iPriority) { m_iPriority = iPriority; }
-	time_t				GetTime() { return m_tTime; }
-	void				SetTime(time_t tTime) { m_tTime = tTime; }
-	EStatus				GetStatus() { return m_eStatus; }
-	void				SetStatus(EStatus eStatus) { m_eStatus = eStatus; }
-	EMatchStatus		GetMatchStatus() { return m_eMatchStatus; }
-	void				SetMatchStatus(EMatchStatus eMatchStatus) { m_eMatchStatus = eMatchStatus; }
-	int					GetMatchRule() { return m_iMatchRule; }
-	void				SetMatchRule(int iMatchRule) { m_iMatchRule = iMatchRule; }
-	const char*			GetDupeKey() { return m_szDupeKey; }
-	void				SetDupeKey(const char* szDupeKey);
-	void				AppendDupeKey(const char* szExtraDupeKey);
-	void				BuildDupeKey(const char* szRageId, const char* szSeries);
-	int					GetDupeScore() { return m_iDupeScore; }
-	void				SetDupeScore(int iDupeScore) { m_iDupeScore = iDupeScore; }
-	EDupeMode			GetDupeMode() { return m_eDupeMode; }
-	void				SetDupeMode(EDupeMode eDupeMode) { m_eDupeMode = eDupeMode; }
-	Attributes*			GetAttributes() { return &m_Attributes; }
-};
-
-typedef std::deque<FeedItemInfo*>	FeedItemInfosBase;
-
-class FeedItemInfos : public FeedItemInfosBase
-{
-private:
-	int					m_iRefCount;
-	SharedFeedData		m_SharedFeedData;
-
-public:
-						FeedItemInfos();
-						~FeedItemInfos();
-	void				Retain();
-	void				Release();
-	void				Add(FeedItemInfo* pFeedItemInfo);
-};
-
-class FeedHistoryInfo
-{
-public:
-	enum EStatus
-	{
-		hsUnknown,
-		hsBacklog,
-		hsFetched
-	};
-
-private:
-	char*				m_szUrl;
-	EStatus				m_eStatus;
-	time_t				m_tLastSeen;
-
-public:
-						FeedHistoryInfo(const char* szUrl, EStatus eStatus, time_t tLastSeen);
-						~FeedHistoryInfo();
-	const char*			GetUrl() { return m_szUrl; }
-	EStatus				GetStatus() { return m_eStatus; }
-	void				SetStatus(EStatus Status) { m_eStatus = Status; }
-	time_t				GetLastSeen() { return m_tLastSeen; }
-	void				SetLastSeen(time_t tLastSeen) { m_tLastSeen = tLastSeen; }
-};
-
-typedef std::deque<FeedHistoryInfo*> FeedHistoryBase;
-
-class FeedHistory : public FeedHistoryBase
-{
-public:
-						~FeedHistory();
-	void				Clear();
-	void				Add(const char* szUrl, FeedHistoryInfo::EStatus eStatus, time_t tLastSeen);
-	void				Remove(const char* szUrl);
-	FeedHistoryInfo*	Find(const char* szUrl);
-};
-
-#endif

daemon/frontend/Frontend.cpp

@@ -1,388 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
- *  Copyright (C) 2007-2014 Andrey Prygunkov <hugbug@users.sourceforge.net>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- * $Revision$
- * $Date$
- *
- */
-
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#ifdef WIN32
-#include "win32.h"
-#endif
-
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#ifndef WIN32
-#include <unistd.h>
-#include <arpa/inet.h>
-#include <netinet/in.h>
-#endif
-
-#include "nzbget.h"
-#include "Options.h"
-#include "Frontend.h"
-#include "Log.h"
-#include "Connection.h"
-#include "MessageBase.h"
-#include "RemoteClient.h"
-#include "Util.h"
-#include "StatMeter.h"
-
-extern Options* g_pOptions;
-extern StatMeter* g_pStatMeter;
-
-Frontend::Frontend()
-{
-	debug("Creating Frontend");
-
-	m_iNeededLogFirstID = 0;
-	m_iNeededLogEntries = 0;
-	m_bSummary = false;
-	m_bFileList = false;
-	m_iCurrentDownloadSpeed = 0;
-	m_lRemainingSize = 0;
-	m_bPauseDownload = false;
-	m_iDownloadLimit = 0;
-	m_iThreadCount = 0;
-	m_iPostJobCount = 0;
-	m_iUpTimeSec = 0;
-	m_iDnTimeSec = 0;
-	m_iAllBytes = 0;
-	m_bStandBy = 0;
-	m_iUpdateInterval = g_pOptions->GetUpdateInterval();
-}
-
-bool Frontend::PrepareData()
-{
-	if (IsRemoteMode())
-	{
-		if (IsStopped())
-		{
-			return false;
-		}
-		if (!RequestMessages() || ((m_bSummary || m_bFileList) && !RequestFileList()))
-		{
-			printf("\nUnable to send request to nzbget-server at %s (port %i)    \n", g_pOptions->GetControlIP(), g_pOptions->GetControlPort());
-			Stop();
-			return false;
-		}
-	}
-	else
-	{
-		if (m_bSummary)
-		{
-			m_iCurrentDownloadSpeed = g_pStatMeter->CalcCurrentDownloadSpeed();
-			m_bPauseDownload = g_pOptions->GetPauseDownload();
-			m_iDownloadLimit = g_pOptions->GetDownloadRate();
-			m_iThreadCount = Thread::GetThreadCount();
-			g_pStatMeter->CalcTotalStat(&m_iUpTimeSec, &m_iDnTimeSec, &m_iAllBytes, &m_bStandBy);
-
-			DownloadQueue *pDownloadQueue = DownloadQueue::Lock();
-			m_iPostJobCount = 0;
-			for (NZBList::iterator it = pDownloadQueue->GetQueue()->begin(); it != pDownloadQueue->GetQueue()->end(); it++)
-			{
-				NZBInfo* pNZBInfo = *it;
-				m_iPostJobCount += pNZBInfo->GetPostInfo() ? 1 : 0;
-			}
-			pDownloadQueue->CalcRemainingSize(&m_lRemainingSize, NULL);
-			DownloadQueue::Unlock();
-
-		}
-	}
-	return true;
-}
-
-void Frontend::FreeData()
-{
-	if (IsRemoteMode())
-	{
-		for (Log::Messages::iterator it = m_RemoteMessages.begin(); it != m_RemoteMessages.end(); it++)
-		{
-			delete *it;
-		}
-		m_RemoteMessages.clear();
-
-		DownloadQueue* pDownloadQueue = DownloadQueue::Lock();
-		pDownloadQueue->GetQueue()->Clear();
-		DownloadQueue::Unlock();
-	}
-}
-
-Log::Messages* Frontend::LockMessages()
-{
-	if (IsRemoteMode())
-	{
-		return &m_RemoteMessages;
-	}
-	else
-	{
-		return g_pLog->LockMessages();
-	}
-}
-
-void Frontend::UnlockMessages()
-{
-	if (!IsRemoteMode())
-	{
-		g_pLog->UnlockMessages();
-	}
-}
-
-DownloadQueue* Frontend::LockQueue()
-{
-	return DownloadQueue::Lock();
-}
-
-void Frontend::UnlockQueue()
-{
-	DownloadQueue::Unlock();
-}
-
-bool Frontend::IsRemoteMode()
-{
-	return g_pOptions->GetRemoteClientMode();
-}
-
-void Frontend::ServerPauseUnpause(bool bPause)
-{
-	if (IsRemoteMode())
-	{
-		RequestPauseUnpause(bPause);
-	}
-	else
-	{
-		g_pOptions->SetResumeTime(0);
-		g_pOptions->SetPauseDownload(bPause);
-	}
-}
-
-void Frontend::ServerSetDownloadRate(int iRate)
-{
-	if (IsRemoteMode())
-	{
-		RequestSetDownloadRate(iRate);
-	}
-	else
-	{
-		g_pOptions->SetDownloadRate(iRate);
-	}
-}
-
-bool Frontend::ServerEditQueue(DownloadQueue::EEditAction eAction, int iOffset, int iID)
-{
-	if (IsRemoteMode())
-	{
-		return RequestEditQueue(eAction, iOffset, iID);
-	}
-	else
-	{
-		DownloadQueue* pDownloadQueue = LockQueue();
-		bool bOK = pDownloadQueue->EditEntry(iID, eAction, iOffset, NULL);
-		UnlockQueue();
-		return bOK;
-	}
-	return false;
-}
-
-void Frontend::InitMessageBase(SNZBRequestBase* pMessageBase, int iRequest, int iSize)
-{
-	pMessageBase->m_iSignature	= htonl(NZBMESSAGE_SIGNATURE);
-	pMessageBase->m_iType = htonl(iRequest);
-	pMessageBase->m_iStructSize = htonl(iSize);
-
-	strncpy(pMessageBase->m_szUsername, g_pOptions->GetControlUsername(), NZBREQUESTPASSWORDSIZE - 1);
-	pMessageBase->m_szUsername[NZBREQUESTPASSWORDSIZE - 1] = '\0';
-
-	strncpy(pMessageBase->m_szPassword, g_pOptions->GetControlPassword(), NZBREQUESTPASSWORDSIZE);
-	pMessageBase->m_szPassword[NZBREQUESTPASSWORDSIZE - 1] = '\0';
-}
-
-bool Frontend::RequestMessages()
-{
-	Connection connection(g_pOptions->GetControlIP(), g_pOptions->GetControlPort(), false);
-
-	bool OK = connection.Connect();
-	if (!OK)
-	{
-		return false;
-	}
-
-	SNZBLogRequest LogRequest;
-	InitMessageBase(&LogRequest.m_MessageBase, eRemoteRequestLog, sizeof(LogRequest));
-	LogRequest.m_iLines = htonl(m_iNeededLogEntries);
-	if (m_iNeededLogEntries == 0)
-	{
-		LogRequest.m_iIDFrom = htonl(m_iNeededLogFirstID > 0 ? m_iNeededLogFirstID : 1);
-	}
-	else
-	{
-		LogRequest.m_iIDFrom = 0;
-	}
-
-	if (!connection.Send((char*)(&LogRequest), sizeof(LogRequest)))
-	{
-		return false;
-	}
-
-	// Now listen for the returned log
-	SNZBLogResponse LogResponse;
-	bool bRead = connection.Recv((char*) &LogResponse, sizeof(LogResponse));
-	if (!bRead || 
-		(int)ntohl(LogResponse.m_MessageBase.m_iSignature) != (int)NZBMESSAGE_SIGNATURE ||
-		ntohl(LogResponse.m_MessageBase.m_iStructSize) != sizeof(LogResponse))
-	{
-		return false;
-	}
-
-	char* pBuf = NULL;
-	if (ntohl(LogResponse.m_iTrailingDataLength) > 0)
-	{
-		pBuf = (char*)malloc(ntohl(LogResponse.m_iTrailingDataLength));
-		if (!connection.Recv(pBuf, ntohl(LogResponse.m_iTrailingDataLength)))
-		{
-			free(pBuf);
-			return false;
-		}
-	}
-
-	connection.Disconnect();
-
-	if (ntohl(LogResponse.m_iTrailingDataLength) > 0)
-	{
-		char* pBufPtr = (char*)pBuf;
-		for (unsigned int i = 0; i < ntohl(LogResponse.m_iNrTrailingEntries); i++)
-		{
-			SNZBLogResponseEntry* pLogAnswer = (SNZBLogResponseEntry*) pBufPtr;
-
-			char* szText = pBufPtr + sizeof(SNZBLogResponseEntry);
-
-			Message* pMessage = new Message(ntohl(pLogAnswer->m_iID), (Message::EKind)ntohl(pLogAnswer->m_iKind), ntohl(pLogAnswer->m_tTime), szText);
-			m_RemoteMessages.push_back(pMessage);
-
-			pBufPtr += sizeof(SNZBLogResponseEntry) + ntohl(pLogAnswer->m_iTextLen);
-		}
-
-		free(pBuf);
-	}
-
-	return true;
-}
-
-bool Frontend::RequestFileList()
-{
-	Connection connection(g_pOptions->GetControlIP(), g_pOptions->GetControlPort(), false);
-
-	bool OK = connection.Connect();
-	if (!OK)
-	{
-		return false;
-	}
-
-	SNZBListRequest ListRequest;
-	InitMessageBase(&ListRequest.m_MessageBase, eRemoteRequestList, sizeof(ListRequest));
-	ListRequest.m_bFileList = htonl(m_bFileList);
-	ListRequest.m_bServerState = htonl(m_bSummary);
-
-	if (!connection.Send((char*)(&ListRequest), sizeof(ListRequest)))
-	{
-		return false;
-	}
-
-	// Now listen for the returned list
-	SNZBListResponse ListResponse;
-	bool bRead = connection.Recv((char*) &ListResponse, sizeof(ListResponse));
-	if (!bRead || 
-		(int)ntohl(ListResponse.m_MessageBase.m_iSignature) != (int)NZBMESSAGE_SIGNATURE ||
-		ntohl(ListResponse.m_MessageBase.m_iStructSize) != sizeof(ListResponse))
-	{
-		return false;
-	}
-
-	char* pBuf = NULL;
-	if (ntohl(ListResponse.m_iTrailingDataLength) > 0)
-	{
-		pBuf = (char*)malloc(ntohl(ListResponse.m_iTrailingDataLength));
-		if (!connection.Recv(pBuf, ntohl(ListResponse.m_iTrailingDataLength)))
-		{
-			free(pBuf);
-			return false;
-		}
-	}
-
-	connection.Disconnect();
-
-	if (m_bSummary)
-	{
-		m_bPauseDownload = ntohl(ListResponse.m_bDownloadPaused);
-		m_lRemainingSize = Util::JoinInt64(ntohl(ListResponse.m_iRemainingSizeHi), ntohl(ListResponse.m_iRemainingSizeLo));
-		m_iCurrentDownloadSpeed = ntohl(ListResponse.m_iDownloadRate);
-		m_iDownloadLimit = ntohl(ListResponse.m_iDownloadLimit);
-		m_iThreadCount = ntohl(ListResponse.m_iThreadCount);
-		m_iPostJobCount = ntohl(ListResponse.m_iPostJobCount);
-		m_iUpTimeSec = ntohl(ListResponse.m_iUpTimeSec);
-		m_iDnTimeSec = ntohl(ListResponse.m_iDownloadTimeSec);
-		m_bStandBy = ntohl(ListResponse.m_bDownloadStandBy);
-		m_iAllBytes = Util::JoinInt64(ntohl(ListResponse.m_iDownloadedBytesHi), ntohl(ListResponse.m_iDownloadedBytesLo));
-	}
-
-	if (m_bFileList && ntohl(ListResponse.m_iTrailingDataLength) > 0)
-	{
-		RemoteClient client;
-		client.SetVerbose(false);
-		
-		DownloadQueue* pDownloadQueue = LockQueue();
-		client.BuildFileList(&ListResponse, pBuf, pDownloadQueue);
-		UnlockQueue();
-	}
-
-	if (pBuf)
-	{
-		free(pBuf);
-	}
-
-	return true;
-}
-
-bool Frontend::RequestPauseUnpause(bool bPause)
-{
-	RemoteClient client;
-	client.SetVerbose(false);
-	return client.RequestServerPauseUnpause(bPause, eRemotePauseUnpauseActionDownload);
-}
-
-bool Frontend::RequestSetDownloadRate(int iRate)
-{
-	RemoteClient client;
-	client.SetVerbose(false);
-	return client.RequestServerSetDownloadRate(iRate);
-}
-
-bool Frontend::RequestEditQueue(DownloadQueue::EEditAction eAction, int iOffset, int iID)
-{
-	RemoteClient client;
-	client.SetVerbose(false);
-	return client.RequestServerEditQueue(eAction, iOffset, NULL, &iID, 1, NULL, eRemoteMatchModeID);
-}

daemon/main/Maintenance.cpp

@@ -1,325 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2013-2014 Andrey Prygunkov <hugbug@users.sourceforge.net>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- * $Revision$
- * $Date$
- *
- */
-
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#ifdef WIN32
-#include "win32.h"
-#endif
-
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#include <ctype.h>
-#ifndef WIN32
-#include <unistd.h>
-#endif
-#include <errno.h>
-
-#include "nzbget.h"
-#include "Log.h"
-#include "Util.h"
-#include "Maintenance.h"
-#include "Options.h"
-
-extern Options* g_pOptions;
-extern Maintenance* g_pMaintenance;
-
-Maintenance::Maintenance()
-{
-	m_iIDMessageGen = 0;
-	m_UpdateScriptController = NULL;
-	m_szUpdateScript = NULL;
-}
-
-Maintenance::~Maintenance()
-{
-	m_mutexController.Lock();
-	if (m_UpdateScriptController)
-	{
-		m_UpdateScriptController->Detach();
-		m_mutexController.Unlock();
-		while (m_UpdateScriptController)
-		{
-			usleep(20*1000);
-		}
-	}
-
-	ClearMessages();
-
-	free(m_szUpdateScript);
-}
-
-void Maintenance::ResetUpdateController()
-{
-	m_mutexController.Lock();
-	m_UpdateScriptController = NULL;
-	m_mutexController.Unlock();
-}
-
-void Maintenance::ClearMessages()
-{
-	for (Log::Messages::iterator it = m_Messages.begin(); it != m_Messages.end(); it++)
-	{
-		delete *it;
-	}
-	m_Messages.clear();
-}
-
-Log::Messages* Maintenance::LockMessages()
-{
-	m_mutexLog.Lock();
-	return &m_Messages;
-}
-
-void Maintenance::UnlockMessages()
-{
-	m_mutexLog.Unlock();
-}
-
-void Maintenance::AppendMessage(Message::EKind eKind, time_t tTime, const char * szText)
-{
-	if (tTime == 0)
-	{
-		tTime = time(NULL);
-	}
-
-	m_mutexLog.Lock();
-	Message* pMessage = new Message(++m_iIDMessageGen, eKind, tTime, szText);
-	m_Messages.push_back(pMessage);
-	m_mutexLog.Unlock();
-}
-
-bool Maintenance::StartUpdate(EBranch eBranch)
-{
-	m_mutexController.Lock();
-	bool bAlreadyUpdating = m_UpdateScriptController != NULL;
-	m_mutexController.Unlock();
-
-	if (bAlreadyUpdating)
-	{
-		error("Could not start update-script: update-script is already running");
-		return false;
-	}
-
-	if (m_szUpdateScript)
-	{
-		free(m_szUpdateScript);
-		m_szUpdateScript = NULL;
-	}
-
-	if (!ReadPackageInfoStr("install-script", &m_szUpdateScript))
-	{
-		return false;
-	}
-
-	ClearMessages();
-
-	m_UpdateScriptController = new UpdateScriptController();
-	m_UpdateScriptController->SetScript(m_szUpdateScript);
-	m_UpdateScriptController->SetBranch(eBranch);
-	m_UpdateScriptController->SetAutoDestroy(true);
-
-	m_UpdateScriptController->Start();
-
-	return true;
-}
-
-bool Maintenance::CheckUpdates(char** pUpdateInfo)
-{
-	char* szUpdateInfoScript;
-	if (!ReadPackageInfoStr("update-info-script", &szUpdateInfoScript))
-	{
-		return false;
-	}
-
-	*pUpdateInfo = NULL;
-	UpdateInfoScriptController::ExecuteScript(szUpdateInfoScript, pUpdateInfo);
-
-	free(szUpdateInfoScript);
-
-	return *pUpdateInfo;
-}
-
-bool Maintenance::ReadPackageInfoStr(const char* szKey, char** pValue)
-{
-	char szFileName[1024];
-	snprintf(szFileName, 1024, "%s%cpackage-info.json", g_pOptions->GetWebDir(), PATH_SEPARATOR);
-	szFileName[1024-1] = '\0';
-
-	char* szPackageInfo;
-	int iPackageInfoLen;
-	if (!Util::LoadFileIntoBuffer(szFileName, &szPackageInfo, &iPackageInfoLen))
-	{
-		error("Could not load file %s", szFileName);
-		return false;
-	}
-
-	char szKeyStr[100];
-	snprintf(szKeyStr, 100, "\"%s\"", szKey);
-	szKeyStr[100-1] = '\0';
-
-	char* p = strstr(szPackageInfo, szKeyStr);
-	if (!p)
-	{
-		error("Could not parse file %s", szFileName);
-		free(szPackageInfo);
-		return false;
-	}
-
-	p = strchr(p + strlen(szKeyStr), '"');
-	if (!p)
-	{
-		error("Could not parse file %s", szFileName);
-		free(szPackageInfo);
-		return false;
-	}
-
-	p++;
-	char* pend = strchr(p, '"');
-	if (!pend)
-	{
-		error("Could not parse file %s", szFileName);
-		free(szPackageInfo);
-		return false;
-	}
-
-	int iLen = pend - p;
-	if (iLen >= sizeof(szFileName))
-	{
-		error("Could not parse file %s", szFileName);
-		free(szPackageInfo);
-		return false;
-	}
-
-	*pValue = (char*)malloc(iLen+1);
-	strncpy(*pValue, p, iLen);
-	(*pValue)[iLen] = '\0';
-
-	WebUtil::JsonDecode(*pValue);
-
-	free(szPackageInfo);
-
-	return true;
-}
-
-void UpdateScriptController::Run()
-{
-	m_iPrefixLen = 0;
-	PrintMessage(Message::mkInfo, "Executing update-script %s", GetScript());
-
-	char szInfoName[1024];
-	snprintf(szInfoName, 1024, "update-script %s", Util::BaseFileName(GetScript()));
-	szInfoName[1024-1] = '\0';
-	SetInfoName(szInfoName);
-
-    const char* szBranchName[] = { "STABLE", "TESTING", "DEVEL" };
-	SetEnvVar("NZBUP_BRANCH", szBranchName[m_eBranch]);
-
-	char szProcessID[20];
-#ifdef WIN32
-	int pid = (int)GetCurrentProcessId();
-#else
-	int pid = (int)getppid();
-#endif
-	snprintf(szProcessID, 20, "%i", pid);
-	szProcessID[20-1] = '\0';
-	SetEnvVar("NZBUP_PROCESSID", szProcessID);
-
-	char szLogPrefix[100];
-	strncpy(szLogPrefix, Util::BaseFileName(GetScript()), 100);
-	szLogPrefix[100-1] = '\0';
-	if (char* ext = strrchr(szLogPrefix, '.')) *ext = '\0'; // strip file extension
-	SetLogPrefix(szLogPrefix);
-	m_iPrefixLen = strlen(szLogPrefix) + 2; // 2 = strlen(": ");
-
-	Execute();
-
-	g_pMaintenance->ResetUpdateController();
-}
-
-void UpdateScriptController::AddMessage(Message::EKind eKind, const char* szText)
-{
-	szText = szText + m_iPrefixLen;
-
-	g_pMaintenance->AppendMessage(eKind, time(NULL), szText);
-	ScriptController::AddMessage(eKind, szText);
-}
-
-void UpdateInfoScriptController::ExecuteScript(const char* szScript, char** pUpdateInfo)
-{
-	detail("Executing update-info-script %s", Util::BaseFileName(szScript));
-
-	UpdateInfoScriptController* pScriptController = new UpdateInfoScriptController();
-	pScriptController->SetScript(szScript);
-
-	char szInfoName[1024];
-	snprintf(szInfoName, 1024, "update-info-script %s", Util::BaseFileName(szScript));
-	szInfoName[1024-1] = '\0';
-	pScriptController->SetInfoName(szInfoName);
-
-	char szLogPrefix[1024];
-	strncpy(szLogPrefix, Util::BaseFileName(szScript), 1024);
-	szLogPrefix[1024-1] = '\0';
-	if (char* ext = strrchr(szLogPrefix, '.')) *ext = '\0'; // strip file extension
-	pScriptController->SetLogPrefix(szLogPrefix);
-	pScriptController->m_iPrefixLen = strlen(szLogPrefix) + 2; // 2 = strlen(": ");
-
-	pScriptController->Execute();
-
-	if (pScriptController->m_UpdateInfo.GetBuffer())
-	{
-		int iLen = strlen(pScriptController->m_UpdateInfo.GetBuffer());
-		*pUpdateInfo = (char*)malloc(iLen + 1);
-		strncpy(*pUpdateInfo, pScriptController->m_UpdateInfo.GetBuffer(), iLen);
-		(*pUpdateInfo)[iLen] = '\0';
-	}
-
-	delete pScriptController;
-}
-
-void UpdateInfoScriptController::AddMessage(Message::EKind eKind, const char* szText)
-{
-	szText = szText + m_iPrefixLen;
-
-	if (!strncmp(szText, "[NZB] ", 6))
-	{
-		debug("Command %s detected", szText + 6);
-		if (!strncmp(szText + 6, "[UPDATEINFO]", 12))
-		{
-			m_UpdateInfo.Append(szText + 6 + 12);
-		}
-		else
-		{
-			error("Invalid command \"%s\" received from %s", szText, GetInfoName());
-		}
-	}
-	else
-	{
-		ScriptController::AddMessage(eKind, szText);
-	}
-}

daemon/main/Maintenance.h

@@ -1,93 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2013-2014 Andrey Prygunkov <hugbug@users.sourceforge.net>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- * $Revision$
- * $Date$
- *
- */
-
-#ifndef MAINTENANCE_H
-#define MAINTENANCE_H
-
-#include "Thread.h"
-#include "Script.h"
-#include "Log.h"
-#include "Util.h"
-
-class UpdateScriptController;
-
-class Maintenance
-{
-private:
-	Log::Messages		m_Messages;
-	Mutex				m_mutexLog;
-	Mutex				m_mutexController;
-	int					m_iIDMessageGen;
-	UpdateScriptController*	m_UpdateScriptController;
-	char*				m_szUpdateScript;
-
-	bool				ReadPackageInfoStr(const char* szKey, char** pValue);
-
-public:
-	enum EBranch
-	{
-		brStable,
-		brTesting,
-		brDevel
-	};
-
-						Maintenance();
-						~Maintenance();
-	void				ClearMessages();
-	void				AppendMessage(Message::EKind eKind, time_t tTime, const char* szText);
-	Log::Messages*		LockMessages();
-	void				UnlockMessages();
-	bool				StartUpdate(EBranch eBranch);
-	void				ResetUpdateController();
-	bool				CheckUpdates(char** pUpdateInfo);
-};
-
-class UpdateScriptController : public Thread, public ScriptController
-{
-private:
-	Maintenance::EBranch	m_eBranch;
-	int						m_iPrefixLen;
-
-protected:
-	virtual void		AddMessage(Message::EKind eKind, const char* szText);
-
-public:
-	virtual void		Run();
-	void				SetBranch(Maintenance::EBranch eBranch) { m_eBranch = eBranch; }
-};
-
-class UpdateInfoScriptController : public ScriptController
-{
-private:
-	int					m_iPrefixLen;
-	StringBuilder		m_UpdateInfo;
-
-protected:
-	virtual void		AddMessage(Message::EKind eKind, const char* szText);
-
-public:
-	static void			ExecuteScript(const char* szScript, char** pUpdateInfo);
-};
-
-#endif

daemon/main/Options.h

@@ -1,531 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
- *  Copyright (C) 2007-2014 Andrey Prygunkov <hugbug@users.sourceforge.net>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- * $Revision$
- * $Date$
- *
- */
-
-
-#ifndef OPTIONS_H
-#define OPTIONS_H
-
-#include <vector>
-#include <list>
-#include <time.h>
-
-#include "Thread.h"
-#include "Util.h"
-
-class Options
-{
-public:
-	enum EClientOperation
-	{
-		opClientNoOperation,
-		opClientRequestDownload,
-		opClientRequestListFiles,
-		opClientRequestListGroups,
-		opClientRequestListStatus,
-		opClientRequestSetRate,
-		opClientRequestDumpDebug,
-		opClientRequestEditQueue,
-		opClientRequestLog,
-		opClientRequestShutdown,
-		opClientRequestReload,
-		opClientRequestVersion,
-		opClientRequestPostQueue,
-		opClientRequestWriteLog,
-		opClientRequestScanSync,
-		opClientRequestScanAsync,
-		opClientRequestDownloadPause,
-		opClientRequestDownloadUnpause,
-		opClientRequestPostPause,
-		opClientRequestPostUnpause,
-		opClientRequestScanPause,
-		opClientRequestScanUnpause,
-		opClientRequestHistory,
-		opClientRequestDownloadUrl
-	};
-	enum EMessageTarget
-	{
-		mtNone,
-		mtScreen,
-		mtLog,
-		mtBoth
-	};
-	enum EOutputMode
-	{
-		omLoggable,
-		omColored,
-		omNCurses
-	};
-	enum EParCheck
-	{
-		pcAuto,
-		pcAlways,
-		pcForce,
-		pcManual
-	};
-	enum EParScan
-	{
-		psLimited,
-		psFull,
-		psAuto
-	};
-	enum EHealthCheck
-	{
-		hcPause,
-		hcDelete,
-		hcNone
-	};
-	enum EMatchMode
-	{
-		mmID = 1,
-		mmName,
-		mmRegEx
-	};
-
-	class OptEntry
-	{
-	private:
-		char*			m_szName;
-		char*			m_szValue;
-		char*			m_szDefValue;
-		int				m_iLineNo;
-
-		void			SetName(const char* szName);
-		void			SetValue(const char* szValue);
-		void			SetLineNo(int iLineNo) { m_iLineNo = iLineNo; }
-
-		friend class Options;
-
-	public:
-						OptEntry();
-						OptEntry(const char* szName, const char* szValue);
-						~OptEntry();
-		const char*		GetName() { return m_szName; }
-		const char*		GetValue() { return m_szValue; }
-		const char*		GetDefValue() { return m_szDefValue; }
-		int				GetLineNo() { return m_iLineNo; }
-	};
-	
-	typedef std::vector<OptEntry*>  OptEntriesBase;
-
-	class OptEntries: public OptEntriesBase
-	{
-	public:
-						~OptEntries();
-		OptEntry*		FindOption(const char* szName);
-	};
-
-	typedef std::vector<char*>  NameList;
-
-	class Category
-	{
-	private:
-		char*			m_szName;
-		char*			m_szDestDir;
-		bool			m_bUnpack;
-		char*			m_szPostScript;
-		NameList		m_Aliases;
-
-	public:
-						Category(const char* szName, const char* szDestDir, bool bUnpack, const char* szPostScript);
-						~Category();
-		const char*		GetName() { return m_szName; }
-		const char*		GetDestDir() { return m_szDestDir; }
-		bool			GetUnpack() { return m_bUnpack; }
-		const char*		GetPostScript() { return m_szPostScript; }
-		NameList*		GetAliases() { return &m_Aliases; }
-	};
-	
-	typedef std::vector<Category*>  CategoriesBase;
-
-	class Categories: public CategoriesBase
-	{
-	public:
-						~Categories();
-		Category*		FindCategory(const char* szName, bool bSearchAliases);
-	};
-
-	class Script
-	{
-	private:
-		char*			m_szName;
-		char*			m_szLocation;
-		char*			m_szDisplayName;
-		bool			m_bPostScript;
-		bool			m_bScanScript;
-		bool			m_bQueueScript;
-		bool			m_bSchedulerScript;
-
-	public:
-						Script(const char* szName, const char* szLocation);
-						~Script();
-		const char*		GetName() { return m_szName; }
-		const char*		GetLocation() { return m_szLocation; }
-		void			SetDisplayName(const char* szDisplayName);
-		const char*		GetDisplayName() { return m_szDisplayName; }
-		bool			GetPostScript() { return m_bPostScript; }
-		void			SetPostScript(bool bPostScript) { m_bPostScript = bPostScript; }
-		bool			GetScanScript() { return m_bScanScript; }
-		void			SetScanScript(bool bScanScript) { m_bScanScript = bScanScript; }
-		bool			GetQueueScript() { return m_bQueueScript; }
-		void			SetQueueScript(bool bQueueScript) { m_bQueueScript = bQueueScript; }
-		bool			GetSchedulerScript() { return m_bSchedulerScript; }
-		void			SetSchedulerScript(bool bSchedulerScript) { m_bSchedulerScript = bSchedulerScript; }
-	};
-
-	typedef std::list<Script*>  ScriptListBase;
-
-	class ScriptList: public ScriptListBase
-	{
-	public:
-						~ScriptList();
-		Script*			Find(const char* szName);	
-	};
-
-	class ConfigTemplate
-	{
-	private:
-		Script*			m_pScript;
-		char*			m_szTemplate;
-
-		friend class Options;
-
-	public:
-						ConfigTemplate(Script* pScript, const char* szTemplate);
-						~ConfigTemplate();
-		Script*			GetScript() { return m_pScript; }
-		const char*		GetTemplate() { return m_szTemplate; }
-	};
-	
-	typedef std::vector<ConfigTemplate*>  ConfigTemplatesBase;
-
-	class ConfigTemplates: public ConfigTemplatesBase
-	{
-	public:
-						~ConfigTemplates();
-	};
-
-private:
-	OptEntries			m_OptEntries;
-	bool				m_bConfigInitialized;
-	Mutex				m_mutexOptEntries;
-	Categories			m_Categories;
-
-	// Options
-	bool				m_bConfigErrors;
-	int					m_iConfigLine;
-	char*				m_szConfigFilename;
-	char*				m_szDestDir;
-	char*				m_szInterDir;
-	char*				m_szTempDir;
-	char*				m_szQueueDir;
-	char*				m_szNzbDir;
-	char*				m_szWebDir;
-	char*				m_szConfigTemplate;
-	char*				m_szScriptDir;
-	EMessageTarget		m_eInfoTarget;
-	EMessageTarget		m_eWarningTarget;
-	EMessageTarget		m_eErrorTarget;
-	EMessageTarget		m_eDebugTarget;
-	EMessageTarget		m_eDetailTarget;
-	bool				m_bDecode;
-	bool				m_bCreateBrokenLog;
-	bool				m_bResetLog;
-	int					m_iConnectionTimeout;
-	int					m_iTerminateTimeout;
-	bool				m_bAppendCategoryDir;
-	bool				m_bContinuePartial;
-	int					m_iRetries;
-	int					m_iRetryInterval;
-	bool				m_bSaveQueue;
-	bool				m_bDupeCheck;
-	char*				m_szControlIP;
-	char*				m_szControlUsername;
-	char*				m_szControlPassword;
-	int					m_iControlPort;
-	bool				m_bSecureControl;
-	int					m_iSecurePort;
-	char*				m_szSecureCert;
-	char*				m_szSecureKey;
-	char*				m_szAuthorizedIP;
-	char*				m_szLockFile;
-	char*				m_szDaemonUsername;
-	EOutputMode			m_eOutputMode;
-	bool				m_bReloadQueue;
-	int					m_iUrlConnections;
-	int					m_iLogBufferSize;
-	bool				m_bCreateLog;
-	char*				m_szLogFile;
-	EParCheck			m_eParCheck;
-	bool				m_bParRepair;
-	EParScan			m_eParScan;
-	bool				m_bParRename;
-	EHealthCheck		m_eHealthCheck;
-	char*				m_szPostScript;
-	char*				m_szScriptOrder;
-	char*				m_szScanScript;
-	char*				m_szQueueScript;
-	bool				m_bNoConfig;
-	int					m_iUMask;
-	int					m_iUpdateInterval;
-	bool				m_bCursesNZBName;
-	bool				m_bCursesTime;
-	bool				m_bCursesGroup;
-	bool				m_bCrcCheck;
-	bool				m_bDirectWrite;
-	int					m_iWriteBufferSize;
-	int					m_iNzbDirInterval;
-	int					m_iNzbDirFileAge;
-	bool				m_bParCleanupQueue;
-	int					m_iDiskSpace;
-	bool				m_bTLS;
-	bool				m_bDumpCore;
-	bool				m_bParPauseQueue;
-	bool				m_bScriptPauseQueue;
-	bool				m_bNzbCleanupDisk;
-	bool				m_bDeleteCleanupDisk;
-	int					m_iParTimeLimit;
-	int					m_iKeepHistory;
-	bool				m_bAccurateRate;
-	bool				m_bUnpack;
-	bool				m_bUnpackCleanupDisk;
-	char*				m_szUnrarCmd;
-	char*				m_szSevenZipCmd;
-	bool				m_bUnpackPauseQueue;
-	char*				m_szExtCleanupDisk;
-	char*				m_szParIgnoreExt;
-	int					m_iFeedHistory;
-	bool				m_bUrlForce;
-	int					m_iTimeCorrection;
-	int					m_iPropagationDelay;
-
-	// Parsed command-line parameters
-	bool				m_bServerMode;
-	bool				m_bDaemonMode;
-	bool				m_bRemoteClientMode;
-	int					m_iEditQueueAction;
-	int					m_iEditQueueOffset;
-	int*				m_pEditQueueIDList;
-	int					m_iEditQueueIDCount;
-	NameList			m_EditQueueNameList;
-	EMatchMode			m_EMatchMode;
-	char*				m_szEditQueueText;
-	char*				m_szArgFilename;
-	char*				m_szAddCategory;
-	int					m_iAddPriority;
-	bool				m_bAddPaused;
-	char*				m_szAddNZBFilename;
-	char*				m_szLastArg;
-	bool				m_bPrintOptions;
-	bool				m_bAddTop;
-	int					m_iSetRate;
-	int					m_iLogLines;
-	int					m_iWriteLogKind;
-	bool				m_bTestBacktrace;
-
-	// Current state
-	bool				m_bPauseDownload;
-	bool				m_bPausePostProcess;
-	bool				m_bPauseScan;
-	bool				m_bTempPauseDownload;
-	int					m_iDownloadRate;
-	EClientOperation	m_eClientOperation;
-	time_t				m_tResumeTime;
-	int					m_iLocalTimeOffset;
-
-	void				InitDefault();
-	void				InitOptFile();
-	void				InitCommandLine(int argc, char* argv[]);
-	void				InitOptions();
-	void				InitFileArg(int argc, char* argv[]);
-	void				InitServers();
-	void				InitCategories();
-	void				InitScheduler();
-	void				InitFeeds();
-	void				CheckOptions();
-	void				PrintUsage(char* com);
-	void				Dump();
-	int					ParseEnumValue(const char* OptName, int argc, const char* argn[], const int argv[]);
-	int					ParseIntValue(const char* OptName, int iBase);
-	float				ParseFloatValue(const char* OptName);
-	OptEntry*			FindOption(const char* optname);
-	const char*			GetOption(const char* optname);
-	void				SetOption(const char* optname, const char* value);
-	bool				SetOptionString(const char* option);
-	bool				SplitOptionString(const char* option, char** pOptName, char** pOptValue);
-	bool				ValidateOptionName(const char* optname, const char* optvalue);
-	void				LoadConfigFile();
-	void				CheckDir(char** dir, const char* szOptionName, bool bAllowEmpty, bool bCreate);
-	void				ParseFileIDList(int argc, char* argv[], int optind);
-	void				ParseFileNameList(int argc, char* argv[], int optind);
-	bool				ParseTime(const char** pTime, int* pHours, int* pMinutes);
-	bool				ParseWeekDays(const char* szWeekDays, int* pWeekDaysBits);
-	void				ConfigError(const char* msg, ...);
-	void				ConfigWarn(const char* msg, ...);
-	void				LocateOptionSrcPos(const char *szOptionName);
-	void				ConvertOldOption(char *szOption, int iOptionBufLen, char *szValue, int iValueBufLen);
-	static bool			CompareScripts(Script* pScript1, Script* pScript2);
-	void				LoadScriptDir(ScriptList* pScriptList, const char* szDirectory, bool bIsSubDir);
-	void				BuildScriptDisplayNames(ScriptList* pScriptList);
-
-public:
-						Options(int argc, char* argv[]);
-						~Options();
-
-	bool				LoadConfig(OptEntries* pOptEntries);
-	bool				SaveConfig(OptEntries* pOptEntries);
-	bool				LoadConfigTemplates(ConfigTemplates* pConfigTemplates);
-	void				LoadScriptList(ScriptList* pScriptList);
-
-	// Options
-	OptEntries*			LockOptEntries();
-	void				UnlockOptEntries();
-	const char*			GetConfigFilename() { return m_szConfigFilename; }
-	const char*			GetDestDir() { return m_szDestDir; }
-	const char*			GetInterDir() { return m_szInterDir; }
-	const char*			GetTempDir() { return m_szTempDir; }
-	const char*			GetQueueDir() { return m_szQueueDir; }
-	const char*			GetNzbDir() { return m_szNzbDir; }
-	const char*			GetWebDir() { return m_szWebDir; }
-	const char*			GetConfigTemplate() { return m_szConfigTemplate; }
-	const char*			GetScriptDir() { return m_szScriptDir; }
-	bool				GetCreateBrokenLog() const { return m_bCreateBrokenLog; }
-	bool				GetResetLog() const { return m_bResetLog; }
-	EMessageTarget		GetInfoTarget() const { return m_eInfoTarget; }
-	EMessageTarget		GetWarningTarget() const { return m_eWarningTarget; }
-	EMessageTarget		GetErrorTarget() const { return m_eErrorTarget; }
-	EMessageTarget		GetDebugTarget() const { return m_eDebugTarget; }
-	EMessageTarget		GetDetailTarget() const { return m_eDetailTarget; }
-	int					GetConnectionTimeout() { return m_iConnectionTimeout; }
-	int					GetTerminateTimeout() { return m_iTerminateTimeout; }
-	bool				GetDecode() { return m_bDecode; };
-	bool				GetAppendCategoryDir() { return m_bAppendCategoryDir; }
-	bool				GetContinuePartial() { return m_bContinuePartial; }
-	int					GetRetries() { return m_iRetries; }
-	int					GetRetryInterval() { return m_iRetryInterval; }
-	bool				GetSaveQueue() { return m_bSaveQueue; }
-	bool				GetDupeCheck() { return m_bDupeCheck; }
-	const char*			GetControlIP() { return m_szControlIP; }
-	const char*			GetControlUsername() { return m_szControlUsername; }
-	const char*			GetControlPassword() { return m_szControlPassword; }
-	int					GetControlPort() { return m_iControlPort; }
-	bool				GetSecureControl() { return m_bSecureControl; }
-	int					GetSecurePort() { return m_iSecurePort; }
-	const char*			GetSecureCert() { return m_szSecureCert; }
-	const char*			GetSecureKey() { return m_szSecureKey; }
-	const char*			GetAuthorizedIP() { return m_szAuthorizedIP; }
-	const char*			GetLockFile() { return m_szLockFile; }
-	const char*			GetDaemonUsername() { return m_szDaemonUsername; }
-	EOutputMode			GetOutputMode() { return m_eOutputMode; }
-	bool				GetReloadQueue() { return m_bReloadQueue; }
-	int					GetUrlConnections() { return m_iUrlConnections; }
-	int					GetLogBufferSize() { return m_iLogBufferSize; }
-	bool				GetCreateLog() { return m_bCreateLog; }
-	const char*			GetLogFile() { return m_szLogFile; }
-	EParCheck			GetParCheck() { return m_eParCheck; }
-	bool				GetParRepair() { return m_bParRepair; }
-	EParScan			GetParScan() { return m_eParScan; }
-	bool				GetParRename() { return m_bParRename; }
-	EHealthCheck		GetHealthCheck() { return m_eHealthCheck; }
-	const char*			GetScriptOrder() { return m_szScriptOrder; }
-	const char*			GetPostScript() { return m_szPostScript; }
-	const char*			GetScanScript() { return m_szScanScript; }
-	const char*			GetQueueScript() { return m_szQueueScript; }
-	int					GetUMask() { return m_iUMask; }
-	int					GetUpdateInterval() {return m_iUpdateInterval; }
-	bool				GetCursesNZBName() { return m_bCursesNZBName; }
-	bool				GetCursesTime() { return m_bCursesTime; }
-	bool				GetCursesGroup() { return m_bCursesGroup; }
-	bool				GetCrcCheck() { return m_bCrcCheck; }
-	bool				GetDirectWrite() { return m_bDirectWrite; }
-	int					GetWriteBufferSize() { return m_iWriteBufferSize; }
-	int					GetNzbDirInterval() { return m_iNzbDirInterval; }
-	int					GetNzbDirFileAge() { return m_iNzbDirFileAge; }
-	bool				GetParCleanupQueue() { return m_bParCleanupQueue; }
-	int					GetDiskSpace() { return m_iDiskSpace; }
-	bool				GetTLS() { return m_bTLS; }
-	bool				GetDumpCore() { return m_bDumpCore; }
-	bool				GetParPauseQueue() { return m_bParPauseQueue; }
-	bool				GetScriptPauseQueue() { return m_bScriptPauseQueue; }
-	bool				GetNzbCleanupDisk() { return m_bNzbCleanupDisk; }
-	bool				GetDeleteCleanupDisk() { return m_bDeleteCleanupDisk; }
-	int					GetParTimeLimit() { return m_iParTimeLimit; }
-	int					GetKeepHistory() { return m_iKeepHistory; }
-	bool				GetAccurateRate() { return m_bAccurateRate; }
-	bool				GetUnpack() { return m_bUnpack; }
-	bool				GetUnpackCleanupDisk() { return m_bUnpackCleanupDisk; }
-	const char*			GetUnrarCmd() { return m_szUnrarCmd; }
-	const char*			GetSevenZipCmd() { return m_szSevenZipCmd; }
-	bool				GetUnpackPauseQueue() { return m_bUnpackPauseQueue; }
-	const char*			GetExtCleanupDisk() { return m_szExtCleanupDisk; }
-	const char*			GetParIgnoreExt() { return m_szParIgnoreExt; }
-	int					GetFeedHistory() { return m_iFeedHistory; }
-	bool				GetUrlForce() { return m_bUrlForce; }
-	int					GetTimeCorrection() { return m_iTimeCorrection; }
-	int					GetPropagationDelay() { return m_iPropagationDelay; }
-
-	Category*			FindCategory(const char* szName, bool bSearchAliases) { return m_Categories.FindCategory(szName, bSearchAliases); }
-
-	// Parsed command-line parameters
-	bool				GetServerMode() { return m_bServerMode; }
-	bool				GetDaemonMode() { return m_bDaemonMode; }
-	bool				GetRemoteClientMode() { return m_bRemoteClientMode; }
-	EClientOperation	GetClientOperation() { return m_eClientOperation; }
-	int					GetEditQueueAction() { return m_iEditQueueAction; }
-	int					GetEditQueueOffset() { return m_iEditQueueOffset; }
-	int*				GetEditQueueIDList() { return m_pEditQueueIDList; }
-	int					GetEditQueueIDCount() { return m_iEditQueueIDCount; }
-	NameList*			GetEditQueueNameList() { return &m_EditQueueNameList; }
-	EMatchMode			GetMatchMode() { return m_EMatchMode; }
-	const char*			GetEditQueueText() { return m_szEditQueueText; }
-	const char*			GetArgFilename() { return m_szArgFilename; }
-	const char*			GetAddCategory() { return m_szAddCategory; }
-	bool				GetAddPaused() { return m_bAddPaused; }
-	const char*			GetLastArg() { return m_szLastArg; }
-	int					GetAddPriority() { return m_iAddPriority; }
-	char*				GetAddNZBFilename() { return m_szAddNZBFilename; }
-	bool				GetAddTop() { return m_bAddTop; }
-	int					GetSetRate() { return m_iSetRate; }
-	int					GetLogLines() { return m_iLogLines; }
-	int					GetWriteLogKind() { return m_iWriteLogKind; }
-	bool				GetTestBacktrace() { return m_bTestBacktrace; }
-
-	// Current state
-	void				SetPauseDownload(bool bPauseDownload) { m_bPauseDownload = bPauseDownload; }
-	bool				GetPauseDownload() const { return m_bPauseDownload; }
-	void				SetPausePostProcess(bool bPausePostProcess) { m_bPausePostProcess = bPausePostProcess; }
-	bool				GetPausePostProcess() const { return m_bPausePostProcess; }
-	void				SetPauseScan(bool bPauseScan) { m_bPauseScan = bPauseScan; }
-	bool				GetPauseScan() const { return m_bPauseScan; }
-	void				SetTempPauseDownload(bool bTempPauseDownload) { m_bTempPauseDownload = bTempPauseDownload; }
-	bool				GetTempPauseDownload() const { return m_bTempPauseDownload; }
-	void				SetDownloadRate(int iRate) { m_iDownloadRate = iRate; }
-	int					GetDownloadRate() const { return m_iDownloadRate; }
-	void				SetResumeTime(time_t tResumeTime) { m_tResumeTime = tResumeTime; }
-	time_t				GetResumeTime() const { return m_tResumeTime; }
-	void				SetLocalTimeOffset(int iLocalTimeOffset) { m_iLocalTimeOffset = iLocalTimeOffset; }
-	int					GetLocalTimeOffset() { return m_iLocalTimeOffset; }
-};
-
-#endif

daemon/main/Scheduler.cpp

@@ -1,477 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2008-2014 Andrey Prygunkov <hugbug@users.sourceforge.net>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- * $Revision$
- * $Date$
- *
- */
-
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#ifdef WIN32
-#include "win32.h"
-#else
-#include <unistd.h>
-#endif
-
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-
-#include "nzbget.h"
-#include "Scheduler.h"
-#include "Options.h"
-#include "Log.h"
-#include "NewsServer.h"
-#include "ServerPool.h"
-#include "FeedInfo.h"
-#include "FeedCoordinator.h"
-#include "QueueScript.h"
-
-extern Options* g_pOptions;
-extern ServerPool* g_pServerPool;
-extern FeedCoordinator* g_pFeedCoordinator;
-
-class SchedulerScriptController : public Thread, public NZBScriptController
-{
-private:
-	char*				m_szScript;
-	bool				m_bExternalProcess;
-	int					m_iTaskID;
-
-	void				PrepareParams(const char* szScriptName);
-	void				ExecuteExternalProcess();
-
-protected:
-	virtual void		ExecuteScript(Options::Script* pScript);
-
-public:
-	virtual				~SchedulerScriptController();
-	virtual void		Run();
-	static void			StartScript(const char* szParam, bool bExternalProcess, int iTaskID);
-};
-
-Scheduler::Task::Task(int iID, int iHours, int iMinutes, int iWeekDaysBits, ECommand eCommand, const char* szParam)
-{
-	m_iID = iID;
-	m_iHours = iHours;
-	m_iMinutes = iMinutes;
-	m_iWeekDaysBits = iWeekDaysBits;
-	m_eCommand = eCommand;
-	m_szParam = szParam ? strdup(szParam) : NULL;
-	m_tLastExecuted = 0;
-}
-
-Scheduler::Task::~Task()
-{
-	free(m_szParam);
-}
-
-
-Scheduler::Scheduler()
-{
-	debug("Creating Scheduler");
-
-	m_tLastCheck = 0;
-	m_TaskList.clear();
-}
-
-Scheduler::~Scheduler()
-{
-	debug("Destroying Scheduler");
-	
-	for (TaskList::iterator it = m_TaskList.begin(); it != m_TaskList.end(); it++)
-	{
-		delete *it;
-	}
-}
-
-void Scheduler::AddTask(Task* pTask)
-{
-	m_mutexTaskList.Lock();
-	m_TaskList.push_back(pTask);
-	m_mutexTaskList.Unlock();
-}
-
-bool Scheduler::CompareTasks(Scheduler::Task* pTask1, Scheduler::Task* pTask2)
-{
-	return (pTask1->m_iHours < pTask2->m_iHours) || 
-		((pTask1->m_iHours == pTask2->m_iHours) && (pTask1->m_iMinutes < pTask2->m_iMinutes));
-}
-
-void Scheduler::FirstCheck()
-{
-	m_mutexTaskList.Lock();
-	m_TaskList.sort(CompareTasks);
-	m_mutexTaskList.Unlock();
-
-	// check all tasks for the last week
-	time_t tCurrent = time(NULL);
-	m_tLastCheck = tCurrent - 60*60*24*7;
-	m_bDetectClockChanges = false;
-	m_bExecuteProcess = false;
-	CheckTasks();
-}
-
-void Scheduler::IntervalCheck()
-{
-	m_bDetectClockChanges = true;
-	m_bExecuteProcess = true;
-	CheckTasks();
-	CheckScheduledResume();
-}
-
-void Scheduler::CheckTasks()
-{
-	PrepareLog();
-
-	m_mutexTaskList.Lock();
-
-	time_t tCurrent = time(NULL);
-
-	if (!m_TaskList.empty())
-	{
-		if (m_bDetectClockChanges)
-		{
-			// Detect large step changes of system time 
-			time_t tDiff = tCurrent - m_tLastCheck;
-			if (tDiff > 60*90 || tDiff < -60*90)
-			{
-				debug("Reset scheduled tasks (detected clock adjustment greater than 90 minutes)");
-				m_bExecuteProcess = false;
-				m_tLastCheck = tCurrent;
-
-				for (TaskList::iterator it = m_TaskList.begin(); it != m_TaskList.end(); it++)
-				{
-					Task* pTask = *it;
-					pTask->m_tLastExecuted = 0;
-				}
-			}
-		}
-
-		time_t tLocalCurrent = tCurrent + g_pOptions->GetLocalTimeOffset();
-		time_t tLocalLastCheck = m_tLastCheck + g_pOptions->GetLocalTimeOffset();
-
-		tm tmCurrent;
-		gmtime_r(&tLocalCurrent, &tmCurrent);
-		tm tmLastCheck;
-		gmtime_r(&tLocalLastCheck, &tmLastCheck);
-
-		tm tmLoop;
-		memcpy(&tmLoop, &tmLastCheck, sizeof(tmLastCheck));
-		tmLoop.tm_hour = tmCurrent.tm_hour;
-		tmLoop.tm_min = tmCurrent.tm_min;
-		tmLoop.tm_sec = tmCurrent.tm_sec;
-		time_t tLoop = Util::Timegm(&tmLoop);
-
-		while (tLoop <= tLocalCurrent)
-		{
-			for (TaskList::iterator it = m_TaskList.begin(); it != m_TaskList.end(); it++)
-			{
-				Task* pTask = *it;
-				if (pTask->m_tLastExecuted != tLoop)
-				{
-					tm tmAppoint;
-					memcpy(&tmAppoint, &tmLoop, sizeof(tmLoop));
-					tmAppoint.tm_hour = pTask->m_iHours;
-					tmAppoint.tm_min = pTask->m_iMinutes;
-					tmAppoint.tm_sec = 0;
-
-					time_t tAppoint = Util::Timegm(&tmAppoint);
-
-					int iWeekDay = tmAppoint.tm_wday;
-					if (iWeekDay == 0)
-					{
-						iWeekDay = 7;
-					}
-
-					bool bWeekDayOK = pTask->m_iWeekDaysBits == 0 || (pTask->m_iWeekDaysBits & (1 << (iWeekDay - 1)));
-					bool bDoTask = bWeekDayOK && tLocalLastCheck < tAppoint && tAppoint <= tLocalCurrent;
-
-					//debug("TEMP: 1) m_tLastCheck=%i, tLocalCurrent=%i, tLoop=%i, tAppoint=%i, bWeekDayOK=%i, bDoTask=%i", m_tLastCheck, tLocalCurrent, tLoop, tAppoint, (int)bWeekDayOK, (int)bDoTask);
-
-					if (bDoTask)
-					{
-						ExecuteTask(pTask);
-						pTask->m_tLastExecuted = tLoop;
-					}
-				}
-			}
-			tLoop += 60*60*24; // inc day
-			gmtime_r(&tLoop, &tmLoop);
-		}
-	}
-
-	m_tLastCheck = tCurrent;
-
-	m_mutexTaskList.Unlock();
-
-	PrintLog();
-}
-
-void Scheduler::ExecuteTask(Task* pTask)
-{
-	const char* szCommandName[] = { "Pause", "Unpause", "Set download rate", "Execute process", "Execute script",
-		"Pause Scan", "Unpause Scan", "Enable Server", "Disable Server", "Fetch Feed" };
-	debug("Executing scheduled command: %s", szCommandName[pTask->m_eCommand]);
-
-	switch (pTask->m_eCommand)
-	{
-		case scDownloadRate:
-			if (!Util::EmptyStr(pTask->m_szParam))
-			{
-				g_pOptions->SetDownloadRate(atoi(pTask->m_szParam) * 1024);
-				m_bDownloadRateChanged = true;
-			}
-			break;
-
-		case scPauseDownload:
-		case scUnpauseDownload:
-			g_pOptions->SetPauseDownload(pTask->m_eCommand == scPauseDownload);
-			m_bPauseDownloadChanged = true;
-			break;
-
-		case scScript:
-		case scProcess:
-			if (m_bExecuteProcess)
-			{
-				SchedulerScriptController::StartScript(pTask->m_szParam, pTask->m_eCommand == scProcess, pTask->m_iID);
-			}
-			break;
-
-		case scPauseScan:
-		case scUnpauseScan:
-			g_pOptions->SetPauseScan(pTask->m_eCommand == scPauseScan);
-			m_bPauseScanChanged = true;
-			break;
-
-		case scActivateServer:
-		case scDeactivateServer:
-			EditServer(pTask->m_eCommand == scActivateServer, pTask->m_szParam);
-			break;
-
-		case scFetchFeed:
-			if (m_bExecuteProcess)
-			{
-				FetchFeed(pTask->m_szParam);
-				break;
-			}
-	}
-}
-
-void Scheduler::PrepareLog()
-{
-	m_bDownloadRateChanged = false;
-	m_bPauseDownloadChanged = false;
-	m_bPauseScanChanged = false;
-	m_bServerChanged = false;
-}
-
-void Scheduler::PrintLog()
-{
-	if (m_bDownloadRateChanged)
-	{
-		info("Scheduler: setting download rate to %i KB/s", g_pOptions->GetDownloadRate() / 1024);
-	}
-	if (m_bPauseDownloadChanged)
-	{
-		info("Scheduler: %s download", g_pOptions->GetPauseDownload() ? "pausing" : "unpausing");
-	}
-	if (m_bPauseScanChanged)
-	{
-		info("Scheduler: %s scan", g_pOptions->GetPauseScan() ? "pausing" : "unpausing");
-	}
-	if (m_bServerChanged)
-	{
-		int index = 0;
-		for (Servers::iterator it = g_pServerPool->GetServers()->begin(); it != g_pServerPool->GetServers()->end(); it++, index++)
-		{
-			NewsServer* pServer = *it;
-			if (pServer->GetActive() != m_ServerStatusList[index])
-			{
-				info("Scheduler: %s %s", pServer->GetActive() ? "activating" : "deactivating", pServer->GetName());
-			}
-		}
-		g_pServerPool->Changed();
-	}
-}
-
-void Scheduler::EditServer(bool bActive, const char* szServerList)
-{
-	Tokenizer tok(szServerList, ",;");
-	while (const char* szServer = tok.Next())
-	{
-		int iID = atoi(szServer);
-		for (Servers::iterator it = g_pServerPool->GetServers()->begin(); it != g_pServerPool->GetServers()->end(); it++)
-		{
-			NewsServer* pServer = *it;
-			if ((iID > 0 && pServer->GetID() == iID) ||
-				!strcasecmp(pServer->GetName(), szServer))
-			{
-				if (!m_bServerChanged)
-				{
-					// store old server status for logging
-					m_ServerStatusList.clear();
-					m_ServerStatusList.reserve(g_pServerPool->GetServers()->size());
-					for (Servers::iterator it2 = g_pServerPool->GetServers()->begin(); it2 != g_pServerPool->GetServers()->end(); it2++)
-					{
-						NewsServer* pServer2 = *it2;
-						m_ServerStatusList.push_back(pServer2->GetActive());
-					}
-				}
-				m_bServerChanged = true;
-				pServer->SetActive(bActive);
-				break;
-			}
-		}
-	}
-}
-
-void Scheduler::FetchFeed(const char* szFeedList)
-{
-	Tokenizer tok(szFeedList, ",;");
-	while (const char* szFeed = tok.Next())
-	{
-		int iID = atoi(szFeed);
-		for (Feeds::iterator it = g_pFeedCoordinator->GetFeeds()->begin(); it != g_pFeedCoordinator->GetFeeds()->end(); it++)
-		{
-			FeedInfo* pFeed = *it;
-			if (pFeed->GetID() == iID ||
-				!strcasecmp(pFeed->GetName(), szFeed) ||
-				!strcasecmp("0", szFeed))
-			{
-				g_pFeedCoordinator->FetchFeed(!strcasecmp("0", szFeed) ? 0 : pFeed->GetID());
-				break;
-			}
-		}
-	}
-}
-
-void Scheduler::CheckScheduledResume()
-{
-	time_t tResumeTime = g_pOptions->GetResumeTime();
-	time_t tCurrentTime = time(NULL);
-	if (tResumeTime > 0 && tCurrentTime >= tResumeTime)
-	{
-		info("Autoresume");
-		g_pOptions->SetResumeTime(0);
-		g_pOptions->SetPauseDownload(false);
-		g_pOptions->SetPausePostProcess(false);
-		g_pOptions->SetPauseScan(false);
-	}
-}
-
-
-SchedulerScriptController::~SchedulerScriptController()
-{
-	free(m_szScript);
-}
-
-void SchedulerScriptController::StartScript(const char* szParam, bool bExternalProcess, int iTaskID)
-{
-	char** argv = NULL;
-	if (bExternalProcess && !Util::SplitCommandLine(szParam, &argv))
-	{
-		error("Could not execute scheduled process-script, failed to parse command line: %s", szParam);
-		return;
-	}
-
-	SchedulerScriptController* pScriptController = new SchedulerScriptController();
-
-	pScriptController->m_bExternalProcess = bExternalProcess;
-	pScriptController->m_szScript = strdup(szParam);
-	pScriptController->m_iTaskID = iTaskID;
-
-	if (bExternalProcess)
-	{
-		pScriptController->SetScript(argv[0]);
-		pScriptController->SetArgs((const char**)argv, true);
-	}
-
-	pScriptController->SetAutoDestroy(true);
-
-	pScriptController->Start();
-}
-
-void SchedulerScriptController::Run()
-{
-	if (m_bExternalProcess)
-	{
-		ExecuteExternalProcess();
-	}
-	else
-	{
-		ExecuteScriptList(m_szScript);
-	}
-}
-
-void SchedulerScriptController::ExecuteScript(Options::Script* pScript)
-{
-	if (!pScript->GetSchedulerScript())
-	{
-		return;
-	}
-
-	PrintMessage(Message::mkInfo, "Executing scheduler-script %s for Task%i", pScript->GetName(), m_iTaskID);
-
-	SetScript(pScript->GetLocation());
-	SetArgs(NULL, false);
-
-	char szInfoName[1024];
-	snprintf(szInfoName, 1024, "scheduler-script %s for Task%i", pScript->GetName(), m_iTaskID);
-	szInfoName[1024-1] = '\0';
-	SetInfoName(szInfoName);
-
-	SetLogPrefix(pScript->GetDisplayName());
-	PrepareParams(pScript->GetName());
-
-	Execute();
-
-	SetLogPrefix(NULL);
-}
-
-void SchedulerScriptController::PrepareParams(const char* szScriptName)
-{
-	ResetEnv();
-
-	SetIntEnvVar("NZBSP_TASKID", m_iTaskID);
-
-	PrepareEnvScript(NULL, szScriptName);
-}
-
-void SchedulerScriptController::ExecuteExternalProcess()
-{
-	info("Executing scheduled process-script %s for Task%i", Util::BaseFileName(GetScript()), m_iTaskID);
-
-	char szInfoName[1024];
-	snprintf(szInfoName, 1024, "scheduled process-script %s for Task%i", Util::BaseFileName(GetScript()), m_iTaskID);
-	szInfoName[1024-1] = '\0';
-	SetInfoName(szInfoName);
-
-	char szLogPrefix[1024];
-	strncpy(szLogPrefix, Util::BaseFileName(GetScript()), 1024);
-	szLogPrefix[1024-1] = '\0';
-	if (char* ext = strrchr(szLogPrefix, '.')) *ext = '\0'; // strip file extension
-	SetLogPrefix(szLogPrefix);
-
-	Execute();
-}

daemon/main/Scheduler.h

@@ -1,102 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2008-2014 Andrey Prygunkov <hugbug@users.sourceforge.net>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- * $Revision$
- * $Date$
- *
- */
-
-
-#ifndef SCHEDULER_H
-#define SCHEDULER_H
-
-#include <list>
-#include <vector>
-#include <time.h>
-
-#include "Thread.h"
-
-class Scheduler
-{
-public:
-	enum ECommand
-	{
-		scPauseDownload,
-		scUnpauseDownload,
-		scDownloadRate,
-		scScript,
-		scProcess,
-		scPauseScan,
-		scUnpauseScan,
-		scActivateServer,
-		scDeactivateServer,
-		scFetchFeed
-	};
-
-	class Task
-	{
-	private:
-		int				m_iID;
-		int				m_iHours;
-		int				m_iMinutes;
-		int				m_iWeekDaysBits;
-		ECommand		m_eCommand;
-		char*			m_szParam;
-		time_t			m_tLastExecuted;
-
-	public:
-						Task(int iID, int iHours, int iMinutes, int iWeekDaysBits, ECommand eCommand, 
-							const char* szParam);
-						~Task();
-		friend class	Scheduler;
-	};
-
-private:
-
-	typedef std::list<Task*>		TaskList;
-	typedef std::vector<bool>		ServerStatusList;
-
-	TaskList			m_TaskList;
-	Mutex				m_mutexTaskList;
-	time_t				m_tLastCheck;
-	bool				m_bDetectClockChanges;
-	bool				m_bDownloadRateChanged;
-	bool				m_bExecuteProcess;
-	bool				m_bPauseDownloadChanged;
-	bool				m_bPauseScanChanged;
-	bool				m_bServerChanged;
-	ServerStatusList	m_ServerStatusList;
-	void				ExecuteTask(Task* pTask);
-	void				CheckTasks();
-	static bool			CompareTasks(Scheduler::Task* pTask1, Scheduler::Task* pTask2);
-	void				PrepareLog();
-	void				PrintLog();
-	void				EditServer(bool bActive, const char* szServerList);
-	void				FetchFeed(const char* szFeedList);
-	void				CheckScheduledResume();
-
-public:
-						Scheduler();
-						~Scheduler();
-	void				AddTask(Task* pTask);
-	void				FirstCheck();
-	void				IntervalCheck();
-};
-
-#endif

daemon/main/nzbget.cpp

@@ -1,876 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
- *  Copyright (C) 2007-2014 Andrey Prygunkov <hugbug@users.sourceforge.net>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- * $Revision$
- * $Date$
- *
- */
-
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#ifdef WIN32
-#include "win32.h"
-#endif
-
-#include <stdlib.h>
-#include <string.h>
-#ifdef WIN32
-#include <winsvc.h>
-#else
-#include <unistd.h>
-#include <pwd.h>
-#include <grp.h>
-#include <sys/resource.h>
-#ifdef HAVE_SYS_PRCTL_H
-#include <sys/prctl.h>
-#endif
-#include <signal.h>
-#endif
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <stdio.h>
-#include <fcntl.h>
-#ifndef DISABLE_PARCHECK
-#include <iostream>
-#endif
-#ifdef HAVE_BACKTRACE
-#include <execinfo.h>
-#endif
-
-#include "nzbget.h"
-#include "ServerPool.h"
-#include "Log.h"
-#include "NZBFile.h"
-#include "Options.h"
-#include "Thread.h"
-#include "ColoredFrontend.h"
-#include "NCursesFrontend.h"
-#include "QueueCoordinator.h"
-#include "UrlCoordinator.h"
-#include "RemoteServer.h"
-#include "RemoteClient.h"
-#include "MessageBase.h"
-#include "DiskState.h"
-#include "PrePostProcessor.h"
-#include "HistoryCoordinator.h"
-#include "DupeCoordinator.h"
-#include "ParChecker.h"
-#include "Scheduler.h"
-#include "Scanner.h"
-#include "FeedCoordinator.h"
-#include "Maintenance.h"
-#include "StatMeter.h"
-#include "Util.h"
-#ifdef WIN32
-#include "NTService.h"
-#endif
-
-// Prototypes
-void RunMain();
-void Run(bool bReload);
-void Reload();
-void Cleanup();
-void ProcessClientRequest();
-#ifndef WIN32
-void InstallSignalHandlers();
-void Daemonize();
-void PrintBacktrace();
-#ifdef HAVE_SYS_PRCTL_H
-void EnableDumpCore();
-#endif
-#ifdef DEBUG
-void MakeSegFault();
-#endif
-#endif
-#ifndef DISABLE_PARCHECK
-void DisableCout();
-#endif
-
-Thread* g_pFrontend = NULL;
-Options* g_pOptions = NULL;
-ServerPool* g_pServerPool = NULL;
-QueueCoordinator* g_pQueueCoordinator = NULL;
-UrlCoordinator* g_pUrlCoordinator = NULL;
-RemoteServer* g_pRemoteServer = NULL;
-RemoteServer* g_pRemoteSecureServer = NULL;
-StatMeter* g_pStatMeter = NULL;
-Log* g_pLog = NULL;
-PrePostProcessor* g_pPrePostProcessor = NULL;
-HistoryCoordinator* g_pHistoryCoordinator = NULL;
-DupeCoordinator* g_pDupeCoordinator = NULL;
-DiskState* g_pDiskState = NULL;
-Scheduler* g_pScheduler = NULL;
-Scanner* g_pScanner = NULL;
-FeedCoordinator* g_pFeedCoordinator = NULL;
-Maintenance* g_pMaintenance = NULL;
-int g_iArgumentCount;
-char* (*g_szEnvironmentVariables)[] = NULL;
-char* (*g_szArguments)[] = NULL;
-bool g_bReloading = true;
-
-/*
- * Main loop
- */
-int main(int argc, char *argv[], char *argp[])
-{
-#ifdef WIN32
-#ifdef _DEBUG
-	_CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
-	_CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
-	_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF
-#ifdef DEBUG_CRTMEMLEAKS
-		| _CRTDBG_CHECK_CRT_DF | _CRTDBG_CHECK_ALWAYS_DF
-#endif
-		);
-#endif
-#endif
-
-	Util::InitVersionRevision();
-	
-#ifdef WIN32
-	InstallUninstallServiceCheck(argc, argv);
-#endif
-
-#ifndef DISABLE_PARCHECK
-	DisableCout();
-#endif
-
-	srand (time(NULL));
-
-	g_iArgumentCount = argc;
-	g_szArguments = (char*(*)[])argv;
-	g_szEnvironmentVariables = (char*(*)[])argp;
-
-#ifdef WIN32
-	for (int i=0; i < argc; i++)
-	{
-		if (!strcmp(argv[i], "-D"))
-		{
-			StartService(RunMain);
-			return 0;
-		}
-	}
-#endif
-
-	RunMain();
-
-#ifdef WIN32
-#ifdef _DEBUG
-	_CrtDumpMemoryLeaks();
-#endif
-#endif
-
-	return 0;
-}
-
-void RunMain()
-{
-	// we need to save and later restore current directory each time
-	// the program is reloaded (RPC-Method "reload") in order for
-	// config to properly load in a case relative paths are used 
-	// in command line
-	char szCurDir[MAX_PATH + 1];
-	Util::GetCurrentDirectory(szCurDir, sizeof(szCurDir));
-	
-	bool bReload = false;
-	while (g_bReloading)
-	{
-		g_bReloading = false;
-		Util::SetCurrentDirectory(szCurDir);
-		Run(bReload);
-		bReload = true;
-	}
-}
-
-void Run(bool bReload)
-{
-	g_pLog = new Log();
-
-	debug("nzbget %s", Util::VersionRevision());
-
-	if (!bReload)
-	{
-		Thread::Init();
-	}
-
-	g_pServerPool = new ServerPool();
-	g_pScheduler = new Scheduler();
-	g_pQueueCoordinator = new QueueCoordinator();
-	g_pStatMeter = new StatMeter();
-	g_pScanner = new Scanner();
-	g_pPrePostProcessor = new PrePostProcessor();
-	g_pHistoryCoordinator = new HistoryCoordinator();
-	g_pDupeCoordinator = new DupeCoordinator();
-	g_pUrlCoordinator = new UrlCoordinator();
-	g_pFeedCoordinator = new FeedCoordinator();
-	g_pMaintenance = new Maintenance();
-
-	debug("Reading options");
-	g_pOptions = new Options(g_iArgumentCount, *g_szArguments);
-
-#ifndef WIN32
-	if (g_pOptions->GetUMask() < 01000)
-	{
-		/* set newly created file permissions */
-		umask(g_pOptions->GetUMask());
-	}
-#endif
-	
-	if (g_pOptions->GetServerMode() && g_pOptions->GetCreateLog() && g_pOptions->GetResetLog())
-	{
-		debug("Deleting old log-file");
-		g_pLog->ResetLog();
-	}
-
-	g_pLog->InitOptions();
-	g_pScanner->InitOptions();
-
-	if (g_pOptions->GetDaemonMode())
-	{
-#ifdef WIN32
-		info("nzbget %s service-mode", Util::VersionRevision());
-#else
-		if (!bReload)
-		{
-			Daemonize();
-		}
-		info("nzbget %s daemon-mode", Util::VersionRevision());
-#endif
-	}
-	else if (g_pOptions->GetServerMode())
-	{
-		info("nzbget %s server-mode", Util::VersionRevision());
-	}
-	else if (g_pOptions->GetRemoteClientMode())
-	{
-		info("nzbget %s remote-mode", Util::VersionRevision());
-	}
-
-	if (!bReload)
-	{
-		Connection::Init();
-	}
-
-	if (!g_pOptions->GetRemoteClientMode())
-	{
-		g_pServerPool->InitConnections();
-		g_pStatMeter->Init();
-	}
-
-#ifndef WIN32
-#ifdef HAVE_SYS_PRCTL_H
-	if (g_pOptions->GetDumpCore())
-	{
-		EnableDumpCore();
-	}
-#endif
-#endif
-
-#ifndef WIN32
-	InstallSignalHandlers();
-#ifdef DEBUG
-	if (g_pOptions->GetTestBacktrace())
-	{
-		MakeSegFault();
-	}
-#endif
-#endif
-
-	// client request
-	if (g_pOptions->GetClientOperation() != Options::opClientNoOperation)
-	{
-		ProcessClientRequest();
-		Cleanup();
-		return;
-	}
-
-	// Setup the network-server
-	if (g_pOptions->GetServerMode())
-	{
-		g_pRemoteServer = new RemoteServer(false);
-		g_pRemoteServer->Start();
-
-		if (g_pOptions->GetSecureControl())
-		{
-			g_pRemoteSecureServer = new RemoteServer(true);
-			g_pRemoteSecureServer->Start();
-		}
-	}
-
-	// Create the frontend
-	if (!g_pOptions->GetDaemonMode())
-	{
-		switch (g_pOptions->GetOutputMode())
-		{
-			case Options::omNCurses:
-#ifndef DISABLE_CURSES
-				g_pFrontend = new NCursesFrontend();
-				break;
-#endif
-			case Options::omColored:
-				g_pFrontend = new ColoredFrontend();
-				break;
-			case Options::omLoggable:
-				g_pFrontend = new LoggableFrontend();
-				break;
-		}
-	}
-
-	// Starting a thread with the frontend
-	if (g_pFrontend)
-	{
-		g_pFrontend->Start();
-	}
-
-	// Starting QueueCoordinator and PrePostProcessor
-	if (!g_pOptions->GetRemoteClientMode())
-	{
-		// Standalone-mode
-		if (!g_pOptions->GetServerMode())
-		{
-			const char* szCategory = g_pOptions->GetAddCategory() ? g_pOptions->GetAddCategory() : "";
-			NZBFile* pNZBFile = NZBFile::Create(g_pOptions->GetArgFilename(), szCategory);
-			if (!pNZBFile)
-			{
-				abort("FATAL ERROR: Parsing NZB-document %s failed\n\n", g_pOptions->GetArgFilename() ? g_pOptions->GetArgFilename() : "N/A");
-				return;
-			}
-			g_pScanner->InitPPParameters(szCategory, pNZBFile->GetNZBInfo()->GetParameters());
-			g_pQueueCoordinator->AddNZBFileToQueue(pNZBFile, NULL, false);
-			delete pNZBFile;
-		}
-
-		if (g_pOptions->GetSaveQueue() && g_pOptions->GetServerMode())
-		{
-			g_pDiskState = new DiskState();
-		}
-
-		g_pQueueCoordinator->Start();
-		g_pUrlCoordinator->Start();
-		g_pPrePostProcessor->Start();
-		g_pFeedCoordinator->Start();
-
-		// enter main program-loop
-		while (g_pQueueCoordinator->IsRunning() || 
-			g_pUrlCoordinator->IsRunning() || 
-			g_pPrePostProcessor->IsRunning() ||
-			g_pFeedCoordinator->IsRunning())
-		{
-			if (!g_pOptions->GetServerMode() && 
-				!g_pQueueCoordinator->HasMoreJobs() && 
-				!g_pUrlCoordinator->HasMoreJobs() && 
-				!g_pPrePostProcessor->HasMoreJobs())
-			{
-				// Standalone-mode: download completed
-				if (!g_pQueueCoordinator->IsStopped())
-				{
-					g_pQueueCoordinator->Stop();
-				}
-				if (!g_pUrlCoordinator->IsStopped())
-				{
-					g_pUrlCoordinator->Stop();
-				}
-				if (!g_pPrePostProcessor->IsStopped())
-				{
-					g_pPrePostProcessor->Stop();
-				}
-				if (!g_pFeedCoordinator->IsStopped())
-				{
-					g_pFeedCoordinator->Stop();
-				}
-			}
-			usleep(100 * 1000);
-		}
-
-		// main program-loop is terminated
-		debug("QueueCoordinator stopped");
-		debug("UrlCoordinator stopped");
-		debug("PrePostProcessor stopped");
-		debug("FeedCoordinator stopped");
-	}
-
-	// Stop network-server
-	if (g_pRemoteServer)
-	{
-		debug("stopping RemoteServer");
-		g_pRemoteServer->Stop();
-		int iMaxWaitMSec = 1000;
-		while (g_pRemoteServer->IsRunning() && iMaxWaitMSec > 0)
-		{
-			usleep(100 * 1000);
-			iMaxWaitMSec -= 100;
-		}
-		if (g_pRemoteServer->IsRunning())
-		{
-			debug("Killing RemoteServer");
-			g_pRemoteServer->Kill();
-		}
-		debug("RemoteServer stopped");
-	}
-
-	if (g_pRemoteSecureServer)
-	{
-		debug("stopping RemoteSecureServer");
-		g_pRemoteSecureServer->Stop();
-		int iMaxWaitMSec = 1000;
-		while (g_pRemoteSecureServer->IsRunning() && iMaxWaitMSec > 0)
-		{
-			usleep(100 * 1000);
-			iMaxWaitMSec -= 100;
-		}
-		if (g_pRemoteSecureServer->IsRunning())
-		{
-			debug("Killing RemoteSecureServer");
-			g_pRemoteSecureServer->Kill();
-		}
-		debug("RemoteSecureServer stopped");
-	}
-
-	// Stop Frontend
-	if (g_pFrontend)
-	{
-		if (!g_pOptions->GetRemoteClientMode())
-		{
-			debug("Stopping Frontend");
-			g_pFrontend->Stop();
-		}
-		while (g_pFrontend->IsRunning())
-		{
-			usleep(50 * 1000);
-		}
-		debug("Frontend stopped");
-	}
-
-	Cleanup();
-}
-
-void ProcessClientRequest()
-{
-	RemoteClient* Client = new RemoteClient();
-
-	switch (g_pOptions->GetClientOperation())
-	{
-		case Options::opClientRequestListFiles:
-			Client->RequestServerList(true, false, g_pOptions->GetMatchMode() == Options::mmRegEx ? g_pOptions->GetEditQueueText() : NULL);
-			break;
-
-		case Options::opClientRequestListGroups:
-			Client->RequestServerList(false, true, g_pOptions->GetMatchMode() == Options::mmRegEx ? g_pOptions->GetEditQueueText() : NULL);
-			break;
-
-		case Options::opClientRequestListStatus:
-			Client->RequestServerList(false, false, NULL);
-			break;
-
-		case Options::opClientRequestDownloadPause:
-			Client->RequestServerPauseUnpause(true, eRemotePauseUnpauseActionDownload);
-			break;
-
-		case Options::opClientRequestDownloadUnpause:
-			Client->RequestServerPauseUnpause(false, eRemotePauseUnpauseActionDownload);
-			break;
-
-		case Options::opClientRequestSetRate:
-			Client->RequestServerSetDownloadRate(g_pOptions->GetSetRate());
-			break;
-
-		case Options::opClientRequestDumpDebug:
-			Client->RequestServerDumpDebug();
-			break;
-
-		case Options::opClientRequestEditQueue:
-			Client->RequestServerEditQueue((DownloadQueue::EEditAction)g_pOptions->GetEditQueueAction(),
-				g_pOptions->GetEditQueueOffset(), g_pOptions->GetEditQueueText(),
-				g_pOptions->GetEditQueueIDList(), g_pOptions->GetEditQueueIDCount(),
-				g_pOptions->GetEditQueueNameList(), (eRemoteMatchMode)g_pOptions->GetMatchMode());
-			break;
-
-		case Options::opClientRequestLog:
-			Client->RequestServerLog(g_pOptions->GetLogLines());
-			break;
-
-		case Options::opClientRequestShutdown:
-			Client->RequestServerShutdown();
-			break;
-
-		case Options::opClientRequestReload:
-			Client->RequestServerReload();
-			break;
-
-		case Options::opClientRequestDownload:
-			Client->RequestServerDownload(g_pOptions->GetArgFilename(), g_pOptions->GetAddCategory(), g_pOptions->GetAddTop(), g_pOptions->GetAddPaused(), g_pOptions->GetAddPriority());
-			break;
-
-		case Options::opClientRequestVersion:
-			Client->RequestServerVersion();
-			break;
-
-		case Options::opClientRequestPostQueue:
-			Client->RequestPostQueue();
-			break;
-
-		case Options::opClientRequestWriteLog:
-			Client->RequestWriteLog(g_pOptions->GetWriteLogKind(), g_pOptions->GetLastArg());
-			break;
-
-		case Options::opClientRequestScanAsync:
-			Client->RequestScan(false);
-			break;
-
-		case Options::opClientRequestScanSync:
-			Client->RequestScan(true);
-			break;
-
-		case Options::opClientRequestPostPause:
-			Client->RequestServerPauseUnpause(true, eRemotePauseUnpauseActionPostProcess);
-			break;
-
-		case Options::opClientRequestPostUnpause:
-			Client->RequestServerPauseUnpause(false, eRemotePauseUnpauseActionPostProcess);
-			break;
-
-		case Options::opClientRequestScanPause:
-			Client->RequestServerPauseUnpause(true, eRemotePauseUnpauseActionScan);
-			break;
-
-		case Options::opClientRequestScanUnpause:
-			Client->RequestServerPauseUnpause(false, eRemotePauseUnpauseActionScan);
-			break;
-
-		case Options::opClientRequestHistory:	 
-			Client->RequestHistory();	 
-			break;
-
-		case Options::opClientRequestDownloadUrl:
-			Client->RequestServerDownloadUrl(g_pOptions->GetLastArg(), g_pOptions->GetAddNZBFilename(), g_pOptions->GetAddCategory(), g_pOptions->GetAddTop(), g_pOptions->GetAddPaused(), g_pOptions->GetAddPriority());
-			break;
-
-		case Options::opClientNoOperation:
-			break;
-	}
-
-	delete Client;
-}
-
-void ExitProc()
-{
-	if (!g_bReloading)
-	{
-		info("Stopping, please wait...");
-	}
-	if (g_pOptions->GetRemoteClientMode())
-	{
-		if (g_pFrontend)
-		{
-			debug("Stopping Frontend");
-			g_pFrontend->Stop();
-		}
-	}
-	else
-	{
-		if (g_pQueueCoordinator)
-		{
-			debug("Stopping QueueCoordinator");
-			g_pQueueCoordinator->Stop();
-			g_pUrlCoordinator->Stop();
-			g_pPrePostProcessor->Stop();
-			g_pFeedCoordinator->Stop();
-		}
-	}
-}
-
-void Reload()
-{
-	g_bReloading = true;
-	info("Reloading...");
-	ExitProc();
-}
-
-#ifndef WIN32
-#ifdef DEBUG
-typedef void(*sighandler)(int);
-std::vector<sighandler> SignalProcList;
-#endif
-
-/*
- * Signal handler
- */
-void SignalProc(int iSignal)
-{
-	switch (iSignal)
-	{
-		case SIGINT:
-			signal(SIGINT, SIG_DFL);   // Reset the signal handler
-			ExitProc();
-			break;
-
-		case SIGTERM:
-			signal(SIGTERM, SIG_DFL);   // Reset the signal handler
-			ExitProc();
-			break;
-
-		case SIGCHLD:
-			// ignoring
-			break;
-
-#ifdef DEBUG
-		case SIGSEGV:
-			signal(SIGSEGV, SIG_DFL);   // Reset the signal handler
-			PrintBacktrace();
-			break;
-#endif
-	}
-}
-
-void InstallSignalHandlers()
-{
-	signal(SIGINT, SignalProc);
-	signal(SIGTERM, SignalProc);
-	signal(SIGPIPE, SIG_IGN);
-#ifdef DEBUG
-	signal(SIGSEGV, SignalProc);
-#endif
-#ifdef SIGCHLD_HANDLER
-    // it could be necessary on some systems to activate a handler for SIGCHLD
-    // however it make troubles on other systems and is deactivated by default
-	signal(SIGCHLD, SignalProc);
-#endif
-}
-
-void PrintBacktrace()
-{
-#ifdef HAVE_BACKTRACE
-	printf("Segmentation fault, tracing...\n");
-	
-	void *array[100];
-	size_t size;
-	char **strings;
-	size_t i;
-
-	size = backtrace(array, 100);
-	strings = backtrace_symbols(array, size);
-
-	// first trace to screen
-	printf("Obtained %zd stack frames\n", size);
-	for (i = 0; i < size; i++)
-	{
-		printf("%s\n", strings[i]);
-	}
-
-	// then trace to log
-	error("Segmentation fault, tracing...");
-	error("Obtained %zd stack frames", size);
-	for (i = 0; i < size; i++)
-	{
-		error("%s", strings[i]);
-	}
-
-	free(strings);
-#else
-	error("Segmentation fault");
-#endif
-}
-
-#ifdef DEBUG
-void MakeSegFault()
-{
-	char* N = NULL;
-	strcpy(N, "");
-}
-#endif
-
-#ifdef HAVE_SYS_PRCTL_H
-/**
-* activates the creation of core-files
-*/
-void EnableDumpCore()
-{
-	rlimit rlim;
-	rlim.rlim_cur= RLIM_INFINITY;
-	rlim.rlim_max= RLIM_INFINITY;
-	setrlimit(RLIMIT_CORE, &rlim);
-	prctl(PR_SET_DUMPABLE, 1);
-}
-#endif
-#endif
-
-void Cleanup()
-{
-	debug("Cleaning up global objects");
-
-	debug("Deleting UrlCoordinator");
-	delete g_pUrlCoordinator;
-	g_pUrlCoordinator = NULL;
-	debug("UrlCoordinator deleted");
-
-	debug("Deleting RemoteServer");
-	delete g_pRemoteServer;
-	g_pRemoteServer = NULL;
-	debug("RemoteServer deleted");
-
-	debug("Deleting RemoteSecureServer");
-	delete g_pRemoteSecureServer;
-	g_pRemoteSecureServer = NULL;
-	debug("RemoteSecureServer deleted");
-
-	debug("Deleting PrePostProcessor");
-	delete g_pPrePostProcessor;
-	g_pPrePostProcessor = NULL;
-	delete g_pScanner;
-	g_pScanner = NULL;
-	debug("PrePostProcessor deleted");
-
-	debug("Deleting HistoryCoordinator");
-	delete g_pHistoryCoordinator;
-	g_pHistoryCoordinator = NULL;
-	debug("HistoryCoordinator deleted");
-
-	debug("Deleting DupeCoordinator");
-	delete g_pDupeCoordinator;
-	g_pDupeCoordinator = NULL;
-	debug("DupeCoordinator deleted");
-
-	debug("Deleting Frontend");
-	delete g_pFrontend;
-	g_pFrontend = NULL;
-	debug("Frontend deleted");
-
-	debug("Deleting QueueCoordinator");
-	delete g_pQueueCoordinator;
-	g_pQueueCoordinator = NULL;
-	debug("QueueCoordinator deleted");
-
-	debug("Deleting DiskState");
-	delete g_pDiskState;
-	g_pDiskState = NULL;
-	debug("DiskState deleted");
-
-	debug("Deleting Options");
-	if (g_pOptions)
-	{
-		if (g_pOptions->GetDaemonMode() && !g_bReloading)
-		{
-			info("Deleting lock file");
-			remove(g_pOptions->GetLockFile());
-		}
-		delete g_pOptions;
-		g_pOptions = NULL;
-	}
-	debug("Options deleted");
-
-	debug("Deleting ServerPool");
-	delete g_pServerPool;
-	g_pServerPool = NULL;
-	debug("ServerPool deleted");
-
-	debug("Deleting Scheduler");
-	delete g_pScheduler;
-	g_pScheduler = NULL;
-	debug("Scheduler deleted");
-
-	debug("Deleting FeedCoordinator");
-	delete g_pFeedCoordinator;
-	g_pFeedCoordinator = NULL;
-	debug("FeedCoordinator deleted");
-
-	debug("Deleting Maintenance");
-	delete g_pMaintenance;
-	g_pMaintenance = NULL;
-	debug("Maintenance deleted");
-
-	debug("Deleting StatMeter");
-	delete g_pStatMeter;
-	g_pStatMeter = NULL;
-	debug("StatMeter deleted");
-
-	if (!g_bReloading)
-	{
-		Connection::Final();
-		Thread::Final();
-	}
-
-	debug("Global objects cleaned up");
-
-	delete g_pLog;
-	g_pLog = NULL;
-}
-
-#ifndef WIN32
-void Daemonize()
-{
-	int i, lfp;
-	char str[10];
-	if (getppid() == 1) return; /* already a daemon */
-	i = fork();
-	if (i < 0) exit(1); /* fork error */
-	if (i > 0) exit(0); /* parent exits */
-	/* child (daemon) continues */
-	setsid(); /* obtain a new process group */
-	for (i = getdtablesize();i >= 0;--i) close(i); /* close all descriptors */
-	i = open("/dev/null", O_RDWR); dup(i); dup(i); /* handle standart I/O */
-	chdir(g_pOptions->GetDestDir()); /* change running directory */
-	lfp = open(g_pOptions->GetLockFile(), O_RDWR | O_CREAT, 0640);
-	if (lfp < 0) exit(1); /* can not open */
-	if (lockf(lfp, F_TLOCK, 0) < 0) exit(0); /* can not lock */
-
-	/* Drop user if there is one, and we were run as root */
-	if ( getuid() == 0 || geteuid() == 0 )
-	{
-		struct passwd *pw = getpwnam(g_pOptions->GetDaemonUsername());
-		if (pw)
-		{
-			fchown(lfp, pw->pw_uid, pw->pw_gid); /* change owner of lock file  */
-			setgroups( 0, (const gid_t*) 0 ); /* Set aux groups to null. */
-			setgid(pw->pw_gid); /* Set primary group. */
-			/* Try setting aux groups correctly - not critical if this fails. */
-			initgroups( g_pOptions->GetDaemonUsername(),pw->pw_gid); 
-			/* Finally, set uid. */
-			setuid(pw->pw_uid);
-		}
-	}
-
-	/* first instance continues */
-	sprintf(str, "%d\n", getpid());
-	write(lfp, str, strlen(str)); /* record pid to lockfile */
-	signal(SIGCHLD, SIG_IGN); /* ignore child */
-	signal(SIGTSTP, SIG_IGN); /* ignore tty signals */
-	signal(SIGTTOU, SIG_IGN);
-	signal(SIGTTIN, SIG_IGN);
-}
-#endif
-
-#ifndef DISABLE_PARCHECK
-class NullStreamBuf : public std::streambuf
-{
-public:
-	int sputc ( char c ) { return (int) c; }
-} NullStreamBufInstance;
-
-void DisableCout()
-{
-	// libpar2 prints messages to c++ standard output stream (std::cout).
-	// However we do not want these messages to be printed.
-	// Since we do not use std::cout in nzbget we just disable it.
-	std::cout.rdbuf(&NullStreamBufInstance);
-}
-#endif

daemon/nntp/Decoder.cpp

@@ -1,473 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
- *  Copyright (C) 2007  Andrey Prygunkov <hugbug@users.sourceforge.net>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- * $Revision$
- * $Date$
- *
- */
-
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#ifdef WIN32
-#include "win32.h"
-#endif
-
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#ifndef WIN32
-#include <unistd.h>
-#endif
-
-#include "nzbget.h"
-#include "Decoder.h"
-#include "Log.h"
-#include "Util.h"
-
-const char* Decoder::FormatNames[] = { "Unknown", "yEnc", "UU" };
-unsigned int YDecoder::crc_tab[256];
-
-Decoder::Decoder()
-{
-	debug("Creating Decoder");
-
-	m_szSrcFilename		= NULL;
-	m_szDestFilename	= NULL;
-	m_szArticleFilename	= NULL;
-}
-
-Decoder::~ Decoder()
-{
-	debug("Destroying Decoder");
-
-	free(m_szArticleFilename);
-}
-
-void Decoder::Clear()
-{
-	free(m_szArticleFilename);
-	m_szArticleFilename = NULL;
-}
-
-Decoder::EFormat Decoder::DetectFormat(const char* buffer, int len)
-{
-	if (!strncmp(buffer, "=ybegin ", 8))
-	{
-		return efYenc;
-	}
-	
-	if ((len == 62 || len == 63) && (buffer[62] == '\n' || buffer[62] == '\r') && *buffer == 'M')
-	{
-		return efUx;
-	}
-
-	if (!strncmp(buffer, "begin ", 6))
-	{
-		bool bOK = true;
-		buffer += 6; //strlen("begin ")
-		while (*buffer && *buffer != ' ')
-		{
-			char ch = *buffer++;
-			if (ch < '0' || ch > '7')
-			{
-				bOK = false;
-				break;
-			}
-		}
-		if (bOK)
-		{
-			return efUx;
-		}
-	}
-
-	return efUnknown;
-}
-
-/**
-  * YDecoder: fast implementation of yEnc-Decoder
-  */
-
-void YDecoder::Init()
-{
-	debug("Initializing global decoder");
-	crc32gentab();
-}
-
-void YDecoder::Final()
-{
-	debug("Finalizing global Decoder");
-}
-
-YDecoder::YDecoder()
-{
-	Clear();
-}
-
-void YDecoder::Clear()
-{
-	Decoder::Clear();
-
-	m_bBody = false;
-	m_bBegin = false;
-	m_bPart = false;
-	m_bEnd = false;
-	m_bCrc = false;
-	m_lExpectedCRC = 0;
-	m_lCalculatedCRC = 0xFFFFFFFF;
-	m_iBegin = 0;
-	m_iEnd = 0xFFFFFFFF;
-	m_iSize = 0;
-	m_iEndSize = 0;
-	m_bAutoSeek = false;
-	m_bNeedSetPos = false;
-	m_bCrcCheck = false;
-}
-
-/* from crc32.c (http://www.koders.com/c/fid699AFE0A656F0022C9D6B9D1743E697B69CE5815.aspx)
- *
- * (c) 1999,2000 Krzysztof Dabrowski
- * (c) 1999,2000 ElysiuM deeZine
- * Released under GPL (thanks)
- *
- * chksum_crc32gentab() --      to a global crc_tab[256], this one will
- *				calculate the crcTable for crc32-checksums.
- *				it is generated to the polynom [..]
- */
-void YDecoder::crc32gentab()
-{
-	unsigned long crc, poly;
-	int i, j;
-
-	poly = 0xEDB88320L;
-	for (i = 0; i < 256; i++)
-	{
-		crc = i;
-		for (j = 8; j > 0; j--)
-		{
-			if (crc & 1)
-			{
-				crc = (crc >> 1) ^ poly;
-			}
-			else
-			{
-				crc >>= 1;
-			}
-		}
-		crc_tab[i] = crc;
-	}
-}
-
-/* This is modified version of chksum_crc() from
- * crc32.c (http://www.koders.com/c/fid699AFE0A656F0022C9D6B9D1743E697B69CE5815.aspx)
- * (c) 1999,2000 Krzysztof Dabrowski
- * (c) 1999,2000 ElysiuM deeZine
- *
- * chksum_crc() -- to a given block, this one calculates the
- *				crc32-checksum until the length is
- *				reached. the crc32-checksum will be
- *				the result.
- */
-unsigned long YDecoder::crc32m(unsigned long startCrc, unsigned char *block, unsigned int length)
-{
-	register unsigned long crc = startCrc;
-	for (unsigned long i = 0; i < length; i++)
-	{
-		crc = ((crc >> 8) & 0x00FFFFFF) ^ crc_tab[(crc ^ *block++) & 0xFF];
-	}
-	return crc;
-}
-
-unsigned int YDecoder::DecodeBuffer(char* buffer)
-{
-	if (m_bBody && !m_bEnd)
-	{
-		if (!strncmp(buffer, "=yend ", 6))
-		{
-			m_bEnd = true;
-			char* pb = strstr(buffer, m_bPart ? " pcrc32=" : " crc32=");
-			if (pb)
-			{
-				m_bCrc = true;
-				pb += 7 + (int)m_bPart; //=strlen(" crc32=") or strlen(" pcrc32=")
-				m_lExpectedCRC = strtoul(pb, NULL, 16);
-			}
-			pb = strstr(buffer, " size=");
-			if (pb) 
-			{
-				pb += 6; //=strlen(" size=")
-				m_iEndSize = (int)atoi(pb);
-			}
-			return 0;
-		}
-
-		char* iptr = buffer;
-		char* optr = buffer;
-		while (true)
-		{
-			switch (*iptr)
-			{
-				case '=':	//escape-sequence
-					iptr++;
-					*optr = *iptr - 64 - 42;
-					optr++;
-					break;
-				case '\n':	// ignored char
-				case '\r':	// ignored char
-					break;
-				case '\0':
-					goto BreakLoop;
-				default:	// normal char
-					*optr = *iptr - 42;
-					optr++;
-					break;
-			}
-			iptr++;
-		}
-BreakLoop:
-
-		if (m_bCrcCheck)
-		{
-			m_lCalculatedCRC = crc32m(m_lCalculatedCRC, (unsigned char *)buffer, (unsigned int)(optr - buffer));
-		}
-		return (unsigned int)(optr - buffer);
-	}
-	else 
-	{
-		if (!m_bPart && !strncmp(buffer, "=ybegin ", 8))
-		{
-			m_bBegin = true;
-			char* pb = strstr(buffer, " name=");
-			if (pb)
-			{
-				pb += 6; //=strlen(" name=")
-				char* pe;
-				for (pe = pb; *pe != '\0' && *pe != '\n' && *pe != '\r'; pe++) ;
-				free(m_szArticleFilename);
-				m_szArticleFilename = (char*)malloc(pe - pb + 1);
-				strncpy(m_szArticleFilename, pb, pe - pb);
-				m_szArticleFilename[pe - pb] = '\0';
-			}
-			pb = strstr(buffer, " size=");
-			if (pb) 
-			{
-				pb += 6; //=strlen(" size=")
-				m_iSize = (int)atoi(pb);
-			}
-			m_bPart = strstr(buffer, " part=");
-			if (!m_bPart)
-			{
-				m_bBody = true;
-				m_iBegin = 1;
-				m_iEnd = m_iSize;
-			}
-		}
-		else if (m_bPart && !strncmp(buffer, "=ypart ", 7))
-		{
-			m_bPart = true;
-			m_bBody = true;
-			char* pb = strstr(buffer, " begin=");
-			if (pb) 
-			{
-				pb += 7; //=strlen(" begin=")
-				m_iBegin = (int)atoi(pb);
-			}
-			pb = strstr(buffer, " end=");
-			if (pb) 
-			{
-				pb += 5; //=strlen(" end=")
-				m_iEnd = (int)atoi(pb);
-			}
-		}
-	}
-
-	return 0;
-}
-
-bool YDecoder::Write(char* buffer, int len, FILE* outfile)
-{
-	unsigned int wcnt = DecodeBuffer(buffer);
-	if (wcnt > 0)
-	{
-		if (m_bNeedSetPos)
-		{
-			if (m_iBegin == 0 || m_iEnd == 0xFFFFFFFF || !outfile)
-			{
-				return false;
-			}
-			if (fseek(outfile, m_iBegin - 1, SEEK_SET))
-			{
-				return false;
-			}
-			m_bNeedSetPos = false;
-		}
-		fwrite(buffer, 1, wcnt, outfile);
-	}
-	return true;
-}
-
-Decoder::EStatus YDecoder::Check()
-{
-	m_lCalculatedCRC ^= 0xFFFFFFFF;
-
-	debug("Expected crc32=%x", m_lExpectedCRC);
-	debug("Calculated crc32=%x", m_lCalculatedCRC);
-
-	if (!m_bBegin)
-	{
-		return eNoBinaryData;
-	}
-	else if (!m_bEnd)
-	{
-		return eArticleIncomplete;
-	}
-	else if (!m_bPart && m_iSize != m_iEndSize)
-	{
-		return eInvalidSize;
-	}
-	else if (m_bCrcCheck && m_bCrc && (m_lExpectedCRC != m_lCalculatedCRC))
-	{
-		return eCrcError;
-	}
-
-	return eFinished;
-}
-
-
-/**
-  * UDecoder: supports UU encoding formats
-  */
-
-UDecoder::UDecoder()
-{
-
-}
-
-void UDecoder::Clear()
-{
-	Decoder::Clear();
-
-	m_bBody = false;
-	m_bEnd = false;
-}
-
-/* DecodeBuffer-function uses portions of code from tool UUDECODE by Clem Dye
- * UUDECODE.c (http://www.bastet.com/uue.zip)
- * Copyright (C) 1998 Clem Dye
- *
- * Released under GPL (thanks)
- */
-
-#define UU_DECODE_CHAR(c) (c == '`' ? 0 : (((c) - ' ') & 077))
-
-unsigned int UDecoder::DecodeBuffer(char* buffer, int len)
-{
-	if (!m_bBody)
-	{
-		if (!strncmp(buffer, "begin ", 6))
-		{
-			char* pb = buffer;
-			pb += 6; //strlen("begin ")
-
-			// skip file-permissions
-			for (; *pb != ' ' && *pb != '\0' && *pb != '\n' && *pb != '\r'; pb++) ; 
-			pb++;
-
-			// extracting filename
-			char* pe;
-			for (pe = pb; *pe != '\0' && *pe != '\n' && *pe != '\r'; pe++) ;
-			free(m_szArticleFilename);
-			m_szArticleFilename = (char*)malloc(pe - pb + 1);
-			strncpy(m_szArticleFilename, pb, pe - pb);
-			m_szArticleFilename[pe - pb] = '\0';
-
-			m_bBody = true;
-			return 0;
-		}
-		else if ((len == 62 || len == 63) && (buffer[62] == '\n' || buffer[62] == '\r') && *buffer == 'M')
-		{
-			m_bBody = true;
-		}
-	}
-
-	if (m_bBody && (!strncmp(buffer, "end ", 4) || *buffer == '`'))
-	{
-		m_bEnd = true;
-	}
-
-	if (m_bBody && !m_bEnd)
-	{
-		int iEffLen = UU_DECODE_CHAR(buffer[0]);
-		if (iEffLen > len)
-		{
-			// error;
-			return 0;
-		}
-
-		char* iptr = buffer;
-		char* optr = buffer;
-		for (++iptr; iEffLen > 0; iptr += 4, iEffLen -= 3)
-		{
-			if (iEffLen >= 3)
-			{
-				*optr++ = UU_DECODE_CHAR (iptr[0]) << 2 | UU_DECODE_CHAR (iptr[1]) >> 4; 
-				*optr++ = UU_DECODE_CHAR (iptr[1]) << 4 | UU_DECODE_CHAR (iptr[2]) >> 2; 
-				*optr++ = UU_DECODE_CHAR (iptr[2]) << 6 | UU_DECODE_CHAR (iptr[3]);
-			}
-			else
-			{
-				if (iEffLen >= 1)
-				{
-					*optr++ = UU_DECODE_CHAR (iptr[0]) << 2 | UU_DECODE_CHAR (iptr[1]) >> 4; 
-				}
-				if (iEffLen >= 2)
-				{
-					*optr++ = UU_DECODE_CHAR (iptr[1]) << 4 | UU_DECODE_CHAR (iptr[2]) >> 2; 
-				}
-			}
-		}
-
-		return (unsigned int)(optr - buffer);
-	}
-
-	return 0;
-}
-
-bool UDecoder::Write(char* buffer, int len, FILE* outfile)
-{
-	unsigned int wcnt = DecodeBuffer(buffer, len);
-	if (wcnt > 0)
-	{
-		fwrite(buffer, 1, wcnt, outfile);
-	}
-	return true;
-}
-
-Decoder::EStatus UDecoder::Check()
-{
-	if (!m_bBody)
-	{
-		return eNoBinaryData;
-	}
-
-	return eFinished;
-}

daemon/nntp/Decoder.h

@@ -1,119 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
- *  Copyright (C) 2007-2008 Andrey Prygunkov <hugbug@users.sourceforge.net>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- * $Revision$
- * $Date$
- *
- */
-
-
-#ifndef DECODER_H
-#define DECODER_H
-
-class Decoder
-{
-public:
-	enum EStatus
-	{
-		eUnknownError,
-		eFinished,
-		eArticleIncomplete,
-		eCrcError,
-		eInvalidSize,
-		eNoBinaryData
-	};
-
-	enum EFormat
-	{
-		efUnknown,
-		efYenc,
-		efUx,
-	};
-
-	static const char* FormatNames[];
-
-protected:
-	const char*				m_szSrcFilename;
-	const char*				m_szDestFilename;
-	char*					m_szArticleFilename;
-
-public:
-							Decoder();
-	virtual					~Decoder();
-	virtual EStatus			Check() = 0;
-	virtual void			Clear();
-	virtual bool			Write(char* buffer, int len, FILE* outfile) = 0;
-	void					SetSrcFilename(const char* szSrcFilename) { m_szSrcFilename = szSrcFilename; }
-	void					SetDestFilename(const char* szDestFilename) { m_szDestFilename = szDestFilename; }
-	const char*				GetArticleFilename() { return m_szArticleFilename; }
-	static EFormat			DetectFormat(const char* buffer, int len);
-};
-
-class YDecoder: public Decoder
-{
-protected:
-	static unsigned int		crc_tab[256];
-	bool					m_bBegin;
-	bool					m_bPart;
-	bool					m_bBody;
-	bool					m_bEnd;
-	bool					m_bCrc;
-	unsigned long			m_lExpectedCRC;
-	unsigned long			m_lCalculatedCRC;
-	unsigned long			m_iBegin;
-	unsigned long			m_iEnd;
-	unsigned long			m_iSize;
-	unsigned long			m_iEndSize;
-	bool					m_bAutoSeek;
-	bool					m_bNeedSetPos;
-	bool					m_bCrcCheck;
-
-	unsigned int			DecodeBuffer(char* buffer);
-	static void				crc32gentab();
-	unsigned long			crc32m(unsigned long startCrc, unsigned char *block, unsigned int length);
-
-public:
-							YDecoder();
-	virtual EStatus			Check();
-	virtual void			Clear();
-	virtual bool			Write(char* buffer, int len, FILE* outfile);
-	void					SetAutoSeek(bool bAutoSeek) { m_bAutoSeek = m_bNeedSetPos = bAutoSeek; }
-	void					SetCrcCheck(bool bCrcCheck) { m_bCrcCheck = bCrcCheck; }
-
-	static void				Init();
-	static void				Final();
-};
-
-class UDecoder: public Decoder
-{
-private:
-	bool					m_bBody;
-	bool					m_bEnd;
-
-	unsigned int			DecodeBuffer(char* buffer, int len);
-
-public:
-							UDecoder();
-	virtual EStatus			Check();
-	virtual void			Clear();
-	virtual bool			Write(char* buffer, int len, FILE* outfile);
-};
-
-#endif

daemon/nntp/NNTPConnection.cpp

@@ -1,281 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
- *  Copyright (C) 2007-2013 Andrey Prygunkov <hugbug@users.sourceforge.net>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- * $Revision$
- * $Date$
- *
- */
-
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#ifdef WIN32
-#include "win32.h"
-#endif
-
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#include <ctype.h>
-
-#include "nzbget.h"
-#include "Log.h"
-#include "NNTPConnection.h"
-#include "Connection.h"
-#include "NewsServer.h"
-
-static const int CONNECTION_LINEBUFFER_SIZE = 1024*10;
-
-NNTPConnection::NNTPConnection(NewsServer* pNewsServer) : Connection(pNewsServer->GetHost(), pNewsServer->GetPort(), pNewsServer->GetTLS())
-{
-	m_pNewsServer = pNewsServer;
-	m_szActiveGroup = NULL;
-	m_szLineBuf = (char*)malloc(CONNECTION_LINEBUFFER_SIZE);
-	m_bAuthError = false;
-	SetCipher(pNewsServer->GetCipher());
-}
-
-NNTPConnection::~NNTPConnection()
-{
-	free(m_szActiveGroup);
-	free(m_szLineBuf);
-}
-
-const char* NNTPConnection::Request(const char* req)
-{
-	if (!req)
-	{
-		return NULL;
-	}
-
-	m_bAuthError = false;
-
-	WriteLine(req);
-
-	char* answer = ReadLine(m_szLineBuf, CONNECTION_LINEBUFFER_SIZE, NULL);
-
-	if (!answer)
-	{
-		return NULL;
-	}
-
-	if (!strncmp(answer, "480", 3))
-	{
-		debug("%s requested authorization", GetHost());
-
-		if (!Authenticate())
-		{
-			return NULL;
-		}
-
-		//try again
-		WriteLine(req);
-		answer = ReadLine(m_szLineBuf, CONNECTION_LINEBUFFER_SIZE, NULL);
-	}
-
-	return answer;
-}
-
-bool NNTPConnection::Authenticate()
-{
-	if (strlen(m_pNewsServer->GetUser()) == 0 || strlen(m_pNewsServer->GetPassword()) == 0)
-	{
-		error("%c%s (%s) requested authorization but username/password are not set in settings", 
-			toupper(m_pNewsServer->GetName()[0]), m_pNewsServer->GetName() + 1, m_pNewsServer->GetHost());
-		m_bAuthError = true;
-		return false;
-	}
-
-	m_bAuthError = !AuthInfoUser(0);
-	return !m_bAuthError;
-}
-
-bool NNTPConnection::AuthInfoUser(int iRecur)
-{
-	if (iRecur > 10)
-	{
-		return false;
-	}
-
-	char tmp[1024];
-	snprintf(tmp, 1024, "AUTHINFO USER %s\r\n", m_pNewsServer->GetUser());
-	tmp[1024-1] = '\0';
-
-	WriteLine(tmp);
-
-	char* answer = ReadLine(m_szLineBuf, CONNECTION_LINEBUFFER_SIZE, NULL);
-	if (!answer)
-	{
-		ReportErrorAnswer("Authorization for server%i (%s) failed: Connection closed by remote host", NULL);
-		return false;
-	}
-
-	if (!strncmp(answer, "281", 3))
-	{
-		debug("Authorization for %s successful", GetHost());
-		return true;
-	}
-	else if (!strncmp(answer, "381", 3))
-	{
-		return AuthInfoPass(++iRecur);
-	}
-	else if (!strncmp(answer, "480", 3))
-	{
-		return AuthInfoUser(++iRecur);
-	}
-
-	if (char* p = strrchr(answer, '\r')) *p = '\0'; // remove last CRLF from error message
-
-	if (GetStatus() != csCancelled)
-	{
-		ReportErrorAnswer("Authorization for server%i (%s) failed (Answer: %s)", answer);
-	}
-	return false;
-}
-
-bool NNTPConnection::AuthInfoPass(int iRecur)
-{
-	if (iRecur > 10)
-	{
-		return false;
-	}
-
-	char tmp[1024];
-	snprintf(tmp, 1024, "AUTHINFO PASS %s\r\n", m_pNewsServer->GetPassword());
-	tmp[1024-1] = '\0';
-
-	WriteLine(tmp);
-
-	char* answer = ReadLine(m_szLineBuf, CONNECTION_LINEBUFFER_SIZE, NULL);
-	if (!answer)
-	{
-		ReportErrorAnswer("Authorization for server%i (%s) failed: Connection closed by remote host", NULL);
-		return false;
-	}
-	else if (!strncmp(answer, "2", 1))
-	{
-		debug("Authorization for %s successful", GetHost());
-		return true;
-	}
-	else if (!strncmp(answer, "381", 3))
-	{
-		return AuthInfoPass(++iRecur);
-	}
-
-	if (char* p = strrchr(answer, '\r')) *p = '\0'; // remove last CRLF from error message
-
-	if (GetStatus() != csCancelled)
-	{
-		ReportErrorAnswer("Authorization for server%i (%s) failed (Answer: %s)", answer);
-	}
-	return false;
-}
-
-const char* NNTPConnection::JoinGroup(const char* grp)
-{
-	if (m_szActiveGroup && !strcmp(m_szActiveGroup, grp))
-	{
-		// already in group
-		strcpy(m_szLineBuf, "211 ");
-		return m_szLineBuf;
-	}
-
-	char tmp[1024];
-	snprintf(tmp, 1024, "GROUP %s\r\n", grp);
-	tmp[1024-1] = '\0';
-
-	const char* answer = Request(tmp);
-
-	if (answer && !strncmp(answer, "2", 1))
-	{
-		debug("Changed group to %s on %s", grp, GetHost());
-		free(m_szActiveGroup);
-		m_szActiveGroup = strdup(grp);
-	}
-	else
-	{
-		debug("Error changing group on %s to %s: %s.", GetHost(), grp, answer);
-	}
-
-	return answer;
-}
-
-bool NNTPConnection::Connect()
-{
-	debug("Opening connection to %s", GetHost());
-
-	if (m_eStatus == csConnected)
-	{
-		return true;
-	}
-
-	if (!Connection::Connect())
-	{
-		return false;
-	}
-
-	char* answer = ReadLine(m_szLineBuf, CONNECTION_LINEBUFFER_SIZE, NULL);
-
-	if (!answer)
-	{
-		ReportErrorAnswer("Connection to server%i (%s) failed: Connection closed by remote host", NULL);
-		Disconnect();
-		return false;
-	}
-
-	if (strncmp(answer, "2", 1))
-	{
-		ReportErrorAnswer("Connection to server%i (%s) failed (Answer: %s)", answer);
-		Disconnect();
-		return false;
-	}
-
-	if ((strlen(m_pNewsServer->GetUser()) > 0 && strlen(m_pNewsServer->GetPassword()) > 0) &&
-		!Authenticate())
-	{
-		return false;
-	}
-
-	debug("Connection to %s established", GetHost());
-
-	return true;
-}
-
-bool NNTPConnection::Disconnect()
-{
-	if (m_eStatus == csConnected)
-	{
-		Request("quit\r\n");
-		free(m_szActiveGroup);
-		m_szActiveGroup = NULL;
-	}
-	return Connection::Disconnect();
-}
-
-void NNTPConnection::ReportErrorAnswer(const char* szMsgPrefix, const char* szAnswer)
-{
-	char szErrStr[1024];
-	snprintf(szErrStr, 1024, szMsgPrefix, m_pNewsServer->GetID(), m_pNewsServer->GetHost(), szAnswer);
-	szErrStr[1024-1] = '\0';
-	
-	ReportError(szErrStr, NULL, false, 0);
-}

daemon/nntp/NNTPConnection.h

@@ -1,59 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
- *  Copyright (C) 2007-2008 Andrey Prygunkov <hugbug@users.sourceforge.net>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- * $Revision$
- * $Date$
- *
- */
-
-
-#ifndef NNTPCONNECTION_H
-#define NNTPCONNECTION_H
-
-#include "NewsServer.h"
-#include "Connection.h"
-
-class NNTPConnection : public Connection
-{
-private:
-	NewsServer*			m_pNewsServer;
-	char* 				m_szActiveGroup;
-	char*				m_szLineBuf;
-	bool				m_bAuthError;
-
-	void				Clear();
-	void				ReportErrorAnswer(const char* szMsgPrefix, const char* szAnswer);
-	bool 				Authenticate();
-	bool 				AuthInfoUser(int iRecur);
-	bool 				AuthInfoPass(int iRecur);
-
-public:
-						NNTPConnection(NewsServer* pNewsServer);
-	virtual				~NNTPConnection();
-	virtual bool 		Connect();
-	virtual bool		Disconnect();
-	NewsServer*			GetNewsServer() { return m_pNewsServer; }
-	const char* 		Request(const char* req);
-	const char*			JoinGroup(const char* grp);
-	bool				GetAuthError() { return m_bAuthError; }
-};
-
-#endif
-

daemon/nntp/NewsServer.cpp

@@ -1,80 +0,0 @@
-/*
- *  This file if part of nzbget
- *
- *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
- *  Copyright (C) 2007-2013 Andrey Prygunkov <hugbug@users.sourceforge.net>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- * $Revision$
- * $Date$
- *
- */
-
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#ifdef WIN32
-#include "win32.h"
-#endif
-
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-
-#include "nzbget.h"
-#include "NewsServer.h"
-
-NewsServer::NewsServer(int iID, bool bActive, const char* szName, const char* szHost, int iPort,
-	const char* szUser, const char* szPass, bool bJoinGroup, bool bTLS,
-	const char* szCipher, int iMaxConnections, int iLevel, int iGroup)
-{
-	m_iID = iID;
-	m_iStateID = 0;
-	m_bActive = bActive;
-	m_iPort = iPort;
-	m_iLevel = iLevel;
-	m_iNormLevel = iLevel;
-	m_iGroup = iGroup;
-	m_iMaxConnections = iMaxConnections;
-	m_bJoinGroup = bJoinGroup;
-	m_bTLS = bTLS;
-	m_szHost = strdup(szHost ? szHost : "");
-	m_szUser = strdup(szUser ? szUser : "");
-	m_szPassword = strdup(szPass ? szPass : "");
-	m_szCipher = strdup(szCipher ? szCipher : "");
-
-	if (szName && strlen(szName) > 0)
-	{
-		m_szName = strdup(szName);
-	}
-	else
-	{
-		m_szName = (char*)malloc(20);
-		snprintf(m_szName, 20, "server%i", iID);
-		m_szName[20-1] = '\0';
-	}
-}
-
-NewsServer::~NewsServer()
-{
-	free(m_szName);
-	free(m_szHost);
-	free(m_szUser);
-	free(m_szPassword);
-	free(m_szCipher);
-}

daemon/nntp/NewsServer.h

@@ -1,78 +0,0 @@
-/*
- *  This file if part of nzbget
- *
- *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
- *  Copyright (C) 2007-2013 Andrey Prygunkov <hugbug@users.sourceforge.net>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- * $Revision$
- * $Date$
- *
- */
-
-
-#ifndef NEWSSERVER_H
-#define NEWSSERVER_H
-
-#include <vector>
-
-class NewsServer
-{
-private:
-	int				m_iID;
-	int				m_iStateID;
-	bool			m_bActive;
-	char*			m_szName;
-	int				m_iGroup;
-	char*			m_szHost;
-	int				m_iPort;
-	char*			m_szUser;
-	char*			m_szPassword;
-	int				m_iMaxConnections;
-	int				m_iLevel;
-	int				m_iNormLevel;
-	bool			m_bJoinGroup;
-	bool			m_bTLS;
-	char*			m_szCipher;
-
-public:
-					NewsServer(int iID, bool bActive, const char* szName, const char* szHost, int iPort,
-						const char* szUser, const char* szPass, bool bJoinGroup,
-						bool bTLS, const char* szCipher, int iMaxConnections, int iLevel, int iGroup);
-					~NewsServer();
-	int				GetID() { return m_iID; }
-	int				GetStateID() { return m_iStateID; }
-	void			SetStateID(int iStateID) { m_iStateID = iStateID; }
-	bool			GetActive() { return m_bActive; }
-	void			SetActive(bool bActive) { m_bActive = bActive; }
-	const char*		GetName() { return m_szName; }
-	int				GetGroup() { return m_iGroup; }
-	const char*		GetHost() { return m_szHost; }
-	int				GetPort() { return m_iPort; }
-	const char*		GetUser() { return m_szUser; }
-	const char*		GetPassword() { return m_szPassword; }
-	int				GetMaxConnections() { return m_iMaxConnections; }
-	int				GetLevel() { return m_iLevel; }
-	int				GetNormLevel() { return m_iNormLevel; }
-	void			SetNormLevel(int iLevel) { m_iNormLevel = iLevel; }
-	int				GetJoinGroup() { return m_bJoinGroup; }
-	bool			GetTLS() { return m_bTLS; }
-	const char*		GetCipher() { return m_szCipher; }
-};
-
-typedef std::vector<NewsServer*>		Servers;
-
-#endif

daemon/nntp/ServerPool.cpp

@@ -1,366 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
- *  Copyright (C) 2007-2014 Andrey Prygunkov <hugbug@users.sourceforge.net>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- * $Revision$
- * $Date$
- *
- */
-
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#ifdef WIN32
-#include "win32.h"
-#endif
-
-#include <stdlib.h>
-#include <string.h>
-#ifndef WIN32
-#include <unistd.h>
-#include <errno.h>
-#endif
-#include <algorithm>
-
-#include "nzbget.h"
-#include "ServerPool.h"
-
-static const int CONNECTION_HOLD_SECODNS = 5;
-
-ServerPool::PooledConnection::PooledConnection(NewsServer* server) : NNTPConnection(server)
-{
-	m_bInUse = false;
-	m_tFreeTime = 0;
-}
-
-ServerPool::ServerPool()
-{
-	debug("Creating ServerPool");
-
-	m_iMaxNormLevel = 0;
-	m_iTimeout = 60;
-	m_iGeneration = 0;
-
-	g_pLog->RegisterDebuggable(this);
-}
-
-ServerPool::~ ServerPool()
-{
-	debug("Destroying ServerPool");
-
-	g_pLog->UnregisterDebuggable(this);
-
-	m_Levels.clear();
-
-	for (Servers::iterator it = m_Servers.begin(); it != m_Servers.end(); it++)
-	{
-		delete *it;
-	}
-	m_Servers.clear();
-	m_SortedServers.clear();
-
-	for (Connections::iterator it = m_Connections.begin(); it != m_Connections.end(); it++)
-	{
-		delete *it;
-	}
-	m_Connections.clear();
-}
-
-void ServerPool::AddServer(NewsServer* pNewsServer)
-{
-	debug("Adding server to ServerPool");
-
-	m_Servers.push_back(pNewsServer);
-	m_SortedServers.push_back(pNewsServer);
-}
-
-/*
- * Calculate normalized levels for all servers.
- * Normalized Level means: starting from 0 with step 1.
- * The servers of minimum Level must be always used even if they are not active;
- * this is to prevent backup servers to act as main servers.
-**/
-void ServerPool::NormalizeLevels()
-{
-	if (m_Servers.empty())
-	{
-		return;
-	}
-
-	std::sort(m_SortedServers.begin(), m_SortedServers.end(), CompareServers);
-
-	// find minimum level
-	int iMinLevel = m_SortedServers.front()->GetLevel();
-	for (Servers::iterator it = m_SortedServers.begin(); it != m_SortedServers.end(); it++)
-	{
-		NewsServer* pNewsServer = *it;
-		if (pNewsServer->GetLevel() < iMinLevel)
-		{
-			iMinLevel = pNewsServer->GetLevel();
-		}
-	}
-
-	m_iMaxNormLevel = 0;
-	int iLastLevel = iMinLevel;
-	for (Servers::iterator it = m_SortedServers.begin(); it != m_SortedServers.end(); it++)
-	{
-		NewsServer* pNewsServer = *it;
-		if ((pNewsServer->GetActive() && pNewsServer->GetMaxConnections() > 0) ||
-			(pNewsServer->GetLevel() == iMinLevel))
-		{
-			if (pNewsServer->GetLevel() != iLastLevel)
-			{
-				m_iMaxNormLevel++;
-			}
-			pNewsServer->SetNormLevel(m_iMaxNormLevel);
-			iLastLevel = pNewsServer->GetLevel();
-		}
-		else
-		{
-			pNewsServer->SetNormLevel(-1);
-		}
-	}
-}
-
-bool ServerPool::CompareServers(NewsServer* pServer1, NewsServer* pServer2)
-{
-	return pServer1->GetLevel() < pServer2->GetLevel();
-}
-
-void ServerPool::InitConnections()
-{
-	debug("Initializing connections in ServerPool");
-
-	m_mutexConnections.Lock();
-
-	NormalizeLevels();
-	m_Levels.clear();
-
-	for (Servers::iterator it = m_SortedServers.begin(); it != m_SortedServers.end(); it++)
-	{
-		NewsServer* pNewsServer = *it;
-		int iNormLevel = pNewsServer->GetNormLevel();
-		if (pNewsServer->GetNormLevel() > -1)
-		{
-			if ((int)m_Levels.size() <= iNormLevel)
-			{
-				m_Levels.push_back(0);
-			}
-
-			if (pNewsServer->GetActive())
-			{
-				int iConnections = 0;
-				
-				for (Connections::iterator it = m_Connections.begin(); it != m_Connections.end(); it++)
-				{
-					PooledConnection* pConnection = *it;
-					if (pConnection->GetNewsServer() == pNewsServer)
-					{
-						iConnections++;
-					}
-				}
-				
-				for (int i = iConnections; i < pNewsServer->GetMaxConnections(); i++)
-				{
-					PooledConnection* pConnection = new PooledConnection(pNewsServer);
-					pConnection->SetTimeout(m_iTimeout);
-					m_Connections.push_back(pConnection);
-					iConnections++;
-				}
-
-				m_Levels[iNormLevel] += iConnections;
-			}
-		}
-	}
-
-	m_iGeneration++;
-
-	m_mutexConnections.Unlock();
-}
-
-NNTPConnection* ServerPool::GetConnection(int iLevel, NewsServer* pWantServer, Servers* pIgnoreServers)
-{
-	PooledConnection* pConnection = NULL;
-
-	m_mutexConnections.Lock();
-
-	if (iLevel < (int)m_Levels.size() && m_Levels[iLevel] > 0)
-	{
-		for (Connections::iterator it = m_Connections.begin(); it != m_Connections.end(); it++)
-		{
-			PooledConnection* pCandidateConnection = *it;
-			NewsServer* pCandidateServer = pCandidateConnection->GetNewsServer();
-			if (!pCandidateConnection->GetInUse() && pCandidateServer->GetActive() &&
-				pCandidateServer->GetNormLevel() == iLevel && 
-				(!pWantServer || pCandidateServer == pWantServer ||
-				 (pWantServer->GetGroup() > 0 && pWantServer->GetGroup() == pCandidateServer->GetGroup())))
-			{
-				// free connection found, check if it's not from the server which should be ignored
-				bool bUseConnection = true;
-				if (pIgnoreServers && !pWantServer)
-				{
-					for (Servers::iterator it = pIgnoreServers->begin(); it != pIgnoreServers->end(); it++)
-					{
-						NewsServer* pIgnoreServer = *it;
-						if (pIgnoreServer == pCandidateServer ||
-							(pIgnoreServer->GetGroup() > 0 && pIgnoreServer->GetGroup() == pCandidateServer->GetGroup() &&
-							 pIgnoreServer->GetNormLevel() == pCandidateServer->GetNormLevel()))
-						{
-							bUseConnection = false;
-							break;
-						}
-					}
-				}
-
-				if (bUseConnection)
-				{
-					pConnection = pCandidateConnection;
-					pConnection->SetInUse(true);
-					break;
-				}
-			}
-		}
-
-		if (pConnection)
-		{
-			m_Levels[iLevel]--;
-		}
-	}
-
-	m_mutexConnections.Unlock();
-
-	return pConnection;
-}
-
-void ServerPool::FreeConnection(NNTPConnection* pConnection, bool bUsed)
-{
-	if (bUsed)
-	{
-		debug("Freeing used connection");
-	}
-
-	m_mutexConnections.Lock();
-
-	((PooledConnection*)pConnection)->SetInUse(false);
-	if (bUsed)
-	{
-		((PooledConnection*)pConnection)->SetFreeTimeNow();
-	}
-
-	if (pConnection->GetNewsServer()->GetNormLevel() > -1 && pConnection->GetNewsServer()->GetActive())
-	{
-		m_Levels[pConnection->GetNewsServer()->GetNormLevel()]++;
-	}
-
-	m_mutexConnections.Unlock();
-}
-
-void ServerPool::CloseUnusedConnections()
-{
-	m_mutexConnections.Lock();
-
-	time_t curtime = ::time(NULL);
-
-	int i = 0;
-	for (Connections::iterator it = m_Connections.begin(); it != m_Connections.end(); )
-	{
-		PooledConnection* pConnection = *it;
-		bool bDeleted = false;
-
-		if (!pConnection->GetInUse() &&
-			(pConnection->GetNewsServer()->GetNormLevel() == -1 ||
-			 !pConnection->GetNewsServer()->GetActive()))
-		{
-			debug("Closing (and deleting) unused connection to server%i", pConnection->GetNewsServer()->GetID());
-			if (pConnection->GetStatus() == Connection::csConnected)
-			{
-				pConnection->Disconnect();
-			}
-			delete pConnection;
-			m_Connections.erase(it);
-			it = m_Connections.begin() + i;
-			bDeleted = true;
-		}
-
-		if (!bDeleted && !pConnection->GetInUse() && pConnection->GetStatus() == Connection::csConnected)
-		{
-			int tdiff = (int)(curtime - pConnection->GetFreeTime());
-			if (tdiff > CONNECTION_HOLD_SECODNS)
-			{
-				debug("Closing (and keeping) unused connection to server%i", pConnection->GetNewsServer()->GetID());
-				pConnection->Disconnect();
-			}
-		}
-
-		if (!bDeleted)
-		{
-			it++;
-			i++;
-		}
-	}
-
-	m_mutexConnections.Unlock();
-}
-
-void ServerPool::Changed()
-{
-	debug("Server config has been changed");
-
-	InitConnections();
-	CloseUnusedConnections();
-}
-
-void ServerPool::LogDebugInfo()
-{
-	info("   ---------- ServerPool");
-
-	info("    Max-Level: %i", m_iMaxNormLevel);
-
-	m_mutexConnections.Lock();
-
-	info("    Servers: %i", m_Servers.size());
-	for (Servers::iterator it = m_Servers.begin(); it != m_Servers.end(); it++)
-	{
-		NewsServer*  pNewsServer = *it;
-		info("      %i) %s (%s): Level=%i, NormLevel=%i", pNewsServer->GetID(), pNewsServer->GetName(),
-			pNewsServer->GetHost(), pNewsServer->GetLevel(), pNewsServer->GetNormLevel());
-	}
-
-	info("    Levels: %i", m_Levels.size());
-	int index = 0;
-	for (Levels::iterator it = m_Levels.begin(); it != m_Levels.end(); it++, index++)
-	{
-		int  iSize = *it;
-		info("      %i: Free connections=%i", index, iSize);
-	}
-
-	info("    Connections: %i", m_Connections.size());
-	for (Connections::iterator it = m_Connections.begin(); it != m_Connections.end(); it++)
-	{
-		PooledConnection*  pConnection = *it;
-		info("      %i) %s (%s): Level=%i, NormLevel=%i, InUse:%i", pConnection->GetNewsServer()->GetID(),
-			pConnection->GetNewsServer()->GetName(), pConnection->GetNewsServer()->GetHost(),
-			pConnection->GetNewsServer()->GetLevel(), pConnection->GetNewsServer()->GetNormLevel(),
-			(int)pConnection->GetInUse());
-	}
-
-	m_mutexConnections.Unlock();
-}

daemon/nntp/ServerPool.h

@@ -1,87 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
- *  Copyright (C) 2007-2013 Andrey Prygunkov <hugbug@users.sourceforge.net>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- * $Revision$
- * $Date$
- *
- */
-
-
-#ifndef SERVERPOOL_H
-#define SERVERPOOL_H
-
-#include <vector>
-#include <time.h>
-
-#include "Log.h"
-#include "Thread.h"
-#include "NewsServer.h"
-#include "NNTPConnection.h"
-
-class ServerPool : public Debuggable
-{
-private:
-	class PooledConnection : public NNTPConnection
-	{
-	private:
-		bool			m_bInUse;
-		time_t			m_tFreeTime;
-	public:
-						PooledConnection(NewsServer* server);
-		bool			GetInUse() { return m_bInUse; }
-		void			SetInUse(bool bInUse) { m_bInUse = bInUse; }
-		time_t			GetFreeTime() { return m_tFreeTime; }
-		void			SetFreeTimeNow() { m_tFreeTime = ::time(NULL); }
-	};
-
-	typedef std::vector<int>				Levels;
-	typedef std::vector<PooledConnection*>	Connections;
-
-	Servers				m_Servers;
-	Servers				m_SortedServers;
-	Connections			m_Connections;
-	Levels				m_Levels;
-	int					m_iMaxNormLevel;
-	Mutex			 	m_mutexConnections;
-	int					m_iTimeout;
-	int					m_iGeneration;
-
-	void				NormalizeLevels();
-	static bool			CompareServers(NewsServer* pServer1, NewsServer* pServer2);
-
-protected:
-	virtual void			LogDebugInfo();
-
-public:
-						ServerPool();
-						~ServerPool();
-	void				SetTimeout(int iTimeout) { m_iTimeout = iTimeout; }
-	void 				AddServer(NewsServer* pNewsServer);
-	void				InitConnections();
-	int					GetMaxNormLevel() { return m_iMaxNormLevel; }
-	Servers*			GetServers() { return &m_Servers; } // Only for read access (no lockings)
-	NNTPConnection*		GetConnection(int iLevel, NewsServer* pWantServer, Servers* pIgnoreServers);
-	void 				FreeConnection(NNTPConnection* pConnection, bool bUsed);
-	void				CloseUnusedConnections();
-	void				Changed();
-	int					GetGeneration() { return m_iGeneration; }
-};
-
-#endif

daemon/nntp/StatMeter.cpp

@@ -1,546 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2014 Andrey Prygunkov <hugbug@users.sourceforge.net>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- * $Revision$
- * $Date$
- *
- */
-
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#ifdef WIN32
-#include "win32.h"
-#endif
-
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-
-#include "nzbget.h"
-#include "StatMeter.h"
-#include "Options.h"
-#include "ServerPool.h"
-#include "DiskState.h"
-
-extern ServerPool* g_pServerPool;
-extern Options* g_pOptions;
-extern DiskState* g_pDiskState;
-
-static const int DAYS_UP_TO_2013_JAN_1 = 15706;
-static const int DAYS_IN_TWENTY_YEARS = 366*20;
-
-ServerVolume::ServerVolume()
-{
-	m_BytesPerSeconds.resize(60);
-	m_BytesPerMinutes.resize(60);
-	m_BytesPerHours.resize(24);
-	m_BytesPerDays.resize(0);
-	m_iFirstDay = 0;
-	m_tDataTime = 0;
-	m_lTotalBytes = 0;
-	m_lCustomBytes = 0;
-	m_tCustomTime = time(NULL);
-	m_iSecSlot = 0;
-	m_iMinSlot = 0;
-	m_iHourSlot = 0;
-	m_iDaySlot = 0;
-}
-
-void ServerVolume::CalcSlots(time_t tLocCurTime)
-{
-	m_iSecSlot = (int)tLocCurTime % 60;
-	m_iMinSlot = ((int)tLocCurTime / 60) % 60;
-	m_iHourSlot = ((int)tLocCurTime % 86400) / 3600;
-	int iDaysSince1970 = (int)tLocCurTime / 86400;
-	m_iDaySlot = iDaysSince1970 - DAYS_UP_TO_2013_JAN_1 + 1;
-	if (0 <= m_iDaySlot && m_iDaySlot < DAYS_IN_TWENTY_YEARS)
-	{
-		int iCurDay = iDaysSince1970;
-		if (m_iFirstDay == 0 || m_iFirstDay > iCurDay)
-		{
-			m_iFirstDay = iCurDay;
-		}
-		m_iDaySlot = iCurDay - m_iFirstDay;
-		if (m_iDaySlot + 1 > (int)m_BytesPerDays.size())
-		{
-			m_BytesPerDays.resize(m_iDaySlot + 1);
-		}
-	}
-	else
-	{
-		m_iDaySlot = -1;
-	}
-}
-
-void ServerVolume::AddData(int iBytes)
-{
-	time_t tCurTime = time(NULL);
-	time_t tLocCurTime = tCurTime + g_pOptions->GetLocalTimeOffset();
-	time_t tLocDataTime = m_tDataTime + g_pOptions->GetLocalTimeOffset();
-
-	int iLastMinSlot = m_iMinSlot;
-	int iLastHourSlot = m_iHourSlot;
-
-	CalcSlots(tLocCurTime);
-
-	if (tLocCurTime != tLocDataTime)
-	{
-		// clear seconds/minutes/hours slots if necessary
-		// also handle the backwards changes of system clock
-
-		int iTotalDelta = (int)(tLocCurTime - tLocDataTime);
-		int iDeltaSign = iTotalDelta >= 0 ? 1 : -1;
-		iTotalDelta = abs(iTotalDelta);
-
-		int iSecDelta = iTotalDelta;
-		if (iDeltaSign < 0) iSecDelta++;
-		if (iSecDelta >= 60) iSecDelta = 60;
-		for (int i = 0; i < iSecDelta; i++)
-		{
-			int iNulSlot = m_iSecSlot - i * iDeltaSign;
-			if (iNulSlot < 0) iNulSlot += 60;
-			if (iNulSlot >= 60) iNulSlot -= 60;
-			m_BytesPerSeconds[iNulSlot] = 0;
-		}
-
-		int iMinDelta = iTotalDelta / 60;
-		if (iDeltaSign < 0) iMinDelta++;
-		if (abs(iMinDelta) >= 60) iMinDelta = 60;
-		if (iMinDelta == 0 && m_iMinSlot != iLastMinSlot) iMinDelta = 1;
-		for (int i = 0; i < iMinDelta; i++)
-		{
-			int iNulSlot = m_iMinSlot - i * iDeltaSign;
-			if (iNulSlot < 0) iNulSlot += 60;
-			if (iNulSlot >= 60) iNulSlot -= 60;
-			m_BytesPerMinutes[iNulSlot] = 0;
-		}
-
-		int iHourDelta = iTotalDelta / (60 * 60);
-		if (iDeltaSign < 0) iHourDelta++;
-		if (iHourDelta >= 24) iHourDelta = 24;
-		if (iHourDelta == 0 && m_iHourSlot != iLastHourSlot) iHourDelta = 1;
-		for (int i = 0; i < iHourDelta; i++)
-		{
-			int iNulSlot = m_iHourSlot - i * iDeltaSign;
-			if (iNulSlot < 0) iNulSlot += 24;
-			if (iNulSlot >= 24) iNulSlot -= 24;
-			m_BytesPerHours[iNulSlot] = 0;
-		}
-	}
-
-	// add bytes to every slot
-	m_BytesPerSeconds[m_iSecSlot] += iBytes;
-	m_BytesPerMinutes[m_iMinSlot] += iBytes;
-	m_BytesPerHours[m_iHourSlot] += iBytes;
-	if (m_iDaySlot >= 0)
-	{
-		m_BytesPerDays[m_iDaySlot] += iBytes;
-	}
-	m_lTotalBytes += iBytes;
-	m_lCustomBytes += iBytes;
-
-	m_tDataTime = tCurTime;
-}
-
-void ServerVolume::ResetCustom()
-{
-	m_lCustomBytes = 0;
-	m_tCustomTime = time(NULL);
-}
-
-void ServerVolume::LogDebugInfo()
-{
-	info("   ---------- ServerVolume");
-
-	char szSec[4000];
-
-	szSec[0] = '\0';
-	for (int i = 0; i < 60; i++)
-	{
-		char szNum[20];
-		snprintf(szNum, 20, "[%i]=%lli ", i, m_BytesPerSeconds[i]);
-		strncat(szSec, szNum, 4000);
-	}
-	info("Secs: %s", szSec);
-
-	szSec[0] = '\0';
-	for (int i = 0; i < 60; i++)
-	{
-		char szNum[20];
-		snprintf(szNum, 20, "[%i]=%lli ", i, m_BytesPerMinutes[i]);
-		strncat(szSec, szNum, 4000);
-	}
-	info("Mins: %s", szSec);
-
-	szSec[0] = '\0';
-	for (int i = 0; i < 24; i++)
-	{
-		char szNum[20];
-		snprintf(szNum, 20, "[%i]=%lli ", i, m_BytesPerHours[i]);
-		strncat(szSec, szNum, 4000);
-	}
-	info("Hours: %s", szSec);
-
-	szSec[0] = '\0';
-	for (int i = 0; i < (int)m_BytesPerDays.size(); i++)
-	{
-		char szNum[20];
-		snprintf(szNum, 20, "[%i]=%lli ", m_iFirstDay + i, m_BytesPerDays[i]);
-		strncat(szSec, szNum, 4000);
-	}
-	info("Days: %s", szSec);
-}
-
-StatMeter::StatMeter()
-{
-	debug("Creating StatMeter");
-
-	ResetSpeedStat();
-
-	m_iAllBytes = 0;
-	m_tStartDownload = 0;
-	m_tPausedFrom = 0;
-	m_bStandBy = true;
-	m_tStartServer = 0;
-	m_tLastCheck = 0;
-	m_tLastTimeOffset = 0;
-	m_bStatChanged = false;
-
-	g_pLog->RegisterDebuggable(this);
-}
-
-StatMeter::~StatMeter()
-{
-	debug("Destroying StatMeter");
-	// Cleanup
-
-	g_pLog->UnregisterDebuggable(this);
-
-	for (ServerVolumes::iterator it = m_ServerVolumes.begin(); it != m_ServerVolumes.end(); it++)
-	{
-		delete *it;
-	}
-
-	debug("StatMeter destroyed");
-}
-
-void StatMeter::Init()
-{
-	m_tStartServer = time(NULL);
-	m_tLastCheck = m_tStartServer;
-	AdjustTimeOffset();
-
-	m_ServerVolumes.resize(1 + g_pServerPool->GetServers()->size());
-	m_ServerVolumes[0] = new ServerVolume();
-	for (Servers::iterator it = g_pServerPool->GetServers()->begin(); it != g_pServerPool->GetServers()->end(); it++)
-	{
-		NewsServer* pServer = *it;
-		m_ServerVolumes[pServer->GetID()] = new ServerVolume();
-	}
-}
-
-void StatMeter::AdjustTimeOffset()
-{
-	time_t tUtcTime = time(NULL);
-	tm tmSplittedTime;
-	gmtime_r(&tUtcTime, &tmSplittedTime);
-	tmSplittedTime.tm_isdst = -1;
-	time_t tLocTime = mktime(&tmSplittedTime);
-	time_t tLocalTimeDelta = tUtcTime - tLocTime;
-	g_pOptions->SetLocalTimeOffset((int)tLocalTimeDelta + g_pOptions->GetTimeCorrection());
-	m_tLastTimeOffset = tUtcTime;
-
-	debug("UTC delta: %i (%i+%i)", g_pOptions->GetLocalTimeOffset(), (int)tLocalTimeDelta, g_pOptions->GetTimeCorrection());
-}
-
-/*
- * Called once per second.
- *  - detect large step changes of system time and adjust statistics;
- *  - save volume stats (if changed).
- */
-void StatMeter::IntervalCheck()
-{
-	time_t m_tCurTime = time(NULL);
-	time_t tDiff = m_tCurTime - m_tLastCheck;
-	if (tDiff > 60 || tDiff < 0)
-	{
-		m_tStartServer += tDiff + 1; // "1" because the method is called once per second
-		if (m_tStartDownload != 0 && !m_bStandBy)
-		{
-			m_tStartDownload += tDiff + 1;
-		}
-		AdjustTimeOffset();
-	}
-	else if (m_tLastTimeOffset > m_tCurTime ||
-		m_tCurTime - m_tLastTimeOffset > 60 * 60 * 3 ||
-		(m_tCurTime - m_tLastTimeOffset > 60 && !m_bStandBy))
-	{
-		// checking time zone settings may prevent the device from entering sleep/hibernate mode
-		// check every minute if not in standby
-		// check at least every 3 hours even in standby
-		AdjustTimeOffset();
-	}
-
-	m_tLastCheck = m_tCurTime;
-
-	if (m_bStatChanged)
-	{
-		Save();
-	}
-}
-
-void StatMeter::EnterLeaveStandBy(bool bEnter)
-{
-	m_mutexStat.Lock();
-	m_bStandBy = bEnter;
-	if (bEnter)
-	{
-		m_tPausedFrom = time(NULL);
-	}
-	else
-	{
-		if (m_tStartDownload == 0)
-		{
-			m_tStartDownload = time(NULL);
-		}
-		else
-		{
-			m_tStartDownload += time(NULL) - m_tPausedFrom;
-		}
-		m_tPausedFrom = 0;
-		ResetSpeedStat();
-	}
-	m_mutexStat.Unlock();
-}
-
-void StatMeter::CalcTotalStat(int* iUpTimeSec, int* iDnTimeSec, long long* iAllBytes, bool* bStandBy)
-{
-	m_mutexStat.Lock();
-	if (m_tStartServer > 0)
-	{
-		*iUpTimeSec = (int)(time(NULL) - m_tStartServer);
-	}
-	else
-	{
-		*iUpTimeSec = 0;
-	}
-	*bStandBy = m_bStandBy;
-	if (m_bStandBy)
-	{
-		*iDnTimeSec = (int)(m_tPausedFrom - m_tStartDownload);
-	}
-	else
-	{
-		*iDnTimeSec = (int)(time(NULL) - m_tStartDownload);
-	}
-	*iAllBytes = m_iAllBytes;
-	m_mutexStat.Unlock();
-}
-
-/*
- * NOTE: see note to "AddSpeedReading"
- */
-int StatMeter::CalcCurrentDownloadSpeed()
-{
-	if (m_bStandBy)
-	{
-		return 0;
-	}
-
-	int iTimeDiff = (int)time(NULL) - m_iSpeedStartTime * SPEEDMETER_SLOTSIZE;
-	if (iTimeDiff == 0)
-	{
-		return 0;
-	}
-
-	return (int)(m_iSpeedTotalBytes / iTimeDiff);
-}
-
-void StatMeter::AddSpeedReading(int iBytes)
-{
-	time_t tCurTime = time(NULL);
-	int iNowSlot = (int)tCurTime / SPEEDMETER_SLOTSIZE;
-
-	if (g_pOptions->GetAccurateRate())
-	{
-#ifdef HAVE_SPINLOCK
-		m_spinlockSpeed.Lock();
-#else
-		m_mutexSpeed.Lock();
-#endif
-	}
-
-	while (iNowSlot > m_iSpeedTime[m_iSpeedBytesIndex])
-	{
-		//record bytes in next slot
-		m_iSpeedBytesIndex++;
-		if (m_iSpeedBytesIndex >= SPEEDMETER_SLOTS)
-		{
-			m_iSpeedBytesIndex = 0;
-		}
-		//Adjust counters with outgoing information.
-		m_iSpeedTotalBytes = m_iSpeedTotalBytes - (long long)m_iSpeedBytes[m_iSpeedBytesIndex];
-
-		//Note we should really use the start time of the next slot
-		//but its easier to just use the outgoing slot time. This
-		//will result in a small error.
-		m_iSpeedStartTime = m_iSpeedTime[m_iSpeedBytesIndex];
-
-		//Now reset.
-		m_iSpeedBytes[m_iSpeedBytesIndex] = 0;
-		m_iSpeedTime[m_iSpeedBytesIndex] = iNowSlot;
-	}
-
-	// Once per second recalculate summary field "m_iSpeedTotalBytes" to recover from possible synchronisation errors
-	if (tCurTime > m_tSpeedCorrection)
-	{
-		long long iSpeedTotalBytes = 0;
-		for (int i = 0; i < SPEEDMETER_SLOTS; i++)
-		{
-			iSpeedTotalBytes += m_iSpeedBytes[i];
-		}
-		m_iSpeedTotalBytes = iSpeedTotalBytes;
-		m_tSpeedCorrection = tCurTime;
-	}
-
-	if (m_iSpeedTotalBytes == 0)
-	{
-		m_iSpeedStartTime = iNowSlot;
-	}
-	m_iSpeedBytes[m_iSpeedBytesIndex] += iBytes;
-	m_iSpeedTotalBytes += iBytes;
-	m_iAllBytes += iBytes;
-
-	if (g_pOptions->GetAccurateRate())
-	{
-#ifdef HAVE_SPINLOCK
-		m_spinlockSpeed.Unlock();
-#else
-		m_mutexSpeed.Unlock();
-#endif
-	}
-}
-
-void StatMeter::ResetSpeedStat()
-{
-	time_t tCurTime = time(NULL);
-	m_iSpeedStartTime = (int)tCurTime / SPEEDMETER_SLOTSIZE;
-	for (int i = 0; i < SPEEDMETER_SLOTS; i++)
-	{
-		m_iSpeedBytes[i] = 0;
-		m_iSpeedTime[i] = m_iSpeedStartTime;
-	}
-	m_iSpeedBytesIndex = 0;
-	m_iSpeedTotalBytes = 0;
-	m_tSpeedCorrection = tCurTime;
-}
-
-void StatMeter::LogDebugInfo()
-{
-	info("   ---------- SpeedMeter");
-	float fSpeed = (float)(CalcCurrentDownloadSpeed() / 1024.0);
-	int iTimeDiff = (int)time(NULL) - m_iSpeedStartTime * SPEEDMETER_SLOTSIZE;
-	info("      Speed: %f", fSpeed);
-	info("      SpeedStartTime: %i", m_iSpeedStartTime);
-	info("      SpeedTotalBytes: %i", m_iSpeedTotalBytes);
-	info("      SpeedBytesIndex: %i", m_iSpeedBytesIndex);
-	info("      AllBytes: %i", m_iAllBytes);
-	info("      Time: %i", (int)time(NULL));
-	info("      TimeDiff: %i", iTimeDiff);
-	for (int i=0; i < SPEEDMETER_SLOTS; i++)
-	{
-		info("      Bytes[%i]: %i, Time[%i]: %i", i, m_iSpeedBytes[i], i, m_iSpeedTime[i]);
-	}
-
-	m_mutexVolume.Lock();
-	int index = 0;
-	for (ServerVolumes::iterator it = m_ServerVolumes.begin(); it != m_ServerVolumes.end(); it++, index++)
-	{
-		ServerVolume* pServerVolume = *it;
-		info("      ServerVolume %i", index);
-		pServerVolume->LogDebugInfo();
-	}
-	m_mutexVolume.Unlock();
-}
-
-void StatMeter::AddServerData(int iBytes, int iServerID)
-{
-	if (iBytes == 0)
-	{
-		return;
-	}
-
-	m_mutexVolume.Lock();
-	m_ServerVolumes[0]->AddData(iBytes);
-	m_ServerVolumes[iServerID]->AddData(iBytes);
-	m_bStatChanged = true;
-	m_mutexVolume.Unlock();
-}
-
-ServerVolumes* StatMeter::LockServerVolumes()
-{
-	m_mutexVolume.Lock();
-
-	// update slots
-	for (ServerVolumes::iterator it = m_ServerVolumes.begin(); it != m_ServerVolumes.end(); it++)
-	{
-		ServerVolume* pServerVolume = *it;
-		pServerVolume->AddData(0);
-	}
-
-	return &m_ServerVolumes;
-}
-
-void StatMeter::UnlockServerVolumes()
-{
-	m_mutexVolume.Unlock();
-}
-
-void StatMeter::Save()
-{
-	if (!g_pOptions->GetServerMode())
-	{
-		return;
-	}
-
-	m_mutexVolume.Lock();
-	g_pDiskState->SaveStats(g_pServerPool->GetServers(), &m_ServerVolumes);
-	m_bStatChanged = false;
-	m_mutexVolume.Unlock();
-}
-
-bool StatMeter::Load(bool* pPerfectServerMatch)
-{
-	m_mutexVolume.Lock();
-
-	bool bOK = g_pDiskState->LoadStats(g_pServerPool->GetServers(), &m_ServerVolumes, pPerfectServerMatch);
-
-	for (ServerVolumes::iterator it = m_ServerVolumes.begin(); it != m_ServerVolumes.end(); it++)
-	{
-		ServerVolume* pServerVolume = *it;
-		pServerVolume->CalcSlots(pServerVolume->GetDataTime() + g_pOptions->GetLocalTimeOffset());
-	}
-
-	m_mutexVolume.Unlock();
-
-	return bOK;
-}

daemon/nntp/StatMeter.h

@@ -1,140 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2014 Andrey Prygunkov <hugbug@users.sourceforge.net>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- * $Revision$
- * $Date$
- *
- */
-
-
-#ifndef STATMETER_H
-#define STATMETER_H
-
-#include <vector>
-#include <time.h>
-
-#include "Log.h"
-#include "Thread.h"
-
-class ServerVolume
-{
-public:
-	typedef std::vector<long long>	VolumeArray;
-
-private:
-	VolumeArray			m_BytesPerSeconds;
-	VolumeArray			m_BytesPerMinutes;
-	VolumeArray			m_BytesPerHours;
-	VolumeArray			m_BytesPerDays;
-	int					m_iFirstDay;
-	long long			m_lTotalBytes;
-	long long			m_lCustomBytes;
-	time_t				m_tDataTime;
-	time_t				m_tCustomTime;
-	int					m_iSecSlot;
-	int					m_iMinSlot;
-	int					m_iHourSlot;
-	int					m_iDaySlot;
-
-public:
-						ServerVolume();
-	VolumeArray*		BytesPerSeconds() { return &m_BytesPerSeconds; }
-	VolumeArray*		BytesPerMinutes() { return &m_BytesPerMinutes; }
-	VolumeArray*		BytesPerHours() { return &m_BytesPerHours; }
-	VolumeArray*		BytesPerDays() { return &m_BytesPerDays; }
-	void				SetFirstDay(int iFirstDay) { m_iFirstDay = iFirstDay; }
-	int					GetFirstDay() { return m_iFirstDay; }
-	void				SetTotalBytes(long long lTotalBytes) { m_lTotalBytes = lTotalBytes; }
-	long long			GetTotalBytes() { return m_lTotalBytes; }
-	void				SetCustomBytes(long long lCustomBytes) { m_lCustomBytes = lCustomBytes; }
-	long long			GetCustomBytes() { return m_lCustomBytes; }
-	int					GetSecSlot() { return m_iSecSlot; }
-	int					GetMinSlot() { return m_iMinSlot; }
-	int					GetHourSlot() { return m_iHourSlot; }
-	int					GetDaySlot() { return m_iDaySlot; }
-	time_t				GetDataTime() { return m_tDataTime; }
-	void				SetDataTime(time_t tDataTime) { m_tDataTime = tDataTime; }
-	time_t				GetCustomTime() { return m_tCustomTime; }
-	void				SetCustomTime(time_t tCustomTime) { m_tCustomTime = tCustomTime; }
-
-	void				AddData(int iBytes);
-	void				CalcSlots(time_t tLocCurTime);
-	void				ResetCustom();
-	void				LogDebugInfo();
-};
-
-typedef std::vector<ServerVolume*>	ServerVolumes;
-
-class StatMeter : public Debuggable
-{
-private:
-	// speed meter
-	static const int	SPEEDMETER_SLOTS = 30;	  
-	static const int	SPEEDMETER_SLOTSIZE = 1;  //Split elapsed time into this number of secs.
-	int					m_iSpeedBytes[SPEEDMETER_SLOTS];
-	long long			m_iSpeedTotalBytes;
-	int					m_iSpeedTime[SPEEDMETER_SLOTS];
-	int					m_iSpeedStartTime; 
-	time_t				m_tSpeedCorrection;
-	int					m_iSpeedBytesIndex;
-#ifdef HAVE_SPINLOCK
-	SpinLock			m_spinlockSpeed;
-#else
-	Mutex				m_mutexSpeed;
-#endif
-
-	// time
-	long long			m_iAllBytes;
-	time_t				m_tStartServer;
-	time_t				m_tLastCheck;
-	time_t				m_tLastTimeOffset;
-	time_t				m_tStartDownload;
-	time_t				m_tPausedFrom;
-	bool				m_bStandBy;
-	Mutex				m_mutexStat;
-
-	// data volume
-	bool				m_bStatChanged;
-	ServerVolumes		m_ServerVolumes;
-	Mutex				m_mutexVolume;
-
-	void				ResetSpeedStat();
-	void				AdjustTimeOffset();
-
-protected:
-	virtual void		LogDebugInfo();
-
-public:
-						StatMeter();
-						~StatMeter();
-	void				Init();
-	int					CalcCurrentDownloadSpeed();
-	void				AddSpeedReading(int iBytes);
-	void				AddServerData(int iBytes, int iServerID);
-	void				CalcTotalStat(int* iUpTimeSec, int* iDnTimeSec, long long* iAllBytes, bool* bStandBy);
-	bool				GetStandBy() { return m_bStandBy; }
-	void				IntervalCheck();
-	void				EnterLeaveStandBy(bool bEnter);
-	ServerVolumes*		LockServerVolumes();
-	void				UnlockServerVolumes();
-	void				Save();
-	bool				Load(bool* pPerfectServerMatch);
-};
-
-#endif

daemon/postprocess/ParChecker.h

@@ -1,133 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2007-2013 Andrey Prygunkov <hugbug@users.sourceforge.net>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- * $Revision$
- * $Date$
- *
- */
-
-
-#ifndef PARCHECKER_H
-#define PARCHECKER_H
-
-#ifndef DISABLE_PARCHECK
-
-#include <deque>
-#include <string>
-
-#include "Thread.h"
-#include "Log.h"
-
-class ParChecker : public Thread
-{
-public:
-	enum EStatus
-	{
-		psFailed,
-		psRepairPossible,
-		psRepaired,
-		psRepairNotNeeded
-	};
-
-	enum EStage
-	{
-		ptLoadingPars,
-		ptVerifyingSources,
-		ptRepairing,
-		ptVerifyingRepaired,
-	};
-
-	typedef std::deque<char*>		FileList;
-	typedef std::deque<void*>		SourceList;
-	
-private:
-	char*				m_szInfoName;
-	char*				m_szDestDir;
-	char*				m_szNZBName;
-	const char*			m_szParFilename;
-	EStatus				m_eStatus;
-	EStage				m_eStage;
-	void*				m_pRepairer;	// declared as void* to prevent the including of libpar2-headers into this header-file
-	char*				m_szErrMsg;
-	FileList			m_QueuedParFiles;
-	Mutex			 	m_mutexQueuedParFiles;
-	bool				m_bQueuedParFilesChanged;
-	FileList			m_ProcessedFiles;
-	int					m_iProcessedFiles;
-	int					m_iFilesToRepair;
-	int					m_iExtraFiles;
-	bool				m_bVerifyingExtraFiles;
-	char*				m_szProgressLabel;
-	int					m_iFileProgress;
-	int					m_iStageProgress;
-	bool				m_bCancelled;
-	SourceList			m_sourceFiles;
-
-	void				Cleanup();
-	EStatus				RunParCheck(const char* szParFilename);
-	int					PreProcessPar();
-	bool				LoadMainParBak();
-	int					ProcessMorePars();
-	bool				LoadMorePars();
-	bool				AddSplittedFragments();
-	bool				AddMissingFiles();
-	bool				IsProcessedFile(const char* szFilename);
-	void				WriteBrokenLog(EStatus eStatus);
-	void				SaveSourceList();
-	void				DeleteLeftovers();
-	void				signal_filename(std::string str);
-	void				signal_progress(double progress);
-	void				signal_done(std::string str, int available, int total);
-
-protected:
-	/**
-	* Unpause par2-files
-	* returns true, if the files with required number of blocks were unpaused,
-	* or false if there are no more files in queue for this collection or not enough blocks
-	*/
-	virtual bool		RequestMorePars(int iBlockNeeded, int* pBlockFound) = 0;
-	virtual void		UpdateProgress() {}
-	virtual void		Completed() {}
-	virtual void		PrintMessage(Message::EKind eKind, const char* szFormat, ...) {}
-	virtual void		RegisterParredFile(const char* szFilename) {}
-	virtual bool		IsParredFile(const char* szFilename) { return false; }
-	EStage				GetStage() { return m_eStage; }
-	const char*			GetProgressLabel() { return m_szProgressLabel; }
-	int					GetFileProgress() { return m_iFileProgress; }
-	int					GetStageProgress() { return m_iStageProgress; }
-
-public:
-						ParChecker();
-	virtual				~ParChecker();
-	virtual void		Run();
-	void				SetDestDir(const char* szDestDir);
-	const char*			GetParFilename() { return m_szParFilename; }
-	const char*			GetInfoName() { return m_szInfoName; }
-	void				SetInfoName(const char* szInfoName);
-	void				SetNZBName(const char* szNZBName);
-	EStatus				GetStatus() { return m_eStatus; }
-	void				AddParFile(const char* szParFilename);
-	void				QueueChanged();
-	void				Cancel();
-	bool				GetCancelled() { return m_bCancelled; }
-};
-
-#endif
-
-#endif

daemon/postprocess/ParCoordinator.cpp

@@ -1,749 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2007-2014 Andrey Prygunkov <hugbug@users.sourceforge.net>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- * $Revision$
- * $Date$
- *
- */
-
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#ifdef WIN32
-#include "win32.h"
-#endif
-
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#include <stdarg.h>
-#include <ctype.h>
-#ifdef WIN32
-#include <direct.h>
-#else
-#include <unistd.h>
-#endif
-
-#include "nzbget.h"
-#include "ParCoordinator.h"
-#include "Options.h"
-#include "Log.h"
-#include "Util.h"
-
-extern Options* g_pOptions;
-
-#ifndef DISABLE_PARCHECK
-bool ParCoordinator::PostParChecker::RequestMorePars(int iBlockNeeded, int* pBlockFound)
-{
-	return m_pOwner->RequestMorePars(m_pPostInfo->GetNZBInfo(), GetParFilename(), iBlockNeeded, pBlockFound);
-}
-
-void ParCoordinator::PostParChecker::UpdateProgress()
-{
-	m_pOwner->UpdateParCheckProgress();
-}
-
-void ParCoordinator::PostParChecker::PrintMessage(Message::EKind eKind, const char* szFormat, ...)
-{
-	char szText[1024];
-	va_list args;
-	va_start(args, szFormat);
-	vsnprintf(szText, 1024, szFormat, args);
-	va_end(args);
-	szText[1024-1] = '\0';
-
-	m_pOwner->PrintMessage(m_pPostInfo, eKind, "%s", szText);
-}
-
-void ParCoordinator::PostParChecker::RegisterParredFile(const char* szFilename)
-{
-	m_pPostInfo->GetParredFiles()->push_back(strdup(szFilename));
-}
-
-bool ParCoordinator::PostParChecker::IsParredFile(const char* szFilename)
-{
-	for (PostInfo::ParredFiles::iterator it = m_pPostInfo->GetParredFiles()->begin(); it != m_pPostInfo->GetParredFiles()->end(); it++)
-	{
-		const char* szParredFile = *it;
-		if (!strcasecmp(szParredFile, szFilename))
-		{
-			return true;
-		}
-	}
-	return false;
-}
-
-void ParCoordinator::PostParRenamer::UpdateProgress()
-{
-	m_pOwner->UpdateParRenameProgress();
-}
-
-void ParCoordinator::PostParRenamer::PrintMessage(Message::EKind eKind, const char* szFormat, ...)
-{
-	char szText[1024];
-	va_list args;
-	va_start(args, szFormat);
-	vsnprintf(szText, 1024, szFormat, args);
-	va_end(args);
-	szText[1024-1] = '\0';
-	
-	m_pOwner->PrintMessage(m_pPostInfo, eKind, "%s", szText);
-}
-
-void ParCoordinator::PostParRenamer::RegisterParredFile(const char* szFilename)
-{
-	m_pPostInfo->GetParredFiles()->push_back(strdup(szFilename));
-}
-
-#endif
-
-ParCoordinator::ParCoordinator()
-{
-	debug("Creating ParCoordinator");
-
-#ifndef DISABLE_PARCHECK
-	m_bStopped = false;
-	m_ParChecker.m_pOwner = this;
-	m_ParRenamer.m_pOwner = this;
-#endif
-}
-
-ParCoordinator::~ParCoordinator()
-{
-	debug("Destroying ParCoordinator");
-}
-
-#ifndef DISABLE_PARCHECK
-void ParCoordinator::Stop()
-{
-	debug("Stopping ParCoordinator");
-
-	m_bStopped = true;
-
-	if (m_ParChecker.IsRunning())
-	{
-		m_ParChecker.Stop();
-		int iMSecWait = 5000;
-		while (m_ParChecker.IsRunning() && iMSecWait > 0)
-		{
-			usleep(50 * 1000);
-			iMSecWait -= 50;
-		}
-		if (m_ParChecker.IsRunning())
-		{
-			warn("Terminating par-check for %s", m_ParChecker.GetInfoName());
-			m_ParChecker.Kill();
-		}
-	}
-}
-#endif
-
-void ParCoordinator::PausePars(DownloadQueue* pDownloadQueue, NZBInfo* pNZBInfo)
-{
-	debug("ParCoordinator: Pausing pars");
-
-	pDownloadQueue->EditEntry(pNZBInfo->GetID(), 
-		DownloadQueue::eaGroupPauseExtraPars, 0, NULL);
-}
-
-bool ParCoordinator::FindMainPars(const char* szPath, ParFileList* pFileList)
-{
-	if (pFileList)
-	{
-		pFileList->clear();
-	}
-
-	DirBrowser dir(szPath);
-	while (const char* filename = dir.Next())
-	{
-		int iBaseLen = 0;
-		if (ParseParFilename(filename, &iBaseLen, NULL))
-		{
-			if (!pFileList)
-			{
-				return true;
-			}
-
-			// check if the base file already added to list
-			bool exists = false;
-			for (ParFileList::iterator it = pFileList->begin(); it != pFileList->end(); it++)
-			{
-				const char* filename2 = *it;
-				exists = SameParCollection(filename, filename2);
-				if (exists)
-				{
-					break;
-				}
-			}
-			if (!exists)
-			{
-				pFileList->push_back(strdup(filename));
-			}
-		}
-	}
-	return pFileList && !pFileList->empty();
-}
-
-bool ParCoordinator::SameParCollection(const char* szFilename1, const char* szFilename2)
-{
-	int iBaseLen1 = 0, iBaseLen2 = 0;
-	return ParseParFilename(szFilename1, &iBaseLen1, NULL) &&
-		ParseParFilename(szFilename2, &iBaseLen2, NULL) &&
-		iBaseLen1 == iBaseLen2 &&
-		!strncasecmp(szFilename1, szFilename2, iBaseLen1);
-}
-
-bool ParCoordinator::ParseParFilename(const char* szParFilename, int* iBaseNameLen, int* iBlocks)
-{
-	char szFilename[1024];
-	strncpy(szFilename, szParFilename, 1024);
-	szFilename[1024-1] = '\0';
-	for (char* p = szFilename; *p; p++) *p = tolower(*p); // convert string to lowercase
-
-	int iLen = strlen(szFilename);
-	if (iLen < 6)
-	{
-		return false;
-	}
-
-	// find last occurence of ".par2" and trim filename after it
-	char* szEnd = szFilename;
-	while (char* p = strstr(szEnd, ".par2")) szEnd = p + 5;
-	*szEnd = '\0';
-
-	iLen = strlen(szFilename);
-	if (iLen < 6)
-	{
-		return false;
-	}
-
-	if (strcasecmp(szFilename + iLen - 5, ".par2"))
-	{
-		return false;
-	}
-	*(szFilename + iLen - 5) = '\0';
-
-	int blockcnt = 0;
-	char* p = strrchr(szFilename, '.');
-	if (p && !strncasecmp(p, ".vol", 4))
-	{
-		char* b = strchr(p, '+');
-		if (!b)
-		{
-			b = strchr(p, '-');
-		}
-		if (b)
-		{
-			blockcnt = atoi(b+1);
-			*p = '\0';
-		}
-	}
-
-	if (iBaseNameLen)
-	{
-		*iBaseNameLen = strlen(szFilename);
-	}
-	if (iBlocks)
-	{
-		*iBlocks = blockcnt;
-	}
-	
-	return true;
-}
-
-#ifndef DISABLE_PARCHECK
-
-/**
- * DownloadQueue must be locked prior to call of this function.
- */
-void ParCoordinator::StartParCheckJob(PostInfo* pPostInfo)
-{
-	m_eCurrentJob = jkParCheck;
-	m_ParChecker.SetPostInfo(pPostInfo);
-	m_ParChecker.SetDestDir(pPostInfo->GetNZBInfo()->GetDestDir());
-	m_ParChecker.SetNZBName(pPostInfo->GetNZBInfo()->GetName());
-	m_ParChecker.PrintMessage(Message::mkInfo, "Checking pars for %s", pPostInfo->GetNZBInfo()->GetName());
-	pPostInfo->SetWorking(true);
-	m_ParChecker.Start();
-}
-
-/**
- * DownloadQueue must be locked prior to call of this function.
- */
-void ParCoordinator::StartParRenameJob(PostInfo* pPostInfo)
-{
-	const char* szDestDir = pPostInfo->GetNZBInfo()->GetDestDir();
-
-	char szFinalDir[1024];
-	if (pPostInfo->GetNZBInfo()->GetUnpackStatus() == NZBInfo::usSuccess)
-	{
-		pPostInfo->GetNZBInfo()->BuildFinalDirName(szFinalDir, 1024);
-		szFinalDir[1024-1] = '\0';
-		szDestDir = szFinalDir;
-	}
-
-	m_eCurrentJob = jkParRename;
-	m_ParRenamer.SetPostInfo(pPostInfo);
-	m_ParRenamer.SetDestDir(szDestDir);
-	m_ParRenamer.SetInfoName(pPostInfo->GetNZBInfo()->GetName());
-	m_ParRenamer.SetDetectMissing(pPostInfo->GetNZBInfo()->GetUnpackStatus() == NZBInfo::usNone);
-	m_ParRenamer.PrintMessage(Message::mkInfo, "Checking renamed files for %s", pPostInfo->GetNZBInfo()->GetName());
-	pPostInfo->SetWorking(true);
-	m_ParRenamer.Start();
-}
-
-bool ParCoordinator::Cancel()
-{
-	if (m_eCurrentJob == jkParCheck)
-	{
-#ifdef HAVE_PAR2_CANCEL
-		if (!m_ParChecker.GetCancelled())
-		{
-			debug("Cancelling par-repair for %s", m_ParChecker.GetInfoName());
-			m_ParChecker.Cancel();
-			return true;
-		}
-#else
-		warn("Cannot cancel par-repair for %s, used version of libpar2 does not support cancelling", m_ParChecker.GetInfoName());
-#endif
-	}
-	else if (m_eCurrentJob == jkParRename)
-	{
-		if (!m_ParRenamer.GetCancelled())
-		{
-			debug("Cancelling par-rename for %s", m_ParRenamer.GetInfoName());
-			m_ParRenamer.Cancel();
-			return true;
-		}
-	}
-	return false;
-}
-
-/**
- * DownloadQueue must be locked prior to call of this function.
- */
-bool ParCoordinator::AddPar(FileInfo* pFileInfo, bool bDeleted)
-{
-	bool bSameCollection = m_ParChecker.IsRunning() &&
-		pFileInfo->GetNZBInfo() == m_ParChecker.GetPostInfo()->GetNZBInfo();
-	if (bSameCollection && !bDeleted)
-	{
-		char szFullFilename[1024];
-		snprintf(szFullFilename, 1024, "%s%c%s", pFileInfo->GetNZBInfo()->GetDestDir(), (int)PATH_SEPARATOR, pFileInfo->GetFilename());
-		szFullFilename[1024-1] = '\0';
-		m_ParChecker.AddParFile(szFullFilename);
-	}
-	else
-	{
-		m_ParChecker.QueueChanged();
-	}
-	return bSameCollection;
-}
-
-void ParCoordinator::ParCheckCompleted()
-{
-	DownloadQueue* pDownloadQueue = DownloadQueue::Lock();
-
-	PostInfo* pPostInfo = m_ParChecker.GetPostInfo();
-
-	// Update ParStatus (accumulate result)
-	if ((m_ParChecker.GetStatus() == ParChecker::psRepaired ||
-		m_ParChecker.GetStatus() == ParChecker::psRepairNotNeeded) &&
-		pPostInfo->GetNZBInfo()->GetParStatus() <= NZBInfo::psSkipped)
-	{
-		pPostInfo->GetNZBInfo()->SetParStatus(NZBInfo::psSuccess);
-	}
-	else if (m_ParChecker.GetStatus() == ParChecker::psRepairPossible &&
-		pPostInfo->GetNZBInfo()->GetParStatus() != NZBInfo::psFailure)
-	{
-		pPostInfo->GetNZBInfo()->SetParStatus(NZBInfo::psRepairPossible);
-	}
-	else
-	{
-		pPostInfo->GetNZBInfo()->SetParStatus(NZBInfo::psFailure);
-	}
-
-	pPostInfo->SetWorking(false);
-	pPostInfo->SetStage(PostInfo::ptQueued);
-
-	pDownloadQueue->Save();
-
-	DownloadQueue::Unlock();
-}
-
-/**
-* Unpause par2-files
-* returns true, if the files with required number of blocks were unpaused,
-* or false if there are no more files in queue for this collection or not enough blocks
-*/
-bool ParCoordinator::RequestMorePars(NZBInfo* pNZBInfo, const char* szParFilename, int iBlockNeeded, int* pBlockFound)
-{
-	DownloadQueue* pDownloadQueue = DownloadQueue::Lock();
-	
-	Blocks blocks;
-	blocks.clear();
-	int iBlockFound = 0;
-    int iCurBlockFound = 0;
-
-	FindPars(pDownloadQueue, pNZBInfo, szParFilename, &blocks, true, true, &iCurBlockFound);
-    iBlockFound += iCurBlockFound;
-	if (iBlockFound < iBlockNeeded)
-	{
-		FindPars(pDownloadQueue, pNZBInfo, szParFilename, &blocks, true, false, &iCurBlockFound);
-        iBlockFound += iCurBlockFound;
-	}
-	if (iBlockFound < iBlockNeeded)
-	{
-		FindPars(pDownloadQueue, pNZBInfo, szParFilename, &blocks, false, false, &iCurBlockFound);
-        iBlockFound += iCurBlockFound;
-	}
-
-	if (iBlockFound >= iBlockNeeded)
-	{
-		// 1. first unpause all files with par-blocks less or equal iBlockNeeded
-		// starting from the file with max block count.
-		// if par-collection was built exponentially and all par-files present,
-		// this step selects par-files with exact number of blocks we need.
-		while (iBlockNeeded > 0)
-		{               
-			BlockInfo* pBestBlockInfo = NULL;
-			for (Blocks::iterator it = blocks.begin(); it != blocks.end(); it++)
-			{
-				BlockInfo* pBlockInfo = *it;
-				if (pBlockInfo->m_iBlockCount <= iBlockNeeded &&
-				   (!pBestBlockInfo || pBestBlockInfo->m_iBlockCount < pBlockInfo->m_iBlockCount))
-				{
-					pBestBlockInfo = pBlockInfo;
-				}
-			}
-			if (pBestBlockInfo)
-			{
-				if (pBestBlockInfo->m_pFileInfo->GetPaused())
-				{
-					m_ParChecker.PrintMessage(Message::mkInfo, "Unpausing %s%c%s for par-recovery", pNZBInfo->GetName(), (int)PATH_SEPARATOR, pBestBlockInfo->m_pFileInfo->GetFilename());
-					pBestBlockInfo->m_pFileInfo->SetPaused(false);
-					pBestBlockInfo->m_pFileInfo->SetExtraPriority(true);
-				}
-				iBlockNeeded -= pBestBlockInfo->m_iBlockCount;
-				blocks.remove(pBestBlockInfo);
-				delete pBestBlockInfo;
-			}
-			else
-			{
-				break;
-			}
-		}
-			
-		// 2. then unpause other files
-		// this step only needed if the par-collection was built not exponentially 
-		// or not all par-files present (or some of them were corrupted)
-		// this step is not optimal, but we hope, that the first step will work good 
-		// in most cases and we will not need the second step often
-		while (iBlockNeeded > 0)
-		{
-			BlockInfo* pBlockInfo = blocks.front();
-			if (pBlockInfo->m_pFileInfo->GetPaused())
-			{
-				m_ParChecker.PrintMessage(Message::mkInfo, "Unpausing %s%c%s for par-recovery", pNZBInfo->GetName(), (int)PATH_SEPARATOR, pBlockInfo->m_pFileInfo->GetFilename());
-				pBlockInfo->m_pFileInfo->SetPaused(false);
-				pBlockInfo->m_pFileInfo->SetExtraPriority(true);
-			}
-			iBlockNeeded -= pBlockInfo->m_iBlockCount;
-		}
-	}
-
-	DownloadQueue::Unlock();
-
-	if (pBlockFound)
-	{
-		*pBlockFound = iBlockFound;
-	}
-
-	for (Blocks::iterator it = blocks.begin(); it != blocks.end(); it++)
-	{
-		delete *it;
-	}
-	blocks.clear();
-
-	bool bOK = iBlockNeeded <= 0;
-
-	return bOK;
-}
-
-void ParCoordinator::FindPars(DownloadQueue* pDownloadQueue, NZBInfo* pNZBInfo, const char* szParFilename,
-	Blocks* pBlocks, bool bStrictParName, bool bExactParName, int* pBlockFound)
-{
-    *pBlockFound = 0;
-	
-	// extract base name from m_szParFilename (trim .par2-extension and possible .vol-part)
-	char* szBaseParFilename = Util::BaseFileName(szParFilename);
-	char szMainBaseFilename[1024];
-	int iMainBaseLen = 0;
-	if (!ParseParFilename(szBaseParFilename, &iMainBaseLen, NULL))
-	{
-		// should not happen
-        error("Internal error: could not parse filename %s", szBaseParFilename);
-		return;
-	}
-	int maxlen = iMainBaseLen < 1024 ? iMainBaseLen : 1024 - 1;
-	strncpy(szMainBaseFilename, szBaseParFilename, maxlen);
-	szMainBaseFilename[maxlen] = '\0';
-	for (char* p = szMainBaseFilename; *p; p++) *p = tolower(*p); // convert string to lowercase
-
-	for (FileList::iterator it = pNZBInfo->GetFileList()->begin(); it != pNZBInfo->GetFileList()->end(); it++)
-	{
-		FileInfo* pFileInfo = *it;
-		int iBlocks = 0;
-		if (ParseParFilename(pFileInfo->GetFilename(), NULL, &iBlocks) &&
-			iBlocks > 0)
-		{
-			bool bUseFile = true;
-
-			if (bExactParName)
-			{
-				bUseFile = SameParCollection(pFileInfo->GetFilename(), Util::BaseFileName(szParFilename));
-			}
-			else if (bStrictParName)
-			{
-				// the pFileInfo->GetFilename() may be not confirmed and may contain
-				// additional texts if Subject could not be parsed correctly
-
-				char szLoFileName[1024];
-				strncpy(szLoFileName, pFileInfo->GetFilename(), 1024);
-				szLoFileName[1024-1] = '\0';
-				for (char* p = szLoFileName; *p; p++) *p = tolower(*p); // convert string to lowercase
-				
-				char szCandidateFileName[1024];
-				snprintf(szCandidateFileName, 1024, "%s.par2", szMainBaseFilename);
-				szCandidateFileName[1024-1] = '\0';
-				if (!strstr(szLoFileName, szCandidateFileName))
-				{
-					snprintf(szCandidateFileName, 1024, "%s.vol", szMainBaseFilename);
-					szCandidateFileName[1024-1] = '\0';
-					bUseFile = strstr(szLoFileName, szCandidateFileName);
-				}
-			}
-
-            bool bAlreadyAdded = false;
-            // check if file is not in the list already
-			if (bUseFile)
-			{
-				for (Blocks::iterator it = pBlocks->begin(); it != pBlocks->end(); it++)
-				{
-					BlockInfo* pBlockInfo = *it;
-					if (pBlockInfo->m_pFileInfo == pFileInfo)
-					{
-						bAlreadyAdded = true;
-						break;
-                	}
-        		}
-			}
-                
-			// if it is a par2-file with blocks and it was from the same NZB-request
-			// and it belongs to the same file collection (same base name),
-			// then OK, we can use it
-            if (bUseFile && !bAlreadyAdded)
-            {
-				BlockInfo* pBlockInfo = new BlockInfo();
-				pBlockInfo->m_pFileInfo = pFileInfo;
-				pBlockInfo->m_iBlockCount = iBlocks;
-				pBlocks->push_back(pBlockInfo);
-				*pBlockFound += iBlocks;
-			}
-		}
-	}
-}
-
-void ParCoordinator::UpdateParCheckProgress()
-{
-	DownloadQueue::Lock();
-
-	PostInfo* pPostInfo = m_ParChecker.GetPostInfo();
-	if (m_ParChecker.GetFileProgress() == 0)
-	{
-		pPostInfo->SetProgressLabel(m_ParChecker.GetProgressLabel());
-	}
-	pPostInfo->SetFileProgress(m_ParChecker.GetFileProgress());
-	pPostInfo->SetStageProgress(m_ParChecker.GetStageProgress());
-    PostInfo::EStage StageKind[] = { PostInfo::ptLoadingPars, PostInfo::ptVerifyingSources, PostInfo::ptRepairing, PostInfo::ptVerifyingRepaired };
-	PostInfo::EStage eStage = StageKind[m_ParChecker.GetStage()];
-	time_t tCurrent = time(NULL);
-
-	if (!pPostInfo->GetStartTime())
-	{
-		pPostInfo->SetStartTime(tCurrent);
-	}
-
-	if (pPostInfo->GetStage() != eStage)
-	{
-		pPostInfo->SetStage(eStage);
-		pPostInfo->SetStageTime(tCurrent);
-	}
-
-	bool bParCancel = false;
-#ifdef HAVE_PAR2_CANCEL
-	if (!m_ParChecker.GetCancelled())
-	{
-		if ((g_pOptions->GetParTimeLimit() > 0) &&
-			m_ParChecker.GetStage() == ParChecker::ptRepairing &&
-			((g_pOptions->GetParTimeLimit() > 5 && tCurrent - pPostInfo->GetStageTime() > 5 * 60) ||
-			(g_pOptions->GetParTimeLimit() <= 5 && tCurrent - pPostInfo->GetStageTime() > 1 * 60)))
-		{
-			// first five (or one) minutes elapsed, now can check the estimated time
-			int iEstimatedRepairTime = (int)((tCurrent - pPostInfo->GetStartTime()) * 1000 / 
-				(pPostInfo->GetStageProgress() > 0 ? pPostInfo->GetStageProgress() : 1));
-			if (iEstimatedRepairTime > g_pOptions->GetParTimeLimit() * 60)
-			{
-				debug("Estimated repair time %i seconds", iEstimatedRepairTime);
-				m_ParChecker.PrintMessage(Message::mkWarning, "Cancelling par-repair for %s, estimated repair time (%i minutes) exceeds allowed repair time", m_ParChecker.GetInfoName(), iEstimatedRepairTime / 60);
-				bParCancel = true;
-			}
-		}
-	}
-#endif
-
-	if (bParCancel)
-	{
-		m_ParChecker.Cancel();
-	}
-
-	DownloadQueue::Unlock();
-	
-	CheckPauseState(pPostInfo);
-}
-
-void ParCoordinator::CheckPauseState(PostInfo* pPostInfo)
-{
-	if (g_pOptions->GetPausePostProcess() && !pPostInfo->GetNZBInfo()->GetForcePriority())
-	{
-		time_t tStageTime = pPostInfo->GetStageTime();
-		time_t tStartTime = pPostInfo->GetStartTime();
-		time_t tWaitTime = time(NULL);
-		
-		// wait until Post-processor is unpaused
-		while (g_pOptions->GetPausePostProcess() && !pPostInfo->GetNZBInfo()->GetForcePriority() && !m_bStopped)
-		{
-			usleep(100 * 1000);
-			
-			// update time stamps
-			
-			time_t tDelta = time(NULL) - tWaitTime;
-			
-			if (tStageTime > 0)
-			{
-				pPostInfo->SetStageTime(tStageTime + tDelta);
-			}
-			
-			if (tStartTime > 0)
-			{
-				pPostInfo->SetStartTime(tStartTime + tDelta);
-			}
-		}
-	}
-}
-
-void ParCoordinator::ParRenameCompleted()
-{
-	DownloadQueue* pDownloadQueue = DownloadQueue::Lock();
-	
-	PostInfo* pPostInfo = m_ParRenamer.GetPostInfo();
-	pPostInfo->GetNZBInfo()->SetRenameStatus(m_ParRenamer.GetStatus() == ParRenamer::psSuccess ? NZBInfo::rsSuccess : NZBInfo::rsFailure);
-
-	if (m_ParRenamer.HasMissedFiles() && pPostInfo->GetNZBInfo()->GetParStatus() <= NZBInfo::psSkipped)
-	{
-		PrintMessage(pPostInfo, Message::mkInfo, "Requesting par-check/repair for %s to restore missing files ", m_ParRenamer.GetInfoName());
-		pPostInfo->SetRequestParCheck(true);
-	}
-	else if (m_ParRenamer.HasSplittedFragments() && pPostInfo->GetNZBInfo()->GetParStatus() <= NZBInfo::psSkipped)
-	{
-		PrintMessage(pPostInfo, Message::mkInfo, "Requesting par-check/repair for %s to join splitted fragments", m_ParRenamer.GetInfoName());
-		pPostInfo->SetRequestParCheck(true);
-	}
-
-	pPostInfo->SetWorking(false);
-	pPostInfo->SetStage(PostInfo::ptQueued);
-	
-	pDownloadQueue->Save();
-
-	DownloadQueue::Unlock();
-}
-
-void ParCoordinator::UpdateParRenameProgress()
-{
-	DownloadQueue::Lock();
-	
-	PostInfo* pPostInfo = m_ParRenamer.GetPostInfo();
-	pPostInfo->SetProgressLabel(m_ParRenamer.GetProgressLabel());
-	pPostInfo->SetStageProgress(m_ParRenamer.GetStageProgress());
-	time_t tCurrent = time(NULL);
-	
-	if (!pPostInfo->GetStartTime())
-	{
-		pPostInfo->SetStartTime(tCurrent);
-	}
-	
-	if (pPostInfo->GetStage() != PostInfo::ptRenaming)
-	{
-		pPostInfo->SetStage(PostInfo::ptRenaming);
-		pPostInfo->SetStageTime(tCurrent);
-	}
-	
-	DownloadQueue::Unlock();
-	
-	CheckPauseState(pPostInfo);
-}
-
-void ParCoordinator::PrintMessage(PostInfo* pPostInfo, Message::EKind eKind, const char* szFormat, ...)
-{
-	char szText[1024];
-	va_list args;
-	va_start(args, szFormat);
-	vsnprintf(szText, 1024, szFormat, args);
-	va_end(args);
-	szText[1024-1] = '\0';
-
-	pPostInfo->AppendMessage(eKind, szText);
-
-	switch (eKind)
-	{
-		case Message::mkDetail:
-			detail("%s", szText);
-			break;
-
-		case Message::mkInfo:
-			info("%s", szText);
-			break;
-
-		case Message::mkWarning:
-			warn("%s", szText);
-			break;
-
-		case Message::mkError:
-			error("%s", szText);
-			break;
-
-		case Message::mkDebug:
-			debug("%s", szText);
-			break;
-	}
-}
-
-#endif

daemon/postprocess/ParCoordinator.h

@@ -1,131 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2007-2014 Andrey Prygunkov <hugbug@users.sourceforge.net>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- * $Revision$
- * $Date$
- *
- */
-
-
-#ifndef PARCOORDINATOR_H
-#define PARCOORDINATOR_H
-
-#include <list>
-#include <deque>
-
-#include "DownloadInfo.h"
-
-#ifndef DISABLE_PARCHECK
-#include "ParChecker.h"
-#include "ParRenamer.h"
-#endif
-
-class ParCoordinator 
-{
-private:
-#ifndef DISABLE_PARCHECK
-	class PostParChecker: public ParChecker
-	{
-	private:
-		ParCoordinator*	m_pOwner;
-		PostInfo*		m_pPostInfo;
-	protected:
-		virtual bool	RequestMorePars(int iBlockNeeded, int* pBlockFound);
-		virtual void	UpdateProgress();
-		virtual void	Completed() { m_pOwner->ParCheckCompleted(); }
-		virtual void	PrintMessage(Message::EKind eKind, const char* szFormat, ...);
-		virtual void	RegisterParredFile(const char* szFilename);
-		virtual bool	IsParredFile(const char* szFilename);
-	public:
-		PostInfo*		GetPostInfo() { return m_pPostInfo; }
-		void			SetPostInfo(PostInfo* pPostInfo) { m_pPostInfo = pPostInfo; }
-
-		friend class ParCoordinator;
-	};
-
-	class PostParRenamer: public ParRenamer
-	{
-	private:
-		ParCoordinator*	m_pOwner;
-		PostInfo*		m_pPostInfo;
-	protected:
-		virtual void	UpdateProgress();
-		virtual void	Completed() { m_pOwner->ParRenameCompleted(); }
-		virtual void	PrintMessage(Message::EKind eKind, const char* szFormat, ...);
-		virtual void	RegisterParredFile(const char* szFilename);
-	public:
-		PostInfo*		GetPostInfo() { return m_pPostInfo; }
-		void			SetPostInfo(PostInfo* pPostInfo) { m_pPostInfo = pPostInfo; }
-		
-		friend class ParCoordinator;
-	};
-	
-	struct BlockInfo
-	{
-		FileInfo*		m_pFileInfo;
-		int				m_iBlockCount;
-	};
-
-	typedef std::list<BlockInfo*> 	Blocks;
-	
-	enum EJobKind
-	{
-		jkParCheck,
-		jkParRename
-	};
-
-private:
-	PostParChecker		m_ParChecker;
-	bool				m_bStopped;
-	PostParRenamer		m_ParRenamer;
-	EJobKind			m_eCurrentJob;
-
-protected:
-	void				UpdateParCheckProgress();
-	void				UpdateParRenameProgress();
-	void				ParCheckCompleted();
-	void				ParRenameCompleted();
-	void				CheckPauseState(PostInfo* pPostInfo);
-	bool				RequestMorePars(NZBInfo* pNZBInfo, const char* szParFilename, int iBlockNeeded, int* pBlockFound);
-	void				PrintMessage(PostInfo* pPostInfo, Message::EKind eKind, const char* szFormat, ...);
-#endif
-
-public:
-	typedef std::deque<char*>		ParFileList;
-
-public:
-						ParCoordinator();
-	virtual				~ParCoordinator();
-	static bool			FindMainPars(const char* szPath, ParFileList* pFileList);
-	static bool			ParseParFilename(const char* szParFilename, int* iBaseNameLen, int* iBlocks);
-	static bool			SameParCollection(const char* szFilename1, const char* szFilename2);
-	void				PausePars(DownloadQueue* pDownloadQueue, NZBInfo* pNZBInfo);
-
-#ifndef DISABLE_PARCHECK
-	bool				AddPar(FileInfo* pFileInfo, bool bDeleted);
-	void				FindPars(DownloadQueue* pDownloadQueue, NZBInfo* pNZBInfo, const char* szParFilename, 
-							Blocks* pBlocks, bool bStrictParName, bool bExactParName, int* pBlockFound);
-	void				StartParCheckJob(PostInfo* pPostInfo);
-	void				StartParRenameJob(PostInfo* pPostInfo);
-	void				Stop();
-	bool				Cancel();
-#endif
-};
-
-#endif

daemon/postprocess/ParRenamer.cpp

@@ -1,499 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2013-2014 Andrey Prygunkov <hugbug@users.sourceforge.net>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- * $Revision$
- * $Date$
- *
- */
-
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#ifdef WIN32
-#include "win32.h"
-#endif
-
-#ifndef DISABLE_PARCHECK
-
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#include <ctype.h>
-#ifdef WIN32
-#include <par2cmdline.h>
-#include <par2repairer.h>
-#include <md5.h>
-#else
-#include <unistd.h>
-#include <libpar2/par2cmdline.h>
-#include <libpar2/par2repairer.h>
-#include <libpar2/md5.h>
-#endif
-
-#include "nzbget.h"
-#include "ParRenamer.h"
-#include "ParCoordinator.h"
-#include "Log.h"
-#include "Options.h"
-#include "Util.h"
-
-extern Options* g_pOptions;
-
-class ParRenamerRepairer : public Par2Repairer
-{
-public:
-	friend class ParRenamer;
-};
-
-ParRenamer::FileHash::FileHash(const char* szFilename, const char* szHash)
-{
-	m_szFilename = strdup(szFilename);
-	m_szHash = strdup(szHash);
-	m_bFileExists = false;
-}
-
-ParRenamer::FileHash::~FileHash()
-{
-	free(m_szFilename);
-	free(m_szHash);
-}
-
-ParRenamer::ParRenamer()
-{
-	debug("Creating ParRenamer");
-
-	m_eStatus = psFailed;
-	m_szDestDir = NULL;
-	m_szInfoName = NULL;
-	m_szProgressLabel = (char*)malloc(1024);
-	m_iStageProgress = 0;
-	m_bCancelled = false;
-	m_bHasSplittedFragments = false;
-	m_bHasMissedFiles = false;
-	m_bDetectMissing = false;
-}
-
-ParRenamer::~ParRenamer()
-{
-	debug("Destroying ParRenamer");
-
-	free(m_szDestDir);
-	free(m_szInfoName);
-	free(m_szProgressLabel);
-
-	Cleanup();
-}
-
-void ParRenamer::Cleanup()
-{
-	ClearHashList();
-	
-	for (DirList::iterator it = m_DirList.begin(); it != m_DirList.end(); it++)
-	{
-		free(*it);
-	}
-	m_DirList.clear();
-}
-
-void ParRenamer::ClearHashList()
-{
-	for (FileHashList::iterator it = m_FileHashList.begin(); it != m_FileHashList.end(); it++)
-	{
-		delete *it;
-	}
-	m_FileHashList.clear();
-}
-
-void ParRenamer::SetDestDir(const char * szDestDir)
-{
-	free(m_szDestDir);
-	m_szDestDir = strdup(szDestDir);
-}
-
-void ParRenamer::SetInfoName(const char * szInfoName)
-{
-	free(m_szInfoName);
-	m_szInfoName = strdup(szInfoName);
-}
-
-void ParRenamer::Cancel()
-{
-	m_bCancelled = true;
-}
-
-void ParRenamer::Run()
-{
-	Cleanup();
-	m_bCancelled = false;
-	m_iFileCount = 0;
-	m_iCurFile = 0;
-	m_iRenamedCount = 0;
-	m_bHasSplittedFragments = false;
-	m_bHasMissedFiles = false;
-	m_eStatus = psFailed;
-
-	snprintf(m_szProgressLabel, 1024, "Checking renamed files for %s", m_szInfoName);
-	m_szProgressLabel[1024-1] = '\0';
-	m_iStageProgress = 0;
-	UpdateProgress();
-
-	BuildDirList(m_szDestDir);
-
-	for (DirList::iterator it = m_DirList.begin(); it != m_DirList.end(); it++)
-	{
-		char* szDestDir = *it;
-		debug("Checking %s", szDestDir);
-		ClearHashList();
-		LoadParFiles(szDestDir);
-
-		if (m_FileHashList.empty())
-		{
-			int iSavedCurFile = m_iCurFile;
-			CheckFiles(szDestDir, true);
-			m_iCurFile = iSavedCurFile; // restore progress indicator
-			LoadParFiles(szDestDir);
-		}
-
-		CheckFiles(szDestDir, false);
-
-		if (m_bDetectMissing)
-		{
-			CheckMissing();
-		}
-	}
-
-	if (m_bCancelled)
-	{
-		PrintMessage(Message::mkWarning, "Renaming cancelled for %s", m_szInfoName);
-	}
-	else if (m_iRenamedCount > 0)
-	{
-		PrintMessage(Message::mkInfo, "Successfully renamed %i file(s) for %s", m_iRenamedCount, m_szInfoName);
-		m_eStatus = psSuccess;
-	}
-	else
-	{
-		PrintMessage(Message::mkInfo, "No renamed files found for %s", m_szInfoName);
-	}
-
-	Cleanup();
-	Completed();
-}
-
-void ParRenamer::BuildDirList(const char* szDestDir)
-{
-	m_DirList.push_back(strdup(szDestDir));
-
-	char* szFullFilename = (char*)malloc(1024);
-	DirBrowser* pDirBrowser = new DirBrowser(szDestDir);
-	
-	while (const char* filename = pDirBrowser->Next())
-	{
-		if (strcmp(filename, ".") && strcmp(filename, "..") && !m_bCancelled)
-		{
-			snprintf(szFullFilename, 1024, "%s%c%s", szDestDir, PATH_SEPARATOR, filename);
-			szFullFilename[1024-1] = '\0';
-			
-			if (Util::DirectoryExists(szFullFilename))
-			{
-				BuildDirList(szFullFilename);
-			}
-			else
-			{
-				m_iFileCount++;
-			}
-		}
-	}
-	
-	free(szFullFilename);
-	delete pDirBrowser;
-}
-
-void ParRenamer::LoadParFiles(const char* szDestDir)
-{
-	ParCoordinator::ParFileList parFileList;
-	ParCoordinator::FindMainPars(szDestDir, &parFileList);
-
-	for (ParCoordinator::ParFileList::iterator it = parFileList.begin(); it != parFileList.end(); it++)
-	{
-		char* szParFilename = *it;
-		
-		char szFullParFilename[1024];
-		snprintf(szFullParFilename, 1024, "%s%c%s", szDestDir, PATH_SEPARATOR, szParFilename);
-		szFullParFilename[1024-1] = '\0';
-		
-		LoadParFile(szFullParFilename);
-		
-		free(*it);
-	}
-}
-
-void ParRenamer::LoadParFile(const char* szParFilename)
-{
-	ParRenamerRepairer* pRepairer = new ParRenamerRepairer();
-
-	if (!pRepairer->LoadPacketsFromFile(szParFilename))
-	{
-		PrintMessage(Message::mkWarning, "Could not load par2-file %s", szParFilename);
-		delete pRepairer;
-		return;
-	}
-
-	for (map<MD5Hash, Par2RepairerSourceFile*>::iterator it = pRepairer->sourcefilemap.begin(); it != pRepairer->sourcefilemap.end(); it++)
-	{
-		if (m_bCancelled)
-		{
-			break;
-		}
-		
-		Par2RepairerSourceFile* sourceFile = (*it).second;
-		if (!sourceFile || !sourceFile->GetDescriptionPacket())
-		{
-			warn("Damaged par2-file detected: %s", szParFilename);
-			continue;
-		}
-		m_FileHashList.push_back(new FileHash(sourceFile->GetDescriptionPacket()->FileName().c_str(),
-			sourceFile->GetDescriptionPacket()->Hash16k().print().c_str()));
-		RegisterParredFile(sourceFile->GetDescriptionPacket()->FileName().c_str());
-	}
-
-	delete pRepairer;
-}
-
-void ParRenamer::CheckFiles(const char* szDestDir, bool bRenamePars)
-{
-	DirBrowser dir(szDestDir);
-	while (const char* filename = dir.Next())
-	{
-		if (strcmp(filename, ".") && strcmp(filename, "..") && !m_bCancelled)
-		{
-			char szFullFilename[1024];
-			snprintf(szFullFilename, 1024, "%s%c%s", szDestDir, PATH_SEPARATOR, filename);
-			szFullFilename[1024-1] = '\0';
-
-			if (!Util::DirectoryExists(szFullFilename))
-			{
-				snprintf(m_szProgressLabel, 1024, "Checking file %s", filename);
-				m_szProgressLabel[1024-1] = '\0';
-				m_iStageProgress = m_iCurFile * 1000 / m_iFileCount;
-				UpdateProgress();
-				m_iCurFile++;
-				
-				if (bRenamePars)
-				{
-					CheckParFile(szDestDir, szFullFilename);
-				}
-				else
-				{
-					CheckRegularFile(szDestDir, szFullFilename);
-				}
-			}
-		}
-	}
-}
-
-void ParRenamer::CheckMissing()
-{
-	for (FileHashList::iterator it = m_FileHashList.begin(); it != m_FileHashList.end(); it++)
-	{
-		FileHash* pFileHash = *it;
-		if (!pFileHash->GetFileExists())
-		{
-			if (Util::MatchFileExt(pFileHash->GetFilename(), g_pOptions->GetParIgnoreExt(), ",;") ||
-				Util::MatchFileExt(pFileHash->GetFilename(), g_pOptions->GetExtCleanupDisk(), ",;"))
-			{
-				info("File %s is missing, ignoring", pFileHash->GetFilename());
-			}
-			else
-			{
-				info("File %s is missing", pFileHash->GetFilename());
-				m_bHasMissedFiles = true;
-			}
-		}
-	}
-}
-
-bool ParRenamer::IsSplittedFragment(const char* szFilename, const char* szCorrectName)
-{
-	bool bSplittedFragement = false;
-	const char* szDiskBasename = Util::BaseFileName(szFilename);
-	const char* szExtension = strrchr(szDiskBasename, '.');
-	int iBaseLen = strlen(szCorrectName);
-	if (szExtension && !strncasecmp(szDiskBasename, szCorrectName, iBaseLen))
-	{
-		const char* p = szDiskBasename + iBaseLen;
-		if (*p == '.')
-		{
-			for (p++; *p && strchr("0123456789", *p); p++) ;
-			bSplittedFragement = !*p;
-			bSplittedFragement = bSplittedFragement && atoi(szDiskBasename + iBaseLen + 1) == 1;
-		}
-	}
-
-	m_bHasSplittedFragments = m_bHasSplittedFragments || bSplittedFragement;
-
-	return bSplittedFragement;
-}
-
-void ParRenamer::CheckRegularFile(const char* szDestDir, const char* szFilename)
-{
-	debug("Computing hash for %s", szFilename);
-
-	const int iBlockSize = 16*1024;
-	
-	FILE* pFile = fopen(szFilename, FOPEN_RB);
-	if (!pFile)
-	{
-		PrintMessage(Message::mkError, "Could not open file %s", szFilename);
-		return;
-	}
-
-	// load first 16K of the file into buffer
-	
-	void* pBuffer = malloc(iBlockSize);
-	
-	int iReadBytes = fread(pBuffer, 1, iBlockSize, pFile);
-	int iError = ferror(pFile);
-	if (iReadBytes != iBlockSize && iError)
-	{
-		PrintMessage(Message::mkError, "Could not read file %s", szFilename);
-		return;
-	}
-	
-	fclose(pFile);
-	
-	MD5Hash hash16k;
-	MD5Context context;
-	context.Update(pBuffer, iReadBytes);
-	context.Final(hash16k);
-	
-	free(pBuffer);
-	
-	debug("file: %s; hash16k: %s", Util::BaseFileName(szFilename), hash16k.print().c_str());
-	
-	for (FileHashList::iterator it = m_FileHashList.begin(); it != m_FileHashList.end(); it++)
-	{
-		FileHash* pFileHash = *it;
-		if (!strcmp(pFileHash->GetHash(), hash16k.print().c_str()))
-		{
-			debug("Found correct filename: %s", pFileHash->GetFilename());
-			pFileHash->SetFileExists(true);
-
-			char szDstFilename[1024];
-			snprintf(szDstFilename, 1024, "%s%c%s", szDestDir, PATH_SEPARATOR, pFileHash->GetFilename());
-			szDstFilename[1024-1] = '\0';
-
-			if (!Util::FileExists(szDstFilename) && !IsSplittedFragment(szFilename, pFileHash->GetFilename()))
-			{
-				PrintMessage(Message::mkInfo, "Renaming %s to %s", Util::BaseFileName(szFilename), pFileHash->GetFilename());
-				if (Util::MoveFile(szFilename, szDstFilename))
-				{
-					m_iRenamedCount++;
-				}
-				else
-				{
-					char szErrBuf[256];
-					PrintMessage(Message::mkError, "Could not rename %s to %s: %s", szFilename, szDstFilename,
-						Util::GetLastErrorMessage(szErrBuf, sizeof(szErrBuf)));
-				}
-			}
-			
-			break;
-		}
-	}
-}
-
-/*
-* For files not having par2-extensions: checks if the file is a par2-file and renames
-* it according to its set-id.
-*/
-void ParRenamer::CheckParFile(const char* szDestDir, const char* szFilename)
-{
-	debug("Checking par2-header for %s", szFilename);
-
-	const char* szBasename = Util::BaseFileName(szFilename);
-	const char* szExtension = strrchr(szBasename, '.');
-	if (szExtension && !strcasecmp(szExtension, ".par2"))
-	{
-		// do not process files already having par2-extension
-		return;
-	}
-
-	FILE* pFile = fopen(szFilename, FOPEN_RB);
-	if (!pFile)
-	{
-		PrintMessage(Message::mkError, "Could not open file %s", szFilename);
-		return;
-	}
-
-	// load par2-header
-	PACKET_HEADER header;
-
-	int iReadBytes = fread(&header, 1, sizeof(header), pFile);
-	int iError = ferror(pFile);
-	if (iReadBytes != sizeof(header) && iError)
-	{
-		PrintMessage(Message::mkError, "Could not read file %s", szFilename);
-		return;
-	}
-
-	fclose(pFile);
-
-	// Check the packet header
-	if (packet_magic != header.magic ||          // not par2-file
-		sizeof(PACKET_HEADER) > header.length || // packet length is too small
-		0 != (header.length & 3) ||              // packet length is not a multiple of 4
-		Util::FileSize(szFilename) < (int)header.length)       // packet would extend beyond the end of the file
-	{
-		// not par2-file or damaged header, ignoring the file
-		return;
-	}
-
-	char szSetId[33];
-	strncpy(szSetId, header.setid.print().c_str(), sizeof(szSetId));
-	szSetId[33-1] = '\0';
-	for (char* p = szSetId; *p; p++) *p = tolower(*p); // convert string to lowercase
-
-	debug("Renaming: %s; setid: %s", Util::BaseFileName(szFilename), szSetId);
-
-	char szDestFileName[1024];
-	int iNum = 1;
-	while (iNum == 1 || Util::FileExists(szDestFileName))
-	{
-		snprintf(szDestFileName, 1024, "%s%c%s.vol%03i+01.PAR2", szDestDir, PATH_SEPARATOR, szSetId, iNum);
-		szDestFileName[1024-1] = '\0';
-		iNum++;
-	}
-
-	PrintMessage(Message::mkInfo, "Renaming %s to %s", Util::BaseFileName(szFilename), Util::BaseFileName(szDestFileName));
-	if (Util::MoveFile(szFilename, szDestFileName))
-	{
-		m_iRenamedCount++;
-	}
-	else
-	{
-		char szErrBuf[256];
-		PrintMessage(Message::mkError, "Could not rename %s to %s: %s", szFilename, szDestFileName,
-			Util::GetLastErrorMessage(szErrBuf, sizeof(szErrBuf)));
-	}
-}
-
-#endif