version 0.5.1

.gitattributes

@@ -1,25 +0,0 @@
-* text=auto
-
-# Use CRLF for certain Windows files.
-*.vcproj                        eol=crlf
-*.sln                           eol=crlf
-*.bat                           eol=crlf
-README-WINDOWS.txt              eol=crlf
-nzbget-setup.nsi                eol=crlf
-windows/package-info.json       eol=crlf
-windows/resources/resource.h    eol=crlf
-windows/resources/nzbget.rc     eol=crlf
-
-# Configure GitHub's language detector
-lib/*               linguist-vendored linguist-language=C++
-webui/lib/*         linguist-vendored
-Makefile.in         linguist-vendored
-configure           linguist-vendored
-config.sub          linguist-vendored
-aclocal.m4          linguist-vendored
-config.guess        linguist-vendored
-depcomp             linguist-vendored
-install-sh          linguist-vendored
-missing             linguist-vendored
-configure.ac        linguist-vendored=false
-Makefile.am         linguist-vendored=false

.gitignore

@@ -1,63 +0,0 @@
-# Compiled Object files
-*.slo
-*.lo
-*.o
-*.obj
-
-# Precompiled Headers
-*.gch
-*.pch
-
-# Compiled Dynamic libraries
-*.so
-*.dylib
-*.dll
-
-# Compiled Static libraries
-*.lai
-*.la
-*.a
-*.lib
-
-# Executables
-*.exe
-*.out
-
-# GNU Autotools
-.deps/
-config.h
-config.log
-config.status
-Makefile
-stamp-h1
-autom4te.cache/
-
-# Visual Studio User-specific files
-*.suo
-*.user
-*.userosscache
-*.sln.docstates
-.vs/
-ipch/
-*.aps
-*.ncb
-*.opensdf
-*.sdf
-*.cachefile
-*.ilk
-*.pch
-*.pdb
-*.pgc
-*.pgd
-*.rsp
-*.sbr
-*.vspscc
-*.vssscc
-*.pidb
-*.svclog
-*.scc
-*.sln
-
-# NZBGet specific
-nzbget
-code_revision.cpp

AUTHORS

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

ArticleDownloader.h

@@ -1,8 +1,8 @@
 /*
  *  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>
+ *  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,13 +28,15 @@
 #define ARTICLEDOWNLOADER_H
 
 #include <time.h>
+#ifdef WIN32
+#include <sys/timeb.h>
+#endif
 
 #include "Observer.h"
 #include "DownloadInfo.h"
 #include "Thread.h"
 #include "NNTPConnection.h"
 #include "Decoder.h"
-#include "ArticleWriter.h"
 
 class ArticleDownloader : public Thread, public Subject
 {
@@ -43,25 +45,17 @@ public:
 	{
 		adUndefined,
 		adRunning,
-		adWaiting,
 		adFinished,
 		adFailed,
-		adRetry,
+		adDecodeError,
 		adCrcError,
+		adDecoding,
+		adJoining,
+		adJoined,
 		adNotFound,
 		adConnectError,
 		adFatalError
 	};
-
-	class ArticleWriterImpl : public ArticleWriter
-	{
-	private:
-		 ArticleDownloader*		m_pOwner;
-	protected:
-		virtual void	SetLastUpdateTimeNow() { m_pOwner->SetLastUpdateTimeNow(); } 
-	public:
-		void			SetOwner(ArticleDownloader* pOwner) { m_pOwner = pOwner; }
-	};
 			
 private:
 	FileInfo*			m_pFileInfo;
@@ -69,49 +63,66 @@ private:
 	NNTPConnection* 	m_pConnection;
 	EStatus				m_eStatus;
 	Mutex			 	m_mutexConnection;
-	char*				m_szInfoName;
-	char				m_szConnectionName[250];
+	const char*			m_szResultFilename;
+	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;
-	ArticleWriterImpl	m_ArticleWriter;
-	ServerStatList		m_ServerStats;
-	bool				m_bWritingStarted;
-	int					m_iDownloadedSize;
+	FILE*				m_pOutFile;
+	bool				m_bDuplicate;
 
 	EStatus				Download();
+	bool				Write(char* szLine, int iLen);
+	bool				PrepareFile(char* szLine);
 	EStatus				DecodeCheck();
 	void				FreeConnection(bool bKeepConnected);
 	EStatus				CheckResponse(const char* szResponse, const char* szComment);
-	void				SetStatus(EStatus eStatus) { m_eStatus = eStatus; }
-	bool				Write(char* szLine, int iLen);
-	void				AddServerData();
 
 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; }
 	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);
+	void 				SetOutputFilename(const char* v);
 	const char* 		GetArticleFilename() { return m_szArticleFilename; }
-	void				SetInfoName(const char* szInfoName);
+	void				SetInfoName(const char* v);
 	const char*			GetInfoName() { return m_szInfoName; }
-	const char*			GetConnectionName() { return m_szConnectionName; }
+	void				CompleteFileParts();
+	static bool			MoveCompletedFiles(NZBInfo* pNZBInfo, const char* szOldDestDir);
 	void				SetConnection(NNTPConnection* pConnection) { m_pConnection = pConnection; }
-	void				CompleteFileParts() { m_ArticleWriter.CompleteFileParts(); }
-	int					GetDownloadedSize() { return m_iDownloadedSize; }
 
 	void				LogDebugInfo();
 };
 
+class DownloadSpeedMeter
+{
+public:
+	virtual				~DownloadSpeedMeter() {};
+	virtual float		CalcCurrentDownloadSpeed() = 0;
+	virtual void		AddSpeedReading(int iBytes) = 0;
+};
+
+class NZBInfoLocker
+{
+public:
+	virtual				~NZBInfoLocker() {};
+	virtual void		LockNZBInfo(NZBInfo* pNZBInfo) = 0;
+	virtual void		UnlockNZBInfo(NZBInfo* pNZBInfo) = 0;
+};
+
 #endif

BinRpc.cpp

@@ -0,0 +1,791 @@
+/*
+ *  This file is 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>
+#include <cstdio>
+#include <fstream>
+#ifndef WIN32
+#include <unistd.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#endif
+
+#include "nzbget.h"
+#include "BinRpc.h"
+#include "Log.h"
+#include "Options.h"
+#include "QueueCoordinator.h"
+#include "QueueEditor.h"
+#include "PrePostProcessor.h"
+#include "Util.h"
+
+extern Options* g_pOptions;
+extern QueueCoordinator* g_pQueueCoordinator;
+extern PrePostProcessor* g_pPrePostProcessor;
+extern void ExitProc();
+
+const char* g_szMessageRequestNames[] =
+    { "N/A", "Download", "Pause/Unpause", "List", "Set download rate", "Dump debug", 
+		"Edit queue", "Log", "Quit", "Version", "Post-queue" };
+
+const unsigned int g_iMessageRequestSizes[] =
+    { 0,
+		sizeof(SNZBDownloadRequest),
+		sizeof(SNZBPauseUnpauseRequest),
+		sizeof(SNZBListRequest),
+		sizeof(SNZBSetDownloadRateRequest),
+		sizeof(SNZBDumpDebugRequest),
+		sizeof(SNZBEditQueueRequest),
+		sizeof(SNZBLogRequest),
+		sizeof(SNZBShutdownRequest),
+		sizeof(SNZBVersionRequest),
+		sizeof(SNZBPostQueueRequest),
+    };
+
+//*****************************************************************
+// BinProcessor
+
+void BinRpcProcessor::Execute()
+{
+	// Read the first package which needs to be a request
+	int iBytesReceived = recv(m_iSocket, ((char*)&m_MessageBase) + sizeof(m_MessageBase.m_iSignature), sizeof(m_MessageBase) - sizeof(m_MessageBase.m_iSignature), 0);
+	if (iBytesReceived < 0)
+	{
+		return;
+	}
+
+	// Make sure this is a nzbget request from a client
+	if ((int)ntohl(m_MessageBase.m_iSignature) != (int)NZBMESSAGE_SIGNATURE)
+	{
+		warn("Non-nzbget request received on port %i from %s", g_pOptions->GetServerPort(), m_szClientIP);
+		return;
+	}
+
+	if (strcmp(m_MessageBase.m_szPassword, g_pOptions->GetServerPassword()))
+	{
+		warn("nzbget request received on port %i from %s, but password invalid", g_pOptions->GetServerPort(), m_szClientIP);
+		return;
+	}
+
+	debug("%s request received from %s", g_szMessageRequestNames[ntohl(m_MessageBase.m_iType)], m_szClientIP);
+
+	Dispatch();
+}
+
+void BinRpcProcessor::Dispatch()
+{
+	if (ntohl(m_MessageBase.m_iType) >= (int)eRemoteRequestDownload &&
+		   ntohl(m_MessageBase.m_iType) <= (int)eRemoteRequestPostQueue &&
+		   g_iMessageRequestSizes[ntohl(m_MessageBase.m_iType)] != ntohl(m_MessageBase.m_iStructSize))
+	{
+		error("Invalid size of request: needed %i Bytes, but received %i Bytes",
+			 g_iMessageRequestSizes[ntohl(m_MessageBase.m_iType)], ntohl(m_MessageBase.m_iStructSize));
+		return;
+	}
+	
+	BinCommand* command = NULL;
+
+	switch (ntohl(m_MessageBase.m_iType))
+	{
+		case eRemoteRequestDownload:
+			{
+				command = new DownloadBinCommand();
+				break;
+			}
+
+		case eRemoteRequestList:
+			{
+				command = new ListBinCommand();
+				break;
+			}
+
+		case eRemoteRequestLog:
+			{
+				command = new LogBinCommand();
+				break;
+			}
+
+		case eRemoteRequestPauseUnpause:
+			{
+				command = new PauseUnpauseBinCommand();
+				break;
+			}
+
+		case eRemoteRequestEditQueue:
+			{
+				command = new EditQueueBinCommand();
+				break;
+			}
+
+		case eRemoteRequestSetDownloadRate:
+			{
+				command = new SetDownloadRateBinCommand();
+				break;
+			}
+
+		case eRemoteRequestDumpDebug:
+			{
+				command = new DumpDebugBinCommand();
+				break;
+			}
+
+		case eRemoteRequestShutdown:
+			{
+				command = new ShutdownBinCommand();
+				break;
+			}
+
+		case eRemoteRequestVersion:
+			{
+				command = new VersionBinCommand();
+				break;
+			}
+
+		case eRemoteRequestPostQueue:
+			{
+				command = new PostQueueBinCommand();
+				break;
+			}
+
+		case eRemoteRequestWriteLog:
+			{
+				command = new WriteLogBinCommand();
+				break;
+			}
+
+		default:
+			error("Received unsupported request %i", ntohl(m_MessageBase.m_iType));
+			break;
+	}
+
+	if (command)
+	{
+		command->SetSocket(m_iSocket);
+		command->SetMessageBase(&m_MessageBase);
+		command->Execute();
+		delete command;
+	}
+}
+
+//*****************************************************************
+// Commands
+
+void BinCommand::SendBoolResponse(bool bSuccess, const char* szText)
+{
+	// all bool-responses have the same format of structure, we use SNZBDownloadResponse here
+	SNZBDownloadResponse BoolResponse;
+	memset(&BoolResponse, 0, sizeof(BoolResponse));
+	BoolResponse.m_MessageBase.m_iSignature = htonl(NZBMESSAGE_SIGNATURE);
+	BoolResponse.m_MessageBase.m_iStructSize = htonl(sizeof(BoolResponse));
+	BoolResponse.m_bSuccess = htonl(bSuccess);
+	int iTextLen = strlen(szText) + 1;
+	BoolResponse.m_iTrailingDataLength = htonl(iTextLen);
+
+	// Send the request answer
+	send(m_iSocket, (char*) &BoolResponse, sizeof(BoolResponse), 0);
+	send(m_iSocket, (char*)szText, iTextLen, 0);
+}
+
+bool BinCommand::ReceiveRequest(void* pBuffer, int iSize)
+{
+	memcpy(pBuffer, m_pMessageBase, sizeof(SNZBRequestBase));
+	iSize -= sizeof(SNZBRequestBase);
+	if (iSize > 0)
+	{
+		int iBytesReceived = recv(m_iSocket, ((char*)pBuffer) + sizeof(SNZBRequestBase), iSize, 0);
+		if (iBytesReceived != iSize)
+		{
+			error("invalid request");
+			return false;
+		}
+	}
+	return true;
+}
+
+void PauseUnpauseBinCommand::Execute()
+{
+	SNZBPauseUnpauseRequest PauseUnpauseRequest;
+	if (!ReceiveRequest(&PauseUnpauseRequest, sizeof(PauseUnpauseRequest)))
+	{
+		return;
+	}
+
+	g_pOptions->SetPause(ntohl(PauseUnpauseRequest.m_bPause));
+	SendBoolResponse(true, "Pause-/Unpause-Command completed successfully");
+}
+
+void SetDownloadRateBinCommand::Execute()
+{
+	SNZBSetDownloadRateRequest SetDownloadRequest;
+	if (!ReceiveRequest(&SetDownloadRequest, sizeof(SetDownloadRequest)))
+	{
+		return;
+	}
+
+	g_pOptions->SetDownloadRate(ntohl(SetDownloadRequest.m_iDownloadRate) / 1024.0f);
+	SendBoolResponse(true, "Rate-Command completed successfully");
+}
+
+void DumpDebugBinCommand::Execute()
+{
+	SNZBDumpDebugRequest DumpDebugRequest;
+	if (!ReceiveRequest(&DumpDebugRequest, sizeof(DumpDebugRequest)))
+	{
+		return;
+	}
+
+	g_pQueueCoordinator->LogDebugInfo();
+	SendBoolResponse(true, "Debug-Command completed successfully");
+}
+
+void ShutdownBinCommand::Execute()
+{
+	SNZBShutdownRequest ShutdownRequest;
+	if (!ReceiveRequest(&ShutdownRequest, sizeof(ShutdownRequest)))
+	{
+		return;
+	}
+
+	SendBoolResponse(true, "Stopping server");
+	ExitProc();
+}
+
+void VersionBinCommand::Execute()
+{
+	SNZBVersionRequest VersionRequest;
+	if (!ReceiveRequest(&VersionRequest, sizeof(VersionRequest)))
+	{
+		return;
+	}
+
+	SendBoolResponse(true, VERSION);
+}
+
+void DownloadBinCommand::Execute()
+{
+	SNZBDownloadRequest DownloadRequest;
+	if (!ReceiveRequest(&DownloadRequest, sizeof(DownloadRequest)))
+	{
+		return;
+	}
+
+	char* pRecvBuffer = (char*)malloc(ntohl(DownloadRequest.m_iTrailingDataLength) + 1);
+	char* pBufPtr = pRecvBuffer;
+
+	// Read from the socket until nothing remains
+	int iResult = 0;
+	int NeedBytes = ntohl(DownloadRequest.m_iTrailingDataLength);
+	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(DownloadRequest.m_szFilename, DownloadRequest.m_szCategory, pRecvBuffer, ntohl(DownloadRequest.m_iTrailingDataLength));
+
+		if (pNZBFile)
+		{
+			info("Request: Queue collection %s", DownloadRequest.m_szFilename);
+			g_pQueueCoordinator->AddNZBFileToQueue(pNZBFile, ntohl(DownloadRequest.m_bAddFirst));
+			delete pNZBFile;
+
+			char tmp[1024];
+			snprintf(tmp, 1024, "Collection %s added to queue", Util::BaseFileName(DownloadRequest.m_szFilename));
+			tmp[1024-1] = '\0';
+			SendBoolResponse(true, tmp);
+		}
+		else
+		{
+			char tmp[1024];
+			snprintf(tmp, 1024, "Download Request failed for %s", Util::BaseFileName(DownloadRequest.m_szFilename));
+			tmp[1024-1] = '\0';
+			SendBoolResponse(false, tmp);
+		}
+	}
+
+	free(pRecvBuffer);
+}
+
+void ListBinCommand::Execute()
+{
+	SNZBListRequest ListRequest;
+	if (!ReceiveRequest(&ListRequest, sizeof(ListRequest)))
+	{
+		return;
+	}
+
+	SNZBListResponse ListResponse;
+	memset(&ListResponse, 0, sizeof(ListResponse));
+	ListResponse.m_MessageBase.m_iSignature = htonl(NZBMESSAGE_SIGNATURE);
+	ListResponse.m_MessageBase.m_iStructSize = htonl(sizeof(ListResponse));
+	ListResponse.m_iEntrySize = htonl(sizeof(SNZBListResponseEntry));
+
+	char* buf = NULL;
+	int bufsize = 0;
+
+	if (ntohl(ListRequest.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(SNZBListResponseEntry);
+		for (DownloadQueue::iterator it = pDownloadQueue->begin(); it != pDownloadQueue->end(); it++)
+		{
+			FileInfo* pFileInfo = *it;
+			bufsize += strlen(pFileInfo->GetNZBInfo()->GetFilename()) + 1;
+			bufsize += strlen(pFileInfo->GetSubject()) + 1;
+			bufsize += strlen(pFileInfo->GetFilename()) + 1;
+			bufsize += strlen(pFileInfo->GetNZBInfo()->GetDestDir()) + 1;
+			bufsize += strlen(pFileInfo->GetNZBInfo()->GetCategory()) + 1;
+			// align struct to 4-bytes, needed by ARM-processor (and may be others)
+			bufsize += bufsize % 4 > 0 ? 4 - bufsize % 4 : 0;
+		}
+
+		buf = (char*) malloc(bufsize);
+		char* bufptr = buf;
+		for (DownloadQueue::iterator it = pDownloadQueue->begin(); it != pDownloadQueue->end(); it++)
+		{
+			unsigned long iSizeHi, iSizeLo;
+			FileInfo* pFileInfo = *it;
+			SNZBListResponseEntry* pListAnswer = (SNZBListResponseEntry*) bufptr;
+			pListAnswer->m_iID				= htonl(pFileInfo->GetID());
+			Util::SplitInt64(pFileInfo->GetSize(), &iSizeHi, &iSizeLo);
+			pListAnswer->m_iFileSizeLo		= htonl(iSizeLo);
+			pListAnswer->m_iFileSizeHi		= htonl(iSizeHi);
+			Util::SplitInt64(pFileInfo->GetRemainingSize(), &iSizeHi, &iSizeLo);
+			pListAnswer->m_iRemainingSizeLo	= htonl(iSizeLo);
+			pListAnswer->m_iRemainingSizeHi	= htonl(iSizeHi);
+			pListAnswer->m_bFilenameConfirmed = htonl(pFileInfo->GetFilenameConfirmed());
+			pListAnswer->m_bPaused			= htonl(pFileInfo->GetPaused());
+			pListAnswer->m_iNZBFilenameLen	= htonl(strlen(pFileInfo->GetNZBInfo()->GetFilename()) + 1);
+			pListAnswer->m_iSubjectLen		= htonl(strlen(pFileInfo->GetSubject()) + 1);
+			pListAnswer->m_iFilenameLen		= htonl(strlen(pFileInfo->GetFilename()) + 1);
+			pListAnswer->m_iDestDirLen		= htonl(strlen(pFileInfo->GetNZBInfo()->GetDestDir()) + 1);
+			pListAnswer->m_iCategoryLen		= htonl(strlen(pFileInfo->GetNZBInfo()->GetCategory()) + 1);
+			bufptr += sizeof(SNZBListResponseEntry);
+			strcpy(bufptr, pFileInfo->GetNZBInfo()->GetFilename());
+			bufptr += ntohl(pListAnswer->m_iNZBFilenameLen);
+			strcpy(bufptr, pFileInfo->GetSubject());
+			bufptr += ntohl(pListAnswer->m_iSubjectLen);
+			strcpy(bufptr, pFileInfo->GetFilename());
+			bufptr += ntohl(pListAnswer->m_iFilenameLen);
+			strcpy(bufptr, pFileInfo->GetNZBInfo()->GetDestDir());
+			bufptr += ntohl(pListAnswer->m_iDestDirLen);
+			strcpy(bufptr, pFileInfo->GetNZBInfo()->GetCategory());
+			bufptr += ntohl(pListAnswer->m_iCategoryLen);
+			// align struct to 4-bytes, needed by ARM-processor (and may be others)
+			if ((size_t)bufptr % 4 > 0)
+			{
+				pListAnswer->m_iCategoryLen = htonl(ntohl(pListAnswer->m_iCategoryLen) + 4 - (size_t)bufptr % 4);
+				memset(bufptr, 0, 4 - (size_t)bufptr % 4); //suppress valgrind warning "uninitialized data"
+				bufptr += 4 - (size_t)bufptr % 4;
+			}
+		}
+
+		g_pQueueCoordinator->UnlockQueue();
+
+		ListResponse.m_iNrTrailingEntries = htonl(NrEntries);
+		ListResponse.m_iTrailingDataLength = htonl(bufsize);
+	}
+
+	if (htonl(ListRequest.m_bServerState))
+	{
+		unsigned long iSizeHi, iSizeLo;
+		ListResponse.m_iDownloadRate = htonl((int)(g_pQueueCoordinator->CalcCurrentDownloadSpeed() * 1024));
+		Util::SplitInt64(g_pQueueCoordinator->CalcRemainingSize(), &iSizeHi, &iSizeLo);
+		ListResponse.m_iRemainingSizeHi = htonl(iSizeHi);
+		ListResponse.m_iRemainingSizeLo = htonl(iSizeLo);
+		ListResponse.m_iDownloadLimit = htonl((int)(g_pOptions->GetDownloadRate() * 1024));
+		ListResponse.m_bServerPaused = htonl(g_pOptions->GetPause());
+		ListResponse.m_iThreadCount = htonl(Thread::GetThreadCount() - 1); // not counting itself
+		PostQueue* pPostQueue = g_pPrePostProcessor->LockPostQueue();
+		ListResponse.m_iPostJobCount = htonl(pPostQueue->size());
+		g_pPrePostProcessor->UnlockPostQueue();
+
+		int iUpTimeSec, iDnTimeSec;
+		long long iAllBytes;
+		bool bStandBy;
+		g_pQueueCoordinator->CalcStat(&iUpTimeSec, &iDnTimeSec, &iAllBytes, &bStandBy);
+		ListResponse.m_iUpTimeSec = htonl(iUpTimeSec);
+		ListResponse.m_iDownloadTimeSec = htonl(iDnTimeSec);
+		ListResponse.m_bServerStandBy = htonl(bStandBy);
+		Util::SplitInt64(iAllBytes, &iSizeHi, &iSizeLo);
+		ListResponse.m_iDownloadedBytesHi = htonl(iSizeHi);
+		ListResponse.m_iDownloadedBytesLo = htonl(iSizeLo);
+	}
+
+	// Send the request answer
+	send(m_iSocket, (char*) &ListResponse, sizeof(ListResponse), 0);
+
+	// Send the data
+	if (bufsize > 0)
+	{
+		send(m_iSocket, buf, bufsize, 0);
+	}
+
+	if (buf)
+	{
+		free(buf);
+	}
+}
+
+void LogBinCommand::Execute()
+{
+	SNZBLogRequest LogRequest;
+	if (!ReceiveRequest(&LogRequest, sizeof(LogRequest)))
+	{
+		return;
+	}
+
+	Log::Messages* pMessages = g_pLog->LockMessages();
+
+	int iNrEntries = ntohl(LogRequest.m_iLines);
+	unsigned int iIDFrom = ntohl(LogRequest.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(SNZBLogResponseEntry);
+	for (unsigned int i = (unsigned int)iStart; i < pMessages->size(); i++)
+	{
+		Message* pMessage = (*pMessages)[i];
+		bufsize += strlen(pMessage->GetText()) + 1;
+		// align struct to 4-bytes, needed by ARM-processor (and may be others)
+		bufsize += bufsize % 4 > 0 ? 4 - bufsize % 4 : 0;
+	}
+
+	char* buf = (char*) malloc(bufsize);
+	char* bufptr = buf;
+	for (unsigned int i = (unsigned int)iStart; i < pMessages->size(); i++)
+	{
+		Message* pMessage = (*pMessages)[i];
+		SNZBLogResponseEntry* pLogAnswer = (SNZBLogResponseEntry*) bufptr;
+		pLogAnswer->m_iID = htonl(pMessage->GetID());
+		pLogAnswer->m_iKind = htonl(pMessage->GetKind());
+		pLogAnswer->m_tTime = htonl((int)pMessage->GetTime());
+		pLogAnswer->m_iTextLen = htonl(strlen(pMessage->GetText()) + 1);
+		bufptr += sizeof(SNZBLogResponseEntry);
+		strcpy(bufptr, pMessage->GetText());
+		bufptr += ntohl(pLogAnswer->m_iTextLen);
+		// align struct to 4-bytes, needed by ARM-processor (and may be others)
+		if ((size_t)bufptr % 4 > 0)
+		{
+			pLogAnswer->m_iTextLen = htonl(ntohl(pLogAnswer->m_iTextLen) + 4 - (size_t)bufptr % 4);
+			memset(bufptr, 0, 4 - (size_t)bufptr % 4); //suppress valgrind warning "uninitialized data"
+			bufptr += 4 - (size_t)bufptr % 4;
+		}
+	}
+
+	g_pLog->UnlockMessages();
+
+	SNZBLogResponse LogResponse;
+	LogResponse.m_MessageBase.m_iSignature = htonl(NZBMESSAGE_SIGNATURE);
+	LogResponse.m_MessageBase.m_iStructSize = htonl(sizeof(LogResponse));
+	LogResponse.m_iEntrySize = htonl(sizeof(SNZBLogResponseEntry));
+	LogResponse.m_iNrTrailingEntries = htonl(iNrEntries);
+	LogResponse.m_iTrailingDataLength = htonl(bufsize);
+
+	// Send the request answer
+	send(m_iSocket, (char*) &LogResponse, sizeof(LogResponse), 0);
+
+	// Send the data
+	if (bufsize > 0)
+	{
+		send(m_iSocket, buf, bufsize, 0);
+	}
+
+	free(buf);
+}
+
+void EditQueueBinCommand::Execute()
+{
+	SNZBEditQueueRequest EditQueueRequest;
+	if (!ReceiveRequest(&EditQueueRequest, sizeof(EditQueueRequest)))
+	{
+		return;
+	}
+
+	int iNrEntries = ntohl(EditQueueRequest.m_iNrTrailingEntries);
+	int iAction = ntohl(EditQueueRequest.m_iAction);
+	int iOffset = ntohl(EditQueueRequest.m_iOffset);
+	int iTextLen = ntohl(EditQueueRequest.m_iTextLen);
+	bool bSmartOrder = ntohl(EditQueueRequest.m_bSmartOrder);
+	unsigned int iBufLength = ntohl(EditQueueRequest.m_iTrailingDataLength);
+
+	if (iNrEntries * sizeof(int32_t) + iTextLen != iBufLength)
+	{
+		error("Invalid struct size");
+		return;
+	}
+
+	if (iNrEntries <= 0)
+	{
+		SendBoolResponse(false, "Edit-Command failed: no IDs specified");
+		return;
+	}
+
+	char* pBuf = (char*)malloc(iBufLength);
+	char* szText = NULL;
+	int32_t* pIDs = NULL;
+
+	// Read from the socket until nothing remains
+	char* pBufPtr = pBuf;
+	int NeedBytes = iBufLength;
+	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;
+	}
+	bool bOK = NeedBytes == 0;
+
+	if (bOK)
+	{
+		szText = iTextLen > 0 ? pBuf : NULL;
+		pIDs = (int32_t*)(pBuf + iTextLen);
+	}
+
+	QueueEditor::IDList cIDList;
+	cIDList.reserve(iNrEntries);
+	for (int i = 0; i < iNrEntries; i++)
+	{
+		cIDList.push_back(ntohl(pIDs[i]));
+	}
+
+	bOK = g_pQueueCoordinator->GetQueueEditor()->EditList(&cIDList, bSmartOrder, (QueueEditor::EEditAction)iAction, iOffset, szText);
+
+	free(pBuf);
+
+	if (bOK)
+	{
+		SendBoolResponse(true, "Edit-Command completed successfully");
+	}
+	else
+	{
+		SendBoolResponse(false, "Edit-Command failed");
+	}
+}
+
+void PostQueueBinCommand::Execute()
+{
+	SNZBPostQueueRequest PostQueueRequest;
+	if (!ReceiveRequest(&PostQueueRequest, sizeof(PostQueueRequest)))
+	{
+		return;
+	}
+
+	SNZBPostQueueResponse PostQueueResponse;
+	memset(&PostQueueResponse, 0, sizeof(PostQueueResponse));
+	PostQueueResponse.m_MessageBase.m_iSignature = htonl(NZBMESSAGE_SIGNATURE);
+	PostQueueResponse.m_MessageBase.m_iStructSize = htonl(sizeof(PostQueueResponse));
+	PostQueueResponse.m_iEntrySize = htonl(sizeof(SNZBPostQueueResponseEntry));
+
+	char* buf = NULL;
+	int bufsize = 0;
+
+	// Make a data structure and copy all the elements of the list into it
+	PostQueue* pPostQueue = g_pPrePostProcessor->LockPostQueue();
+
+	int NrEntries = pPostQueue->size();
+
+	// calculate required buffer size
+	bufsize = NrEntries * sizeof(SNZBPostQueueResponseEntry);
+	for (PostQueue::iterator it = pPostQueue->begin(); it != pPostQueue->end(); it++)
+	{
+		PostInfo* pPostInfo = *it;
+		bufsize += strlen(pPostInfo->GetNZBFilename()) + 1;
+		bufsize += strlen(pPostInfo->GetParFilename()) + 1;
+		bufsize += strlen(pPostInfo->GetInfoName()) + 1;
+		bufsize += strlen(pPostInfo->GetDestDir()) + 1;
+		bufsize += strlen(pPostInfo->GetProgressLabel()) + 1;
+		// align struct to 4-bytes, needed by ARM-processor (and may be others)
+		bufsize += bufsize % 4 > 0 ? 4 - bufsize % 4 : 0;
+	}
+
+	time_t tCurTime = time(NULL);
+	buf = (char*) malloc(bufsize);
+	char* bufptr = buf;
+
+	for (PostQueue::iterator it = pPostQueue->begin(); it != pPostQueue->end(); it++)
+	{
+		PostInfo* pPostInfo = *it;
+		SNZBPostQueueResponseEntry* pPostQueueAnswer = (SNZBPostQueueResponseEntry*) bufptr;
+		pPostQueueAnswer->m_iID				= htonl(pPostInfo->GetID());
+		pPostQueueAnswer->m_iStage			= htonl(pPostInfo->GetStage());
+		pPostQueueAnswer->m_iStageProgress	= htonl(pPostInfo->GetStageProgress());
+		pPostQueueAnswer->m_iFileProgress	= htonl(pPostInfo->GetFileProgress());
+		pPostQueueAnswer->m_iTotalTimeSec	= htonl((int)(pPostInfo->GetStartTime() ? tCurTime - pPostInfo->GetStartTime() : 0));
+		pPostQueueAnswer->m_iStageTimeSec	= htonl((int)(pPostInfo->GetStageTime() ? tCurTime - pPostInfo->GetStageTime() : 0));
+		pPostQueueAnswer->m_iNZBFilenameLen		= htonl(strlen(pPostInfo->GetNZBFilename()) + 1);
+		pPostQueueAnswer->m_iParFilename		= htonl(strlen(pPostInfo->GetParFilename()) + 1);
+		pPostQueueAnswer->m_iInfoNameLen		= htonl(strlen(pPostInfo->GetInfoName()) + 1);
+		pPostQueueAnswer->m_iDestDirLen			= htonl(strlen(pPostInfo->GetDestDir()) + 1);
+		pPostQueueAnswer->m_iProgressLabelLen	= htonl(strlen(pPostInfo->GetProgressLabel()) + 1);
+		bufptr += sizeof(SNZBPostQueueResponseEntry);
+		strcpy(bufptr, pPostInfo->GetNZBFilename());
+		bufptr += ntohl(pPostQueueAnswer->m_iNZBFilenameLen);
+		strcpy(bufptr, pPostInfo->GetParFilename());
+		bufptr += ntohl(pPostQueueAnswer->m_iParFilename);
+		strcpy(bufptr, pPostInfo->GetInfoName());
+		bufptr += ntohl(pPostQueueAnswer->m_iInfoNameLen);
+		strcpy(bufptr, pPostInfo->GetDestDir());
+		bufptr += ntohl(pPostQueueAnswer->m_iDestDirLen);
+		strcpy(bufptr, pPostInfo->GetProgressLabel());
+		bufptr += ntohl(pPostQueueAnswer->m_iProgressLabelLen);
+		// align struct to 4-bytes, needed by ARM-processor (and may be others)
+		if ((size_t)bufptr % 4 > 0)
+		{
+			pPostQueueAnswer->m_iProgressLabelLen = htonl(ntohl(pPostQueueAnswer->m_iProgressLabelLen) + 4 - (size_t)bufptr % 4);
+			memset(bufptr, 0, 4 - (size_t)bufptr % 4); //suppress valgrind warning "uninitialized data"
+			bufptr += 4 - (size_t)bufptr % 4;
+		}
+	}
+
+	g_pPrePostProcessor->UnlockPostQueue();
+
+	PostQueueResponse.m_iNrTrailingEntries = htonl(NrEntries);
+	PostQueueResponse.m_iTrailingDataLength = htonl(bufsize);
+
+	// Send the request answer
+	send(m_iSocket, (char*) &PostQueueResponse, sizeof(PostQueueResponse), 0);
+
+	// Send the data
+	if (bufsize > 0)
+	{
+		send(m_iSocket, buf, bufsize, 0);
+	}
+
+	if (buf)
+	{
+		free(buf);
+	}
+}
+
+void WriteLogBinCommand::Execute()
+{
+	SNZBWriteLogRequest WriteLogRequest;
+	if (!ReceiveRequest(&WriteLogRequest, sizeof(WriteLogRequest)))
+	{
+		return;
+	}
+
+	char* pRecvBuffer = (char*)malloc(ntohl(WriteLogRequest.m_iTrailingDataLength) + 1);
+	char* pBufPtr = pRecvBuffer;
+
+	// Read from the socket until nothing remains
+	int iResult = 0;
+	int NeedBytes = ntohl(WriteLogRequest.m_iTrailingDataLength);
+	pRecvBuffer[NeedBytes] = '\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)
+	{
+		bool OK = true;
+		switch ((Message::EKind)ntohl(WriteLogRequest.m_iKind))
+		{
+			case Message::mkDetail:
+				detail(pRecvBuffer);
+				break;
+			case Message::mkInfo:
+				info(pRecvBuffer);
+				break;
+			case Message::mkWarning:
+				warn(pRecvBuffer);
+				break;
+			case Message::mkError:
+				error(pRecvBuffer);
+				break;
+			case Message::mkDebug:
+				debug(pRecvBuffer);
+				break;
+			default:
+				OK = false;
+		}
+		SendBoolResponse(OK, OK ? "Message added to log" : "Invalid message-kind");
+	}
+
+	free(pRecvBuffer);
+}

BinRpc.h

@@ -0,0 +1,131 @@
+/*
+ *  This file is 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$
+ *
+ */
+
+
+#ifndef BINRPC_H
+#define BINRPC_H
+
+#include "Connection.h"
+#include "MessageBase.h"
+
+class BinRpcProcessor
+{
+private:
+	SOCKET				m_iSocket;
+	SNZBRequestBase		m_MessageBase;
+	const char*			m_szClientIP;
+
+	void				Dispatch();
+
+public:
+	void				Execute();
+	void				SetSocket(SOCKET iSocket) { m_iSocket = iSocket; }
+	void				SetSignature(int iSignature) { m_MessageBase.m_iSignature = iSignature; }
+	void				SetClientIP(const char* szClientIP) { m_szClientIP = szClientIP; }
+};
+
+class BinCommand
+{
+protected:
+	SOCKET				m_iSocket;
+	SNZBRequestBase*	m_pMessageBase;
+
+	bool				ReceiveRequest(void* pBuffer, int iSize);
+	void				SendBoolResponse(bool bSuccess, const char* szText);
+
+public:
+	virtual				~BinCommand() {}
+	virtual void		Execute() = 0;
+	void				SetSocket(SOCKET iSocket) { m_iSocket = iSocket; }
+	void				SetMessageBase(SNZBRequestBase*	pMessageBase) { m_pMessageBase = pMessageBase; }
+};
+
+class DownloadBinCommand: public BinCommand
+{
+public:
+	virtual void		Execute();
+};
+
+class ListBinCommand: public BinCommand
+{
+public:
+	virtual void		Execute();
+};
+
+class LogBinCommand: public BinCommand
+{
+public:
+	virtual void		Execute();
+};
+
+class PauseUnpauseBinCommand: public BinCommand
+{
+public:
+	virtual void		Execute();
+};
+
+class EditQueueBinCommand: public BinCommand
+{
+public:
+	virtual void		Execute();
+};
+
+class SetDownloadRateBinCommand: public BinCommand
+{
+public:
+	virtual void		Execute();
+};
+
+class DumpDebugBinCommand: public BinCommand
+{
+public:
+	virtual void		Execute();
+};
+
+class ShutdownBinCommand: public BinCommand
+{
+public:
+	virtual void		Execute();
+};
+
+class VersionBinCommand: public BinCommand
+{
+public:
+	virtual void		Execute();
+};
+
+class PostQueueBinCommand: public BinCommand
+{
+public:
+	virtual void		Execute();
+};
+
+class WriteLogBinCommand: public BinCommand
+{
+public:
+	virtual void		Execute();
+};
+
+#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$
@@ -74,11 +74,11 @@ void ColoredFrontend::PrintStatus()
 	char tmp[1024];
 	char timeString[100];
 	timeString[0] = '\0';
-	int iCurrentDownloadSpeed = m_bStandBy ? 0 : m_iCurrentDownloadSpeed;
+	float fCurrentDownloadSpeed = m_bStandBy ? 0 : m_fCurrentDownloadSpeed;
 
-	if (iCurrentDownloadSpeed > 0 && !m_bPauseDownload)
+	if (fCurrentDownloadSpeed > 0.0 && !m_bPause)
 	{
-		long long remain_sec = (long long)(m_lRemainingSize / iCurrentDownloadSpeed);
+		long long remain_sec = m_lRemainingSize / ((long long)(fCurrentDownloadSpeed * 1024));
 		int h = (int)(remain_sec / 3600);
 		int m = (int)((remain_sec % 3600) / 60);
 		int s = (int)(remain_sec % 60);
@@ -86,9 +86,9 @@ void ColoredFrontend::PrintStatus()
 	}
 
 	char szDownloadLimit[128];
-	if (m_iDownloadLimit > 0)
+	if (m_fDownloadLimit > 0.0f)
 	{
-		sprintf(szDownloadLimit, ", Limit %i KB/s", m_iDownloadLimit / 1024);
+		sprintf(szDownloadLimit, ", Limit %.0f KB/S", m_fDownloadLimit);
 	}
 	else
 	{
@@ -112,13 +112,9 @@ void ColoredFrontend::PrintStatus()
 	const char* szControlSeq = "\033[K";
 #endif
 
-	char szFileSize[20];
-	char szCurrendSpeed[20];
-	snprintf(tmp, 1024, " %d threads, %s, %s remaining%s%s%s%s%s\n",
-		m_iThreadCount, Util::FormatSpeed(szCurrendSpeed, sizeof(szCurrendSpeed), iCurrentDownloadSpeed),
-		Util::FormatSize(szFileSize, sizeof(szFileSize), m_lRemainingSize),
-		timeString, szPostStatus, m_bPauseDownload ? (m_bStandBy ? ", Paused" : ", Pausing") : "",
-		szDownloadLimit, szControlSeq);
+	snprintf(tmp, 1024, " %d threads, %.0f KB/s, %.2f MB remaining%s%s%s%s%s\n", 
+		m_iThreadCount, fCurrentDownloadSpeed, (float)(Util::Int64ToFloat(m_lRemainingSize) / 1024.0 / 1024.0), 
+		timeString, szPostStatus, m_bPause ? (m_bStandBy ? ", Paused" : ", Pausing") : "", szDownloadLimit, szControlSeq);
 	tmp[1024-1] = '\0';
 	printf("%s", tmp);
 	m_bNeedGoBack = true;

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,728 @@
+/*
+ *  This file if part of nzbget
+ *
+ *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007-2008 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
+// 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 <cstdio>
+#ifdef WIN32
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#else
+#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"
+#include "TLS.h"
+
+static const int CONNECTION_READBUFFER_SIZE = 1024;
+#ifndef DISABLE_TLS
+bool Connection::bTLSLibInitialized = false;
+#endif
+
+void Connection::Init(bool bTLS)
+{
+	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
+	if (bTLS)
+	{
+		debug("Initializing TLS library");
+		char* szErrStr;
+		int iRes = tls_lib_init(&szErrStr);
+		bTLSLibInitialized = iRes == TLS_EOK;
+		if (!bTLSLibInitialized)
+		{
+			error("Could not initialize TLS library: %s", szErrStr ? szErrStr : "unknown error");
+			if (szErrStr)
+			{
+				free(szErrStr);
+			}
+		}
+	}
+#endif
+}
+
+void Connection::Final()
+{
+	debug("Finalizing global connection data");
+
+#ifdef WIN32
+	WSACleanup();
+#endif
+
+#ifndef DISABLE_TLS
+	if (bTLSLibInitialized)
+	{
+		debug("Finalizing TLS library");
+		tls_lib_deinit();
+	}
+#endif
+}
+
+Connection::Connection(NetAddress* pNetAddress)
+{
+	debug("Creating Connection");
+
+	m_pNetAddress		= pNetAddress;
+	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_bAutoClose		= true;
+#ifndef DISABLE_TLS
+	m_pTLS				= NULL;
+	m_bTLSError			= false;
+#endif
+}
+
+Connection::Connection(SOCKET iSocket, bool bAutoClose)
+{
+	debug("Creating Connection");
+
+	m_pNetAddress		= NULL;
+	m_eStatus			= csConnected;
+	m_iSocket			= iSocket;
+	m_iBufAvail			= 0;
+	m_iTimeout			= 60;
+	m_bSuppressErrors	= true;
+	m_szReadBuf			= (char*)malloc(CONNECTION_READBUFFER_SIZE + 1);
+	m_bAutoClose		= bAutoClose;
+#ifndef DISABLE_TLS
+	m_pTLS				= NULL;
+#endif
+}
+
+Connection::~Connection()
+{
+	debug("Destroying Connection");
+
+	if (m_eStatus == csConnected && m_bAutoClose)
+	{
+		Disconnect();
+	}
+	free(m_szReadBuf);
+#ifndef DISABLE_TLS
+	if (m_pTLS)
+	{
+		free(m_pTLS);
+	}
+#endif
+}
+
+bool Connection::Connect()
+{
+	debug("Connecting");
+
+	if (m_eStatus == csConnected)
+		return true;
+
+	bool bRes = DoConnect();
+
+	if (bRes)
+		m_eStatus = csConnected;
+	else
+		Connection::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;
+}
+
+int Connection::Bind()
+{
+	debug("Binding");
+
+	if (m_eStatus == csListening)
+	{
+		return 0;
+	}
+
+	int iRes = DoBind();
+
+	if (iRes == 0)
+	{
+		m_eStatus = csListening;
+	}
+
+	return iRes;
+}
+
+int Connection::WriteLine(const char* pBuffer)
+{
+	//debug("Connection::write(char* line)");
+
+	if (m_eStatus != csConnected)
+	{
+		return -1;
+	}
+
+	int iRes = DoWriteLine(pBuffer);
+
+	return iRes;
+}
+
+int Connection::Send(const 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, int* pBytesRead)
+{
+	if (m_eStatus != csConnected)
+	{
+		return NULL;
+	}
+
+	char* res = DoReadLine(pBuffer, iSize, pBytesRead);
+
+	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, true, 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;
+
+	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");
+
+	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_pNetAddress->GetPort());
+
+	int res = getaddrinfo(m_pNetAddress->GetHost(), iPortStr, &addr_hints, &addr_list);
+	if (res != 0)
+	{
+		ReportError("Could not resolve hostname %s", m_pNetAddress->GetHost(), true, 0);
+		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)
+		{
+			res = connect(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);
+
+	if (m_iSocket == INVALID_SOCKET)
+	{
+		ReportError("Connection to %s failed!", m_pNetAddress->GetHost(), true, 0);
+		return false;
+	} 
+
+#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, true, 0);
+	}
+
+	return true;
+}
+
+bool Connection::DoDisconnect()
+{
+	debug("Do disconnecting");
+
+	if (m_iSocket > 0)
+	{
+		closesocket(m_iSocket);
+		m_iSocket = INVALID_SOCKET;
+#ifndef DISABLE_TLS
+		if (m_pTLS)
+		{
+			CloseTLS();
+		}
+#endif
+	}
+
+	m_eStatus = csDisconnected;
+	return true;
+}
+
+int Connection::DoWriteLine(const char* pBuffer)
+{
+	//debug("Connection::doWrite()");
+	return send(m_iSocket, pBuffer, strlen(pBuffer), 0);
+}
+
+char* Connection::DoReadLine(char* pBuffer, int iSize, int* pBytesRead)
+{
+	//debug( "Connection::DoReadLine()" );
+	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;
+	}
+	
+	if (pBufPtr == pBuffer)
+	{
+		return NULL;
+	}
+	return pBuffer;
+}
+
+int Connection::DoBind()
+{
+	debug("Do binding");
+
+	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_pNetAddress->GetPort());
+
+	int res = getaddrinfo(m_pNetAddress->GetHost(), iPortStr, &addr_hints, &addr_list);
+	if (res != 0)
+	{
+		error( "Could not resolve hostname %s", m_pNetAddress->GetHost() );
+		return -1;
+	}
+
+	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);
+
+	if (m_iSocket == INVALID_SOCKET)
+	{
+		ReportError("Binding socket failed for %s", m_pNetAddress->GetHost(), true, 0);
+		return -1;
+	}
+
+	if (listen(m_iSocket, 10) < 0)
+	{
+		ReportError("Listen on socket failed for %s", m_pNetAddress->GetHost(), true, 0);
+		return -1;
+	}
+
+	return 0;
+}
+
+SOCKET Connection::DoAccept()
+{
+	SOCKET iSocket = accept(GetSocket(), NULL, NULL);
+
+	if (iSocket == INVALID_SOCKET && m_eStatus != csCancelled)
+	{
+		ReportError("Could not accept connection", NULL, true, 0);
+	}
+
+	return iSocket;
+}
+
+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 ErrCode)
+{
+#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)
+	{
+		if (ErrCode == 0)
+		{
+#ifdef WIN32
+			ErrCode = WSAGetLastError();
+#else
+			ErrCode = errno;
+#endif
+		}
+#ifdef WIN32
+		if (m_bSuppressErrors)
+		{
+			debug("%s: ErrNo %i", szErrPrefix, ErrCode);
+		}
+		else
+		{
+			error("%s: ErrNo %i", szErrPrefix, ErrCode);
+		}
+#else
+		const char* szErrMsg = hstrerror(ErrCode);
+		if (m_bSuppressErrors)
+		{
+			debug("%s: ErrNo %i, %s", szErrPrefix, ErrCode, szErrMsg);
+		}
+		else
+		{
+			error("%s: ErrNo %i, %s", szErrPrefix, ErrCode, szErrMsg);
+		}
+#endif
+	}
+	else
+	{
+		if (m_bSuppressErrors)
+		{
+			debug(szErrPrefix);
+		}
+		else
+		{
+			error(szErrPrefix);
+		}
+	}
+}
+
+#ifndef DISABLE_TLS
+bool Connection::CheckTLSResult(int iResultCode, char* szErrStr, const char* szErrMsgPrefix)
+{
+	bool bOK = iResultCode == TLS_EOK;
+	if (!bOK)
+	{
+		ReportError(szErrMsgPrefix, szErrStr ? szErrStr : "unknown error", false, 0);
+		if (szErrStr)
+		{
+			free(szErrStr);
+		}
+	}
+	return bOK;
+}
+
+bool Connection::StartTLS()
+{
+	debug("Starting TLS");
+
+	if (m_pTLS)
+	{
+		free(m_pTLS);
+	}
+
+	m_pTLS = malloc(sizeof(tls_t));
+	tls_t* pTLS = (tls_t*)m_pTLS;
+	memset(pTLS, 0, sizeof(tls_t));
+	tls_clear(pTLS);
+
+	char* szErrStr;
+	int iRes;
+		
+	iRes = tls_init(pTLS, NULL, NULL, NULL, 0, &szErrStr);
+	if (!CheckTLSResult(iRes, szErrStr, "Could not initialize TLS-object: %s"))
+	{
+		return false;
+	}
+
+	debug("tls_start...");
+	iRes = tls_start(pTLS, (int)m_iSocket, NULL, 1, NULL, &szErrStr);
+	debug("tls_start...%i", iRes);
+	if (!CheckTLSResult(iRes, szErrStr, "Could not establish secure connection: %s"))
+	{
+		return false;
+	}
+
+	return true;
+}
+
+void Connection::CloseTLS()
+{
+	tls_close((tls_t*)m_pTLS);
+	free(m_pTLS);
+	m_pTLS = NULL;
+}
+
+int Connection::recv(SOCKET s, char* buf, int len, int flags)
+{
+	size_t iReceived = 0;
+	
+	if (m_pTLS)
+	{
+		m_bTLSError = false;
+		char* szErrStr;
+		int iRes = tls_getbuf((tls_t*)m_pTLS, buf, len, &iReceived, &szErrStr);
+		if (!CheckTLSResult(iRes, szErrStr, "Could not read from TLS-socket: %s"))
+		{
+			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)
+{
+	if (m_pTLS)
+	{
+		m_bTLSError = false;
+		char* szErrStr;
+		int iRes = tls_putbuf((tls_t*)m_pTLS, buf, len, &szErrStr);
+		if (!CheckTLSResult(iRes, szErrStr, "Could not send to TLS-socket: %s"))
+		{
+			m_bTLSError = true;
+			return -1;
+		}
+		return 0;
+	}
+	else
+	{
+		int iRet = ::send(s, buf, len, flags);
+		return iRet;
+	}
+}
+#endif

Connection.h

@@ -0,0 +1,100 @@
+/*
+ *  This file if part of nzbget
+ *
+ *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007-2008 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;
+	char*				m_szReadBuf;
+	int					m_iBufAvail;
+	char*				m_szBufPtr;
+	EStatus				m_eStatus;
+	int					m_iTimeout;
+	bool				m_bSuppressErrors;
+	bool				m_bAutoClose;
+#ifndef DISABLE_TLS
+	void*				m_pTLS;
+	static bool			bTLSLibInitialized;
+	bool				m_bTLSError;
+#endif
+
+	void				ReportError(const char* szMsgPrefix, const char* szMsgArg, bool PrintErrCode, int ErrCode);
+	virtual bool 		DoConnect();
+	virtual bool		DoDisconnect();
+	int					DoBind();
+	int					DoWriteLine(const char* pBuffer);
+	char*				DoReadLine(char* pBuffer, int iSize, int* pBytesRead);
+	SOCKET				DoAccept();
+#ifndef DISABLE_TLS
+	bool				CheckTLSResult(int iResultCode, char* szErrStr, const char* szErrMsgPrefix);
+	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(NetAddress* pNetAddress);
+						Connection(SOCKET iSocket, bool bAutoClose);
+	virtual 			~Connection();
+	static void			Init(bool bTLS);
+	static void			Final();
+	bool 				Connect();
+	bool				Disconnect();
+	int					Bind();
+	int					Send(const char* pBuffer, int iSize);
+	int					Recv(char* pBuffer, int iSize);
+	bool				RecvAll(char* pBuffer, int iSize);
+	char*				ReadLine(char* pBuffer, int iSize, int* pBytesRead);
+	int					WriteLine(const char* pBuffer);
+	SOCKET				Accept();
+	void				Cancel();
+	NetAddress*			GetServer() { return m_pNetAddress; }
+	SOCKET				GetSocket() { return m_iSocket; }
+	void				SetTimeout(int iTimeout) { m_iTimeout = iTimeout; }
+	EStatus				GetStatus() { return m_eStatus; }
+	void				SetSuppressErrors(bool bSuppressErrors) { m_bSuppressErrors = bSuppressErrors; }
+	bool				GetSuppressErrors() { return m_bSuppressErrors; }
+#ifndef DISABLE_TLS
+	bool				StartTLS();
+#endif
+};
+
+#endif

Decoder.cpp

@@ -1,7 +1,8 @@
 /*
  *  This file is part of nzbget
  *
- *  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
@@ -15,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$
@@ -24,7 +25,7 @@
 
 
 #ifdef HAVE_CONFIG_H
-#include "config.h"
+#include <config.h>
 #endif
 
 #ifdef WIN32
@@ -44,11 +45,14 @@
 #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;
 }
 
@@ -56,23 +60,29 @@ Decoder::~ Decoder()
 {
 	debug("Destroying Decoder");
 
-	free(m_szArticleFilename);
+	if (m_szArticleFilename)
+	{
+		free(m_szArticleFilename);
+	}
 }
 
 void Decoder::Clear()
 {
-	free(m_szArticleFilename);
+	if (m_szArticleFilename)
+	{
+		free(m_szArticleFilename);
+	}
 	m_szArticleFilename = NULL;
 }
 
-Decoder::EFormat Decoder::DetectFormat(const char* buffer, int len, bool inBody)
+Decoder::EFormat Decoder::DetectFormat(const char* buffer, int len)
 {
 	if (!strncmp(buffer, "=ybegin ", 8))
 	{
 		return efYenc;
 	}
 	
-	if (inBody && (len == 62 || len == 63) && (buffer[62] == '\n' || buffer[62] == '\r') && *buffer == 'M')
+	if ((len == 62 || len == 63) && (buffer[62] == '\n' || buffer[62] == '\r') && *buffer == 'M')
 	{
 		return efUx;
 	}
@@ -103,6 +113,17 @@ Decoder::EFormat Decoder::DetectFormat(const char* buffer, int len, bool inBody)
   * YDecoder: fast implementation of yEnc-Decoder
   */
 
+void YDecoder::Init()
+{
+	debug("Initializing global decoder");
+	crc32gentab();
+}
+
+void YDecoder::Final()
+{
+	debug("Finalizing global Decoder");
+}
+
 YDecoder::YDecoder()
 {
 	Clear();
@@ -123,10 +144,66 @@ void YDecoder::Clear()
 	m_iEnd = 0;
 	m_iSize = 0;
 	m_iEndSize = 0;
+	m_bAutoSeek = false;
+	m_bNeedSetPos = false;
 	m_bCrcCheck = false;
 }
 
-int YDecoder::DecodeBuffer(char* buffer, int len)
+/* 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)
 	{
@@ -144,7 +221,7 @@ int YDecoder::DecodeBuffer(char* buffer, int len)
 			if (pb) 
 			{
 				pb += 6; //=strlen(" size=")
-				m_iEndSize = (long long)atoll(pb);
+				m_iEndSize = (int)atoi(pb);
 			}
 			return 0;
 		}
@@ -176,9 +253,9 @@ BreakLoop:
 
 		if (m_bCrcCheck)
 		{
-			m_lCalculatedCRC = Util::Crc32m(m_lCalculatedCRC, (unsigned char *)buffer, (unsigned int)(optr - buffer));
+			m_lCalculatedCRC = crc32m(m_lCalculatedCRC, (unsigned char *)buffer, (unsigned int)(optr - buffer));
 		}
-		return optr - buffer;
+		return (unsigned int)(optr - buffer);
 	}
 	else 
 	{
@@ -191,7 +268,10 @@ BreakLoop:
 				pb += 6; //=strlen(" name=")
 				char* pe;
 				for (pe = pb; *pe != '\0' && *pe != '\n' && *pe != '\r'; pe++) ;
-				free(m_szArticleFilename);
+				if (m_szArticleFilename)
+				{
+					free(m_szArticleFilename);
+				}
 				m_szArticleFilename = (char*)malloc(pe - pb + 1);
 				strncpy(m_szArticleFilename, pb, pe - pb);
 				m_szArticleFilename[pe - pb] = '\0';
@@ -200,7 +280,7 @@ BreakLoop:
 			if (pb) 
 			{
 				pb += 6; //=strlen(" size=")
-				m_iSize = (long long)atoll(pb);
+				m_iSize = (int)atoi(pb);
 			}
 			m_bPart = strstr(buffer, " part=");
 			if (!m_bPart)
@@ -218,13 +298,13 @@ BreakLoop:
 			if (pb) 
 			{
 				pb += 7; //=strlen(" begin=")
-				m_iBegin = (long long)atoll(pb);
+				m_iBegin = (int)atoi(pb);
 			}
 			pb = strstr(buffer, " end=");
 			if (pb) 
 			{
 				pb += 5; //=strlen(" end=")
-				m_iEnd = (long long)atoll(pb);
+				m_iEnd = (int)atoi(pb);
 			}
 		}
 	}
@@ -232,6 +312,28 @@ BreakLoop:
 	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 == 0 || !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;
@@ -286,7 +388,7 @@ void UDecoder::Clear()
 
 #define UU_DECODE_CHAR(c) (c == '`' ? 0 : (((c) - ' ') & 077))
 
-int UDecoder::DecodeBuffer(char* buffer, int len)
+unsigned int UDecoder::DecodeBuffer(char* buffer, int len)
 {
 	if (!m_bBody)
 	{
@@ -302,7 +404,10 @@ int UDecoder::DecodeBuffer(char* buffer, int len)
 			// extracting filename
 			char* pe;
 			for (pe = pb; *pe != '\0' && *pe != '\n' && *pe != '\r'; pe++) ;
-			free(m_szArticleFilename);
+			if (m_szArticleFilename)
+			{
+				free(m_szArticleFilename);
+			}
 			m_szArticleFilename = (char*)malloc(pe - pb + 1);
 			strncpy(m_szArticleFilename, pb, pe - pb);
 			m_szArticleFilename[pe - pb] = '\0';
@@ -353,12 +458,22 @@ int UDecoder::DecodeBuffer(char* buffer, int len)
 			}
 		}
 
-		return optr - buffer;
+		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)

Decoder.h

@@ -1,7 +1,8 @@
 /*
  *  This file is part of nzbget
  *
- *  Copyright (C) 2007-2014 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007-2008 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 +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$
@@ -49,6 +50,8 @@ public:
 	static const char* FormatNames[];
 
 protected:
+	const char*				m_szSrcFilename;
+	const char*				m_szDestFilename;
 	char*					m_szArticleFilename;
 
 public:
@@ -56,14 +59,17 @@ public:
 	virtual					~Decoder();
 	virtual EStatus			Check() = 0;
 	virtual void			Clear();
-	virtual int				DecodeBuffer(char* buffer, int len) = 0;
+	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, bool inBody);
+	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;
@@ -71,23 +77,28 @@ protected:
 	bool					m_bCrc;
 	unsigned long			m_lExpectedCRC;
 	unsigned long			m_lCalculatedCRC;
-	long long				m_iBegin;
-	long long				m_iEnd;
-	long long				m_iSize;
-	long long				m_iEndSize;
+	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 int				DecodeBuffer(char* buffer, int len);
+	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; }
-	long long				GetBegin() { return m_iBegin; }
-	long long				GetEnd() { return m_iEnd; }
-	long long				GetSize() { return m_iSize; }
-	unsigned long			GetExpectedCrc() { return m_lExpectedCRC; }
-	unsigned long			GetCalculatedCrc() { return m_lCalculatedCRC; }
+
+	static void				Init();
+	static void				Final();
 };
 
 class UDecoder: public Decoder
@@ -96,11 +107,13 @@ private:
 	bool					m_bBody;
 	bool					m_bEnd;
 
+	unsigned int			DecodeBuffer(char* buffer, int len);
+
 public:
 							UDecoder();
 	virtual EStatus			Check();
 	virtual void			Clear();
-	virtual int				DecodeBuffer(char* buffer, int len);
+	virtual bool			Write(char* buffer, int len, FILE* outfile);
 };
 
 #endif

DiskState.cpp

@@ -0,0 +1,761 @@
+/*
+ *  This file is 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 <stdio.h>
+
+#include "nzbget.h"
+#include "DiskState.h"
+#include "Options.h"
+#include "Log.h"
+#include "Util.h"
+
+extern Options* g_pOptions;
+
+static const char* FORMATVERSION_SIGNATURE_V3 = "nzbget diskstate file version 3\n";
+static const char* FORMATVERSION_SIGNATURE_V4 = "nzbget diskstate file version 4\n";
+static const char* FORMATVERSION_SIGNATURE_V5 = "nzbget diskstate file version 5\n";
+
+/* Parse signature and return format version number
+*/
+int DiskState::ParseFormatVersion(const char* szFormatSignature)
+{
+	if (!strcmp(szFormatSignature, FORMATVERSION_SIGNATURE_V3))
+	{
+		return 3;
+	}
+	else if (!strcmp(szFormatSignature, FORMATVERSION_SIGNATURE_V4))
+	{
+		return 4;
+	}
+	else if (!strcmp(szFormatSignature, FORMATVERSION_SIGNATURE_V5))
+	{
+		return 5;
+	}
+	else
+	{
+		return 0;
+	}
+}
+
+/* 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.
+ * This function saves file "queue" and files with NZB-info. It does not
+ * save file-infos.
+ */
+bool DiskState::SaveDownloadQueue(DownloadQueue* pDownloadQueue)
+{
+	debug("Saving queue to disk");
+
+	// prepare list of nzb-infos
+
+	typedef std::deque<NZBInfo*> NZBList;
+	NZBList cNZBList;
+
+	for (DownloadQueue::iterator it = pDownloadQueue->begin(); it != pDownloadQueue->end(); it++)
+	{
+		FileInfo* pFileInfo = *it;
+		bool inlist = false;
+		for (NZBList::iterator it = cNZBList.begin(); it != cNZBList.end(); it++)
+		{
+			NZBInfo* pNZBInfo = *it;
+			if (pNZBInfo == pFileInfo->GetNZBInfo())
+			{
+				inlist = true;
+				break;
+			}
+		}
+		if (!inlist)
+		{
+			cNZBList.push_back(pFileInfo->GetNZBInfo());
+		}
+	}
+
+	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, FORMATVERSION_SIGNATURE_V5);
+
+	// save nzb-infos
+	fprintf(outfile, "%i\n", cNZBList.size());
+	for (NZBList::iterator it = cNZBList.begin(); it != cNZBList.end(); it++)
+	{
+		NZBInfo* pNZBInfo = *it;
+		fprintf(outfile, "%s\n", pNZBInfo->GetFilename());
+		fprintf(outfile, "%s\n", pNZBInfo->GetDestDir());
+		fprintf(outfile, "%s\n", pNZBInfo->GetQueuedFilename());
+		fprintf(outfile, "%s\n", pNZBInfo->GetCategory());
+		fprintf(outfile, "%i\n", pNZBInfo->GetPostProcess() ? 1 : 0);
+		fprintf(outfile, "%i\n", pNZBInfo->GetFileCount());
+		unsigned long High, Low;
+		Util::SplitInt64(pNZBInfo->GetSize(), &High, &Low);
+		fprintf(outfile, "%lu,%lu\n", High, Low);
+
+		fprintf(outfile, "%i\n", pNZBInfo->GetCompletedFiles()->size());
+		for (NZBInfo::Files::iterator it = pNZBInfo->GetCompletedFiles()->begin(); it != pNZBInfo->GetCompletedFiles()->end(); it++)
+		{
+			char* szFilename = *it;
+			fprintf(outfile, "%s\n", szFilename);
+		}
+	}
+
+	// save file-infos
+	fprintf(outfile, "%i\n", pDownloadQueue->size());
+	for (DownloadQueue::iterator it = pDownloadQueue->begin(); it != pDownloadQueue->end(); it++)
+	{
+		FileInfo* pFileInfo = *it;
+		if (!pFileInfo->GetDeleted())
+		{
+			// find index of nzb-info
+			int iNZBIndex = 0;
+			for (unsigned int i = 0; i < cNZBList.size(); i++)
+			{
+				iNZBIndex++;
+				if (cNZBList[i] == pFileInfo->GetNZBInfo())
+				{
+					break;
+				}
+			}
+
+			fprintf(outfile, "%i,%i,%i\n", pFileInfo->GetID(), iNZBIndex, (int)pFileInfo->GetPaused());
+		}
+	}
+	fclose(outfile);
+
+	if (pDownloadQueue->empty())
+	{
+		remove(fileName);
+	}
+
+	return true;
+}
+
+bool DiskState::LoadDownloadQueue(DownloadQueue* pDownloadQueue)
+{
+	debug("Loading queue from disk");
+
+	bool bOK = false;
+
+	typedef std::deque<NZBInfo*> NZBList;
+	NZBList cNZBList;
+
+	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;
+	}
+
+	char FileSignatur[128];
+	fgets(FileSignatur, sizeof(FileSignatur), infile);
+	int iFormatVersion = ParseFormatVersion(FileSignatur);
+	if (iFormatVersion != 3 && iFormatVersion != 4 && iFormatVersion != 5)
+	{
+		error("Could not load diskstate due file version mismatch");
+		fclose(infile);
+		return false;
+	}
+
+	int size;
+	char buf[1024];
+
+	// load nzb-infos
+	if (fscanf(infile, "%i\n", &size) != 1) goto error;
+	for (int i = 0; i < size; i++)
+	{
+		NZBInfo* pNZBInfo = new NZBInfo();
+		pNZBInfo->AddReference();
+		cNZBList.push_back(pNZBInfo);
+
+		if (!fgets(buf, sizeof(buf), infile)) goto error;
+		if (buf[0] != 0) buf[strlen(buf)-1] = 0; // remove traling '\n'
+		pNZBInfo->SetFilename(buf);
+
+		if (!fgets(buf, sizeof(buf), infile)) goto error;
+		if (buf[0] != 0) buf[strlen(buf)-1] = 0; // remove traling '\n'
+		pNZBInfo->SetDestDir(buf);
+
+		if (iFormatVersion >= 5)
+		{
+			if (!fgets(buf, sizeof(buf), infile)) goto error;
+			if (buf[0] != 0) buf[strlen(buf)-1] = 0; // remove traling '\n'
+			pNZBInfo->SetQueuedFilename(buf);
+		}
+
+		if (iFormatVersion >= 4)
+		{
+			if (!fgets(buf, sizeof(buf), infile)) goto error;
+			if (buf[0] != 0) buf[strlen(buf)-1] = 0; // remove traling '\n'
+			pNZBInfo->SetCategory(buf);
+
+			int iPostProcess;
+			if (fscanf(infile, "%i\n", &iPostProcess) != 1) goto error;
+			pNZBInfo->SetPostProcess(iPostProcess == 1);
+		}
+
+		int iFileCount;
+		if (fscanf(infile, "%i\n", &iFileCount) != 1) goto error;
+		pNZBInfo->SetFileCount(iFileCount);
+
+		unsigned long High, Low;
+		if (fscanf(infile, "%lu,%lu\n", &High, &Low) != 2) goto error;
+		pNZBInfo->SetSize(Util::JoinInt64(High, Low));
+
+		if (iFormatVersion >= 4)
+		{
+			int iFileCount;
+			if (fscanf(infile, "%i\n", &iFileCount) != 1) goto error;
+			for (int i = 0; i < iFileCount; i++)
+			{
+				if (!fgets(buf, sizeof(buf), infile)) goto error;
+				if (buf[0] != 0) buf[strlen(buf)-1] = 0; // remove traling '\n'
+				pNZBInfo->GetCompletedFiles()->push_back(strdup(buf));
+			}
+		}
+	}
+
+	// load file-infos
+	if (fscanf(infile, "%i\n", &size) != 1) goto error;
+	for (int i = 0; i < size; i++)
+	{
+		unsigned int id, iNZBIndex, paused;
+		if (fscanf(infile, "%i,%i,%i\n", &id, &iNZBIndex, &paused) != 3) goto error;
+		if (iNZBIndex < 0 || iNZBIndex > cNZBList.size()) goto error;
+
+		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, true, false);
+		if (res)
+		{
+			pFileInfo->SetID(id);
+			pFileInfo->SetPaused(paused);
+			pFileInfo->SetNZBInfo(cNZBList[iNZBIndex - 1]);
+			pDownloadQueue->push_back(pFileInfo);
+		}
+		else
+		{
+			warn("Could not load diskstate for file %s", fileName);
+			delete pFileInfo;
+		}
+	}
+
+	bOK = true;
+
+error:
+
+	fclose(infile);
+	if (!bOK)
+	{
+		error("Error reading diskstate for file %s", fileName);
+	}
+
+	for (NZBList::iterator it = cNZBList.begin(); it != cNZBList.end(); it++)
+	{
+		NZBInfo* pNZBInfo = *it;
+		pNZBInfo->Release();
+	}
+
+	return bOK;
+}
+
+bool DiskState::SaveFile(FileInfo* pFileInfo)
+{
+	char fileName[1024];
+	snprintf(fileName, 1024, "%s%i", g_pOptions->GetQueueDir(), pFileInfo->GetID());
+	fileName[1024-1] = '\0';
+	return SaveFileInfo(pFileInfo, fileName);
+}
+
+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->GetSubject());
+	fprintf(outfile, "%s\n", pFileInfo->GetFilename());
+	fprintf(outfile, "%i\n", pFileInfo->GetFilenameConfirmed());
+	unsigned long High, Low;
+	Util::SplitInt64(pFileInfo->GetSize(), &High, &Low);
+	fprintf(outfile, "%lu,%lu\n", High, Low);
+
+	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::LoadArticles(FileInfo* pFileInfo)
+{
+	char fileName[1024];
+	snprintf(fileName, 1024, "%s%i", g_pOptions->GetQueueDir(), pFileInfo->GetID());
+	fileName[1024-1] = '\0';
+	return LoadFileInfo(pFileInfo, fileName, false, true);
+}
+
+bool DiskState::LoadFileInfo(FileInfo* pFileInfo, const char * szFilename, bool bFileSummary, bool bArticles)
+{
+	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'
+	if (bFileSummary) pFileInfo->SetSubject(buf);
+
+	if (!fgets(buf, sizeof(buf), infile)) goto error;
+	if (buf[0] != 0) buf[strlen(buf)-1] = 0; // remove traling '\n'
+	if (bFileSummary) pFileInfo->SetFilename(buf);
+
+	int iFilenameConfirmed;
+	if (fscanf(infile, "%i\n", &iFilenameConfirmed) != 1) goto error;
+	if (bFileSummary) pFileInfo->SetFilenameConfirmed(iFilenameConfirmed);
+	
+	unsigned long High, Low;
+	if (fscanf(infile, "%lu,%lu\n", &High, &Low) != 2) goto error;
+	if (bFileSummary) pFileInfo->SetSize(Util::JoinInt64(High, Low));
+	if (bFileSummary) 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'
+		if (bFileSummary) pFileInfo->GetGroups()->push_back(strdup(buf));
+	}
+
+	if (bArticles)
+	{
+		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;
+}
+
+bool DiskState::SavePostQueue(PostQueue* pPostQueue, bool bCompleted)
+{
+	debug("Saving post-queue to disk");
+
+	char fileName[1024];
+	snprintf(fileName, 1024, "%s%s", g_pOptions->GetQueueDir(), bCompleted ? "postc" : "postq");
+	fileName[1024-1] = '\0';
+
+	FILE* outfile = fopen(fileName, "w");
+
+	if (!outfile)
+	{
+		error("Could not create file %s", fileName);
+		perror(fileName);
+		return false;
+	}
+
+	fprintf(outfile, FORMATVERSION_SIGNATURE_V5);
+
+	fprintf(outfile, "%i\n", pPostQueue->size());
+	for (PostQueue::iterator it = pPostQueue->begin(); it != pPostQueue->end(); it++)
+	{
+		PostInfo* pPostInfo = *it;
+		fprintf(outfile, "%s\n", pPostInfo->GetNZBFilename());
+		fprintf(outfile, "%s\n", pPostInfo->GetDestDir());
+		fprintf(outfile, "%s\n", pPostInfo->GetParFilename());
+		fprintf(outfile, "%s\n", pPostInfo->GetInfoName());
+		fprintf(outfile, "%s\n", pPostInfo->GetCategory());
+		fprintf(outfile, "%s\n", pPostInfo->GetQueuedFilename());
+		fprintf(outfile, "%i\n", (int)pPostInfo->GetParCheck());
+		fprintf(outfile, "%i\n", (int)pPostInfo->GetParStatus());
+		fprintf(outfile, "%i\n", (int)pPostInfo->GetParFailed());
+		fprintf(outfile, "%i\n", (int)pPostInfo->GetStage());
+	}
+	fclose(outfile);
+
+	if (pPostQueue->empty())
+	{
+		remove(fileName);
+	}
+
+	return true;
+}
+
+bool DiskState::LoadPostQueue(PostQueue* pPostQueue, bool bCompleted)
+{
+	debug("Loading post-queue from disk");
+
+	char fileName[1024];
+	snprintf(fileName, 1024, "%s%s", g_pOptions->GetQueueDir(), bCompleted ? "postc" : "postq");
+	fileName[1024-1] = '\0';
+
+	FILE* infile = fopen(fileName, "r");
+
+	if (!infile)
+	{
+		error("Could not open file %s", fileName);
+		return false;
+	}
+
+	char FileSignatur[128];
+	fgets(FileSignatur, sizeof(FileSignatur), infile);
+	int iFormatVersion = ParseFormatVersion(FileSignatur);
+	if (iFormatVersion != 3 && iFormatVersion != 4 && iFormatVersion != 5)
+	{
+		error("Could not load diskstate due file version mismatch");
+		fclose(infile);
+		return false;
+	}
+
+	int size;
+	char buf[1024];
+	int iIntValue;
+
+	// load file-infos
+	if (fscanf(infile, "%i\n", &size) != 1) goto error;
+	for (int i = 0; i < size; i++)
+	{
+		PostInfo* pPostInfo = new PostInfo();
+
+		if (!fgets(buf, sizeof(buf), infile)) goto error;
+		if (buf[0] != 0) buf[strlen(buf)-1] = 0; // remove traling '\n'
+		pPostInfo->SetNZBFilename(buf);
+
+		if (!fgets(buf, sizeof(buf), infile)) goto error;
+		if (buf[0] != 0) buf[strlen(buf)-1] = 0; // remove traling '\n'
+		pPostInfo->SetDestDir(buf);
+
+		if (!fgets(buf, sizeof(buf), infile)) goto error;
+		if (buf[0] != 0) buf[strlen(buf)-1] = 0; // remove traling '\n'
+		pPostInfo->SetParFilename(buf);
+
+		if (!fgets(buf, sizeof(buf), infile)) goto error;
+		if (buf[0] != 0) buf[strlen(buf)-1] = 0; // remove traling '\n'
+		pPostInfo->SetInfoName(buf);
+
+		if (iFormatVersion >= 4)
+		{
+			if (!fgets(buf, sizeof(buf), infile)) goto error;
+			if (buf[0] != 0) buf[strlen(buf)-1] = 0; // remove traling '\n'
+			pPostInfo->SetCategory(buf);
+		}
+		else
+		{
+			pPostInfo->SetCategory("");
+		}
+
+		if (iFormatVersion >= 5)
+		{
+			if (!fgets(buf, sizeof(buf), infile)) goto error;
+			if (buf[0] != 0) buf[strlen(buf)-1] = 0; // remove traling '\n'
+			pPostInfo->SetQueuedFilename(buf);
+		}
+		else
+		{
+			pPostInfo->SetQueuedFilename("");
+		}
+
+		if (fscanf(infile, "%i\n", &iIntValue) != 1) goto error;
+		pPostInfo->SetParCheck(iIntValue);
+
+		if (fscanf(infile, "%i\n", &iIntValue) != 1) goto error;
+		pPostInfo->SetParStatus(iIntValue);
+
+		if (fscanf(infile, "%i\n", &iIntValue) != 1) goto error;
+		pPostInfo->SetParFailed(iIntValue);
+
+		if (fscanf(infile, "%i\n", &iIntValue) != 1) goto error;
+		pPostInfo->SetStage((PostInfo::EStage)iIntValue);
+
+		pPostQueue->push_back(pPostInfo);
+	}
+
+	fclose(infile);
+	return true;
+
+error:
+	fclose(infile);
+	error("Error reading diskstate for file %s", fileName);
+	return false;
+}
+
+/*
+ * Delete all files from Queue.
+ * Returns true if successful, false if not
+ */
+bool DiskState::DiscardDownloadQueue()
+{
+	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);
+	int iFormatVersion = ParseFormatVersion(FileSignatur);
+	if (iFormatVersion == 3 || iFormatVersion == 4 || iFormatVersion == 5)
+	{
+		// skip nzb-infos
+		int size = 0;
+		char buf[1024];
+		fscanf(infile, "%i\n", &size);
+		for (int i = 0; i < size; i++)
+		{
+			if (!fgets(buf, sizeof(buf), infile)) break; // filename
+			if (!fgets(buf, sizeof(buf), infile)) break; // destdir
+			if (iFormatVersion >= 4)
+			{
+				if (!fgets(buf, sizeof(buf), infile)) break; // category
+				if (!fgets(buf, sizeof(buf), infile)) break; // postprocess
+			}
+			if (iFormatVersion >= 5)
+			{
+				if (!fgets(buf, sizeof(buf), infile)) break; // localfile
+			}
+			if (!fgets(buf, sizeof(buf), infile)) break; // file count
+			if (!fgets(buf, sizeof(buf), infile)) break; // file size
+			if (iFormatVersion >= 4)
+			{
+				// completed files
+				int iFileCount;
+				if (fscanf(infile, "%i\n", &iFileCount) != 1) break;
+				for (int i = 0; i < iFileCount; i++)
+				{
+					if (!fgets(buf, sizeof(buf), infile)) break; // filename
+				}
+			}
+		}
+
+		// file-infos
+		fscanf(infile, "%i\n", &size);
+		for (int i = 0; i < size; i++)
+		{
+			int id, group, paused;
+			if (fscanf(infile, "%i,%i,%i\n", &id, &group, &paused) == 3)
+			{
+				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;
+}
+
+/*
+ * Delete all files from Queue.
+ * Returns true if successful, false if not
+ */
+bool DiskState::DiscardPostQueue()
+{
+	debug("Discarding post-queue");
+
+	char fileName[1024];
+
+	snprintf(fileName, 1024, "%s%s", g_pOptions->GetQueueDir(), "postq");
+	fileName[1024-1] = '\0';
+	remove(fileName);
+
+	snprintf(fileName, 1024, "%s%s", g_pOptions->GetQueueDir(), "postc");
+	fileName[1024-1] = '\0';
+	remove(fileName);
+
+	return true;
+}
+
+bool DiskState::DownloadQueueExists()
+{
+	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';
+	return Util::FileExists(fileName);
+}
+
+bool DiskState::PostQueueExists(bool bCompleted)
+{
+	debug("Checking if a saved queue exists on disk");
+
+	char fileName[1024];
+	snprintf(fileName, 1024, "%s%s", g_pOptions->GetQueueDir(), bCompleted ? "postc" : "postq");
+	fileName[1024-1] = '\0';
+	return Util::FileExists(fileName);
+}
+
+bool DiskState::DiscardFile(DownloadQueue* pDownloadQueue, FileInfo* pFileInfo)
+{
+	// delete diskstate-file for file-info
+	char fileName[1024];
+	snprintf(fileName, 1024, "%s%i", g_pOptions->GetQueueDir(), pFileInfo->GetID());
+	fileName[1024-1] = '\0';
+	remove(fileName);
+
+	return !pDownloadQueue || SaveDownloadQueue(pDownloadQueue);
+}
+
+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())
+	{
+		int id, part;
+		bool del = strstr(filename, ".tmp") || strstr(filename, ".dec") ||
+			((sscanf(filename, "%i.out", &id) == 1) &&
+				!(g_pOptions->GetContinuePartial() && g_pOptions->GetDirectWrite()));
+		if (!del)
+		{
+			if ((sscanf(filename, "%i.%i", &id, &part) == 2) ||
+				(sscanf(filename, "%i.out", &id) == 1))
+			{
+				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,54 @@
+/*
+ *  This file is 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"
+#include "PostInfo.h"
+
+class DiskState
+{
+private:
+	bool				SaveFileInfo(FileInfo* pFileInfo, const char* szFilename);
+	bool				LoadFileInfo(FileInfo* pFileInfo, const char* szFilename, bool bFileSummary, bool bArticles);
+	int					ParseFormatVersion(const char* szFormatSignature);
+	
+public:
+	bool				DownloadQueueExists();
+	bool				PostQueueExists(bool bCompleted);
+	bool				SaveDownloadQueue(DownloadQueue* pDownloadQueue);
+	bool				LoadDownloadQueue(DownloadQueue* pDownloadQueue);
+	bool				SaveFile(FileInfo* pFileInfo);
+	bool				LoadArticles(FileInfo* pFileInfo);
+	bool				SavePostQueue(PostQueue* pPostQueue, bool bCompleted);
+	bool				LoadPostQueue(PostQueue* pPostQueue, bool bCompleted);
+	bool				DiscardDownloadQueue();
+	bool				DiscardPostQueue();
+	bool				DiscardFile(DownloadQueue* pDownloadQueue, FileInfo* pFileInfo);
+	void				CleanupTempDir(DownloadQueue* pDownloadQueue);
+};
+
+#endif

DownloadInfo.cpp

@@ -0,0 +1,450 @@
+/*
+ *  This file is 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 <cctype>
+#include <cstdio>
+#include <sys/stat.h>
+
+#include "nzbget.h"
+#include "DownloadInfo.h"
+#include "Options.h"
+#include "Log.h"
+#include "Util.h"
+
+extern Options* g_pOptions;
+
+int FileInfo::m_iIDGen = 0;
+
+NZBInfo::NZBInfo()
+{
+	debug("Creating NZBInfo");
+
+	m_szFilename = NULL;
+	m_szDestDir = NULL;
+	m_szCategory = strdup("");
+	m_iFileCount = 0;
+	m_lSize = 0;
+	m_iRefCount = 0;
+	m_bPostProcess = false;
+	m_szQueuedFilename = strdup("");
+}
+
+NZBInfo::~NZBInfo()
+{
+	debug("Destroying NZBInfo");
+
+	if (m_szFilename)
+	{
+		free(m_szFilename);
+	}
+	if (m_szDestDir)
+	{
+		free(m_szDestDir);
+	}
+	if (m_szCategory)
+	{
+		free(m_szCategory);
+	}
+	if (m_szQueuedFilename)
+	{
+		free(m_szQueuedFilename);
+	}
+
+	for (Files::iterator it = m_completedFiles.begin(); it != m_completedFiles.end(); it++)
+	{
+		free(*it);
+	}
+	m_completedFiles.clear();
+}
+
+void NZBInfo::AddReference()
+{
+	m_iRefCount++;
+}
+
+void NZBInfo::Release()
+{
+	m_iRefCount--;
+	if (m_iRefCount <= 0)
+	{
+		delete this;
+	}
+}
+
+void NZBInfo::SetDestDir(const char* szDestDir)
+{
+	if (m_szDestDir)
+	{
+		free(m_szDestDir);
+	}
+	m_szDestDir = strdup(szDestDir);
+}
+
+void NZBInfo::SetFilename(const char * szFilename)
+{
+	m_szFilename = strdup(szFilename);
+}
+
+void NZBInfo::SetCategory(const char* szCategory)
+{
+	if (m_szCategory)
+	{
+		free(m_szCategory);
+	}
+	m_szCategory = strdup(szCategory);
+}
+
+void NZBInfo::SetQueuedFilename(const char * szQueuedFilename)
+{
+	if (m_szQueuedFilename)
+	{
+		free(m_szQueuedFilename);
+	}
+	m_szQueuedFilename = strdup(szQueuedFilename);
+}
+
+void NZBInfo::GetNiceNZBName(char* szBuffer, int iSize)
+{
+	MakeNiceNZBName(m_szFilename, szBuffer, iSize);
+}
+
+void NZBInfo::MakeNiceNZBName(const char * szNZBFilename, char * szBuffer, int iSize)
+{
+	char postname[1024];
+	const char* szBaseName = Util::BaseFileName(szNZBFilename);
+
+	// if .nzb file has a certain structure, try to strip out certain elements
+	if (sscanf(szBaseName, "msgid_%*d_%1023s", postname) == 1)
+	{
+		// OK, using stripped name
+	}
+	else
+	{
+		// using complete filename
+		strncpy(postname, szBaseName, 1024);
+		postname[1024-1] = '\0';
+	}
+
+	// wipe out ".nzb"
+	if (char* p = strrchr(postname, '.')) *p = '\0';
+
+	Util::MakeValidFilename(postname, '_', false);
+
+	// if the resulting name is empty, use basename without cleaning up "msgid_"
+	if (strlen(postname) == 0)
+	{
+		// using complete filename
+		strncpy(postname, szBaseName, 1024);
+		postname[1024-1] = '\0';
+
+		// wipe out ".nzb"
+		if (char* p = strrchr(postname, '.')) *p = '\0';
+
+		Util::MakeValidFilename(postname, '_', false);
+
+		// if the resulting name is STILL empty, use "noname"
+		if (strlen(postname) == 0)
+		{
+			strncpy(postname, "noname", 1024);
+		}
+	}
+
+	strncpy(szBuffer, postname, iSize);
+	szBuffer[iSize-1] = '\0';
+}
+
+void NZBInfo::BuildDestDirName()
+{
+	char szBuffer[1024];
+	char szCategory[1024];
+	bool bHasCategory = m_szCategory && m_szCategory[0] != '\0';
+	if (g_pOptions->GetAppendCategoryDir() && bHasCategory)
+	{
+		strncpy(szCategory, m_szCategory, 1024);
+		szCategory[1024 - 1] = '\0';
+		Util::MakeValidFilename(szCategory, '_', true);
+	}
+
+	if (g_pOptions->GetAppendNZBDir())
+	{
+		char szNiceNZBName[1024];
+		GetNiceNZBName(szNiceNZBName, 1024);
+		if (g_pOptions->GetAppendCategoryDir() && bHasCategory)
+		{
+			snprintf(szBuffer, 1024, "%s%s%c%s", g_pOptions->GetDestDir(), szCategory, PATH_SEPARATOR, szNiceNZBName);
+		}
+		else
+		{
+			snprintf(szBuffer, 1024, "%s%s", g_pOptions->GetDestDir(), szNiceNZBName);
+		}
+		szBuffer[1024-1] = '\0';
+	}
+	else
+	{
+		if (g_pOptions->GetAppendCategoryDir() && bHasCategory)
+		{
+			snprintf(szBuffer, 1024, "%s%s", g_pOptions->GetDestDir(), szCategory);
+		}
+		else
+		{
+			strncpy(szBuffer, g_pOptions->GetDestDir(), 1024);
+		}
+		szBuffer[1024-1] = '\0'; // trim the last slash, always returned by GetDestDir()
+	}
+
+	SetDestDir(szBuffer);
+}
+
+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_lSize = 0;
+	m_lRemainingSize = 0;
+	m_bPaused = false;
+	m_bDeleted = false;
+	m_iCompleted = 0;
+	m_bOutputInitialized = false;
+	m_pNZBInfo = NULL;
+	m_iIDGen++;
+	m_iID = m_iIDGen;
+}
+
+FileInfo::~ FileInfo()
+{
+	debug("Destroying FileInfo");
+
+	if (m_szSubject)
+	{
+		free(m_szSubject);
+	}
+	if (m_szFilename)
+	{
+		free(m_szFilename);
+	}
+
+	for (Groups::iterator it = m_Groups.begin(); it != m_Groups.end() ;it++)
+	{
+		free(*it);
+	}
+	m_Groups.clear();
+
+	ClearArticles();
+
+	if (m_pNZBInfo)
+	{
+		m_pNZBInfo->Release();
+	}
+}
+
+void FileInfo::ClearArticles()
+{
+	for (Articles::iterator it = m_Articles.begin(); it != m_Articles.end() ;it++)
+	{
+		delete *it;
+	}
+	m_Articles.clear();
+}
+
+void FileInfo::SetID(int s)
+{
+	m_iID = s;
+	if (m_iIDGen < m_iID)
+	{
+		m_iIDGen = m_iID;
+	}
+}
+
+void FileInfo::SetNZBInfo(NZBInfo* pNZBInfo)
+{
+	m_pNZBInfo = pNZBInfo;
+	m_pNZBInfo->AddReference();
+}
+
+void FileInfo::SetSubject(const char* szSubject)
+{
+	m_szSubject = strdup(szSubject);
+}
+
+void FileInfo::SetFilename(const char* szFilename)
+{
+	if (m_szFilename)
+	{
+		free(m_szFilename);
+	}
+	m_szFilename = strdup(szFilename);
+}
+
+void FileInfo::MakeValidFilename()
+{
+	Util::MakeValidFilename(m_szFilename, '_', false);
+}
+
+void FileInfo::LockOutputFile()
+{
+	m_mutexOutputFile.Lock();
+}
+
+void FileInfo::UnlockOutputFile()
+{
+	m_mutexOutputFile.Unlock();
+}
+
+bool FileInfo::IsDupe(const char* szFilename)
+{
+	char fileName[1024];
+	snprintf(fileName, 1024, "%s%c%s", m_pNZBInfo->GetDestDir(), (int)PATH_SEPARATOR, szFilename);
+	fileName[1024-1] = '\0';
+	if (Util::FileExists(fileName))
+	{
+		return true;
+	}
+	snprintf(fileName, 1024, "%s%c%s_broken", m_pNZBInfo->GetDestDir(), (int)PATH_SEPARATOR, szFilename);
+	fileName[1024-1] = '\0';
+	if (Util::FileExists(fileName))
+	{
+		return true;
+	}
+
+	return false;
+}
+
+GroupInfo::GroupInfo()
+{
+	m_iFirstID = 0;
+	m_iLastID = 0;
+	m_iRemainingFileCount = 0;
+	m_lRemainingSize = 0;
+	m_lPausedSize = 0;
+	m_iRemainingParCount = 0;
+}
+
+GroupInfo::~GroupInfo()
+{
+	if (m_pNZBInfo)
+	{
+		m_pNZBInfo->Release();
+	}
+}
+
+void GroupInfo::BuildGroups(DownloadQueue* pDownloadQueue, GroupQueue* pGroupQueue)
+{
+    for (DownloadQueue::iterator it = pDownloadQueue->begin(); it != pDownloadQueue->end(); it++)
+    {
+        FileInfo* pFileInfo = *it;
+		GroupInfo* pGroupInfo = NULL;
+		for (GroupQueue::iterator itg = pGroupQueue->begin(); itg != pGroupQueue->end(); itg++)
+		{
+			GroupInfo* pGroupInfo1 = *itg;
+			if (pGroupInfo1->GetNZBInfo() == pFileInfo->GetNZBInfo())
+			{
+				pGroupInfo = pGroupInfo1;
+				break;
+			}
+		}
+		if (!pGroupInfo)
+		{
+			pGroupInfo = new GroupInfo();
+			pGroupInfo->m_pNZBInfo = pFileInfo->GetNZBInfo();
+			pGroupInfo->m_pNZBInfo->AddReference();
+			pGroupInfo->m_iFirstID = pFileInfo->GetID();
+			pGroupInfo->m_iLastID = pFileInfo->GetID();
+			pGroupQueue->push_back(pGroupInfo);
+		}
+		if (pFileInfo->GetID() < pGroupInfo->GetFirstID())
+		{
+			pGroupInfo->m_iFirstID = pFileInfo->GetID();
+		}
+		if (pFileInfo->GetID() > pGroupInfo->GetLastID())
+		{
+			pGroupInfo->m_iLastID = pFileInfo->GetID();
+		}
+		pGroupInfo->m_iRemainingFileCount++;
+		pGroupInfo->m_lRemainingSize += pFileInfo->GetRemainingSize();
+		if (pFileInfo->GetPaused())
+		{
+			pGroupInfo->m_lPausedSize += pFileInfo->GetRemainingSize();
+		}
+
+		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"))
+		{
+			pGroupInfo->m_iRemainingParCount++;
+		}
+	}
+}

DownloadInfo.h

@@ -0,0 +1,197 @@
+/*
+ *  This file is 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>
+
+#include "Thread.h"
+
+class NZBInfo
+{
+public:
+	typedef std::vector<char*>			Files;
+
+private:
+	int					m_iRefCount;
+	char* 				m_szFilename;
+	char* 				m_szDestDir;
+	char* 				m_szCategory;
+	int		 			m_iFileCount;
+	long long 			m_lSize;
+	Files				m_completedFiles;
+	bool				m_bPostProcess;
+	char*				m_szQueuedFilename;
+
+public:
+						NZBInfo();
+						~NZBInfo();
+	void				AddReference();
+	void				Release();
+	const char*			GetFilename() { return m_szFilename; }
+	void				SetFilename(const char* szFilename);
+	void				GetNiceNZBName(char* szBuffer, int iSize);
+	static void			MakeNiceNZBName(const char* szNZBFilename, char* szBuffer, int iSize);
+	const char*			GetDestDir() { return m_szDestDir; }   // needs locking (for shared objects)
+	void				SetDestDir(const char* szDestDir);     // needs locking (for shared objects)
+	const char*			GetCategory() { return m_szCategory; } // needs locking (for shared objects)
+	void				SetCategory(const char* szCategory);   // needs locking (for shared objects)
+	long long 			GetSize() { return m_lSize; }
+	void 				SetSize(long long s) { m_lSize = s; }
+	int					GetFileCount() { return m_iFileCount; }
+	void 				SetFileCount(int s) { m_iFileCount = s; }
+	void				BuildDestDirName();
+	Files*				GetCompletedFiles() { return &m_completedFiles; }
+	bool				GetPostProcess() { return m_bPostProcess; }
+	void				SetPostProcess(bool b) { m_bPostProcess = b; }
+	const char*			GetQueuedFilename() { return m_szQueuedFilename; }
+	void				SetQueuedFilename(const char* szQueuedFilename);
+};
+
+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;
+	NZBInfo*			m_pNZBInfo;
+	Articles			m_Articles;
+	Groups				m_Groups;
+	char* 				m_szSubject;
+	char*				m_szFilename;
+	long long 			m_lSize;
+	long long 			m_lRemainingSize;
+	bool				m_bPaused;
+	bool				m_bDeleted;
+	bool				m_bFilenameConfirmed;
+	int					m_iCompleted;
+	bool				m_bOutputInitialized;
+	Mutex				m_mutexOutputFile;
+
+	static int			m_iIDGen;
+
+public:
+						FileInfo();
+						~FileInfo();
+	int					GetID() { return m_iID; }
+	void				SetID(int s);
+	NZBInfo*			GetNZBInfo() { return m_pNZBInfo; }
+	void				SetNZBInfo(NZBInfo* pNZBInfo);
+	Articles* 			GetArticles() { return &m_Articles; }
+	Groups* 			GetGroups() { return &m_Groups; }
+	const char*			GetSubject() { return m_szSubject; }
+	void 				SetSubject(const char* szSubject);
+	const char*			GetFilename() { return m_szFilename; }
+	void 				SetFilename(const char* szFilename);
+	void				MakeValidFilename();
+	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; }
+	int					GetCompleted() { return m_iCompleted; }
+	void				SetCompleted(int s) { m_iCompleted = s; }
+	void				ClearArticles();
+	void				LockOutputFile();
+	void				UnlockOutputFile();
+	bool				GetOutputInitialized() { return m_bOutputInitialized; }
+	void				SetOutputInitialized(bool bOutputInitialized) { m_bOutputInitialized = bOutputInitialized; }
+	bool				IsDupe(const char* szFilename);
+};
+                              
+typedef std::deque<FileInfo*> DownloadQueue;
+
+class GroupInfo;
+typedef std::deque<GroupInfo*> GroupQueue;
+
+class GroupInfo
+{
+private:
+	NZBInfo*			m_pNZBInfo;
+	int					m_iFirstID;
+	int					m_iLastID;
+	int		 			m_iRemainingFileCount;
+	long long 			m_lRemainingSize;
+	long long 			m_lPausedSize;
+	int					m_iRemainingParCount;
+
+public:
+						GroupInfo();
+						~GroupInfo();
+	NZBInfo*			GetNZBInfo() { return m_pNZBInfo; }
+	int					GetFirstID() { return m_iFirstID; }
+	int					GetLastID() { return m_iLastID; }
+	long long 			GetRemainingSize() { return m_lRemainingSize; }
+	long long 			GetPausedSize() { return m_lPausedSize; }
+	int					GetRemainingFileCount() { return m_iRemainingFileCount; }
+	int					GetRemainingParCount() { return m_iRemainingParCount; }
+
+	static void			BuildGroups(DownloadQueue* pDownloadQueue, GroupQueue* pGroupQueue);
+};
+
+#endif

Frontend.cpp

@@ -2,7 +2,7 @@
  *  This file is part of nzbget
  *
  *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
- *  Copyright (C) 2007-2015 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *  Copyright (C) 2007-2008 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$
@@ -34,7 +34,8 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <stdio.h>
+#include <cstdio>
+#include <fstream>
 #ifndef WIN32
 #include <unistd.h>
 #include <arpa/inet.h>
@@ -47,9 +48,14 @@
 #include "Log.h"
 #include "Connection.h"
 #include "MessageBase.h"
+#include "QueueCoordinator.h"
+#include "PrePostProcessor.h"
 #include "RemoteClient.h"
 #include "Util.h"
-#include "StatMeter.h"
+
+extern QueueCoordinator* g_pQueueCoordinator;
+extern PrePostProcessor* g_pPrePostProcessor;
+extern Options* g_pOptions;
 
 Frontend::Frontend()
 {
@@ -59,16 +65,18 @@ Frontend::Frontend()
 	m_iNeededLogEntries = 0;
 	m_bSummary = false;
 	m_bFileList = false;
-	m_iCurrentDownloadSpeed = 0;
+	m_fCurrentDownloadSpeed = 0;
 	m_lRemainingSize = 0;
-	m_bPauseDownload = false;
-	m_iDownloadLimit = 0;
+	m_bPause = false;
+	m_fDownloadLimit = 0;
 	m_iThreadCount = 0;
 	m_iPostJobCount = 0;
 	m_iUpTimeSec = 0;
 	m_iDnTimeSec = 0;
 	m_iAllBytes = 0;
 	m_bStandBy = 0;
+	m_RemoteMessages.clear();
+	m_RemoteQueue.clear();
 	m_iUpdateInterval = g_pOptions->GetUpdateInterval();
 }
 
@@ -82,8 +90,7 @@ bool Frontend::PrepareData()
 		}
 		if (!RequestMessages() || ((m_bSummary || m_bFileList) && !RequestFileList()))
 		{
-			const char* szControlIP = !strcmp(g_pOptions->GetControlIP(), "0.0.0.0") ? "127.0.0.1" : g_pOptions->GetControlIP();
-			printf("\nUnable to send request to nzbget-server at %s (port %i)    \n", szControlIP, g_pOptions->GetControlPort());
+			printf("\nUnable to send request to nzbget-server at %s (port %i)    \n", g_pOptions->GetServerIP(), g_pOptions->GetServerPort());
 			Stop();
 			return false;
 		}
@@ -92,22 +99,15 @@ bool Frontend::PrepareData()
 	{
 		if (m_bSummary)
 		{
-			m_iCurrentDownloadSpeed = g_pStatMeter->CalcCurrentDownloadSpeed();
-			m_bPauseDownload = g_pOptions->GetPauseDownload();
-			m_iDownloadLimit = g_pOptions->GetDownloadRate();
+			m_fCurrentDownloadSpeed = g_pQueueCoordinator->CalcCurrentDownloadSpeed();
+			m_lRemainingSize = g_pQueueCoordinator->CalcRemainingSize();
+			m_bPause = g_pOptions->GetPause();
+			m_fDownloadLimit = 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();
-
+			PostQueue* pPostQueue = g_pPrePostProcessor->LockPostQueue();
+			m_iPostJobCount = pPostQueue->size();
+			g_pPrePostProcessor->UnlockPostQueue();
+			g_pQueueCoordinator->CalcStat(&m_iUpTimeSec, &m_iDnTimeSec, &m_iAllBytes, &m_bStandBy);
 		}
 	}
 	return true;
@@ -117,15 +117,21 @@ void Frontend::FreeData()
 {
 	if (IsRemoteMode())
 	{
-		m_RemoteMessages.Clear();
+		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();
+		for (DownloadQueue::iterator it = m_RemoteQueue.begin(); it != m_RemoteQueue.end(); it++)
+		{
+			delete *it;
+		}
+		m_RemoteQueue.clear();
 	}
 }
 
-MessageList* Frontend::LockMessages()
+Log::Messages * Frontend::LockMessages()
 {
 	if (IsRemoteMode())
 	{
@@ -145,14 +151,24 @@ void Frontend::UnlockMessages()
 	}
 }
 
-DownloadQueue* Frontend::LockQueue()
+DownloadQueue * Frontend::LockQueue()
 {
-	return DownloadQueue::Lock();
+	if (IsRemoteMode())
+	{
+		return &m_RemoteQueue;
+	}
+	else
+	{
+		return g_pQueueCoordinator->LockQueue();
+	}
 }
 
 void Frontend::UnlockQueue()
 {
-	DownloadQueue::Unlock();
+	if (!IsRemoteMode())
+	{
+		g_pQueueCoordinator->UnlockQueue();
+	}
 }
 
 bool Frontend::IsRemoteMode()
@@ -168,24 +184,35 @@ void Frontend::ServerPauseUnpause(bool bPause)
 	}
 	else
 	{
-		g_pOptions->SetResumeTime(0);
-		g_pOptions->SetPauseDownload(bPause);
+		g_pOptions->SetPause(bPause);
 	}
 }
 
-void Frontend::ServerSetDownloadRate(int iRate)
+void Frontend::ServerSetDownloadRate(float fRate)
 {
 	if (IsRemoteMode())
 	{
-		RequestSetDownloadRate(iRate);
+		RequestSetDownloadRate(fRate);
 	}
 	else
 	{
-		g_pOptions->SetDownloadRate(iRate);
+		g_pOptions->SetDownloadRate(fRate);
 	}
 }
 
-bool Frontend::ServerEditQueue(DownloadQueue::EEditAction eAction, int iOffset, int iID)
+void Frontend::ServerDumpDebug()
+{
+	if (IsRemoteMode())
+	{
+		RequestDumpDebug();
+	}
+	else
+	{
+		g_pQueueCoordinator->LogDebugInfo();
+	}
+}
+
+bool Frontend::ServerEditQueue(QueueEditor::EEditAction eAction, int iOffset, int iID)
 {
 	if (IsRemoteMode())
 	{
@@ -193,10 +220,7 @@ bool Frontend::ServerEditQueue(DownloadQueue::EEditAction eAction, int iOffset,
 	}
 	else
 	{
-		DownloadQueue* pDownloadQueue = LockQueue();
-		bool bOK = pDownloadQueue->EditEntry(iID, eAction, iOffset, NULL);
-		UnlockQueue();
-		return bOK;
+		return g_pQueueCoordinator->GetQueueEditor()->EditEntry(iID, true, eAction, iOffset, NULL);
 	}
 	return false;
 }
@@ -206,18 +230,14 @@ void Frontend::InitMessageBase(SNZBRequestBase* pMessageBase, int iRequest, int
 	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);
+	strncpy(pMessageBase->m_szPassword, g_pOptions->GetServerPassword(), NZBREQUESTPASSWORDSIZE);
 	pMessageBase->m_szPassword[NZBREQUESTPASSWORDSIZE - 1] = '\0';
 }
 
 bool Frontend::RequestMessages()
 {
-	const char* szControlIP = !strcmp(g_pOptions->GetControlIP(), "0.0.0.0") ? "127.0.0.1" : g_pOptions->GetControlIP();
-	Connection connection(szControlIP, g_pOptions->GetControlPort(), false);
+	NetAddress netAddress(g_pOptions->GetServerIP(), g_pOptions->GetServerPort());
+	Connection connection(&netAddress);
 
 	bool OK = connection.Connect();
 	if (!OK)
@@ -237,15 +257,15 @@ bool Frontend::RequestMessages()
 		LogRequest.m_iIDFrom = 0;
 	}
 
-	if (!connection.Send((char*)(&LogRequest), sizeof(LogRequest)))
+	if (connection.Send((char*)(&LogRequest), sizeof(LogRequest)) < 0)
 	{
 		return false;
 	}
 
 	// Now listen for the returned log
 	SNZBLogResponse LogResponse;
-	bool bRead = connection.Recv((char*) &LogResponse, sizeof(LogResponse));
-	if (!bRead || 
+	int iResponseLen = connection.Recv((char*) &LogResponse, sizeof(LogResponse));
+	if (iResponseLen != sizeof(LogResponse) || 
 		(int)ntohl(LogResponse.m_MessageBase.m_iSignature) != (int)NZBMESSAGE_SIGNATURE ||
 		ntohl(LogResponse.m_MessageBase.m_iStructSize) != sizeof(LogResponse))
 	{
@@ -256,7 +276,7 @@ bool Frontend::RequestMessages()
 	if (ntohl(LogResponse.m_iTrailingDataLength) > 0)
 	{
 		pBuf = (char*)malloc(ntohl(LogResponse.m_iTrailingDataLength));
-		if (!connection.Recv(pBuf, ntohl(LogResponse.m_iTrailingDataLength)))
+		if (!connection.RecvAll(pBuf, ntohl(LogResponse.m_iTrailingDataLength)))
 		{
 			free(pBuf);
 			return false;
@@ -288,8 +308,8 @@ bool Frontend::RequestMessages()
 
 bool Frontend::RequestFileList()
 {
-	const char* szControlIP = !strcmp(g_pOptions->GetControlIP(), "0.0.0.0") ? "127.0.0.1" : g_pOptions->GetControlIP();
-	Connection connection(szControlIP, g_pOptions->GetControlPort(), false);
+	NetAddress netAddress(g_pOptions->GetServerIP(), g_pOptions->GetServerPort());
+	Connection connection(&netAddress);
 
 	bool OK = connection.Connect();
 	if (!OK)
@@ -302,15 +322,15 @@ bool Frontend::RequestFileList()
 	ListRequest.m_bFileList = htonl(m_bFileList);
 	ListRequest.m_bServerState = htonl(m_bSummary);
 
-	if (!connection.Send((char*)(&ListRequest), sizeof(ListRequest)))
+	if (connection.Send((char*)(&ListRequest), sizeof(ListRequest)) < 0)
 	{
 		return false;
 	}
 
 	// Now listen for the returned list
 	SNZBListResponse ListResponse;
-	bool bRead = connection.Recv((char*) &ListResponse, sizeof(ListResponse));
-	if (!bRead || 
+	int iResponseLen = connection.Recv((char*) &ListResponse, sizeof(ListResponse));
+	if (iResponseLen != sizeof(ListResponse) || 
 		(int)ntohl(ListResponse.m_MessageBase.m_iSignature) != (int)NZBMESSAGE_SIGNATURE ||
 		ntohl(ListResponse.m_MessageBase.m_iStructSize) != sizeof(ListResponse))
 	{
@@ -321,7 +341,7 @@ bool Frontend::RequestFileList()
 	if (ntohl(ListResponse.m_iTrailingDataLength) > 0)
 	{
 		pBuf = (char*)malloc(ntohl(ListResponse.m_iTrailingDataLength));
-		if (!connection.Recv(pBuf, ntohl(ListResponse.m_iTrailingDataLength)))
+		if (!connection.RecvAll(pBuf, ntohl(ListResponse.m_iTrailingDataLength)))
 		{
 			free(pBuf);
 			return false;
@@ -332,28 +352,72 @@ bool Frontend::RequestFileList()
 
 	if (m_bSummary)
 	{
-		m_bPauseDownload = ntohl(ListResponse.m_bDownloadPaused);
+		m_bPause = ntohl(ListResponse.m_bServerPaused);
 		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_fCurrentDownloadSpeed = ntohl(ListResponse.m_iDownloadRate) / 1024.0f;
+		m_fDownloadLimit = ntohl(ListResponse.m_iDownloadLimit) / 1024.0f;
 		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_bStandBy = ntohl(ListResponse.m_bServerStandBy);
 		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();
-	}
+		typedef std::deque<NZBInfo*> NZBList;
+		NZBList cNZBList;
 
+		char* pBufPtr = (char*)pBuf;
+		for (unsigned int i = 0; i < ntohl(ListResponse.m_iNrTrailingEntries); i++)
+		{
+			SNZBListResponseEntry* pListAnswer = (SNZBListResponseEntry*) pBufPtr;
+
+			char* szNZBFilename = pBufPtr + sizeof(SNZBListResponseEntry);
+			char* szSubject = pBufPtr + sizeof(SNZBListResponseEntry) + ntohl(pListAnswer->m_iNZBFilenameLen);
+			char* szFileName = pBufPtr + sizeof(SNZBListResponseEntry) + ntohl(pListAnswer->m_iNZBFilenameLen) + ntohl(pListAnswer->m_iSubjectLen);
+			char* szDestDir = pBufPtr + sizeof(SNZBListResponseEntry) + ntohl(pListAnswer->m_iNZBFilenameLen) + ntohl(pListAnswer->m_iSubjectLen) + ntohl(pListAnswer->m_iFilenameLen);
+			char* szCategory = pBufPtr + sizeof(SNZBListResponseEntry) + ntohl(pListAnswer->m_iNZBFilenameLen) + ntohl(pListAnswer->m_iSubjectLen) + ntohl(pListAnswer->m_iFilenameLen) + ntohl(pListAnswer->m_iDestDirLen);
+			
+			FileInfo* pFileInfo = new FileInfo();
+			pFileInfo->SetID(ntohl(pListAnswer->m_iID));
+			pFileInfo->SetSize(Util::JoinInt64(ntohl(pListAnswer->m_iFileSizeHi), ntohl(pListAnswer->m_iFileSizeLo)));
+			pFileInfo->SetRemainingSize(Util::JoinInt64(ntohl(pListAnswer->m_iRemainingSizeHi), ntohl(pListAnswer->m_iRemainingSizeLo)));
+			pFileInfo->SetPaused(ntohl(pListAnswer->m_bPaused));
+			pFileInfo->SetSubject(szSubject);
+			pFileInfo->SetFilename(szFileName);
+			pFileInfo->SetFilenameConfirmed(ntohl(pListAnswer->m_bFilenameConfirmed));
+
+			// find nzb-info or create new
+			NZBInfo* pNZBInfo = NULL;
+			for (NZBList::iterator it = cNZBList.begin(); it != cNZBList.end(); it++)
+			{
+				NZBInfo* pNZBInfo2 = *it;
+				if (!strcmp(pNZBInfo2->GetFilename(), szNZBFilename))
+				{
+					pNZBInfo = pNZBInfo2;
+					break;
+				}
+			}
+			if (!pNZBInfo)
+			{
+				pNZBInfo = new NZBInfo();
+				pNZBInfo->SetFilename(szNZBFilename);
+				pNZBInfo->SetDestDir(szDestDir);
+				pNZBInfo->SetCategory(szCategory);
+				cNZBList.push_back(pNZBInfo);
+			}
+
+			pFileInfo->SetNZBInfo(pNZBInfo);
+
+			m_RemoteQueue.push_back(pFileInfo);
+
+			pBufPtr += sizeof(SNZBListResponseEntry) + ntohl(pListAnswer->m_iNZBFilenameLen) +
+				ntohl(pListAnswer->m_iSubjectLen) + ntohl(pListAnswer->m_iFilenameLen) + 
+				ntohl(pListAnswer->m_iDestDirLen) + ntohl(pListAnswer->m_iCategoryLen);
+		}
+	}
 	if (pBuf)
 	{
 		free(pBuf);
@@ -366,19 +430,26 @@ bool Frontend::RequestPauseUnpause(bool bPause)
 {
 	RemoteClient client;
 	client.SetVerbose(false);
-	return client.RequestServerPauseUnpause(bPause, eRemotePauseUnpauseActionDownload);
+	return client.RequestServerPauseUnpause(bPause);
 }
 
-bool Frontend::RequestSetDownloadRate(int iRate)
+bool Frontend::RequestSetDownloadRate(float fRate)
 {
 	RemoteClient client;
 	client.SetVerbose(false);
-	return client.RequestServerSetDownloadRate(iRate);
+	return client.RequestServerSetDownloadRate(fRate);
 }
 
-bool Frontend::RequestEditQueue(DownloadQueue::EEditAction eAction, int iOffset, int iID)
+bool Frontend::RequestDumpDebug()
 {
 	RemoteClient client;
 	client.SetVerbose(false);
-	return client.RequestServerEditQueue(eAction, iOffset, NULL, &iID, 1, NULL, eRemoteMatchModeID);
+	return client.RequestServerDumpDebug();
+}
+
+bool Frontend::RequestEditQueue(int iAction, int iOffset, int iID)
+{
+	RemoteClient client;
+	client.SetVerbose(false);
+	return client.RequestServerEditQueue(iAction, iOffset, NULL, &iID, 1, false);
 }

Frontend.h

@@ -1,8 +1,8 @@
 /*
  *  This file is part of nzbget
  *
- *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
- *  Copyright (C) 2007-2015 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$
@@ -36,7 +36,8 @@
 class Frontend : public Thread
 {
 private:
-	MessageList			m_RemoteMessages;
+	Log::Messages		m_RemoteMessages;
+	DownloadQueue		m_RemoteQueue;
 
 	bool				RequestMessages();
 	bool				RequestFileList();
@@ -49,10 +50,10 @@ protected:
 	int					m_iUpdateInterval;
 
 	// 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;
@@ -62,7 +63,7 @@ protected:
 
 	bool				PrepareData();
 	void				FreeData();
-	MessageList*		LockMessages();
+	Log::Messages*		LockMessages();
 	void				UnlockMessages();
 	DownloadQueue*		LockQueue();
 	void				UnlockQueue();
@@ -70,10 +71,12 @@ protected:
 	void				InitMessageBase(SNZBRequestBase* 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(QueueEditor::EEditAction eAction, int iOffset, int iEntry);
+	bool 				RequestEditQueue(int iAction, int iOffset, int iID);
 
 public:
 						Frontend();

INSTALL

@@ -0,0 +1,167 @@
+Basic Installation
+==================
+
+   These are generic installation instructions.
+
+   The `configure' shell script attempts to guess correct values for
+various system-dependent variables used during compilation.  It uses
+those values to create a `Makefile' in each directory of the package.
+It may also create one or more `.h' files containing system-dependent
+definitions.  Finally, it creates a shell script `config.status' that
+you can run in the future to recreate the current configuration, a file
+`config.cache' that saves the results of its tests to speed up
+reconfiguring, and a file `config.log' containing compiler output
+(useful mainly for debugging `configure').
+
+   If you need to do unusual things to compile the package, please try
+to figure out how `configure' could check whether to do them, and mail
+diffs or instructions to the address given in the `README' so they can
+be considered for the next release.  If at some point `config.cache'
+contains results you don't want to keep, you may remove or edit it.
+
+   The file `configure.in' is used to create `configure' by a program
+called `autoconf'.  You only need `configure.in' if you want to change
+it or regenerate `configure' using a newer version of `autoconf'.
+
+The simplest way to compile this package is:
+
+  1. `cd' to the directory containing the package's source code and type
+     `./configure' to configure the package for your system.  If you're
+     using `csh' on an old version of System V, you might need to type
+     `sh ./configure' instead to prevent `csh' from trying to execute
+     `configure' itself.
+
+     Running `configure' takes a while.  While running, it prints some
+     messages telling which features it is checking for.
+
+  2. Type `make' to compile the package.
+
+  3. Type `make install' to install the programs and any data files and
+     documentation.
+
+  4. You can remove the program binaries and object files from the
+     source code directory by typing `make clean'.  
+
+Compilers and Options
+=====================
+
+   Some systems require unusual options for compilation or linking that
+the `configure' script does not know about.  You can give `configure'
+initial values for variables by setting them in the environment.  Using
+a Bourne-compatible shell, you can do that on the command line like
+this:
+     CC=c89 CFLAGS=-O2 LIBS=-lposix ./configure
+
+Or on systems that have the `env' program, you can do it like this:
+     env CPPFLAGS=-I/usr/local/include LDFLAGS=-s ./configure
+
+Compiling For Multiple Architectures
+====================================
+
+   You can compile the package for more than one kind of computer at the
+same time, by placing the object files for each architecture in their
+own directory.  To do this, you must use a version of `make' that
+supports the `VPATH' variable, such as GNU `make'.  `cd' to the
+directory where you want the object files and executables to go and run
+the `configure' script.  `configure' automatically checks for the
+source code in the directory that `configure' is in and in `..'.
+
+   If you have to use a `make' that does not supports the `VPATH'
+variable, you have to compile the package for one architecture at a time
+in the source code directory.  After you have installed the package for
+one architecture, use `make distclean' before reconfiguring for another
+architecture.
+
+Installation Names
+==================
+
+   By default, `make install' will install the package's files in
+`/usr/local/bin', `/usr/local/man', etc.  You can specify an
+installation prefix other than `/usr/local' by giving `configure' the
+option `--prefix=PATH'.
+
+   You can specify separate installation prefixes for
+architecture-specific files and architecture-independent files.  If you
+give `configure' the option `--exec-prefix=PATH', the package will use
+PATH as the prefix for installing programs and libraries.
+Documentation and other data files will still use the regular prefix.
+
+   If the package supports it, you can cause programs to be installed
+with an extra prefix or suffix on their names by giving `configure' the
+option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'.
+
+Optional Features
+=================
+
+   Some packages pay attention to `--enable-FEATURE' options to
+`configure', where FEATURE indicates an optional part of the package.
+They may also pay attention to `--with-PACKAGE' options, where PACKAGE
+is something like `gnu-as' or `x' (for the X Window System).  The
+`README' should mention any `--enable-' and `--with-' options that the
+package recognizes.
+
+   For packages that use the X Window System, `configure' can usually
+find the X include and library files automatically, but if it doesn't,
+you can use the `configure' options `--x-includes=DIR' and
+`--x-libraries=DIR' to specify their locations.
+
+Specifying the System Type
+==========================
+
+   There may be some features `configure' can not figure out
+automatically, but needs to determine by the type of host the package
+will run on.  Usually `configure' can figure that out, but if it prints
+a message saying it can not guess the host type, give it the
+`--host=TYPE' option.  TYPE can either be a short name for the system
+type, such as `sun4', or a canonical name with three fields:
+     CPU-COMPANY-SYSTEM
+
+See the file `config.sub' for the possible values of each field.  If
+`config.sub' isn't included in this package, then this package doesn't
+need to know the host type.
+
+   If you are building compiler tools for cross-compiling, you can also
+use the `--target=TYPE' option to select the type of system they will
+produce code for and the `--build=TYPE' option to select the type of
+system on which you are compiling the package.
+
+Sharing Defaults
+================
+
+   If you want to set default values for `configure' scripts to share,
+you can create a site shell script called `config.site' that gives
+default values for variables like `CC', `cache_file', and `prefix'.
+`configure' looks for `PREFIX/share/config.site' if it exists, then
+`PREFIX/etc/config.site' if it exists.  Or, you can set the
+`CONFIG_SITE' environment variable to the location of the site script.
+A warning: not all `configure' scripts look for a site script.
+
+Operation Controls
+==================
+
+   `configure' recognizes the following options to control how it
+operates.
+
+`--cache-file=FILE'
+     Use and save the results of the tests in FILE instead of
+     `./config.cache'.  Set FILE to `/dev/null' to disable caching, for
+     debugging `configure'.
+
+`--help'
+     Print a summary of the options to `configure', and exit.
+
+`--quiet'
+`--silent'
+`-q'
+     Do not print messages saying which checks are being made.
+
+`--srcdir=DIR'
+     Look for the package's source code in directory DIR.  Usually
+     `configure' can determine that directory automatically.
+
+`--version'
+     Print the version of Autoconf used to generate the `configure'
+     script, and exit.
+
+`configure' also accepts some other, not widely useful, options.
+

Log.cpp

@@ -0,0 +1,359 @@
+/*
+ *  This file is 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>
+#include <stdarg.h>
+#include <cstdio>
+
+#include "nzbget.h"
+#include "Options.h"
+#include "Log.h"
+#include "Util.h"
+
+extern Options* g_pOptions;
+
+Log::Log()
+{
+	m_Messages.clear();
+	m_iIDGen = 0;
+	m_szLogFilename = NULL;
+#ifdef DEBUG
+	m_bExtraDebug = Util::FileExists("extradebug");
+#endif
+}
+
+Log::~Log()
+{
+	for (Messages::iterator it = m_Messages.begin(); it != m_Messages.end(); it++)
+	{
+		delete *it;
+	}
+	m_Messages.clear();
+	if (m_szLogFilename)
+	{
+		free(m_szLogFilename);
+	}
+}
+
+void Log::Filelog(const char* msg, ...)
+{
+	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;
+		va_start(ap, msg);
+		vsnprintf(tmp2, 1024, msg, ap);
+		tmp2[1024-1] = '\0';
+		va_end(ap);
+
+		time_t rawtime;
+		time(&rawtime);
+		
+		char szTime[50];
+#ifdef HAVE_CTIME_R_3
+		ctime_r(&rawtime, szTime, 50);
+#else
+		ctime_r(&rawtime, szTime);
+#endif
+		szTime[50-1] = '\0';
+		szTime[strlen(szTime) - 1] = '\0'; // trim LF
+
+		FILE* file = fopen(m_szLogFilename, "a+");
+		if (file)
+		{
+#ifdef WIN32
+			unsigned long iThreadId = GetCurrentThreadId();
+#else
+			unsigned long iThreadId = (unsigned long)pthread_self();
+#endif
+#ifdef DEBUG
+			fprintf(file, "%s\t%lu\t%s%s", szTime, iThreadId, tmp2, LINE_ENDING);
+#else
+			fprintf(file, "%s\t%s%s", szTime, tmp2, LINE_ENDING);
+#endif
+			fclose(file);
+		}
+		else
+		{
+			perror(m_szLogFilename);
+		}
+	}
+}
+
+#undef 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
+{
+#ifdef DEBUG
+	char tmp1[1024];
+
+	va_list ap;
+	va_start(ap, msg);
+	vsnprintf(tmp1, 1024, msg, ap);
+	tmp1[1024-1] = '\0';
+	va_end(ap);
+
+	char tmp2[1024];
+#ifdef HAVE_VARIADIC_MACROS
+	if (szFuncname)
+	{
+		snprintf(tmp2, 1024, "%s (%s:%i:%s)", tmp1, Util::BaseFileName(szFilename), iLineNr, szFuncname);
+	}
+	else
+	{
+		snprintf(tmp2, 1024, "%s (%s:%i)", tmp1, Util::BaseFileName(szFilename), iLineNr);
+	}
+#else
+	snprintf(tmp2, 1024, "%s", tmp1);
+#endif
+	tmp2[1024-1] = '\0';
+
+	g_pLog->m_mutexLog.Lock();
+
+	if (!g_pOptions)
+	{
+		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->GetDebugTarget();
+	if (eMessageTarget == Options::mtLog || eMessageTarget == Options::mtBoth)
+	{
+		g_pLog->Filelog("DEBUG\t%s", tmp2);
+	}
+	if (eMessageTarget == Options::mtScreen || eMessageTarget == Options::mtBoth)
+	{
+		g_pLog->AppendMessage(Message::mkDebug, tmp2);
+	}
+
+	g_pLog->m_mutexLog.Unlock();
+#endif
+}
+
+void error(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->GetErrorTarget();
+	if (eMessageTarget == Options::mtLog || eMessageTarget == Options::mtBoth)
+	{
+		g_pLog->Filelog("ERROR\t%s", tmp2);
+	}
+	if (eMessageTarget == Options::mtScreen || eMessageTarget == Options::mtBoth)
+	{
+		g_pLog->AppendMessage(Message::mkError, tmp2);
+	}
+
+	g_pLog->m_mutexLog.Unlock();
+}
+
+void warn(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->GetWarningTarget();
+	if (eMessageTarget == Options::mtLog || eMessageTarget == Options::mtBoth)
+	{
+		g_pLog->Filelog("WARNING\t%s", tmp2);
+	}
+	if (eMessageTarget == Options::mtScreen || eMessageTarget == Options::mtBoth)
+	{
+		g_pLog->AppendMessage(Message::mkWarning, tmp2);
+	}
+
+	g_pLog->m_mutexLog.Unlock();
+}
+
+void info(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->GetInfoTarget();
+	if (eMessageTarget == Options::mtLog || eMessageTarget == Options::mtBoth)
+	{
+		g_pLog->Filelog("INFO\t%s", tmp2);
+	}
+	if (eMessageTarget == Options::mtScreen || eMessageTarget == Options::mtBoth)
+	{
+		g_pLog->AppendMessage(Message::mkInfo, tmp2);
+	}
+
+	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->GetDetailTarget();
+	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];
+
+	va_list ap;
+	va_start(ap, msg);
+	vsnprintf(tmp2, 1024, msg, ap);
+	tmp2[1024-1] = '\0';
+	va_end(ap);
+
+	g_pLog->m_mutexLog.Lock();
+
+	printf("\n%s", tmp2);
+
+	g_pLog->Filelog(tmp2);
+
+	g_pLog->m_mutexLog.Unlock();
+
+	exit(-1);
+}
+
+//************************************************************
+// Message
+
+Message::Message(unsigned int iID, EKind eKind, time_t tTime, const char* szText)
+{
+	m_iID = iID;
+	m_eKind = eKind;
+	m_tTime = tTime;
+	if (szText)
+	{
+		m_szText = strdup(szText);
+	}
+	else
+	{
+		m_szText = NULL;
+	}
+}
+
+Message::~ Message()
+{
+	if (m_szText)
+	{
+		free(m_szText);
+	}
+}
+
+void Log::AppendMessage(Message::EKind eKind, const char * szText)
+{
+	Message* pMessage = new Message(++m_iIDGen, eKind, time(NULL), szText);
+	m_Messages.push_back(pMessage);
+
+	while (m_Messages.size() > (unsigned int)g_pOptions->GetLogBufferSize())
+	{
+		Message* pMessage = m_Messages.front();
+		delete pMessage;
+		m_Messages.pop_front();
+	}
+}
+
+Log::Messages* Log::LockMessages()
+{
+	m_mutexLog.Lock();
+	return &m_Messages;
+}
+
+void Log::UnlockMessages()
+{
+	m_mutexLog.Unlock();
+}
+
+void Log::ResetLog()
+{
+	remove(g_pOptions->GetLogFile());
+}

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-2015 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"
@@ -37,14 +36,14 @@ 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
 {
@@ -64,88 +63,57 @@ 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; }
 };
 
-typedef std::deque<Message*> MessageListBase;
-
-class MessageList: public MessageListBase
-{
-public:
-						~MessageList();
-	void				Clear();
-};
-
-class Debuggable
-{
-protected:
-	virtual void		LogDebugInfo() = 0;
-	friend class Log;
-};
-
 class Log
 {
 public:
-	typedef std::list<Debuggable*>	Debuggables;
+	typedef std::deque<Message*>	Messages;
 
 private:
 	Mutex				m_mutexLog;
-	MessageList			m_Messages;
-	Debuggables			m_Debuggables;
-	Mutex				m_mutexDebug;
+	Messages			m_Messages;
 	char*				m_szLogFilename;
 	unsigned int		m_iIDGen;
-	time_t				m_tLastWritten;
-	bool				m_bOptInit;
 #ifdef DEBUG
 	bool				m_bExtraDebug;
 #endif
 
-						Log();
-						~Log();
 	void				Filelog(const char* msg, ...);
-	void				AddMessage(Message::EKind eKind, const char* szText);
-	void				RotateLog();
+	void				AppendMessage(Message::EKind eKind, const char* szText);
 
 	friend void error(const char* msg, ...);
 	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:
-	static void			Init();
-	static void			Final();
-	MessageList*		LockMessages();
+	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-2015  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$
@@ -79,7 +79,7 @@ void LoggableFrontend::Update()
 
 	BeforePrint();
 
-	MessageList* pMessages = LockMessages();
+	Log::Messages* pMessages = LockMessages();
 	if (!pMessages->empty())
 	{
 		Message* pFirstMessage = pMessages->front();

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,459 +1,20 @@
-#
-#  This file is part of nzbget
-#
-# Copyright (C) 2008-2015 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 BinRpc.cpp BinRpc.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 \
+	NCursesFrontend.cpp NCursesFrontend.h NNTPConnection.cpp NNTPConnection.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 PostInfo.cpp \
+	PostInfo.h PrePostProcessor.cpp PrePostProcessor.h QueueCoordinator.cpp \
+	QueueCoordinator.h QueueEditor.cpp QueueEditor.h RemoteClient.cpp RemoteClient.h \
+	RemoteServer.cpp RemoteServer.h ScriptController.cpp ScriptController.h ServerPool.cpp \
+	ServerPool.h TLS.cpp TLS.h Thread.cpp Thread.h Util.cpp Util.h XmlRpc.cpp XmlRpc.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/extension/FeedScript.cpp \
-	daemon/extension/FeedScript.h \
-	daemon/extension/NzbScript.cpp \
-	daemon/extension/NzbScript.h \
-	daemon/extension/PostScript.cpp \
-	daemon/extension/PostScript.h \
-	daemon/extension/QueueScript.cpp \
-	daemon/extension/QueueScript.h \
-	daemon/extension/ScanScript.cpp \
-	daemon/extension/ScanScript.h \
-	daemon/extension/SchedulerScript.cpp \
-	daemon/extension/SchedulerScript.h \
-	daemon/extension/ScriptConfig.cpp \
-	daemon/extension/ScriptConfig.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/CommandLineParser.cpp \
-    daemon/main/CommandLineParser.h \
-	daemon/main/DiskService.cpp \
-	daemon/main/DiskService.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/main/StackTrace.cpp \
-	daemon/main/StackTrace.h \
-	daemon/nntp/ArticleDownloader.cpp \
-	daemon/nntp/ArticleDownloader.h \
-	daemon/nntp/ArticleWriter.cpp \
-	daemon/nntp/ArticleWriter.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/Cleanup.cpp \
-	daemon/postprocess/Cleanup.h \
-	daemon/postprocess/DupeMatcher.cpp \
-	daemon/postprocess/DupeMatcher.h \
-	daemon/postprocess/ParChecker.cpp \
-	daemon/postprocess/ParChecker.h \
-	daemon/postprocess/ParCoordinator.cpp \
-	daemon/postprocess/ParCoordinator.h \
-	daemon/postprocess/ParParser.cpp \
-	daemon/postprocess/ParParser.h \
-	daemon/postprocess/ParRenamer.cpp \
-	daemon/postprocess/ParRenamer.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/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/Service.cpp \
-	daemon/util/Service.h \
-	daemon/util/Util.cpp \
-	daemon/util/Util.h \
-	code_revision.cpp
-
-if WITH_PAR2
-nzbget_SOURCES += \
-	lib/par2/commandline.cpp \
-	lib/par2/commandline.h \
-	lib/par2/crc.cpp \
-	lib/par2/crc.h \
-	lib/par2/creatorpacket.cpp \
-	lib/par2/creatorpacket.h \
-	lib/par2/criticalpacket.cpp \
-	lib/par2/criticalpacket.h \
-	lib/par2/datablock.cpp \
-	lib/par2/datablock.h \
-	lib/par2/descriptionpacket.cpp \
-	lib/par2/descriptionpacket.h \
-	lib/par2/diskfile.cpp \
-	lib/par2/diskfile.h \
-	lib/par2/filechecksummer.cpp \
-	lib/par2/filechecksummer.h \
-	lib/par2/galois.cpp \
-	lib/par2/galois.h \
-	lib/par2/letype.h \
-	lib/par2/mainpacket.cpp \
-	lib/par2/mainpacket.h \
-	lib/par2/md5.cpp \
-	lib/par2/md5.h \
-	lib/par2/par2cmdline.h \
-	lib/par2/par2creatorsourcefile.cpp \
-	lib/par2/par2creatorsourcefile.h \
-	lib/par2/par2fileformat.cpp \
-	lib/par2/par2fileformat.h \
-	lib/par2/par2repairer.cpp \
-	lib/par2/par2repairer.h \
-	lib/par2/par2repairersourcefile.cpp \
-	lib/par2/par2repairersourcefile.h \
-	lib/par2/parheaders.cpp \
-	lib/par2/parheaders.h \
-	lib/par2/recoverypacket.cpp \
-	lib/par2/recoverypacket.h \
-	lib/par2/reedsolomon.cpp \
-	lib/par2/reedsolomon.h \
-	lib/par2/verificationhashtable.cpp \
-	lib/par2/verificationhashtable.h \
-	lib/par2/verificationpacket.cpp \
-	lib/par2/verificationpacket.h
-endif
-
-AM_CPPFLAGS = \
-	-I$(srcdir)/daemon/connect \
-	-I$(srcdir)/daemon/extension \
-	-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 \
-	-I$(srcdir)/lib/par2
-
-if WITH_TESTS
-nzbget_SOURCES += \
-	lib/catch/catch.h \
-	tests/suite/TestMain.cpp \
-	tests/suite/TestMain.h \
-	tests/suite/TestUtil.cpp \
-	tests/suite/TestUtil.h \
-	tests/main/CommandLineParserTest.cpp \
-	tests/main/OptionsTest.cpp \
-	tests/feed/FeedFilterTest.cpp \
-	tests/postprocess/ParCheckerTest.cpp \
-	tests/postprocess/ParRenamerTest.cpp \
-	tests/queue/NZBFileTest.cpp \
-	tests/util/UtilTest.cpp
-
-AM_CPPFLAGS += \
-	-I$(srcdir)/lib/catch \
-	-I$(srcdir)/tests/suite
-endif
-
-EXTRA_DIST = \
-	$(windows_FILES) \
-	$(osx_FILES) \
-	$(linux_FILES) \
-	$(testdata_FILES)
-
-windows_FILES = \
-	daemon/windows/NTService.cpp \
-	daemon/windows/NTService.h \
-	daemon/windows/win32.h \
-	daemon/windows/WinConsole.cpp \
-	daemon/windows/WinConsole.h \
-	nzbget.vcproj \
-	windows/nzbget-command-shell.bat  \
-	windows/install-update.bat  \
-	windows/README-WINDOWS.txt  \
-	windows/package-info.json  \
-	windows/resources/mainicon.ico \
-	windows/resources/nzbget.rc \
-	windows/resources/resource.h \
-	windows/resources/trayicon_idle.ico \
-	windows/resources/trayicon_paused.ico \
-	windows/resources/trayicon_working.ico \
-	windows/setup/nzbget-setup.nsi \
-	windows/setup/install.bmp \
-	windows/setup/uninstall.bmp
-
-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/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
-
-linux_FILES = \
-	linux/installer.sh \
-	linux/install-update.sh \
-	linux/package-info.json \
-	linux/build-info.txt \
-	linux/build-nzbget \
-	linux/build-unpack
-
-doc_FILES = \
-	lib/par2/AUTHORS \
-	lib/par2/README \
-	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
-
-testdata_FILES = \
-	tests/testdata/dupematcher1/testfile.part01.rar \
-	tests/testdata/dupematcher1/testfile.part24.rar \
-	tests/testdata/dupematcher2/testfile.part04.rar \
-	tests/testdata/dupematcher2/testfile.part43.rar \
-	tests/testdata/nzbfile/dotless.nzb \
-	tests/testdata/nzbfile/dotless.txt \
-	tests/testdata/nzbfile/plain.nzb \
-	tests/testdata/nzbfile/plain.txt \
-	tests/testdata/parchecker/crc.txt \
-	tests/testdata/parchecker/testfile.dat \
-	tests/testdata/parchecker/testfile.nfo \
-	tests/testdata/parchecker/testfile.par2 \
-	tests/testdata/parchecker/testfile.vol00+1.PAR2 \
-	tests/testdata/parchecker/testfile.vol01+2.PAR2 \
-	tests/testdata/parchecker/testfile.vol03+3.PAR2
-
-# Install
-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.
-
-# 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 git revision:
-# 1) If directory ".git" exists we take revision from git log.
-#    File is recreated only if revision number was changed.
-# 2) If directory ".git" doesn't exists we keep and reuse file "code_revision.cpp",
-#    which was possibly created early.
-# 3) If neither directory ".git" nor file "code_revision.cpp" are available
-#    we create new file "code_revision.c" with empty revision number.
-code_revision.cpp: FORCE
-	@ if test -d ./.git ; then \
-		B="$(shell git branch | sed -n -e 's/^\* \(.*\)/\1/p')"; \
-		M="$(shell git status --porcelain)" ; \
-		if test "$$M" != "" ; then \
-			M="M" ; \
-		fi ; \
-		if test "$$B" = "master" ; then \
-			V="$$M" ; \
-		elif test "$$B" = "develop" ; then \
-			V="$(shell git rev-list HEAD | wc -l | xargs)" ; \
-			V="$${V}$$M" ; \
-		else \
-			V="$(shell git rev-list HEAD | wc -l | xargs)" ; \
-			V="$${V}$$M ($$B)" ; \
-		fi ; \
-		H="$(shell test -f ./code_revision.cpp && head -n 1 code_revision.cpp)"; \
-		if test "/* $$V */" != "$$H" ; then \
-			( \
-			echo "/* $$V */" ;\
-			echo "/* This file is automatically regenerated on each build. Do not edit it. */" ;\
-			echo "const char* code_revision(void)" ;\
-			echo "{" ;\
-			echo "	const char* revision = \"$$V\";" ;\
-			echo "	return revision;" ;\
-			echo "}" ;\
-			) > code_revision.cpp ; \
-		fi \
-	elif test -f ./code_revision.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* code_revision(void)" ;\
-		echo "{" ;\
-		echo "	const char* revision = \"\";" ;\
-		echo "	return revision;" ;\
-		echo "}" ;\
-		) > code_revision.cpp ; \
-	fi
-FORCE:
-
-# Ignore "code_revision.cpp" in distcleancheck
-distcleancheck_listfiles = \
-	find . -type f -exec sh -c 'test -f $(srcdir)/$$1 || echo $$1' \
-	sh '{}' ';'
+EXTRA_DIST = nzbget.conf.example postprocess-example.sh \
+	win32.h NTService.cpp NTService.h \
+	libpar2-0.2-MSVC8.patch libsigc++-2.0.18-MSVC8.patch \
+	Makefile.cvs 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 {} \;
-	find $(distdir)/lib -type f -print -exec chmod -x {} \;
-	find $(distdir)/tests -type f -print -exec chmod -x {} \;
-

Makefile.cvs

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

MessageBase.h

@@ -1,8 +1,8 @@
 /*
  *  This file is part of nzbget
  *
- *  Copyright (C) 2005 Bo Cordes Petersen <placebodk@users.sourceforge.net>
- *  Copyright (C) 2007-2015 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$
@@ -27,11 +27,7 @@
 #ifndef MESSAGEBASE_H
 #define MESSAGEBASE_H
 
-#if (!(defined(WIN32) && _MSC_VER < 1600))
-#include <stdint.h>
-#endif
-
-static const int32_t NZBMESSAGE_SIGNATURE = 0x6E7A6228; // = "nzb-XX" (protocol version)
+static const int32_t NZBMESSAGE_SIGNATURE = 0x6E7A6203; // = "nzb3" (nzb version 3)
 static const int NZBREQUESTFILENAMESIZE = 512;
 static const int NZBREQUESTPASSWORDSIZE = 32;
 
@@ -39,14 +35,8 @@ static const int NZBREQUESTPASSWORDSIZE = 32;
  * NZBGet communication protocol uses only two basic data types: integer and char.
  * Integer values are passed using network byte order (Big-Endian).
  * Use function "htonl" and "ntohl" to convert integers to/from machine 
- * (host) byte order.
+ ' (host) byte order.
  * All char-strings ends with NULL-char.
- *
- * NOTE: 
- * NZBGet communication protocol is intended for usage only by NZBGet itself.
- * The communication works only if server and client has the same version.
- * The compatibility with previous program versions is not provided.
- * Third-party programs should use JSON-RPC or XML-RPC to communicate with NZBGet.
  */
 
 // Possible values for field "m_iType" of struct "SNZBRequestBase":
@@ -60,28 +50,33 @@ enum eRemoteRequest
 	eRemoteRequestEditQueue,
 	eRemoteRequestLog,
 	eRemoteRequestShutdown,
-	eRemoteRequestReload,
 	eRemoteRequestVersion,
 	eRemoteRequestPostQueue,
-	eRemoteRequestWriteLog,
-	eRemoteRequestScan,
-	eRemoteRequestHistory
+	eRemoteRequestWriteLog
 };
 
-// Possible values for field "m_iAction" of struct "SNZBPauseUnpauseRequest":
-enum eRemotePauseUnpauseAction
+// Possible values for field "m_iAction" of struct "SNZBEditQueueRequest":
+// File-Actions affect one file, Group-Actions affect all files in group.
+// Group is a list of files, added to queue from one NZB-File.
+enum eRemoteEditAction
 {
-	eRemotePauseUnpauseActionDownload = 1,	// pause/unpause download queue
-	eRemotePauseUnpauseActionPostProcess,	// pause/unpause post-processor queue
-	eRemotePauseUnpauseActionScan			// pause/unpause scan of incoming nzb-directory
-};
-
-// Possible values for field "m_iMatchMode" of struct "SNZBEditQueueRequest":
-enum eRemoteMatchMode
-{
-	eRemoteMatchModeID = 1,				// ID
-	eRemoteMatchModeName,				// Name
-	eRemoteMatchModeRegEx,				// RegEx
+	eRemoteEditActionFileMoveOffset = 1,	// move to m_iOffset relative to the current position in queue
+	eRemoteEditActionFileMoveTop,			// move to top of queue
+	eRemoteEditActionFileMoveBottom,		// move to bottom of queue
+	eRemoteEditActionFilePause,				// pause
+	eRemoteEditActionFileResume,			// resume (unpause)
+	eRemoteEditActionFileDelete,			// delete
+	eRemoteEditActionFilePauseAllPars,		// pause only (all) pars (does not affect other files)
+	eRemoteEditActionFilePauseExtraPars,	// pause only (almost all) pars, except main par-file (does not affect other files)
+	eRemoteEditActionGroupMoveOffset,		// move to m_iOffset relative to the current position in queue
+	eRemoteEditActionGroupMoveTop,			// move to top of queue
+	eRemoteEditActionGroupMoveBottom,		// move to bottom of queue
+	eRemoteEditActionGroupPause,			// pause
+	eRemoteEditActionGroupResume,			// resume (unpause)
+	eRemoteEditActionGroupDelete,			// delete
+	eRemoteEditActionGroupPauseAllPars,		// pause only (all) pars (does not affect other files)
+	eRemoteEditActionGroupPauseExtraPars,	// pause only (almost all) pars, except main par-file (does not affect other files)
+	eRemoteEditActionGroupSetCategory		// set or change category for a group
 };
 
 // The basic SNZBRequestBase struct, used in all requests
@@ -90,8 +85,7 @@ struct SNZBRequestBase
 	int32_t					m_iSignature;			// Signature must be NZBMESSAGE_SIGNATURE in integer-value
 	int32_t					m_iStructSize;			// Size of the entire struct
 	int32_t					m_iType;				// Message type, see enum in NZBMessageRequest-namespace
-	char					m_szUsername[NZBREQUESTPASSWORDSIZE];	// User name
-	char					m_szPassword[NZBREQUESTPASSWORDSIZE];	// Password
+	char					m_szPassword[NZBREQUESTPASSWORDSIZE];	// Password needs to be in every request
 };
 
 // The basic SNZBResposneBase struct, used in all responses
@@ -105,14 +99,9 @@ struct SNZBResponseBase
 struct SNZBDownloadRequest
 {
 	SNZBRequestBase			m_MessageBase;			// Must be the first in the struct
-	char					m_szNZBFilename[NZBREQUESTFILENAMESIZE];// Name of nzb-file. For URLs can be empty, then the filename is read from URL download response
-	char					m_szCategory[NZBREQUESTFILENAMESIZE];	// Category, can be empty
+	char					m_szFilename[NZBREQUESTFILENAMESIZE];	// Name of nzb-file, may contain full path (local path on client) or only filename
+	char					m_szCategory[NZBREQUESTFILENAMESIZE];	// Category, be empty
 	int32_t					m_bAddFirst;			// 1 - add file to the top of download queue
-	int32_t					m_bAddPaused;			// 1 - pause added files
-	int32_t					m_iPriority;			// Priority for files (0 - default)
-	int32_t					m_iDupeScore;			// Duplicate score
-	int32_t					m_iDupeMode;			// Duplicate mode (EDupeMode)
-	char					m_szDupeKey[NZBREQUESTFILENAMESIZE];	// Duplicate key
 	int32_t					m_iTrailingDataLength;	// Length of nzb-file in bytes
 	//char					m_szContent[m_iTrailingDataLength];	// variable sized
 };
@@ -132,9 +121,6 @@ struct SNZBListRequest
 	SNZBRequestBase			m_MessageBase;			// Must be the first in the struct
 	int32_t					m_bFileList;			// 1 - return file list
 	int32_t					m_bServerState;			// 1 - return server state
-	int32_t					m_iMatchMode;			// File/Group match mode, see enum eRemoteMatchMode (only values eRemoteMatchModeID (no filter) and eRemoteMatchModeRegEx are allowed)
-	int32_t					m_bMatchGroup;			// 0 - match files; 1 - match nzbs (when m_iMatchMode == eRemoteMatchModeRegEx)
-	char					m_szPattern[NZBREQUESTFILENAMESIZE];	// RegEx Pattern (when m_iMatchMode == eRemoteMatchModeRegEx)
 };
 
 // A list response
@@ -146,81 +132,39 @@ struct SNZBListResponse
 	int32_t 				m_iRemainingSizeHi;		// Remaining size in bytes, High 32-bits of 64-bit value
 	int32_t					m_iDownloadRate;		// Current download speed, in Bytes pro Second
 	int32_t					m_iDownloadLimit;		// Current download limit, in Bytes pro Second
-	int32_t					m_bDownloadPaused;		// 1 - download queue is currently in paused-state
-	int32_t					m_bDownload2Paused;		// 1 - download queue is currently in paused-state (second pause-register)
-	int32_t					m_bDownloadStandBy;		// 0 - there are currently downloads running, 1 - no downloads in progress (download queue paused or all download jobs completed)
-	int32_t					m_bPostPaused;			// 1 - post-processor queue is currently in paused-state
-	int32_t					m_bScanPaused;			// 1 - scaning of incoming directory is currently in paused-state
+	int32_t					m_bServerPaused;		// 1 - server is currently in paused-state
 	int32_t					m_iThreadCount;			// Number of threads running
 	int32_t					m_iPostJobCount;		// Number of jobs in post-processor queue (including current job)
 	int32_t					m_iUpTimeSec;			// Server up time in seconds
 	int32_t					m_iDownloadTimeSec;		// Server download time in seconds (up_time - standby_time)
 	int32_t					m_iDownloadedBytesLo;	// Amount of data downloaded since server start, Low 32-bits of 64-bit value
 	int32_t					m_iDownloadedBytesHi;	// Amount of data downloaded since server start, High 32-bits of 64-bit value
-	int32_t					m_bRegExValid;			// 0 - error in RegEx-pattern, 1 - RegEx-pattern is valid (only when Request has eRemoteMatchModeRegEx)
-	int32_t					m_iNrTrailingNZBEntries;	// Number of List-NZB-entries, following to this structure
-	int32_t					m_iNrTrailingPPPEntries;	// Number of List-PPP-entries, following to this structure
-	int32_t					m_iNrTrailingFileEntries;	// Number of List-File-entries, following to this structure
-	int32_t					m_iTrailingDataLength;		// Length of all List-entries, following to this structure
-	// SNZBListResponseEntry m_NZBEntries[m_iNrTrailingNZBEntries]			// variable sized
-	// SNZBListResponseEntry m_PPPEntries[m_iNrTrailingPPPEntries]			// variable sized
-	// SNZBListResponseEntry m_FileEntries[m_iNrTrailingFileEntries]		// variable sized
+	int32_t					m_bServerStandBy;		// 0 - there are currently downloads running, 1 - no downloads in progress (server paused or all jobs completed)
+	int32_t					m_iNrTrailingEntries;	// Number of List-entries, following to this structure
+	int32_t					m_iTrailingDataLength;	// Length of all List-entries, following to this structure
+	// SNZBListResponseEntry m_Entries[m_iNrTrailingEntries]		// variable sized
 };
 
-// A list response nzb entry
-struct SNZBListResponseNZBEntry
-{
-	int32_t					m_iID;					// NZB-ID
-	int32_t					m_iKind;				// Item Kind (see NZBInfo::Kind)
-	int32_t					m_iSizeLo;				// Size of all files in bytes, Low 32-bits of 64-bit value
-	int32_t					m_iSizeHi;				// Size of all files in bytes, High 32-bits of 64-bit value
-	int32_t					m_iRemainingSizeLo;		// Size of remaining (unpaused) files in bytes, Low 32-bits of 64-bit value
-	int32_t					m_iRemainingSizeHi;		// Size of remaining (unpaused) files in bytes, High 32-bits of 64-bit value
-	int32_t					m_iPausedSizeLo;		// Size of npaused files in bytes, Low 32-bits of 64-bit value
-	int32_t					m_iPausedSizeHi;		// Size of paused files in bytes, High 32-bits of 64-bit value
-	int32_t					m_iPausedCount;			// Number of paused files
-	int32_t					m_iRemainingParCount;	// Number of remaining par-files
-	int32_t					m_iPriority;			// Download priority
-	int32_t					m_bMatch;				// 1 - group matches the pattern (only when Request has eRemoteMatchModeRegEx)
-	int32_t					m_iFilenameLen;			// Length of Filename-string (m_szFilename), following to this record
-	int32_t					m_iNameLen;				// Length of Name-string (m_szName), following to this record
-	int32_t					m_iDestDirLen;			// Length of DestDir-string (m_szDestDir), following to this record
-	int32_t					m_iCategoryLen;			// Length of Category-string (m_szCategory), following to this record
-	int32_t					m_iQueuedFilenameLen;	// Length of queued file name (m_szQueuedFilename), following to this record
-	//char					m_szFilename[m_iFilenameLen];				// variable sized
-	//char					m_szName[m_iNameLen];						// variable sized
-	//char					m_szDestDir[m_iDestDirLen];					// variable sized
-	//char					m_szCategory[m_iCategoryLen];				// variable sized
-	//char					m_szQueuedFilename[m_iQueuedFilenameLen];	// variable sized
-};
-
-// A list response pp-parameter entry
-struct SNZBListResponsePPPEntry
-{
-	int32_t					m_iNZBIndex;			// Index of NZB-Entry in m_NZBEntries-list
-	int32_t					m_iNameLen;				// Length of Name-string (m_szName), following to this record
-	int32_t					m_iValueLen;			// Length of Value-string (m_szValue), following to this record
-	//char					m_szName[m_iNameLen];	// variable sized
-	//char					m_szValue[m_iValueLen];	// variable sized
-};
-
-// A list response file entry
-struct SNZBListResponseFileEntry
+// A list response entry
+struct SNZBListResponseEntry
 {
 	int32_t					m_iID;					// Entry-ID
-	int32_t					m_iNZBIndex;			// Index of NZB-Entry in m_NZBEntries-list
 	int32_t					m_iFileSizeLo;			// Filesize in bytes, Low 32-bits of 64-bit value
 	int32_t					m_iFileSizeHi;			// Filesize in bytes, High 32-bits of 64-bit value
 	int32_t					m_iRemainingSizeLo;		// Remaining size in bytes, Low 32-bits of 64-bit value
 	int32_t					m_iRemainingSizeHi;		// Remaining size in bytes, High 32-bits of 64-bit value
 	int32_t					m_bPaused;				// 1 - file is paused
 	int32_t					m_bFilenameConfirmed;	// 1 - Filename confirmed (read from article body), 0 - Filename parsed from subject (can be changed after reading of article)
-	int32_t					m_iActiveDownloads;		// Number of active downloads for this file
-	int32_t					m_bMatch;				// 1 - file matches the pattern (only when Request has eRemoteMatchModeRegEx)
+	int32_t					m_iNZBFilenameLen;		// Length of NZBFileName-string (m_szNZBFilename), following to this record
 	int32_t					m_iSubjectLen;			// Length of Subject-string (m_szSubject), following to this record
 	int32_t					m_iFilenameLen;			// Length of Filename-string (m_szFilename), following to this record
+	int32_t					m_iDestDirLen;			// Length of DestDir-string (m_szDestDir), following to this record
+	int32_t					m_iCategoryLen;			// Length of Category-string (m_szCategory), following to this record
+	//char					m_szNZBFilename[m_iNZBFilenameLen];	// variable sized, may contain full path (local path on client) or only filename
 	//char					m_szSubject[m_iSubjectLen];			// variable sized
 	//char					m_szFilename[m_iFilenameLen];		// variable sized
+	//char					m_szDestDir[m_iDestDirLen];			// variable sized
+	//char					m_szCategory[m_iCategoryLen];		// variable sized
 };
 
 // A log request
@@ -256,7 +200,6 @@ struct SNZBPauseUnpauseRequest
 {
 	SNZBRequestBase			m_MessageBase;			// Must be the first in the struct
 	int32_t					m_bPause;				// 1 - server must be paused, 0 - server must be unpaused
-	int32_t					m_iAction;				// Action to be executed, see enum eRemotePauseUnpauseAction
 };
 
 // A Pause/Unpause response
@@ -284,21 +227,19 @@ struct SNZBSetDownloadRateResponse
 	//char					m_szText[m_iTrailingDataLength];	// variable sized
 };
 
-// edit queue request
+// An edit queue request
 struct SNZBEditQueueRequest
 {
 	SNZBRequestBase			m_MessageBase;			// Must be the first in the struct
-	int32_t					m_iAction;				// Action to be executed, see enum DownloadQueue::EEditAction
+	int32_t					m_iAction;				// Action to be executed, see enum in NZBMessageRequest-namespace
 	int32_t					m_iOffset;				// Offset to move (for m_iAction = 0)
-	int32_t					m_iMatchMode;				// File/Group match mode, see enum eRemoteMatchMode
-	int32_t					m_iNrTrailingIDEntries;		// Number of ID-entries, following to this structure
-	int32_t					m_iNrTrailingNameEntries;	// Number of Name-entries, following to this structure
-	int32_t					m_iTrailingNameEntriesLen;	// Length of all Name-entries, following to this structure
-	int32_t					m_iTextLen;					// Length of Text-string (m_szText), following to this record
-	int32_t					m_iTrailingDataLength;		// Length of Text-string and all ID-entries, following to this structure
-	//char					m_szText[m_iTextLen];		// variable sized
-	//int32_t				m_iIDs[m_iNrTrailingIDEntries];			// variable sized array of IDs. For File-Actions - ID of file, for Group-Actions - ID of any file belonging to group
-	//char*					m_szNames[m_iNrTrailingNameEntries];	// variable sized array of strings. For File-Actions - name of file incl. nzb-name as path, for Group-Actions - name of group
+	int32_t					m_bSmartOrder;			// For Move-Actions: 0 - execute action for each ID in order they are placed in array;
+													// 1 - smart execute to ensure that the relative order of all affected IDs are not changed.
+	int32_t					m_iNrTrailingEntries;	// Number of ID-entries, following to this structure
+	int32_t					m_iTextLen;				// Length of Text-string (m_szText), following to this record
+	int32_t					m_iTrailingDataLength;	// Length of Text-string and all ID-entries, following to this structure
+	//char					m_szText[m_iTextLen];	// variable sized
+	//int32_t				m_iIDs[m_iNrTrailingEntries];	// variable sized array of IDs. For File-Actions - ID of file, for Group-Actions - ID of any file belonging to group
 };
 
 // An edit queue response
@@ -340,21 +281,6 @@ struct SNZBShutdownResponse
 	//char					m_szText[m_iTrailingDataLength];	// variable sized
 };
 
-// Reload server request
-struct SNZBReloadRequest
-{
-	SNZBRequestBase			m_MessageBase;			// Must be the first in the struct
-};
-
-// Reload server response
-struct SNZBReloadResponse
-{
-	SNZBResponseBase		m_MessageBase;			// Must be the first in the struct
-	int32_t					m_bSuccess;				// 0 - command failed, 1 - command executed successfully
-	int32_t					m_iTrailingDataLength;	// Length of Text-string (m_szText), following to this record
-	//char					m_szText[m_iTrailingDataLength];	// variable sized
-};
-
 // Server version request
 struct SNZBVersionRequest
 {
@@ -396,10 +322,12 @@ struct SNZBPostQueueResponseEntry
 	int32_t					m_iTotalTimeSec;		// Number of seconds this post-job is beeing processed (after it first changed the state from QUEUED).
 	int32_t					m_iStageTimeSec;		// Number of seconds the current stage is beeing processed.
 	int32_t					m_iNZBFilenameLen;		// Length of NZBFileName-string (m_szNZBFilename), following to this record
+	int32_t					m_iParFilename;			// Length of ParFilename-string (m_szParFilename), following to this record
 	int32_t					m_iInfoNameLen;			// Length of Filename-string (m_szFilename), following to this record
 	int32_t					m_iDestDirLen;			// Length of DestDir-string (m_szDestDir), following to this record
 	int32_t					m_iProgressLabelLen;	// Length of ProgressLabel-string (m_szProgressLabel), following to this record
 	//char					m_szNZBFilename[m_iNZBFilenameLen];		// variable sized, may contain full path (local path on client) or only filename
+	//char					m_szParFilename[m_iParFilename];		// variable sized
 	//char					m_szInfoName[m_iInfoNameLen];			// variable sized
 	//char					m_szDestDir[m_iDestDirLen];				// variable sized
 	//char					m_szProgressLabel[m_iProgressLabelLen];	// variable sized
@@ -414,7 +342,7 @@ struct SNZBWriteLogRequest
 	//char					m_szText[m_iTrailingDataLength];	// variable sized
 };
 
-// Write log response
+// Write log  response
 struct SNZBWriteLogResponse
 {
 	SNZBResponseBase		m_MessageBase;			// Must be the first in the struct
@@ -423,57 +351,4 @@ struct SNZBWriteLogResponse
 	//char					m_szText[m_iTrailingDataLength];	// variable sized
 };
 
-// Scan nzb directory request
-struct SNZBScanRequest
-{
-	SNZBRequestBase			m_MessageBase;			// Must be the first in the struct
-	int32_t					m_bSyncMode;			// 0 - asynchronous Scan (the command returns immediately), 1 - synchronous Scan (the command returns when the scan is completed)
-};
-
-// Scan nzb directory response
-struct SNZBScanResponse
-{
-	SNZBResponseBase		m_MessageBase;			// Must be the first in the struct
-	int32_t					m_bSuccess;				// 0 - command failed, 1 - command executed successfully
-	int32_t					m_iTrailingDataLength;	// Length of Text-string (m_szText), following to this record
-	//char					m_szText[m_iTrailingDataLength];	// variable sized
-};
-
-// A history request
-struct SNZBHistoryRequest
-{
-	SNZBRequestBase			m_MessageBase;			// Must be the first in the struct
-	int32_t					m_bHidden;				// 0 - only return visible records, 1 - also return hidden records
-};
-
-// history response
-struct SNZBHistoryResponse
-{
-	SNZBResponseBase		m_MessageBase;			// Must be the first in the struct
-	int32_t					m_iEntrySize;			// Size of the SNZBHistoryResponseEntry-struct
-	int32_t					m_iNrTrailingEntries;	// Number of History-entries, following to this structure
-	int32_t					m_iTrailingDataLength;	// Length of all History-entries, following to this structure
-	// SNZBHistoryResponseEntry m_Entries[m_iNrTrailingEntries]			// variable sized
-};
-
-// history entry
-struct SNZBHistoryResponseEntry
-{
-	int32_t					m_iID;					// History-ID
-	int32_t					m_iKind;				// Kind of Item: 1 - Collection (NZB), 2 - URL, 3 - DUP (hidden record)
-	int32_t					m_tTime;				// When the item was added to history. time since the Epoch (00:00:00 UTC, January 1, 1970), measured in seconds.
-	int32_t					m_iNicenameLen;			// Length of Nicename-string (m_szNicename), following to this record
-	// for Collection and Dup items (m_iKind = 1 or 2)
-	int32_t					m_iSizeLo;				// Size of all files in bytes, Low 32-bits of 64-bit value
-	int32_t					m_iSizeHi;				// Size of all files in bytes, High 32-bits of 64-bit value
-	// for Collection items (m_iKind = 1)
-	int32_t					m_iFileCount;			// Initial number of files included in NZB-file
-	int32_t					m_iParStatus;			// See NZBInfo::EParStatus
-	int32_t					m_iScriptStatus;		// See NZBInfo::EScriptStatus
-	// for URL items (m_iKind = 2)
-	int32_t					m_iUrlStatus;			// See NZBInfo::EUrlStatus
-	// trailing data
-	//char					m_szNicename[m_iNicenameLen];				// variable sized
-};
-
 #endif

NCursesFrontend.cpp

@@ -1,8 +1,8 @@
 /*
  *  This file is part of nzbget
  *
- *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
- *  Copyright (C) 2007-2015 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$
@@ -25,7 +25,7 @@
 
 
 #ifdef HAVE_CONFIG_H
-#include "config.h"
+#include <config.h>
 #endif
 
 #ifdef WIN32
@@ -43,7 +43,6 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <stdio.h>
 #ifndef WIN32
 #include <unistd.h>
 #endif
@@ -61,18 +60,7 @@
 #undef erase
 #endif
 
-#ifndef WIN32
-// curses.h on Solaris declares "clear()" via DEFINE. That causes problems, because
-// it also affects calls to deque's method "clear()", producing compiler errors.
-// We use function "curses_clear()" to call macro "clear" of curses, then
-// undefine macro "clear".
-void curses_clear()
-{
-    clear();
-}
-#undef clear
-#endif
-
+extern Options* g_pOptions;
 extern void ExitProc();
 
 static const int NCURSES_COLORPAIR_TEXT			= 1;
@@ -136,13 +124,15 @@ NCursesFrontend::NCursesFrontend()
 	m_bShowNZBname = g_pOptions->GetCursesNZBName();
 	m_bShowTimestamp = g_pOptions->GetCursesTime();
 	m_bGroupFiles = g_pOptions->GetCursesGroup();
-	m_QueueWindowPercentage = 50;
+	m_QueueWindowPercentage = 0.5f;
 	m_iDataUpdatePos = 0;
     m_bUpdateNextTime = false;
 	m_iLastEditEntry = -1;
 	m_bLastPausePars = false;
 	m_szHint = NULL;
 
+	m_groupQueue.clear();
+
     // Setup curses
 #ifdef WIN32
 	HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
@@ -202,9 +192,14 @@ NCursesFrontend::NCursesFrontend()
 NCursesFrontend::~NCursesFrontend()
 {
 #ifdef WIN32
-	free(m_pScreenBuffer);
-	free(m_pOldScreenBuffer);
-
+	if (m_pScreenBuffer)
+	{
+		free(m_pScreenBuffer);
+	}
+	if (m_pOldScreenBuffer)
+	{
+		free(m_pOldScreenBuffer);
+	}
 	m_ColorAttr.clear();
 
 	HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
@@ -269,6 +264,7 @@ void NCursesFrontend::Run()
     }
 
     FreeData();
+	ClearGroupQueue();
 	
     debug("Exiting NCursesFrontend-loop");
 }
@@ -287,11 +283,13 @@ void NCursesFrontend::Update(int iKey)
     if (m_iDataUpdatePos <= 0)
     {
         FreeData();
+		ClearGroupQueue();
 		m_iNeededLogEntries = m_iMessagesWinClientHeight;
         if (!PrepareData())
         {
             return;
         }
+		PrepareGroupQueue();
 
 		// recalculate frame sizes
 		CalcWindowSizes();
@@ -308,7 +306,7 @@ void NCursesFrontend::Update(int iKey)
 	}
 
     //------------------------------------------
-    // Print Current NZBInfoList
+    // Print Current NZBQueue
     //------------------------------------------
 	if (m_iQueueWinHeight > 0)
 	{
@@ -353,7 +351,7 @@ void NCursesFrontend::CalcWindowSizes()
 		m_pOldScreenBuffer = (CHAR_INFO*)realloc(m_pOldScreenBuffer, m_iScreenBufferSize);
 		memset(m_pOldScreenBuffer, 0, m_iScreenBufferSize);
 #else
-        curses_clear();
+        clear();
 #endif
         m_iScreenHeight = iNrRows;
         m_iScreenWidth = iNrColumns;
@@ -362,7 +360,7 @@ void NCursesFrontend::CalcWindowSizes()
     int iQueueSize = CalcQueueSize();
     
 	m_iQueueWinTop = 0;
-	m_iQueueWinHeight = (m_iScreenHeight - 2) * m_QueueWindowPercentage / 100;
+	m_iQueueWinHeight = (int)((float) (m_iScreenHeight - 2) * m_QueueWindowPercentage);
 	if (m_iQueueWinHeight - 1 > iQueueSize)
 	{
 		m_iQueueWinHeight = iQueueSize > 0 ? iQueueSize + 1 : 1 + 1;
@@ -384,22 +382,17 @@ void NCursesFrontend::CalcWindowSizes()
 
 int NCursesFrontend::CalcQueueSize()
 {
-	int iQueueSize = 0;
-	DownloadQueue* pDownloadQueue = LockQueue();
 	if (m_bGroupFiles)
 	{
-		iQueueSize = pDownloadQueue->GetQueue()->size();
+		return m_groupQueue.size();
 	}
 	else
 	{
-		for (NZBList::iterator it = pDownloadQueue->GetQueue()->begin(); it != pDownloadQueue->GetQueue()->end(); it++)
-		{
-			NZBInfo* pNZBInfo = *it;
-			iQueueSize += pNZBInfo->GetFileList()->size();
-		}
+		DownloadQueue* pDownloadQueue = LockQueue();
+		int iQueueSize = pDownloadQueue->size();
+		UnlockQueue();
+		return iQueueSize;
 	}
-	UnlockQueue();
-	return iQueueSize;
 }
 
 void NCursesFrontend::PlotLine(const char * szString, int iRow, int iPos, int iColorPair)
@@ -503,7 +496,7 @@ void NCursesFrontend::PrintMessages()
     int iLine = iLineNr + m_iMessagesWinClientHeight - 1;
 	int iLinesToPrint = m_iMessagesWinClientHeight;
 
-    MessageList* pMessages = LockMessages();
+    Log::Messages* pMessages = LockMessages();
     
 	// print messages from bottom
 	for (int i = (int)pMessages->size() - 1; i >= 0 && iLinesToPrint > 0; i--)
@@ -547,8 +540,6 @@ int NCursesFrontend::PrintMessage(Message* Msg, int iRow, int iMaxLines)
 		szText = (char*)malloc(iLen);
 
 		time_t rawtime = Msg->GetTime();
-		rawtime += g_pOptions->GetTimeCorrection();
-
 		char szTime[50];
 #ifdef HAVE_CTIME_R_3
 		ctime_r(&rawtime, szTime, 50);
@@ -612,10 +603,10 @@ void NCursesFrontend::PrintStatus()
     char timeString[100];
     timeString[0] = '\0';
 
-	int iCurrentDownloadSpeed = m_bStandBy ? 0 : m_iCurrentDownloadSpeed;
-    if (iCurrentDownloadSpeed > 0 && !m_bPauseDownload)
+	float fCurrentDownloadSpeed = m_bStandBy ? 0 : m_fCurrentDownloadSpeed;
+    if (fCurrentDownloadSpeed > 0.0 && !m_bPause)
     {
-        long long remain_sec = (long long)(m_lRemainingSize / iCurrentDownloadSpeed);
+        long long remain_sec = (long long)(m_lRemainingSize / (fCurrentDownloadSpeed * 1024));
 		int h = (int)(remain_sec / 3600);
 		int m = (int)((remain_sec % 3600) / 60);
 		int s = (int)(remain_sec % 60);
@@ -623,9 +614,9 @@ void NCursesFrontend::PrintStatus()
     }
 
     char szDownloadLimit[128];
-    if (m_iDownloadLimit > 0)
+    if (m_fDownloadLimit > 0.0f)
     {
-        sprintf(szDownloadLimit, ", Limit %i KB/s", m_iDownloadLimit / 1024);
+        sprintf(szDownloadLimit, ", Limit %.0f KB/s", m_fDownloadLimit);
     }
     else
     {
@@ -642,16 +633,11 @@ void NCursesFrontend::PrintStatus()
         szPostStatus[0] = 0;
     }
 
-	char szCurrentSpeed[20];
-	char szAverageSpeed[20];
-	char szRemainingSize[20];
-	int iAverageSpeed = (int)(m_iDnTimeSec > 0 ? m_iAllBytes / m_iDnTimeSec : 0);
+	float fAverageSpeed = Util::Int64ToFloat(m_iDnTimeSec > 0 ? m_iAllBytes / m_iDnTimeSec / 1024 : 0);
 
-	snprintf(tmp, MAX_SCREEN_WIDTH, " %d threads, %s, %s remaining%s%s%s%s, Avg. %s",
-		m_iThreadCount, Util::FormatSpeed(szCurrentSpeed, sizeof(szCurrentSpeed), iCurrentDownloadSpeed),
-		Util::FormatSize(szRemainingSize, sizeof(szRemainingSize), m_lRemainingSize),
-		timeString, szPostStatus, m_bPauseDownload ? (m_bStandBy ? ", Paused" : ", Pausing") : "",
-		szDownloadLimit, Util::FormatSpeed(szAverageSpeed, sizeof(szAverageSpeed), iAverageSpeed));
+	snprintf(tmp, MAX_SCREEN_WIDTH, " %d threads, %.0f KB/s, %.2f MB remaining%s%s%s%s, Avg. %.0f KB/s", 
+		m_iThreadCount, fCurrentDownloadSpeed, (float)(Util::Int64ToFloat(m_lRemainingSize) / 1024.0 / 1024.0), timeString, 
+		szPostStatus, m_bPause ? (m_bStandBy ? ", Paused" : ", Pausing") : "", szDownloadLimit, fAverageSpeed);
 	tmp[MAX_SCREEN_WIDTH - 1] = '\0';
     PlotLine(tmp, iStatusRow, 0, NCURSES_COLORPAIR_STATUS);
 }
@@ -723,8 +709,11 @@ void NCursesFrontend::PrintKeyInputBar()
 
 void NCursesFrontend::SetHint(const char* szHint)
 {
-	free(m_szHint);
-	m_szHint = NULL;
+	if (m_szHint)
+	{
+		free(m_szHint);
+		m_szHint = NULL;
+	}
 	if (szHint)
 	{
 		m_szHint = strdup(szHint);
@@ -746,24 +735,31 @@ void NCursesFrontend::PrintQueue()
 
 void NCursesFrontend::PrintFileQueue()
 {
+	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';
+		PrintTopHeader(szBuffer, iLineNr++, true);
+        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;
 
-	int iLineNr = m_iQueueWinTop + 1;
-	long long lRemaining = 0;
-	long long lPaused = 0;
-	int iPausedFiles = 0;
-	int iFileNum = 0;
-
-	for (NZBList::iterator it = pDownloadQueue->GetQueue()->begin(); it != pDownloadQueue->GetQueue()->end(); it++)
-	{
-		NZBInfo* pNZBInfo = *it;
-		for (FileList::iterator it2 = pNZBInfo->GetFileList()->begin(); it2 != pNZBInfo->GetFileList()->end(); it2++, iFileNum++)
-		{
-			FileInfo* pFileInfo = *it2;
-
-			if (iFileNum >= m_iQueueScrollOffset && iFileNum < m_iQueueScrollOffset + m_iQueueWinHeight -1)
+			if (i >= m_iQueueScrollOffset && i < m_iQueueScrollOffset + m_iQueueWinHeight -1)
 			{
-				PrintFilename(pFileInfo, iLineNr++, iFileNum == m_iSelectedQueueEntry);
+				PrintFilename(pFileInfo, iLineNr++, i == m_iSelectedQueueEntry);
 			}
 
 			if (pFileInfo->GetPaused())
@@ -772,32 +768,20 @@ void NCursesFrontend::PrintFileQueue()
 				lPaused += pFileInfo->GetRemainingSize();
 			}
 			lRemaining += pFileInfo->GetRemainingSize();
-		}
-	}
-
-	if (iFileNum > 0)
-	{
+        }
+		
 		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 ? "" : "*** ", iFileNum,
-			iFileNum - iPausedFiles,
-			Util::FormatSize(szRemaining, sizeof(szRemaining), lRemaining),
-			Util::FormatSize(szUnpaused, sizeof(szUnpaused), lRemaining - lPaused));
+			m_bUseColor ? "" : "*** ", pDownloadQueue->size(), pDownloadQueue->size() - iPausedFiles, szRemaining, szUnpaused);
 		szBuffer[MAX_SCREEN_WIDTH - 1] = '\0';
 		PrintTopHeader(szBuffer, m_iQueueWinTop, true);
     }
-	else
-	{
-		iLineNr--;
-		char szBuffer[MAX_SCREEN_WIDTH];
-		snprintf(szBuffer, sizeof(szBuffer), "%s Files for downloading", m_bUseColor ? "" : "*** ");
-		szBuffer[MAX_SCREEN_WIDTH - 1] = '\0';
-		PrintTopHeader(szBuffer, iLineNr++, true);
-        PlotLine("Ready to receive nzb-job", iLineNr++, 0, NCURSES_COLORPAIR_TEXT);
-	}
-
     UnlockQueue();
 }
 
@@ -820,30 +804,17 @@ void NCursesFrontend::PrintFilename(FileInfo * pFileInfo, int iRow, bool bSelect
 		color = NCURSES_COLORPAIR_TEXT;
 	}
 
-	const char* szDownloading = "";
-	if (pFileInfo->GetActiveDownloads() > 0)
-	{
-		szDownloading = " *";
-	}
-
-	char szPriority[100];
-	szPriority[0] = '\0';
-	if (pFileInfo->GetNZBInfo()->GetPriority() != 0)
-	{
-		sprintf(szPriority, " [%+i]", pFileInfo->GetNZBInfo()->GetPriority());
-	}
-
 	char szCompleted[20];
 	szCompleted[0] = '\0';
 	if (pFileInfo->GetRemainingSize() < pFileInfo->GetSize())
 	{
-		sprintf(szCompleted, ", %i%%", (int)(100 - pFileInfo->GetRemainingSize() * 100 / pFileInfo->GetSize()));
+		sprintf(szCompleted, ", %i%%", (int)(100 - Util::Int64ToFloat(pFileInfo->GetRemainingSize()) * 100.0 / Util::Int64ToFloat(pFileInfo->GetSize())));
 	}
 
 	char szNZBNiceName[1024];
 	if (m_bShowNZBname)
 	{
-		strncpy(szNZBNiceName, pFileInfo->GetNZBInfo()->GetName(), 1023);
+		pFileInfo->GetNZBInfo()->GetNiceNZBName(szNZBNiceName, 1023);
 		int len = strlen(szNZBNiceName);
 		szNZBNiceName[len] = PATH_SEPARATOR;
 		szNZBNiceName[len + 1] = '\0';
@@ -853,17 +824,36 @@ void NCursesFrontend::PrintFilename(FileInfo * pFileInfo, int iRow, bool bSelect
 		szNZBNiceName[0] = '\0';
 	}
 
-	char szSize[20];
 	char szBuffer[MAX_SCREEN_WIDTH];
-	snprintf(szBuffer, MAX_SCREEN_WIDTH, "%s%i%s%s%s %s%s (%s%s)%s", Brace1, pFileInfo->GetID(),
-		Brace2, szPriority, szDownloading, szNZBNiceName, pFileInfo->GetFilename(),
-		Util::FormatSize(szSize, sizeof(szSize), pFileInfo->GetSize()),
+	snprintf(szBuffer, MAX_SCREEN_WIDTH, "%s%i%s %s%s (%.2f MB%s)%s", Brace1, pFileInfo->GetID(),
+		Brace2, szNZBNiceName, pFileInfo->GetFilename(), (float)(Util::Int64ToFloat(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)(Util::Int64ToFloat(lFileSize) / 1024 / 1024 / 1024));
+	}
+	else if (lFileSize > 1024 * 1024)
+	{
+		snprintf(szBuffer, iBufLen, "%.2f MB", (float)(Util::Int64ToFloat(lFileSize) / 1024 / 1024));
+	}
+	else if (lFileSize > 1024)
+	{
+		snprintf(szBuffer, iBufLen, "%.2f KB", (float)(Util::Int64ToFloat(lFileSize) / 1024));
+	}
+	else 
+	{
+		snprintf(szBuffer, iBufLen, "%i", (int)lFileSize);
+	}
+	szBuffer[iBufLen - 1] = '\0';
+}
+
 void NCursesFrontend::PrintTopHeader(char* szHeader, int iLineNr, bool bUpTime)
 {
     char szBuffer[MAX_SCREEN_WIDTH];
@@ -928,8 +918,8 @@ void NCursesFrontend::PrintGroupQueue()
 {
 	int iLineNr = m_iQueueWinTop;
 
-    DownloadQueue* pDownloadQueue = LockQueue();
-	if (pDownloadQueue->GetQueue()->empty())
+	GroupQueue* pGroupQueue = &m_groupQueue;
+	if (pGroupQueue->empty())
     {
 		char szBuffer[MAX_SCREEN_WIDTH];
 		snprintf(szBuffer, sizeof(szBuffer), "%s NZBs for downloading", m_bUseColor ? "" : "*** ");
@@ -940,241 +930,153 @@ void NCursesFrontend::PrintGroupQueue()
     else
     {
 		iLineNr++;
-
-		ResetColWidths();
-		int iCalcLineNr = iLineNr;
-		int i = 0;
-        for (NZBList::iterator it = pDownloadQueue->GetQueue()->begin(); it != pDownloadQueue->GetQueue()->end(); it++, i++)
-        {
-            NZBInfo* pNZBInfo = *it;
-			if (i >= m_iQueueScrollOffset && i < m_iQueueScrollOffset + m_iQueueWinHeight -1)
-			{
-				PrintGroupname(pNZBInfo, iCalcLineNr++, false, true);
-			}
-        }
-
 		long long lRemaining = 0;
 		long long lPaused = 0;
-		i = 0;
-        for (NZBList::iterator it = pDownloadQueue->GetQueue()->begin(); it != pDownloadQueue->GetQueue()->end(); it++, i++)
+		int i = 0;
+        for (GroupQueue::iterator it = pGroupQueue->begin(); it != pGroupQueue->end(); it++, i++)
         {
-            NZBInfo* pNZBInfo = *it;
+            GroupInfo* pGroupInfo = *it;
+
 			if (i >= m_iQueueScrollOffset && i < m_iQueueScrollOffset + m_iQueueWinHeight -1)
 			{
-				PrintGroupname(pNZBInfo, iLineNr++, i == m_iSelectedQueueEntry, false);
+				PrintGroupname(pGroupInfo, iLineNr++, i == m_iSelectedQueueEntry);
 			}
-			lRemaining += pNZBInfo->GetRemainingSize();
-			lPaused += pNZBInfo->GetPausedSize();
+
+			lRemaining += pGroupInfo->GetRemainingSize();
+			lPaused += pGroupInfo->GetPausedSize();
         }
 		
 		char szRemaining[20];
-		Util::FormatSize(szRemaining, sizeof(szRemaining), lRemaining);
+		FormatFileSize(szRemaining, sizeof(szRemaining), lRemaining);
 
 		char szUnpaused[20];
-		Util::FormatSize(szUnpaused, sizeof(szUnpaused), lRemaining - lPaused);
+		FormatFileSize(szUnpaused, sizeof(szUnpaused), lRemaining - lPaused);
 		
 		char szBuffer[MAX_SCREEN_WIDTH];
 		snprintf(szBuffer, sizeof(szBuffer), " %sNZBs for downloading - %i NZBs in queue - %s / %s", 
-			m_bUseColor ? "" : "*** ", (int)pDownloadQueue->GetQueue()->size(), szRemaining, szUnpaused);
+			m_bUseColor ? "" : "*** ", pGroupQueue->size(), szRemaining, szUnpaused);
 		szBuffer[MAX_SCREEN_WIDTH - 1] = '\0';
 		PrintTopHeader(szBuffer, m_iQueueWinTop, false);
     }
-    UnlockQueue();
 }
 
-void NCursesFrontend::ResetColWidths()
+void NCursesFrontend::PrintGroupname(GroupInfo * pGroupInfo, int iRow, bool bSelected)
 {
-	m_iColWidthFiles = 0;
-	m_iColWidthTotal = 0;
-	m_iColWidthLeft = 0;
-}
-
-void NCursesFrontend::PrintGroupname(NZBInfo* pNZBInfo, int iRow, bool bSelected, bool bCalcColWidth)
-{
-	int color = NCURSES_COLORPAIR_TEXT;
-	char chBrace1 = '[';
-	char chBrace2 = ']';
+	int color = 0;
+	const char* Brace1 = "[";
+	const char* Brace2 = "]";
 	if (m_eInputMode == eEditQueue && bSelected)
 	{
 		color = NCURSES_COLORPAIR_TEXTHIGHL;
 		if (!m_bUseColor)
 		{
-			chBrace1 = '<';
-			chBrace2 = '>';
+			Brace1 = "<";
+			Brace2 = ">";
 		}
 	}
-
-	const char* szDownloading = "";
-	if (pNZBInfo->GetActiveDownloads() > 0)
+	else
 	{
-		szDownloading = " *";
+		color = NCURSES_COLORPAIR_TEXT;
 	}
 
-	long long lUnpausedRemainingSize = pNZBInfo->GetRemainingSize() - pNZBInfo->GetPausedSize();
+	long long lUnpausedRemainingSize = pGroupInfo->GetRemainingSize() - pGroupInfo->GetPausedSize();
 
 	char szRemaining[20];
-	Util::FormatSize(szRemaining, sizeof(szRemaining), lUnpausedRemainingSize);
+	FormatFileSize(szRemaining, sizeof(szRemaining), lUnpausedRemainingSize);
 
-	char szPriority[100];
-	szPriority[0] = '\0';
-	if (pNZBInfo->GetPriority() != 0)
+	char szPaused[20];
+	szPaused[0] = '\0';
+	if (pGroupInfo->GetPausedSize() > 0)
 	{
-		sprintf(szPriority, " [%+i]", pNZBInfo->GetPriority());
+		char szPausedSize[20];
+		FormatFileSize(szPausedSize, sizeof(szPausedSize), pGroupInfo->GetPausedSize());
+		sprintf(szPaused, " + %s paused", szPausedSize);
 	}
 
+	char szNZBNiceName[1024];
+	pGroupInfo->GetNZBInfo()->GetNiceNZBName(szNZBNiceName, 1023);
+
 	char szBuffer[MAX_SCREEN_WIDTH];
-
-	// Format:
-	// [id - id] Name   Left-Files/Paused     Total      Left     Time
-	// [1-2] Nzb-name             999/999 999.99 MB 999.99 MB 00:00:00
-
-	int iNameLen = 0;
-	if (bCalcColWidth)
-	{
-		iNameLen = m_iScreenWidth - 1 - 9 - 11 - 11 - 9;
-	}
-	else
-	{
-		iNameLen = m_iScreenWidth - 1 - m_iColWidthFiles - 2 - m_iColWidthTotal - 2 - m_iColWidthLeft - 2 - 9;
-	}
-
-	bool bPrintFormatted = iNameLen > 20;
-
-	if (bPrintFormatted)
-	{
-		char szFiles[20];
-		snprintf(szFiles, 20, "%i/%i", (int)pNZBInfo->GetFileList()->size(), pNZBInfo->GetPausedFileCount());
-		szFiles[20-1] = '\0';
-		
-		char szTotal[20];
-		Util::FormatSize(szTotal, sizeof(szTotal), pNZBInfo->GetSize());
-
-		char szNameWithIds[1024];
-		snprintf(szNameWithIds, 1024, "%c%i%c%s%s %s", chBrace1, pNZBInfo->GetID(), chBrace2, 
-			szPriority, szDownloading, pNZBInfo->GetName());
-		szNameWithIds[iNameLen] = '\0';
-
-		char szTime[100];
-		szTime[0] = '\0';
-		int iCurrentDownloadSpeed = m_bStandBy ? 0 : m_iCurrentDownloadSpeed;
-		if (pNZBInfo->GetPausedSize() > 0 && lUnpausedRemainingSize == 0)
-		{
-			snprintf(szTime, 100, "[paused]");
-			Util::FormatSize(szRemaining, sizeof(szRemaining), pNZBInfo->GetRemainingSize());
-		}
-		else if (iCurrentDownloadSpeed > 0 && !m_bPauseDownload)
-		{
-			long long remain_sec = (long long)(lUnpausedRemainingSize / iCurrentDownloadSpeed);
-			int h = (int)(remain_sec / 3600);
-			int m = (int)((remain_sec % 3600) / 60);
-			int s = (int)(remain_sec % 60);
-			if (h < 100)
-			{
-				snprintf(szTime, 100, "%.2d:%.2d:%.2d", h, m, s);
-			}
-			else
-			{
-				snprintf(szTime, 100, "99:99:99");
-			}
-		}
-
-		if (bCalcColWidth)
-		{
-			int iColWidthFiles = strlen(szFiles);
-			m_iColWidthFiles = iColWidthFiles > m_iColWidthFiles ? iColWidthFiles : m_iColWidthFiles;
-
-			int iColWidthTotal = strlen(szTotal);
-			m_iColWidthTotal = iColWidthTotal > m_iColWidthTotal ? iColWidthTotal : m_iColWidthTotal;
-
-			int iColWidthLeft = strlen(szRemaining);
-			m_iColWidthLeft = iColWidthLeft > m_iColWidthLeft ? iColWidthLeft : m_iColWidthLeft;
-		}
-		else
-		{
-			snprintf(szBuffer, MAX_SCREEN_WIDTH, "%-*s  %*s  %*s  %*s  %8s", iNameLen, szNameWithIds, m_iColWidthFiles, szFiles, m_iColWidthTotal, szTotal, m_iColWidthLeft, szRemaining, szTime);
-		}
-	}
-	else
-	{
-		snprintf(szBuffer, MAX_SCREEN_WIDTH, "%c%i%c%s %s", chBrace1, pNZBInfo->GetID(), 
-			chBrace2, szDownloading, pNZBInfo->GetName());
-	}
-
+	snprintf(szBuffer, MAX_SCREEN_WIDTH, "%s%i-%i%s %s (%i file%s, %s%s)", Brace1, pGroupInfo->GetFirstID(), pGroupInfo->GetLastID(), Brace2, szNZBNiceName, 
+		pGroupInfo->GetRemainingFileCount(), pGroupInfo->GetRemainingFileCount() > 1 ? "s" : "", szRemaining, szPaused);
 	szBuffer[MAX_SCREEN_WIDTH - 1] = '\0';
 
-	if (!bCalcColWidth)
-	{
-		PlotLine(szBuffer, iRow, 0, color);
-	}
+	PlotLine(szBuffer, iRow, 0, color);
 }
 
-bool NCursesFrontend::EditQueue(DownloadQueue::EEditAction eAction, int iOffset)
+void NCursesFrontend::PrepareGroupQueue()
+{
+	m_groupQueue.clear();
+
+    DownloadQueue* pDownloadQueue = LockQueue();
+	GroupInfo::BuildGroups(pDownloadQueue, &m_groupQueue);
+	UnlockQueue();
+}
+
+void NCursesFrontend::ClearGroupQueue()
+{
+	for (GroupQueue::iterator it = m_groupQueue.begin(); it != m_groupQueue.end(); it++)
+	{
+		delete *it;
+	}
+	m_groupQueue.clear();
+}
+
+bool NCursesFrontend::EditQueue(QueueEditor::EEditAction eAction, int iOffset)
 {
 	int ID = 0;
 
 	if (m_bGroupFiles)
 	{
-		DownloadQueue* pDownloadQueue = LockQueue();
-		if (m_iSelectedQueueEntry >= 0 && m_iSelectedQueueEntry < (int)pDownloadQueue->GetQueue()->size())
+		if (m_iSelectedQueueEntry >= 0 && m_iSelectedQueueEntry < (int)m_groupQueue.size())
 		{
-			NZBInfo* pNZBInfo = pDownloadQueue->GetQueue()->at(m_iSelectedQueueEntry);
-			ID = pNZBInfo->GetID();
-			if (eAction == DownloadQueue::eaFilePause)
+			GroupInfo* pGroupInfo = m_groupQueue[m_iSelectedQueueEntry];
+			ID = pGroupInfo->GetLastID();
+			if (eAction == QueueEditor::eaFilePause)
 			{
-				if (pNZBInfo->GetRemainingSize() == pNZBInfo->GetPausedSize())
+				if (pGroupInfo->GetRemainingSize() == pGroupInfo->GetPausedSize())
 				{
-					eAction = DownloadQueue::eaFileResume;
+					eAction = QueueEditor::eaFileResume;
 				}
-				else if (pNZBInfo->GetPausedSize() == 0 && (pNZBInfo->GetRemainingParCount() > 0) &&
+				else if (pGroupInfo->GetPausedSize() == 0 && (pGroupInfo->GetRemainingParCount() > 0) &&
 					!(m_bLastPausePars && m_iLastEditEntry == m_iSelectedQueueEntry))
 				{
-					eAction = DownloadQueue::eaFilePauseExtraPars;
+					eAction = QueueEditor::eaFilePauseExtraPars;
 					m_bLastPausePars = true;
 				}
 				else
 				{
-					eAction = DownloadQueue::eaFilePause;
+					eAction = QueueEditor::eaFilePause;
 					m_bLastPausePars = false;
 				}
 			}
 		}
-		UnlockQueue();
 
 		// map file-edit-actions to group-edit-actions
-		 DownloadQueue::EEditAction FileToGroupMap[] = {
-			(DownloadQueue::EEditAction)0,
-			DownloadQueue::eaGroupMoveOffset, 
-			DownloadQueue::eaGroupMoveTop, 
-			DownloadQueue::eaGroupMoveBottom, 
-			DownloadQueue::eaGroupPause, 
-			DownloadQueue::eaGroupResume, 
-			DownloadQueue::eaGroupDelete,
-			DownloadQueue::eaGroupPauseAllPars,
-			DownloadQueue::eaGroupPauseExtraPars };
+		QueueEditor::EEditAction FileToGroupMap[] = {
+			(QueueEditor::EEditAction)0,
+			QueueEditor::eaGroupMoveOffset, 
+			QueueEditor::eaGroupMoveTop, 
+			QueueEditor::eaGroupMoveBottom, 
+			QueueEditor::eaGroupPause, 
+			QueueEditor::eaGroupResume, 
+			QueueEditor::eaGroupDelete,
+			QueueEditor::eaGroupPauseAllPars,
+			QueueEditor::eaGroupPauseExtraPars };
 		eAction = FileToGroupMap[eAction];
 	}
 	else
 	{
 		DownloadQueue* pDownloadQueue = LockQueue();
-
-		int iFileNum = 0;
-		for (NZBList::iterator it = pDownloadQueue->GetQueue()->begin(); it != pDownloadQueue->GetQueue()->end(); it++)
+		if (m_iSelectedQueueEntry >= 0 && m_iSelectedQueueEntry < (int)pDownloadQueue->size())
 		{
-			NZBInfo* pNZBInfo = *it;
-			for (FileList::iterator it2 = pNZBInfo->GetFileList()->begin(); it2 != pNZBInfo->GetFileList()->end(); it2++, iFileNum++)
+			FileInfo* pFileInfo = (*pDownloadQueue)[m_iSelectedQueueEntry];
+			ID = pFileInfo->GetID();
+			if (eAction == QueueEditor::eaFilePause)
 			{
-				if (m_iSelectedQueueEntry == iFileNum)
-				{
-					FileInfo* pFileInfo = *it2;
-					ID = pFileInfo->GetID();
-					if (eAction == DownloadQueue::eaFilePause)
-					{
-						eAction = !pFileInfo->GetPaused() ? DownloadQueue::eaFilePause : DownloadQueue::eaFileResume;
-					}
-				}
+				eAction = !pFileInfo->GetPaused() ? QueueEditor::eaFilePause : QueueEditor::eaFileResume;
 			}
 		}
-
 		UnlockQueue();
 	}
 
@@ -1258,17 +1160,17 @@ void NCursesFrontend::UpdateInput(int initialKey)
 				break;
 			case 'w':
 				// swicth window sizes
-				if (m_QueueWindowPercentage == 50)
+				if (m_QueueWindowPercentage == 0.5)
 				{
-					m_QueueWindowPercentage = 100;
+					m_QueueWindowPercentage = 1;
 				}
-				else if (m_QueueWindowPercentage == 100 && m_eInputMode != eEditQueue)
+				else if (m_QueueWindowPercentage == 1 && m_eInputMode != eEditQueue)
 				{
 					m_QueueWindowPercentage = 0;
 				}
 				else 
 				{
-					m_QueueWindowPercentage = 50;
+					m_QueueWindowPercentage = 0.5;
 				}
 				CalcWindowSizes();
 				SetCurrentQueueEntry(m_iSelectedQueueEntry);
@@ -1291,9 +1193,12 @@ void NCursesFrontend::UpdateInput(int initialKey)
 				// Key 'p' for pause
 				if (!IsRemoteMode())
 				{
-					info(m_bPauseDownload ? "Unpausing download" : "Pausing download");
+					info(m_bPause ? "Unpausing download" : "Pausing download");
 				}
-				ServerPauseUnpause(!m_bPauseDownload);
+				ServerPauseUnpause(!m_bPause);
+				break;
+			case '\'':
+				ServerDumpDebug();
 				break;
 			case 'e':
 			case 10: // return
@@ -1303,7 +1208,7 @@ void NCursesFrontend::UpdateInput(int initialKey)
 					m_eInputMode = eEditQueue;
 					if (m_QueueWindowPercentage == 0)
 					{
-						m_QueueWindowPercentage = 50;
+						m_QueueWindowPercentage = 0.5;
 					}
 					return;
 				}
@@ -1379,38 +1284,38 @@ void NCursesFrontend::UpdateInput(int initialKey)
 				break;
 			case 'p':
 				// Key 'p' for pause
-				EditQueue(DownloadQueue::eaFilePause, 0);
+				EditQueue(QueueEditor::eaFilePause, 0);
 				break;
 			case 'd':
 				SetHint(" Use Uppercase \"D\" for delete");
 				break;
 			case 'D':
 				// Delete entry
-				if (EditQueue(DownloadQueue::eaFileDelete, 0))
+				if (EditQueue(QueueEditor::eaFileDelete, 0))
 				{
 					SetCurrentQueueEntry(m_iSelectedQueueEntry);
 				}
 				break;
 			case 'u':
-				if (EditQueue(DownloadQueue::eaFileMoveOffset, -1))
+				if (EditQueue(QueueEditor::eaFileMoveOffset, -1))
 				{
 					SetCurrentQueueEntry(m_iSelectedQueueEntry - 1);
 				}
 				break;
 			case 'n':
-				if (EditQueue(DownloadQueue::eaFileMoveOffset, +1))
+				if (EditQueue(QueueEditor::eaFileMoveOffset, +1))
 				{
 					SetCurrentQueueEntry(m_iSelectedQueueEntry + 1);
 				}
 				break;
 			case 't':
-				if (EditQueue(DownloadQueue::eaFileMoveTop, 0))
+				if (EditQueue(QueueEditor::eaFileMoveTop, 0))
 				{
 					SetCurrentQueueEntry(0);
 				}
 				break;
 			case 'b':
-				if (EditQueue(DownloadQueue::eaFileMoveBottom, 0))
+				if (EditQueue(QueueEditor::eaFileMoveBottom, 0))
 				{
 					SetCurrentQueueEntry(iQueueSize > 0 ? iQueueSize - 1 : 0);
 				}
@@ -1430,7 +1335,7 @@ void NCursesFrontend::UpdateInput(int initialKey)
 			// Enter
 			else if (iKey == 10 || iKey == 13)
 			{
-				ServerSetDownloadRate(m_iInputValue * 1024);
+				ServerSetDownloadRate((float)m_iInputValue);
 				m_eInputMode = eNormal;
 				return;
 			}

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"
@@ -62,11 +61,9 @@ private:
 	int					m_iLastEditEntry;
 	bool				m_bLastPausePars;
 	int					m_iQueueScrollOffset;
+	GroupQueue			m_groupQueue;
 	char*				m_szHint;
 	time_t				m_tStartHint;
-	int					m_iColWidthFiles;
-	int					m_iColWidthTotal;
-	int					m_iColWidthLeft;
 
 	// Inputting numbers
 	int					m_iInputNumberIndex;
@@ -85,7 +82,7 @@ private:
 	bool				m_bShowNZBname;
 	bool				m_bShowTimestamp;
 	bool				m_bGroupFiles;
-	int					m_QueueWindowPercentage;
+	float				m_QueueWindowPercentage;
 
 #ifdef WIN32
 	void			init_pair(int iColorNumber, WORD wForeColor, WORD wBackColor);
@@ -97,9 +94,10 @@ private:
 	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			PrintGroupname(GroupInfo * pGroupInfo, int iRow, bool bSelected);
+	void			PrepareGroupQueue();
 	void			PrintTopHeader(char* szHeader, int iLineNr, bool bUpTime);
+	void			ClearGroupQueue();
 	int				PrintMessage(Message* Msg, int iRow, int iMaxLines);
 	void			PrintKeyInputBar();
 	void 			PrintStatus();
@@ -107,11 +105,12 @@ private:
 	void			Update(int iKey);
 	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);
+	bool			EditQueue(QueueEditor::EEditAction eAction, int iOffset);
 	void			SetHint(const char* szHint);
 
 protected:

NNTPConnection.cpp

@@ -2,7 +2,7 @@
  *  This file is part of nzbget
  *
  *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
- *  Copyright (C) 2007-2015 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *  Copyright (C) 2007-2008 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
@@ -34,8 +34,7 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <stdio.h>
-#include <ctype.h>
+#include <cstdio>
 
 #include "nzbget.h"
 #include "Log.h"
@@ -45,18 +44,20 @@
 
 static const int CONNECTION_LINEBUFFER_SIZE = 1024*10;
 
-NNTPConnection::NNTPConnection(NewsServer* pNewsServer) : Connection(pNewsServer->GetHost(), pNewsServer->GetPort(), pNewsServer->GetTLS())
+NNTPConnection::NNTPConnection(NewsServer* server) : Connection(server)
 {
-	m_pNewsServer = pNewsServer;
 	m_szActiveGroup = NULL;
 	m_szLineBuf = (char*)malloc(CONNECTION_LINEBUFFER_SIZE);
 	m_bAuthError = false;
-	SetCipher(pNewsServer->GetCipher());
 }
 
 NNTPConnection::~NNTPConnection()
 {
-	free(m_szActiveGroup);
+	if (m_szActiveGroup)
+	{
+		free(m_szActiveGroup);
+		m_szActiveGroup = NULL;
+	}
 	free(m_szLineBuf);
 }
 
@@ -80,16 +81,19 @@ const char* NNTPConnection::Request(const char* req)
 
 	if (!strncmp(answer, "480", 3))
 	{
-		debug("%s requested authorization", GetHost());
+		debug("%s requested authorization", m_pNetAddress->GetHost());
 
+		//authentication required!
 		if (!Authenticate())
 		{
+			m_bAuthError = true;
 			return NULL;
 		}
 
 		//try again
 		WriteLine(req);
 		answer = ReadLine(m_szLineBuf, CONNECTION_LINEBUFFER_SIZE, NULL);
+		return answer;
 	}
 
 	return answer;
@@ -97,16 +101,13 @@ const char* NNTPConnection::Request(const char* req)
 
 bool NNTPConnection::Authenticate()
 {
-	if (strlen(m_pNewsServer->GetUser()) == 0 || strlen(m_pNewsServer->GetPassword()) == 0)
+	if (!((NewsServer*)m_pNetAddress)->GetUser() ||
+		!((NewsServer*)m_pNetAddress)->GetPassword())
 	{
-		ReportError("Could not connect to %s: server requested authorization but username/password are not set in settings",
-			m_pNewsServer->GetHost(), false, 0);
-		m_bAuthError = true;
-		return false;
+		return true;
 	}
 
-	m_bAuthError = !AuthInfoUser(0);
-	return !m_bAuthError;
+	return AuthInfoUser();
 }
 
 bool NNTPConnection::AuthInfoUser(int iRecur)
@@ -117,7 +118,7 @@ bool NNTPConnection::AuthInfoUser(int iRecur)
 	}
 
 	char tmp[1024];
-	snprintf(tmp, 1024, "AUTHINFO USER %s\r\n", m_pNewsServer->GetUser());
+	snprintf(tmp, 1024, "AUTHINFO USER %s\r\n", ((NewsServer*)m_pNetAddress)->GetUser());
 	tmp[1024-1] = '\0';
 
 	WriteLine(tmp);
@@ -125,13 +126,13 @@ bool NNTPConnection::AuthInfoUser(int iRecur)
 	char* answer = ReadLine(m_szLineBuf, CONNECTION_LINEBUFFER_SIZE, NULL);
 	if (!answer)
 	{
-		ReportErrorAnswer("Authorization for %s (%s) failed: Connection closed by remote host", NULL);
+		ReportError("Authorization for %s failed: Connection closed by remote host.", m_pNetAddress->GetHost(), true, 0);
 		return false;
 	}
 
 	if (!strncmp(answer, "281", 3))
 	{
-		debug("Authorization for %s successful", GetHost());
+		debug("Authorization for %s successful", m_pNetAddress->GetHost());
 		return true;
 	}
 	else if (!strncmp(answer, "381", 3))
@@ -147,7 +148,7 @@ bool NNTPConnection::AuthInfoUser(int iRecur)
 
 	if (GetStatus() != csCancelled)
 	{
-		ReportErrorAnswer("Authorization for %s (%s) failed: %s", answer);
+		ReportErrorAnswer("Authorization for %s failed (Answer: %s)", answer);
 	}
 	return false;
 }
@@ -160,7 +161,7 @@ bool NNTPConnection::AuthInfoPass(int iRecur)
 	}
 
 	char tmp[1024];
-	snprintf(tmp, 1024, "AUTHINFO PASS %s\r\n", m_pNewsServer->GetPassword());
+	snprintf(tmp, 1024, "AUTHINFO PASS %s\r\n", ((NewsServer*)m_pNetAddress)->GetPassword());
 	tmp[1024-1] = '\0';
 
 	WriteLine(tmp);
@@ -168,12 +169,12 @@ bool NNTPConnection::AuthInfoPass(int iRecur)
 	char* answer = ReadLine(m_szLineBuf, CONNECTION_LINEBUFFER_SIZE, NULL);
 	if (!answer)
 	{
-		ReportErrorAnswer("Authorization failed for %s (%s): Connection closed by remote host", NULL);
+		ReportError("Authorization for %s failed: Connection closed by remote host.", m_pNetAddress->GetHost(), true, 0);
 		return false;
 	}
 	else if (!strncmp(answer, "2", 1))
 	{
-		debug("Authorization for %s successful", GetHost());
+		debug("Authorization for %s successful", m_pNetAddress->GetHost());
 		return true;
 	}
 	else if (!strncmp(answer, "381", 3))
@@ -185,7 +186,7 @@ bool NNTPConnection::AuthInfoPass(int iRecur)
 
 	if (GetStatus() != csCancelled)
 	{
-		ReportErrorAnswer("Authorization for %s (%s) failed: %s", answer);
+		ReportErrorAnswer("Authorization for %s failed (Answer: %s)", answer);
 	}
 	return false;
 }
@@ -204,80 +205,86 @@ const char* NNTPConnection::JoinGroup(const char* grp)
 	tmp[1024-1] = '\0';
 
 	const char* answer = Request(tmp);
+	if (m_bAuthError)
+	{
+		return answer;
+	}
 
 	if (answer && !strncmp(answer, "2", 1))
 	{
-		debug("Changed group to %s on %s", grp, GetHost());
-		free(m_szActiveGroup);
+		debug("Changed group to %s on %s", grp, GetServer()->GetHost());
+
+		if (m_szActiveGroup)
+		{
+			free(m_szActiveGroup);
+		}
 		m_szActiveGroup = strdup(grp);
 	}
 	else
 	{
-		debug("Error changing group on %s to %s: %s.", GetHost(), grp, answer);
+		debug("Error changing group on %s to %s: %s.",
+			 GetServer()->GetHost(), grp, answer);
 	}
 
 	return answer;
 }
 
-bool NNTPConnection::Connect()
+bool NNTPConnection::DoConnect()
 {
-	debug("Opening connection to %s", GetHost());
-
-	if (m_eStatus == csConnected)
+	debug("Opening connection to %s", GetServer()->GetHost());
+	bool res = Connection::DoConnect();
+	if (!res)
 	{
-		return true;
+		return res;
 	}
 
-	if (!Connection::Connect())
+#ifndef DISABLE_TLS
+	if (GetNewsServer()->GetTLS())
 	{
-		return false;
+		if (!StartTLS())
+		{
+			return false;
+		}
 	}
+#endif
 
-	char* answer = ReadLine(m_szLineBuf, CONNECTION_LINEBUFFER_SIZE, NULL);
+	char* answer = DoReadLine(m_szLineBuf, CONNECTION_LINEBUFFER_SIZE, NULL);
 
 	if (!answer)
 	{
-		ReportErrorAnswer("Connection to %s (%s) failed: Connection closed by remote host", NULL);
-		Disconnect();
+		ReportError("Connection to %s failed: Connection closed by remote host.", m_pNetAddress->GetHost(), true, 0);
 		return false;
 	}
 
 	if (strncmp(answer, "2", 1))
 	{
-		ReportErrorAnswer("Connection to %s (%s) failed: %s", answer);
-		Disconnect();
+		ReportErrorAnswer("Connection to %s failed (Answer: %s)", answer);
 		return false;
 	}
 
-	if ((strlen(m_pNewsServer->GetUser()) > 0 && strlen(m_pNewsServer->GetPassword()) > 0) &&
-		!Authenticate())
-	{
-		return false;
-	}
-
-	debug("Connection to %s established", GetHost());
+	debug("Connection to %s established", GetServer()->GetHost());
 
 	return true;
 }
 
-bool NNTPConnection::Disconnect()
+bool NNTPConnection::DoDisconnect()
 {
 	if (m_eStatus == csConnected)
 	{
-		if (!m_bBroken)
+		Request("quit\r\n");
+		if (m_szActiveGroup)
 		{
-			Request("quit\r\n");
+			free(m_szActiveGroup);
+			m_szActiveGroup = NULL;
 		}
-		free(m_szActiveGroup);
-		m_szActiveGroup = NULL;
 	}
-	return Connection::Disconnect();
+	return Connection::DoDisconnect();
 }
 
 void NNTPConnection::ReportErrorAnswer(const char* szMsgPrefix, const char* szAnswer)
 {
 	char szErrStr[1024];
-	snprintf(szErrStr, 1024, szMsgPrefix, m_pNewsServer->GetName(), m_pNewsServer->GetHost(), szAnswer);
+	snprintf(szErrStr, 1024, szMsgPrefix, m_pNetAddress->GetHost(), szAnswer);
 	szErrStr[1024-1] = '\0';
 	
 	ReportError(szErrStr, NULL, false, 0);

NNTPConnection.h

@@ -2,7 +2,7 @@
  *  This file is part of nzbget
  *
  *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
- *  Copyright (C) 2007-2015 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *  Copyright (C) 2007-2008 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$
@@ -33,28 +33,27 @@
 class NNTPConnection : public Connection
 {
 private:
-	NewsServer*			m_pNewsServer;
-	char* 				m_szActiveGroup;
-	char*				m_szLineBuf;
-	bool				m_bAuthError;
+	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);
+	virtual bool 			DoConnect();
+	virtual bool 			DoDisconnect();
+	void					Clear();
+	void					ReportErrorAnswer(const char* szMsgPrefix, const char* szAnswer);
 
 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; }
-
+							NNTPConnection(NewsServer* server);
+	virtual					~NNTPConnection();
+	NewsServer*				GetNewsServer() { return(NewsServer*)m_pNetAddress; }
+	const char* 			Request(const char* req);
+	bool 					Authenticate();
+	bool 					AuthInfoUser(int iRecur = 0);
+	bool 					AuthInfoPass(int iRecur = 0);
+	const char*				JoinGroup(const char* grp);
+	bool					GetAuthError() { return m_bAuthError; }
 };
 
+
 #endif
 

NTService.cpp

@@ -1,7 +1,7 @@
 /*
  *  This file is part of nzbget
  *
- *  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
@@ -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$
@@ -30,7 +30,6 @@
 #include "win32.h"
 
 #include <string.h>
-#include <stdio.h>
 
 #include "nzbget.h"
 #include "Log.h"
@@ -201,24 +200,3 @@ void InstallUninstallServiceCheck(int argc, char *argv[])
 		exit(0);
 	}
 }
-
-bool IsServiceRunning()
-{
-	SC_HANDLE scm = OpenSCManager(0, 0, 0);
-	if (!scm)
-	{
-		return false;
-	}
-
-	SC_HANDLE hService = OpenService(scm, "NZBGet", SERVICE_QUERY_STATUS);
-	SERVICE_STATUS ServiceStatus;
-	bool bRunning = false;
-	if (hService && QueryServiceStatus(hService, &ServiceStatus))
-	{
-		bRunning = ServiceStatus.dwCurrentState != SERVICE_STOPPED;
-	}
-
-	CloseServiceHandle(scm);
-
-	return bRunning;
-}

NTService.h

@@ -1,7 +1,7 @@
 /*
  *  This file is part of nzbget
  *
- *  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
@@ -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$
@@ -30,6 +30,5 @@ typedef void (*RunProc)(void);
 
 void InstallUninstallServiceCheck(int argc, char *argv[]);
 void StartService(RunProc RunProcPtr);
-bool IsServiceRunning();
 
 #endif

NZBFile.cpp

@@ -0,0 +1,573 @@
+/*
+ *  This file is 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 <string.h>
+#include <list>
+#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"
+#include "Options.h"
+#include "DiskState.h"
+#include "Util.h"
+
+extern Options* g_pOptions;
+extern DiskState* g_pDiskState;
+
+NZBFile::NZBFile(const char* szFileName, const char* szCategory)
+{
+    debug("Creating NZBFile");
+
+    m_szFileName = strdup(szFileName);
+	m_pNZBInfo = new NZBInfo();
+	m_pNZBInfo->AddReference();
+	m_pNZBInfo->SetFilename(szFileName);
+	m_pNZBInfo->SetCategory(szCategory);
+	m_pNZBInfo->BuildDestDirName();
+
+    m_FileInfos.clear();
+}
+
+NZBFile::~NZBFile()
+{
+    debug("Destroying NZBFile");
+
+    // Cleanup
+    if (m_szFileName)
+    {
+        free(m_szFileName);
+    }
+
+    for (FileInfos::iterator it = m_FileInfos.begin(); it != m_FileInfos.end(); it++)
+    {
+        delete *it;
+    }
+    m_FileInfos.clear();
+
+	if (m_pNZBInfo)
+	{
+		m_pNZBInfo->Release();
+	}
+}
+
+void NZBFile::LogDebugInfo()
+{
+    debug(" NZBFile %s", m_szFileName);
+}
+
+void NZBFile::DetachFileInfos()
+{
+    m_FileInfos.clear();
+}
+
+NZBFile* NZBFile::CreateFromBuffer(const char* szFileName, const char* szCategory, const char* szBuffer, int iSize)
+{
+	return Create(szFileName, szCategory, szBuffer, iSize, true);
+}
+
+NZBFile* NZBFile::CreateFromFile(const char* szFileName, const char* szCategory)
+{
+	return Create(szFileName, szCategory, NULL, 0, false);
+}
+
+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::AddFileInfo(FileInfo* pFileInfo)
+{
+	// deleting empty articles
+	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++;
+		}
+	}
+
+	if (!pArticles->empty())
+	{
+		ParseSubject(pFileInfo);
+		m_FileInfos.push_back(pFileInfo);
+		pFileInfo->SetNZBInfo(m_pNZBInfo);
+		m_pNZBInfo->SetSize(m_pNZBInfo->GetSize() + pFileInfo->GetSize());
+		m_pNZBInfo->SetFileCount(m_pNZBInfo->GetFileCount() + 1);
+
+		if (g_pOptions->GetSaveQueue() && g_pOptions->GetServerMode())
+		{
+			g_pDiskState->SaveFile(pFileInfo);
+			pFileInfo->ClearArticles();
+		}
+	}
+	else
+	{
+		delete pFileInfo; 
+	}
+}
+
+void NZBFile::ParseSubject(FileInfo* pFileInfo)
+{
+	// tokenize subject, considering spaces as separators and quotation 
+	// marks as non separatable token delimiters.
+	// then take the last token containing dot (".") as a filename
+
+	typedef std::list<char*> TokenList;
+	TokenList tokens;
+	tokens.clear();
+
+	// tokenizing
+	char* p = (char*)pFileInfo->GetSubject();
+	char* start = p;
+	bool quot = false;
+	while (true)
+	{
+		char ch = *p;
+		bool sep = (ch == '\"') || (!quot && ch == ' ') || (ch == '\0');
+		if (sep)
+		{
+			// end of token
+			int len = (int)(p - start);
+			if (len > 0)
+			{
+				char* token = (char*)malloc(len + 1);
+				strncpy(token, start, len);
+				token[len] = '\0';
+				tokens.push_back(token);
+			}
+			start = p;
+			if (ch != '\"' || quot)
+			{
+				start++;
+			}
+			quot = *start == '\"';
+			if (quot)
+			{
+				start++;
+				char* q = strchr(start, '\"');
+				if (q)
+				{
+					p = q - 1;
+				}
+				else
+				{
+					quot = false;
+				}
+			}
+		}
+		if (ch == '\0')
+		{
+			break;
+		}
+		p++;
+	}
+
+	if (!tokens.empty())
+	{
+		// finding the best candidate for being a filename
+		char* besttoken = tokens.back();
+		for (TokenList::reverse_iterator it = tokens.rbegin(); it != tokens.rend(); it++)
+		{
+			char* s = *it;
+			char* p = strchr(s, '.');
+			if (p && (p[1] != '\0'))
+			{
+				besttoken = s;
+				break;
+			}
+		}
+		pFileInfo->SetFilename(besttoken);
+
+		// free mem
+		for (TokenList::iterator it = tokens.begin(); it != tokens.end(); it++)
+		{
+			free(*it);
+		}
+	}
+	else
+	{
+		// subject is empty or contains only separators?
+		debug("Could not extract Filename from Subject: %s. Using Subject as Filename", pFileInfo->GetSubject());
+		pFileInfo->SetFilename(pFileInfo->GetSubject());
+	}
+
+	pFileInfo->MakeValidFilename();
+}
+
+/**
+ * Check if the parsing of subject was correct
+ */
+void NZBFile::CheckFilenames()
+{
+    for (FileInfos::iterator it = m_FileInfos.begin(); it != m_FileInfos.end(); it++)
+    {
+        FileInfo* pFileInfo1 = *it;
+		int iDupe = 0;
+		for (FileInfos::iterator it2 = it + 1; it2 != m_FileInfos.end(); it2++)
+		{
+			FileInfo* pFileInfo2 = *it2;
+			if (!strcmp(pFileInfo1->GetFilename(), pFileInfo2->GetFilename()) &&
+				strcmp(pFileInfo1->GetSubject(), pFileInfo2->GetSubject()))
+			{
+				iDupe++;
+			}
+		}
+
+		// If more than two files have the same parsed filename but different subjects,
+		// this means, that the parsing was not correct.
+		// in this case we take subjects as filenames to prevent 
+		// false "duplicate files"-alarm.
+		// It's Ok for just two files to have the same filename, this is 
+		// an often case by posting-errors to repost bad files
+		if (iDupe > 2 || (iDupe == 2 && m_FileInfos.size() == 2))
+		{
+			for (FileInfos::iterator it2 = it; it2 != m_FileInfos.end(); it2++)
+			{
+				FileInfo* pFileInfo2 = *it2;
+				pFileInfo2->SetFilename(pFileInfo2->GetSubject());
+				pFileInfo2->MakeValidFilename();
+
+				if (g_pOptions->GetSaveQueue() && g_pOptions->GetServerMode())
+				{
+					g_pDiskState->LoadArticles(pFileInfo2);
+					g_pDiskState->SaveFile(pFileInfo2);
+					pFileInfo2->ClearArticles();
+				}
+			}
+		}
+    }
+}
+
+#ifdef WIN32
+NZBFile* NZBFile::Create(const char* szFileName, const char* szCategory, 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
+	{
+		// 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);
+		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, szCategory);
+    if (pFile->ParseNZB(doc))
+	{
+		pFile->CheckFilenames();
+	}
+	else
+	{
+		delete pFile;
+		pFile = NULL;
+	}
+
+    return pFile;
+}
+
+void NZBFile::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 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->SetSubject(subject);
+
+		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);
+            }
+		}
+
+		AddFileInfo(pFileInfo);
+	}
+	return true;
+}
+
+#else
+
+NZBFile* NZBFile::Create(const char* szFileName, const char* szCategory, 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, szCategory);
+    if (pFile->ParseNZB(doc))
+	{
+		pFile->CheckFilenames();
+	}
+	else
+	{
+		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->SetFilename(m_szFileName);
+
+                    while (xmlTextReaderMoveToNextAttribute(node))
+                    {
+						xmlFree(name);
+            			name = xmlTextReaderName(node);
+                        if (!strcmp("subject",(char*)name))
+                        {
+							xmlFree(value);
+							value = xmlTextReaderValue(node);
+                            pFileInfo->SetSubject((char*)value);
+                        }
+                    }
+                }
+                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))
+                {
+					AddFileInfo(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,68 @@
+/*
+ *  This file is 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;
+	NZBInfo*			m_pNZBInfo;
+	char*				m_szFileName;
+
+						NZBFile(const char* szFileName, const char* szCategory);
+	void				AddArticle(FileInfo* pFileInfo, ArticleInfo* pArticleInfo);
+	void				AddFileInfo(FileInfo* pFileInfo);
+	void				ParseSubject(FileInfo* pFileInfo);
+	void				CheckFilenames();
+#ifdef WIN32
+    bool 				ParseNZB(IUnknown* nzb);
+	static void			EncodeURL(const char* szFilename, char* szURL);
+#else
+    bool 				ParseNZB(void* nzb);
+#endif
+	static NZBFile*		Create(const char* szFileName, const char* szCategory, const char* szBuffer, int iSize, bool bFromBuffer);
+
+public:
+	virtual 			~NZBFile();
+	static NZBFile*		CreateFromBuffer(const char* szFileName, const char* szCategory, const char* szBuffer, int iSize);
+	static NZBFile*		CreateFromFile(const char* szFileName, const char* szCategory);
+	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) 2015 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,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$
@@ -23,27 +24,31 @@
  */
 
 
-#ifndef DISKSERVICE_H
-#define DISKSERVICE_H
-
-#include "Service.h"
-
-class DiskService : public Service
-{
-private:
-	int					m_iInterval;
-	bool				m_bWaitingRequiredDir;
-	bool				m_bWaitingReported;
-
-	void				CheckDiskSpace();
-	void				CheckRequiredDir();
-
-protected:
-	virtual int			ServiceInterval() { return 200; }
-	virtual void		ServiceWork();
-
-public:
-						DiskService();
-};
-
+#ifdef HAVE_CONFIG_H
+#include <config.h>
 #endif
+
+#ifdef WIN32
+#include "win32.h"
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "nzbget.h"
+#include "NetAddress.h"
+
+NetAddress::NetAddress(const char* szHost, int iPort)
+{
+	m_szHost = NULL;
+	m_iPort = iPort;
+	if (szHost)
+		m_szHost = strdup(szHost);
+}
+
+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-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
@@ -15,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$
@@ -23,13 +24,21 @@
  */
 
 
-#ifndef STACKTRACE_H
-#define STACKTRACE_H
+#ifndef NETADDRESS_H
+#define NETADDRESS_H
 
-void InstallErrorHandler();
+class NetAddress
+{
+private:
+	char*			m_szHost;
+	int				m_iPort;
+
+public:
+	NetAddress(const char* szHost, int iPort);
+	virtual 		~NetAddress();
+	const char*		GetHost() { return m_szHost; }
+	int				GetPort() { return m_iPort; }
+};
 
-#ifdef DEBUG
-void TestSegFault();
-#endif
 
 #endif

NewsServer.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-2008 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
@@ -34,49 +34,38 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <stdio.h>
 
 #include "nzbget.h"
 #include "NewsServer.h"
+#include "Log.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 iRetention, int iLevel, int iGroup)
+NewsServer::NewsServer(const char* szHost, int iPort, const char* szUser, const char* szPass, bool bJoinGroup, bool bTLS, int iMaxConnections, int iLevel) : NetAddress(szHost, iPort)
 {
-	m_iID = iID;
-	m_iStateID = 0;
-	m_bActive = bActive;
-	m_iPort = iPort;
+	m_szUser = NULL;
+	m_szPassword = NULL;
 	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 : "");
-	m_iRetention = iRetention;
-	m_tBlockTime = 0;
 
-	if (szName && strlen(szName) > 0)
+	if (szUser)
 	{
-		m_szName = strdup(szName);
+		m_szUser = strdup(szUser);
 	}
-	else
+	if (szPass)
 	{
-		m_szName = (char*)malloc(20);
-		snprintf(m_szName, 20, "server%i", iID);
-		m_szName[20-1] = '\0';
+		m_szPassword = strdup(szPass);
 	}
 }
 
 NewsServer::~NewsServer()
 {
-	free(m_szName);
-	free(m_szHost);
-	free(m_szUser);
-	free(m_szPassword);
-	free(m_szCipher);
+	if (m_szUser)
+	{
+		free(m_szUser);
+	}
+	if (m_szPassword)
+	{
+		free(m_szPassword);
+	}
 }

NewsServer.h

@@ -0,0 +1,53 @@
+/*
+ *  This file if part of nzbget
+ *
+ *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007-2008 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;
+	bool			m_bJoinGroup;
+	bool			m_bTLS;
+
+public:
+					NewsServer(const char* szHost, int iPort, const char* szUser, const char* szPass, bool bJoinGroup, bool bTLS, int iMaxConnections, int iLevel);
+	virtual			~NewsServer();
+	const char*		GetUser() { return m_szUser; }
+	const char*		GetPassword() { return m_szPassword; }
+	int				GetMaxConnections() { return m_iMaxConnections; }
+	int				GetLevel() { return m_iLevel; }
+	int				GetJoinGroup() { return m_bJoinGroup; }
+	bool			GetTLS() { return m_bTLS; }
+};
+
+#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,288 @@
+/*
+ *  This file is part of nzbget
+ *
+ *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007-2008 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,
+		opClientRequestVersion,
+		opClientRequestPostQueue,
+		opClientRequestWriteLog
+	};
+	enum EMessageTarget
+	{
+		mtNone,
+		mtScreen,
+		mtLog,
+		mtBoth
+	};
+	enum EOutputMode
+	{
+		omLoggable,
+		omColored,
+		omNCurses
+	};
+	enum ELoadPars
+	{
+		lpNone,
+		lpOne,
+		lpAll
+	};
+	enum EPostLogKind
+	{
+		plNone,
+		plDetail,
+		plInfo,
+		plWarning,
+		plError,
+		plDebug
+	};
+
+private:
+	struct OptEntry
+	{
+		char* name;
+		char* value;
+	};
+	
+	std::vector< struct OptEntry >	optEntries;
+
+	bool				m_bConfigInitialized;
+
+	// 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;
+	EMessageTarget		m_eDetailTarget;
+	bool				m_bDecode;
+	bool				m_bCreateBrokenLog;
+	bool				m_bResetLog;
+	int					m_iConnectionTimeout;
+	int					m_iTerminateTimeout;
+	bool				m_bAppendNZBDir;
+	bool				m_bAppendCategoryDir;
+	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;
+	char*				m_szDaemonUserName;
+	EOutputMode			m_eOutputMode;
+	bool				m_bReloadQueue;
+	bool				m_bReloadPostQueue;
+	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;
+	int					m_iUMask;
+	int					m_iUpdateInterval;
+	bool				m_bCursesNZBName;
+	bool				m_bCursesTime;
+	bool				m_bCursesGroup;
+	bool				m_bCrcCheck;
+	bool				m_bRetryOnCrcError;
+	int					m_iThreadLimit;
+	bool				m_bDirectWrite;
+	int					m_iWriteBufferSize;
+	int					m_iNzbDirInterval;
+	int					m_iNzbDirFileAge;
+	bool				m_bParCleanupQueue;
+	int					m_iDiskSpace;
+	EPostLogKind		m_ePostLogKind;
+	bool				m_bAllowReProcess;
+	bool				m_bTLS;
+	bool				m_bDumpCore;
+	bool				m_bParPauseQueue;
+	bool				m_bPostPauseQueue;
+	bool				m_bNzbCleanupDisk;
+
+	// 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;
+	char*				m_szEditQueueText;
+	char*				m_szArgFilename;
+	char*				m_szCategory;
+	char*				m_szLastArg;
+	bool				m_bPrintOptions;
+	bool				m_bAddTop;
+	float				m_fSetRate;
+	int					m_iLogLines;
+	int					m_iWriteLogKind;
+	bool				m_bTestBacktrace;
+
+	// Current state
+	bool				m_bPause;
+	float				m_fDownloadRate;
+	EClientOperation	m_eClientOperation;
+
+	void				InitDefault();
+	void				InitOptFile();
+	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, const char* OptValue, 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);
+	void				ParseFileIDList(int argc, char* argv[], int optind);
+
+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; }
+	EMessageTarget		GetDetailTarget() const { return m_eDetailTarget; }
+	int					GetConnectionTimeout() { return m_iConnectionTimeout; }
+	int					GetTerminateTimeout() { return m_iTerminateTimeout; }
+	bool				GetDecode() { return m_bDecode; };
+	bool				GetAppendNZBDir() { return m_bAppendNZBDir; }
+	bool				GetAppendCategoryDir() { return m_bAppendCategoryDir; }
+	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; }
+	char*				GetDaemonUserName() { return m_szDaemonUserName; }
+	EOutputMode			GetOutputMode() { return m_eOutputMode; }
+	bool				GetReloadQueue() { return m_bReloadQueue; }
+	bool				GetReloadPostQueue() { return m_bReloadPostQueue; }
+	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; }
+	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				GetRetryOnCrcError() { return m_bRetryOnCrcError; }
+	int					GetThreadLimit() { return m_iThreadLimit; }
+	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; }
+	EPostLogKind		GetPostLogKind() { return m_ePostLogKind; }
+	bool				GetAllowReProcess() { return m_bAllowReProcess; }
+	bool				GetTLS() { return m_bTLS; }
+	bool				GetDumpCore() { return m_bDumpCore; }
+	bool				GetParPauseQueue() { return m_bParPauseQueue; }
+	bool				GetPostPauseQueue() { return m_bPostPauseQueue; }
+	bool				GetNzbCleanupDisk() { return m_bNzbCleanupDisk; }
+
+	// 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; }
+	const char*			GetEditQueueText() { return m_szEditQueueText; }
+	const char*			GetArgFilename() { return m_szArgFilename; }
+	const char*			GetCategory() { return m_szCategory; }
+	const char*			GetLastArg() { return m_szLastArg; }
+	bool				GetAddTop() { return m_bAddTop; }
+	float				GetSetRate() { return m_fSetRate; }
+	int					GetLogLines() { return m_iLogLines; }
+	int					GetWriteLogKind() { return m_iWriteLogKind; }
+	bool				GetTestBacktrace() { return m_bTestBacktrace; }
+
+	// 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,544 @@
+/*
+ *  This file is 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>
+#include <fstream>
+#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 "Options.h"
+#include "Util.h"
+
+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_szProgressLabel = (char*)malloc(1024);
+	m_iFileProgress = 0;
+	m_iStageProgress = 0;
+	m_iExtraFiles = 0;
+	m_bVerifyingExtraFiles = false;
+	m_eStage = ptLoadingPars;
+	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);
+	}
+	free(m_szProgressLabel);
+
+	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()
+{
+	m_bRepairNotNeeded = false;
+	m_eStage = ptLoadingPars;
+	m_iProcessedFiles = 0;
+	m_iExtraFiles = 0;
+	m_bVerifyingExtraFiles = false;
+
+	info("Verifying %s", m_szInfoName);
+	SetStatus(psWorking);
+
+	snprintf(m_szProgressLabel, 1024, "Verifying %s", m_szInfoName);
+	m_szProgressLabel[1024-1] = '\0';
+	m_iFileProgress = 0;
+	m_iStageProgress = 0;
+	UpdateProgress();
+
+    debug("par: %s", m_szParFilename);
+    CommandLine commandLine;
+    const char* argv[] = { "par2", "r", "-v", "-v", 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* pRepairer = new Repairer();
+	m_pRepairer = pRepairer;
+
+	pRepairer->sig_filename.connect(sigc::mem_fun(*this, &ParChecker::signal_filename));
+	pRepairer->sig_progress.connect(sigc::mem_fun(*this, &ParChecker::signal_progress));
+	pRepairer->sig_done.connect(sigc::mem_fun(*this, &ParChecker::signal_done));
+	
+    res = pRepairer->PreProcess(commandLine);
+    debug("ParChecker: PreProcess-result=%i", res);
+
+	if (res != eSuccess || IsStopped())
+	{
+       	error("Could not verify %s: %s", m_szInfoName, IsStopped() ? "due stopping" : "par2-file could not be processed");
+		m_szErrMsg = strdup("par2-file could not be processed");
+		SetStatus(psFailed);
+		delete pRepairer;
+		return;
+	}
+
+	char BufReason[1024];
+	BufReason[0] = '\0';
+	if (m_szErrMsg)
+	{
+		free(m_szErrMsg);
+	}
+	m_szErrMsg = NULL;
+	
+	m_eStage = ptVerifyingSources;
+    res = pRepairer->Process(commandLine, false);
+    debug("ParChecker: Process-result=%i", res);
+
+	if (!IsStopped() && res == eRepairNotPossible && CheckSplittedFragments())
+	{
+		pRepairer->UpdateVerificationResults();
+		res = pRepairer->Process(commandLine, false);
+		debug("ParChecker: Process-result=%i", res);
+	}
+
+	bool bMoreFilesLoaded = true;
+	while (!IsStopped() && res == eRepairNotPossible)
+	{
+		int missingblockcount = pRepairer->missingblockcount - pRepairer->recoverypacketmap.size();
+		if (bMoreFilesLoaded)
+		{
+			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);
+			if (requested)
+			{
+				strncpy(m_szProgressLabel, "Awaiting additional par-files", 1024);
+				m_szProgressLabel[1024-1] = '\0';
+				m_iFileProgress = 0;
+				UpdateProgress();
+			}
+			
+			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;
+		}
+
+		bMoreFilesLoaded = LoadMorePars();
+		if (bMoreFilesLoaded)
+		{
+			pRepairer->UpdateVerificationResults();
+			res = pRepairer->Process(commandLine, false);
+			debug("ParChecker: Process-result=%i", res);
+		}
+	}
+
+	if (IsStopped())
+	{
+		SetStatus(psFailed);
+		delete pRepairer;
+		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);
+
+			snprintf(m_szProgressLabel, 1024, "Repairing %s", m_szInfoName);
+			m_szProgressLabel[1024-1] = '\0';
+			m_iFileProgress = 0;
+			m_iStageProgress = 0;
+			m_iProcessedFiles = 0;
+			m_eStage = ptRepairing;
+			m_iFilesToRepair = pRepairer->damagedfilecount + pRepairer->missingfilecount;
+			UpdateProgress();
+
+			res = pRepairer->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 pRepairer;
+}
+
+bool ParChecker::LoadMorePars()
+{
+	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*)m_pRepairer)->LoadPacketsFromFile(szParFilename);
+		if (loadedOK)
+		{
+			info("File %s successfully loaded for par-check", Util::BaseFileName(szParFilename), m_szInfoName);
+		}
+		else
+		{
+			info("Could not load file %s for par-check", Util::BaseFileName(szParFilename), m_szInfoName);
+		}
+		free(szParFilename);
+	}
+
+	return !moreFiles.empty();
+}
+
+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();
+}
+
+bool ParChecker::CheckSplittedFragments()
+{
+	bool bFragmentsAdded = false;
+
+	for (vector<Par2RepairerSourceFile*>::iterator it = ((Repairer*)m_pRepairer)->sourcefiles.begin();
+		it != ((Repairer*)m_pRepairer)->sourcefiles.end(); it++)
+	{
+		Par2RepairerSourceFile *sourcefile = *it;
+		if (!sourcefile->GetTargetExists() && AddSplittedFragments(sourcefile->TargetFileName().c_str()))
+		{
+			bFragmentsAdded = true;
+		}
+	}
+
+	return bFragmentsAdded;
+}
+
+bool ParChecker::AddSplittedFragments(const char* szFilename)
+{
+	char szDirectory[1024];
+	strncpy(szDirectory, szFilename, 1024);
+	szDirectory[1024-1] = '\0';
+
+	char* szBasename = Util::BaseFileName(szDirectory);
+	if (szBasename == szDirectory)
+	{
+		return false;
+	}
+	szBasename[-1] = '\0';
+	int iBaseLen = strlen(szBasename);
+
+	list<CommandLine::ExtraFile> extrafiles;
+
+	DirBrowser dir(szDirectory);
+	while (const char* filename = dir.Next())
+	{
+		if (!strncasecmp(filename, szBasename, iBaseLen))
+		{
+			const char* p = filename + iBaseLen;
+			if (*p == '.')
+			{
+				for (p++; *p && strchr("0123456789", *p); p++) ;
+				if (!*p)
+				{
+					debug("Found splitted fragment %s", filename);
+
+					char fullfilename[1024];
+					snprintf(fullfilename, 1024, "%s%c%s", szDirectory, PATH_SEPARATOR, filename);
+					fullfilename[1024-1] = '\0';
+
+					CommandLine::ExtraFile extrafile(fullfilename, Util::FileSize(fullfilename));
+					extrafiles.push_back(extrafile);
+				}
+			}
+		}
+	}
+
+	bool bFragmentsAdded = false;
+
+	if (!extrafiles.empty())
+	{
+		m_iExtraFiles = extrafiles.size();
+		m_bVerifyingExtraFiles = true;
+		bFragmentsAdded = ((Repairer*)m_pRepairer)->VerifyExtraFiles(extrafiles);
+		m_bVerifyingExtraFiles = false;
+	}
+
+	return bFragmentsAdded;
+}
+
+void ParChecker::signal_filename(std::string str)
+{
+    const char* szStageMessage[] = { "Loading file", "Verifying file", "Repairing file", "Verifying repaired file" };
+
+	if (m_eStage == ptRepairing)
+	{
+		m_eStage = ptVerifyingRepaired;
+	}
+
+	info("%s %s", szStageMessage[m_eStage], str.c_str());
+
+	snprintf(m_szProgressLabel, 1024, "%s %s", szStageMessage[m_eStage], str.c_str());
+	m_szProgressLabel[1024-1] = '\0';
+	m_iFileProgress = 0;
+	UpdateProgress();
+}
+
+void ParChecker::signal_progress(double progress)
+{
+	m_iFileProgress = (int)progress;
+
+	if (m_eStage == ptRepairing)
+	{
+		// calculating repair-data for all files
+		m_iStageProgress = m_iFileProgress;
+	}
+	else
+	{
+		// processing individual files
+
+		int iTotalFiles = 0;
+		if (m_eStage == ptVerifyingRepaired)
+		{
+			// repairing individual files
+			iTotalFiles = m_iFilesToRepair;
+		}
+		else
+		{
+			// verifying individual files
+			iTotalFiles = ((Repairer*)m_pRepairer)->sourcefiles.size() + m_iExtraFiles;
+		}
+
+		if (iTotalFiles > 0)
+		{
+			if (m_iFileProgress < 1000)
+			{
+				m_iStageProgress = (m_iProcessedFiles * 1000 + m_iFileProgress) / iTotalFiles;
+			}
+			else
+			{
+				m_iStageProgress = m_iProcessedFiles * 1000 / iTotalFiles;
+			}
+		}
+		else
+		{
+			m_iStageProgress = 0;
+		}
+	}
+
+	debug("Current-progres: %i, Total-progress: %i", m_iFileProgress, m_iStageProgress);
+
+	UpdateProgress();
+}
+
+void ParChecker::signal_done(std::string str, int available, int total)
+{
+	m_iProcessedFiles++;
+
+	if (m_eStage == ptVerifyingSources)
+	{
+		if (available < total && !m_bVerifyingExtraFiles)
+		{
+			bool bFileExists = true;
+
+			for (vector<Par2RepairerSourceFile*>::iterator it = ((Repairer*)m_pRepairer)->sourcefiles.begin();
+				it != ((Repairer*)m_pRepairer)->sourcefiles.end(); it++)
+			{
+				Par2RepairerSourceFile *sourcefile = *it;
+				if (sourcefile && !strcmp(str.c_str(), Util::BaseFileName(sourcefile->TargetFileName().c_str())) &&
+					!sourcefile->GetTargetExists())
+				{
+					bFileExists = false;
+					break;
+				}
+			}
+
+			if (bFileExists)
+			{
+				warn("File %s has %i bad block(s) of total %i block(s)", str.c_str(), total - available, total);
+			}
+			else
+			{
+				warn("File %s with %i block(s) is missing", str.c_str(), total);
+			}
+		}
+	}
+}
+
+#endif

ParChecker.h

@@ -0,0 +1,118 @@
+/*
+ *  This file is 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
+	};
+
+	enum EStage
+	{
+		ptLoadingPars,
+		ptVerifyingSources,
+		ptRepairing,
+		ptVerifyingRepaired,
+	};
+
+	typedef std::deque<char*>		QueuedParFiles;
+	
+private:
+	char*				m_szInfoName;
+	char*				m_szNZBFilename;
+	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;
+	bool				m_bRepairNotNeeded;
+	QueuedParFiles		m_QueuedParFiles;
+	Mutex			 	m_mutexQueuedParFiles;
+	Semaphore			m_semNeedMoreFiles;
+	int					m_iProcessedFiles;
+	int					m_iFilesToRepair;
+	int					m_iExtraFiles;
+	bool				m_bVerifyingExtraFiles;
+	char*				m_szProgressLabel;
+	int					m_iFileProgress;
+	int					m_iStageProgress;
+
+	bool				LoadMorePars();
+	bool				CheckSplittedFragments();
+	bool				AddSplittedFragments(const char* szFilename);
+	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() {}
+	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();
+	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();
+};
+
+#endif
+
+#endif

PostInfo.cpp

@@ -0,0 +1,174 @@
+/*
+ *  This file is 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 "nzbget.h"
+#include "PostInfo.h"
+#include "Options.h"
+
+extern Options* g_pOptions;
+
+int PostInfo::m_iIDGen = 0;
+
+PostInfo::PostInfo()
+{
+	debug("Creating PostInfo");
+
+	m_szNZBFilename = NULL;
+	m_szDestDir = NULL;
+	m_szParFilename = NULL;
+	m_szInfoName = NULL;
+	m_szCategory = NULL;
+	m_szQueuedFilename = NULL;
+	m_bWorking = false;
+	m_bParCheck = false;
+	m_iParStatus = 0;
+	m_bParFailed = false;
+	m_szProgressLabel = strdup("");
+	m_iFileProgress = 0;
+	m_iStageProgress = 0;
+	m_tStartTime = 0;
+	m_tStageTime = 0;
+	m_eStage = ptQueued;
+	m_pScriptThread = NULL;
+	m_Messages.clear();
+	m_iIDGen++;
+	m_iID = m_iIDGen;
+}
+
+PostInfo::~ PostInfo()
+{
+	debug("Destroying PostInfo");
+
+	if (m_szNZBFilename)
+	{
+		free(m_szNZBFilename);
+	}
+	if (m_szDestDir)
+	{
+		free(m_szDestDir);
+	}
+	if (m_szParFilename)
+	{
+		free(m_szParFilename);
+	}
+	if (m_szInfoName)
+	{
+		free(m_szInfoName);
+	}
+	if (m_szCategory)
+	{
+		free(m_szCategory);
+	}
+	if (m_szQueuedFilename)
+	{
+		free(m_szQueuedFilename);
+	}
+	if (m_szProgressLabel)
+	{
+		free(m_szProgressLabel);
+	}
+	for (Messages::iterator it = m_Messages.begin(); it != m_Messages.end(); it++)
+	{
+		delete *it;
+	}
+	m_Messages.clear();
+}
+
+void PostInfo::SetNZBFilename(const char* szNZBFilename)
+{
+	m_szNZBFilename = strdup(szNZBFilename);
+}
+
+void PostInfo::SetDestDir(const char* szDestDir)
+{
+	m_szDestDir = strdup(szDestDir);
+}
+
+void PostInfo::SetParFilename(const char* szParFilename)
+{
+	m_szParFilename = strdup(szParFilename);
+}
+
+void PostInfo::SetInfoName(const char* szInfoName)
+{
+	m_szInfoName = strdup(szInfoName);
+}
+
+void PostInfo::SetCategory(const char* szCategory)
+{
+	m_szCategory = strdup(szCategory);
+}
+
+void PostInfo::SetQueuedFilename(const char * szQueuedFilename)
+{
+	m_szQueuedFilename = strdup(szQueuedFilename);
+}
+
+void PostInfo::SetProgressLabel(const char* szProgressLabel)
+{
+	if (m_szProgressLabel)
+	{
+		free(m_szProgressLabel);
+	}
+	m_szProgressLabel = strdup(szProgressLabel);
+}
+
+PostInfo::Messages* PostInfo::LockMessages()
+{
+	m_mutexLog.Lock();
+	return &m_Messages;
+}
+
+void PostInfo::UnlockMessages()
+{
+	m_mutexLog.Unlock();
+}
+
+void PostInfo::AppendMessage(Message::EKind eKind, const char * szText)
+{
+	Message* pMessage = new Message(++m_iIDGen, eKind, time(NULL), szText);
+
+	m_mutexLog.Lock();
+	m_Messages.push_back(pMessage);
+
+	while (m_Messages.size() > (unsigned int)g_pOptions->GetLogBufferSize())
+	{
+		Message* pMessage = m_Messages.front();
+		delete pMessage;
+		m_Messages.pop_front();
+	}
+	m_mutexLog.Unlock();
+}

PostInfo.h

@@ -0,0 +1,119 @@
+/*
+ *  This file is 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 POSTINFO_H
+#define POSTINFO_H
+
+#include <deque>
+
+#include "Log.h"
+#include "Thread.h"
+
+class PostInfo
+{
+public:
+	enum EStage
+	{
+		ptQueued,
+		ptLoadingPars,
+		ptVerifyingSources,
+		ptRepairing,
+		ptVerifyingRepaired,
+		ptExecutingScript,
+		ptFinished
+	};
+
+	typedef std::deque<Message*>	Messages;
+
+private:
+	int				m_iID;
+	char*			m_szNZBFilename;
+	char*			m_szDestDir;
+	char*			m_szParFilename;
+	char*			m_szInfoName;
+	char*			m_szCategory;
+	char*			m_szQueuedFilename;
+	bool			m_bWorking;
+	bool			m_bParCheck;
+	int				m_iParStatus;
+	bool			m_bParFailed;
+	EStage			m_eStage;
+	char*			m_szProgressLabel;
+	int				m_iFileProgress;
+	int				m_iStageProgress;
+	time_t			m_tStartTime;
+	time_t			m_tStageTime;
+	Thread*			m_pScriptThread;
+	
+	Mutex			m_mutexLog;
+	Messages		m_Messages;
+	static int		m_iIDGen;
+
+public:
+					PostInfo();
+					~PostInfo();
+	int				GetID() { return m_iID; }
+	const char*		GetNZBFilename() { return m_szNZBFilename; }
+	void			SetNZBFilename(const char* szNZBFilename);
+	const char*		GetDestDir() { return m_szDestDir; }
+	void			SetDestDir(const char* szDestDir);
+	const char*		GetParFilename() { return m_szParFilename; }
+	void			SetParFilename(const char* szParFilename);
+	const char*		GetInfoName() { return m_szInfoName; }
+	void			SetInfoName(const char* szInfoName);
+	const char*		GetCategory() { return m_szCategory; }
+	void			SetCategory(const char* szCategory);
+	const char*		GetQueuedFilename() { return m_szQueuedFilename; }
+	void			SetQueuedFilename(const char* szQueuedFilename);
+	EStage			GetStage() { return m_eStage; }
+	void			SetStage(EStage eStage) { m_eStage = eStage; }
+	void			SetProgressLabel(const char* szProgressLabel);
+	const char*		GetProgressLabel() { return m_szProgressLabel; }
+	int				GetFileProgress() { return m_iFileProgress; }
+	void			SetFileProgress(int iFileProgress) { m_iFileProgress = iFileProgress; }
+	int				GetStageProgress() { return m_iStageProgress; }
+	void			SetStageProgress(int iStageProgress) { m_iStageProgress = iStageProgress; }
+	time_t			GetStartTime() { return m_tStartTime; }
+	void			SetStartTime(time_t tStartTime) { m_tStartTime = tStartTime; }
+	time_t			GetStageTime() { return m_tStageTime; }
+	void			SetStageTime(time_t tStageTime) { m_tStageTime = tStageTime; }
+	bool			GetWorking() { return m_bWorking; }
+	void			SetWorking(bool bWorking) { m_bWorking = bWorking; }
+	bool			GetParCheck() { return m_bParCheck; }
+	void			SetParCheck(bool bParCheck) { m_bParCheck = bParCheck; }
+	int				GetParStatus() { return m_iParStatus; }
+	void			SetParStatus(int iParStatus) { m_iParStatus = iParStatus; }
+	bool			GetParFailed() { return m_bParFailed; }
+	void			SetParFailed(bool bParFailed) { m_bParFailed = bParFailed; }
+	void			AppendMessage(Message::EKind eKind, const char* szText);
+	Thread*			GetScriptThread() { return m_pScriptThread; }
+	void			SetScriptThread(Thread* pScriptThread) { m_pScriptThread = pScriptThread; }
+	Messages*		LockMessages();
+	void			UnlockMessages();
+};
+
+typedef std::deque<PostInfo*> PostQueue;
+
+#endif

PrePostProcessor.h

@@ -0,0 +1,136 @@
+/*
+ *  This file is 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"
+#include "PostInfo.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 PostParChecker: public ParChecker
+	{
+	private:
+		PrePostProcessor* m_Owner;
+	protected:
+		virtual bool	RequestMorePars(int iBlockNeeded, int* pBlockFound);
+		virtual void	UpdateProgress();
+
+		friend class PrePostProcessor;
+	};
+
+	struct BlockInfo
+	{
+		FileInfo*		m_pFileInfo;
+		int				m_iBlockCount;
+	};
+
+	typedef std::deque<BlockInfo*> 	Blocks;
+#endif
+	
+private:
+	QueueCoordinatorObserver	m_QueueCoordinatorObserver;
+	bool				m_bHasMoreJobs;
+	bool				m_bPostScript;
+
+	void				PausePars(DownloadQueue* pDownloadQueue, const char* szNZBFilename);
+	void				CheckIncomingNZBs(const char* szDirectory, const char* szCategory);
+	bool				IsNZBFileCompleted(DownloadQueue* pDownloadQueue, const char* szNZBFilename, 
+							bool bIgnoreFirstInPostQueue, bool bIgnorePaused, bool bCheckPostQueue);
+	bool				CheckScript(FileInfo* pFileInfo);
+	bool				JobExists(PostQueue* pPostQueue, const char* szNZBFilename);
+	bool				ClearCompletedJobs(const char* szNZBFilename);
+	void				CheckPostQueue();
+	void				JobCompleted(DownloadQueue* pDownloadQueue, PostInfo* pPostInfo);
+	void				StartScriptJob(DownloadQueue* pDownloadQueue, PostInfo* pPostInfo);
+	void				SavePostQueue();
+	void				SanitisePostQueue();
+	void				CheckDiskSpace();
+	bool				PostProcessEnabled();
+	void				AddFileToQueue(const char* szFilename, const char* szCategory);
+
+	Mutex			 	m_mutexQueue;
+	PostQueue			m_PostQueue;
+	PostQueue			m_CompletedJobs;
+
+#ifndef DISABLE_PARCHECK
+	PostParChecker		m_ParChecker;
+	ParCheckerObserver	m_ParCheckerObserver;
+
+	void				ParCheckerUpdate(Subject* Caller, void* Aspect);
+	bool				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);
+	int					GetParCleanupQueueGroup(DownloadQueue* pDownloadQueue, const char* szNZBFilename);
+	bool				HasFailedParJobs(const char* szNZBFilename);
+	bool				ParJobExists(PostQueue* pPostQueue, const char* szParFilename);
+	bool				ParseParFilename(const char* szParFilename, int* iBaseNameLen, int* iBlocks);
+	bool				RequestMorePars(const char* szNZBFilename, const char* szParFilename, int iBlockNeeded, int* pBlockFound);
+	void				FindPars(DownloadQueue* pDownloadQueue, const char* szNZBFilename, const char* szParFilename, 
+							Blocks* pBlocks, bool bStrictParName, bool bExactParName, int* pBlockFound);
+	void				UpdateParProgress();
+	void				StartParJob(PostInfo* pPostInfo);
+#endif
+	
+public:
+						PrePostProcessor();
+	virtual				~PrePostProcessor();
+	virtual void		Run();
+	virtual void		Stop();
+	void				QueueCoordinatorUpdate(Subject* Caller, void* Aspect);
+	bool				HasMoreJobs() { return m_bHasMoreJobs; }
+	PostQueue*			LockPostQueue();
+	void				UnlockPostQueue();
+};
+
+#endif

QueueCoordinator.cpp

@@ -0,0 +1,852 @@
+/*
+ *  This file is 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>
+#include <cstdio>
+#include <sys/stat.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 "DiskState.h"
+#include "Log.h"
+#include "Util.h"
+#include "Decoder.h"
+
+extern Options* g_pOptions;
+extern ServerPool* g_pServerPool;
+extern DiskState* g_pDiskState;
+
+QueueCoordinator::QueueCoordinator()
+{
+	debug("Creating QueueCoordinator");
+
+	m_bHasMoreJobs = true;
+	m_DownloadQueue.clear();
+	m_ActiveDownloads.clear();
+	ResetSpeedStat();
+
+	m_iAllBytes = 0;
+	m_tStartServer = 0;
+	m_tStartDownload = 0;
+	m_tPausedFrom = 0;
+	m_bStandBy = true;
+
+	YDecoder::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();
+
+	YDecoder::Final();
+
+	debug("QueueCoordinator destroyed");
+}
+
+void QueueCoordinator::Run()
+{
+	debug("Entering QueueCoordinator-loop");
+
+	m_mutexDownloadQueue.Lock();
+
+	if (g_pOptions->GetServerMode() && g_pOptions->GetSaveQueue() && g_pDiskState->DownloadQueueExists())
+	{
+		if (g_pOptions->GetReloadQueue())
+		{
+			g_pDiskState->LoadDownloadQueue(&m_DownloadQueue);
+		}
+		else
+		{
+			g_pDiskState->DiscardDownloadQueue();
+		}
+	}
+
+	g_pDiskState->CleanupTempDir(&m_DownloadQueue);
+
+	m_mutexDownloadQueue.Unlock();
+
+	m_tStartServer = time(NULL);
+	m_tLastCheck = m_tStartServer;
+	bool bWasStandBy = true;
+	bool bArticeDownloadsRunning = false;
+	int iResetCounter = 0;
+
+	while (!IsStopped())
+	{
+		if (!g_pOptions->GetPause())
+		{
+			NNTPConnection* pConnection = g_pServerPool->GetConnection(0, false);
+			if (pConnection)
+			{
+				// start download for next article
+				FileInfo* pFileInfo;
+				ArticleInfo* pArticleInfo;
+
+				m_mutexDownloadQueue.Lock();
+				bool bHasMoreArticles = GetNextArticle(pFileInfo, pArticleInfo);
+				bArticeDownloadsRunning = !m_ActiveDownloads.empty();
+				m_bHasMoreJobs = bHasMoreArticles || bArticeDownloadsRunning;
+				if (bHasMoreArticles && !IsStopped() && Thread::GetThreadCount() < g_pOptions->GetThreadLimit())
+				{
+					StartArticleDownload(pFileInfo, pArticleInfo, pConnection);
+					bArticeDownloadsRunning = true;
+				}
+				else
+				{
+					g_pServerPool->FreeConnection(pConnection, false);
+				}
+				m_mutexDownloadQueue.Unlock();
+			}
+		}
+		else
+		{
+			m_mutexDownloadQueue.Lock();
+			bArticeDownloadsRunning = !m_ActiveDownloads.empty();
+			m_mutexDownloadQueue.Unlock();
+		}
+
+		bool bStandBy = !bArticeDownloadsRunning;
+		if (bStandBy ^ bWasStandBy)
+		{
+			EnterLeaveStandBy(bStandBy);
+			bWasStandBy = bStandBy;
+		}
+
+		// sleep longer in StandBy
+		int iSleepInterval = bStandBy ? 100 : 5;
+		usleep(iSleepInterval * 1000);
+
+		AddSpeedReading(0);
+
+		iResetCounter+= iSleepInterval;
+		if (iResetCounter >= 1000)
+		{
+			// this code should not be called too often, once per second is OK
+			g_pServerPool->CloseUnusedConnections();
+			ResetHangingDownloads();
+			iResetCounter = 0;
+			AdjustStartTime();
+		}
+	}
+
+	// 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;
+	tmpDownloadQueue.clear();
+	DownloadQueue DupeList;
+	DupeList.clear();
+
+	int index1 = 0;
+	for (NZBFile::FileInfos::iterator it = pNZBFile->GetFileInfos()->begin(); it != pNZBFile->GetFileInfos()->end(); it++)
+	{
+		index1++;
+		FileInfo* pFileInfo = *it;
+
+		if (g_pOptions->GetDupeCheck())
+		{
+			bool dupe = false;
+			if (IsDupe(pFileInfo))
+			{
+				warn("File \"%s\" seems to be duplicate, skipping", pFileInfo->GetFilename());
+				dupe = true;
+			}
+			int index2 = 0;
+			for (NZBFile::FileInfos::iterator it2 = pNZBFile->GetFileInfos()->begin(); it2 != pNZBFile->GetFileInfos()->end(); it2++)
+			{
+				index2++;
+				FileInfo* pFileInfo2 = *it2;
+				if (pFileInfo != pFileInfo2 &&
+					!strcmp(pFileInfo->GetFilename(), pFileInfo2->GetFilename()) &&
+					(pFileInfo->GetSize() < pFileInfo2->GetSize() || 
+					 (pFileInfo->GetSize() == pFileInfo2->GetSize() && index2 < index1)))
+				{
+					warn("File \"%s\" appears twice in nzb-request, adding only the biggest file", pFileInfo->GetFilename());
+					dupe = true;
+					break;
+				}
+			}
+			if (dupe)
+			{
+				DupeList.push_back(pFileInfo);
+				continue;
+			}
+		}
+
+		if (bAddFirst)
+		{
+			tmpDownloadQueue.push_front(pFileInfo);
+		}
+		else
+		{
+			tmpDownloadQueue.push_back(pFileInfo);
+		}
+	}
+
+	for (DownloadQueue::iterator it = tmpDownloadQueue.begin(); it != tmpDownloadQueue.end(); it++)
+	{
+		if (bAddFirst)
+		{
+			m_DownloadQueue.push_front(*it);
+		}
+		else
+		{
+			m_DownloadQueue.push_back(*it);
+		}
+	}
+
+	for (DownloadQueue::iterator it = DupeList.begin(); it != DupeList.end(); it++)
+	{
+		FileInfo* pFileInfo = *it;
+		if (g_pOptions->GetSaveQueue() && g_pOptions->GetServerMode())
+		{
+			g_pDiskState->DiscardFile(NULL, pFileInfo);
+		}
+		delete pFileInfo;
+	}
+
+	pNZBFile->DetachFileInfos();
+
+	Aspect aspect = { eaNZBFileAdded, NULL, &m_DownloadQueue, pNZBFile->GetFileName() };
+	Notify(&aspect);
+	
+	if (g_pOptions->GetSaveQueue() && g_pOptions->GetServerMode())
+	{
+		g_pDiskState->SaveDownloadQueue(&m_DownloadQueue);
+	}
+
+	m_mutexDownloadQueue.Unlock();
+}
+
+bool QueueCoordinator::AddFileToQueue(const char* szFileName, const char* szCategory)
+{
+	// Parse the buffer and make it into a NZBFile
+	NZBFile* pNZBFile = NZBFile::CreateFromFile(szFileName, szCategory);
+
+	// Did file parse correctly?
+	if (!pNZBFile)
+	{
+		return false;
+	}
+
+	// Add NZBFile to Queue
+	AddNZBFileToQueue(pNZBFile, false);
+
+	delete pNZBFile;
+
+	return true;
+}
+
+/*
+ * NOTE: see note to "AddSpeedReading"
+ */
+float QueueCoordinator::CalcCurrentDownloadSpeed()
+{
+	if (m_bStandBy)
+	{
+		return 0;
+	}
+
+    int iTimeDiff = (int)time(NULL) - m_iSpeedStartTime * SPEEDMETER_SLOTSIZE;
+    if (iTimeDiff == 0)
+    {
+    	return 0;
+    }
+	float fSpeed = m_iSpeedTotalBytes / 1024.0f / iTimeDiff;
+	return fSpeed;
+}
+
+/*
+ * NOTE: we should use mutex by access to m_iSpeedBytes and m_iSpeedBytesIndex,
+ * but this would results in a big performance loss (the function 
+ * "AddSpeedReading" is called extremly often), so we better agree with calculation 
+ * errors possible because of simultaneuos access from several threads.
+ * The used algorithm is able to recover after few seconds.
+ * In any case the calculation errors can not result in fatal system 
+ * errors (segmentation faults).
+ */
+void QueueCoordinator::AddSpeedReading(int iBytes)
+{
+    int iNowSlot = (int)time(NULL) / SPEEDMETER_SLOTSIZE;
+
+    if (iNowSlot > m_iSpeedTime[m_iSpeedBytesIndex])
+    {
+        //record bytes in next slot
+        m_iSpeedBytesIndex++;
+        if (m_iSpeedBytesIndex >= SPEEDMETER_SLOTS)
+        {
+            m_iSpeedBytesIndex = 0;
+        }
+        //Adjust counters with outging information.
+        m_iSpeedTotalBytes -= 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;
+    } 
+
+    if (m_iSpeedTotalBytes == 0)
+    {
+        m_iSpeedStartTime = iNowSlot;
+    }
+    m_iSpeedBytes[m_iSpeedBytesIndex] += iBytes;
+    m_iSpeedTotalBytes += iBytes;
+	m_iAllBytes += iBytes;
+}
+
+void QueueCoordinator::ResetSpeedStat()
+{
+    m_iSpeedStartTime = (int)time(NULL) / 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;
+}
+
+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;
+}
+
+/*
+ * NOTE: DownloadQueue must be locked prior to call of this function
+ * Returns True if Entry was deleted from Queue or False if it was scheduled for Deletion.
+ * NOTE: "False" does not mean unsuccess; the entry is (or will be) deleted in any case.
+ */
+bool QueueCoordinator::DeleteQueueEntry(FileInfo* pFileInfo)
+{
+	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)
+	{
+		Aspect aspect = { eaFileDeleted, pFileInfo, &m_DownloadQueue, NULL };
+		Notify(&aspect);
+
+		DeleteFileInfo(pFileInfo, false);
+	}
+	return hasDownloads;
+}
+
+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())
+		{
+			if (pFileInfo->GetArticles()->empty() && g_pOptions->GetSaveQueue() && g_pOptions->GetServerMode())
+			{
+				g_pDiskState->LoadArticles(pFileInfo);
+			}
+			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, NNTPConnection* pConnection)
+{
+	debug("Starting new ArticleDownloader");
+
+	ArticleDownloader* pArticleDownloader = new ArticleDownloader();
+	pArticleDownloader->SetAutoDestroy(true);
+	pArticleDownloader->Attach(this);
+	pArticleDownloader->SetFileInfo(pFileInfo);
+	pArticleDownloader->SetArticleInfo(pArticleInfo);
+	pArticleDownloader->SetConnection(pConnection);
+	BuildArticleFilename(pArticleDownloader, pFileInfo, pArticleInfo);
+
+	pArticleInfo->SetStatus(ArticleInfo::aiRunning);
+
+	m_ActiveDownloads.push_back(pArticleDownloader);
+	pArticleDownloader->Start();
+}
+
+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->GetNZBInfo()->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);
+
+	if (g_pOptions->GetDirectWrite())
+	{
+		snprintf(name, 1024, "%s%i.out", g_pOptions->GetTempDir(), pFileInfo->GetID());
+		name[1024-1] = '\0';
+		pArticleDownloader->SetOutputFilename(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);
+		if (g_pOptions->GetDupeCheck() && pFileInfo->IsDupe(pFileInfo->GetFilename()))
+		{
+			warn("File \"%s\" seems to be duplicate, cancelling download and deleting file from queue", pFileInfo->GetFilename());
+			fileCompleted = false;
+			DeleteQueueEntry(pFileInfo);
+		}
+	}
+
+	bool deleteFileObj = false;
+
+	if (pFileInfo->GetDeleted())
+	{
+		int cnt = 0;
+		for (ActiveDownloads::iterator it = m_ActiveDownloads.begin(); it != m_ActiveDownloads.end(); it++)
+		{
+			if ((*it)->GetFileInfo() == pFileInfo)
+			{
+				cnt++;
+			}
+		}
+		if (cnt == 1)
+		{
+			// this was the last Download for a file deleted from queue
+			deleteFileObj = true;
+		}
+	}
+
+	if (fileCompleted && !IsStopped() && !pFileInfo->GetDeleted())
+	{
+		// all jobs done
+		m_mutexDownloadQueue.Unlock();
+		pArticleDownloader->CompleteFileParts();
+		m_mutexDownloadQueue.Lock();
+		deleteFileObj = true;
+	}
+
+	// delete Download from Queue
+	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)
+	{
+		bool fileDeleted = pFileInfo->GetDeleted();
+		// delete File from Queue
+		pFileInfo->SetDeleted(true);
+
+		Aspect aspect = { fileCompleted && !fileDeleted ? eaFileCompleted : eaFileDeleted, pFileInfo, &m_DownloadQueue, NULL };
+		Notify(&aspect);
+		
+		DeleteFileInfo(pFileInfo, fileCompleted);
+	}
+
+	m_mutexDownloadQueue.Unlock();
+}
+
+void QueueCoordinator::DeleteFileInfo(FileInfo* pFileInfo, bool bCompleted)
+{
+	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())
+	{
+		g_pDiskState->DiscardFile(&m_DownloadQueue, pFileInfo);
+	}
+
+	if (!bCompleted)
+	{
+		// deleting temporary files
+
+		if (!g_pOptions->GetDirectWrite() || g_pOptions->GetContinuePartial())
+		{
+			for (FileInfo::Articles::iterator it = pFileInfo->GetArticles()->begin(); it != pFileInfo->GetArticles()->end(); it++)
+			{
+				ArticleInfo* pa = *it;
+				if (pa->GetResultFilename())
+				{
+					remove(pa->GetResultFilename());
+				}
+			}
+		}
+
+		if (g_pOptions->GetDirectWrite())
+		{
+			char name[1024];
+			snprintf(name, 1024, "%s%i.out", g_pOptions->GetTempDir(), pFileInfo->GetID());
+			name[1024-1] = '\0';
+			remove(name);
+		}
+	}
+
+	delete pFileInfo;
+}
+
+bool QueueCoordinator::IsDupe(FileInfo* pFileInfo)
+{
+	debug("Checking if the file is already queued");
+
+	// checking on disk
+	if (pFileInfo->IsDupe(pFileInfo->GetFilename()))
+	{
+		return true;
+	}
+
+	// checking in queue
+	for (DownloadQueue::iterator it = m_DownloadQueue.begin(); it != m_DownloadQueue.end(); it++)
+	{
+		FileInfo* pQueueEntry = *it;
+		if (!strcmp(pFileInfo->GetNZBInfo()->GetDestDir(), pQueueEntry->GetNZBInfo()->GetDestDir()) &&
+			!strcmp(pFileInfo->GetFilename(), pQueueEntry->GetFilename()) &&
+			pFileInfo != pQueueEntry)
+		{
+			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", Util::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();
+}
+
+void QueueCoordinator::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 QueueCoordinator::CalcStat(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();
+}
+
+/*
+ * Detects large step changes of system time and adjust statistics.
+ */
+void QueueCoordinator::AdjustStartTime()
+{
+	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_tStartDownload += tDiff + 1;
+		}
+	}		
+	m_tLastCheck = m_tCurTime;
+}
+
+bool QueueCoordinator::SetQueueEntryNZBCategory(NZBInfo* pNZBInfo, const char* szCategory)
+{
+	if (pNZBInfo->GetPostProcess())
+	{
+		char szNZBNiceName[1024];
+		pNZBInfo->GetNiceNZBName(szNZBNiceName, 1024);
+		error("Could not change category for %s. File in post-process-stage", szNZBNiceName);
+		return false;
+	}
+
+	char szOldDestDir[1024];
+	strncpy(szOldDestDir, pNZBInfo->GetDestDir(), 1024);
+	szOldDestDir[1024-1] = '\0';
+
+	pNZBInfo->SetCategory(szCategory);
+	pNZBInfo->BuildDestDirName();
+
+	bool bDirUnchanged = !strcmp(pNZBInfo->GetDestDir(), szOldDestDir);
+	bool bOK = bDirUnchanged || ArticleDownloader::MoveCompletedFiles(pNZBInfo, szOldDestDir);
+
+	return bOK;
+}

QueueCoordinator.h

@@ -0,0 +1,128 @@
+/*
+ *  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 <time.h>
+#ifdef WIN32
+#include <sys/timeb.h>
+#endif
+
+#include "Thread.h"
+#include "NZBFile.h"
+#include "ArticleDownloader.h"
+#include "DownloadInfo.h"
+#include "Observer.h"
+#include "QueueEditor.h"
+#include "NNTPConnection.h"
+                                            
+class QueueCoordinator : public Thread, public Observer, public Subject, public DownloadSpeedMeter, public NZBInfoLocker
+{
+public:
+	typedef std::list<ArticleDownloader*>	ActiveDownloads;
+	enum EAspectAction
+	{
+		eaNZBFileAdded,
+		eaFileCompleted,
+		eaFileDeleted
+	};
+	struct Aspect
+	{
+		EAspectAction eAction;
+		FileInfo* pFileInfo;
+		DownloadQueue* pDownloadQueue;
+		const char* szNZBFilename;
+	};
+
+private:
+	DownloadQueue			m_DownloadQueue;
+	ActiveDownloads			m_ActiveDownloads;
+	QueueEditor				m_QueueEditor;
+	Mutex			 		m_mutexDownloadQueue;
+	bool					m_bHasMoreJobs;
+
+	// statistics
+	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];
+    int                     m_iSpeedTotalBytes;
+    int 					m_iSpeedTime[SPEEDMETER_SLOTS];
+    int                     m_iSpeedStartTime; 
+
+    int						m_iSpeedBytesIndex;
+	long long				m_iAllBytes;
+	time_t					m_tStartServer;
+	time_t					m_tLastCheck;
+	time_t					m_tStartDownload;
+	time_t					m_tPausedFrom;
+	bool					m_bStandBy;
+	Mutex					m_mutexStat;
+
+	bool					GetNextArticle(FileInfo* &pFileInfo, ArticleInfo* &pArticleInfo);
+	void					StartArticleDownload(FileInfo* pFileInfo, ArticleInfo* pArticleInfo, NNTPConnection* pConnection);
+	void					BuildArticleFilename(ArticleDownloader* pArticleDownloader, FileInfo* pFileInfo, ArticleInfo* pArticleInfo);
+	bool					IsDupe(FileInfo* pFileInfo);
+	void					ArticleCompleted(ArticleDownloader* pArticleDownloader);
+	void					DeleteFileInfo(FileInfo* pFileInfo, bool bCompleted);
+	void					ResetHangingDownloads();
+	void					ResetSpeedStat();
+	void					EnterLeaveStandBy(bool bEnter);
+	void					AdjustStartTime();
+
+public:
+							QueueCoordinator();                
+	virtual					~QueueCoordinator();
+	virtual void			Run();
+	virtual void 			Stop();
+	void					Update(Subject* Caller, void* Aspect);
+
+	// statistics
+	long long 				CalcRemainingSize();
+	virtual float			CalcCurrentDownloadSpeed();
+	virtual void			AddSpeedReading(int iBytes);
+	void					CalcStat(int* iUpTimeSec, int* iDnTimeSec, long long* iAllBytes, bool* bStandBy);
+
+	// Editing the queue
+	DownloadQueue*			LockQueue();
+	void					UnlockQueue() ;
+	void					AddNZBFileToQueue(NZBFile* pNZBQueue, bool bAddFirst);
+	bool					AddFileToQueue(const char* szFileName, const char* szCategory);
+	bool					HasMoreJobs() { return m_bHasMoreJobs; }
+	bool					GetStandBy() { return m_bStandBy; }
+	bool					DeleteQueueEntry(FileInfo* pFileInfo);
+	bool					SetQueueEntryNZBCategory(NZBInfo* pNZBInfo, const char* szCategory);
+	QueueEditor*			GetQueueEditor() { return &m_QueueEditor; }
+
+	virtual void			LockNZBInfo(NZBInfo* pNZBInfo) { LockQueue(); }
+	virtual void			UnlockNZBInfo(NZBInfo* pNZBInfo) { UnlockQueue(); }
+
+	void					LogDebugInfo();
+};
+
+#endif

QueueEditor.cpp

@@ -0,0 +1,669 @@
+/*
+ *  This file is 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 <cctype>
+#include <cstdio>
+#include <sys/stat.h>
+#ifndef WIN32
+#include <unistd.h>
+#include <sys/time.h>
+#endif
+
+#include "nzbget.h"
+#include "DownloadInfo.h"
+#include "QueueEditor.h"
+#include "QueueCoordinator.h"
+#include "DiskState.h"
+#include "Options.h"
+#include "Log.h"
+#include "Util.h"
+
+extern QueueCoordinator* g_pQueueCoordinator;
+extern Options* g_pOptions;
+extern DiskState* g_pDiskState;
+
+const int MAX_ID = 100000000;
+
+QueueEditor::EditItem::EditItem(FileInfo* pFileInfo, int iOffset)
+{
+	m_pFileInfo = pFileInfo;
+	m_iOffset = iOffset;
+}
+
+QueueEditor::QueueEditor()
+{
+	debug("Creating QueueEditor");
+}
+
+QueueEditor::~QueueEditor()
+{
+	debug("Destroying QueueEditor");
+}
+
+FileInfo* QueueEditor::FindFileInfo(DownloadQueue* pDownloadQueue, int iID)
+{
+	for (DownloadQueue::iterator it = pDownloadQueue->begin(); it != pDownloadQueue->end(); it++)
+	{
+		FileInfo* pFileInfo = *it;
+		if (pFileInfo->GetID() == iID)
+		{
+			return pFileInfo;
+		}
+	}
+	return NULL;
+}
+
+int QueueEditor::FindFileInfoEntry(DownloadQueue* pDownloadQueue, FileInfo* pFileInfo)
+{
+	int iEntry = 0;
+	for (DownloadQueue::iterator it = pDownloadQueue->begin(); it != pDownloadQueue->end(); it++)
+	{
+		FileInfo* pFileInfo2 = *it;
+		if (pFileInfo2 == pFileInfo)
+		{
+			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
+ */
+void QueueEditor::PauseUnpauseEntry(FileInfo* pFileInfo, bool bPause)
+{
+	pFileInfo->SetPaused(bPause);
+}
+
+/*
+ * Removes entry with index iEntry
+ * returns true if successful, false if operation is not possible
+ */
+void QueueEditor::DeleteEntry(FileInfo* pFileInfo)
+{
+	info("Deleting file %s from download queue", pFileInfo->GetFilename());
+	g_pQueueCoordinator->DeleteQueueEntry(pFileInfo);
+}
+
+/*
+ * Moves entry identified with iID in the queue
+ * returns true if successful, false if operation is not possible
+ */
+void QueueEditor::MoveEntry(DownloadQueue* pDownloadQueue, FileInfo* pFileInfo, int iOffset)
+{
+	int iEntry = FindFileInfoEntry(pDownloadQueue, pFileInfo);
+	if (iEntry > -1)
+	{
+		int iNewEntry = iEntry + iOffset;
+
+		if (iNewEntry < 0)
+		{
+			iNewEntry = 0;
+		}
+		if ((unsigned int)iNewEntry > pDownloadQueue->size() - 1)
+		{
+			iNewEntry = (int)pDownloadQueue->size() - 1;
+		}
+
+		if (iNewEntry >= 0 && (unsigned int)iNewEntry <= pDownloadQueue->size() - 1)
+		{
+			FileInfo* fi = (*pDownloadQueue)[iEntry];
+			pDownloadQueue->erase(pDownloadQueue->begin() + iEntry);
+			pDownloadQueue->insert(pDownloadQueue->begin() + iNewEntry, fi);
+		}
+	}
+}
+
+bool QueueEditor::EditEntry(int ID, bool bSmartOrder, EEditAction eAction, int iOffset, const char* szText)
+{
+	IDList cIDList;
+	cIDList.clear();
+	cIDList.push_back(ID);
+	return EditList(&cIDList, bSmartOrder, eAction, iOffset, szText);
+}
+
+bool QueueEditor::LockedEditEntry(DownloadQueue* pDownloadQueue, int ID, bool bSmartOrder, EEditAction eAction, int iOffset, const char* szText)
+{
+	IDList cIDList;
+	cIDList.clear();
+	cIDList.push_back(ID);
+	return InternEditList(pDownloadQueue, &cIDList, bSmartOrder, eAction, iOffset, szText);
+}
+
+bool QueueEditor::EditList(IDList* pIDList, bool bSmartOrder, EEditAction eAction, int iOffset, const char* szText)
+{
+	DownloadQueue* pDownloadQueue = g_pQueueCoordinator->LockQueue();
+
+	bool bOK = InternEditList(pDownloadQueue, pIDList, bSmartOrder, eAction, iOffset, szText);
+
+	if (g_pOptions->GetSaveQueue() && g_pOptions->GetServerMode())
+	{
+		g_pDiskState->SaveDownloadQueue(pDownloadQueue);
+	}
+
+	g_pQueueCoordinator->UnlockQueue();
+
+	return bOK;
+}
+
+bool QueueEditor::InternEditList(DownloadQueue* pDownloadQueue, IDList* pIDList, bool bSmartOrder, EEditAction eAction, int iOffset, const char* szText)
+{
+	if (eAction == eaGroupMoveOffset)
+	{
+		AlignAffectedGroups(pDownloadQueue, pIDList, bSmartOrder, iOffset);
+	}
+
+	ItemList cItemList;
+	PrepareList(pDownloadQueue, &cItemList, pIDList, bSmartOrder, eAction, iOffset);
+
+	if (eAction == eaFilePauseAllPars || eAction == eaFilePauseExtraPars)
+	{
+		PauseParsInGroups(&cItemList, eAction == eaFilePauseExtraPars);
+	}
+	else
+	{
+		for (ItemList::iterator it = cItemList.begin(); it != cItemList.end(); it++)
+		{
+			EditItem* pItem = *it;
+			switch (eAction)
+			{
+				case eaFilePause:
+					PauseUnpauseEntry(pItem->m_pFileInfo, true);
+					break;
+
+				case eaFileResume:
+					PauseUnpauseEntry(pItem->m_pFileInfo, false);
+					break;
+
+				case eaFileMoveOffset:
+				case eaFileMoveTop:
+				case eaFileMoveBottom:
+					MoveEntry(pDownloadQueue, pItem->m_pFileInfo, pItem->m_iOffset);
+					break;
+
+				case eaFileDelete:
+					DeleteEntry(pItem->m_pFileInfo);
+					break;
+
+				case eaFilePauseAllPars:
+				case eaFilePauseExtraPars:
+					// remove compiler warning "enumeration not handled in switch"
+					break;
+
+				case eaGroupSetCategory:
+					SetNZBCategory(pItem->m_pFileInfo->GetNZBInfo(), szText);
+					break;
+
+				case eaGroupPause:
+				case eaGroupResume:
+				case eaGroupDelete:
+				case eaGroupMoveTop:
+				case eaGroupMoveBottom:
+				case eaGroupMoveOffset:
+				case eaGroupPauseAllPars:
+				case eaGroupPauseExtraPars:
+					EditGroup(pDownloadQueue, pItem->m_pFileInfo, eAction, iOffset);
+					break;
+			}
+			delete pItem;
+		}
+	}
+
+	return cItemList.size() > 0;
+}
+
+void QueueEditor::PrepareList(DownloadQueue* pDownloadQueue, ItemList* pItemList, IDList* pIDList, bool bSmartOrder, 
+	EEditAction EEditAction, int iOffset)
+{
+	if (EEditAction == eaFileMoveTop)
+	{
+		iOffset = -MAX_ID;
+	}
+	else if (EEditAction == eaFileMoveBottom)
+	{
+		iOffset = MAX_ID;
+	}
+
+	pItemList->reserve(pIDList->size());
+	if (bSmartOrder && iOffset != 0 && 
+		(EEditAction == eaFileMoveOffset || EEditAction == eaFileMoveTop || EEditAction == eaFileMoveBottom))
+	{
+		//add IDs to list in order they currently have in download queue
+		int iLastDestPos = -1;
+		int iStart, iEnd, iStep;
+		if (iOffset < 0)
+		{
+			iStart = 0;
+			iEnd = pDownloadQueue->size();
+			iStep = 1;
+		}
+		else
+		{
+			iStart = pDownloadQueue->size() - 1;
+			iEnd = -1;
+			iStep = -1;
+		}
+		for (int iIndex = iStart; iIndex != iEnd; iIndex += iStep)
+		{
+			FileInfo* pFileInfo = (*pDownloadQueue)[iIndex];
+			int iID = pFileInfo->GetID();
+			for (IDList::iterator it = pIDList->begin(); it != pIDList->end(); it++)
+			{
+				if (iID == *it)
+				{
+					int iWorkOffset = iOffset;
+					int iDestPos = iIndex + iWorkOffset;
+					if (iLastDestPos == -1)
+					{
+						if (iDestPos < 0)
+						{
+							iWorkOffset = -iIndex;
+						}
+						else if (iDestPos > int(pDownloadQueue->size()) - 1)
+						{
+							iWorkOffset = int(pDownloadQueue->size()) - 1 - iIndex;
+						}
+					}
+					else
+					{
+						if (iWorkOffset < 0 && iDestPos <= iLastDestPos)
+						{
+							iWorkOffset = iLastDestPos - iIndex + 1;
+						}
+						else if (iWorkOffset > 0 && iDestPos >= iLastDestPos)
+						{
+							iWorkOffset = iLastDestPos - iIndex - 1;
+						}
+					}
+					iLastDestPos = iIndex + iWorkOffset;
+					pItemList->push_back(new EditItem(pFileInfo, iWorkOffset));
+					break;
+				}
+			}
+		}
+	}
+	else
+	{
+		// check ID range
+		int iMaxID = 0;
+		int iMinID = MAX_ID;
+		for (DownloadQueue::iterator it = pDownloadQueue->begin(); it != pDownloadQueue->end(); it++)
+		{
+			FileInfo* pFileInfo = *it;
+			int ID = pFileInfo->GetID();
+			if (ID > iMaxID)
+			{
+				iMaxID = ID;
+			}
+			if (ID < iMinID)
+			{
+				iMinID = ID;
+			}
+		}
+
+		//add IDs to list in order they were transmitted in command
+		for (IDList::iterator it = pIDList->begin(); it != pIDList->end(); it++)
+		{
+			int iID = *it;
+			if (iMinID <= iID && iID <= iMaxID)
+			{
+				FileInfo* pFileInfo = FindFileInfo(pDownloadQueue, iID);
+				if (pFileInfo)
+				{
+					pItemList->push_back(new EditItem(pFileInfo, iOffset));
+				}
+			}
+		}
+	}
+}
+
+bool QueueEditor::EditGroup(DownloadQueue* pDownloadQueue, FileInfo* pFileInfo, EEditAction eAction, int iOffset)
+{
+	IDList cIDList;
+	cIDList.clear();
+
+	// collecting files belonging to group
+	for (DownloadQueue::iterator it = pDownloadQueue->begin(); it != pDownloadQueue->end(); it++)
+	{
+		FileInfo* pFileInfo2 = *it;
+		if (pFileInfo2->GetNZBInfo() == pFileInfo->GetNZBInfo())
+		{
+			cIDList.push_back(pFileInfo2->GetID());
+		}
+	}
+
+	if (eAction == eaGroupMoveOffset)
+	{
+		// calculating offset in terms of files
+		FileList cGroupList;
+		BuildGroupList(pDownloadQueue, &cGroupList);
+		unsigned int iNum = 0;
+		for (FileList::iterator it = cGroupList.begin(); it != cGroupList.end(); it++, iNum++)
+		{
+			FileInfo* pGroupInfo = *it;
+			if (pGroupInfo->GetNZBInfo() == pFileInfo->GetNZBInfo())
+			{
+				break;
+			}
+		}
+		int iFileOffset = 0;
+		if (iOffset > 0)
+		{
+			if (iNum + iOffset >= cGroupList.size() - 1)
+			{
+				eAction = eaGroupMoveBottom;
+			}
+			else
+			{
+				for (unsigned int i = iNum + 2; i < cGroupList.size() && iOffset > 0; i++, iOffset--)
+				{
+					iFileOffset += FindFileInfoEntry(pDownloadQueue, cGroupList[i]) - FindFileInfoEntry(pDownloadQueue, cGroupList[i-1]);
+				}
+			}
+		}
+		else
+		{
+			if (iNum + iOffset <= 0)
+			{
+				eAction = eaGroupMoveTop;
+			}
+			else
+			{
+				for (unsigned int i = iNum; i > 0 && iOffset < 0; i--, iOffset++)
+				{
+					iFileOffset -= FindFileInfoEntry(pDownloadQueue, cGroupList[i]) - FindFileInfoEntry(pDownloadQueue, cGroupList[i-1]);
+				}
+			}
+		}
+		iOffset = iFileOffset;
+	}
+
+	EEditAction GroupToFileMap[] = { (EEditAction)0, eaFileMoveOffset, eaFileMoveTop, eaFileMoveBottom, eaFilePause, eaFileResume, eaFileDelete, eaFilePauseAllPars, eaFilePauseExtraPars,
+		eaFileMoveOffset, eaFileMoveTop, eaFileMoveBottom, eaFilePause, eaFileResume, eaFileDelete, eaFilePauseAllPars, eaFilePauseExtraPars };
+
+	return InternEditList(pDownloadQueue, &cIDList, true, GroupToFileMap[eAction], iOffset, NULL);
+}
+
+void QueueEditor::BuildGroupList(DownloadQueue* pDownloadQueue, FileList* pGroupList)
+{
+	pGroupList->clear();
+    for (DownloadQueue::iterator it = pDownloadQueue->begin(); it != pDownloadQueue->end(); it++)
+    {
+        FileInfo* pFileInfo = *it;
+		FileInfo* pGroupInfo = NULL;
+		for (FileList::iterator itg = pGroupList->begin(); itg != pGroupList->end(); itg++)
+		{
+			FileInfo* pGroupInfo1 = *itg;
+			if (pGroupInfo1->GetNZBInfo() == pFileInfo->GetNZBInfo())
+			{
+				pGroupInfo = pGroupInfo1;
+				break;
+			}
+		}
+		if (!pGroupInfo)
+		{
+			pGroupList->push_back(pFileInfo);
+		}
+	}
+}
+
+bool QueueEditor::ItemExists(FileList* pFileList, FileInfo* pFileInfo)
+{
+	for (FileList::iterator it = pFileList->begin(); it != pFileList->end(); it++)
+	{
+		if (*it == pFileInfo)
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+void QueueEditor::AlignAffectedGroups(DownloadQueue* pDownloadQueue, IDList* pIDList, bool bSmartOrder, int iOffset)
+{
+	// Build list of all groups; List contains first file of each group
+	FileList cGroupList;
+	BuildGroupList(pDownloadQueue, &cGroupList);
+
+	// Find affected groups. It includes groups being moved and groups directly
+	// above or under of these groups (those order is also changed)
+	FileList cAffectedGroupList;
+	cAffectedGroupList.clear();
+	ItemList cItemList;
+	PrepareList(pDownloadQueue, &cItemList, pIDList, bSmartOrder, eaFileMoveOffset, iOffset);
+	for (ItemList::iterator it = cItemList.begin(); it != cItemList.end(); it++)
+	{
+		EditItem* pItem = *it;
+		unsigned int iNum = 0;
+		for (FileList::iterator it = cGroupList.begin(); it != cGroupList.end(); it++, iNum++)
+		{
+			FileInfo* pFileInfo = *it;
+			if (pItem->m_pFileInfo->GetNZBInfo() == pFileInfo->GetNZBInfo())
+			{
+				if (!ItemExists(&cAffectedGroupList, pFileInfo))
+				{
+					cAffectedGroupList.push_back(pFileInfo);
+				}
+				if (iOffset < 0)
+				{
+					for (int i = iNum - 1; i >= -iOffset-1; i--)
+					{
+						if (!ItemExists(&cAffectedGroupList, cGroupList[i]))
+						{
+							cAffectedGroupList.push_back(cGroupList[i]);
+						}
+					}
+				}
+				if (iOffset > 0)
+				{
+					for (unsigned int i = iNum + 1; i <= cGroupList.size() - iOffset; i++)
+					{
+						if (!ItemExists(&cAffectedGroupList, cGroupList[i]))
+						{
+							cAffectedGroupList.push_back(cGroupList[i]);
+						}
+					}
+
+					if (iNum + 1 < cGroupList.size())
+					{
+						cAffectedGroupList.push_back(cGroupList[iNum + 1]);
+					}
+				}
+				break;
+			}
+		}
+		delete pItem;
+	}
+	cGroupList.clear();
+
+	// Aligning groups
+	for (FileList::iterator it = cAffectedGroupList.begin(); it != cAffectedGroupList.end(); it++)
+	{
+		FileInfo* pFileInfo = *it;
+		AlignGroup(pDownloadQueue, pFileInfo);
+	}
+}
+
+void QueueEditor::AlignGroup(DownloadQueue* pDownloadQueue, FileInfo* pFirstFileInfo)
+{
+	FileInfo* pLastFileInfo = NULL;
+	unsigned int iLastNum = 0;
+	unsigned int iNum = 0;
+	while (iNum < pDownloadQueue->size())
+	{
+		FileInfo* pFileInfo = (*pDownloadQueue)[iNum];
+		if (pFirstFileInfo->GetNZBInfo() == pFileInfo->GetNZBInfo())
+		{
+			if (pLastFileInfo && iNum - iLastNum > 1)
+			{
+				pDownloadQueue->erase(pDownloadQueue->begin() + iNum);
+				pDownloadQueue->insert(pDownloadQueue->begin() + iLastNum + 1, pFileInfo);
+				iLastNum++;
+			}
+			else
+			{
+				iLastNum = iNum;
+			}
+			pLastFileInfo = pFileInfo;
+		}
+		iNum++;
+	}
+}
+
+void QueueEditor::PauseParsInGroups(ItemList* pItemList, bool bExtraParsOnly)
+{
+	while (true)
+	{
+		FileList GroupFileList;
+		GroupFileList.clear();
+		FileInfo* pFirstFileInfo = NULL;
+
+		for (ItemList::iterator it = pItemList->begin(); it != pItemList->end(); )
+		{
+			EditItem* pItem = *it;
+			if (!pFirstFileInfo || 
+				(pFirstFileInfo->GetNZBInfo() == pItem->m_pFileInfo->GetNZBInfo()))
+			{
+				GroupFileList.push_back(pItem->m_pFileInfo);
+				if (!pFirstFileInfo)
+				{
+					pFirstFileInfo = pItem->m_pFileInfo;
+				}
+				delete pItem;
+				pItemList->erase(it);
+				it = pItemList->begin();
+				continue;
+			}
+			it++;
+		}
+
+		if (!GroupFileList.empty())
+		{
+			PausePars(&GroupFileList, bExtraParsOnly);
+		}
+		else
+		{
+			break;
+		}
+	}
+}
+
+/**
+* If the parameter "bExtraParsOnly" is set to "false", then we pause all par2-files.
+* If the parameter "bExtraParsOnly" is set to "true", we use the following strategy:
+* At first we find all par-files, which do not have "vol" in their names, then we pause
+* all vols and do not affect all just-pars.
+* In a case, if there are no just-pars, but only vols, we find the smallest vol-file
+* and do not affect it, but pause all other pars.
+*/
+void QueueEditor::PausePars(FileList* pFileList, bool bExtraParsOnly)
+{
+	debug("QueueEditor: Pausing pars");
+	
+	FileList Pars, Vols;
+	Pars.clear();
+	Vols.clear();
+			
+	for (FileList::iterator it = pFileList->begin(); it != pFileList->end(); it++)
+	{
+		FileInfo* pFileInfo = *it;
+		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 (!bExtraParsOnly)
+			{
+				pFileInfo->SetPaused(true);
+			}
+			else
+			{
+				if (strstr(szLoFileName, ".vol"))
+				{
+					Vols.push_back(pFileInfo);
+				}
+				else
+				{
+					Pars.push_back(pFileInfo);
+				}
+			}
+		}
+	}
+	
+	if (bExtraParsOnly)
+	{
+		if (!Pars.empty())
+		{
+			for (FileList::iterator it = Vols.begin(); it != Vols.end(); it++)
+			{
+				FileInfo* pFileInfo = *it;
+				pFileInfo->SetPaused(true);
+			}
+		}
+		else
+		{
+			// pausing all Vol-files except the smallest one
+			FileInfo* pSmallest = NULL;
+			for (FileList::iterator it = Vols.begin(); it != Vols.end(); it++)
+			{
+				FileInfo* pFileInfo = *it;
+				if (!pSmallest)
+				{
+					pSmallest = pFileInfo;
+				}
+				else if (pSmallest->GetSize() > pFileInfo->GetSize())
+				{
+					pSmallest->SetPaused(true);
+					pSmallest = pFileInfo;
+				}
+				else 
+				{
+					pFileInfo->SetPaused(true);
+				}
+			}
+		}
+	}
+}
+
+void QueueEditor::SetNZBCategory(NZBInfo* pNZBInfo, const char* szCategory)
+{
+	debug("QueueEditor: setting category '%s' for '%s'", szCategory, Util::BaseFileName(pNZBInfo->GetFilename()));
+
+	g_pQueueCoordinator->SetQueueEntryNZBCategory(pNZBInfo, szCategory);
+}

QueueEditor.h

@@ -0,0 +1,100 @@
+/*
+ *  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 QUEUEEDITOR_H
+#define QUEUEEDITOR_H
+
+#include <vector>
+
+#include "DownloadInfo.h"
+
+class QueueEditor
+{
+public:
+	typedef std::vector<int> IDList;
+
+	enum EEditAction
+	{
+		eaFileMoveOffset = 1,			// move to m_iOffset relative to the current position in queue
+		eaFileMoveTop,
+		eaFileMoveBottom,
+		eaFilePause,
+		eaFileResume,
+		eaFileDelete,
+		eaFilePauseAllPars,
+		eaFilePauseExtraPars,
+		eaGroupMoveOffset,				// move to m_iOffset relative to the current position in queue
+		eaGroupMoveTop,
+		eaGroupMoveBottom,
+		eaGroupPause,
+		eaGroupResume,
+		eaGroupDelete,
+		eaGroupPauseAllPars,
+		eaGroupPauseExtraPars,
+		eaGroupSetCategory
+	};
+
+private:
+	class EditItem
+	{
+	public:
+		int			m_iOffset;
+		FileInfo*	m_pFileInfo;
+
+		EditItem(FileInfo* pFileInfo, int iOffset);
+	};
+
+	typedef std::vector<EditItem*> ItemList;
+	typedef std::vector<FileInfo*> FileList;
+
+private:
+	FileInfo*				FindFileInfo(DownloadQueue* pDownloadQueue, int iID);
+	int						FindFileInfoEntry(DownloadQueue* pDownloadQueue, FileInfo* pFileInfo);
+	bool					InternEditList(DownloadQueue* pDownloadQueue, IDList* pIDList, bool bSmartOrder, EEditAction eAction, int iOffset, const char* szText);
+	void					PrepareList(DownloadQueue* pDownloadQueue, ItemList* pItemList, IDList* pIDList, bool bSmartOrder, EEditAction eAction, int iOffset);
+	bool					EditGroup(DownloadQueue* pDownloadQueue, FileInfo* pFileInfo, EEditAction eAction, int iOffset);
+	void					BuildGroupList(DownloadQueue* pDownloadQueue, FileList* pGroupList);
+	void					AlignAffectedGroups(DownloadQueue* pDownloadQueue, IDList* pIDList, bool bSmartOrder, int iOffset);
+	bool					ItemExists(FileList* pFileList, FileInfo* pFileInfo);
+	void					AlignGroup(DownloadQueue* pDownloadQueue, FileInfo* pFirstFileInfo);
+	void					PauseParsInGroups(ItemList* pItemList, bool bExtraParsOnly);
+	void					PausePars(FileList* pFileList, bool bExtraParsOnly);
+	void					SetNZBCategory(NZBInfo* pNZBInfo, const char* szCategory);
+
+	void					PauseUnpauseEntry(FileInfo* pFileInfo, bool bPause);
+	void					DeleteEntry(FileInfo* pFileInfo);
+	void					MoveEntry(DownloadQueue* pDownloadQueue, FileInfo* pFileInfo, int iOffset);
+
+public:
+							QueueEditor();                
+							~QueueEditor();
+
+	bool					EditEntry(int ID, bool bSmartOrder, EEditAction eAction, int iOffset, const char* szText);
+	bool					EditList(IDList* pIDList, bool bSmartOrder, EEditAction eAction, int iOffset, const char* szText);
+
+	bool					LockedEditEntry(DownloadQueue* pDownloadQueue, int ID, bool bSmartOrder, EEditAction eAction, int iOffset, const char* szText);
+};
+
+#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,9 +29,6 @@ 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 
 depends on command-line parameters passed to the program.
@@ -44,16 +37,29 @@ depends on command-line parameters passed to the program.
 2. Supported OS
 =====================================
 
-NZBGet is written in C++ and works on Windows, OS X, Linux and
-most POSIX-conform OS'es.
+NZBGet is written in C++ and was initialy developed on Linux.
+It was ported to Windows later and tested for compatibility with
+several POSIX-OS'es.
+
+The current version (0.5.1) should run at least on:
+  - Linux Debian 4.0 on x86;
+  - Linux BusyBox with uClibc on MIPSEL;
+  - Windows XP SP2 on x86.
+
+One of the previous versions (0.3.0) was also tested on:
+  - Linux Debian 3.1 on x86;
+  - Solaris 10 on x86;
+  - Linux Debian 3.1 on SPARC (QEmu).
+  - PC-BSD 1.4 (based on FreeBSD 6.2) 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, OS X and Linux. For most POSIX-systems you need to compile
-the program yourself. 
+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. 
 
 If you have downloaded binaries you can just jump to section 
 "Configuration".
@@ -62,8 +68,8 @@ If you have downloaded binaries you can just jump to section
 3. Prerequisites on POSIX
 =====================================
 
-NZBGet is developed on a linux-system, but it runs on other
-POSIX platforms.
+NZBGet is developed on a linux-system, but it should run on other
+POSIX platforms (see the list of tested platforms above).
 
 NZBGet absolutely needs the following libraries:
 
@@ -76,16 +82,17 @@ And the following libraries are optional:
    - libcurses   (usually part of commercial systems)
      or (better)
    - libncurses  (http://invisible-island.net/ncurses)
-    
+   
+ - for par-check and -repair (enabled by default):
+   - 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)
+     or
+   - OpenSSL     (http://www.openssl.org)
 
- - for gzip support in web-server and web-client (enabled by default):
-   - zlib     (http://www.zlib.net)
-
-All these libraries are included in modern POSIX distributions and
+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 
@@ -95,41 +102,24 @@ 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:
+ - 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:
@@ -138,16 +128,13 @@ You may run configure with additional arguments:
     if you can not use curses/ncurses.
     
   --disable-parcheck - to make without parcheck-support. Use this option
-    if you have troubles when compiling par2-module.
+    if you can not use libpar2 or libsigc++.
 
-  --with-tlslib=(OpenSSL, GnuTLS) - to select which TLS/SSL library
+  --with-tlslib=(GnuTLS, OpenSSL) - 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.
+    you can not neither GnuTLS nor OpenSSL.
        
   --enable-debug - to build in debug-mode, if you want to see and log
     debug-messages.
@@ -155,13 +142,23 @@ You may run configure with additional arguments:
 Optional package: par-check
 ---------------------------
 NZBGet can check and repair downloaded files for you. For this purpose
-it uses library par2.
+it uses library par2 (libpar2), which needs sigc++ on its part.
 
-For your convenience the source code of libpar2 is integrated into
-NZBGet’s source tree and is compiled automatically when you make NZBGet.
+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:
 
-In a case errors occur during this process the inclusion of par2-module
-can be disabled using configure option "--disable-parcheck":
+  --with-libpar2-includes
+  --with-libpar2-libraries
+  --with-libsigc-includes
+  --with-libsigc-libraries
+  
+The library libsigc++ must be installed first, since libpar2 requires it.
+
+If you are not able to use libpar2 or libsigc++ or do not want them you can
+make the program without support for par-check using option 
+"--disable-parcheck":
 
   ./configure --disable-parcheck
 
@@ -169,10 +166,10 @@ 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 useful:
+Following configure-parameters may be usefull:
 
-  --with-libcurses-includes=/path/to/curses/includes
-  --with-libcurses-libraries=/path/to/curses/libraries
+  --with-libcurses-includes
+  --with-libcurses-libraries
 
 If you are not able to use curses or ncurses or do not want them you can
 make the program without support for curses using option "--disable-curses":
@@ -182,20 +179,20 @@ make the program without support for curses using option "--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.
+with TLS/SSL support. NZBGet can use two libraries: GnuTLS or OpenSSL.
 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:
+avialable it gives the precedence to GnuTLS. You may override that with
+the option --with-tlslib=(GnuTLS, OpenSSL). For example to build whith OpenSSL:
 
-  ./configure --with-tlslib= GnuTLS
+  ./configure --with-tlslib=OpenSSL
   
-Following configure-parameters may be useful:
+Following configure-parameters may be usefull:
 
-  --with-libtls-includess=/path/to/gnutls/includes
-  --with-libtls-libraries=/path/to/gnutls/libraries
+  --with-libtls-includes
+  --with-libtls-libraries
 
-  --with-openssl-includess=/path/to/openssl/includes
-  --with-openssl-libraries=/path/to/openssl/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":
@@ -210,41 +207,44 @@ NZBGet is developed using MS Visual C++ 2005. The project file and solution
 are provided. If you use MS Visual C++ 2005 Express you need to download
 and install Platform SDK.
 
-To compile the program with TLS/SSL support you need either OpenSSL or GnuTLS:
-   - OpenSSL  (http://www.openssl.org)
-   or
+To compile the program with par-check-support you also need the following 
+libraries:
+
+   - libsigc++   (http://libsigc.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:
+
    - GnuTLS   (http://www.gnu.org/software/gnutls)
 
-Also required are:
-   - Regex (http://gnuwin32.sourceforge.net/packages/regex.htm)
-   - Zlib (http://gnuwin32.sourceforge.net/packages/zlib.htm)
+Download a precompiled version of GnuTLS from http://josefsson.org/gnutls4win
+and create lib-file as described there in section "Using the GnuTLS DLL from 
+your Visual Studio program".
+
+After libsigc++ and libpar2 are compiled in static libraries (.lib), the 
+library for GnuTLS is created 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:
-  <EXE-DIR>/nzbget.conf
+
   ~/.nzbget
   /etc/nzbget.conf
   /usr/etc/nzbget.conf
@@ -268,12 +268,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:
 ----------------
 
@@ -301,16 +295,10 @@ 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
@@ -337,18 +325,9 @@ 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)
 
-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:
-
-  [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:
+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:
 
   nzbget -E T 2
   
@@ -361,8 +340,8 @@ or to delete files 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:
+same nzb-request. You need to pass one ID of any file in the group. For
+example to delete all files from the first nzb-request:
 
   nzbget -E G D 1
 
@@ -381,7 +360,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)
 
@@ -400,88 +379,26 @@ 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.
+After the download of nzb-file is completed nzbget can call post-process-script, 
+defined in configuration file. See example configuration file for the 
+description of parameters passed to the script.
 
-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. 
+An example script for unraring of downloaded files is provided in file
+postprocess-example.sh. That example is for POSIX systems (not for Windows).
 
 =====================================
 8. Authors
 =====================================
 
-NZBGet is developed and maintained by Andrey Prygunkov
+NZBGet was initialiy written by Sven Henkel (sidddy@users.sourceforge.net).
+
+Up to version 0.2.3 it was 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).
 
-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 distribution archive includes additional components
-written by other authors:
-
-Par2:
-	Peter Brian Clements <peterbclements@users.sourceforge.net>
-
-Par2 library API:
-	Francois Lesueur <flesueur@users.sourceforge.net>
-
-Catch:
-	Two Blue Cubes Ltd <https://github.com/philsquared/Catch>
-
-jQuery:
-	John Resig <http://jquery.com>
-	The Dojo Foundation <http://sizzlejs.com>
-
-Bootstrap:
-	Twitter, Inc <http://twitter.github.com/bootstrap>
-
-Raphaël:
-	Dmitry Baranovskiy <http://raphaeljs.com>
-	Sencha Labs <http://sencha.com>
-
-Elycharts:
-	Void Labs s.n.c. <http://void.it>
-
-iconSweets:
-	Yummygum <http://yummygum.com>
+Module TLS (TLS.c, TLS.h) is based on work by Martin Lambers (marlam@marlam.de).
 
 =====================================
 9. Copyright
@@ -496,13 +413,21 @@ 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)
+   - GnuTLS      (http://www.gnu.org/software/gnutls)
+
+libpar2 is distributed under GPL; libsigc++ and GnuTLS - 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
 

README.md

@@ -1,15 +0,0 @@
-# NZBGet #
-NZBGet is a binary downloader, which downloads files from Usenet
-based on information given in nzb-files. 
-
-NZBGet is written in C++ and is known for its extraordinary performance and efficiency.
-
-NZBGet can be run at almost every platform - classic PCs, NAS, media players, SAT-receivers, WLAN-routers, etc.
-The download area provides precompiled binaries
-for Windows, Mac OS X and Linux (compatible with many CPUs and platform variants). For other platforms
-the program can be compiled from sources.
-
-- [Home page (nzbget.net)](http://nzbget.net) - for first time visitors, learn more about NZBGet;
-- [Downloads](http://nzbget.net/download) - get the binaries and sources;
-- [Documentation](https://github.com/nzbget/nzbget/wiki) - installation manuals, HOW-TOs, API;
-- [Forum](http://forum.nzbget.net) - get support, share your ideas, scripts, add-ons.

RemoteClient.cpp

@@ -0,0 +1,748 @@
+/*
+ *  This file is part of nzbget
+ *
+ *  Copyright (C) 2005 Bo Cordes Petersen <placebodk@sourceforge.net>
+ *  Copyright (C) 2007-2008 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 <cstdio>
+#ifdef WIN32
+#include <windows.h>
+#else
+#include <unistd.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#endif
+#include <stdarg.h>
+
+#include "nzbget.h"
+#include "RemoteClient.h"
+#include "DownloadInfo.h"
+#include "Options.h"
+#include "Log.h"
+#include "Util.h"
+
+extern Options* g_pOptions;
+
+RemoteClient::RemoteClient()
+{
+	m_pConnection	= NULL;
+	m_pNetAddress	= NULL;
+	m_bVerbose		= true;
+
+	/*
+	printf("sizeof(SNZBRequestBase)=%i\n", sizeof(SNZBRequestBase));
+	printf("sizeof(SNZBDownloadRequest)=%i\n", sizeof(SNZBDownloadRequest));
+	printf("sizeof(SNZBListRequest)=%i\n", sizeof(SNZBListRequest));
+	printf("sizeof(SNZBListResponse)=%i\n", sizeof(SNZBListResponse));
+	printf("sizeof(SNZBListResponseEntry)=%i\n", sizeof(SNZBListResponseEntry));
+	printf("sizeof(SNZBLogRequest)=%i\n", sizeof(SNZBLogRequest));
+	printf("sizeof(SNZBLogResponse)=%i\n", sizeof(SNZBLogResponse));
+	printf("sizeof(SNZBLogResponseEntry)=%i\n", sizeof(SNZBLogResponseEntry));
+	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(const char * msg,...)
+{
+	if (m_bVerbose)
+	{
+		va_list ap;
+		va_start(ap, msg);
+		::vprintf(msg, ap);
+		va_end(ap);
+	}
+}
+
+void RemoteClient::perror(const 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();
+	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(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_szPassword, g_pOptions->GetServerPassword(), NZBREQUESTPASSWORDSIZE - 1);
+	pMessageBase->m_szPassword[NZBREQUESTPASSWORDSIZE - 1] = '\0';
+}
+
+bool RemoteClient::ReceiveBoolResponse()
+{
+	printf("Request sent\n");
+
+	// all bool-responses have the same format of structure, we use SNZBDownloadResponse here
+	SNZBDownloadResponse BoolResponse;
+	memset(&BoolResponse, 0, sizeof(BoolResponse));
+
+	int iResponseLen = m_pConnection->Recv((char*)&BoolResponse, sizeof(BoolResponse));
+	if (iResponseLen != sizeof(BoolResponse) || 
+		(int)ntohl(BoolResponse.m_MessageBase.m_iSignature) != (int)NZBMESSAGE_SIGNATURE ||
+		ntohl(BoolResponse.m_MessageBase.m_iStructSize) != sizeof(BoolResponse))
+	{
+		if (iResponseLen < 0)
+		{
+			printf("No response received (timeout)\n");
+		}
+		else
+		{
+			printf("Invalid response received: either not nzbget-server or wrong server version\n");
+		}
+		return false;
+	}
+
+	int iTextLen = ntohl(BoolResponse.m_iTrailingDataLength);
+	char* buf = (char*)malloc(iTextLen);
+	iResponseLen = m_pConnection->Recv(buf, iTextLen);
+	if (iResponseLen != iTextLen)
+	{
+		if (iResponseLen < 0)
+		{
+			printf("No response received (timeout)\n");
+		}
+		else
+		{
+			printf("Invalid response received: either not nzbget-server or wrong server version\n");
+		}
+		return false;
+	}
+
+	printf("server returned: %s\n", buf);
+	free(buf);
+	return ntohl(BoolResponse.m_bSuccess);
+}
+
+/*
+ * Sends a message to the running nzbget process.
+ */
+bool RemoteClient::RequestServerDownload(const char* szFilename, const char* szCategory, bool bAddFirst)
+{
+	// Read the file into the buffer
+	char* szBuffer	= NULL;
+	int iLength		= 0;
+	if (!Util::LoadFileIntoBuffer(szFilename, &szBuffer, &iLength))
+	{
+		printf("Could not load file %s\n", szFilename);
+		return false;
+	}
+
+	bool OK = InitConnection();
+	if (OK)
+	{
+		SNZBDownloadRequest DownloadRequest;
+		InitMessageBase(&DownloadRequest.m_MessageBase, eRemoteRequestDownload, sizeof(DownloadRequest));
+		DownloadRequest.m_bAddFirst = htonl(bAddFirst);
+		DownloadRequest.m_iTrailingDataLength = htonl(iLength);
+
+		strncpy(DownloadRequest.m_szFilename, szFilename, NZBREQUESTFILENAMESIZE - 1);
+		DownloadRequest.m_szFilename[NZBREQUESTFILENAMESIZE-1] = '\0';
+		DownloadRequest.m_szCategory[0] = '\0';
+		if (szCategory)
+		{
+			strncpy(DownloadRequest.m_szCategory, szCategory, NZBREQUESTFILENAMESIZE - 1);
+		}
+		DownloadRequest.m_szCategory[NZBREQUESTFILENAMESIZE-1] = '\0';
+
+		if (m_pConnection->Send((char*)(&DownloadRequest), sizeof(DownloadRequest)) < 0)
+		{
+			perror("m_pConnection->Send");
+			OK = false;
+		}
+		else
+		{
+			m_pConnection->Send(szBuffer, iLength);
+			OK = ReceiveBoolResponse();
+			m_pConnection->Disconnect();
+		}
+	}
+
+	// Cleanup
+	if (szBuffer)
+	{
+		free(szBuffer);
+	}
+
+	return OK;
+}
+
+bool RemoteClient::RequestServerList()
+{
+	if (!InitConnection()) return false;
+
+	SNZBListRequest ListRequest;
+	InitMessageBase(&ListRequest.m_MessageBase, eRemoteRequestList, sizeof(ListRequest));
+	ListRequest.m_bFileList = htonl(true);
+	ListRequest.m_bServerState = htonl(true);
+
+	if (m_pConnection->Send((char*)(&ListRequest), sizeof(ListRequest)) < 0)
+	{
+		perror("m_pConnection->Send");
+		return false;
+	}
+
+	printf("Request sent\n");
+
+	// Now listen for the returned list
+	SNZBListResponse ListResponse;
+	int iResponseLen = m_pConnection->Recv((char*) &ListResponse, sizeof(ListResponse));
+	if (iResponseLen != sizeof(ListResponse) || 
+		(int)ntohl(ListResponse.m_MessageBase.m_iSignature) != (int)NZBMESSAGE_SIGNATURE ||
+		ntohl(ListResponse.m_MessageBase.m_iStructSize) != sizeof(ListResponse))
+	{
+		if (iResponseLen < 0)
+		{
+			printf("No response received (timeout)\n");
+		}
+		else
+		{
+			printf("Invalid response received: either not nzbget-server or wrong server version\n");
+		}
+		return false;
+	}
+
+	char* pBuf = NULL;
+	if (ntohl(ListResponse.m_iTrailingDataLength) > 0)
+	{
+		pBuf = (char*)malloc(ntohl(ListResponse.m_iTrailingDataLength));
+		if (!m_pConnection->RecvAll(pBuf, ntohl(ListResponse.m_iTrailingDataLength)))
+		{
+			free(pBuf);
+			return false;
+		}
+	}
+
+	m_pConnection->Disconnect();
+
+	if (ntohl(ListResponse.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 (unsigned int i = 0; i < ntohl(ListResponse.m_iNrTrailingEntries); i++)
+		{
+			SNZBListResponseEntry* pListAnswer = (SNZBListResponseEntry*) pBufPtr;
+
+			long long lFileSize = Util::JoinInt64(ntohl(pListAnswer->m_iFileSizeHi), ntohl(pListAnswer->m_iFileSizeLo));
+			long long lRemainingSize = Util::JoinInt64(ntohl(pListAnswer->m_iRemainingSizeHi), ntohl(pListAnswer->m_iRemainingSizeLo));
+
+			char szCompleted[100];
+			szCompleted[0] = '\0';
+			if (lRemainingSize < lFileSize)
+			{
+				sprintf(szCompleted, ", %i%s", (int)(100 - Util::Int64ToFloat(lRemainingSize) * 100.0 / Util::Int64ToFloat(lFileSize)), "%");
+			}
+			char szStatus[100];
+			if (ntohl(pListAnswer->m_bPaused))
+			{
+				sprintf(szStatus, " (paused)");
+				lPaused += lRemainingSize;
+			}
+			else
+			{
+				szStatus[0] = '\0';
+				lRemaining += lRemainingSize;
+			}
+			char* szNZBFilename = pBufPtr + sizeof(SNZBListResponseEntry);
+			char* szFilename = pBufPtr + sizeof(SNZBListResponseEntry) + ntohl(pListAnswer->m_iNZBFilenameLen) + ntohl(pListAnswer->m_iSubjectLen);
+			
+			char szNZBNiceName[1024];
+			NZBInfo::MakeNiceNZBName(szNZBFilename, szNZBNiceName, 1024);
+			
+			printf("[%i] %s%c%s (%.2f MB%s)%s\n", ntohl(pListAnswer->m_iID), szNZBNiceName, (int)PATH_SEPARATOR, szFilename,
+				(float)(Util::Int64ToFloat(lFileSize) / 1024.0 / 1024.0), szCompleted, szStatus);
+
+			pBufPtr += sizeof(SNZBListResponseEntry) + ntohl(pListAnswer->m_iNZBFilenameLen) +
+				ntohl(pListAnswer->m_iSubjectLen) + ntohl(pListAnswer->m_iFilenameLen) + 
+				ntohl(pListAnswer->m_iDestDirLen) + ntohl(pListAnswer->m_iCategoryLen);
+		}
+
+		printf("-----------------------------------\n");
+		printf("Files: %i\n", ntohl(ListResponse.m_iNrTrailingEntries));
+		if (lPaused > 0)
+		{
+			printf("Remaining size: %.2f MB (+%.2f MB paused)\n", (float)(Util::Int64ToFloat(lRemaining) / 1024.0 / 1024.0), 
+				(float)(Util::Int64ToFloat(lPaused) / 1024.0 / 1024.0));
+		}
+		else
+		{
+			printf("Remaining size: %.2f MB\n", (float)(Util::Int64ToFloat(lRemaining) / 1024.0 / 1024.0));
+		}
+		printf("Current download rate: %.1f KB/s\n", (float)(ntohl(ListResponse.m_iDownloadRate) / 1024.0));
+
+		free(pBuf);
+	}
+
+	long long iAllBytes = Util::JoinInt64(ntohl(ListResponse.m_iDownloadedBytesHi), ntohl(ListResponse.m_iDownloadedBytesLo));
+	float fAverageSpeed = Util::Int64ToFloat(ntohl(ListResponse.m_iDownloadTimeSec) > 0 ? iAllBytes / ntohl(ListResponse.m_iDownloadTimeSec) : 0);
+	printf("Session download rate: %.1f KB/s\n", (float)(fAverageSpeed / 1024.0));
+
+	if (ntohl(ListResponse.m_iDownloadLimit) > 0)
+	{
+		printf("Speed limit: %.1f KB/s\n", (float)(ntohl(ListResponse.m_iDownloadLimit) / 1024.0));
+	}
+
+	int sec = ntohl(ListResponse.m_iUpTimeSec);
+	int h = sec / 3600;
+	int m = (sec % 3600) / 60;
+	int s = sec % 60;
+	printf("Up time: %.2d:%.2d:%.2d\n", h, m, s);
+
+	sec = ntohl(ListResponse.m_iDownloadTimeSec);
+	h = sec / 3600;
+	m = (sec % 3600) / 60;
+	s = sec % 60;
+	printf("Download time: %.2d:%.2d:%.2d\n", h, m, s);
+
+	printf("Downloaded: %.2f MB\n", (float)(Util::Int64ToFloat(iAllBytes) / 1024.0 / 1024.0));
+
+	printf("Threads running: %i\n", ntohl(ListResponse.m_iThreadCount));
+
+	if (ntohl(ListResponse.m_iPostJobCount) > 0)
+	{
+		printf("Post-jobs: %i\n", (int)ntohl(ListResponse.m_iPostJobCount));
+	}
+
+	if (ntohl(ListResponse.m_bServerStandBy))
+	{
+		printf("Server state: Stand-By\n");
+	}
+	else
+	{
+		printf("Server state: %s\n", ntohl(ListResponse.m_bServerPaused) ? "Paused" : "Downloading");
+	}
+
+	return true;
+}
+
+bool RemoteClient::RequestServerLog(int iLines)
+{
+	if (!InitConnection()) return false;
+
+	SNZBLogRequest LogRequest;
+	InitMessageBase(&LogRequest.m_MessageBase, eRemoteRequestLog, sizeof(LogRequest));
+	LogRequest.m_iLines = htonl(iLines);
+	LogRequest.m_iIDFrom = 0;
+
+	if (m_pConnection->Send((char*)(&LogRequest), sizeof(LogRequest)) < 0)
+	{
+		perror("m_pConnection->Send");
+		return false;
+	}
+
+	printf("Request sent\n");
+
+	// Now listen for the returned log
+	SNZBLogResponse LogResponse;
+	int iResponseLen = m_pConnection->Recv((char*) &LogResponse, sizeof(LogResponse));
+	if (iResponseLen != sizeof(LogResponse) || 
+		(int)ntohl(LogResponse.m_MessageBase.m_iSignature) != (int)NZBMESSAGE_SIGNATURE ||
+		ntohl(LogResponse.m_MessageBase.m_iStructSize) != sizeof(LogResponse))
+	{
+		if (iResponseLen < 0)
+		{
+			printf("No response received (timeout)\n");
+		}
+		else
+		{
+			printf("Invalid response received: either not nzbget-server or wrong server version\n");
+		}
+		return false;
+	}
+
+	char* pBuf = NULL;
+	if (ntohl(LogResponse.m_iTrailingDataLength) > 0)
+	{
+		pBuf = (char*)malloc(ntohl(LogResponse.m_iTrailingDataLength));
+		if (!m_pConnection->RecvAll(pBuf, ntohl(LogResponse.m_iTrailingDataLength)))
+		{
+			free(pBuf);
+			return false;
+		}
+	}
+
+	m_pConnection->Disconnect();
+
+	if (LogResponse.m_iTrailingDataLength == 0)
+	{
+		printf("Log is empty\n");
+	}
+	else
+	{
+		printf("Log (last %i entries)\n", ntohl(LogResponse.m_iNrTrailingEntries));
+		printf("-----------------------------------\n");
+
+		char* pBufPtr = (char*)pBuf;
+		for (unsigned int i = 0; i < ntohl(LogResponse.m_iNrTrailingEntries); i++)
+		{
+			SNZBLogResponseEntry* pLogAnswer = (SNZBLogResponseEntry*) pBufPtr;
+
+			char* szText = pBufPtr + sizeof(SNZBLogResponseEntry);
+			switch (ntohl(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;
+				case Message::mkDetail:
+					printf("[DETAIL] %s\n", szText);
+					break;
+			}
+
+			pBufPtr += sizeof(SNZBLogResponseEntry) + ntohl(pLogAnswer->m_iTextLen);
+		}
+
+		printf("-----------------------------------\n");
+
+		free(pBuf);
+	}
+
+	return true;
+}
+
+bool RemoteClient::RequestServerPauseUnpause(bool bPause)
+{
+	if (!InitConnection()) return false;
+
+	SNZBPauseUnpauseRequest PauseUnpauseRequest;
+	InitMessageBase(&PauseUnpauseRequest.m_MessageBase, eRemoteRequestPauseUnpause, sizeof(PauseUnpauseRequest));
+	PauseUnpauseRequest.m_bPause = htonl(bPause);
+
+	if (m_pConnection->Send((char*)(&PauseUnpauseRequest), sizeof(PauseUnpauseRequest)) < 0)
+	{
+		perror("m_pConnection->Send");
+		m_pConnection->Disconnect();
+		return false;
+	}
+
+	bool OK = ReceiveBoolResponse();
+	m_pConnection->Disconnect();
+
+	return OK;
+}
+
+bool RemoteClient::RequestServerSetDownloadRate(float fRate)
+{
+	if (!InitConnection()) return false;
+
+	SNZBSetDownloadRateRequest SetDownloadRateRequest;
+	InitMessageBase(&SetDownloadRateRequest.m_MessageBase, eRemoteRequestSetDownloadRate, sizeof(SetDownloadRateRequest));
+	SetDownloadRateRequest.m_iDownloadRate = htonl((unsigned int)(fRate * 1024));
+
+	if (m_pConnection->Send((char*)(&SetDownloadRateRequest), sizeof(SetDownloadRateRequest)) < 0)
+	{
+		perror("m_pConnection->Send");
+		m_pConnection->Disconnect();
+		return false;
+	}
+
+	bool OK = ReceiveBoolResponse();
+	m_pConnection->Disconnect();
+
+	return OK;
+}
+
+bool RemoteClient::RequestServerDumpDebug()
+{
+	if (!InitConnection()) return false;
+
+	SNZBDumpDebugRequest DumpDebugInfo;
+	InitMessageBase(&DumpDebugInfo.m_MessageBase, eRemoteRequestDumpDebug, sizeof(DumpDebugInfo));
+
+	if (m_pConnection->Send((char*)(&DumpDebugInfo), sizeof(DumpDebugInfo)) < 0)
+	{
+		perror("m_pConnection->Send");
+		m_pConnection->Disconnect();
+		return false;
+	}
+
+	bool OK = ReceiveBoolResponse();
+	m_pConnection->Disconnect();
+
+	return OK;
+}
+
+bool RemoteClient::RequestServerEditQueue(int iAction, int iOffset, const char* szText, int* pIDList, int iIDCount, bool bSmartOrder)
+{
+	if (iIDCount <= 0 || pIDList == NULL)
+	{
+		printf("File(s) not specified\n");
+		return false;
+	}
+
+	if (!InitConnection()) return false;
+
+	int iTextLen = szText ? strlen(szText) + 1 : 0;
+	// align size to 4-bytes, needed by ARM-processor (and may be others)
+	iTextLen += iTextLen % 4 > 0 ? 4 - iTextLen % 4 : 0;
+	int iLength = sizeof(int32_t) * iIDCount + iTextLen;
+
+	SNZBEditQueueRequest EditQueueRequest;
+	InitMessageBase(&EditQueueRequest.m_MessageBase, eRemoteRequestEditQueue, sizeof(EditQueueRequest));
+	EditQueueRequest.m_iAction = htonl(iAction);
+	EditQueueRequest.m_iOffset = htonl((int)iOffset);
+	EditQueueRequest.m_bSmartOrder = htonl(bSmartOrder);
+	EditQueueRequest.m_iTextLen = htonl(iTextLen);
+	EditQueueRequest.m_iNrTrailingEntries = htonl(iIDCount);
+	EditQueueRequest.m_iTrailingDataLength = htonl(iLength);
+
+	char* pTrailingData = (char*)malloc(iLength);
+
+	if (iTextLen > 0)
+	{
+		strcpy(pTrailingData, szText);
+	}
+
+	int32_t* pIDs = (int32_t*)(pTrailingData + iTextLen);
+	
+	for (int i = 0; i < iIDCount; i++)
+	{
+		pIDs[i] = htonl(pIDList[i]);
+	}
+			
+	bool OK = false;
+	if (m_pConnection->Send((char*)(&EditQueueRequest), sizeof(EditQueueRequest)) < 0)
+	{
+		perror("m_pConnection->Send");
+	}
+	else
+	{
+		m_pConnection->Send(pTrailingData, iLength);
+		OK = ReceiveBoolResponse();
+		m_pConnection->Disconnect();
+	}
+
+	free(pTrailingData);
+
+	m_pConnection->Disconnect();
+	return OK;
+}
+
+bool RemoteClient::RequestServerShutdown()
+{
+	if (!InitConnection()) return false;
+
+	SNZBShutdownRequest ShutdownRequest;
+	InitMessageBase(&ShutdownRequest.m_MessageBase, eRemoteRequestShutdown, sizeof(ShutdownRequest));
+
+	bool OK = m_pConnection->Send((char*)(&ShutdownRequest), sizeof(ShutdownRequest)) >= 0;
+	if (OK)
+	{
+		OK = ReceiveBoolResponse();
+	}
+	else
+	{
+		perror("m_pConnection->Send");
+	}
+
+	m_pConnection->Disconnect();
+	return OK;
+}
+
+bool RemoteClient::RequestServerVersion()
+{
+	if (!InitConnection()) return false;
+
+	SNZBVersionRequest VersionRequest;
+	InitMessageBase(&VersionRequest.m_MessageBase, eRemoteRequestVersion, sizeof(VersionRequest));
+
+	bool OK = m_pConnection->Send((char*)(&VersionRequest), sizeof(VersionRequest)) >= 0;
+	if (OK)
+	{
+		OK = ReceiveBoolResponse();
+	}
+	else
+	{
+		perror("m_pConnection->Send");
+	}
+
+	m_pConnection->Disconnect();
+	return OK;
+}
+
+bool RemoteClient::RequestPostQueue()
+{
+	if (!InitConnection()) return false;
+
+	SNZBPostQueueRequest PostQueueRequest;
+	InitMessageBase(&PostQueueRequest.m_MessageBase, eRemoteRequestPostQueue, sizeof(PostQueueRequest));
+
+	if (m_pConnection->Send((char*)(&PostQueueRequest), sizeof(PostQueueRequest)) < 0)
+	{
+		perror("m_pConnection->Send");
+		return false;
+	}
+
+	printf("Request sent\n");
+
+	// Now listen for the returned list
+	SNZBPostQueueResponse PostQueueResponse;
+	int iResponseLen = m_pConnection->Recv((char*) &PostQueueResponse, sizeof(PostQueueResponse));
+	if (iResponseLen != sizeof(PostQueueResponse) || 
+		(int)ntohl(PostQueueResponse.m_MessageBase.m_iSignature) != (int)NZBMESSAGE_SIGNATURE ||
+		ntohl(PostQueueResponse.m_MessageBase.m_iStructSize) != sizeof(PostQueueResponse))
+	{
+		if (iResponseLen < 0)
+		{
+			printf("No response received (timeout)\n");
+		}
+		else
+		{
+			printf("Invalid response received: either not nzbget-server or wrong server version\n");
+		}
+		return false;
+	}
+
+	char* pBuf = NULL;
+	if (ntohl(PostQueueResponse.m_iTrailingDataLength) > 0)
+	{
+		pBuf = (char*)malloc(ntohl(PostQueueResponse.m_iTrailingDataLength));
+		if (!m_pConnection->RecvAll(pBuf, ntohl(PostQueueResponse.m_iTrailingDataLength)))
+		{
+			free(pBuf);
+			return false;
+		}
+	}
+
+	m_pConnection->Disconnect();
+
+	if (ntohl(PostQueueResponse.m_iTrailingDataLength) == 0)
+	{
+		printf("Server has no files queued for post-processing\n");
+	}
+	else
+	{
+		printf("Post-Processing List\n");
+		printf("-----------------------------------\n");
+
+		char* pBufPtr = (char*)pBuf;
+		for (unsigned int i = 0; i < ntohl(PostQueueResponse.m_iNrTrailingEntries); i++)
+		{
+			SNZBPostQueueResponseEntry* pPostQueueAnswer = (SNZBPostQueueResponseEntry*) pBufPtr;
+
+			int iStageProgress = ntohl(pPostQueueAnswer->m_iStageProgress);
+
+			static const int EXECUTING_SCRIPT = 5;
+			char szCompleted[100];
+			szCompleted[0] = '\0';
+			if (iStageProgress > 0 && (int)ntohl(pPostQueueAnswer->m_iStage) != EXECUTING_SCRIPT)
+			{
+				sprintf(szCompleted, ", %i%s", (int)(iStageProgress / 10), "%");
+			}
+
+			const char* szPostStageName[] = { "", ", Loading Pars", ", Verifying source files", ", Repairing", ", Verifying repaired files", ", Executing postprocess-script", "" };
+			char* szInfoName = pBufPtr + sizeof(SNZBPostQueueResponseEntry) + ntohl(pPostQueueAnswer->m_iNZBFilenameLen) + ntohl(pPostQueueAnswer->m_iParFilename);
+			
+			printf("[%i] %s%s%s\n", ntohl(pPostQueueAnswer->m_iID), szInfoName, szPostStageName[ntohl(pPostQueueAnswer->m_iStage)], szCompleted);
+
+			pBufPtr += sizeof(SNZBPostQueueResponseEntry) + ntohl(pPostQueueAnswer->m_iNZBFilenameLen) + 
+				ntohl(pPostQueueAnswer->m_iParFilename) + ntohl(pPostQueueAnswer->m_iInfoNameLen) +
+				ntohl(pPostQueueAnswer->m_iDestDirLen) + ntohl(pPostQueueAnswer->m_iProgressLabelLen);
+		}
+
+		free(pBuf);
+
+		printf("-----------------------------------\n");
+	}
+
+	return true;
+}
+
+bool RemoteClient::RequestWriteLog(int iKind, const char* szText)
+{
+	if (!InitConnection()) return false;
+
+	SNZBWriteLogRequest WriteLogRequest;
+	InitMessageBase(&WriteLogRequest.m_MessageBase, eRemoteRequestWriteLog, sizeof(WriteLogRequest));
+	WriteLogRequest.m_iKind = htonl(iKind);
+	int iLength = strlen(szText) + 1;
+	WriteLogRequest.m_iTrailingDataLength = htonl(iLength);
+
+	if (m_pConnection->Send((char*)(&WriteLogRequest), sizeof(WriteLogRequest)) < 0)
+	{
+		perror("m_pConnection->Send");
+		return false;
+	}
+
+	m_pConnection->Send(szText, iLength);
+	bool OK = ReceiveBoolResponse();
+	m_pConnection->Disconnect();
+	return OK;
+}

RemoteClient.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-2015 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$
@@ -30,24 +30,12 @@
 #include "Options.h"
 #include "MessageBase.h"
 #include "Connection.h"
-#include "DownloadInfo.h"
 
 class RemoteClient
 {
 private:
-	class MatchedNZBInfo: public NZBInfo
-	{
-	public:
-		bool		m_bMatch;
-	};
-
-	class MatchedFileInfo: public FileInfo
-	{
-	public:
-		bool		m_bMatch;
-	};
-
 	Connection* 	m_pConnection;
+	NetAddress*		m_pNetAddress;
 	bool			m_bVerbose;
 
 	bool			InitConnection();
@@ -57,27 +45,20 @@ private:
 	void			perror(const char* msg);
 
 public:
-					RemoteClient();
-					~RemoteClient();
+	RemoteClient();
+	~RemoteClient();
 	void			SetVerbose(bool bVerbose) { m_bVerbose = bVerbose; };
-	bool 			RequestServerDownload(const char* szNZBFilename, const char* szNZBContent, const char* szCategory,
-						bool bAddFirst, bool bAddPaused, int iPriority,
-						const char* szDupeKey, int iDupeMode, int iDupeScore);
-	bool			RequestServerList(bool bFiles, bool bGroups, const char* szPattern);
-	bool			RequestServerPauseUnpause(bool bPause, eRemotePauseUnpauseAction iAction);
-	bool			RequestServerSetDownloadRate(int iRate);
+	bool 			RequestServerDownload(const char* szFilename, const char* szCategory, bool bAddFirst);
+	bool			RequestServerList();
+	bool			RequestServerPauseUnpause(bool bPause);
+	bool			RequestServerSetDownloadRate(float fRate);
 	bool			RequestServerDumpDebug();
-	bool 			RequestServerEditQueue(DownloadQueue::EEditAction eAction, int iOffset, const char* szText,
-						int* pIDList, int iIDCount, NameList* pNameList, eRemoteMatchMode iMatchMode);
+	bool 			RequestServerEditQueue(int iAction, int iOffset, const char* szText, int* pIDList, int iIDCount, bool bSmartOrder);
 	bool			RequestServerLog(int iLines);
 	bool			RequestServerShutdown();
-	bool			RequestServerReload();
 	bool			RequestServerVersion();
 	bool			RequestPostQueue();
 	bool 			RequestWriteLog(int iKind, const char* szText);
-	bool			RequestScan(bool bSyncMode);
-	bool			RequestHistory(bool bWithHidden);
-	void			BuildFileList(SNZBListResponse* pListResponse, const char* pTrailingData, DownloadQueue* pDownloadQueue);
 };
 
 #endif

RemoteServer.cpp

@@ -0,0 +1,226 @@
+/*
+ *  This file is 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 "BinRpc.h"
+#include "XmlRpc.h"
+#include "Log.h"
+#include "Options.h"
+
+extern Options* g_pOptions;
+
+//*****************************************************************
+// RemoteServer
+
+RemoteServer::RemoteServer()
+{
+	debug("Creating RemoteServer");
+
+	m_pNetAddress = new NetAddress(g_pOptions->GetServerIP(), g_pOptions->GetServerPort());
+	m_pConnection = NULL;
+}
+
+RemoteServer::~RemoteServer()
+{
+	debug("Destroying RemoteServer");
+
+	if (m_pConnection)
+	{
+		delete m_pConnection;
+	}
+	delete m_pNetAddress;
+}
+
+void RemoteServer::Run()
+{
+	debug("Entering RemoteServer-loop");
+
+	while (!IsStopped())
+	{
+		bool bBind = true;
+
+		if (!m_pConnection)
+		{
+			m_pConnection = new Connection(m_pNetAddress);
+			m_pConnection->SetTimeout(g_pOptions->GetConnectionTimeout());
+			m_pConnection->SetSuppressErrors(false);
+			bBind = m_pConnection->Bind() == 0;
+		}
+
+		// Accept connections and store the "new" socket value
+		SOCKET iSocket = INVALID_SOCKET;
+		if (bBind)
+		{
+			iSocket = m_pConnection->Accept();
+		}
+		if (!bBind || iSocket == INVALID_SOCKET)
+		{
+			// Remote server could not bind or accept connection, waiting 1/2 sec and try again
+			if (IsStopped())
+			{
+				break; 
+			}
+			usleep(500 * 1000);
+			delete m_pConnection;
+			m_pConnection = NULL;
+			continue;
+		}
+
+		RequestProcessor* commandThread = new RequestProcessor();
+		commandThread->SetAutoDestroy(true);
+		commandThread->SetSocket(iSocket);
+		commandThread->Start();
+	}
+	if (m_pConnection)
+	{
+		m_pConnection->Disconnect();
+	}
+
+	debug("Exiting RemoteServer-loop");
+}
+
+void RemoteServer::Stop()
+{
+	Thread::Stop();
+	if (m_pConnection)
+	{
+		m_pConnection->SetSuppressErrors(true);
+		m_pConnection->Cancel();
+#ifdef WIN32
+		m_pConnection->Disconnect();
+#endif
+	}
+}
+
+//*****************************************************************
+// RequestProcessor
+
+void RequestProcessor::Run()
+{
+	// Read the first 4 bytes to determine request type
+	bool bOK = false;
+	int iSignature = 0;
+	int iBytesReceived = recv(m_iSocket, (char*)&iSignature, sizeof(iSignature), 0);
+	if (iBytesReceived < 0)
+	{
+		return;
+	}
+
+	// Info - connection received
+#ifdef WIN32
+	char* ip = NULL;
+#else
+	char ip[20];
+#endif
+	struct sockaddr_in PeerName;
+	int iPeerNameLength = sizeof(PeerName);
+	if (getpeername(m_iSocket, (struct sockaddr*)&PeerName, (socklen_t*) &iPeerNameLength) >= 0)
+	{
+#ifdef WIN32
+		ip = inet_ntoa(PeerName.sin_addr);
+#else
+		inet_ntop(AF_INET, &PeerName.sin_addr, ip, sizeof(ip));
+#endif
+	}
+
+	if ((int)ntohl(iSignature) == (int)NZBMESSAGE_SIGNATURE)
+	{
+		// binary request received
+		bOK = true;
+		BinRpcProcessor processor;
+		processor.SetSocket(m_iSocket);
+		processor.SetSignature(iSignature);
+		processor.SetClientIP(ip);
+		processor.Execute();
+	}
+	else if (!strncmp((char*)&iSignature, "POST", 4) || !strncmp((char*)&iSignature, "GET ", 4))
+	{
+		// XML-RPC or JSON-RPC request received
+		Connection con(m_iSocket, false);
+		char szBuffer[1024];
+		if (con.ReadLine(szBuffer, sizeof(szBuffer), NULL))
+		{
+			XmlRpcProcessor::EHttpMethod eHttpMethod = XmlRpcProcessor::hmGet;
+			char* szUrl = szBuffer;
+			if (!strncmp((char*)&iSignature, "POST", 4))
+			{
+				eHttpMethod = XmlRpcProcessor::hmPost;
+				szUrl++;
+			}
+			if (char* p = strchr(szUrl, ' '))
+			{
+				*p = '\0';
+			}
+
+			XmlRpcProcessor::ERpcProtocol eProtocol = XmlRpcProcessor::rpUndefined;
+			if (!strcmp(szUrl, "/xmlrpc") || !strncmp(szUrl, "/xmlrpc/", 8))
+			{
+				eProtocol = XmlRpcProcessor::rpXmlRpc;
+			}
+			else if (!strcmp(szUrl, "/jsonrpc") || !strncmp(szUrl, "/jsonrpc/", 9))
+			{
+				eProtocol = XmlRpcProcessor::rpJsonRpc;
+			}
+
+			if (eProtocol != XmlRpcProcessor::rpUndefined)
+			{
+				XmlRpcProcessor processor;
+				processor.SetConnection(&con);
+				processor.SetClientIP(ip);
+				processor.SetProtocol(eProtocol);
+				processor.SetHttpMethod(eHttpMethod);
+				processor.SetUrl(szUrl);
+				processor.Execute();
+				bOK = true;
+			}
+		}
+	}
+
+	if (!bOK)
+	{
+		warn("Non-nzbget request received on port %i from %s", g_pOptions->GetServerPort(), ip);
+	}
+
+	closesocket(m_iSocket);
+}

RemoteServer.h

@@ -1,8 +1,8 @@
 /*
  *  This file is 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,16 +28,17 @@
 #define REMOTESERVER_H
 
 #include "Thread.h"
+#include "NetAddress.h"
 #include "Connection.h"
 
 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();
@@ -46,14 +47,11 @@ public:
 class RequestProcessor : public Thread
 {
 private:
-	bool				m_bTLS;
-	Connection*			m_pConnection;
+	SOCKET				m_iSocket;
 
 public:
-						~RequestProcessor();
 	virtual void		Run();
-	void				SetTLS(bool bTLS) { m_bTLS = bTLS; }
-	void				SetConnection(Connection* pConnection) { m_pConnection = pConnection; }
+	void				SetSocket(SOCKET iSocket) { m_iSocket = iSocket; };
 };
 
 #endif

ScriptController.cpp

@@ -0,0 +1,403 @@
+/*
+ *  This file is part of nzbget
+ *
+ *  Copyright (C) 2007-2008 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>
+#include <sys/wait.h>
+#include <signal.h>
+#endif
+#include <sys/stat.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+
+#include "nzbget.h"
+#include "ScriptController.h"
+#include "Log.h"
+#include "Util.h"
+#include "Options.h"
+
+extern Options* g_pOptions;
+
+void ScriptController::StartScriptJob(PostInfo* pPostInfo, const char* szScript, bool bNZBFileCompleted, bool bHasFailedParJobs)
+{
+	if (g_pOptions->GetPostPauseQueue() && !g_pOptions->GetPause())
+	{
+		info("Pausing queue before post-process-script");
+		g_pOptions->SetPause(true);
+	}
+
+	info("Executing post-process-script for %s", pPostInfo->GetInfoName());
+
+	ScriptController* pScriptController = new ScriptController();
+	pScriptController->m_pPostInfo = pPostInfo;
+	pScriptController->m_szScript = szScript;
+	pScriptController->m_bNZBFileCompleted = bNZBFileCompleted;
+	pScriptController->m_bHasFailedParJobs = bHasFailedParJobs;
+	pScriptController->SetAutoDestroy(false);
+
+	pPostInfo->SetScriptThread(pScriptController);
+
+	pScriptController->Start();
+}
+
+void ScriptController::Run()
+{
+	if (!Util::FileExists(m_szScript))
+	{
+		error("Could not start post-process-script: could not find file %s", m_szScript);
+		Finished();
+		return;
+	}
+
+	char szParStatus[10];
+	snprintf(szParStatus, 10, "%i", m_pPostInfo->GetParStatus());
+	szParStatus[10-1] = '\0';
+
+	char szCollectionCompleted[10];
+	snprintf(szCollectionCompleted, 10, "%i", (int)m_bNZBFileCompleted);
+	szCollectionCompleted[10-1] = '\0';
+
+	char szHasFailedParJobs[10];
+	snprintf(szHasFailedParJobs, 10, "%i", (int)m_bHasFailedParJobs);
+	szHasFailedParJobs[10-1] = '\0';
+
+	int pipein;
+
+#ifdef WIN32
+	char szCmdLine[2048];
+	snprintf(szCmdLine, 2048, "\"%s\" \"%s\" \"%s\" \"%s\" %s %s %s \"%s\"", m_szScript, m_pPostInfo->GetDestDir(), 
+		m_pPostInfo->GetNZBFilename(), m_pPostInfo->GetParFilename(), szParStatus, szCollectionCompleted, 
+		szHasFailedParJobs, m_pPostInfo->GetCategory());
+	szCmdLine[2048-1] = '\0';
+	
+	// create pipes to write and read data
+	HANDLE hReadPipe, hWritePipe;
+	SECURITY_ATTRIBUTES SecurityAttributes;
+	memset(&SecurityAttributes, 0, sizeof(SecurityAttributes));
+	SecurityAttributes.nLength = sizeof(SecurityAttributes);
+	SecurityAttributes.bInheritHandle = TRUE;
+
+	CreatePipe(&hReadPipe, &hWritePipe, &SecurityAttributes, 0);
+
+	STARTUPINFO StartupInfo;
+	memset(&StartupInfo, 0, sizeof(StartupInfo));
+	StartupInfo.cb = sizeof(StartupInfo);
+	StartupInfo.dwFlags = STARTF_USESTDHANDLES;
+	StartupInfo.hStdInput = 0;
+	StartupInfo.hStdOutput = hWritePipe;
+	StartupInfo.hStdError = hWritePipe;
+
+	PROCESS_INFORMATION ProcessInfo;
+	memset(&ProcessInfo, 0, sizeof(ProcessInfo));
+
+	BOOL bOK = CreateProcess(NULL, szCmdLine, NULL, NULL, TRUE, NORMAL_PRIORITY_CLASS | CREATE_NO_WINDOW, NULL, m_pPostInfo->GetDestDir(), &StartupInfo, &ProcessInfo);
+	if (!bOK)
+	{
+		DWORD dwErrCode = GetLastError();
+		char szErrMsg[255];
+		szErrMsg[255-1] = '\0';
+		if (FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM || FORMAT_MESSAGE_IGNORE_INSERTS || FORMAT_MESSAGE_ARGUMENT_ARRAY, 
+			NULL, dwErrCode, 0, szErrMsg, 255, NULL))
+		{
+			error("Could not start post-process-script: %s", szErrMsg);
+		}
+		else
+		{
+			error("Could not start post-process-script: error %i", dwErrCode);
+		}
+		Finished();
+		return;
+	}
+
+	debug("Child Process-ID: %i", (int)ProcessInfo.dwProcessId);
+
+	m_hProcess = ProcessInfo.hProcess;
+
+	// close unused "write" end
+	CloseHandle(hWritePipe);
+
+	pipein = _open_osfhandle((intptr_t)hReadPipe, _O_RDONLY);
+
+#else
+
+	char szDestDir[1024];
+	strncpy(szDestDir, m_pPostInfo->GetDestDir(), 1024);
+	szDestDir[1024-1] = '\0';
+	
+	char szNZBFilename[1024];
+	strncpy(szNZBFilename, m_pPostInfo->GetNZBFilename(), 1024);
+	szNZBFilename[1024-1] = '\0';
+	
+	char szParFilename[1024];
+	strncpy(szParFilename, m_pPostInfo->GetParFilename(), 1024);
+	szParFilename[1024-1] = '\0';
+
+	int p[2];
+	int pipeout;
+
+	// create the pipe
+	if (pipe(p))
+	{
+		error("Could not open pipe: errno %i", errno);
+		Finished();
+		return;
+	}
+
+	pipein = p[0];
+	pipeout = p[1];
+
+	debug("forking");
+	pid_t pid = fork();
+
+	if (pid == -1)
+	{
+		error("Could not start post-process-script: errno %i", errno);
+		Finished();
+		return;
+	}
+	else if (pid == 0)
+	{
+		// here goes the second instance
+			
+		// close up the "read" end
+		close(pipein);
+      			
+		// make the pipeout to be the same as stdout and stderr
+		dup2(pipeout, 1);
+		dup2(pipeout, 2);
+		
+		close(pipeout);
+
+		execlp(m_szScript, m_szScript, szDestDir, szNZBFilename, szParFilename, szParStatus, 
+			szCollectionCompleted, szHasFailedParJobs, m_pPostInfo->GetCategory(), NULL);
+		fprintf(stdout, "[ERROR] Could not start post-process-script: %s", strerror(errno));
+		fflush(stdout);
+		_exit(-1);
+	}
+
+	// continue the first instance
+	debug("forked");
+	debug("Child Process-ID: %i", (int)pid);
+
+	m_hProcess = pid;
+
+	// close unused "write" end
+	close(pipeout);
+#endif
+
+	// open the read end
+	FILE* readpipe = fdopen(pipein, "r");
+	if (!readpipe)
+	{
+		error("Could not open pipe to post-process-script");
+		Finished();
+		return;
+	}
+	
+	char* buf = (char*)malloc(10240);
+
+	debug("Entering pipe-loop");
+	while (!feof(readpipe) && !IsStopped())
+	{
+		if (fgets(buf, 10240, readpipe))
+		{
+			AddMessage(buf);
+		}
+	}
+	debug("Exited pipe-loop");
+	
+	free(buf);
+	fclose(readpipe);
+
+	if (IsStopped())
+	{
+		warn("Interrupted post-process-script for %s", m_pPostInfo->GetInfoName());
+	}
+
+#ifdef WIN32
+	WaitForSingleObject(m_hProcess, INFINITE);
+#else
+	waitpid(m_hProcess, NULL, 0);
+#endif
+
+	if (!IsStopped())
+	{
+		info("Completed post-process-script for %s", m_pPostInfo->GetInfoName());
+	}
+
+	Finished();
+}
+
+void ScriptController::Finished()
+{
+	m_pPostInfo->SetStage(PostInfo::ptFinished);
+	m_pPostInfo->SetWorking(false);
+
+	if (g_pOptions->GetPostPauseQueue())
+	{
+		info("Unpausing queue after post-process-script");
+		g_pOptions->SetPause(false);
+	}
+}
+
+void ScriptController::AddMessage(char* szText)
+{
+	debug("Adding message received from post-process-script");
+
+	for (char* pend = szText + strlen(szText) - 1; pend >= szText && (*pend == '\n' || *pend == '\r' || *pend == ' '); pend--) *pend = '\0';
+
+	if (strlen(szText) == 0)
+	{
+		// skip empty lines
+		return;
+	}
+
+	if (!strncmp(szText, "[INFO] ", 7))
+	{
+		info(szText + 7);
+		Options::EMessageTarget eMessageTarget = g_pOptions->GetInfoTarget();
+		if (eMessageTarget == Options::mtScreen || eMessageTarget == Options::mtBoth)
+		{
+			m_pPostInfo->AppendMessage(Message::mkInfo, szText + 7);
+		}
+	}
+	else if (!strncmp(szText, "[WARNING] ", 10))
+	{
+		warn(szText + 10);
+		Options::EMessageTarget eMessageTarget = g_pOptions->GetWarningTarget();
+		if (eMessageTarget == Options::mtScreen || eMessageTarget == Options::mtBoth)
+		{
+			m_pPostInfo->AppendMessage(Message::mkWarning, szText + 10);
+		}
+	}
+	else if (!strncmp(szText, "[ERROR] ", 8))
+	{
+		error(szText + 8);
+		Options::EMessageTarget eMessageTarget = g_pOptions->GetErrorTarget();
+		if (eMessageTarget == Options::mtScreen || eMessageTarget == Options::mtBoth)
+		{
+			m_pPostInfo->AppendMessage(Message::mkError, szText + 8);
+		}
+	}
+	else if (!strncmp(szText, "[DETAIL] ", 9))
+	{
+		detail(szText + 9);
+		Options::EMessageTarget eMessageTarget = g_pOptions->GetDetailTarget();
+		if (eMessageTarget == Options::mtScreen || eMessageTarget == Options::mtBoth)
+		{
+			m_pPostInfo->AppendMessage(Message::mkDetail, szText + 9);
+		}
+	}
+	else if (!strncmp(szText, "[DEBUG] ", 8))
+	{
+		debug(szText + 8);
+		Options::EMessageTarget eMessageTarget = g_pOptions->GetDebugTarget();
+		if (eMessageTarget == Options::mtScreen || eMessageTarget == Options::mtBoth)
+		{
+			m_pPostInfo->AppendMessage(Message::mkDebug, szText + 8);
+		}
+	}
+	else 
+	{
+		Options::EMessageTarget eMessageTarget = Options::mtNone;
+		Message::EKind eKind = Message::mkDebug;
+		switch (g_pOptions->GetPostLogKind())
+		{
+			case Options::plNone:
+				break;
+
+			case Options::plDetail:
+				detail("Post-Process: %s", szText);
+				eMessageTarget = g_pOptions->GetDetailTarget();
+				eKind = Message::mkDetail;
+				break;
+
+			case Options::plInfo:
+				info("Post-Process: %s", szText);
+				eMessageTarget = g_pOptions->GetInfoTarget();
+				eKind = Message::mkInfo;
+				break;
+
+			case Options::plWarning:
+				warn("Post-Process: %s", szText);
+				eMessageTarget = g_pOptions->GetWarningTarget();
+				eKind = Message::mkWarning;
+				break;
+
+			case Options::plError:
+				error("Post-Process: %s", szText);
+				eMessageTarget = g_pOptions->GetErrorTarget();
+				eKind = Message::mkError;
+				break;
+
+			case Options::plDebug:
+				debug("Post-Process: %s", szText);
+				eMessageTarget = g_pOptions->GetDebugTarget();
+				eKind = Message::mkDebug;
+				break;
+		}
+		if (eMessageTarget == Options::mtScreen || eMessageTarget == Options::mtBoth)
+		{
+			m_pPostInfo->AppendMessage(eKind, szText);
+		}
+	}
+
+	debug("Adding message received from post-process-script - completed");
+}
+
+void ScriptController::Stop()
+{
+	debug("Stopping post-process-script");
+	Thread::Stop();
+
+#ifdef WIN32
+	BOOL bOK = TerminateProcess(m_hProcess, -1);
+#else
+	bool bOK = kill(m_hProcess, 9) == 0;
+#endif
+
+	if (bOK)
+	{
+		debug("Terminated post-process-script");
+	}
+	else
+	{
+		error("Could not terminate post-process-script");
+	}
+
+	debug("Post-process-script stopped");
+}

ScriptController.h

@@ -1,7 +1,7 @@
 /*
  *  This file is part of nzbget
  *
- *  Copyright (C) 2007-2015 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *  Copyright (C) 2007-2008 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$
@@ -23,30 +23,33 @@
  */
 
 
-#ifndef POSTSCRIPT_H
-#define POSTSCRIPT_H
+#ifndef SCRIPTCONTROLLER_H
+#define SCRIPTCONTROLLER_H
 
 #include "Thread.h"
-#include "NzbScript.h"
+#include "PostInfo.h"
 
-class PostScriptController : public Thread, public NZBScriptController
+class ScriptController : public Thread
 {
 private:
 	PostInfo*			m_pPostInfo;
- 	int					m_iPrefixLen;
-	ScriptConfig::Script*	m_pScript;
+	const char*			m_szScript;
+	bool				m_bNZBFileCompleted;
+	bool				m_bHasFailedParJobs;
+#ifdef WIN32
+	HANDLE				m_hProcess;
+#else
+	pid_t				m_hProcess;
+#endif
 
-	void				PrepareParams(const char* szScriptName);
-	ScriptStatus::EStatus	AnalyseExitCode(int iExitCode);
-
-protected:
-	virtual void		ExecuteScript(ScriptConfig::Script* pScript);
-	virtual void		AddMessage(Message::EKind eKind, const char* szText);
+	void				AddMessage(char* szText);
+	void				Finished();
 
 public:
 	virtual void		Run();
 	virtual void		Stop();
-	static void			StartJob(PostInfo* pPostInfo);
+	static void			StartScriptJob(PostInfo* pPostInfo, const char* szScript, 
+							bool bNZBFileCompleted, bool bHasFailedParJobs);
 };
 
 #endif

ServerPool.cpp

@@ -0,0 +1,251 @@
+/*
+ *  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"
+
+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_iMaxLevel = 0;
+	m_iTimeout = 60;
+	m_Servers.clear();
+	m_Connections.clear();
+	m_Semaphores.clear();
+}
+
+ServerPool::~ ServerPool()
+{
+	debug("Destroying ServerPool");
+
+	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();
+
+	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);
+}
+
+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++)
+		{
+			PooledConnection* pConnection = new PooledConnection(pNewsServer);
+			pConnection->SetTimeout(m_iTimeout);
+			m_Connections.push_back(pConnection);
+		}
+	}
+
+	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 iLevel, bool bWait)
+{
+	bool bWaitVal = false;
+	if (bWait)
+	{
+		debug("Getting connection (wait)");
+		bWaitVal = m_Semaphores[iLevel]->Wait();
+	}
+	else
+	{
+		bWaitVal = m_Semaphores[iLevel]->TryWait();
+	}
+
+	if (!bWaitVal)
+	{
+		// signal received or wait timeout
+		return NULL;
+	}
+
+	m_mutexConnections.Lock();
+
+	PooledConnection* pConnection = NULL;
+	for (Connections::iterator it = m_Connections.begin(); it != m_Connections.end(); it++)
+	{
+		PooledConnection* pConnection1 = *it;
+		if (!pConnection1->GetInUse() && pConnection1->GetNewsServer()->GetLevel() == iLevel)
+		{
+			// free connection found, take it!
+			pConnection = pConnection1;
+			pConnection->SetInUse(true);
+			break;
+		}
+	}
+
+	m_mutexConnections.Unlock();
+
+	if (!pConnection)
+	{
+		error("ServerPool: serious error, no free connection found, but there should be one.");
+	}
+
+	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();
+	}
+	m_Semaphores[pConnection->GetNewsServer()->GetLevel()]->Post();
+
+	m_mutexConnections.Unlock();
+}
+
+void ServerPool::CloseUnusedConnections()
+{
+	m_mutexConnections.Lock();
+
+	time_t curtime = ::time(NULL);
+
+	for (Connections::iterator it = m_Connections.begin(); it != m_Connections.end(); it++)
+	{
+		PooledConnection* pConnection = *it;
+		if (!pConnection->GetInUse() && pConnection->GetStatus() == Connection::csConnected)
+		{
+			int tdiff = (int)(curtime - pConnection->GetFreeTime());
+			if (tdiff > CONNECTION_HOLD_SECODNS)
+			{
+				debug("Closing unused connection to %s", pConnection->GetNewsServer()->GetHost());
+				pConnection->Disconnect();
+			}
+		}
+	}
+
+	m_mutexConnections.Unlock();
+}
+
+void ServerPool::LogDebugInfo()
+{
+	debug("   ServerPool");
+	debug("   ----------------");
+
+	debug("    Max-Level: %i", m_iMaxLevel);
+
+	m_mutexConnections.Lock();
+
+	debug("    Connections: %i", m_Connections.size());
+	for (Connections::iterator it = m_Connections.begin(); it != m_Connections.end(); it++)
+	{
+		debug("      Connection: Level=%i, InUse:%i", (*it)->GetNewsServer()->GetLevel(), (int)(*it)->GetInUse());
+	}
+/*
+	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_mutexConnections.Unlock();
+}

ServerPool.h

@@ -1,8 +1,9 @@
 /*
- *  This file is part of nzbget
+ *  This file if part of nzbget
  *
- *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
- *  Copyright (C) 2007-2015 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *  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
@@ -16,7 +17,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,12 +31,11 @@
 #include <vector>
 #include <time.h>
 
-#include "Log.h"
 #include "Thread.h"
 #include "NewsServer.h"
 #include "NNTPConnection.h"
 
-class ServerPool : public Debuggable
+class ServerPool
 {
 private:
 	class PooledConnection : public NNTPConnection
@@ -51,42 +51,29 @@ private:
 		void			SetFreeTimeNow() { m_tFreeTime = ::time(NULL); }
 	};
 
-	typedef std::vector<int>				Levels;
+	typedef std::vector<NewsServer*>		Servers;
+	typedef std::vector<Semaphore*>			Semaphores;
 	typedef std::vector<PooledConnection*>	Connections;
 
 	Servers				m_Servers;
-	Servers				m_SortedServers;
 	Connections			m_Connections;
-	Levels				m_Levels;
-	int					m_iMaxNormLevel;
+	Semaphores			m_Semaphores;
+	int					m_iMaxLevel;
 	Mutex			 	m_mutexConnections;
 	int					m_iTimeout;
-	int					m_iRetryInterval;
-	int					m_iGeneration;
-
-	void				NormalizeLevels();
-	static bool			CompareServers(NewsServer* pServer1, NewsServer* pServer2);
-
-protected:
-	virtual void		LogDebugInfo();
 
 public:
-						ServerPool();
-						~ServerPool();
+	ServerPool();
+	~ServerPool();
 	void				SetTimeout(int iTimeout) { m_iTimeout = iTimeout; }
-	void				SetRetryInterval(int iRetryInterval) { m_iRetryInterval = iRetryInterval; }
-	void 				AddServer(NewsServer* pNewsServer);
+	void 				AddServer(NewsServer *s);
 	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);
+	int					GetMaxLevel() { return m_iMaxLevel; }
+	NNTPConnection*		GetConnection(int iLevel, bool bWait);
 	void 				FreeConnection(NNTPConnection* pConnection, bool bUsed);
 	void				CloseUnusedConnections();
-	void				Changed();
-	int					GetGeneration() { return m_iGeneration; }
-	void				BlockServer(NewsServer* pNewsServer);
+
+	void				LogDebugInfo();
 };
 
-extern ServerPool* g_pServerPool;
-
 #endif

TLS.h

@@ -0,0 +1,211 @@
+/*
+ *  This file is part of nzbget
+ *
+ *  Based on "tls.h" from project "mpop" by Martin Lambers
+ *  Original source code available on http://sourceforge.net/projects/mpop/
+ *
+ *  Copyright (C) 2000, 2003, 2004, 2005, 2006, 2007
+ *  Martin Lambers <marlam@marlam.de>
+ *
+ *  Copyright (C) 2008 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 TLS_H
+#define TLS_H
+
+#ifndef DISABLE_TLS
+
+#ifdef HAVE_LIBGNUTLS
+# include <gnutls/gnutls.h>
+#endif /* HAVE_LIBGNUTLS */
+#ifdef HAVE_OPENSSL
+# include <openssl/ssl.h>
+#endif /* HAVE_OPENSSL */
+
+
+/*
+ * If a function with an 'errstr' argument returns a value != TLS_EOK,
+ * '*errstr' either points to an allocates string containing an error 
+ * description or is NULL.
+ * If such a function returns TLS_EOK, 'errstr' will not be changed.
+ */
+#define TLS_EOK		0	/* no error */
+#define TLS_ELIBFAILED	1	/* The underlying library failed */
+#define TLS_ESEED	2	/* Cannot seed pseudo random number generator */
+#define TLS_ECERT	3	/* Certificate check or verification failed */
+#define TLS_EIO		4	/* Input/output error */
+#define TLS_EFILE	5	/* A file does not exist/cannot be read */
+#define TLS_EHANDSHAKE	6	/* TLS handshake failed */
+
+
+/*
+ * Always use tls_clear() before using a tls_t!
+ * Never call a tls_*() function with tls_t NULL!
+ */
+
+typedef struct
+{
+    int have_trust_file;
+    int is_active;
+#ifdef HAVE_LIBGNUTLS
+    gnutls_session_t session;
+    gnutls_certificate_credentials_t cred;
+#endif /* HAVE_LIBGNUTLS */
+#ifdef HAVE_OPENSSL
+    SSL_CTX *ssl_ctx;
+    SSL *ssl;
+#endif /* HAVE_OPENSSL */
+} tls_t;
+
+/*
+ * Information about a X509 certificate.
+ * The 6 owner_info and issuer_info fields are:
+ *   Common Name
+ *   Organization
+ *   Organizational unit
+ *   Locality
+ *   State/Province
+ *   Country
+ * Each of these entries may be NULL if it was not provided.
+ */
+typedef struct
+{
+    unsigned char sha1_fingerprint[20];
+    unsigned char md5_fingerprint[16];
+    time_t activation_time;
+    time_t expiration_time;
+    char *owner_info[6];		
+    char *issuer_info[6];
+} tls_cert_info_t;
+
+/*
+ * tls_lib_init()
+ *
+ * Initialize underlying TLS library. If this function returns TLS_ELIBFAILED,
+ * *errstr will always point to an error string.
+ * Used error codes: TLS_ELIBFAILED
+ */
+int tls_lib_init(char **errstr);
+
+/*
+ * tls_clear()
+ *
+ * Clears a tls_t type (marks it inactive).
+ */
+void tls_clear(tls_t *tls);
+
+/*
+ * tls_init()
+ *
+ * Initializes a tls_t. If both 'key_file' and 'ca_file' are not NULL, they are
+ * set to be used when the peer request a certificate. If 'trust_file' is not
+ * NULL, it will be used to verify the peer certificate.
+ * All files must be in PEM format.
+ * If 'force_sslv3' is set, then only the SSLv3 protocol will be accepted. This
+ * option might be needed to talk to some obsolete broken servers. Only use this
+ * if you have to.
+ * Used error codes: TLS_ELIBFAILED, TLS_EFILE
+ */
+int tls_init(tls_t *tls, 
+	const char *key_file, const char *ca_file, const char *trust_file, 
+	int force_sslv3, char **errstr);
+
+/*
+ * tls_start()
+ *
+ * Starts TLS encryption on a socket.
+ * 'tls' must be initialized using tls_init().
+ * If 'no_certcheck' is true, then no checks will be performed on the peer
+ * certificate. If it is false and no trust file was set with tls_init(), 
+ * only sanity checks are performed on the peer certificate. If it is false 
+ * and a trust file was set, real verification of the peer certificate is 
+ * performed.
+ * 'hostname' is the host to start TLS with. It is needed for sanity checks/
+ * verification.
+ * 'tci' must be allocated with tls_cert_info_new(). Information about the 
+ * peer's certificata will be stored in it. It can later be freed with
+ * tls_cert_info_free(). 'tci' is allowed to be NULL; no certificate 
+ * information will be passed in this case.
+ * Used error codes: TLS_ELIBFAILED, TLS_ECERT, TLS_EHANDSHAKE
+ */
+int tls_start(tls_t *tls, int fd, const char *hostname, int no_certcheck,
+	tls_cert_info_t *tci, char **errstr);
+
+/*
+ * tls_is_active()
+ *
+ * Returns whether 'tls' is an active TLS connection.
+ */
+int tls_is_active(tls_t *tls);
+
+/*
+ * tls_cert_info_new()
+ * Returns a new tls_cert_info_t
+ */
+tls_cert_info_t *tls_cert_info_new(void);
+
+/*
+ * tls_cert_info_free()
+ * Frees a tls_cert_info_t
+ */
+void tls_cert_info_free(tls_cert_info_t *tci);
+
+/*
+ * tls_cert_info_get()
+ *
+ * Extracts certificate information from the TLS connection 'tls' and stores
+ * it in 'tci'. See the description of tls_cert_info_t above.
+ * Used error codes: TLS_ECERT
+ */
+int tls_cert_info_get(tls_t *tls, tls_cert_info_t *tci, char **errstr);
+
+/*
+ * tls_getbuf()
+ *
+ * Reads a buffer using TLS and stores it in 's'.
+ * Used error codes: TLS_EIO
+ */
+int tls_getbuf(tls_t *tls, char* s, size_t len, size_t* readlen, char **errstr);
+
+/*
+ * tls_putbuf()
+ *
+ * Writes 'len' characters from the string 's' using TLS.
+ * Used error codes: TLS_EIO
+ */
+int tls_putbuf(tls_t *tls, const char *s, size_t len, char **errstr);
+
+/*
+ * tls_close()
+ *
+ * Close a TLS connection and mark it inactive
+ */
+void tls_close(tls_t *tls);
+
+/*
+ * tls_lib_deinit()
+ *
+ * Deinit underlying TLS library.
+ */
+void tls_lib_deinit(void);
+
+#endif
+#endif

Thread.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-2015 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$
@@ -34,66 +34,141 @@
 
 #include <stdlib.h>
 #include <stdio.h>
-#include <errno.h>
 
 #ifdef WIN32
 #include <process.h>
-#else
-#include <fcntl.h>
-#include <pthread.h>
 #endif
 
 #include "Log.h"
 #include "Thread.h"
 
 int Thread::m_iThreadCount = 1; // take the main program thread into account
-Mutex* Thread::m_pMutexThread;
-
+Mutex Thread::m_mutexThread;
 
 Mutex::Mutex()
 {
 #ifdef WIN32
-	m_pMutexObj = (CRITICAL_SECTION*)malloc(sizeof(CRITICAL_SECTION));
-	InitializeCriticalSection((CRITICAL_SECTION*)m_pMutexObj);
+	InitializeCriticalSection(&m_mutexObj);
 #else
-	m_pMutexObj = (pthread_mutex_t*)malloc(sizeof(pthread_mutex_t));
-	pthread_mutex_init((pthread_mutex_t*)m_pMutexObj, NULL);
+	pthread_mutex_init(&m_mutexObj, NULL);
 #endif
 }
 
 Mutex::~ Mutex()
 {
 #ifdef WIN32
-	DeleteCriticalSection((CRITICAL_SECTION*)m_pMutexObj);
+	DeleteCriticalSection(&m_mutexObj);
 #else
-	pthread_mutex_destroy((pthread_mutex_t*)m_pMutexObj);
+	pthread_mutex_destroy(&m_mutexObj);
 #endif
-	free(m_pMutexObj);
 }
 
 void Mutex::Lock()
 {
 #ifdef WIN32
-	EnterCriticalSection((CRITICAL_SECTION*)m_pMutexObj);
+	EnterCriticalSection(&m_mutexObj);
 #ifdef DEBUG
 	// CriticalSections on Windows can be locked many times from the same thread,
 	// but we do not want this and must treat such situations as errors and detect them.
-	if (((CRITICAL_SECTION*)m_pMutexObj)->RecursionCount > 1)
+	if (m_mutexObj.RecursionCount > 1)
 	{
 		error("Internal program error: inconsistent thread-lock detected");
 	}
 #endif
 #else
-	pthread_mutex_lock((pthread_mutex_t*)m_pMutexObj);
+	pthread_mutex_lock(&m_mutexObj);
 #endif
 }
 
 void Mutex::Unlock()
 {
 #ifdef WIN32
-	LeaveCriticalSection((CRITICAL_SECTION*)m_pMutexObj);
+	LeaveCriticalSection(&m_mutexObj);
 #else
-	pthread_mutex_unlock((pthread_mutex_t*)m_pMutexObj);
+	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::TryWait()
+{
+#ifdef WIN32
+	return WaitForSingleObject(m_semObj, 0) == WAIT_OBJECT_0;
+#else
+	return sem_trywait(&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
 }
 
@@ -101,27 +176,18 @@ void Mutex::Unlock()
 void Thread::Init()
 {
 	debug("Initializing global thread data");
-
-	m_pMutexThread = new Mutex();
 }
 
 void Thread::Final()
 {
 	debug("Finalizing global thread data");
-
-	delete m_pMutexThread;
 }
 
 Thread::Thread()
 {
 	debug("Creating Thread");
 
-#ifdef WIN32
-	m_pThreadObj = NULL;
-#else
-	m_pThreadObj = (pthread_t*)malloc(sizeof(pthread_t));
-	*((pthread_t*)m_pThreadObj) = 0;
-#endif
+	m_Thread = 0;
 	m_bRunning = false;
 	m_bStopped = false;
 	m_bAutoDestroy = false;
@@ -130,9 +196,6 @@ Thread::Thread()
 Thread::~Thread()
 {
 	debug("Destroying Thread");
-#ifndef WIN32
-	free(m_pThreadObj);
-#endif
 }
 
 void Thread::Start()
@@ -141,29 +204,30 @@ void Thread::Start()
 
 	m_bRunning = true;
 	
-	// NOTE: we must guarantee, that in a time we set m_bRunning
+	// 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 its job and terminate.
-	// We lock mutex m_pMutexThread on calling pthread_create; the started thread
+	// 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_pMutexThread->Lock();
+	m_mutexThread.Lock();
 
 #ifdef WIN32
-	m_pThreadObj = (HANDLE)_beginthread(Thread::thread_handler, 0, (void *)this);
-	m_bRunning = m_pThreadObj != NULL;
+	m_Thread = (HANDLE)_beginthread(Thread::thread_handler, 0, (void *)this);
+	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((pthread_t*)m_pThreadObj, &m_Attr, Thread::thread_handler, (void *) this);
+	m_bRunning = !pthread_create(&m_Thread, &m_Attr, Thread::thread_handler, (void *) this);
 	pthread_attr_destroy(&m_Attr);
 #endif
 
-	m_pMutexThread->Unlock();
+	m_mutexThread.Unlock();
 }
 
 void Thread::Stop()
@@ -173,30 +237,23 @@ void Thread::Stop()
 	m_bStopped = true;
 } 
 
-void Thread::Resume()
-{
-	debug("Resuming Thread");
-
-	m_bStopped = false;
-}
-
 bool Thread::Kill()
 {
 	debug("Killing Thread");
 
-	m_pMutexThread->Lock();
+	m_mutexThread.Lock();
 
 #ifdef WIN32
-	bool terminated = TerminateThread((HANDLE)m_pThreadObj, 0) != 0;
+	bool terminated = TerminateThread(m_Thread, 0) != 0;
 #else
-	bool terminated = pthread_cancel(*(pthread_t*)m_pThreadObj) == 0;
+	bool terminated = pthread_cancel(m_Thread) == 0;
 #endif
 
 	if (terminated)
 	{
 		m_iThreadCount--;
 	}
-	m_pMutexThread->Unlock();
+	m_mutexThread.Unlock();
 	return terminated;
 }
 
@@ -206,9 +263,9 @@ void __cdecl Thread::thread_handler(void* pObject)
 void* Thread::thread_handler(void* pObject)
 #endif
 {
-	m_pMutexThread->Lock();
+	m_mutexThread.Lock();
 	m_iThreadCount++;
-	m_pMutexThread->Unlock();
+	m_mutexThread.Unlock();
 
 	debug("Entering Thread-func");
 
@@ -226,9 +283,9 @@ void* Thread::thread_handler(void* pObject)
 		delete pThread;
 	}
 
-	m_pMutexThread->Lock();
+	m_mutexThread.Lock();
 	m_iThreadCount--;
-	m_pMutexThread->Unlock();
+	m_mutexThread.Unlock();
 
 #ifndef WIN32
 	return NULL;
@@ -237,8 +294,8 @@ void* Thread::thread_handler(void* pObject)
 
 int Thread::GetThreadCount()
 {
-	m_pMutexThread->Lock();
+	m_mutexThread.Lock();
 	int iThreadCount = m_iThreadCount;
-	m_pMutexThread->Unlock();
+	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-2015 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,12 +48,38 @@ public:
 	void					Unlock();
 };
 
+
+class Semaphore
+{
+private:
+#ifdef WIN32
+	HANDLE					m_semObj;
+#else
+	sem_t					m_semObj;
+#endif
+	
+public:
+							Semaphore();
+							Semaphore(int iValue);
+							~Semaphore();
+	void					Post();
+	bool					Wait();
+	bool					TryWait();
+	bool					TimedWait(int iMSec);
+	bool					IsLocked();
+};
+
+
 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;
@@ -56,14 +91,11 @@ private:
 #endif
 
 public:
-							Thread();
+	Thread();
 	virtual 				~Thread();
-	static void				Init();
-	static void				Final();
 
 	virtual void 			Start();
 	virtual void 			Stop();
-	virtual void 			Resume();
 	bool					Kill();
 
 	bool 					IsStopped() { return m_bStopped; };
@@ -73,6 +105,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.h

@@ -0,0 +1,143 @@
+/*
+ *  This file is 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>
+#include <sys/timeb.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();
+};
+
+class Util 
+{
+public:
+
+	static char* BaseFileName(const char* filename);
+	static void NormalizePathSeparators(char* szPath);
+	static bool LoadFileIntoBuffer(const char* szFileName, char** pBuffer, int* pBufferLength);
+	static bool SetFileSize(const char* szFilename, int iSize);
+	static void MakeValidFilename(char* szFilename, char cReplaceChar, bool bAllowSlashes);
+	static bool MoveFile(const char* szSrcFilename, const char* szDstFilename);
+	static bool FileExists(const char* szFilename);
+	static bool DirectoryExists(const char* szDirFilename);
+	static bool CreateDirectory(const char* szDirFilename);
+	static bool ForceDirectories(const char* szPath);
+	static long long FileSize(const char* szFilename);
+	static long long FreeDiskSize(const char* szPath);
+	static bool DirEmpty(const char* szDirFilename);
+
+	static long long JoinInt64(unsigned long Hi, unsigned long Lo);
+	static void SplitInt64(long long Int64, unsigned long* Hi, unsigned long* Lo);
+
+	/**
+	 * Int64ToFloat converts Int64 to float.
+	 * Simple (float)Int64 does not work on all compilers,
+	 * for example on ARM for NSLU2 (unslung).
+	 */
+	static float Int64ToFloat(long long Int64);
+
+	static float EqualTime(_timeval* t1, _timeval* t2);
+	static bool EmptyTime(_timeval* t);
+	static float DiffTime(_timeval* t1, _timeval* t2);
+
+	static unsigned int DecodeBase64(char* szInputBuffer, int iInputBufferLength, char* szOutputBuffer);
+
+	/*
+	 * Encodes string to be used as content of xml-tag.
+	 * Returns new string allocated with malloc, it need to be freed by caller.
+	 */
+	static char* XmlEncode(const char* raw);
+
+	/*
+	 * Decodes string from xml.
+	 * The string is decoded on the place overwriting the content of raw-data.
+	 */
+	static void XmlDecode(char* raw);
+
+	/*
+	 * Returns pointer to tag-content and length of content in iValueLength
+	 * The returned pointer points to the part of source-string, no additional strings are allocated.
+	 */
+	static const char* XmlFindTag(const char* szXml, const char* szTag, int* pValueLength);
+
+	/*
+	 * Parses tag-content into szValueBuf.
+	 */
+	static bool XmlParseTagValue(const char* szXml, const char* szTag, char* szValueBuf, int iValueBufSize, const char** pTagEnd);
+
+	/*
+	 * Creates JSON-string by replace the certain characters with escape-sequences.
+	 * Returns new string allocated with malloc, it need to be freed by caller.
+	 */
+	static char* JsonEncode(const char* raw);
+
+	/*
+	 * Decodes JSON-string.
+	 * The string is decoded on the place overwriting the content of raw-data.
+	 */
+	static void JsonDecode(char* raw);
+
+	/*
+	 * Returns pointer to field-content and length of content in iValueLength
+	 * The returned pointer points to the part of source-string, no additional strings are allocated.
+	 */
+	static const char* JsonFindField(const char* szJsonText, const char* szFieldName, int* pValueLength);
+
+	/*
+	 * Returns pointer to field-content and length of content in iValueLength
+	 * The returned pointer points to the part of source-string, no additional strings are allocated.
+	 */
+	static const char* JsonNextValue(const char* szJsonText, int* pValueLength);
+};
+
+#endif

XmlRpc.h

@@ -1,7 +1,7 @@
 /*
  *  This file is part of nzbget
  *
- *  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
@@ -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$
@@ -27,7 +27,19 @@
 #define XMLRPC_H
 
 #include "Connection.h"
-#include "Util.h"
+
+class StringBuilder
+{
+private:
+	char*				m_szBuffer;
+	int					m_iBufferSize;
+	int					m_iUsedSize;
+public:
+						StringBuilder();
+						~StringBuilder();
+	void				Append(const char* szStr);
+	const char*			GetBuffer() { return m_szBuffer; }
+};
 
 class XmlCommand;
 
@@ -38,8 +50,7 @@ public:
 	{
 		rpUndefined,
 		rpXmlRpc,
-		rpJsonRpc,
-		rpJsonPRpc
+		rpJsonRpc
 	};
 
 	enum EHttpMethod
@@ -48,38 +59,28 @@ public:
 		hmGet
 	};
 
-	enum EUserAccess
-	{
-		uaControl,
-		uaRestricted,
-		uaAdd
-	};
-
 private:
+	Connection*			m_pConnection;
+	const char*			m_szClientIP;
 	char*				m_szRequest;
-	const char*			m_szContentType;
 	ERpcProtocol		m_eProtocol;
 	EHttpMethod			m_eHttpMethod;
-	EUserAccess			m_eUserAccess;
 	char*				m_szUrl;
-	StringBuilder		m_cResponse;
 
 	void				Dispatch();
+	void				SendResponse(const char* szResponse, bool bFault);
 	XmlCommand*			CreateCommand(const char* szMethodName);
 	void				MutliCall();
-	void				BuildResponse(const char* szResponse, const char* szCallbackFunc, bool bFault, const char* szRequestId);
 
 public:
 						XmlRpcProcessor();
 						~XmlRpcProcessor();
 	void				Execute();
+	void				SetConnection(Connection* pConnection) { m_pConnection = pConnection; }
+	void				SetProtocol(ERpcProtocol eProtocol) { m_eProtocol = eProtocol; }
 	void				SetHttpMethod(EHttpMethod eHttpMethod) { m_eHttpMethod = eHttpMethod; }
-	void				SetUserAccess(EUserAccess eUserAccess) { m_eUserAccess = eUserAccess; }
 	void				SetUrl(const char* szUrl);
-	void				SetRequest(char* szRequest) { m_szRequest = szRequest; }
-	const char*			GetResponse() { return m_cResponse.GetBuffer(); }
-	const char*			GetContentType() { return m_szContentType; }
-	static bool			IsRpcRequest(const char* szUrl);
+	void				SetClientIP(const char* szClientIP) { m_szClientIP = szClientIP; }
 };
 
 class XmlCommand
@@ -87,29 +88,20 @@ class XmlCommand
 protected:
 	char*				m_szRequest;
 	char*				m_szRequestPtr;
-	char*				m_szCallbackFunc;
 	StringBuilder		m_StringBuilder;
 	bool				m_bFault;
 	XmlRpcProcessor::ERpcProtocol	m_eProtocol;
 	XmlRpcProcessor::EHttpMethod	m_eHttpMethod;
-	XmlRpcProcessor::EUserAccess	m_eUserAccess;
 
-	void				BuildErrorResponse(int iErrCode, const char* szErrText, ...);
+	void				BuildErrorResponse(int iErrCode, const char* szErrText);
 	void				BuildBoolResponse(bool bOK);
-	void				BuildIntResponse(int iValue);
 	void				AppendResponse(const char* szPart);
-	void				AppendFmtResponse(const char* szFormat, ...);
-	void				AppendCondResponse(const char* szPart, bool bCond);
-	void				OptimizeResponse(int iRecordCount);
-	bool				IsJson();
-	bool				CheckSafeMethod();
+	bool				IsJson() { return m_eProtocol == XmlRpcProcessor::rpJsonRpc; }
 	bool				NextParamAsInt(int* iValue);
 	bool				NextParamAsBool(bool* bValue);
 	bool				NextParamAsStr(char** szValueBuf);
-	char*				XmlNextValue(char* szXml, const char* szTag, int* pValueLength);
 	const char*			BoolToStr(bool bValue);
 	char*				EncodeStr(const char* szStr);
-	void				DecodeStr(char* szStr);
 
 public:
 						XmlCommand();
@@ -119,10 +111,103 @@ public:
 	void				SetRequest(char* szRequest) { m_szRequest = szRequest; m_szRequestPtr = m_szRequest; }
 	void				SetProtocol(XmlRpcProcessor::ERpcProtocol eProtocol) { m_eProtocol = eProtocol; }
 	void				SetHttpMethod(XmlRpcProcessor::EHttpMethod eHttpMethod) { m_eHttpMethod = eHttpMethod; }
-	void				SetUserAccess(XmlRpcProcessor::EUserAccess eUserAccess) { m_eUserAccess = eUserAccess; }
 	const char*			GetResponse() { return m_StringBuilder.GetBuffer(); }
-	const char*			GetCallbackFunc() { return m_szCallbackFunc; }
 	bool				GetFault() { return m_bFault; }
 };
 
+class ErrorXmlCommand: public XmlCommand
+{
+private:
+	int					m_iErrCode;
+	const char*			m_szErrText;
+
+public:
+						ErrorXmlCommand(int iErrCode, const char* szErrText);
+	virtual void		Execute();
+};
+
+class PauseXmlCommand: public XmlCommand
+{
+public:
+	virtual void		Execute();
+};
+
+class UnPauseXmlCommand: public XmlCommand
+{
+public:
+	virtual void		Execute();
+};
+
+class ShutdownXmlCommand: public XmlCommand
+{
+public:
+	virtual void		Execute();
+};
+
+class VersionXmlCommand: public XmlCommand
+{
+public:
+	virtual void		Execute();
+};
+
+class DumpDebugXmlCommand: public XmlCommand
+{
+public:
+	virtual void		Execute();
+};
+
+class SetDownloadRateXmlCommand: public XmlCommand
+{
+public:
+	virtual void		Execute();
+};
+
+class StatusXmlCommand: public XmlCommand
+{
+public:
+	virtual void		Execute();
+};
+
+class LogXmlCommand: public XmlCommand
+{
+public:
+	virtual void		Execute();
+};
+
+class ListFilesXmlCommand: public XmlCommand
+{
+public:
+	virtual void		Execute();
+};
+
+class ListGroupsXmlCommand: public XmlCommand
+{
+public:
+	virtual void		Execute();
+};
+
+class EditQueueXmlCommand: public XmlCommand
+{
+public:
+	virtual void		Execute();
+};
+
+class DownloadXmlCommand: public XmlCommand
+{
+public:
+	virtual void		Execute();
+};
+
+class PostQueueXmlCommand: public XmlCommand
+{
+public:
+	virtual void		Execute();
+};
+
+class WriteLogXmlCommand: public XmlCommand
+{
+public:
+	virtual void		Execute();
+};
+
 #endif

aclocal.m4

@@ -1,7 +1,7 @@
-# generated automatically by aclocal 1.9.6 -*- Autoconf -*-
+# generated automatically by aclocal 1.10 -*- Autoconf -*-
 
 # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
-# 2005  Free Software Foundation, Inc.
+# 2005, 2006  Free Software Foundation, Inc.
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
 # with or without modifications, as long as this notice is preserved.
@@ -11,6 +11,11 @@
 # even the implied warranty of MERCHANTABILITY or FITNESS FOR A
 # PARTICULAR PURPOSE.
 
+m4_if(m4_PACKAGE_VERSION, [2.61],,
+[m4_fatal([this file was generated for autoconf 2.61.
+You have another version of autoconf.  If you want to use that,
+you should regenerate the build system entirely.], [63])])
+
 # pkg.m4 - Macros to locate and utilise pkg-config.            -*- Autoconf -*-
 # 
 # Copyright © 2004 Scott James Remnant <scott@netsplit.com>.
@@ -159,7 +164,7 @@ path to pkg-config.
 
 _PKG_TEXT
 
-To get pkg-config, see <http://pkg-config.freedesktop.org/>.])],
+To get pkg-config, see <http://www.freedesktop.org/software/pkgconfig>.])],
 		[$4])
 else
 	$1[]_CFLAGS=$pkg_cv_[]$1[]_CFLAGS
@@ -169,7 +174,7 @@ else
 fi[]dnl
 ])# PKG_CHECK_MODULES
 
-# Copyright (C) 2002, 2003, 2005  Free Software Foundation, Inc.
+# Copyright (C) 2002, 2003, 2005, 2006  Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -179,14 +184,29 @@ fi[]dnl
 # ----------------------------
 # Automake X.Y traces this macro to ensure aclocal.m4 has been
 # generated from the m4 files accompanying Automake X.Y.
-AC_DEFUN([AM_AUTOMAKE_VERSION], [am__api_version="1.9"])
+# (This private macro should not be called outside this file.)
+AC_DEFUN([AM_AUTOMAKE_VERSION],
+[am__api_version='1.10'
+dnl Some users find AM_AUTOMAKE_VERSION and mistake it for a way to
+dnl require some minimum version.  Point them to the right macro.
+m4_if([$1], [1.10], [],
+      [AC_FATAL([Do not call $0, use AM_INIT_AUTOMAKE([$1]).])])dnl
+])
+
+# _AM_AUTOCONF_VERSION(VERSION)
+# -----------------------------
+# aclocal traces this macro to find the Autoconf version.
+# This is a private macro too.  Using m4_define simplifies
+# the logic in aclocal, which can simply ignore this definition.
+m4_define([_AM_AUTOCONF_VERSION], [])
 
 # AM_SET_CURRENT_AUTOMAKE_VERSION
 # -------------------------------
-# Call AM_AUTOMAKE_VERSION so it can be traced.
+# Call AM_AUTOMAKE_VERSION and AM_AUTOMAKE_VERSION so they 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.10])dnl
+_AM_AUTOCONF_VERSION(m4_PACKAGE_VERSION)])
 
 # AM_AUX_DIR_EXPAND                                         -*- Autoconf -*-
 
@@ -243,14 +263,14 @@ am_aux_dir=`cd $ac_aux_dir && pwd`
 
 # AM_CONDITIONAL                                            -*- Autoconf -*-
 
-# Copyright (C) 1997, 2000, 2001, 2003, 2004, 2005
+# Copyright (C) 1997, 2000, 2001, 2003, 2004, 2005, 2006
 # Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
 # with or without modifications, as long as this notice is preserved.
 
-# serial 7
+# serial 8
 
 # AM_CONDITIONAL(NAME, SHELL-CONDITION)
 # -------------------------------------
@@ -259,8 +279,10 @@ AC_DEFUN([AM_CONDITIONAL],
 [AC_PREREQ(2.52)dnl
  ifelse([$1], [TRUE],  [AC_FATAL([$0: invalid condition: $1])],
 	[$1], [FALSE], [AC_FATAL([$0: invalid condition: $1])])dnl
-AC_SUBST([$1_TRUE])
-AC_SUBST([$1_FALSE])
+AC_SUBST([$1_TRUE])dnl
+AC_SUBST([$1_FALSE])dnl
+_AM_SUBST_NOTMAKE([$1_TRUE])dnl
+_AM_SUBST_NOTMAKE([$1_FALSE])dnl
 if $2; then
   $1_TRUE=
   $1_FALSE='#'
@@ -274,15 +296,14 @@ AC_CONFIG_COMMANDS_PRE(
 Usually this means the macro was only invoked conditionally.]])
 fi])])
 
-
-# Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005
+# Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
 # Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
 # with or without modifications, as long as this notice is preserved.
 
-# serial 8
+# serial 9
 
 # There are a few dirty hacks below to avoid letting `AC_PROG_CC' be
 # written in clear, in which case automake, when reading aclocal.m4,
@@ -310,6 +331,7 @@ AC_REQUIRE([AM_DEP_TRACK])dnl
 ifelse([$1], CC,   [depcc="$CC"   am_compiler_list=],
        [$1], CXX,  [depcc="$CXX"  am_compiler_list=],
        [$1], OBJC, [depcc="$OBJC" am_compiler_list='gcc3 gcc'],
+       [$1], UPC,  [depcc="$UPC"  am_compiler_list=],
        [$1], GCJ,  [depcc="$GCJ"  am_compiler_list='gcc3 gcc'],
                    [depcc="$$1"   am_compiler_list=])
 
@@ -375,6 +397,7 @@ AC_CACHE_CHECK([dependency style of $depcc],
        depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
        $SHELL ./depcomp $depcc -c -o sub/conftest.${OBJEXT-o} sub/conftest.c \
          >/dev/null 2>conftest.err &&
+       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
        grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
        grep sub/conftest.${OBJEXT-o} sub/conftest.Po > /dev/null 2>&1 &&
        ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
@@ -427,7 +450,8 @@ if test "x$enable_dependency_tracking" != xno; then
   AMDEPBACKSLASH='\'
 fi
 AM_CONDITIONAL([AMDEP], [test "x$enable_dependency_tracking" != xno])
-AC_SUBST([AMDEPBACKSLASH])
+AC_SUBST([AMDEPBACKSLASH])dnl
+_AM_SUBST_NOTMAKE([AMDEPBACKSLASH])dnl
 ])
 
 # Generate code to set up dependency tracking.              -*- Autoconf -*-
@@ -452,8 +476,9 @@ AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS],
   # some people rename them; so instead we look at the file content.
   # Grep'ing the first line is not enough: some people post-process
   # each Makefile.in and add a new line on top of each file to say so.
-  # So let's grep whole file.
-  if grep '^#.*generated by automake' $mf > /dev/null 2>&1; then
+  # Grep'ing the whole file is not good either: AIX grep has a line
+  # limit of 2048, but all sed's we know have understand at least 4000.
+  if sed 10q "$mf" | grep '^#.*generated by automake' > /dev/null 2>&1; then
     dirpart=`AS_DIRNAME("$mf")`
   else
     continue
@@ -500,8 +525,8 @@ AC_DEFUN([AM_OUTPUT_DEPENDENCY_COMMANDS],
 
 # Do all the work for Automake.                             -*- Autoconf -*-
 
-# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
-# Free Software Foundation, Inc.
+# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
+# 2005, 2006 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -524,16 +549,20 @@ AC_DEFUN([AM_OUTPUT_DEPENDENCY_COMMANDS],
 # arguments mandatory, and then we can depend on a new Autoconf
 # release and drop the old call support.
 AC_DEFUN([AM_INIT_AUTOMAKE],
-[AC_PREREQ([2.58])dnl
+[AC_PREREQ([2.60])dnl
 dnl Autoconf wants to disallow AM_ names.  We explicitly allow
 dnl the ones we care about.
 m4_pattern_allow([^AM_[A-Z]+FLAGS$])dnl
 AC_REQUIRE([AM_SET_CURRENT_AUTOMAKE_VERSION])dnl
 AC_REQUIRE([AC_PROG_INSTALL])dnl
-# test to see if srcdir already configured
-if test "`cd $srcdir && pwd`" != "`pwd`" &&
-   test -f $srcdir/config.status; then
-  AC_MSG_ERROR([source directory already configured; run "make distclean" there first])
+if test "`cd $srcdir && pwd`" != "`pwd`"; then
+  # Use -I$(srcdir) only when $(srcdir) != ., so that make's output
+  # is not polluted with repeated "-I."
+  AC_SUBST([am__isrc], [' -I$(srcdir)'])_AM_SUBST_NOTMAKE([am__isrc])dnl
+  # test to see if srcdir already configured
+  if test -f $srcdir/config.status; then
+    AC_MSG_ERROR([source directory already configured; run "make distclean" there first])
+  fi
 fi
 
 # test whether we have cygpath
@@ -553,6 +582,9 @@ m4_ifval([$2],
  AC_SUBST([PACKAGE], [$1])dnl
  AC_SUBST([VERSION], [$2])],
 [_AM_SET_OPTIONS([$1])dnl
+dnl Diagnose old-style AC_INIT with new-style AM_AUTOMAKE_INIT.
+m4_if(m4_ifdef([AC_PACKAGE_NAME], 1)m4_ifdef([AC_PACKAGE_VERSION], 1), 11,,
+  [m4_fatal([AC_INIT should be called with package and version arguments])])dnl
  AC_SUBST([PACKAGE], ['AC_PACKAGE_TARNAME'])dnl
  AC_SUBST([VERSION], ['AC_PACKAGE_VERSION'])])dnl
 
@@ -588,6 +620,10 @@ AC_PROVIDE_IFELSE([AC_PROG_CXX],
                   [_AM_DEPENDENCIES(CXX)],
                   [define([AC_PROG_CXX],
                           defn([AC_PROG_CXX])[_AM_DEPENDENCIES(CXX)])])dnl
+AC_PROVIDE_IFELSE([AC_PROG_OBJC],
+                  [_AM_DEPENDENCIES(OBJC)],
+                  [define([AC_PROG_OBJC],
+                          defn([AC_PROG_OBJC])[_AM_DEPENDENCIES(OBJC)])])dnl
 ])
 ])
 
@@ -623,7 +659,7 @@ echo "timestamp for $1" >`AS_DIRNAME([$1])`/stamp-h[]$_am_stamp_count])
 # Define $install_sh.
 AC_DEFUN([AM_PROG_INSTALL_SH],
 [AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
-install_sh=${install_sh-"$am_aux_dir/install-sh"}
+install_sh=${install_sh-"\$(SHELL) $am_aux_dir/install-sh"}
 AC_SUBST(install_sh)])
 
 # Copyright (C) 2003, 2005  Free Software Foundation, Inc.
@@ -701,14 +737,14 @@ rm -f confinc confmf
 
 # Fake the existence of programs that GNU maintainers use.  -*- Autoconf -*-
 
-# Copyright (C) 1997, 1999, 2000, 2001, 2003, 2005
+# Copyright (C) 1997, 1999, 2000, 2001, 2003, 2004, 2005
 # Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
 # with or without modifications, as long as this notice is preserved.
 
-# serial 4
+# serial 5
 
 # AM_MISSING_PROG(NAME, PROGRAM)
 # ------------------------------
@@ -724,6 +760,7 @@ AC_SUBST($1)])
 # If it does, set am_missing_run to use it, otherwise, to nothing.
 AC_DEFUN([AM_MISSING_HAS_RUN],
 [AC_REQUIRE([AM_AUX_DIR_EXPAND])dnl
+AC_REQUIRE_AUX_FILE([missing])dnl
 test x"${MISSING+set}" = xset || MISSING="\${SHELL} $am_aux_dir/missing"
 # Use eval to expand $SHELL
 if eval "$MISSING --run true"; then
@@ -734,7 +771,7 @@ else
 fi
 ])
 
-# Copyright (C) 2003, 2004, 2005  Free Software Foundation, Inc.
+# Copyright (C) 2003, 2004, 2005, 2006  Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -742,60 +779,23 @@ fi
 
 # AM_PROG_MKDIR_P
 # ---------------
-# Check whether `mkdir -p' is supported, fallback to mkinstalldirs otherwise.
-#
-# Automake 1.8 used `mkdir -m 0755 -p --' to ensure that directories
-# created by `make install' are always world readable, even if the
-# installer happens to have an overly restrictive umask (e.g. 077).
-# This was a mistake.  There are at least two reasons why we must not
-# use `-m 0755':
-#   - it causes special bits like SGID to be ignored,
-#   - it may be too restrictive (some setups expect 775 directories).
-#
-# Do not use -m 0755 and let people choose whatever they expect by
-# setting umask.
-#
-# We cannot accept any implementation of `mkdir' that recognizes `-p'.
-# Some implementations (such as Solaris 8's) are not thread-safe: if a
-# parallel make tries to run `mkdir -p a/b' and `mkdir -p a/c'
-# concurrently, both version can detect that a/ is missing, but only
-# one can create it and the other will error out.  Consequently we
-# restrict ourselves to GNU make (using the --version option ensures
-# this.)
+# Check for `mkdir -p'.
 AC_DEFUN([AM_PROG_MKDIR_P],
-[if mkdir -p --version . >/dev/null 2>&1 && test ! -d ./--version; then
-  # We used to keeping the `.' as first argument, in order to
-  # allow $(mkdir_p) to be used without argument.  As in
-  #   $(mkdir_p) $(somedir)
-  # where $(somedir) is conditionally defined.  However this is wrong
-  # for two reasons:
-  #  1. if the package is installed by a user who cannot write `.'
-  #     make install will fail,
-  #  2. the above comment should most certainly read
-  #     $(mkdir_p) $(DESTDIR)$(somedir)
-  #     so it does not work when $(somedir) is undefined and
-  #     $(DESTDIR) is not.
-  #  To support the latter case, we have to write
-  #     test -z "$(somedir)" || $(mkdir_p) $(DESTDIR)$(somedir),
-  #  so the `.' trick is pointless.
-  mkdir_p='mkdir -p --'
-else
-  # On NextStep and OpenStep, the `mkdir' command does not
-  # recognize any option.  It will interpret all options as
-  # directories to create, and then abort because `.' already
-  # exists.
-  for d in ./-p ./--version;
-  do
-    test -d $d && rmdir $d
-  done
-  # $(mkinstalldirs) is defined by Automake if mkinstalldirs exists.
-  if test -f "$ac_aux_dir/mkinstalldirs"; then
-    mkdir_p='$(mkinstalldirs)'
-  else
-    mkdir_p='$(install_sh) -d'
-  fi
-fi
-AC_SUBST([mkdir_p])])
+[AC_PREREQ([2.60])dnl
+AC_REQUIRE([AC_PROG_MKDIR_P])dnl
+dnl Automake 1.8 to 1.9.6 used to define mkdir_p.  We now use MKDIR_P,
+dnl while keeping a definition of mkdir_p for backward compatibility.
+dnl @MKDIR_P@ is magic: AC_OUTPUT adjusts its value for each Makefile.
+dnl However we cannot define mkdir_p as $(MKDIR_P) for the sake of
+dnl Makefile.ins that do not define MKDIR_P, so we do our own
+dnl adjustment using top_builddir (which is defined more often than
+dnl MKDIR_P).
+AC_SUBST([mkdir_p], ["$MKDIR_P"])dnl
+case $mkdir_p in
+  [[\\/$]]* | ?:[[\\/]]*) ;;
+  */*) mkdir_p="\$(top_builddir)/$mkdir_p" ;;
+esac
+])
 
 # Helper functions for option handling.                     -*- Autoconf -*-
 
@@ -907,9 +907,21 @@ dnl Don't test for $cross_compiling = yes, because it might be `maybe'.
 if test "$cross_compiling" != no; then
   AC_CHECK_TOOL([STRIP], [strip], :)
 fi
-INSTALL_STRIP_PROGRAM="\${SHELL} \$(install_sh) -c -s"
+INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s"
 AC_SUBST([INSTALL_STRIP_PROGRAM])])
 
+# Copyright (C) 2006  Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# _AM_SUBST_NOTMAKE(VARIABLE)
+# ---------------------------
+# Prevent Automake from outputing VARIABLE = @VARIABLE@ in Makefile.in.
+# This macro is traced by Automake.
+AC_DEFUN([_AM_SUBST_NOTMAKE])
+
 # Check how to create a tarball.                            -*- Autoconf -*-
 
 # Copyright (C) 2004, 2005  Free Software Foundation, Inc.

config.h.in

@@ -3,25 +3,15 @@
 /* Define to 1 to include debug-code */
 #undef DEBUG
 
-/* Define to 1 if deleting of files during reading of directory is not
-   properly supported by OS */
-#undef DIRBROWSER_SNAPSHOT
-
 /* 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 par-verification and repair */
+/* 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 enable unit and integration tests */
-#undef ENABLE_TESTS
-
 /* Define to the name of macro which returns the name of function being
    compiled */
 #undef FUNCTION_MACRO_NAME
@@ -38,43 +28,6 @@
 /* Define to 1 if you have the <curses.h> header file. */
 #undef HAVE_CURSES_H
 
-/* Define to 1 if you have the <dirent.h> header file, and it defines `DIR'.
-   */
-#undef HAVE_DIRENT_H
-
-/* Define to 1 if you have the <endian.h> header file. */
-#undef HAVE_ENDIAN_H
-
-/* Define to 1 if fdatasync is supported */
-#undef HAVE_FDATASYNC
-
-/* Define to 1 if fseeko (and presumably ftello) exists and is declared. */
-#undef HAVE_FSEEKO
-
-/* Define to 1 if F_FULLFSYNC is supported */
-#undef HAVE_FULLFSYNC
-
-/* 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
-
-/* Define to 1 if gethostbyname_r takes 6 arguments */
-#undef HAVE_GETHOSTBYNAME_R_6
-
-/* Define to 1 if you have the `getopt' function. */
-#undef HAVE_GETOPT
-
-/* Define to 1 if you have the <getopt.h> header file. */
-#undef HAVE_GETOPT_H
-
 /* Define to 1 if getopt_long is supported */
 #undef HAVE_GETOPT_LONG
 
@@ -84,9 +37,6 @@
 /* Define to 1 to use GnuTLS library for TLS/SSL-support. */
 #undef HAVE_LIBGNUTLS
 
-/* Define to 1 if you have the `memcpy' function. */
-#undef HAVE_MEMCPY
-
 /* Define to 1 if you have the <memory.h> header file. */
 #undef HAVE_MEMORY_H
 
@@ -96,56 +46,24 @@
 /* Define to 1 if you have the <ncurses/ncurses.h> header file. */
 #undef HAVE_NCURSES_NCURSES_H
 
-/* Define to 1 if you have the <ndir.h> header file, and it defines `DIR'. */
-#undef HAVE_NDIR_H
-
 /* Define to 1 to use OpenSSL library for TLS/SSL-support. */
 #undef HAVE_OPENSSL
 
-/* Define to 1 if you have the <regex.h> header file. */
-#undef HAVE_REGEX_H
-
-/* Define to 1 if _SC_NPROCESSORS_ONLN is present in unistd.h */
-#undef HAVE_SC_NPROCESSORS_ONLN
-
-/* Define to 1 if stdbool.h conforms to C99. */
-#undef HAVE_STDBOOL_H
+/* Define to 1 if stat64 is supported */
+#undef HAVE_STAT64
 
 /* Define to 1 if you have the <stdint.h> header file. */
 #undef HAVE_STDINT_H
 
-/* Define to 1 if you have the <stdio.h> header file. */
-#undef HAVE_STDIO_H
-
 /* Define to 1 if you have the <stdlib.h> header file. */
 #undef HAVE_STDLIB_H
 
-/* Define to 1 if you have the `strcasecmp' function. */
-#undef HAVE_STRCASECMP
-
-/* Define to 1 if you have the `strchr' function. */
-#undef HAVE_STRCHR
-
-/* Define to 1 if you have the `stricmp' function. */
-#undef HAVE_STRICMP
-
 /* Define to 1 if you have the <strings.h> header file. */
 #undef HAVE_STRINGS_H
 
 /* Define to 1 if you have the <string.h> header file. */
 #undef HAVE_STRING_H
 
-/* Define to 1 if you have the <sys/dir.h> header file, and it defines `DIR'.
-   */
-#undef HAVE_SYS_DIR_H
-
-/* Define to 1 if you have the <sys/ndir.h> header file, and it defines `DIR'.
-   */
-#undef HAVE_SYS_NDIR_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
 
@@ -158,12 +76,6 @@
 /* Define to 1 if variadic macros are supported */
 #undef HAVE_VARIADIC_MACROS
 
-/* Define to 1 if the system has the type `_Bool'. */
-#undef HAVE__BOOL
-
-/* Define to 1 to exclude debug-code */
-#undef NDEBUG
-
 /* Name of package */
 #undef PACKAGE
 
@@ -182,39 +94,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
-
-/* Define to 1 if your processor stores words with the most significant byte
-   first (like Motorola and SPARC, unlike Intel and VAX). */
-#undef WORDS_BIGENDIAN
-
-/* Number of bits in a file offset, on hosts where this is settable. */
-#undef _FILE_OFFSET_BITS
-
-/* Define to 1 to make fseeko visible on some hosts (e.g. glibc 2.2). */
-#undef _LARGEFILE_SOURCE
-
-/* Define for large files, on AIX-style hosts. */
-#undef _LARGE_FILES
-
-/* Define to empty if `const' does not conform to ANSI C. */
-#undef const
-
-/* Define to `__inline__' or `__inline' if that's what the C compiler
-   calls it, or to nothing if 'inline' is not supported under any name.  */
-#ifndef __cplusplus
-#undef inline
-#endif
-
-/* Define to `unsigned int' if <sys/types.h> does not define. */
-#undef size_t

configure.ac

@@ -1,40 +1,33 @@
-#
-#  This file is part of nzbget
-#
-# Copyright (C) 2008-2015 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.
-#
-#
-
 #                                               -*- Autoconf -*-
 # Process this file with autoconf to produce a configure script.
 
 AC_PREREQ(2.59)
-AC_INIT(nzbget, 16.3, hugbug@users.sourceforge.net)
-AC_CONFIG_AUX_DIR(posix)
-AM_INIT_AUTOMAKE([foreign])
-AC_CONFIG_SRCDIR([daemon/main/nzbget.cpp])
+AC_INIT(nzbget, 0.5.1, hugbug@users.sourceforge.net)
+AM_INIT_AUTOMAKE(nzbget, 0.5.1)
+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"
+    ;;
+  *-linux*)
+    LIBPREF1="/usr"
+    ;;
+  *-freebsd*)
+    LIBPREF1="/usr/local"
+    ;;
+  *-solaris*)
+    LIBPREF1="/usr"
+    ;;
+esac
+
+
 if test "$LIBPREF" = ""; then
-	LIBPREF="/usr"
+	LIBPREF="$LIBPREF1"
 fi
 
 
@@ -42,23 +35,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
@@ -73,21 +73,16 @@ dnl
 dnl Getopt
 dnl
 AC_CHECK_FUNC(getopt_long,
-	[AC_DEFINE([HAVE_GETOPT_LONG], 1, [Define to 1 if getopt_long is supported])],)
+	[AC_DEFINE([HAVE_GETOPT_LONG], 1, [Define to 1 if getopt_long is supported])],
+	[AC_LIBOBJ(getopt) AC_LIBOBJ(getopt1)])
 
 
 dnl
-dnl fsync
+dnl stat64
 dnl
-AC_CHECK_FUNC(fdatasync,
-	[AC_DEFINE([HAVE_FDATASYNC], 1, [Define to 1 if fdatasync is supported])],)
-AC_CHECK_DECL(F_FULLFSYNC,
-	[AC_DEFINE([HAVE_FULLFSYNC], 1, [Define to 1 if F_FULLFSYNC is supported])],,[#include <fcntl.h>])
-
-dnl
-dnl use 64-Bits for file sizes
-dnl
-AC_SYS_LARGEFILE
+AC_CHECK_FUNC(stat64,
+	[AC_DEFINE([HAVE_STAT64], 1, [Define to 1 if stat64 is supported])],
+	[AC_LIBOBJ(stat64)])
 
 
 dnl
@@ -98,7 +93,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
@@ -112,143 +106,54 @@ 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 for __FUNCTION__ or __func__ macro
 dnl
-AC_CHECK_FUNC(getaddrinfo,
-	FOUND="yes"
-	[AC_DEFINE([HAVE_GETADDRINFO], 1, [Define to 1 if getaddrinfo is supported])]
-	AC_SEARCH_LIBS([getaddrinfo], [nsl]),
-	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_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
-
-
-dnl
-dnl Determine what socket length (socklen_t) data type is
-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])
-
-
-dnl
-dnl Dir-browser's snapshot
-dnl
-AC_MSG_CHECKING(whether dir-browser snapshot workaround is needed)
-if test "$target_vendor" == "apple"; then
-	AC_MSG_RESULT([[yes]])
-	AC_DEFINE([DIRBROWSER_SNAPSHOT], 1, [Define to 1 if deleting of files during reading of directory is not properly supported by OS])
-else
-	AC_MSG_RESULT([[no]])
+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 check cpu cores via sysconf
-dnl
-AC_MSG_CHECKING(for cpu cores via sysconf)
-AC_TRY_COMPILE(
-	[#include <unistd.h>],
-	[ int a = _SC_NPROCESSORS_ONLN; ],
-	FOUND="yes"
-	AC_MSG_RESULT([[yes]])
-	AC_DEFINE([HAVE_SC_NPROCESSORS_ONLN], 1, [Define to 1 if _SC_NPROCESSORS_ONLN is present in unistd.h]),
-	FOUND="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"])
+      [AS_HELP_STRING([--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 were not found."))
 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"],
-		AC_MSG_ERROR("libxml2 library not found"))
-fi
-AC_CHECK_HEADER(libxml/tree.h,,
-	AC_MSG_ERROR("libxml2 header files not found"))
+	[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
@@ -257,8 +162,8 @@ 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] )
+	[ USECURSES=$enableval ],
+	[ USECURSES=yes] )
 AC_MSG_RESULT($USECURSES)
 if test "$USECURSES" = "yes"; then
 	INCVAL="${LIBPREF}/include"
@@ -267,6 +172,7 @@ if test "$USECURSES" = "yes"; then
 		[AS_HELP_STRING([--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])],
 		[LIBVAL="$withval"])
@@ -289,7 +195,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]))
@@ -299,37 +205,75 @@ fi
 
 
 dnl
-dnl Use par-checking. Deafult: yes.
+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])],
+	[AS_HELP_STRING([--disable-parcheck], [do not include par-check/-repair-support (removes dependency from libpar2- and libsigc-libraries)])],
 	[ ENABLEPARCHECK=$enableval ],
 	[ ENABLEPARCHECK=yes] )
 AC_MSG_RESULT($ENABLEPARCHECK)
 if test "$ENABLEPARCHECK" = "yes"; then
-	dnl PAR2 checks. 
+
 	dnl 
-	dnl Checks for header files.
-	AC_HEADER_DIRENT
-	AC_HEADER_STDBOOL
-	AC_HEADER_STDC
-	AC_CHECK_HEADERS([stdio.h] [endian.h] [getopt.h])
-	dnl Checks for typedefs, structures, and compiler characteristics.
-	AC_TYPE_SIZE_T
-	AC_C_BIGENDIAN
-	AC_C_CONST
-	AC_C_INLINE
-	AC_FUNC_FSEEKO
-	dnl Checks for library functions.
-	AC_FUNC_MEMCMP
-	AC_CHECK_FUNCS([stricmp] [strcasecmp])
-	AC_CHECK_FUNCS([strchr] [memcpy])
-	AC_CHECK_FUNCS([getopt])
-	AM_CONDITIONAL(WITH_PAR2, true)
+	dnl checks for libsigc++ includes and libraries (required for libpar2).
+	dnl
+
+	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,
+			[LDFLAGS="${LDFLAGS} $LIBSIGC_LIBS"]
+			[CPPFLAGS="${CPPFLAGS} $LIBSIGC_CFLAGS"])
+	fi
+
+	AC_LANG_PUSH(C++)
+	AC_CHECK_HEADER(sigc++/type_traits.h,,
+		AC_MSG_ERROR("libsigc++-2.0 header files were not found."))
+	AC_LANG_POP(C++)
+
+	dnl
+	dnl checks for libpar2 includes and libraries.
+	dnl
+	INCVAL="${LIBPREF}/include"
+	LIBVAL="${LIBPREF}/lib"
+	AC_ARG_WITH(libpar2_includes,
+		[AS_HELP_STRING([--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 were not found in $INCVAL."))
+	AC_LANG_POP(C++)
+
+	AC_ARG_WITH(libpar2_libraries,
+		[AS_HELP_STRING([--with-libpar2-libraries=DIR], [libpar2 library directory])],
+		[LIBVAL="$withval"])
+
+	LDFLAGS="${LDFLAGS} -L${LIBVAL}"
+
+	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
+
 else
-	AC_DEFINE([DISABLE_PARCHECK],1,[Define to 1 to disable par-verification and repair])
-	AM_CONDITIONAL(WITH_PAR2, false)
+	AC_DEFINE([DISABLE_PARCHECK],1,[Define to 1 to disable smart par-verification and restoration])
 fi
 
 
@@ -344,53 +288,12 @@ AC_ARG_ENABLE(tls,
 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])],
+		[AS_HELP_STRING([--with-tlslib=(GnuTLS, OpenSSL)], [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])
+		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=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"
@@ -398,45 +301,25 @@ if test "$USETLS" = "yes"; then
 			[AS_HELP_STRING([--with-libgnutls-includes=DIR], [GnuTLS include directory])],
 			[INCVAL="$withval"])
 		CPPFLAGS="${CPPFLAGS} -I${INCVAL}"
+		CFLAGS="${CFLAGS} -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)])
+			AC_MSG_ERROR([Couldn't find GnuTLS headers (gnutls.h).])
 		fi
 		if test "$FOUND" = "yes"; then
 			AC_SEARCH_LIBS([gnutls_global_init], [gnutls],
 				FOUND=yes,
 				FOUND=no)
-			if test "$FOUND" = "yes"; then
-				dnl gcrypt is optional
-				AC_MSG_CHECKING([whether gcrypt is needed])
-				AC_TRY_COMPILE(
-					[#include <gnutls/gnutls.h>]
-					[#if GNUTLS_VERSION_NUMBER <= 0x020b00]
-					[compile error]
-					[#endif],
-					[int a;],
-					AC_MSG_RESULT([no])
-					GCRYPT=no,
-					AC_MSG_RESULT([yes])
-					GCRYPT=yes)
-				if test "$GCRYPT" = "yes"; then
-					AC_CHECK_HEADER([gcrypt.h],
-						AC_SEARCH_LIBS([gcry_control], [gnutls gcrypt],
-							FOUND=yes,
-							FOUND=no),
-						FOUND=yes)
-				fi
-			fi
 			if test "$FOUND" = "no" -a "$TLSLIB" = "GnuTLS"; then
-				AC_MSG_ERROR([Couldn't find GnuTLS library])
+				AC_MSG_ERROR([Couldn't find GnuTLS library.])
 			fi
 			if test "$FOUND" = "yes"; then
 				TLSLIB="GnuTLS"
@@ -444,12 +327,46 @@ if test "$USETLS" = "yes"; then
 			fi
 		fi
 	fi
-
+	
+	if test "$TLSLIB" = "OpenSSL" -o "$TLSLIB" = ""; then
+		INCVAL="${LIBPREF}/include"
+		LIBVAL="${LIBPREF}/lib"
+		AC_ARG_WITH(openssl_includes,
+			[AS_HELP_STRING([--with-openssl-includes=DIR], [OpenSSL include directory])],
+			[INCVAL="$withval"])
+		CPPFLAGS="${CPPFLAGS} -I${INCVAL}"
+		CFLAGS="${CFLAGS} -I${INCVAL}"
+		AC_ARG_WITH(openssl_libraries,
+			[AS_HELP_STRING([--with-openssl-libraries=DIR], [OpenSSL library directory])],
+			[LIBVAL="$withval"])
+		LDFLAGS="${LDFLAGS} -L${LIBVAL}"
+	
+		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([SSL_library_init], [ssl],
+				FOUND=yes,
+				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" = ""; then
 		if test "$TLSHEADERS" = ""; then
-			AC_MSG_ERROR([Couldn't find neither OpenSSL nor GnuTLS headers (ssl.h or gnutls.h)])
+			AC_MSG_ERROR([Couldn't find neither GnuTLS nor OpenSSL headers (gnutls.h or ssl.h).])
 		else
-			AC_MSG_ERROR([Couldn't find neither OpenSSL nor GnuTLS library])
+			AC_MSG_ERROR([Couldn't find neither GnuTLS nor OpenSSL library.])
 		fi
 	fi
 else
@@ -457,53 +374,6 @@ else
 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 
@@ -512,32 +382,41 @@ AC_ARG_ENABLE(debug,
 	[AS_HELP_STRING([--enable-debug], [enable debugging])],
 	[ ENABLEDEBUG=$enableval ],
 	[ ENABLEDEBUG=no] )
+if test "$ENABLEDEBUG" = "yes"; then
+	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
+dnl Backtracing on segmentation faults
 if test "$ENABLEDEBUG" = "yes"; then
+	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 Begin of debugging code
-dnl
-
-AC_DEFINE([DEBUG],1,Define to 1 to include debug-code)
-
-
-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_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"])
 fi
 
 
@@ -555,58 +434,15 @@ 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 Substitute flags.
+AC_SUBST(CFLAGS)
+AC_SUBST(CPPFLAGS)
+AC_SUBST(LDFLAGS)
+AC_SUBST(CXXFLAGS)
+AC_SUBST(TAR)
+AC_SUBST(AR)
+AC_SUBST(ADDSRCS)
 
 
-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
-else
-AC_DEFINE([NDEBUG],1,Define to 1 to exclude debug-code)
-fi
-
-
-dnl
-dnl Enable test suite. Deafult: no.
-dnl
-AC_MSG_CHECKING(whether to enable unit and integration tests)
-AC_ARG_ENABLE(tests,
-	[AS_HELP_STRING([--enable-tests], [enable unit and integration tests])],
-	[ ENABLETESTS=$enableval ],
-	[ ENABLETESTS=no] )
-AC_MSG_RESULT($ENABLETESTS)
-if test "$ENABLETESTS" = "yes"; then
-	AC_DEFINE([ENABLE_TESTS],1,[Define to 1 to enable unit and integration tests])
-	AM_CONDITIONAL(WITH_TESTS, true)
-else
-	AM_CONDITIONAL(WITH_TESTS, false)
-fi
-
 AC_CONFIG_FILES([Makefile])
 AC_OUTPUT

daemon/connect/Connection.h

@@ -1,148 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
- *  Copyright (C) 2007-2015 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;
-	bool				m_bBroken;
-	bool				m_bGracefull;
-
-	struct SockAddr
-	{
-		int				ai_family;
-		int				ai_socktype;
-		int				ai_protocol;
-		bool			operator==(const SockAddr& rhs) const
-							{ return memcmp(this, &rhs, sizeof(SockAddr)) == 0; }
-	};
-
-#ifndef DISABLE_TLS
-	class ConTLSSocket: public TLSSocket
-	{
-	private:
-		Connection*		m_pOwner;
-	protected:
-		virtual void	PrintError(const char* szErrMsg) { m_pOwner->PrintError(szErrMsg); }
-	public:
-						ConTLSSocket(SOCKET iSocket, bool bIsClient, const char* szCertFile,
-							const char* szKeyFile, const char* szCipher, Connection* pOwner):
-							TLSSocket(iSocket, bIsClient, szCertFile, szKeyFile, szCipher), m_pOwner(pOwner) {}
-	};
-
-	ConTLSSocket*		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);
-	virtual void		PrintError(const char* szErrMsg);
-	bool				DoConnect();
-	bool				DoDisconnect();
-	bool				InitSocketOpts();
-	bool				ConnectWithTimeout(void* address, int address_len);
-#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();
-	bool				GetGracefull() { return m_bGracefull; }
-	void				SetGracefull(bool bGracefull) { m_bGracefull = bGracefull; }
-#ifndef DISABLE_TLS
-	bool				StartTLS(bool bIsClient, const char* szCertFile, const char* szKeyFile);
-#endif
-	int					FetchTotalBytesRead();
-};
-
-#endif

daemon/connect/TLS.cpp

@@ -1,565 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2008-2015 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>
-#include <stdio.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)
-{
-	char szMessage[1024];
-
-#ifdef HAVE_LIBGNUTLS
-	const char* errstr = gnutls_strerror(m_iRetCode);
-	if (m_bSuppressErrors)
-	{
-		debug("%s: %s", szErrMsg, errstr);
-	}
-	else
-	{
-		snprintf(szMessage, sizeof(szMessage), "%s: %s", szErrMsg, errstr);
-		szMessage[sizeof(szMessage) - 1] = '\0';
-		PrintError(szMessage);
-	}
-#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)
-		{
-			snprintf(szMessage, sizeof(szMessage), "%s: %s", szErrMsg, errstr);
-			szMessage[sizeof(szMessage) - 1] = '\0';
-			PrintError(szMessage);
-		}
-		else
-		{
-			PrintError(szErrMsg);
-		}
-	} while (errcode);
-#endif /* HAVE_OPENSSL */
-}
-
-void TLSSocket::PrintError(const char* szErrMsg)
-{
-	error("%s", szErrMsg);
-}
-
-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,65 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2008-2015 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);
-
-protected:
-	virtual void		PrintError(const char* szErrMsg);
-
-public:
-						TLSSocket(SOCKET iSocket, bool bIsClient, const char* szCertFile, const char* szKeyFile, const char* szCipher);
-	virtual				~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,762 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2012-2015 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"
-
-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 = WebUtil::URLEncode(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;
-	}
-
-	EStatus Status = adFailed;
-
-	while (!IsStopped() && iRemainedDownloadRetries > 0 && iRemainedConnectRetries > 0)
-	{
-		SetLastUpdateTimeNow();
-
-		Status = DownloadWithRedirects(5);
-
-		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 != 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->SetTimeout(g_pOptions->GetUrlTimeout());
-	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::DownloadWithRedirects(int iMaxRedirects)
-{
-	// do sync download, following redirects
-	EStatus eStatus = adRedirect;
-	while (eStatus == adRedirect && iMaxRedirects >= 0)
-	{
-		iMaxRedirects--;
-		eStatus = Download();
-	}
-
-	if (eStatus == adRedirect && iMaxRedirects < 0)
-	{
-		warn("Too many redirects for %s", m_szInfoName);
-		eStatus = adFailed;
-	}
-
-	return eStatus;
-}
-
-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')
-		{
-			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;
-		}
-
-		// Connection closed or timeout?
-		if (iLen <= 0)
-		{
-			if (iLen == 0 && 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())
-	{
-		// redirect within host
-
-		char szResource[1024];
-		URL oldUrl(m_szURL);
-
-		if (*szLocation == '/')
-		{
-			// absolute path within host
-			strncpy(szResource, szLocation, 1024);
-			szResource[1024-1] = '\0';
-		}
-		else
-		{
-			// relative path within host
-			strncpy(szResource, oldUrl.GetResource(), 1024);
-			szResource[1024-1] = '\0';
-
-			char* p = strchr(szResource, '?');
-			if (p)
-			{
-				*p = '\0';
-			}
-
-			p = strrchr(szResource, '/');
-			if (p)
-			{
-				p[1] = '\0';
-			}
-
-			strncat(szResource, szLocation, 1024 - strlen(szResource));
-			szResource[1024-1] = '\0';
-		}
-
-		if (oldUrl.GetPort() > 0)
-		{
-			snprintf(szUrlBuf, 1024, "%s://%s:%i%s", oldUrl.GetProtocol(), oldUrl.GetHost(), oldUrl.GetPort(), szResource);
-		}
-		else
-		{
-			snprintf(szUrlBuf, 1024, "%s://%s%s", oldUrl.GetProtocol(), oldUrl.GetHost(), szResource);
-		}
-		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->GetWriteBuffer() > 0)
-	{
-		setvbuf(m_pOutFile, NULL, _IOFBF, g_pOptions->GetWriteBuffer() * 1024);
-	}
-
-	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;
-	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();
-	EStatus				DownloadWithRedirects(int iMaxRedirects);
-	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/extension/FeedScript.cpp

@@ -1,95 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2015 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 <ctype.h>
-#ifndef WIN32
-#include <unistd.h>
-#endif
-#include <sys/stat.h>
-#include <stdio.h>
-
-#include "nzbget.h"
-#include "FeedScript.h"
-#include "Options.h"
-#include "Log.h"
-#include "Util.h"
-
-
-void FeedScriptController::ExecuteScripts(const char* szFeedScript, const char* szFeedFile, int iFeedID)
-{
-	FeedScriptController* pScriptController = new FeedScriptController();
-
-	pScriptController->m_szFeedFile = szFeedFile;
-	pScriptController->m_iFeedID = iFeedID;
-
-	pScriptController->ExecuteScriptList(szFeedScript);
-
-	delete pScriptController;
-}
-
-void FeedScriptController::ExecuteScript(ScriptConfig::Script* pScript)
-{
-	if (!pScript->GetFeedScript())
-	{
-		return;
-	}
-
-	PrintMessage(Message::mkInfo, "Executing feed-script %s for Feed%i", pScript->GetName(), m_iFeedID);
-
-	SetScript(pScript->GetLocation());
-	SetArgs(NULL, false);
-
-	char szInfoName[1024];
-	snprintf(szInfoName, 1024, "feed-script %s for Feed%i", pScript->GetName(), m_iFeedID);
-	szInfoName[1024-1] = '\0';
-	SetInfoName(szInfoName);
-
-	SetLogPrefix(pScript->GetDisplayName());
-	PrepareParams(pScript->GetName());
-
-	Execute();
-
-	SetLogPrefix(NULL);
-}
-
-void FeedScriptController::PrepareParams(const char* szScriptName)
-{
-	ResetEnv();
-
-	SetEnvVar("NZBFP_FILENAME", m_szFeedFile);
-	SetIntEnvVar("NZBFP_FEEDID", m_iFeedID);
-
-	PrepareEnvScript(NULL, szScriptName);
-}

daemon/extension/FeedScript.h

@@ -1,46 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2015 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 FEEDSCRIPT_H
-#define FEEDSCRIPT_H
-
-#include "NzbScript.h"
-
-class FeedScriptController : public NZBScriptController
-{
-private:
-	const char*			m_szFeedFile;
-	int					m_iFeedID;
-
-	void				PrepareParams(const char* szScriptName);
-
-protected:
-	virtual void		ExecuteScript(ScriptConfig::Script* pScript);
-
-public:
-	static void			ExecuteScripts(const char* szFeedScript, const char* szFeedFile, int iFeedID);
-};
-
-#endif

daemon/extension/NzbScript.cpp

@@ -1,125 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2007-2015 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 <ctype.h>
-#ifndef WIN32
-#include <unistd.h>
-#endif
-#include <sys/stat.h>
-#include <stdio.h>
-#include <algorithm>
-
-#include "nzbget.h"
-#include "NzbScript.h"
-#include "Options.h"
-#include "Log.h"
-#include "Util.h"
-
-		 
-/**
- * If szStripPrefix is not NULL, only pp-parameters, whose names start with the prefix
- * are processed. The prefix is then stripped from the names.
- * If szStripPrefix is NULL, all pp-parameters are processed; without stripping.
- */
-void NZBScriptController::PrepareEnvParameters(NZBParameterList* pParameters, const char* szStripPrefix)
-{
-	int iPrefixLen = szStripPrefix ? strlen(szStripPrefix) : 0;
-
-	for (NZBParameterList::iterator it = pParameters->begin(); it != pParameters->end(); it++)
-	{
-		NZBParameter* pParameter = *it;
-		const char* szValue = pParameter->GetValue();
-		
-#ifdef WIN32
-		char* szAnsiValue = strdup(szValue);
-		WebUtil::Utf8ToAnsi(szAnsiValue, strlen(szAnsiValue) + 1);
-		szValue = szAnsiValue;
-#endif
-
-		if (szStripPrefix && !strncmp(pParameter->GetName(), szStripPrefix, iPrefixLen) && (int)strlen(pParameter->GetName()) > iPrefixLen)
-		{
-			SetEnvVarSpecial("NZBPR", pParameter->GetName() + iPrefixLen, szValue);
-		}
-		else if (!szStripPrefix)
-		{
-			SetEnvVarSpecial("NZBPR", pParameter->GetName(), szValue);
-		}
-
-#ifdef WIN32
-		free(szAnsiValue);
-#endif
-	}
-}
-
-void NZBScriptController::PrepareEnvScript(NZBParameterList* pParameters, const char* szScriptName)
-{
-	if (pParameters)
-	{
-		PrepareEnvParameters(pParameters, NULL);
-	}
-
-	char szParamPrefix[1024];
-	snprintf(szParamPrefix, 1024, "%s:", szScriptName);
-	szParamPrefix[1024-1] = '\0';
-
-	if (pParameters)
-	{
-		PrepareEnvParameters(pParameters, szParamPrefix);
-	}
-
-	PrepareEnvOptions(szParamPrefix);
-}
-
-void NZBScriptController::ExecuteScriptList(const char* szScriptList)
-{
-	for (ScriptConfig::Scripts::iterator it = g_pScriptConfig->GetScripts()->begin(); it != g_pScriptConfig->GetScripts()->end(); it++)
-	{
-		ScriptConfig::Script* pScript = *it;
-
-		if (szScriptList && *szScriptList)
-		{
-			// split szScriptList into tokens
-			Tokenizer tok(szScriptList, ",;");
-			while (const char* szScriptName = tok.Next())
-			{
-				if (Util::SameFilename(szScriptName, pScript->GetName()))
-				{
-					ExecuteScript(pScript);
-					break;
-				}
-			}
-		}
-	}
-}

daemon/extension/NzbScript.h

@@ -1,42 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2007-2015 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 NZBSCRIPT_H
-#define NZBSCRIPT_H
-
-#include "Script.h"
-#include "DownloadInfo.h"
-#include "ScriptConfig.h"
-
-class NZBScriptController : public ScriptController
-{
-protected:
-	void				PrepareEnvParameters(NZBParameterList* pParameters, const char* szStripPrefix);
-	void				PrepareEnvScript(NZBParameterList* pParameters, const char* szScriptName);
-	void				ExecuteScriptList(const char* szScriptList);
-	virtual void		ExecuteScript(ScriptConfig::Script* pScript) = 0;
-};
-
-#endif

daemon/extension/PostScript.cpp

@@ -1,351 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2007-2015 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 <ctype.h>
-#ifndef WIN32
-#include <unistd.h>
-#endif
-#include <stdio.h>
-
-#include "nzbget.h"
-#include "PostScript.h"
-#include "Log.h"
-#include "Util.h"
-#include "Options.h"
-
-static const int POSTPROCESS_PARCHECK = 92;
-static const int POSTPROCESS_SUCCESS = 93;
-static const int POSTPROCESS_ERROR = 94;
-static const int POSTPROCESS_NONE = 95;
-
-void PostScriptController::StartJob(PostInfo* pPostInfo)
-{
-	PostScriptController* pScriptController = new PostScriptController();
-	pScriptController->m_pPostInfo = pPostInfo;
-	pScriptController->SetWorkingDir(g_pOptions->GetDestDir());
-	pScriptController->SetAutoDestroy(false);
-	pScriptController->m_iPrefixLen = 0;
-
-	pPostInfo->SetPostThread(pScriptController);
-
-	pScriptController->Start();
-}
-
-void PostScriptController::Run()
-{
-	StringBuilder scriptCommaList;
-
-	// the locking is needed for accessing the members of NZBInfo
-	DownloadQueue::Lock();
-	for (NZBParameterList::iterator it = m_pPostInfo->GetNZBInfo()->GetParameters()->begin(); it != m_pPostInfo->GetNZBInfo()->GetParameters()->end(); it++)
-	{
-		NZBParameter* pParameter = *it;
-		const char* szVarname = pParameter->GetName();
-		if (strlen(szVarname) > 0 && szVarname[0] != '*' && szVarname[strlen(szVarname)-1] == ':' &&
-			(!strcasecmp(pParameter->GetValue(), "yes") || !strcasecmp(pParameter->GetValue(), "on") || !strcasecmp(pParameter->GetValue(), "1")))
-		{
-			char* szScriptName = strdup(szVarname);
-			szScriptName[strlen(szScriptName)-1] = '\0'; // remove trailing ':'
-			scriptCommaList.Append(szScriptName);
-			scriptCommaList.Append(",");
-			free(szScriptName);
-		}
-	}
-	m_pPostInfo->GetNZBInfo()->GetScriptStatuses()->Clear();
-	DownloadQueue::Unlock();
-
-	ExecuteScriptList(scriptCommaList.GetBuffer());
-
-	m_pPostInfo->SetStage(PostInfo::ptFinished);
-	m_pPostInfo->SetWorking(false);
-}
-
-void PostScriptController::ExecuteScript(ScriptConfig::Script* pScript)
-{
-	// if any script has requested par-check, do not execute other scripts
-	if (!pScript->GetPostScript() || m_pPostInfo->GetRequestParCheck())
-	{
-		return;
-	}
-
-	PrintMessage(Message::mkInfo, "Executing post-process-script %s for %s", pScript->GetName(), m_pPostInfo->GetNZBInfo()->GetName());
-
-	char szProgressLabel[1024];
-	snprintf(szProgressLabel, 1024, "Executing post-process-script %s", pScript->GetName());
-	szProgressLabel[1024-1] = '\0';
-
-	DownloadQueue::Lock();
-	m_pPostInfo->SetProgressLabel(szProgressLabel);
-	DownloadQueue::Unlock();
-
-	SetScript(pScript->GetLocation());
-	SetArgs(NULL, false);
-
-	char szInfoName[1024];
-	snprintf(szInfoName, 1024, "post-process-script %s for %s", pScript->GetName(), m_pPostInfo->GetNZBInfo()->GetName());
-	szInfoName[1024-1] = '\0';
-	SetInfoName(szInfoName);
-
-	m_pScript = pScript;
-	SetLogPrefix(pScript->GetDisplayName());
-	m_iPrefixLen = strlen(pScript->GetDisplayName()) + 2; // 2 = strlen(": ");
-	PrepareParams(pScript->GetName());
-
-	int iExitCode = Execute();
-
-	szInfoName[0] = 'P'; // uppercase
-
-	SetLogPrefix(NULL);
-	ScriptStatus::EStatus eStatus = AnalyseExitCode(iExitCode);
-	
-	// the locking is needed for accessing the members of NZBInfo
-	DownloadQueue::Lock();
-	m_pPostInfo->GetNZBInfo()->GetScriptStatuses()->Add(pScript->GetName(), eStatus);
-	DownloadQueue::Unlock();
-}
-
-void PostScriptController::PrepareParams(const char* szScriptName)
-{
-	// the locking is needed for accessing the members of NZBInfo
-	DownloadQueue::Lock();
-
-	ResetEnv();
-
-	SetIntEnvVar("NZBPP_NZBID", m_pPostInfo->GetNZBInfo()->GetID());
-	SetEnvVar("NZBPP_NZBNAME", m_pPostInfo->GetNZBInfo()->GetName());
-	SetEnvVar("NZBPP_DIRECTORY", m_pPostInfo->GetNZBInfo()->GetDestDir());
-	SetEnvVar("NZBPP_NZBFILENAME", m_pPostInfo->GetNZBInfo()->GetFilename());
-	SetEnvVar("NZBPP_URL", m_pPostInfo->GetNZBInfo()->GetURL());
-	SetEnvVar("NZBPP_FINALDIR", m_pPostInfo->GetNZBInfo()->GetFinalDir());
-	SetEnvVar("NZBPP_CATEGORY", m_pPostInfo->GetNZBInfo()->GetCategory());
-	SetIntEnvVar("NZBPP_HEALTH", m_pPostInfo->GetNZBInfo()->CalcHealth());
-	SetIntEnvVar("NZBPP_CRITICALHEALTH", m_pPostInfo->GetNZBInfo()->CalcCriticalHealth(false));
-
-	SetEnvVar("NZBPP_DUPEKEY", m_pPostInfo->GetNZBInfo()->GetDupeKey());
-	SetIntEnvVar("NZBPP_DUPESCORE", m_pPostInfo->GetNZBInfo()->GetDupeScore());
-
-	const char* szDupeModeName[] = { "SCORE", "ALL", "FORCE" };
-	SetEnvVar("NZBPP_DUPEMODE", szDupeModeName[m_pPostInfo->GetNZBInfo()->GetDupeMode()]);
-
-	char szStatus[256];
-	strncpy(szStatus, m_pPostInfo->GetNZBInfo()->MakeTextStatus(true), sizeof(szStatus));
-	szStatus[256-1] = '\0';
-	SetEnvVar("NZBPP_STATUS", szStatus);
-
-	char* szDetail = strchr(szStatus, '/');
-	if (szDetail) *szDetail = '\0';
-	SetEnvVar("NZBPP_TOTALSTATUS", szStatus);
-
-    const char* szScriptStatusName[] = { "NONE", "FAILURE", "SUCCESS" };
-	SetEnvVar("NZBPP_SCRIPTSTATUS", szScriptStatusName[m_pPostInfo->GetNZBInfo()->GetScriptStatuses()->CalcTotalStatus()]);
-
-	// deprecated
-	int iParStatus[] = { 0, 0, 1, 2, 3, 4 };
-	NZBInfo::EParStatus eParStatus = m_pPostInfo->GetNZBInfo()->GetParStatus();
-	// for downloads marked as bad and for deleted downloads pass par status "Failure"
-	// for compatibility with older scripts which don't check "NZBPP_TOTALSTATUS"
-	if (m_pPostInfo->GetNZBInfo()->GetDeleteStatus() != NZBInfo::dsNone ||
-		m_pPostInfo->GetNZBInfo()->GetMarkStatus() == NZBInfo::ksBad)
-	{
-		eParStatus = NZBInfo::psFailure;
-	}
-	SetIntEnvVar("NZBPP_PARSTATUS", iParStatus[eParStatus]);
-
-	// deprecated
-	int iUnpackStatus[] = { 0, 0, 1, 2, 3, 4 };
-	SetIntEnvVar("NZBPP_UNPACKSTATUS", iUnpackStatus[m_pPostInfo->GetNZBInfo()->GetUnpackStatus()]);
-
-	// deprecated
-	SetIntEnvVar("NZBPP_HEALTHDELETED", (int)m_pPostInfo->GetNZBInfo()->GetDeleteStatus() == NZBInfo::dsHealth);
-
-	SetIntEnvVar("NZBPP_TOTALARTICLES", (int)m_pPostInfo->GetNZBInfo()->GetTotalArticles());
-	SetIntEnvVar("NZBPP_SUCCESSARTICLES", (int)m_pPostInfo->GetNZBInfo()->GetSuccessArticles());
-	SetIntEnvVar("NZBPP_FAILEDARTICLES", (int)m_pPostInfo->GetNZBInfo()->GetFailedArticles());
-
-	for (ServerStatList::iterator it = m_pPostInfo->GetNZBInfo()->GetServerStats()->begin(); it != m_pPostInfo->GetNZBInfo()->GetServerStats()->end(); it++)
-	{
-		ServerStat* pServerStat = *it;
-
-		char szName[50];
-
-		snprintf(szName, 50, "NZBPP_SERVER%i_SUCCESSARTICLES", pServerStat->GetServerID());
-		szName[50-1] = '\0';
-		SetIntEnvVar(szName, pServerStat->GetSuccessArticles());
-
-		snprintf(szName, 50, "NZBPP_SERVER%i_FAILEDARTICLES", pServerStat->GetServerID());
-		szName[50-1] = '\0';
-		SetIntEnvVar(szName, pServerStat->GetFailedArticles());
-	}
-
-	PrepareEnvScript(m_pPostInfo->GetNZBInfo()->GetParameters(), szScriptName);
-	
-	DownloadQueue::Unlock();
-}
-
-ScriptStatus::EStatus PostScriptController::AnalyseExitCode(int iExitCode)
-{
-	// The ScriptStatus is accumulated for all scripts:
-	// If any script has failed the status is "failure", etc.
-
-	switch (iExitCode)
-	{
-		case POSTPROCESS_SUCCESS:
-			PrintMessage(Message::mkInfo, "%s successful", GetInfoName());
-			return ScriptStatus::srSuccess;
-
-		case POSTPROCESS_ERROR:
-		case -1: // Execute() returns -1 if the process could not be started (file not found or other problem)
-			PrintMessage(Message::mkError, "%s failed", GetInfoName());
-			return ScriptStatus::srFailure;
-
-		case POSTPROCESS_NONE:
-			PrintMessage(Message::mkInfo, "%s skipped", GetInfoName());
-			return ScriptStatus::srNone;
-
-#ifndef DISABLE_PARCHECK
-		case POSTPROCESS_PARCHECK:
-			if (m_pPostInfo->GetNZBInfo()->GetParStatus() > NZBInfo::psSkipped)
-			{
-				PrintMessage(Message::mkError, "%s requested par-check/repair, but the collection was already checked", GetInfoName());
-				return ScriptStatus::srFailure;
-			}
-			else
-			{
-				PrintMessage(Message::mkInfo, "%s requested par-check/repair", GetInfoName());
-				m_pPostInfo->SetRequestParCheck(true);
-				m_pPostInfo->SetForceRepair(true);
-				return ScriptStatus::srSuccess;
-			}
-			break;
-#endif
-
-		default:
-			PrintMessage(Message::mkError, "%s failed (terminated with unknown status)", GetInfoName());
-			return ScriptStatus::srFailure;
-	}
-}
-
-void PostScriptController::AddMessage(Message::EKind eKind, const char* szText)
-{
-	const char* szMsgText = szText + m_iPrefixLen;
-
-	if (!strncmp(szMsgText, "[NZB] ", 6))
-	{
-		debug("Command %s detected", szMsgText + 6);
-		if (!strncmp(szMsgText + 6, "FINALDIR=", 9))
-		{
-			DownloadQueue::Lock();
-			m_pPostInfo->GetNZBInfo()->SetFinalDir(szMsgText + 6 + 9);
-			DownloadQueue::Unlock();
-		}
-		else if (!strncmp(szMsgText + 6, "DIRECTORY=", 10))
-		{
-			DownloadQueue::Lock();
-			m_pPostInfo->GetNZBInfo()->SetDestDir(szMsgText + 6 + 10);
-			DownloadQueue::Unlock();
-		}
-		else if (!strncmp(szMsgText + 6, "NZBPR_", 6))
-		{
-			char* szParam = strdup(szMsgText + 6 + 6);
-			char* szValue = strchr(szParam, '=');
-			if (szValue)
-			{
-				*szValue = '\0';
-				DownloadQueue::Lock();
-				m_pPostInfo->GetNZBInfo()->GetParameters()->SetParameter(szParam, szValue + 1);
-				DownloadQueue::Unlock();
-			}
-			else
-			{
-				m_pPostInfo->GetNZBInfo()->PrintMessage(Message::mkError,
-					"Invalid command \"%s\" received from %s", szMsgText, GetInfoName());
-			}
-			free(szParam);
-		}
-		else if (!strncmp(szMsgText + 6, "MARK=BAD", 8))
-		{
-			SetLogPrefix(NULL);
-			PrintMessage(Message::mkWarning, "Marking %s as bad", m_pPostInfo->GetNZBInfo()->GetName());
-			SetLogPrefix(m_pScript->GetDisplayName());
-			m_pPostInfo->GetNZBInfo()->SetMarkStatus(NZBInfo::ksBad);
-		}
-		else
-		{
-			m_pPostInfo->GetNZBInfo()->PrintMessage(Message::mkError,
-				"Invalid command \"%s\" received from %s", szMsgText, GetInfoName());
-		}
-	}
-	else
-	{
-		m_pPostInfo->GetNZBInfo()->AddMessage(eKind, szText);
-		DownloadQueue::Lock();
-		m_pPostInfo->SetProgressLabel(szText);
-		DownloadQueue::Unlock();
-	}
-
-	if (g_pOptions->GetPausePostProcess() && !m_pPostInfo->GetNZBInfo()->GetForcePriority())
-	{
-		time_t tStageTime = m_pPostInfo->GetStageTime();
-		time_t tStartTime = m_pPostInfo->GetStartTime();
-		time_t tWaitTime = time(NULL);
-
-		// wait until Post-processor is unpaused
-		while (g_pOptions->GetPausePostProcess() && !m_pPostInfo->GetNZBInfo()->GetForcePriority() && !IsStopped())
-		{
-			usleep(100 * 1000);
-
-			// update time stamps
-
-			time_t tDelta = time(NULL) - tWaitTime;
-
-			if (tStageTime > 0)
-			{
-				m_pPostInfo->SetStageTime(tStageTime + tDelta);
-			}
-
-			if (tStartTime > 0)
-			{
-				m_pPostInfo->SetStartTime(tStartTime + tDelta);
-			}
-		}
-	}
-}
-
-void PostScriptController::Stop()
-{
-	debug("Stopping post-process-script");
-	Thread::Stop();
-	Terminate();
-}

daemon/extension/QueueScript.cpp

@@ -1,525 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2007-2015 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 <ctype.h>
-#ifndef WIN32
-#include <unistd.h>
-#endif
-#include <sys/stat.h>
-#include <stdio.h>
-
-#include "nzbget.h"
-#include "QueueScript.h"
-#include "NzbScript.h"
-#include "Options.h"
-#include "Log.h"
-#include "Util.h"
-
-static const char* QUEUE_EVENT_NAMES[] = { "FILE_DOWNLOADED", "URL_COMPLETED", "NZB_ADDED", "NZB_DOWNLOADED", "NZB_DELETED" };
-
-class QueueScriptController : public Thread, public NZBScriptController
-{
-private:
-	char*				m_szNZBName;
-	char*				m_szNZBFilename;
-	char*				m_szUrl;
-	char*				m_szCategory;
-	char*				m_szDestDir;
-	int					m_iID;
-	int					m_iPriority;
-	char*				m_szDupeKey;
-	EDupeMode			m_eDupeMode;
-	int					m_iDupeScore;
-	NZBParameterList	m_Parameters;
-	int					m_iPrefixLen;
-	ScriptConfig::Script*	m_pScript;
-	QueueScriptCoordinator::EEvent	m_eEvent;
-	bool				m_bMarkBad;
-	NZBInfo::EDeleteStatus m_eDeleteStatus;
-	NZBInfo::EUrlStatus	m_eUrlStatus;
-
-	void				PrepareParams(const char* szScriptName);
-
-protected:
-	virtual void		ExecuteScript(ScriptConfig::Script* pScript);
-	virtual void		AddMessage(Message::EKind eKind, const char* szText);
-
-public:
-	virtual				~QueueScriptController();
-	virtual void		Run();
-	static void			StartScript(NZBInfo* pNZBInfo, ScriptConfig::Script* pScript, QueueScriptCoordinator::EEvent eEvent);
-};
-
-
-QueueScriptController::~QueueScriptController()
-{
-	free(m_szNZBName);
-	free(m_szNZBFilename);
-	free(m_szUrl);
-	free(m_szCategory);
-	free(m_szDestDir);
-	free(m_szDupeKey);
-}
-
-void QueueScriptController::StartScript(NZBInfo* pNZBInfo, ScriptConfig::Script* pScript, QueueScriptCoordinator::EEvent eEvent)
-{
-	QueueScriptController* pScriptController = new QueueScriptController();
-
-	pScriptController->m_szNZBName = strdup(pNZBInfo->GetName());
-	pScriptController->m_szNZBFilename = strdup(pNZBInfo->GetFilename());
-	pScriptController->m_szUrl = strdup(pNZBInfo->GetURL());
-	pScriptController->m_szCategory = strdup(pNZBInfo->GetCategory());
-	pScriptController->m_szDestDir = strdup(pNZBInfo->GetDestDir());
-	pScriptController->m_iID = pNZBInfo->GetID();
-	pScriptController->m_iPriority = pNZBInfo->GetPriority();
-	pScriptController->m_szDupeKey = strdup(pNZBInfo->GetDupeKey());
-	pScriptController->m_eDupeMode = pNZBInfo->GetDupeMode();
-	pScriptController->m_iDupeScore = pNZBInfo->GetDupeScore();
-	pScriptController->m_Parameters.CopyFrom(pNZBInfo->GetParameters());
-	pScriptController->m_pScript = pScript;
-	pScriptController->m_eEvent = eEvent;
-	pScriptController->m_iPrefixLen = 0;
-	pScriptController->m_bMarkBad = false;
-	pScriptController->m_eDeleteStatus = pNZBInfo->GetDeleteStatus();
-	pScriptController->m_eUrlStatus = pNZBInfo->GetUrlStatus();
-	pScriptController->SetAutoDestroy(true);
-
-	pScriptController->Start();
-}
-
-void QueueScriptController::Run()
-{
-	ExecuteScript(m_pScript);
-
-	SetLogPrefix(NULL);
-
-	if (m_bMarkBad)
-	{
-		DownloadQueue* pDownloadQueue = DownloadQueue::Lock();
-		NZBInfo* pNZBInfo = pDownloadQueue->GetQueue()->Find(m_iID);
-		if (pNZBInfo)
-		{
-			PrintMessage(Message::mkWarning, "Cancelling download and deleting %s", m_szNZBName);
-			pNZBInfo->SetDeleteStatus(NZBInfo::dsBad);
-			pDownloadQueue->EditEntry(m_iID, DownloadQueue::eaGroupDelete, 0, NULL);
-		}
-		DownloadQueue::Unlock();
-	}
-
-	g_pQueueScriptCoordinator->CheckQueue();
-}
-
-void QueueScriptController::ExecuteScript(ScriptConfig::Script* pScript)
-{
-	PrintMessage(m_eEvent == QueueScriptCoordinator::qeFileDownloaded ? Message::mkDetail : Message::mkInfo,
-		"Executing queue-script %s for %s", pScript->GetName(), Util::BaseFileName(m_szNZBName));
-
-	SetScript(pScript->GetLocation());
-	SetArgs(NULL, false);
-
-	char szInfoName[1024];
-	snprintf(szInfoName, 1024, "queue-script %s for %s", pScript->GetName(), Util::BaseFileName(m_szNZBName));
-	szInfoName[1024-1] = '\0';
-	SetInfoName(szInfoName);
-
-	SetLogPrefix(pScript->GetDisplayName());
-	m_iPrefixLen = strlen(pScript->GetDisplayName()) + 2; // 2 = strlen(": ");
-	PrepareParams(pScript->GetName());
-
-	Execute();
-
-	SetLogPrefix(NULL);
-}
-
-void QueueScriptController::PrepareParams(const char* szScriptName)
-{
-	ResetEnv();
-
-	SetEnvVar("NZBNA_NZBNAME", m_szNZBName);
-	SetIntEnvVar("NZBNA_NZBID", m_iID);
-	SetEnvVar("NZBNA_FILENAME", m_szNZBFilename);
-	SetEnvVar("NZBNA_DIRECTORY", m_szDestDir);
-	SetEnvVar("NZBNA_URL", m_szUrl);
-	SetEnvVar("NZBNA_CATEGORY", m_szCategory);
-	SetIntEnvVar("NZBNA_PRIORITY", m_iPriority);
-	SetIntEnvVar("NZBNA_LASTID", m_iID);	// deprecated
-
-	SetEnvVar("NZBNA_DUPEKEY", m_szDupeKey);
-	SetIntEnvVar("NZBNA_DUPESCORE", m_iDupeScore);
-
-	const char* szDupeModeName[] = { "SCORE", "ALL", "FORCE" };
-	SetEnvVar("NZBNA_DUPEMODE", szDupeModeName[m_eDupeMode]);
-
-	SetEnvVar("NZBNA_EVENT", QUEUE_EVENT_NAMES[m_eEvent]);
-
-    const char* szDeleteStatusName[] = { "NONE", "MANUAL", "HEALTH", "DUPE", "BAD", "GOOD", "COPY", "SCAN" };
-	SetEnvVar("NZBNA_DELETESTATUS", szDeleteStatusName[m_eDeleteStatus]);
-
-	const char* szUrlStatusName[] = { "NONE", "UNKNOWN", "SUCCESS", "FAILURE", "UNKNOWN", "SCAN_SKIPPED", "SCAN_FAILURE" };
-	SetEnvVar("NZBNA_URLSTATUS", szUrlStatusName[m_eUrlStatus]);
-
-	PrepareEnvScript(&m_Parameters, szScriptName);
-}
-
-void QueueScriptController::AddMessage(Message::EKind eKind, const char* szText)
-{
-	const char* szMsgText = szText + m_iPrefixLen;
-
-	if (!strncmp(szMsgText, "[NZB] ", 6))
-	{
-		debug("Command %s detected", szMsgText + 6);
-		if (!strncmp(szMsgText + 6, "NZBPR_", 6))
-		{
-			char* szParam = strdup(szMsgText + 6 + 6);
-			char* szValue = strchr(szParam, '=');
-			if (szValue)
-			{
-				*szValue = '\0';
-				DownloadQueue* pDownloadQueue = DownloadQueue::Lock();
-				NZBInfo* pNZBInfo = pDownloadQueue->GetQueue()->Find(m_iID);
-				if (pNZBInfo)
-				{
-					pNZBInfo->GetParameters()->SetParameter(szParam, szValue + 1);
-				}
-				DownloadQueue::Unlock();
-			}
-			else
-			{
-				error("Invalid command \"%s\" received from %s", szMsgText, GetInfoName());
-			}
-			free(szParam);
-		}
-		else if (!strncmp(szMsgText + 6, "MARK=BAD", 8))
-		{
-			m_bMarkBad = true;
-			DownloadQueue* pDownloadQueue = DownloadQueue::Lock();
-			NZBInfo* pNZBInfo = pDownloadQueue->GetQueue()->Find(m_iID);
-			if (pNZBInfo)
-			{
-				SetLogPrefix(NULL);
-				PrintMessage(Message::mkWarning, "Marking %s as bad", m_szNZBName);
-				SetLogPrefix(m_pScript->GetDisplayName());
-				pNZBInfo->SetMarkStatus(NZBInfo::ksBad);
-			}
-			DownloadQueue::Unlock();
-		}
-		else
-		{
-			error("Invalid command \"%s\" received from %s", szMsgText, GetInfoName());
-		}
-	}
-	else
-	{
-		ScriptController::AddMessage(eKind, szText);
-	}
-}
-
-
-QueueScriptCoordinator::QueueItem::QueueItem(int iNZBID, ScriptConfig::Script* pScript, EEvent eEvent)
-{
-	m_iNZBID = iNZBID;
-	m_pScript = pScript;
-	m_eEvent = eEvent;
-}
-
-QueueScriptCoordinator::QueueScriptCoordinator()
-{
-	m_pCurItem = NULL;
-	m_bStopped = false;
-}
-
-QueueScriptCoordinator::~QueueScriptCoordinator()
-{
-	delete m_pCurItem;
-	for (Queue::iterator it = m_Queue.begin(); it != m_Queue.end(); it++ )
-	{
-		delete *it;
-	}
-}
-
-void QueueScriptCoordinator::InitOptions()
-{
-	m_bHasQueueScripts = false;
-	for (ScriptConfig::Scripts::iterator it = g_pScriptConfig->GetScripts()->begin(); it != g_pScriptConfig->GetScripts()->end(); it++)
-	{
-		ScriptConfig::Script* pScript = *it;
-		if (pScript->GetQueueScript())
-		{
-			m_bHasQueueScripts = true;
-			break;
-		}
-	}
-}
-
-void QueueScriptCoordinator::EnqueueScript(NZBInfo* pNZBInfo, EEvent eEvent)
-{
-	if (!m_bHasQueueScripts)
-	{
-		return;
-	}
-
-	m_mutexQueue.Lock();
-
-	if (eEvent == qeNzbDownloaded)
-	{
-		// delete all other queued scripts for this nzb
-		for (Queue::iterator it = m_Queue.begin(); it != m_Queue.end(); )
-		{
-			QueueItem* pQueueItem = *it;
-			if (pQueueItem->GetNZBID() == pNZBInfo->GetID())
-			{
-				delete pQueueItem;
-				it = m_Queue.erase(it);
-				continue;
-			}
-			it++;
-		}
-	}
-
-	// respect option "EventInterval"
-	time_t tCurTime = time(NULL);
-	if (eEvent == qeFileDownloaded &&
-		(g_pOptions->GetEventInterval() == -1 ||
-		 (g_pOptions->GetEventInterval() > 0 && tCurTime - pNZBInfo->GetQueueScriptTime() > 0 &&
-		 (int)(tCurTime - pNZBInfo->GetQueueScriptTime()) < g_pOptions->GetEventInterval())))
-	{
-		m_mutexQueue.Unlock();
-		return;
-	}
-
-	for (ScriptConfig::Scripts::iterator it = g_pScriptConfig->GetScripts()->begin(); it != g_pScriptConfig->GetScripts()->end(); it++)
-	{
-		ScriptConfig::Script* pScript = *it;
-
-		if (!pScript->GetQueueScript())
-		{
-			continue;
-		}
-
-		bool bUseScript = false;
-
-		// check queue-scripts
-		const char* szQueueScript = g_pOptions->GetQueueScript();
-		if (!Util::EmptyStr(szQueueScript))
-		{
-			// split szQueueScript into tokens
-			Tokenizer tok(szQueueScript, ",;");
-			while (const char* szScriptName = tok.Next())
-			{
-				if (Util::SameFilename(szScriptName, pScript->GetName()))
-				{
-					bUseScript = true;
-					break;
-				}
-			}
-		}
-
-		// check post-processing-scripts
-		if (!bUseScript)
-		{
-			for (NZBParameterList::iterator it = pNZBInfo->GetParameters()->begin(); it != pNZBInfo->GetParameters()->end(); it++)
-			{
-				NZBParameter* pParameter = *it;
-				const char* szVarname = pParameter->GetName();
-				if (strlen(szVarname) > 0 && szVarname[0] != '*' && szVarname[strlen(szVarname)-1] == ':' &&
-					(!strcasecmp(pParameter->GetValue(), "yes") ||
-					 !strcasecmp(pParameter->GetValue(), "on") ||
-					 !strcasecmp(pParameter->GetValue(), "1")))
-				{
-					char szScriptName[1024];
-					strncpy(szScriptName, szVarname, 1024);
-					szScriptName[1024-1] = '\0';
-					szScriptName[strlen(szScriptName)-1] = '\0'; // remove trailing ':'
-					if (Util::SameFilename(szScriptName, pScript->GetName()))
-					{
-						bUseScript = true;
-						break;
-					}
-				}
-			}
-		}
-
-		bUseScript &= Util::EmptyStr(pScript->GetQueueEvents()) || strstr(pScript->GetQueueEvents(), QUEUE_EVENT_NAMES[eEvent]);
-
-		if (bUseScript)
-		{
-			bool bAlreadyQueued = false;
-			if (eEvent == qeFileDownloaded)
-			{
-				// check if this script is already queued for this nzb
-				for (Queue::iterator it2 = m_Queue.begin(); it2 != m_Queue.end(); it2++)
-				{
-					QueueItem* pQueueItem = *it2;
-					if (pQueueItem->GetNZBID() == pNZBInfo->GetID() && pQueueItem->GetScript() == pScript)
-					{
-						bAlreadyQueued = true;
-						break;
-					}
-				}
-			}
-
-			if (!bAlreadyQueued)
-			{
-				QueueItem* pQueueItem = new QueueItem(pNZBInfo->GetID(), pScript, eEvent);
-				if (m_pCurItem)
-				{
-					m_Queue.push_back(pQueueItem);
-				}
-				else
-				{
-					StartScript(pNZBInfo, pQueueItem);
-				}
-			}
-
-			pNZBInfo->SetQueueScriptTime(time(NULL));
-		}
-	}
-
-	m_mutexQueue.Unlock();
-}
-
-NZBInfo* QueueScriptCoordinator::FindNZBInfo(DownloadQueue* pDownloadQueue, int iNZBID)
-{
-	NZBInfo* pNZBInfo = pDownloadQueue->GetQueue()->Find(iNZBID);
-	if (!pNZBInfo)
-	{
-		for (HistoryList::iterator it = pDownloadQueue->GetHistory()->begin(); it != pDownloadQueue->GetHistory()->end(); it++)
-		{
-			HistoryInfo* pHistoryInfo = *it;
-			if (pHistoryInfo->GetNZBInfo() && pHistoryInfo->GetNZBInfo()->GetID() == iNZBID)
-			{
-				pNZBInfo = pHistoryInfo->GetNZBInfo();
-				break;
-			}
-		}
-	}
-	return pNZBInfo;
-}
-
-void QueueScriptCoordinator::CheckQueue()
-{
-	if (m_bStopped)
-	{
-		return;
-	}
-
-	DownloadQueue* pDownloadQueue = DownloadQueue::Lock();
-	m_mutexQueue.Lock();
-
-	delete m_pCurItem;
-
-	m_pCurItem = NULL;
-	NZBInfo* pCurNZBInfo = NULL;
-	Queue::iterator itCurItem = m_Queue.end();
-
-	for (Queue::iterator it = m_Queue.begin(); it != m_Queue.end(); )
-	{
-		QueueItem* pQueueItem = *it;
-
-		NZBInfo* pNZBInfo = FindNZBInfo(pDownloadQueue, pQueueItem->GetNZBID());
-
-		// in a case this nzb must not be processed further - delete queue script from queue
-		if (!pNZBInfo ||
-			(pNZBInfo->GetDeleteStatus() != NZBInfo::dsNone && pQueueItem->GetEvent() != qeNzbDeleted) ||
-			pNZBInfo->GetMarkStatus() == NZBInfo::ksBad)
-		{
-			delete pQueueItem;
-			it = m_Queue.erase(it);
-			continue;
-		}
-
-		if (!m_pCurItem || pQueueItem->GetEvent() > m_pCurItem->GetEvent())
-		{
-			m_pCurItem = pQueueItem;
-			itCurItem = it;
-			pCurNZBInfo = pNZBInfo;
-		}
-
-		it++;
-	}
-
-	if (m_pCurItem)
-	{
-		m_Queue.erase(itCurItem);
-		StartScript(pCurNZBInfo, m_pCurItem);
-	}
-
-	m_mutexQueue.Unlock();
-	DownloadQueue::Unlock();
-}
-
-void QueueScriptCoordinator::StartScript(NZBInfo* pNZBInfo, QueueItem* pQueueItem)
-{
-	m_pCurItem = pQueueItem;
-	QueueScriptController::StartScript(pNZBInfo, pQueueItem->GetScript(), pQueueItem->GetEvent());
-}
-
-bool QueueScriptCoordinator::HasJob(int iNZBID, bool* pActive)
-{
-	m_mutexQueue.Lock();
-	bool bWorking = m_pCurItem && m_pCurItem->GetNZBID() == iNZBID;
-	if (pActive)
-	{
-		*pActive = bWorking;
-	}
-	if (!bWorking)
-	{
-		for (Queue::iterator it = m_Queue.begin(); it != m_Queue.end(); it++)
-		{
-			QueueItem* pQueueItem = *it;
-			bWorking = pQueueItem->GetNZBID() == iNZBID;
-			if (bWorking)
-			{
-				break;
-			}
-		}
-	}
-	m_mutexQueue.Unlock();
-
-	return bWorking;
-}
-
-int QueueScriptCoordinator::GetQueueSize()
-{
-	m_mutexQueue.Lock();
-	int iQueuedCount = m_Queue.size();
-	if (m_pCurItem)
-	{
-		iQueuedCount++;
-	}
-	m_mutexQueue.Unlock();
-
-	return iQueuedCount;
-}

daemon/extension/QueueScript.h

@@ -1,84 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2007-2015 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 QUEUESCRIPT_H
-#define QUEUESCRIPT_H
-
-#include <list>
-
-#include "DownloadInfo.h"
-#include "ScriptConfig.h"
-
-class QueueScriptCoordinator
-{
-public:
-	enum EEvent
-	{
-		qeFileDownloaded,	// lowest priority
-		qeUrlCompleted,
-		qeNzbAdded,
-		qeNzbDownloaded,
-		qeNzbDeleted		// highest priority
-	};
-
-private:
-	class QueueItem
-	{
-	private:
-		int					m_iNZBID;
-		ScriptConfig::Script*	m_pScript;
-		EEvent				m_eEvent;
-	public:
-							QueueItem(int iNZBID, ScriptConfig::Script* pScript, EEvent eEvent);
-		int					GetNZBID() { return m_iNZBID; }
-		ScriptConfig::Script*	GetScript() { return m_pScript; }
-		EEvent				GetEvent() { return m_eEvent; }
-	};
-
-	typedef std::list<QueueItem*> Queue;
-	
-	Queue				m_Queue;
-	Mutex				m_mutexQueue;
-	QueueItem*			m_pCurItem;
-	bool				m_bHasQueueScripts;
-	bool				m_bStopped;
-
-	void				StartScript(NZBInfo* pNZBInfo, QueueItem* pQueueItem);
-	NZBInfo*			FindNZBInfo(DownloadQueue* pDownloadQueue, int iNZBID);
-
-public:
-						QueueScriptCoordinator();
-						~QueueScriptCoordinator();
-	void				Stop() { m_bStopped = true; }
-	void				InitOptions();
-	void				EnqueueScript(NZBInfo* pNZBInfo, EEvent eEvent);
-	void				CheckQueue();
-	bool				HasJob(int iNZBID, bool* pActive);
-	int					GetQueueSize();
-};
-
-extern QueueScriptCoordinator* g_pQueueScriptCoordinator;
-
-#endif

daemon/extension/ScanScript.cpp

@@ -1,207 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2007-2015 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 <ctype.h>
-#ifndef WIN32
-#include <unistd.h>
-#endif
-#include <sys/stat.h>
-#include <stdio.h>
-
-#include "nzbget.h"
-#include "ScanScript.h"
-#include "Scanner.h"
-#include "Options.h"
-#include "Log.h"
-#include "Util.h"
-
-void ScanScriptController::ExecuteScripts(const char* szNZBFilename,
-	const char* szUrl, const char* szDirectory, char** pNZBName, char** pCategory,
-	int* iPriority, NZBParameterList* pParameters, bool* bAddTop, bool* bAddPaused,
-	char** pDupeKey, int* iDupeScore, EDupeMode* eDupeMode)
-{
-	ScanScriptController* pScriptController = new ScanScriptController();
-
-	pScriptController->m_szNZBFilename = szNZBFilename;
-	pScriptController->m_szUrl = szUrl;
-	pScriptController->m_szDirectory = szDirectory;
-	pScriptController->m_pNZBName = pNZBName;
-	pScriptController->m_pCategory = pCategory;
-	pScriptController->m_pParameters = pParameters;
-	pScriptController->m_iPriority = iPriority;
-	pScriptController->m_bAddTop = bAddTop;
-	pScriptController->m_bAddPaused = bAddPaused;
-	pScriptController->m_pDupeKey = pDupeKey;
-	pScriptController->m_iDupeScore = iDupeScore;
-	pScriptController->m_eDupeMode = eDupeMode;
-	pScriptController->m_iPrefixLen = 0;
-
-	pScriptController->ExecuteScriptList(g_pOptions->GetScanScript());
-
-	delete pScriptController;
-}
-
-void ScanScriptController::ExecuteScript(ScriptConfig::Script* pScript)
-{
-	if (!pScript->GetScanScript() || !Util::FileExists(m_szNZBFilename))
-	{
-		return;
-	}
-
-	PrintMessage(Message::mkInfo, "Executing scan-script %s for %s", pScript->GetName(), Util::BaseFileName(m_szNZBFilename));
-
-	SetScript(pScript->GetLocation());
-	SetArgs(NULL, false);
-
-	char szInfoName[1024];
-	snprintf(szInfoName, 1024, "scan-script %s for %s", pScript->GetName(), Util::BaseFileName(m_szNZBFilename));
-	szInfoName[1024-1] = '\0';
-	SetInfoName(szInfoName);
-
-	SetLogPrefix(pScript->GetDisplayName());
-	m_iPrefixLen = strlen(pScript->GetDisplayName()) + 2; // 2 = strlen(": ");
-	PrepareParams(pScript->GetName());
-
-	Execute();
-
-	SetLogPrefix(NULL);
-}
-
-void ScanScriptController::PrepareParams(const char* szScriptName)
-{
-	ResetEnv();
-
-	SetEnvVar("NZBNP_FILENAME", m_szNZBFilename);
-	SetEnvVar("NZBNP_URL", m_szUrl);
-	SetEnvVar("NZBNP_NZBNAME", strlen(*m_pNZBName) > 0 ? *m_pNZBName : Util::BaseFileName(m_szNZBFilename));
-	SetEnvVar("NZBNP_CATEGORY", *m_pCategory);
-	SetIntEnvVar("NZBNP_PRIORITY", *m_iPriority);
-	SetIntEnvVar("NZBNP_TOP", *m_bAddTop ? 1 : 0);
-	SetIntEnvVar("NZBNP_PAUSED", *m_bAddPaused ? 1 : 0);
-	SetEnvVar("NZBNP_DUPEKEY", *m_pDupeKey);
-	SetIntEnvVar("NZBNP_DUPESCORE", *m_iDupeScore);
-
-	const char* szDupeModeName[] = { "SCORE", "ALL", "FORCE" };
-	SetEnvVar("NZBNP_DUPEMODE", szDupeModeName[*m_eDupeMode]);
-
-	// remove trailing slash
-	char szDir[1024];
-	strncpy(szDir, m_szDirectory, 1024);
-	szDir[1024-1] = '\0';
-	int iLen = strlen(szDir);
-	if (szDir[iLen-1] == PATH_SEPARATOR)
-	{
-		szDir[iLen-1] = '\0';
-	}
-	SetEnvVar("NZBNP_DIRECTORY", szDir);
-
-	PrepareEnvScript(m_pParameters, szScriptName);
-}
-
-void ScanScriptController::AddMessage(Message::EKind eKind, const char* szText)
-{
-	const char* szMsgText = szText + m_iPrefixLen;
-
-	if (!strncmp(szMsgText, "[NZB] ", 6))
-	{
-		debug("Command %s detected", szMsgText + 6);
-		if (!strncmp(szMsgText + 6, "NZBNAME=", 8))
-		{
-			free(*m_pNZBName);
-			*m_pNZBName = strdup(szMsgText + 6 + 8);
-		}
-		else if (!strncmp(szMsgText + 6, "CATEGORY=", 9))
-		{
-			free(*m_pCategory);
-			*m_pCategory = strdup(szMsgText + 6 + 9);
-			g_pScanner->InitPPParameters(*m_pCategory, m_pParameters, true);
-		}
-		else if (!strncmp(szMsgText + 6, "NZBPR_", 6))
-		{
-			char* szParam = strdup(szMsgText + 6 + 6);
-			char* szValue = strchr(szParam, '=');
-			if (szValue)
-			{
-				*szValue = '\0';
-				m_pParameters->SetParameter(szParam, szValue + 1);
-			}
-			else
-			{
-				error("Invalid command \"%s\" received from %s", szMsgText, GetInfoName());
-			}
-			free(szParam);
-		}
-		else if (!strncmp(szMsgText + 6, "PRIORITY=", 9))
-		{
-			*m_iPriority = atoi(szMsgText + 6 + 9);
-		}
-		else if (!strncmp(szMsgText + 6, "TOP=", 4))
-		{
-			*m_bAddTop = atoi(szMsgText + 6 + 4) != 0;
-		}
-		else if (!strncmp(szMsgText + 6, "PAUSED=", 7))
-		{
-			*m_bAddPaused = atoi(szMsgText + 6 + 7) != 0;
-		}
-		else if (!strncmp(szMsgText + 6, "DUPEKEY=", 8))
-		{
-			free(*m_pDupeKey);
-			*m_pDupeKey = strdup(szMsgText + 6 + 8);
-		}
-		else if (!strncmp(szMsgText + 6, "DUPESCORE=", 10))
-		{
-			*m_iDupeScore = atoi(szMsgText + 6 + 10);
-		}
-		else if (!strncmp(szMsgText + 6, "DUPEMODE=", 9))
-		{
-			const char* szDupeMode = szMsgText + 6 + 9;
-			if (strcasecmp(szDupeMode, "score") && strcasecmp(szDupeMode, "all") && strcasecmp(szDupeMode, "force"))
-			{
-				error("Invalid value \"%s\" for command \"DUPEMODE\" received from %s", szDupeMode, GetInfoName());
-				return;
-			}
-			*m_eDupeMode = !strcasecmp(szDupeMode, "all") ? dmAll :
-				!strcasecmp(szDupeMode, "force") ? dmForce : dmScore;
-		}
-		else
-		{
-			error("Invalid command \"%s\" received from %s", szMsgText, GetInfoName());
-		}
-	}
-	else
-	{
-		ScriptController::AddMessage(eKind, szText);
-	}
-}

daemon/extension/ScanScript.h

@@ -1,61 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2007-2015 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 SCANSCRIPT_H
-#define SCANSCRIPT_H
-
-#include "NzbScript.h"
-
-class ScanScriptController : public NZBScriptController
-{
-private:
-	const char*			m_szNZBFilename;
-	const char*			m_szUrl;
-	const char*			m_szDirectory;
-	char**				m_pNZBName;
-	char**				m_pCategory;
-	int*				m_iPriority;
-	NZBParameterList*	m_pParameters;
-	bool*				m_bAddTop;
-	bool*				m_bAddPaused;
-	char**				m_pDupeKey;
-	int*				m_iDupeScore;
-	EDupeMode*			m_eDupeMode;
-	int					m_iPrefixLen;
-
-	void				PrepareParams(const char* szScriptName);
-
-protected:
-	virtual void		ExecuteScript(ScriptConfig::Script* pScript);
-	virtual void		AddMessage(Message::EKind eKind, const char* szText);
-
-public:
-	static void			ExecuteScripts(const char* szNZBFilename, const char* szUrl,
-							const char* szDirectory, char** pNZBName, char** pCategory, int* iPriority,
-							NZBParameterList* pParameters, bool* bAddTop, bool* bAddPaused,
-							char** pDupeKey, int* iDupeScore, EDupeMode* eDupeMode);
-};
-
-#endif

daemon/extension/SchedulerScript.cpp

@@ -1,143 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2007-2015 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 <ctype.h>
-#ifndef WIN32
-#include <unistd.h>
-#endif
-#include <sys/stat.h>
-#include <stdio.h>
-
-#include "nzbget.h"
-#include "SchedulerScript.h"
-#include "Options.h"
-#include "Log.h"
-#include "Util.h"
-
-
-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(ScriptConfig::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/extension/SchedulerScript.h

@@ -1,50 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2007-2015 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 SCHEDULERSCRIPT_H
-#define SCHEDULERSCRIPT_H
-
-#include "NzbScript.h"
-
-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(ScriptConfig::Script* pScript);
-
-public:
-	virtual				~SchedulerScriptController();
-	virtual void		Run();
-	static void			StartScript(const char* szParam, bool bExternalProcess, int iTaskID);
-};
-
-#endif

daemon/extension/ScriptConfig.cpp

@@ -1,559 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2013-2015 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 <sys/stat.h>
-#include <set>
-
-#include "nzbget.h"
-#include "Util.h"
-#include "Options.h"
-#include "Log.h"
-#include "ScriptConfig.h"
-
-static const char* BEGIN_SCRIPT_SIGNATURE = "### NZBGET ";
-static const char* POST_SCRIPT_SIGNATURE = "POST-PROCESSING";
-static const char* SCAN_SCRIPT_SIGNATURE = "SCAN";
-static const char* QUEUE_SCRIPT_SIGNATURE = "QUEUE";
-static const char* SCHEDULER_SCRIPT_SIGNATURE = "SCHEDULER";
-static const char* FEED_SCRIPT_SIGNATURE = "FEED";
-static const char* END_SCRIPT_SIGNATURE = " SCRIPT";
-static const char* QUEUE_EVENTS_SIGNATURE = "### QUEUE EVENTS:";
-
-ScriptConfig* g_pScriptConfig = NULL;
-
-
-ScriptConfig::ConfigTemplate::ConfigTemplate(Script* pScript, const char* szTemplate)
-{
-	m_pScript = pScript;
-	m_szTemplate = strdup(szTemplate ? szTemplate : "");
-}
-
-ScriptConfig::ConfigTemplate::~ConfigTemplate()
-{
-	delete m_pScript;
-	free(m_szTemplate);
-}
-
-ScriptConfig::ConfigTemplates::~ConfigTemplates()
-{
-	for (iterator it = begin(); it != end(); it++)
-	{
-		delete *it;
-	}
-}
-
-
-ScriptConfig::Script::Script(const char* szName, const char* szLocation)
-{
-	m_szName = strdup(szName);
-	m_szLocation = strdup(szLocation);
-	m_szDisplayName = strdup(szName);
-	m_bPostScript = false;
-	m_bScanScript = false;
-	m_bQueueScript = false;
-	m_bSchedulerScript = false;
-	m_bFeedScript = false;
-	m_szQueueEvents = NULL;
-}
-
-ScriptConfig::Script::~Script()
-{
-	free(m_szName);
-	free(m_szLocation);
-	free(m_szDisplayName);
-	free(m_szQueueEvents);
-}
-
-void ScriptConfig::Script::SetDisplayName(const char* szDisplayName)
-{
-	free(m_szDisplayName);
-	m_szDisplayName = strdup(szDisplayName);
-}
-
-void ScriptConfig::Script::SetQueueEvents(const char* szQueueEvents)
-{
-	free(m_szQueueEvents);
-	m_szQueueEvents = szQueueEvents ? strdup(szQueueEvents) : NULL;
-}
-
-
-ScriptConfig::Scripts::~Scripts()
-{
-	Clear();
-}
-
-void ScriptConfig::Scripts::Clear()
-{
-	for (iterator it = begin(); it != end(); it++)
-	{
-		delete *it;
-	}
-	clear();
-}
-
-ScriptConfig::Script* ScriptConfig::Scripts::Find(const char* szName)
-{
-	for (iterator it = begin(); it != end(); it++)
-	{
-		Script* pScript = *it;
-		if (!strcmp(pScript->GetName(), szName))
-		{
-			return pScript;
-		}
-	}
-
-	return NULL;
-}
-
-
-ScriptConfig::ScriptConfig()
-{
-	InitScripts();
-	InitConfigTemplates();
-}
-
-ScriptConfig::~ScriptConfig()
-{
-}
-
-bool ScriptConfig::LoadConfig(Options::OptEntries* pOptEntries)
-{
-	// read config file
-	FILE* infile = fopen(g_pOptions->GetConfigFilename(), FOPEN_RB);
-
-	if (!infile)
-	{
-		return false;
-	}
-
-	int iBufLen = (int)Util::FileSize(g_pOptions->GetConfigFilename()) + 1;
-	char* buf = (char*)malloc(iBufLen);
-
-	while (fgets(buf, iBufLen - 1, infile))
-	{
-		// remove trailing '\n' and '\r' and spaces
-		Util::TrimRight(buf);
-
-		// skip comments and empty lines
-		if (buf[0] == 0 || buf[0] == '#' || strspn(buf, " ") == strlen(buf))
-		{
-			continue;
-		}
-
-		char* optname;
-		char* optvalue;
-		if (g_pOptions->SplitOptionString(buf, &optname, &optvalue))
-		{
-			Options::OptEntry* pOptEntry = new Options::OptEntry();
-			pOptEntry->SetName(optname);
-			pOptEntry->SetValue(optvalue);
-			pOptEntries->push_back(pOptEntry);
-
-			free(optname);
-			free(optvalue);
-		}
-	}
-
-	fclose(infile);
-	free(buf);
-
-	return true;
-}
-
-bool ScriptConfig::SaveConfig(Options::OptEntries* pOptEntries)
-{
-	// save to config file
-	FILE* infile = fopen(g_pOptions->GetConfigFilename(), FOPEN_RBP);
-
-	if (!infile)
-	{
-		return false;
-	}
-
-	std::vector<char*> config;
-	std::set<Options::OptEntry*> writtenOptions;
-
-	// read config file into memory array
-	int iBufLen = (int)Util::FileSize(g_pOptions->GetConfigFilename()) + 1;
-	char* buf = (char*)malloc(iBufLen);
-	while (fgets(buf, iBufLen - 1, infile))
-	{
-		config.push_back(strdup(buf));
-	}
-	free(buf);
-
-	// write config file back to disk, replace old values of existing options with new values
-	rewind(infile);
-	for (std::vector<char*>::iterator it = config.begin(); it != config.end(); it++)
-    {
-        char* buf = *it;
-
-		const char* eq = strchr(buf, '=');
-		if (eq && buf[0] != '#')
-		{
-			// remove trailing '\n' and '\r' and spaces
-			Util::TrimRight(buf);
-
-			char* optname;
-			char* optvalue;
-			if (g_pOptions->SplitOptionString(buf, &optname, &optvalue))
-			{
-				Options::OptEntry *pOptEntry = pOptEntries->FindOption(optname);
-				if (pOptEntry)
-				{
-					fputs(pOptEntry->GetName(), infile);
-					fputs("=", infile);
-					fputs(pOptEntry->GetValue(), infile);
-					fputs("\n", infile);
-					writtenOptions.insert(pOptEntry);
-				}
-
-				free(optname);
-				free(optvalue);
-			}
-		}
-		else
-		{
-			fputs(buf, infile);
-		}
-
-		free(buf);
-	}
-
-	// write new options
-	for (Options::OptEntries::iterator it = pOptEntries->begin(); it != pOptEntries->end(); it++)
-	{
-		Options::OptEntry* pOptEntry = *it;
-		std::set<Options::OptEntry*>::iterator fit = writtenOptions.find(pOptEntry);
-		if (fit == writtenOptions.end())
-		{
-			fputs(pOptEntry->GetName(), infile);
-			fputs("=", infile);
-			fputs(pOptEntry->GetValue(), infile);
-			fputs("\n", infile);
-		}
-	}
-
-	// close and truncate the file
-	int pos = (int)ftell(infile);
-	fclose(infile);
-
-	Util::TruncateFile(g_pOptions->GetConfigFilename(), pos);
-
-	return true;
-}
-
-bool ScriptConfig::LoadConfigTemplates(ConfigTemplates* pConfigTemplates)
-{
-	char* szBuffer;
-	int iLength;
-	if (!Util::LoadFileIntoBuffer(g_pOptions->GetConfigTemplate(), &szBuffer, &iLength))
-	{
-		return false;
-	}
-	ConfigTemplate* pConfigTemplate = new ConfigTemplate(NULL, szBuffer);
-	pConfigTemplates->push_back(pConfigTemplate);
-	free(szBuffer);
-
-	if (!g_pOptions->GetScriptDir())
-	{
-		return true;
-	}
-
-	Scripts scriptList;
-	LoadScripts(&scriptList);
-
-	const int iBeginSignatureLen = strlen(BEGIN_SCRIPT_SIGNATURE);
-	const int iQueueEventsSignatureLen = strlen(QUEUE_EVENTS_SIGNATURE);
-
-	for (Scripts::iterator it = scriptList.begin(); it != scriptList.end(); it++)
-	{
-		Script* pScript = *it;
-
-		FILE* infile = fopen(pScript->GetLocation(), FOPEN_RB);
-		if (!infile)
-		{
-			ConfigTemplate* pConfigTemplate = new ConfigTemplate(pScript, "");
-			pConfigTemplates->push_back(pConfigTemplate);
-			continue;
-		}
-
-		StringBuilder stringBuilder;
-		char buf[1024];
-		bool bInConfig = false;
-
-		while (fgets(buf, sizeof(buf) - 1, infile))
-		{
-			if (!strncmp(buf, BEGIN_SCRIPT_SIGNATURE, iBeginSignatureLen) &&
-				strstr(buf, END_SCRIPT_SIGNATURE) &&
-				(strstr(buf, POST_SCRIPT_SIGNATURE) ||
-				 strstr(buf, SCAN_SCRIPT_SIGNATURE) ||
-				 strstr(buf, QUEUE_SCRIPT_SIGNATURE) ||
-				 strstr(buf, SCHEDULER_SCRIPT_SIGNATURE) ||
-				 strstr(buf, FEED_SCRIPT_SIGNATURE)))
-			{
-				if (bInConfig)
-				{
-					break;
-				}
-				bInConfig = true;
-				continue;
-			}
-
-			bool bSkip = !strncmp(buf, QUEUE_EVENTS_SIGNATURE, iQueueEventsSignatureLen);
-
-			if (bInConfig && !bSkip)
-			{
-				stringBuilder.Append(buf);
-			}
-		}
-
-		fclose(infile);
-
-		ConfigTemplate* pConfigTemplate = new ConfigTemplate(pScript, stringBuilder.GetBuffer());
-		pConfigTemplates->push_back(pConfigTemplate);
-	}
-
-	// clearing the list without deleting of objects, which are in pConfigTemplates now 
-	scriptList.clear();
-
-	return true;
-}
-
-void ScriptConfig::InitConfigTemplates()
-{
-	if (!LoadConfigTemplates(&m_ConfigTemplates))
-	{
-		error("Could not read configuration templates");
-	}
-}
-
-void ScriptConfig::InitScripts()
-{
-	LoadScripts(&m_Scripts);
-}
-
-void ScriptConfig::LoadScripts(Scripts* pScripts)
-{
-	if (strlen(g_pOptions->GetScriptDir()) == 0)
-	{
-		return;
-	}
-
-	Scripts tmpScripts;
-	LoadScriptDir(&tmpScripts, g_pOptions->GetScriptDir(), false);
-	tmpScripts.sort(CompareScripts);
-
-	// first add all scripts from m_szScriptOrder
-	Tokenizer tok(g_pOptions->GetScriptOrder(), ",;");
-	while (const char* szScriptName = tok.Next())
-	{
-		Script* pScript = tmpScripts.Find(szScriptName);
-		if (pScript)
-		{
-			tmpScripts.remove(pScript);
-			pScripts->push_back(pScript);
-		}
-	}
-
-	// second add all other scripts from scripts directory
-	for (Scripts::iterator it = tmpScripts.begin(); it != tmpScripts.end(); it++)
-	{
-		Script* pScript = *it;
-		if (!pScripts->Find(pScript->GetName()))
-		{
-			pScripts->push_back(pScript);
-		}
-	}
-
-	tmpScripts.clear();
-
-	BuildScriptDisplayNames(pScripts);
-}
-
-void ScriptConfig::LoadScriptDir(Scripts* pScripts, const char* szDirectory, bool bIsSubDir)
-{
-	int iBufSize = 1024*10;
-	char* szBuffer = (char*)malloc(iBufSize+1);
-
-	const int iBeginSignatureLen = strlen(BEGIN_SCRIPT_SIGNATURE);
-	const int iQueueEventsSignatureLen = strlen(QUEUE_EVENTS_SIGNATURE);
-
-	DirBrowser dir(szDirectory);
-	while (const char* szFilename = dir.Next())
-	{
-		if (szFilename[0] != '.' && szFilename[0] != '_')
-		{
-			char szFullFilename[1024];
-			snprintf(szFullFilename, 1024, "%s%s", szDirectory, szFilename);
-			szFullFilename[1024-1] = '\0';
-
-			if (!Util::DirectoryExists(szFullFilename))
-			{
-				// check if the file contains pp-script-signature
-				FILE* infile = fopen(szFullFilename, FOPEN_RB);
-				if (infile)
-				{
-					// read first 10KB of the file and look for signature
-					int iReadBytes = fread(szBuffer, 1, iBufSize, infile);
-					fclose(infile);
-					szBuffer[iReadBytes] = 0;
-
-					// split buffer into lines
-					Tokenizer tok(szBuffer, "\n\r", true);
-					while (char* szLine = tok.Next())
-					{
-						if (!strncmp(szLine, BEGIN_SCRIPT_SIGNATURE, iBeginSignatureLen) &&
-							strstr(szLine, END_SCRIPT_SIGNATURE))
-						{
-							bool bPostScript = strstr(szLine, POST_SCRIPT_SIGNATURE);
-							bool bScanScript = strstr(szLine, SCAN_SCRIPT_SIGNATURE);
-							bool bQueueScript = strstr(szLine, QUEUE_SCRIPT_SIGNATURE);
-							bool bSchedulerScript = strstr(szLine, SCHEDULER_SCRIPT_SIGNATURE);
-							bool bFeedScript = strstr(szLine, FEED_SCRIPT_SIGNATURE);
-							if (bPostScript || bScanScript || bQueueScript || bSchedulerScript || bFeedScript)
-							{
-								char szScriptName[1024];
-								if (bIsSubDir)
-								{
-									char szDirectory2[1024];
-									snprintf(szDirectory2, 1024, "%s", szDirectory);
-									szDirectory2[1024-1] = '\0';
-									int iLen = strlen(szDirectory2);
-									if (szDirectory2[iLen-1] == PATH_SEPARATOR || szDirectory2[iLen-1] == ALT_PATH_SEPARATOR)
-									{
-										// trim last path-separator
-										szDirectory2[iLen-1] = '\0';
-									}
-
-									snprintf(szScriptName, 1024, "%s%c%s", Util::BaseFileName(szDirectory2), PATH_SEPARATOR, szFilename);
-								}
-								else
-								{
-									snprintf(szScriptName, 1024, "%s", szFilename);
-								}
-								szScriptName[1024-1] = '\0';
-
-								char* szQueueEvents = NULL;
-								if (bQueueScript)
-								{
-									while (char* szLine = tok.Next())
-									{
-										if (!strncmp(szLine, QUEUE_EVENTS_SIGNATURE, iQueueEventsSignatureLen))
-										{
-											szQueueEvents = szLine + iQueueEventsSignatureLen;
-											break;
-										}
-									}
-								}
-
-								Script* pScript = new Script(szScriptName, szFullFilename);
-								pScript->SetPostScript(bPostScript);
-								pScript->SetScanScript(bScanScript);
-								pScript->SetQueueScript(bQueueScript);
-								pScript->SetSchedulerScript(bSchedulerScript);
-								pScript->SetFeedScript(bFeedScript);
-								pScript->SetQueueEvents(szQueueEvents);
-								pScripts->push_back(pScript);
-								break;
-							}
-						}
-					}
-				}
-			}
-			else if (!bIsSubDir)
-			{
-				snprintf(szFullFilename, 1024, "%s%s%c", szDirectory, szFilename, PATH_SEPARATOR);
-				szFullFilename[1024-1] = '\0';
-
-				LoadScriptDir(pScripts, szFullFilename, true);
-			}
-		}
-	}
-
-	free(szBuffer);
-}
-
-bool ScriptConfig::CompareScripts(Script* pScript1, Script* pScript2)
-{
-	return strcmp(pScript1->GetName(), pScript2->GetName()) < 0;
-}
-
-void ScriptConfig::BuildScriptDisplayNames(Scripts* pScripts)
-{
-	// trying to use short name without path and extension.
-	// if there are other scripts with the same short name - using a longer name instead (with ot without extension)
-
-	for (Scripts::iterator it = pScripts->begin(); it != pScripts->end(); it++)
-	{
-		Script* pScript = *it;
-
-		char szShortName[256];
-		strncpy(szShortName, pScript->GetName(), 256);
-		szShortName[256-1] = '\0';
-		if (char* ext = strrchr(szShortName, '.')) *ext = '\0'; // strip file extension
-
-		const char* szDisplayName = Util::BaseFileName(szShortName);
-
-		for (Scripts::iterator it2 = pScripts->begin(); it2 != pScripts->end(); it2++)
-		{
-			Script* pScript2 = *it2;
-
-			char szShortName2[256];
-			strncpy(szShortName2, pScript2->GetName(), 256);
-			szShortName2[256-1] = '\0';
-			if (char* ext = strrchr(szShortName2, '.')) *ext = '\0'; // strip file extension
-
-			const char* szDisplayName2 = Util::BaseFileName(szShortName2);
-
-			if (!strcmp(szDisplayName, szDisplayName2) && pScript->GetName() != pScript2->GetName())
-			{
-				if (!strcmp(szShortName, szShortName2))
-				{
-					szDisplayName =	pScript->GetName();
-				}
-				else
-				{
-					szDisplayName =	szShortName;
-				}
-				break;
-			}
-		}
-
-		pScript->SetDisplayName(szDisplayName);
-	}
-}

daemon/extension/ScriptConfig.h

@@ -1,128 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2013-2015 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 SCRIPTCONFIG_H
-#define SCRIPTCONFIG_H
-
-#include <vector>
-#include <list>
-#include <time.h>
-
-#include "Options.h"
-
-class ScriptConfig
-{
-public:
-	class Script
-	{
-	private:
-		char*			m_szName;
-		char*			m_szLocation;
-		char*			m_szDisplayName;
-		bool			m_bPostScript;
-		bool			m_bScanScript;
-		bool			m_bQueueScript;
-		bool			m_bSchedulerScript;
-		bool			m_bFeedScript;
-		char*			m_szQueueEvents;
-
-	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; }
-		bool			GetFeedScript() { return m_bFeedScript; }
-		void			SetFeedScript(bool bFeedScript) { m_bFeedScript = bFeedScript; }
-		void			SetQueueEvents(const char* szQueueEvents);
-		const char*		GetQueueEvents() { return m_szQueueEvents; }
-	};
-
-	typedef std::list<Script*>  ScriptsBase;
-
-	class Scripts: public ScriptsBase
-	{
-	public:
-						~Scripts();
-		void			Clear();
-		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:
-	Scripts				m_Scripts;
-	ConfigTemplates		m_ConfigTemplates;
-
-	void				InitScripts();
-	void				InitConfigTemplates();
-	static bool			CompareScripts(Script* pScript1, Script* pScript2);
-	void				LoadScriptDir(Scripts* pScripts, const char* szDirectory, bool bIsSubDir);
-	void				BuildScriptDisplayNames(Scripts* pScripts);
-	void				LoadScripts(Scripts* pScripts);
-
-public:
-						ScriptConfig();
-						~ScriptConfig();
-	Scripts*			GetScripts() { return &m_Scripts; }
-	bool				LoadConfig(Options::OptEntries* pOptEntries);
-	bool				SaveConfig(Options::OptEntries* pOptEntries);
-	bool				LoadConfigTemplates(ConfigTemplates* pConfigTemplates);
-	ConfigTemplates*	GetConfigTemplates() { return &m_ConfigTemplates; }
-};
-
-extern ScriptConfig* g_pScriptConfig;
-
-#endif

daemon/feed/FeedCoordinator.cpp

@@ -1,802 +0,0 @@
-/*
- *  This file is part of nzbget
- *
- *  Copyright (C) 2013-2015 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 "FeedScript.h"
-#include "DiskState.h"
-#include "DupeCoordinator.h"
-
-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::FilterHelper::FilterHelper()
-{
-	m_pSeasonEpisodeRegEx = NULL;
-}
-
-FeedCoordinator::FilterHelper::~FilterHelper()
-{
-	delete m_pSeasonEpisodeRegEx;
-}
-
-void FeedCoordinator::FilterHelper::CalcDupeStatus(const char* szTitle, const char* szDupeKey, char* szStatusBuf, int iBufLen)
-{
-	const char* szDupeStatusName[] = { "", "QUEUED", "DOWNLOADING", "3", "SUCCESS", "5", "6", "7", "WARNING",
-		"9", "10", "11", "12", "13", "14", "15", "FAILURE" };
-	char szStatuses[200];
-	szStatuses[0] = '\0';
-
-	DownloadQueue* pDownloadQueue = DownloadQueue::Lock();
-	DupeCoordinator::EDupeStatus eDupeStatus = g_pDupeCoordinator->GetDupeStatus(pDownloadQueue, szTitle, szDupeKey);
-	DownloadQueue::Unlock();
-
-	for (int i = 1; i <= (int)DupeCoordinator::dsFailure; i = i << 1)
-	{
-		if (eDupeStatus & i)
-		{
-			if (*szStatuses)
-			{
-				strcat(szStatuses, ",");
-			}
-			strcat(szStatuses, szDupeStatusName[i]);
-		}
-	}
-
-	strncpy(szStatusBuf, szStatuses, iBufLen);
-}
-
-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())
-		{
-			FeedScriptController::ExecuteScripts(
-				!Util::EmptyStr(pFeedInfo->GetFeedScript()) ? pFeedInfo->GetFeedScript(): g_pOptions->GetFeedScript(),
-				pFeedInfo->GetOutputFilename(), pFeedInfo->GetID());
-			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->SetFeedFilterHelper(&m_FilterHelper);
-		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 && pFeedInfo->GetBacklog())
-			{
-				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->SetFeedID(pFeedInfo->GetID());
-	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->GetID(), pFeedInfo->GetName(), pFeedInfo->GetUrl(), pFeedInfo->GetFilter(), 
-		pFeedInfo->GetBacklog(), pFeedInfo->GetPauseNzb(), pFeedInfo->GetCategory(),
-		pFeedInfo->GetPriority(), pFeedInfo->GetInterval(), pFeedInfo->GetFeedScript(), 0, NULL, ppFeedItemInfos);
-}
-
-bool FeedCoordinator::PreviewFeed(int iID, const char* szName, const char* szUrl, const char* szFilter,
-	bool bBacklog, bool bPauseNzb, const char* szCategory, int iPriority, int iInterval, const char* szFeedScript,
-	int iCacheTimeSec, const char* szCacheId, FeedItemInfos** ppFeedItemInfos)
-{
-	debug("Preview feed %s", szName);
-
-	FeedInfo* pFeedInfo = new FeedInfo(iID, szName, szUrl, bBacklog, iInterval,
-		szFilter, bPauseNzb, szCategory, iPriority, szFeedScript);
-	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)
-		{
-			FeedScriptController::ExecuteScripts(
-				!Util::EmptyStr(pFeedInfo->GetFeedScript()) ? pFeedInfo->GetFeedScript(): g_pOptions->GetFeedScript(),
-				pFeedInfo->GetOutputFilename(), pFeedInfo->GetID());
-			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 && pFeedInfo->GetBacklog() ? 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();
-}