version 11.0

.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,74 +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.h.in~
-config.log
-config.status
-Makefile
-stamp-h1
-autom4te.cache/
-.dirstamp
-*.o-*
-
-# 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
-.vscode/
-
-# macOS
-.DS_Store
-
-# NZBGet specific
-nzbget
-code_revision.cpp
-*.temp
-*.pyc
-pytest.ini
-.cache

.lgtm.yml

@@ -1,17 +0,0 @@
-# Configuration file for integration with http://lgtm.com
-
-path_classifiers:
-  library:
-    # exclude these directories from default alerts report:
-    - lib
-    - webui/lib
-
-extraction:
-  cpp:
-    configure:
-      command:
-        # compile with tests to activate scanning of C++ sources for tests
-        - ./configure --enable-tests
-
-queries:
-  - exclude: js/incomplete-sanitization  # this one gives false positives only and nothing useful

.travis.yml

@@ -1,67 +0,0 @@
-sudo: required
-dist: trusty
-language: cpp
-
-matrix:
-  include:
-
-    - compiler: gcc
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-          packages:
-            - g++-5
-            - unrar
-            - p7zip-full
-            - par2
-      env:
-        - COMPILER=g++-5
-
-    - compiler: gcc
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-          packages:
-            - g++-4.9
-            - unrar
-            - p7zip-full
-            - par2
-      env:
-        - COMPILER=g++-4.9
-
-    - compiler: gcc
-      addons:
-        apt:
-          packages:
-            - unrar
-            - p7zip-full
-            - par2
-      env:
-        - COMPILER=g++-4.8
-        - CXXFLAGS="-std=c++11 -O2 -s"
-        - CONFIGUREOPTS="--disable-cpp-check"
-
-    - compiler: clang
-      addons:
-        apt:
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.6
-          packages:
-            - clang-3.6
-            - unrar
-            - p7zip-full
-            - par2
-      env:
-        - COMPILER=clang++-3.6
-
-install:
-  - sudo pip install -U pytest
-
-script:
-  - $COMPILER --version
-  - CXX=$COMPILER ./configure $CONFIGUREOPTS --enable-tests && make
-  - ./nzbget --tests
-  - cd tests/functional && pytest -v

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)
+	Andrey Prygunkov <hugbug@users.sourceforge.net>		    (versions 0.3.0 and later)

ArticleDownloader.h

@@ -0,0 +1,120 @@
+/*
+ *  This file is part of nzbget
+ *
+ *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007-2009 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 ARTICLEDOWNLOADER_H
+#define ARTICLEDOWNLOADER_H
+
+#include <time.h>
+
+#include "Observer.h"
+#include "DownloadInfo.h"
+#include "Thread.h"
+#include "NNTPConnection.h"
+#include "Decoder.h"
+
+class ArticleDownloader : public Thread, public Subject
+{
+public:
+	enum EStatus
+	{
+		adUndefined,
+		adRunning,
+		adWaiting,
+		adFinished,
+		adFailed,
+		adRetry,
+		adCrcError,
+		adDecoding,
+		adJoining,
+		adJoined,
+		adNotFound,
+		adConnectError,
+		adFatalError
+	};
+			
+private:
+	FileInfo*			m_pFileInfo;
+	ArticleInfo*		m_pArticleInfo;
+	NNTPConnection* 	m_pConnection;
+	EStatus				m_eStatus;
+	Mutex			 	m_mutexConnection;
+	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;
+	FILE*				m_pOutFile;
+	bool				m_bDuplicate;
+
+	EStatus				Download();
+	bool				Write(char* szLine, int iLen);
+	bool				PrepareFile(char* szLine);
+	bool				CreateOutputFile(int iSize);
+	void				BuildOutputFilename();
+	EStatus				DecodeCheck();
+	void				FreeConnection(bool bKeepConnected);
+	EStatus				CheckResponse(const char* szResponse, const char* szComment);
+	void				SetStatus(EStatus eStatus) { m_eStatus = eStatus; }
+	const char* 		GetTempFilename() { return m_szTempFilename; }
+	void 				SetTempFilename(const char* v);
+	void 				SetOutputFilename(const char* v);
+
+public:
+						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; }
+	EStatus				GetStatus() { return m_eStatus; }
+	virtual void		Run();
+	virtual void		Stop();
+	bool				Terminate();
+	time_t				GetLastUpdateTime() { return m_tLastUpdateTime; }
+	void				SetLastUpdateTimeNow() { m_tLastUpdateTime = ::time(NULL); }
+	const char* 		GetArticleFilename() { return m_szArticleFilename; }
+	void				SetInfoName(const char* v);
+	const char*			GetInfoName() { return m_szInfoName; }
+	void				CompleteFileParts();
+	static bool			MoveCompletedFiles(NZBInfo* pNZBInfo, const char* szOldDestDir);
+	void				SetConnection(NNTPConnection* pConnection) { m_pConnection = pConnection; }
+
+	void				LogDebugInfo();
+};
+
+class DownloadSpeedMeter
+{
+public:
+	virtual				~DownloadSpeedMeter() {};
+	virtual int			CalcCurrentDownloadSpeed() = 0;
+	virtual void		AddSpeedReading(int iBytes) = 0;
+};
+
+#endif

BinRpc.h

@@ -0,0 +1,159 @@
+/*
+ *  This file is part of nzbget
+ *
+ *  Copyright (C) 2005 Bo Cordes Petersen <placebodk@sourceforge.net>
+ *  Copyright (C) 2007-2009 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 BINRPC_H
+#define BINRPC_H
+
+#include "Connection.h"
+#include "MessageBase.h"
+
+class BinRpcProcessor
+{
+private:
+	SNZBRequestBase		m_MessageBase;
+	Connection*			m_pConnection;
+
+	void				Dispatch();
+
+public:
+						BinRpcProcessor();
+	void				Execute();
+	void				SetConnection(Connection* pConnection) { m_pConnection = pConnection; }
+};
+
+class BinCommand
+{
+protected:
+	Connection*			m_pConnection;
+	SNZBRequestBase*	m_pMessageBase;
+
+	bool				ReceiveRequest(void* pBuffer, int iSize);
+	void				SendBoolResponse(bool bSuccess, const char* szText);
+
+public:
+	virtual				~BinCommand() {}
+	virtual void		Execute() = 0;
+	void				SetConnection(Connection* pConnection) { m_pConnection = pConnection; }
+	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 ReloadBinCommand: 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();
+};
+
+class ScanBinCommand: public BinCommand
+{
+public:
+	virtual void		Execute();
+};
+
+class HistoryBinCommand: public BinCommand
+{
+public:
+	virtual void		Execute();
+};
+
+class DownloadUrlBinCommand: public BinCommand
+{
+public:
+	virtual void		Execute();
+};
+
+class UrlQueueBinCommand: public BinCommand
+{
+public:
+	virtual void		Execute();
+};
+
+#endif

COPYING

@@ -1,12 +1,12 @@
-                    GNU GENERAL PUBLIC LICENSE
-                       Version 2, June 1991
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
 
- Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+                       59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  Everyone is permitted to copy and distribute verbatim copies
  of this license document, but changing it is not allowed.
 
-                            Preamble
+			    Preamble
 
   The licenses for most software are designed to take away your
 freedom to share and change it.  By contrast, the GNU General Public
@@ -15,7 +15,7 @@ software--to make sure the software is free for all its users.  This
 General Public License applies to most of the Free Software
 Foundation's software and to any other program whose authors commit to
 using it.  (Some other Free Software Foundation software is covered by
-the GNU Lesser General Public License instead.)  You can apply it to
+the GNU Library General Public License instead.)  You can apply it to
 your programs, too.
 
   When we speak of free software, we are referring to freedom, not
@@ -55,8 +55,8 @@ patent must be licensed for everyone's free use or not licensed at all.
 
   The precise terms and conditions for copying, distribution and
 modification follow.
-
-                    GNU GENERAL PUBLIC LICENSE
+
+		    GNU GENERAL PUBLIC LICENSE
    TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
 
   0. This License applies to any program or other work which contains
@@ -110,7 +110,7 @@ above, provided that you also meet all of these conditions:
     License.  (Exception: if the Program itself is interactive but
     does not normally print such an announcement, your work based on
     the Program is not required to print an announcement.)
-
+
 These requirements apply to the modified work as a whole.  If
 identifiable sections of that work are not derived from the Program,
 and can be reasonably considered independent and separate works in
@@ -168,7 +168,7 @@ access to copy from a designated place, then offering equivalent
 access to copy the source code from the same place counts as
 distribution of the source code, even though third parties are not
 compelled to copy the source along with the object code.
-
+
   4. You may not copy, modify, sublicense, or distribute the Program
 except as expressly provided under this License.  Any attempt
 otherwise to copy, modify, sublicense or distribute the Program is
@@ -225,7 +225,7 @@ impose that choice.
 
 This section is intended to make thoroughly clear what is believed to
 be a consequence of the rest of this License.
-
+
   8. If the distribution and/or use of the Program is restricted in
 certain countries either by patents or by copyrighted interfaces, the
 original copyright holder who places the Program under this License
@@ -255,7 +255,7 @@ make exceptions for this.  Our decision will be guided by the two goals
 of preserving the free status of all derivatives of our free software and
 of promoting the sharing and reuse of software generally.
 
-                            NO WARRANTY
+			    NO WARRANTY
 
   11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
 FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
@@ -277,9 +277,9 @@ YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
 PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGES.
 
-                     END OF TERMS AND CONDITIONS
-
-            How to Apply These Terms to Your New Programs
+		     END OF TERMS AND CONDITIONS
+
+	    How to Apply These Terms to Your New Programs
 
   If you develop a new program, and you want it to be of the greatest
 possible use to the public, the best way to achieve this is to make it
@@ -303,9 +303,10 @@ the "copyright" line and a pointer to where the full notice is found.
     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.
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
 
 Also add information on how to contact you by electronic and paper mail.
 
@@ -335,5 +336,5 @@ necessary.  Here is a sample; alter the names:
 This General Public License does not permit incorporating your program into
 proprietary programs.  If your program is a subroutine library, you may
 consider it more useful to permit linking proprietary applications with the
-library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.
+library.  If this is what you want to do, use the GNU Library General
+Public License instead of this License.

ColoredFrontend.cpp

@@ -0,0 +1,194 @@
+/*
+ *  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>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef WIN32
+#include "win32.h"
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#ifndef WIN32
+#include <unistd.h>
+#endif
+
+#include "nzbget.h"
+#include "ColoredFrontend.h"
+#include "Util.h"
+
+ColoredFrontend::ColoredFrontend()
+{
+	m_bSummary = true;
+	m_bNeedGoBack = false;
+#ifdef WIN32
+	m_hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
+#endif
+}
+
+void ColoredFrontend::BeforePrint()
+{
+	if (m_bNeedGoBack)
+	{
+		// go back one line
+#ifdef WIN32
+		CONSOLE_SCREEN_BUFFER_INFO BufInfo;
+		GetConsoleScreenBufferInfo(m_hConsole, &BufInfo);
+		BufInfo.dwCursorPosition.Y--;
+		SetConsoleCursorPosition(m_hConsole, BufInfo.dwCursorPosition);
+#else
+		printf("\r\033[1A");
+#endif
+		m_bNeedGoBack = false;
+	}
+}
+
+void ColoredFrontend::PrintStatus()
+{
+	char tmp[1024];
+	char timeString[100];
+	timeString[0] = '\0';
+	int iCurrentDownloadSpeed = m_bStandBy ? 0 : m_iCurrentDownloadSpeed;
+
+	if (iCurrentDownloadSpeed > 0 && !(m_bPauseDownload || m_bPauseDownload2))
+	{
+		long long remain_sec = (long long)(m_lRemainingSize / iCurrentDownloadSpeed);
+		int h = (int)(remain_sec / 3600);
+		int m = (int)((remain_sec % 3600) / 60);
+		int s = (int)(remain_sec % 60);
+		sprintf(timeString, " (~ %.2d:%.2d:%.2d)", h, m, s);
+	}
+
+	char szDownloadLimit[128];
+	if (m_iDownloadLimit > 0)
+	{
+		sprintf(szDownloadLimit, ", Limit %.0f KB/s", (float)m_iDownloadLimit / 1024.0);
+	}
+	else
+	{
+		szDownloadLimit[0] = 0;
+	}
+
+    char szPostStatus[128];
+    if (m_iPostJobCount > 0)
+    {
+        sprintf(szPostStatus, ", %i post-job%s", m_iPostJobCount, m_iPostJobCount > 1 ? "s" : "");
+    }
+    else
+    {
+        szPostStatus[0] = 0;
+    }
+
+#ifdef WIN32
+	char* szControlSeq = "";
+#else
+	printf("\033[s");
+	const char* szControlSeq = "\033[K";
+#endif
+
+	snprintf(tmp, 1024, " %d threads, %.*f KB/s, %.2f MB remaining%s%s%s%s%s\n", 
+		m_iThreadCount, (iCurrentDownloadSpeed >= 10*1024 ? 0 : 1), (float)iCurrentDownloadSpeed / 1024.0, 
+		(float)(Util::Int64ToFloat(m_lRemainingSize) / 1024.0 / 1024.0), timeString, szPostStatus, 
+		m_bPauseDownload || m_bPauseDownload2 ? (m_bStandBy ? ", Paused" : ", Pausing") : "",
+		szDownloadLimit, szControlSeq);
+	tmp[1024-1] = '\0';
+	printf("%s", tmp);
+	m_bNeedGoBack = true;
+} 
+
+void ColoredFrontend::PrintMessage(Message * pMessage)
+{
+#ifdef WIN32
+	switch (pMessage->GetKind())
+	{
+		case Message::mkDebug:
+			SetConsoleTextAttribute(m_hConsole, 8);
+			printf("[DEBUG]");
+			break;
+		case Message::mkError:
+			SetConsoleTextAttribute(m_hConsole, 4);
+			printf("[ERROR]");
+			break; 
+		case Message::mkWarning:
+			SetConsoleTextAttribute(m_hConsole, 5);
+			printf("[WARNING]");
+			break;
+		case Message::mkInfo:
+			SetConsoleTextAttribute(m_hConsole, 2);
+			printf("[INFO]");
+			break;
+		case Message::mkDetail:
+			SetConsoleTextAttribute(m_hConsole, 2);
+			printf("[DETAIL]");
+			break;
+	}
+	SetConsoleTextAttribute(m_hConsole, 7);
+	char* msg = strdup(pMessage->GetText());
+	CharToOem(msg, msg);
+	printf(" %s\n", msg);
+	free(msg);
+#else
+	const char* msg = pMessage->GetText();
+	switch (pMessage->GetKind())
+	{
+		case Message::mkDebug:
+			printf("[DEBUG] %s\033[K\n", msg);
+			break;
+		case Message::mkError:
+			printf("\033[31m[ERROR]\033[39m %s\033[K\n", msg);
+			break;
+		case Message::mkWarning:
+			printf("\033[35m[WARNING]\033[39m %s\033[K\n", msg);
+			break;
+		case Message::mkInfo:
+			printf("\033[32m[INFO]\033[39m %s\033[K\n", msg);
+			break;
+		case Message::mkDetail:
+			printf("\033[32m[DETAIL]\033[39m %s\033[K\n", msg);
+			break;
+	}
+#endif
+}
+
+void ColoredFrontend::PrintSkip()
+{
+#ifdef WIN32
+	printf(".....\n");
+#else
+	printf(".....\033[K\n");
+#endif
+}
+
+void ColoredFrontend::BeforeExit()
+{
+	if (IsRemoteMode())
+	{
+		printf("\n");
+	}
+}

ColoredFrontend.h

@@ -1,8 +1,8 @@
 /*
- *  This file is part of nzbget. See <http://nzbget.net>.
+ *  This file if part of nzbget
  *
- *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
- *  Copyright (C) 2007-2016 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrey Prygunkov <hugbug@users.sourceforge.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -15,7 +15,12 @@
  *  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, see <http://www.gnu.org/licenses/>.
+ *  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$
+ *
  */
 
 
@@ -27,22 +32,22 @@
 
 class ColoredFrontend : public LoggableFrontend
 {
-public:
-	ColoredFrontend();
-
-protected:
-	virtual void BeforePrint();
-	virtual void PrintMessage(Message& message);
-	virtual void PrintStatus();
-	virtual void PrintSkip();
-	virtual void BeforeExit();
-
 private:
-	bool m_needGoBack = false;
+	bool			m_bNeedGoBack;
 
 #ifdef WIN32
-	HANDLE m_console;
+	HANDLE			m_hConsole;
 #endif
+
+protected:
+	virtual void 	BeforePrint();
+	virtual void	PrintMessage(Message* pMessage);
+	virtual void 	PrintStatus();
+	virtual void 	PrintSkip();
+	virtual void	BeforeExit();
+
+public:
+	ColoredFrontend();
 };
 
 #endif

Connection.cpp

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

Connection.h

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

Decoder.cpp

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

Decoder.h

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

DiskState.h

@@ -0,0 +1,64 @@
+/*
+ *  This file is part of nzbget
+ *
+ *  Copyright (C) 2007-2013 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * $Revision$
+ * $Date$
+ *                                                          
+ */
+
+
+#ifndef DISKSTATE_H
+#define DISKSTATE_H
+
+#include "DownloadInfo.h"
+
+class DiskState
+{
+private:
+	int					ParseFormatVersion(const char* szFormatSignature);
+	bool				SaveFileInfo(FileInfo* pFileInfo, const char* szFilename);
+	bool				LoadFileInfo(FileInfo* pFileInfo, const char* szFilename, bool bFileSummary, bool bArticles);
+	void				SaveNZBList(DownloadQueue* pDownloadQueue, FILE* outfile);
+	bool				LoadNZBList(DownloadQueue* pDownloadQueue, FILE* infile, int iFormatVersion);
+	void				SaveFileQueue(DownloadQueue* pDownloadQueue, FileQueue* pFileQueue, FILE* outfile);
+	bool				LoadFileQueue(DownloadQueue* pDownloadQueue, FileQueue* pFileQueue, FILE* infile, int iFormatVersion);
+	void				SavePostQueue(DownloadQueue* pDownloadQueue, FILE* outfile);
+	bool				LoadPostQueue(DownloadQueue* pDownloadQueue, FILE* infile, int iFormatVersion);
+	bool				LoadOldPostQueue(DownloadQueue* pDownloadQueue);
+	void				SaveUrlQueue(DownloadQueue* pDownloadQueue, FILE* outfile);
+	bool				LoadUrlQueue(DownloadQueue* pDownloadQueue, FILE* infile, int iFormatVersion);
+	void				SaveUrlInfo(UrlInfo* pUrlInfo, FILE* outfile);
+	bool				LoadUrlInfo(UrlInfo* pUrlInfo, FILE* infile, int iFormatVersion);
+	void				SaveHistory(DownloadQueue* pDownloadQueue, FILE* outfile);
+	bool				LoadHistory(DownloadQueue* pDownloadQueue, FILE* infile, int iFormatVersion);
+	int					FindNZBInfoIndex(DownloadQueue* pDownloadQueue, NZBInfo* pNZBInfo);
+
+public:
+	bool				DownloadQueueExists();
+	bool				PostQueueExists(bool bCompleted);
+	bool				SaveDownloadQueue(DownloadQueue* pDownloadQueue);
+	bool				LoadDownloadQueue(DownloadQueue* pDownloadQueue);
+	bool				SaveFile(FileInfo* pFileInfo);
+	bool				LoadArticles(FileInfo* pFileInfo);
+	void				DiscardDownloadQueue();
+	bool				DiscardFile(FileInfo* pFileInfo);
+	void				CleanupTempDir(DownloadQueue* pDownloadQueue);
+};
+
+#endif

DownloadInfo.h

@@ -0,0 +1,591 @@
+/*
+ *  This file is part of nzbget
+ *
+ *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007-2013 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifndef DOWNLOADINFO_H
+#define DOWNLOADINFO_H
+
+#include <vector>
+#include <deque>
+#include <time.h>
+
+#include "Log.h"
+#include "Thread.h"
+
+class NZBInfo;
+class DownloadQueue;
+
+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;
+	time_t				m_tTime;
+	bool				m_bPaused;
+	bool				m_bDeleted;
+	bool				m_bFilenameConfirmed;
+	int					m_iCompleted;
+	bool				m_bOutputInitialized;
+	char*				m_szOutputFilename;
+	Mutex*				m_pMutexOutputFile;
+	int					m_iPriority;
+	bool				m_bExtraPriority;
+	int					m_iActiveDownloads;
+	bool				m_bAutoDeleted;
+
+	static int			m_iIDGen;
+
+public:
+						FileInfo();
+						~FileInfo();
+	int					GetID() { return m_iID; }
+	void				SetID(int iID);
+	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; }
+	time_t				GetTime() { return m_tTime; }
+	void				SetTime(time_t tTime) { m_tTime = tTime; }
+	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();
+	const char*			GetOutputFilename() { return m_szOutputFilename; }
+	void 				SetOutputFilename(const char* szOutputFilename);
+	bool				GetOutputInitialized() { return m_bOutputInitialized; }
+	void				SetOutputInitialized(bool bOutputInitialized) { m_bOutputInitialized = bOutputInitialized; }
+	bool				IsDupe(const char* szFilename);
+	int					GetPriority() { return m_iPriority; }
+	void				SetPriority(int iPriority) { m_iPriority = iPriority; }
+	bool				GetExtraPriority() { return m_bExtraPriority; }
+	void				SetExtraPriority(bool bExtraPriority) { m_bExtraPriority = bExtraPriority; };
+	int					GetActiveDownloads() { return m_iActiveDownloads; }
+	void				SetActiveDownloads(int iActiveDownloads);
+	bool				GetAutoDeleted() { return m_bAutoDeleted; }
+	void				SetAutoDeleted(bool bAutoDeleted) { m_bAutoDeleted = bAutoDeleted; }
+};
+                              
+typedef std::deque<FileInfo*> FileQueue;
+
+class GroupInfo
+{
+private:
+	NZBInfo*			m_pNZBInfo;
+	int					m_iFirstID;
+	int					m_iLastID;
+	int		 			m_iRemainingFileCount;
+	int					m_iPausedFileCount;
+	long long 			m_lRemainingSize;
+	long long 			m_lPausedSize;
+	int					m_iRemainingParCount;
+	time_t				m_tMinTime;
+	time_t				m_tMaxTime;
+	int					m_iMinPriority;
+	int					m_iMaxPriority;
+	int					m_iActiveDownloads;
+
+	friend class DownloadQueue;
+
+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					GetPausedFileCount() { return m_iPausedFileCount; }
+	int					GetRemainingParCount() { return m_iRemainingParCount; }
+	time_t				GetMinTime() { return m_tMinTime; }
+	time_t				GetMaxTime() { return m_tMaxTime; }
+	int					GetMinPriority() { return m_iMinPriority; }
+	int					GetMaxPriority() { return m_iMaxPriority; }
+	int					GetActiveDownloads() { return m_iActiveDownloads; }
+};
+
+typedef std::deque<GroupInfo*> GroupQueue;
+
+class NZBParameter
+{
+private:
+	char* 				m_szName;
+	char* 				m_szValue;
+
+	void				SetValue(const char* szValue);
+
+	friend class NZBParameterList;
+
+public:
+						NZBParameter(const char* szName);
+						~NZBParameter();
+	const char*			GetName() { return m_szName; }
+	const char*			GetValue() { return m_szValue; }
+};
+
+typedef std::deque<NZBParameter*> NZBParameterListBase;
+
+class NZBParameterList : public NZBParameterListBase
+{
+public:
+	void				SetParameter(const char* szName, const char* szValue);
+};
+
+class ScriptStatus
+{
+public:
+	enum EStatus
+	{
+		srNone,
+		srFailure,
+		srSuccess
+	};
+
+private:
+	char* 				m_szName;
+	EStatus				m_eStatus;
+	
+	friend class ScriptStatusList;
+	
+public:
+						ScriptStatus(const char* szName, EStatus eStatus);
+						~ScriptStatus();
+	const char*			GetName() { return m_szName; }
+	EStatus				GetStatus() { return m_eStatus; }
+};
+
+typedef std::deque<ScriptStatus*> ScriptStatusListBase;
+
+class ScriptStatusList : public ScriptStatusListBase
+{
+public:
+						~ScriptStatusList();
+	void				Add(const char* szScriptName, ScriptStatus::EStatus eStatus);
+	void				Clear();
+	ScriptStatus::EStatus	CalcTotalStatus();
+};
+
+class NZBInfoList;
+
+class NZBInfo
+{
+public:
+	enum ERenameStatus
+	{
+		rsNone,
+		rsSkipped,
+		rsFailure,
+		rsSuccess
+	};
+
+	enum EParStatus
+	{
+		psNone,
+		psSkipped,
+		psFailure,
+		psSuccess,
+		psRepairPossible,
+		psManual
+	};
+
+	enum EUnpackStatus
+	{
+		usNone,
+		usSkipped,
+		usFailure,
+		usSuccess
+	};
+
+	enum ECleanupStatus
+	{
+		csNone,
+		csFailure,
+		csSuccess
+	};
+
+	enum EMoveStatus
+	{
+		msNone,
+		msFailure,
+		msSuccess
+	};
+
+	typedef std::vector<char*>			Files;
+	typedef std::deque<Message*>		Messages;
+
+private:
+	int					m_iID;
+	int					m_iRefCount;
+	char* 				m_szFilename;
+	char*				m_szName;
+	char* 				m_szDestDir;
+	char* 				m_szCategory;
+	int		 			m_iFileCount;
+	int		 			m_iParkedFileCount;
+	long long 			m_lSize;
+	Files				m_completedFiles;
+	bool				m_bPostProcess;
+	ERenameStatus		m_eRenameStatus;
+	EParStatus			m_eParStatus;
+	EUnpackStatus		m_eUnpackStatus;
+	ECleanupStatus		m_eCleanupStatus;
+	EMoveStatus			m_eMoveStatus;
+	char*				m_szQueuedFilename;
+	bool				m_bDeleted;
+	bool				m_bParCleanup;
+	bool				m_bParManual;
+	bool				m_bCleanupDisk;
+	bool				m_bUnpackCleanedUpDisk;
+	NZBInfoList*		m_Owner;
+	NZBParameterList	m_ppParameters;
+	ScriptStatusList	m_scriptStatuses;
+	Mutex				m_mutexLog;
+	Messages			m_Messages;
+	int					m_iIDMessageGen;
+
+	static int			m_iIDGen;
+
+	friend class NZBInfoList;
+
+public:
+						NZBInfo();
+						~NZBInfo();
+	void				AddReference();
+	void				Release();
+	int					GetID() { return m_iID; }
+	void				SetID(int iID);
+	const char*			GetFilename() { return m_szFilename; }
+	void				SetFilename(const char* szFilename);
+	static void			MakeNiceNZBName(const char* szNZBFilename, char* szBuffer, int iSize, bool bRemoveExt);
+	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)
+	const char*			GetName() { return m_szName; } 	   // needs locking (for shared objects)
+	void				SetName(const char* szName);	   // needs locking (for shared objects)
+	long long 			GetSize() { return m_lSize; }
+	void 				SetSize(long long lSize) { m_lSize = lSize; }
+	int					GetFileCount() { return m_iFileCount; }
+	void 				SetFileCount(int iFileCount) { m_iFileCount = iFileCount; }
+	int					GetParkedFileCount() { return m_iParkedFileCount; }
+	void 				SetParkedFileCount(int iParkedFileCount) { m_iParkedFileCount = iParkedFileCount; }
+	void				BuildDestDirName();
+	void				BuildFinalDirName(char* szFinalDirBuf, int iBufSize);
+	Files*				GetCompletedFiles() { return &m_completedFiles; }		// needs locking (for shared objects)
+	void				ClearCompletedFiles();
+	bool				GetPostProcess() { return m_bPostProcess; }
+	void				SetPostProcess(bool bPostProcess) { m_bPostProcess = bPostProcess; }
+	ERenameStatus		GetRenameStatus() { return m_eRenameStatus; }
+	void				SetRenameStatus(ERenameStatus eRenameStatus) { m_eRenameStatus = eRenameStatus; }
+	EParStatus			GetParStatus() { return m_eParStatus; }
+	void				SetParStatus(EParStatus eParStatus) { m_eParStatus = eParStatus; }
+	EUnpackStatus		GetUnpackStatus() { return m_eUnpackStatus; }
+	void				SetUnpackStatus(EUnpackStatus eUnpackStatus) { m_eUnpackStatus = eUnpackStatus; }
+	ECleanupStatus		GetCleanupStatus() { return m_eCleanupStatus; }
+	void				SetCleanupStatus(ECleanupStatus eCleanupStatus) { m_eCleanupStatus = eCleanupStatus; }
+	EMoveStatus			GetMoveStatus() { return m_eMoveStatus; }
+	void				SetMoveStatus(EMoveStatus eMoveStatus) { m_eMoveStatus = eMoveStatus; }
+	const char*			GetQueuedFilename() { return m_szQueuedFilename; }
+	void				SetQueuedFilename(const char* szQueuedFilename);
+	bool				GetDeleted() { return m_bDeleted; }
+	void				SetDeleted(bool bDeleted) { m_bDeleted = bDeleted; }
+	bool				GetParCleanup() { return m_bParCleanup; }
+	void				SetParCleanup(bool bParCleanup) { m_bParCleanup = bParCleanup; }
+	bool				GetCleanupDisk() { return m_bCleanupDisk; }
+	void				SetCleanupDisk(bool bCleanupDisk) { m_bCleanupDisk = bCleanupDisk; }
+	bool				GetUnpackCleanedUpDisk() { return m_bUnpackCleanedUpDisk; }
+	void				SetUnpackCleanedUpDisk(bool bUnpackCleanedUpDisk) { m_bUnpackCleanedUpDisk = bUnpackCleanedUpDisk; }
+	NZBParameterList*	GetParameters() { return &m_ppParameters; }				// needs locking (for shared objects)
+	void				SetParameter(const char* szName, const char* szValue);	// needs locking (for shared objects)
+	ScriptStatusList*	GetScriptStatuses() { return &m_scriptStatuses; }        // needs locking (for shared objects)
+	void				AppendMessage(Message::EKind eKind, time_t tTime, const char* szText);
+	Messages*			LockMessages();
+	void				UnlockMessages();
+};
+
+typedef std::deque<NZBInfo*> NZBInfoListBase;
+
+class NZBInfoList : public NZBInfoListBase
+{
+public:
+	void				Add(NZBInfo* pNZBInfo);
+	void				Remove(NZBInfo* pNZBInfo);
+	void				ReleaseAll();
+};
+
+class PostInfo
+{
+public:
+	enum EStage
+	{
+		ptQueued,
+		ptLoadingPars,
+		ptVerifyingSources,
+		ptRepairing,
+		ptVerifyingRepaired,
+		ptRenaming,
+		ptUnpacking,
+		ptMoving,
+		ptExecutingScript,
+		ptFinished
+	};
+
+	typedef std::deque<Message*>	Messages;
+
+private:
+	int					m_iID;
+	NZBInfo*			m_pNZBInfo;
+	char*				m_szInfoName;
+	bool				m_bWorking;
+	bool				m_bDeleted;
+	bool				m_bRequestParCheck;
+	bool				m_bRequestParRename;
+	EStage				m_eStage;
+	char*				m_szProgressLabel;
+	int					m_iFileProgress;
+	int					m_iStageProgress;
+	time_t				m_tStartTime;
+	time_t				m_tStageTime;
+	Thread*				m_pPostThread;
+	
+	Mutex				m_mutexLog;
+	Messages			m_Messages;
+	int					m_iIDMessageGen;
+
+	static int			m_iIDGen;
+
+public:
+						PostInfo();
+						~PostInfo();
+	int					GetID() { return m_iID; }
+	NZBInfo*			GetNZBInfo() { return m_pNZBInfo; }
+	void				SetNZBInfo(NZBInfo* pNZBInfo);
+	const char*			GetInfoName() { return m_szInfoName; }
+	void				SetInfoName(const char* szInfoName);
+	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				GetDeleted() { return m_bDeleted; }
+	void				SetDeleted(bool bDeleted) { m_bDeleted = bDeleted; }
+	bool				GetRequestParCheck() { return m_bRequestParCheck; }
+	void				SetRequestParCheck(bool bRequestParCheck) { m_bRequestParCheck = bRequestParCheck; }
+	bool				GetRequestParRename() { return m_bRequestParRename; }
+	void				SetRequestParRename(bool bRequestParRename) { m_bRequestParRename = bRequestParRename; }
+	void				AppendMessage(Message::EKind eKind, const char* szText);
+	Thread*				GetPostThread() { return m_pPostThread; }
+	void				SetPostThread(Thread* pPostThread) { m_pPostThread = pPostThread; }
+	Messages*			LockMessages();
+	void				UnlockMessages();
+};
+
+typedef std::deque<PostInfo*> PostQueue;
+
+typedef std::vector<int> IDList;
+
+typedef std::vector<char*> NameList;
+
+class UrlInfo
+{
+public:
+	enum EStatus
+	{
+		aiUndefined,
+		aiRunning,
+		aiFinished,
+		aiFailed,
+		aiRetry
+	};
+
+private:
+	int					m_iID;
+	char*				m_szURL;
+	char*				m_szNZBFilename;
+	char* 				m_szCategory;
+	int					m_iPriority;
+	bool				m_bAddTop;
+	bool				m_bAddPaused;
+	EStatus				m_eStatus;
+
+	static int			m_iIDGen;
+
+public:
+						UrlInfo();
+						~UrlInfo();
+	int					GetID() { return m_iID; }
+	void				SetID(int iID);
+	const char*			GetURL() { return m_szURL; }			// needs locking (for shared objects)
+	void				SetURL(const char* szURL);				// needs locking (for shared objects)
+	const char*			GetNZBFilename() { return m_szNZBFilename; }		// needs locking (for shared objects)
+	void				SetNZBFilename(const char* szNZBFilename);			// 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)
+	int					GetPriority() { return m_iPriority; }
+	void				SetPriority(int iPriority) { m_iPriority = iPriority; }
+	bool				GetAddTop() { return m_bAddTop; }
+	void				SetAddTop(bool bAddTop) { m_bAddTop = bAddTop; }
+	bool				GetAddPaused() { return m_bAddPaused; }
+	void				SetAddPaused(bool bAddPaused) { m_bAddPaused = bAddPaused; }
+	void				GetName(char* szBuffer, int iSize);		// needs locking (for shared objects)
+	static void			MakeNiceName(const char* szURL, const char* szNZBFilename, char* szBuffer, int iSize);
+	EStatus				GetStatus() { return m_eStatus; }
+	void				SetStatus(EStatus Status) { m_eStatus = Status; }
+};
+
+typedef std::deque<UrlInfo*> UrlQueue;
+
+class HistoryInfo
+{
+public:
+	enum EKind
+	{
+		hkUnknown,
+		hkNZBInfo,
+		hkUrlInfo
+	};
+
+private:
+	int					m_iID;
+	EKind				m_eKind;
+	void*				m_pInfo;
+	time_t				m_tTime;
+
+	static int			m_iIDGen;
+
+public:
+						HistoryInfo(NZBInfo* pNZBInfo);
+						HistoryInfo(UrlInfo* pUrlInfo);
+						~HistoryInfo();
+	int					GetID() { return m_iID; }
+	void				SetID(int iID);
+	EKind				GetKind() { return m_eKind; }
+	NZBInfo*			GetNZBInfo() { return (NZBInfo*)m_pInfo; }
+	UrlInfo*			GetUrlInfo() { return (UrlInfo*)m_pInfo; }
+	void				DiscardUrlInfo() { m_pInfo = NULL; }
+	time_t				GetTime() { return m_tTime; }
+	void				SetTime(time_t tTime) { m_tTime = tTime; }
+	void				GetName(char* szBuffer, int iSize);		// needs locking (for shared objects)
+};
+
+typedef std::deque<HistoryInfo*> HistoryList;
+
+class DownloadQueue
+{
+protected:
+	NZBInfoList			m_NZBInfoList;
+	FileQueue			m_FileQueue;
+	PostQueue			m_PostQueue;
+	HistoryList			m_HistoryList;
+	FileQueue			m_ParkedFiles;
+	UrlQueue			m_UrlQueue;
+
+public:
+	NZBInfoList*		GetNZBInfoList() { return &m_NZBInfoList; }
+	FileQueue*			GetFileQueue() { return &m_FileQueue; }
+	PostQueue*			GetPostQueue() { return &m_PostQueue; }
+	HistoryList*		GetHistoryList() { return &m_HistoryList; }
+	FileQueue*			GetParkedFiles() { return &m_ParkedFiles; }
+	UrlQueue*			GetUrlQueue() { return &m_UrlQueue; }
+	void				BuildGroups(GroupQueue* pGroupQueue);
+};
+
+class DownloadQueueHolder
+{
+public:
+	virtual					~DownloadQueueHolder() {};
+	virtual DownloadQueue*	LockQueue() = 0;
+	virtual void			UnlockQueue() = 0;
+};
+
+#endif

Frontend.cpp

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

Frontend.h

@@ -0,0 +1,86 @@
+/*
+ *  This file is part of nzbget
+ *
+ *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007-2010 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 FRONTEND_H
+#define FRONTEND_H
+
+#include "Thread.h"
+#include "Log.h"
+#include "DownloadInfo.h"
+#include "MessageBase.h"
+#include "QueueEditor.h"
+
+class Frontend : public Thread
+{
+private:
+	Log::Messages		m_RemoteMessages;
+	DownloadQueue		m_RemoteQueue;
+
+	bool				RequestMessages();
+	bool				RequestFileList();
+
+protected:
+	bool				m_bSummary;
+	bool				m_bFileList;
+	unsigned int		m_iNeededLogEntries;
+	unsigned int		m_iNeededLogFirstID;
+	int					m_iUpdateInterval;
+
+	// summary
+	int					m_iCurrentDownloadSpeed;
+	long long 			m_lRemainingSize;
+	bool				m_bPauseDownload;
+	bool				m_bPauseDownload2;
+	int					m_iDownloadLimit;
+	int					m_iThreadCount;
+	int					m_iPostJobCount;
+	int					m_iUpTimeSec;
+	int					m_iDnTimeSec;
+	long long			m_iAllBytes;
+	bool				m_bStandBy;
+
+	bool				PrepareData();
+	void				FreeData();
+	Log::Messages*		LockMessages();
+	void				UnlockMessages();
+	DownloadQueue*		LockQueue();
+	void				UnlockQueue();
+	bool				IsRemoteMode();
+	void				InitMessageBase(SNZBRequestBase* pMessageBase, int iRequest, int iSize);
+	void				ServerPauseUnpause(bool bPause, bool bSecondRegister);
+	bool				RequestPauseUnpause(bool bPause, bool bSecondRegister);
+	void				ServerSetDownloadRate(int iRate);
+	bool				RequestSetDownloadRate(int iRate);
+	void				ServerDumpDebug();
+	bool				RequestDumpDebug();
+	bool 				ServerEditQueue(QueueEditor::EEditAction eAction, int iOffset, int iEntry);
+	bool 				RequestEditQueue(eRemoteEditAction iAction, int iOffset, int iID);
+
+public:
+						Frontend();
+};
+
+#endif

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,416 @@
+/*
+ *  This file is part of nzbget
+ *
+ *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007-2013 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef WIN32
+#include "win32.h"
+#else
+#include <pthread.h>
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <stdarg.h>
+#include <stdio.h>
+
+#include "nzbget.h"
+#include "Options.h"
+#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()
+{
+	Clear();
+	if (m_szLogFilename)
+	{
+		free(m_szLogFilename);
+	}
+}
+
+void Log::Filelog(const char* msg, ...)
+{
+	if (m_szLogFilename)
+	{
+		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, "ab+");
+		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);
+		}
+	}
+}
+
+#ifdef DEBUG
+#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
+{
+	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 && g_pLog->m_bExtraDebug)
+	{
+		printf("%s\n", tmp2);
+	}
+
+	Options::EMessageTarget eMessageTarget = g_pOptions ? g_pOptions->GetDebugTarget() : Options::mtScreen;
+	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 ? g_pOptions->GetErrorTarget() : Options::mtBoth;
+	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 ? g_pOptions->GetWarningTarget() : Options::mtScreen;
+	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 ? g_pOptions->GetInfoTarget() : Options::mtScreen;
+	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 ? g_pOptions->GetDetailTarget() : Options::mtScreen;
+	if (eMessageTarget == Options::mtLog || eMessageTarget == Options::mtBoth)
+	{
+		g_pLog->Filelog("DETAIL\t%s", tmp2);
+	}
+	if (eMessageTarget == Options::mtScreen || eMessageTarget == Options::mtBoth)
+	{
+		g_pLog->AppendMessage(Message::mkDetail, tmp2);
+	}
+
+	g_pLog->m_mutexLog.Unlock();
+}
+
+void abort(const char* msg, ...)
+{
+	char tmp2[1024];
+
+	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::Clear()
+{
+	m_mutexLog.Lock();
+	for (Messages::iterator it = m_Messages.begin(); it != m_Messages.end(); it++)
+	{
+		delete *it;
+	}
+	m_Messages.clear();
+	m_mutexLog.Unlock();
+}
+
+void Log::AppendMessage(Message::EKind eKind, const char * szText)
+{
+	Message* pMessage = new Message(++m_iIDGen, eKind, time(NULL), szText);
+	m_Messages.push_back(pMessage);
+
+	if (g_pOptions)
+	{
+		while (m_Messages.size() > (unsigned int)g_pOptions->GetLogBufferSize())
+		{
+			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());
+}
+
+/*
+* During intializing stage (when options were not read yet) all messages
+* are saved in screen log, even if they shouldn't (according to options).
+* Method "InitOptions()" check all messages added to screen log during
+* intializing stage and does three things:
+* 1) save the messages to log-file (if they should according to options);
+* 2) delete messages from screen log (if they should not be saved in screen log).
+* 3) renumerate IDs
+*/
+void Log::InitOptions()
+{
+	const char* szMessageType[] = { "INFO", "WARNING", "ERROR", "DEBUG", "DETAIL"};
+
+	if (g_pOptions->GetCreateLog() && g_pOptions->GetLogFile())
+	{
+		m_szLogFilename = strdup(g_pOptions->GetLogFile());
+	}
+
+	m_iIDGen = 0;
+
+	for (unsigned int i = 0; i < m_Messages.size(); )
+	{
+		Message* pMessage = m_Messages.at(i);
+		Options::EMessageTarget eTarget = Options::mtNone;
+		switch (pMessage->GetKind())
+		{
+			case Message::mkDebug:
+				eTarget = g_pOptions->GetDebugTarget();
+				break;
+			case Message::mkDetail:
+				eTarget = g_pOptions->GetDetailTarget();
+				break;
+			case Message::mkInfo:
+				eTarget = g_pOptions->GetInfoTarget();
+				break;
+			case Message::mkWarning:
+				eTarget = g_pOptions->GetWarningTarget();
+				break;
+			case Message::mkError:
+				eTarget = g_pOptions->GetErrorTarget();
+				break;
+		}
+
+		if (eTarget == Options::mtLog || eTarget == Options::mtBoth)
+		{
+			Filelog("%s\t%s", szMessageType[pMessage->GetKind()], pMessage->GetText());
+		}
+
+		if (eTarget == Options::mtLog || eTarget == Options::mtNone)
+		{
+			delete pMessage;
+			m_Messages.erase(m_Messages.begin() + i);
+		}
+		else
+		{
+			pMessage->m_iID = ++m_iIDGen;
+			i++;
+		}
+	}
+}

Log.h

@@ -0,0 +1,128 @@
+/*
+ *  This file is part of nzbget
+ *
+ *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007-2009 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 LOG_H
+#define LOG_H
+
+#include <deque>
+#include <time.h>
+
+#include "Thread.h"
+
+void error(const char* msg, ...);
+void warn(const char* msg, ...);
+void info(const char* msg, ...);
+void detail(const char* msg, ...);
+void abort(const char* msg, ...);
+
+#ifdef DEBUG
+#ifdef HAVE_VARIADIC_MACROS
+	void debug(const char* szFilename, const char* szFuncname, int iLineNr, const char* msg, ...);
+#else
+	void debug(const char* msg, ...);
+#endif
+#endif
+
+class Message
+{
+public:
+	enum EKind
+	{
+		mkInfo,
+	    mkWarning,
+	    mkError,
+	    mkDebug,
+	    mkDetail
+	};
+
+private:
+	unsigned int		m_iID;
+	EKind				m_eKind;
+	time_t				m_tTime;
+	char*				m_szText;
+
+	friend class Log;
+
+public:
+						Message(unsigned int iID, EKind eKind, time_t tTime, const char* szText);
+						~Message();
+	unsigned int		GetID() { return m_iID; }
+	EKind				GetKind() { return m_eKind; }
+	time_t				GetTime() { return m_tTime; }
+	const char*			GetText() { return m_szText; }
+};
+
+class Log
+{
+public:
+	typedef std::deque<Message*>	Messages;
+
+private:
+	Mutex				m_mutexLog;
+	Messages			m_Messages;
+	char*				m_szLogFilename;
+	unsigned int		m_iIDGen;
+#ifdef DEBUG
+	bool				m_bExtraDebug;
+#endif
+
+	void				Filelog(const char* msg, ...);
+	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:
+						Log();
+						~Log();
+	Messages*			LockMessages();
+	void				UnlockMessages();
+	void				Clear();
+	void				ResetLog();
+	void				InitOptions();
+};
+
+#ifdef DEBUG
+#ifdef HAVE_VARIADIC_MACROS
+#define debug(...)   debug(__FILE__, FUNCTION_MACRO_NAME, __LINE__, __VA_ARGS__)
+#endif
+#else
+#define debug(...)   do { } while(0)
+#endif
+
+extern Log* g_pLog;
+
+#endif

LoggableFrontend.cpp

@@ -1,8 +1,8 @@
 /*
- *  This file is part of nzbget. See <http://nzbget.net>.
+ *  This file if part of nzbget
  *
- *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
- *  Copyright (C) 2007-2016 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrey Prygunkov <hugbug@users.sourceforge.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -15,15 +15,43 @@
  *  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, see <http://www.gnu.org/licenses/>.
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
  */
 
 
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef WIN32
+#include "win32.h"
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#ifndef WIN32
+#include <unistd.h>
+#endif
+
 #include "nzbget.h"
-#include "Util.h"
 #include "LoggableFrontend.h"
 #include "Log.h"
 
+LoggableFrontend::LoggableFrontend()
+{
+	debug("Creating LoggableFrontend");
+
+	m_iNeededLogEntries = 0;
+	m_bSummary = false;
+	m_bFileList = false;
+}
+
 void LoggableFrontend::Run()
 {
 	debug("Entering LoggableFrontend-loop");
@@ -31,7 +59,7 @@ void LoggableFrontend::Run()
 	while (!IsStopped())
 	{
 		Update();
-		Wait(m_updateInterval);
+		usleep(m_iUpdateInterval * 1000);
 	}
 	// Printing the last messages
 	Update();
@@ -51,24 +79,23 @@ void LoggableFrontend::Update()
 
 	BeforePrint();
 
+	Log::Messages* pMessages = LockMessages();
+	if (!pMessages->empty())
 	{
-		GuardedMessageList messages = GuardMessages();
-		if (!messages->empty())
+		Message* pFirstMessage = pMessages->front();
+		int iStart = m_iNeededLogFirstID - pFirstMessage->GetID() + 1;
+		if (iStart < 0)
 		{
-			Message& firstMessage = messages->front();
-			int start = m_neededLogFirstId - firstMessage.GetId() + 1;
-			if (start < 0)
-			{
-				PrintSkip();
-				start = 0;
-			}
-			for (uint32 i = (uint32)start; i < messages->size(); i++)
-			{
-				PrintMessage(messages->at(i));
-				m_neededLogFirstId = messages->at(i).GetId();
-			}
+			PrintSkip();
+			iStart = 0;
+		}
+		for (unsigned int i = (unsigned int)iStart; i < pMessages->size(); i++)
+		{
+			PrintMessage((*pMessages)[i]);
+			m_iNeededLogFirstID = (*pMessages)[i]->GetID();
 		}
 	}
+	UnlockMessages();
 
 	PrintStatus();
 
@@ -77,16 +104,15 @@ void LoggableFrontend::Update()
 	fflush(stdout);
 }
 
-void LoggableFrontend::PrintMessage(Message& message)
+void LoggableFrontend::PrintMessage(Message * pMessage)
 {
 #ifdef WIN32
-	CString cmsg = message.GetText();
-	CharToOem(cmsg, cmsg);
-	const char* msg = cmsg;
+	char* msg = strdup(pMessage->GetText());
+	CharToOem(msg, msg);
 #else
-	const char* msg = message.GetText();
+	const char* msg = pMessage->GetText();
 #endif
-	switch (message.GetKind())
+	switch (pMessage->GetKind())
 	{
 		case Message::mkDebug:
 			printf("[DEBUG] %s\n", msg);
@@ -104,6 +130,9 @@ void LoggableFrontend::PrintMessage(Message& message)
 			printf("[DETAIL] %s\n", msg);
 			break;
 	}
+#ifdef WIN32
+	free(msg);
+#endif
 }
 
 void LoggableFrontend::PrintSkip()

LoggableFrontend.h

@@ -1,8 +1,8 @@
 /*
- *  This file is part of nzbget. See <http://nzbget.net>.
+ *  This file if part of nzbget
  *
- *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
- *  Copyright (C) 2007-2016 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrey Prygunkov <hugbug@users.sourceforge.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -15,7 +15,12 @@
  *  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, see <http://www.gnu.org/licenses/>.
+ *  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$
+ *
  */
 
 
@@ -28,13 +33,16 @@
 class LoggableFrontend : public Frontend
 {
 protected:
-	virtual void Run();
-	virtual void Update();
-	virtual void BeforePrint() {};
-	virtual void BeforeExit() {};
-	virtual void PrintMessage(Message& message);
-	virtual void PrintStatus() {};
-	virtual void PrintSkip();
+
+	virtual void 	Run();
+	virtual void 	Update();
+	virtual void	BeforePrint() {};
+	virtual void	BeforeExit() {};
+	virtual void	PrintMessage(Message* pMessage);
+	virtual void 	PrintStatus() {};
+	virtual void 	PrintSkip();
+public:
+	LoggableFrontend();
 };
 
 #endif

Makefile.am

@@ -1,7 +1,7 @@
 #
-#  This file is part of nzbget. See <http://nzbget.net>.
+#  This file if part of nzbget
 #
-# Copyright (C) 2008-2019 Andrey Prygunkov <hugbug@users.sourceforge.net>
+# Copyright (C) 2008-2013 Andrey Prygunkov <hugbug@users.sourceforge.net>
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -14,446 +14,68 @@
 # 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, see <http://www.gnu.org/licenses/>.
+# 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 = \
-	daemon/connect/Connection.cpp \
-	daemon/connect/Connection.h \
-	daemon/connect/TlsSocket.cpp \
-	daemon/connect/TlsSocket.h \
-	daemon/connect/WebDownloader.cpp \
-	daemon/connect/WebDownloader.h \
-	daemon/extension/FeedScript.cpp \
-	daemon/extension/FeedScript.h \
-	daemon/extension/CommandScript.cpp \
-	daemon/extension/CommandScript.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/WorkState.cpp \
-	daemon/main/WorkState.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/ParParser.cpp \
-	daemon/postprocess/ParParser.h \
-	daemon/postprocess/ParRenamer.cpp \
-	daemon/postprocess/ParRenamer.h \
-	daemon/postprocess/PrePostProcessor.cpp \
-	daemon/postprocess/PrePostProcessor.h \
-	daemon/postprocess/RarRenamer.cpp \
-	daemon/postprocess/RarRenamer.h \
-	daemon/postprocess/RarReader.cpp \
-	daemon/postprocess/RarReader.h \
-	daemon/postprocess/Rename.cpp \
-	daemon/postprocess/Rename.h \
-	daemon/postprocess/Repair.cpp \
-	daemon/postprocess/Repair.h \
-	daemon/postprocess/Unpack.cpp \
-	daemon/postprocess/Unpack.h \
-	daemon/postprocess/DirectUnpack.cpp \
-	daemon/postprocess/DirectUnpack.h \
-	daemon/queue/DirectRenamer.cpp \
-	daemon/queue/DirectRenamer.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/NString.cpp \
-	daemon/util/NString.h \
-	daemon/util/Container.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/FileSystem.cpp \
-	daemon/util/FileSystem.h \
-	daemon/util/Util.cpp \
-	daemon/util/Util.h \
-	daemon/nserv/NServMain.h \
-	daemon/nserv/NServMain.cpp \
-	daemon/nserv/NServFrontend.h \
-	daemon/nserv/NServFrontend.cpp \
-	daemon/nserv/NntpServer.h \
-	daemon/nserv/NntpServer.cpp \
-	daemon/nserv/NzbGenerator.h \
-	daemon/nserv/NzbGenerator.cpp \
-	daemon/nserv/YEncoder.h \
-	daemon/nserv/YEncoder.cpp \
-	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/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
-
-# Simd decoder and Crc32
-nzbget_SOURCES += \
-	lib/yencode/YEncode.h \
-	lib/yencode/SimdInit.cpp \
-	lib/yencode/SimdDecoder.cpp \
-	lib/yencode/ScalarDecoder.cpp \
-	lib/yencode/Sse2Decoder.cpp \
-	lib/yencode/Ssse3Decoder.cpp \
-	lib/yencode/PclmulCrc.cpp \
-	lib/yencode/NeonDecoder.cpp \
-	lib/yencode/AcleCrc.cpp \
-	lib/yencode/SliceCrc.cpp
-
-lib/yencode/Sse2Decoder.$(OBJEXT) : CXXFLAGS+=$(SSE2_CXXFLAGS)
-lib/yencode/Ssse3Decoder.$(OBJEXT) : CXXFLAGS+=$(SSSE3_CXXFLAGS)
-lib/yencode/PclmulCrc.$(OBJEXT) : CXXFLAGS+=$(PCLMUL_CXXFLAGS)
-lib/yencode/NeonDecoder.$(OBJEXT) : CXXFLAGS+=$(NEON_CXXFLAGS)
-lib/yencode/AcleCrc.$(OBJEXT) : CXXFLAGS+=$(ACLECRC_CXXFLAGS)
-
-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)/daemon/nserv \
-	-I$(srcdir)/lib/par2 \
-	-I$(srcdir)/lib/yencode
-
-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/DupeMatcherTest.cpp \
-	tests/postprocess/RarRenamerTest.cpp \
-	tests/postprocess/RarReaderTest.cpp \
-	tests/postprocess/DirectUnpackTest.cpp \
-	tests/queue/NzbFileTest.cpp \
-	tests/nntp/ServerPoolTest.cpp \
-	tests/util/FileSystemTest.cpp \
-	tests/util/NStringTest.cpp \
-	tests/util/UtilTest.cpp
-
-if WITH_PAR2
-nzbget_SOURCES += \
-	tests/postprocess/ParCheckerTest.cpp \
-	tests/postprocess/ParRenamerTest.cpp
-endif
-
-AM_CPPFLAGS += \
-	-I$(srcdir)/lib/catch \
-	-I$(srcdir)/tests/suite
-endif
+	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 NewsServer.cpp NewsServer.h Observer.cpp \
+	Observer.h Options.cpp Options.h ParChecker.cpp ParChecker.h ParRenamer.cpp ParRenamer.h \
+	ParCoordinator.cpp ParCoordinator.h PrePostProcessor.cpp PrePostProcessor.h QueueCoordinator.cpp \
+	QueueCoordinator.h QueueEditor.cpp QueueEditor.h RemoteClient.cpp RemoteClient.h \
+	RemoteServer.cpp RemoteServer.h Scanner.cpp Scanner.h Scheduler.cpp Scheduler.h ScriptController.cpp \
+	ScriptController.h ServerPool.cpp ServerPool.h svn_version.cpp TLS.cpp TLS.h Thread.cpp Thread.h \
+	Util.cpp Util.h XmlRpc.cpp XmlRpc.h WebDownloader.cpp WebDownloader.h WebServer.cpp WebServer.h \
+	UrlCoordinator.cpp UrlCoordinator.h Unpack.cpp Unpack.h nzbget.cpp nzbget.h
 
 EXTRA_DIST = \
-	$(windows_FILES) \
-	$(osx_FILES) \
-	$(linux_FILES) \
-	$(testdata_FILES) \
-	$(par2doc_FILES)
+	Makefile.cvs nzbgetd \
+	$(patches_FILES) $(windows_FILES)
+
+patches_FILES = \
+	libpar2-0.2-bugfixes.patch libpar2-0.2-cancel.patch \
+	libpar2-0.2-MSVC8.patch libsigc++-2.0.18-MSVC8.patch
 
 windows_FILES = \
-	daemon/windows/StdAfx.cpp \
-	daemon/windows/WinService.cpp \
-	daemon/windows/WinService.h \
-	daemon/windows/WinConsole.cpp \
-	daemon/windows/WinConsole.h \
-	nzbget.vcxproj \
-	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/resources/install.bmp \
-	windows/resources/uninstall.bmp \
-	windows/nzbget-setup.nsi
-
-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 \
-	linux/build-toolchain-android \
-	linux/build-toolchain-freebsd
+	win32.h NTService.cpp NTService.h nzbget.sln nzbget.vcproj nzbget-shell.bat
 
 doc_FILES = \
-	README \
-	ChangeLog \
-	COPYING
-
-par2doc_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 \
-	webui/img/favicon-256x256-opaque.png \
-	webui/img/favicon-256x256.png
+	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/lib/bootstrap.js webui/lib/bootstrap.min.js webui/lib/bootstrap.css  \
+	webui/lib/jquery.js webui/lib/jquery.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 \
-	tests/testdata/parchecker2/crc.txt \
-	tests/testdata/parchecker2/testfile.7z.001 \
-	tests/testdata/parchecker2/testfile.7z.002 \
-	tests/testdata/parchecker2/testfile.7z.003 \
-	tests/testdata/parchecker2/testfile.7z.par2 \
-	tests/testdata/parchecker2/testfile.7z.vol0+1.PAR2 \
-	tests/testdata/parchecker2/testfile.7z.vol1+2.PAR2 \
-	tests/testdata/parchecker2/testfile.7z.vol3+3.PAR2 \
-	tests/testdata/rarrenamer/testfile3.part01.rar \
-	tests/testdata/rarrenamer/testfile3.part02.rar \
-	tests/testdata/rarrenamer/testfile3.part03.rar \
-	tests/testdata/rarrenamer/testfile5.part01.rar \
-	tests/testdata/rarrenamer/testfile5.part02.rar \
-	tests/testdata/rarrenamer/testfile5.part03.rar \
-	tests/testdata/rarrenamer/testfile3oldnam.rar \
-	tests/testdata/rarrenamer/testfile3oldnam.r00 \
-	tests/testdata/rarrenamer/testfile3oldnam.r01 \
-	tests/testdata/rarrenamer/testfile3encdata.part01.rar \
-	tests/testdata/rarrenamer/testfile3encdata.part02.rar \
-	tests/testdata/rarrenamer/testfile3encdata.part03.rar \
-	tests/testdata/rarrenamer/testfile3encnam.part01.rar \
-	tests/testdata/rarrenamer/testfile3encnam.part02.rar \
-	tests/testdata/rarrenamer/testfile3encnam.part03.rar \
-	tests/testdata/rarrenamer/testfile5encdata.part01.rar \
-	tests/testdata/rarrenamer/testfile5encdata.part02.rar \
-	tests/testdata/rarrenamer/testfile5encdata.part03.rar \
-	tests/testdata/rarrenamer/testfile5encnam.part01.rar \
-	tests/testdata/rarrenamer/testfile5encnam.part02.rar \
-	tests/testdata/rarrenamer/testfile5encnam.part03.rar
+ppscripts_FILES = \
+	ppscripts/EMail.py ppscripts/Logger.py
 
 # Install
+sbin_SCRIPTS = nzbgetd
 dist_doc_DATA = $(doc_FILES)
 exampleconfdir = $(datadir)/nzbget
 dist_exampleconf_DATA = $(exampleconf_FILES)
 webuidir = $(datadir)/nzbget
 nobase_dist_webui_DATA = $(webui_FILES)
-scriptsdir = $(datadir)/nzbget
-nobase_dist_scripts_SCRIPTS = $(scripts_FILES)
+ppscriptsdir = $(datadir)/nzbget
+nobase_dist_ppscripts_SCRIPTS = $(ppscripts_FILES)
 
 # Note about "sed": 
 # We need to make some changes in installed files.
@@ -464,6 +86,13 @@ nobase_dist_scripts_SCRIPTS = $(scripts_FILES)
 # 3) delete original.temp
 # These steps ensure that the output file has the same permissions as the original file.
 
+# Configure installed script
+install-exec-hook:
+	rm -f "$(DESTDIR)$(sbindir)/nzbgetd.temp"
+	cp "$(DESTDIR)$(sbindir)/nzbgetd" "$(DESTDIR)$(sbindir)/nzbgetd.temp"
+	sed 's?/usr/local/bin?$(bindir)?' < "$(DESTDIR)$(sbindir)/nzbgetd.temp" > "$(DESTDIR)$(sbindir)/nzbgetd"
+	rm "$(DESTDIR)$(sbindir)/nzbgetd.temp"
+
 # Prepare example configuration file
 install-data-hook:
 	rm -f "$(DESTDIR)$(exampleconfdir)/nzbget.conf.temp"
@@ -472,7 +101,7 @@ install-data-hook:
 	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"
+	sed 's:typically installed to /usr/local/share/nzbget/ppscripts:installed to $(ppscriptsdir)/ppscripts:' < "$(DESTDIR)$(exampleconfdir)/nzbget.conf.temp" > "$(DESTDIR)$(exampleconfdir)/nzbget.conf"
 	rm "$(DESTDIR)$(exampleconfdir)/nzbget.conf.temp"
 
 # Install configuration files into /etc
@@ -486,59 +115,44 @@ install-conf:
 uninstall-conf:
 	rm -f "$(DESTDIR)$(sysconfdir)/nzbget.conf"
 
-# Determining git revision:
-# 1) If directory ".git" exists we take revision from git log.
+# Determining subversion revision:
+# 1) If directory ".svn" exists we take revision from it using program svnversion (part of subversion package)
 #    File is recreated only if revision number was changed.
-# 2) If directory ".git" doesn't exists we keep and reuse file "code_revision.cpp",
+# 2) If directory ".svn" doesn't exists we keep and reuse file "svn_version.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=`git branch | sed -n -e 's/^\* \(.*\)/\1/p'`; \
-		M=`git status --porcelain` ; \
-		if test "$$M" != "" ; then \
-			M="M" ; \
-		fi ; \
-		if test "$$B" = "master" ; then \
-			V="$$M" ; \
-		elif test "$$B" = "develop" ; then \
-			V=`git rev-list HEAD | wc -l | xargs` ; \
-			V="$${V}$$M" ; \
-		else \
-			V=`git rev-list HEAD | wc -l | xargs` ; \
-			V="$${V}$$M ($$B)" ; \
-		fi ; \
-		H=`test -f ./code_revision.cpp && head -n 1 code_revision.cpp`; \
+# 3) If neither directory ".svn" nor file "svn_version.cpp" are available
+#    we create new file "svn_version.c" with empty revision number.
+svn_version.cpp: FORCE
+	@ if test -d ./.svn ; then \
+		V="$(shell svnversion -n .)"; \
+		H="$(shell test -f ./svn_version.cpp && head -n 1 svn_version.cpp)"; \
 		if test "/* $$V */" != "$$H" ; then \
 			( \
 			echo "/* $$V */" ;\
 			echo "/* This file is automatically regenerated on each build. Do not edit it. */" ;\
-			echo "#include \"nzbget.h\"" ;\
-			echo "const char* code_revision(void)" ;\
+			echo "const char* svn_version(void)" ;\
 			echo "{" ;\
-			echo "	const char* revision = \"$$V\";" ;\
-			echo "	return revision;" ;\
+			echo "	const char* SVN_Version = \"$$V\";" ;\
+			echo "	return SVN_Version;" ;\
 			echo "}" ;\
-			) > code_revision.cpp ; \
+			) > svn_version.cpp ; \
 		fi \
-	elif test -f ./code_revision.cpp ; then \
+	elif test -f ./svn_version.cpp ; then \
 		test "ok, reuse existing file"; \
 	else \
 		( \
 		echo "/*  */" ;\
 		echo "/* This file is automatically regenerated on each build. Do not edit it. */" ;\
-		echo "#include \"nzbget.h\"" ;\
-		echo "const char* code_revision(void)" ;\
+		echo "const char* svn_version(void)" ;\
 		echo "{" ;\
-		echo "	const char* revision = \"\";" ;\
-		echo "	return revision;" ;\
+		echo "	const char* SVN_Version = \"\";" ;\
+		echo "	return SVN_Version;" ;\
 		echo "}" ;\
-		) > code_revision.cpp ; \
+		) > svn_version.cpp ; \
 	fi
 FORCE:
 
-# Ignore "code_revision.cpp" in distcleancheck
+# Ignore "svn_version.cpp" in distcleancheck
 distcleancheck_listfiles = \
 	find . -type f -exec sh -c 'test -f $(srcdir)/$$1 || echo $$1' \
 	sh '{}' ';'
@@ -547,8 +161,6 @@ clean-bak: rm *~
 
 # Fix premissions
 dist-hook:
-	find $(distdir)/daemon -type f -print -exec chmod -x {} \;
+	chmod -x $(distdir)/*.cpp $(distdir)/*.h
 	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

@@ -0,0 +1,553 @@
+/*
+ *  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>
+ *
+ *  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 MESSAGEBASE_H
+#define MESSAGEBASE_H
+
+static const int32_t NZBMESSAGE_SIGNATURE = 0x6E7A6217; // = "nzb-XX" (protocol version)
+static const int NZBREQUESTFILENAMESIZE = 512;
+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.
+ * 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":
+enum eRemoteRequest
+{
+	eRemoteRequestDownload = 1,
+	eRemoteRequestPauseUnpause,
+	eRemoteRequestList,
+	eRemoteRequestSetDownloadRate,
+	eRemoteRequestDumpDebug,
+	eRemoteRequestEditQueue,
+	eRemoteRequestLog,
+	eRemoteRequestShutdown,
+	eRemoteRequestReload,
+	eRemoteRequestVersion,
+	eRemoteRequestPostQueue,
+	eRemoteRequestWriteLog,
+	eRemoteRequestScan,
+	eRemoteRequestHistory,
+	eRemoteRequestDownloadUrl,
+	eRemoteRequestUrlQueue
+};
+
+// 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
+{
+	eRemoteEditActionFileMoveOffset = 1,	// move files to m_iOffset relative to the current position in download-queue
+	eRemoteEditActionFileMoveTop,			// move files to the top of download-queue
+	eRemoteEditActionFileMoveBottom,		// move files to the bottom of download-queue
+	eRemoteEditActionFilePause,				// pause files
+	eRemoteEditActionFileResume,			// resume (unpause) files
+	eRemoteEditActionFileDelete,			// delete files
+	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)
+	eRemoteEditActionFileSetPriority,		// set priority for files
+	eRemoteEditActionFileReorder,			// (not supported)
+	eRemoteEditActionFileSplit,				// split - create new group from selected files
+	eRemoteEditActionGroupMoveOffset,		// move group to m_iOffset relative to the current position in download-queue
+	eRemoteEditActionGroupMoveTop,			// move group to the top of download-queue
+	eRemoteEditActionGroupMoveBottom,		// move group to the bottom of download-queue
+	eRemoteEditActionGroupPause,			// pause group
+	eRemoteEditActionGroupResume,			// resume (unpause) group
+	eRemoteEditActionGroupDelete,			// delete group
+	eRemoteEditActionGroupPauseAllPars,		// pause only (all) pars (does not affect other files) in group
+	eRemoteEditActionGroupPauseExtraPars,	// pause only (almost all) pars in group, except main par-file (does not affect other files)
+	eRemoteEditActionGroupSetPriority,		// set priority for groups
+	eRemoteEditActionGroupSetCategory,		// set or change category for a group
+	eRemoteEditActionGroupMerge,			// merge group
+	eRemoteEditActionGroupSetParameter,		// set post-process parameter for group
+	eRemoteEditActionGroupSetName,			// set group name (rename group)
+	eRemoteEditActionPostMoveOffset = 51,	// move post-job to m_iOffset relative to the current position in post-queue
+	eRemoteEditActionPostMoveTop,			// move post-job to the top of post-queue
+	eRemoteEditActionPostMoveBottom,		// move post-job to the bottom of post-queue
+	eRemoteEditActionPostDelete,			// delete post-job
+	eRemoteEditActionHistoryDelete,			// delete history-item
+	eRemoteEditActionHistoryReturn,			// move history-item back to download queue
+	eRemoteEditActionHistoryProcess,		// move history-item back to download queue and start postprocessing
+	eRemoteEditActionHistorySetParameter	// set post-process parameter for history-item
+};
+
+// Possible values for field "m_iAction" of struct "SNZBPauseUnpauseRequest":
+enum eRemotePauseUnpauseAction
+{
+	eRemotePauseUnpauseActionDownload = 1,	// pause/unpause download queue
+	eRemotePauseUnpauseActionDownload2,		// pause/unpause download queue (second pause-register)
+	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
+};
+
+// The basic SNZBRequestBase struct, used in all requests
+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
+};
+
+// The basic SNZBResposneBase struct, used in all responses
+struct SNZBResponseBase
+{
+	int32_t					m_iSignature;			// Signature must be NZBMESSAGE_SIGNATURE in integer-value
+	int32_t					m_iStructSize;			// Size of the entire struct
+};
+
+// A download request
+struct SNZBDownloadRequest
+{
+	SNZBRequestBase			m_MessageBase;			// Must be the first in the struct
+	char					m_szFilename[NZBREQUESTFILENAMESIZE];	// Name of nzb-file, may contain full path (local path on client) or only filename
+	char					m_szCategory[NZBREQUESTFILENAMESIZE];	// Category, can 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_iTrailingDataLength;	// Length of nzb-file in bytes
+	//char					m_szContent[m_iTrailingDataLength];	// variable sized
+};
+
+// A download response
+struct SNZBDownloadResponse
+{
+	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 list and status request
+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
+struct SNZBListResponse
+{
+	SNZBResponseBase		m_MessageBase;			// Must be the first in the struct
+	int32_t					m_iEntrySize;			// Size of the SNZBListResponseEntry-struct
+	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_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_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
+};
+
+// A list response nzb entry
+struct SNZBListResponseNZBEntry
+{
+	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_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
+{
+	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_iPriority;			// Download priority
+	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_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
+	//char					m_szSubject[m_iSubjectLen];			// variable sized
+	//char					m_szFilename[m_iFilenameLen];		// variable sized
+};
+
+// A log request
+struct SNZBLogRequest
+{
+	SNZBRequestBase			m_MessageBase;			// Must be the first in the struct
+	int32_t					m_iIDFrom;				// Only one of these two parameters
+	int32_t					m_iLines;				// can be set. The another one must be set to "0".
+};
+
+// A log response
+struct SNZBLogResponse
+{
+	SNZBResponseBase		m_MessageBase;			// Must be the first in the struct
+	int32_t					m_iEntrySize;			// Size of the SNZBLogResponseEntry-struct
+	int32_t					m_iNrTrailingEntries;	// Number of Log-entries, following to this structure
+	int32_t					m_iTrailingDataLength;	// Length of all Log-entries, following to this structure
+	// SNZBLogResponseEntry m_Entries[m_iNrTrailingEntries]	// variable sized
+};
+
+// A log response entry
+struct SNZBLogResponseEntry
+{
+	int32_t					m_iID;					// ID of Log-entry
+	int32_t					m_iKind;				// see Message::Kind in "Log.h"
+	int32_t					m_tTime;				// time since the Epoch (00:00:00 UTC, January 1, 1970), measured in seconds.
+	int32_t					m_iTextLen;				// Length of Text-string (m_szText), following to this record
+	//char					m_szText[m_iTextLen];	// variable sized
+};
+
+// A Pause/Unpause request
+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
+struct SNZBPauseUnpauseResponse
+{
+	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
+};
+
+// Request setting the download rate
+struct SNZBSetDownloadRateRequest
+{
+	SNZBRequestBase			m_MessageBase;			// Must be the first in the struct
+	int32_t					m_iDownloadRate;		// Speed limit, in Bytes pro Second
+};
+
+// A setting download rate response
+struct SNZBSetDownloadRateResponse
+{
+	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
+};
+
+// 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 eRemoteEditAction
+	int32_t					m_iOffset;				// Offset to move (for m_iAction = 0)
+	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_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
+};
+
+// An edit queue response
+struct SNZBEditQueueResponse
+{
+	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
+};
+
+// Request dumping of debug info
+struct SNZBDumpDebugRequest
+{
+	SNZBRequestBase			m_MessageBase;			// Must be the first in the struct
+};
+
+// Dumping of debug response
+struct SNZBDumpDebugResponse
+{
+	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
+};
+
+// Shutdown server request
+struct SNZBShutdownRequest
+{
+	SNZBRequestBase			m_MessageBase;			// Must be the first in the struct
+};
+
+// Shutdown server response
+struct SNZBShutdownResponse
+{
+	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
+};
+
+// 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
+{
+	SNZBRequestBase			m_MessageBase;			// Must be the first in the struct
+};
+
+// Server version  response
+struct SNZBVersionResponse
+{
+	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
+};
+
+// PostQueue request
+struct SNZBPostQueueRequest
+{
+	SNZBRequestBase			m_MessageBase;			// Must be the first in the struct
+};
+
+// A PostQueue response
+struct SNZBPostQueueResponse
+{
+	SNZBResponseBase		m_MessageBase;			// Must be the first in the struct
+	int32_t					m_iEntrySize;			// Size of the SNZBPostQueueResponseEntry-struct
+	int32_t					m_iNrTrailingEntries;	// Number of PostQueue-entries, following to this structure
+	int32_t					m_iTrailingDataLength;	// Length of all PostQueue-entries, following to this structure
+	// SNZBPostQueueResponseEntry m_Entries[m_iNrTrailingEntries]		// variable sized
+};
+
+// A PostQueue response entry
+struct SNZBPostQueueResponseEntry
+{
+	int32_t					m_iID;					// ID of Post-entry
+	int32_t					m_iStage;				// See PrePostProcessor::EPostJobStage
+	int32_t					m_iStageProgress;		// Progress of current stage, value in range 0..1000
+	int32_t					m_iFileProgress;		// Progress of current file, value in range 0..1000
+	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_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_szInfoName[m_iInfoNameLen];			// variable sized
+	//char					m_szDestDir[m_iDestDirLen];				// variable sized
+	//char					m_szProgressLabel[m_iProgressLabelLen];	// variable sized
+};
+
+// Write log request
+struct SNZBWriteLogRequest
+{
+	SNZBRequestBase			m_MessageBase;			// Must be the first in the struct
+	int32_t					m_iKind;				// see Message::Kind in "Log.h"
+	int32_t					m_iTrailingDataLength;	// Length of nzb-file in bytes
+	//char					m_szText[m_iTrailingDataLength];	// variable sized
+};
+
+// Write log response
+struct SNZBWriteLogResponse
+{
+	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
+};
+
+// 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
+};
+
+// 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
+	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 items (m_iKind = 1)
+	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_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 UrlInfo::EStatus
+	// trailing data
+	//char					m_szNicename[m_iNicenameLen];				// variable sized
+};
+
+// download url request
+struct SNZBDownloadUrlRequest
+{
+	SNZBRequestBase			m_MessageBase;			// Must be the first in the struct
+	char					m_szURL[NZBREQUESTFILENAMESIZE];		// url to nzb-file
+	char					m_szNZBFilename[NZBREQUESTFILENAMESIZE];// Name of nzb-file. Can be empty, then the filename is read from URL download response
+	char					m_szCategory[NZBREQUESTFILENAMESIZE];	// Category, can be empty
+	int32_t					m_bAddFirst;							// 1 - add url to the top of download queue
+	int32_t					m_bAddPaused;							// 1 - pause added files
+	int32_t					m_iPriority;							// Priority for files (0 - default)
+};
+
+// download url response
+struct SNZBDownloadUrlResponse
+{
+	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
+};
+
+// UrlQueue request
+struct SNZBUrlQueueRequest
+{
+	SNZBRequestBase			m_MessageBase;			// Must be the first in the struct
+};
+
+// UrlQueue response
+struct SNZBUrlQueueResponse
+{
+	SNZBResponseBase		m_MessageBase;			// Must be the first in the struct
+	int32_t					m_iEntrySize;			// Size of the SNZBUrlQueueResponseEntry-struct
+	int32_t					m_iNrTrailingEntries;	// Number of UrlQueue-entries, following to this structure
+	int32_t					m_iTrailingDataLength;	// Length of all UrlQueue-entries, following to this structure
+	// SNZBUrlQueueResponseEntry m_Entries[m_iNrTrailingEntries]		// variable sized
+};
+
+// UrlQueue response entry
+struct SNZBUrlQueueResponseEntry
+{
+	int32_t					m_iID;					// ID of Url-entry
+	int32_t					m_iURLLen;				// Length of URL-string (m_szURL), following to this record
+	int32_t					m_iNZBFilenameLen;		// Length of NZBFilename-string (m_szNZBFilename), following to this record
+	//char					m_szURL[m_iURLLen];					// variable sized
+	//char					m_szNZBFilename[m_iNZBFilenameLen];	// variable sized
+};
+
+#endif

NCursesFrontend.h

@@ -0,0 +1,130 @@
+/*
+ *  This file is part of nzbget
+ *
+ *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007-2009 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 NCURSESFRONTEND_H
+#define NCURSESFRONTEND_H
+
+#ifndef DISABLE_CURSES
+
+#include <vector>
+#include <time.h>
+
+#include "Frontend.h"
+#include "Log.h"
+#include "DownloadInfo.h"
+
+class NCursesFrontend : public Frontend
+{
+private:
+
+	enum EInputMode
+	{
+	    eNormal,
+	    eEditQueue,
+	    eDownloadRate
+	};
+
+	bool				m_bUseColor;
+	int					m_iDataUpdatePos;
+    bool				m_bUpdateNextTime;
+	int					m_iScreenHeight;
+	int					m_iScreenWidth;
+	int					m_iQueueWinTop;
+	int					m_iQueueWinHeight;
+	int					m_iQueueWinClientHeight;
+	int					m_iMessagesWinTop;
+	int					m_iMessagesWinHeight;
+	int					m_iMessagesWinClientHeight;
+	int					m_iSelectedQueueEntry;
+	int					m_iLastEditEntry;
+	bool				m_bLastPausePars;
+	int					m_iQueueScrollOffset;
+	GroupQueue			m_groupQueue;
+	char*				m_szHint;
+	time_t				m_tStartHint;
+	int					m_iColWidthFiles;
+	int					m_iColWidthTotal;
+	int					m_iColWidthLeft;
+
+	// Inputting numbers
+	int					m_iInputNumberIndex;
+	int					m_iInputValue;
+
+#ifdef WIN32
+	CHAR_INFO*			m_pScreenBuffer;
+	CHAR_INFO*			m_pOldScreenBuffer;
+	int					m_iScreenBufferSize;
+	std::vector<WORD>	m_ColorAttr;
+#else
+	void* 				m_pWindow;  //  WINDOW*
+#endif
+
+	EInputMode			m_eInputMode;
+	bool				m_bShowNZBname;
+	bool				m_bShowTimestamp;
+	bool				m_bGroupFiles;
+	float				m_QueueWindowPercentage;
+
+#ifdef WIN32
+	void			init_pair(int iColorNumber, WORD wForeColor, WORD wBackColor);
+#endif
+	void			PlotLine(const char * szString, int iRow, int iPos, int iColorPair);
+	void			PlotText(const char * szString, int iRow, int iPos, int iColorPair, bool bBlink);
+	void			PrintMessages();
+	void			PrintQueue();
+	void			PrintFileQueue();
+	void			PrintFilename(FileInfo* pFileInfo, int iRow, bool bSelected);
+	void			PrintGroupQueue();
+	void			ResetColWidths();
+	void			PrintGroupname(GroupInfo * pGroupInfo, int iRow, bool bSelected, bool bCalcColWidth);
+	void			PrepareGroupQueue();
+	void			PrintTopHeader(char* szHeader, int iLineNr, bool bUpTime);
+	void			ClearGroupQueue();
+	int				PrintMessage(Message* Msg, int iRow, int iMaxLines);
+	void			PrintKeyInputBar();
+	void 			PrintStatus();
+	void			UpdateInput(int initialKey);
+	void			Update(int iKey);
+	void			SetCurrentQueueEntry(int iEntry);
+	void			CalcWindowSizes();
+	void			RefreshScreen();
+	int				ReadConsoleKey();
+	int				CalcQueueSize();
+	void			NeedUpdateData();
+	bool			EditQueue(QueueEditor::EEditAction eAction, int iOffset);
+	void			SetHint(const char* szHint);
+
+protected:
+	virtual void 	Run();
+
+public:
+					NCursesFrontend();
+	virtual			~NCursesFrontend();
+};
+
+#endif
+
+#endif

NNTPConnection.cpp

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

NNTPConnection.h

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

NTService.cpp

@@ -1,7 +1,7 @@
 /*
- *  This file is part of nzbget. See <http://nzbget.net>.
+ *  This file is part of nzbget
  *
- *  Copyright (C) 2007-2016 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrey Prygunkov <hugbug@users.sourceforge.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -14,19 +14,32 @@
  *  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, see <http://www.gnu.org/licenses/>.
+ *  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
+
+#include "win32.h"
+
+#include <string.h>
+
 #include "nzbget.h"
 #include "Log.h"
-#include "WinService.h"
+#include "NTService.h"
 
 extern void ExitProc();
-RunProc Run = nullptr;
+RunProc Run = NULL;
 
 char* strServiceName = "NZBGet";
-SERVICE_STATUS_HANDLE nServiceStatusHandle;
+SERVICE_STATUS_HANDLE nServiceStatusHandle; 
 DWORD nServiceCurrentStatus;
 
 BOOL UpdateServiceStatus(DWORD dwCurrentState, DWORD dwWaitHint)
@@ -56,7 +69,7 @@ BOOL UpdateServiceStatus(DWORD dwCurrentState, DWORD dwWaitHint)
 void ServiceCtrlHandler(DWORD nControlCode)
 {
 	switch(nControlCode)
-	{
+	{	
 	case SERVICE_CONTROL_SHUTDOWN:
 	case SERVICE_CONTROL_STOP:
 		nServiceCurrentStatus = SERVICE_STOP_PENDING;
@@ -89,7 +102,7 @@ void ServiceMain(DWORD argc, LPTSTR *argv)
 	{
 		return;
 	}
-
+	
 	Run();
 
 	UpdateServiceStatus(SERVICE_STOPPED, 0);
@@ -102,7 +115,7 @@ void StartService(RunProc RunProcPtr)
 	SERVICE_TABLE_ENTRY servicetable[]=
 	{
 		{strServiceName,(LPSERVICE_MAIN_FUNCTION)ServiceMain},
-		{nullptr,nullptr}
+		{NULL,NULL}
 	};
 	BOOL success = StartServiceCtrlDispatcher(servicetable);
 	if(!success)
@@ -119,18 +132,20 @@ void InstallService(int argc, char *argv[])
 		printf("Could not install service\n");
 		return;
 	}
+	
+	char szExeName[1024];
+	GetModuleFileName(NULL, szExeName, 1024);
+	szExeName[1024-1] = '\0';
 
-	char exeName[1024];
-	GetModuleFileName(nullptr, exeName, 1024);
-	exeName[1024-1] = '\0';
-
-	BString<1024> cmdLine("%s -D", exeName);
+	char szCmdLine[1024];
+	snprintf(szCmdLine, 1024, "%s -D", szExeName);
+	szCmdLine[1024-1] = '\0';
 
 	SC_HANDLE hService = CreateService(scm, strServiceName,
 		strServiceName,
 		SERVICE_ALL_ACCESS,SERVICE_WIN32_OWN_PROCESS,SERVICE_DEMAND_START,
 		SERVICE_ERROR_NORMAL,
-		cmdLine,
+		szCmdLine,
 		0,0,0,0,0);
 	if(!hService)
 	{
@@ -152,7 +167,7 @@ void UnInstallService()
 		printf("Could not uninstall service\n");
 		return;
 	}
-
+	
 	SC_HANDLE hService = OpenService(scm, strServiceName, STANDARD_RIGHTS_REQUIRED);
 	if(!hService)
 	{
@@ -185,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 running = false;
-	if (hService && QueryServiceStatus(hService, &ServiceStatus))
-	{
-		running = ServiceStatus.dwCurrentState != SERVICE_STOPPED;
-	}
-
-	CloseServiceHandle(scm);
-
-	return running;
-}

NTService.h

@@ -1,7 +1,7 @@
 /*
- *  This file is part of nzbget. See <http://nzbget.net>.
+ *  This file is part of nzbget
  *
- *  Copyright (C) 2007-2016 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrey Prygunkov <hugbug@users.sourceforge.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -14,17 +14,21 @@
  *  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, see <http://www.gnu.org/licenses/>.
+ *  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 WINSERVICE_H
-#define WINSERVICE_H
+#ifndef NTSERVICE_H
+#define NTSERVICE_H
 
 typedef void (*RunProc)(void);
 
 void InstallUninstallServiceCheck(int argc, char *argv[]);
 void StartService(RunProc RunProcPtr);
-bool IsServiceRunning();
 
 #endif

NZBFile.cpp

@@ -0,0 +1,716 @@
+/*
+ *  This file is part of nzbget
+ *
+ *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007-2013 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef WIN32
+#include "win32.h"
+#endif
+
+#include <string.h>
+#include <list>
+#ifdef WIN32
+#include <comutil.h>
+#import <msxml.tlb> named_guids 
+using namespace MSXML;
+#else
+#include <libxml/parser.h>
+#include <libxml/xmlreader.h>
+#include <libxml/xmlerror.h>
+#include <libxml/entities.h>
+#endif
+
+#include "nzbget.h"
+#include "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();
+
+#ifndef WIN32
+	m_pFileInfo = NULL;
+	m_pArticle = NULL;
+	m_szTagContent = NULL;
+	m_iTagContentLen = 0;
+#endif
+
+    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();
+	}
+
+#ifndef WIN32
+	if (m_pFileInfo)
+	{
+		delete m_pFileInfo;
+	}
+	
+	if (m_szTagContent)
+	{
+		free(m_szTagContent);
+	}
+#endif
+}
+
+void NZBFile::LogDebugInfo()
+{
+    debug(" NZBFile %s", m_szFileName);
+}
+
+void NZBFile::DetachFileInfos()
+{
+    m_FileInfos.clear();
+}
+
+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())
+	{
+		m_FileInfos.push_back(pFileInfo);
+		pFileInfo->SetNZBInfo(m_pNZBInfo);
+		m_pNZBInfo->SetSize(m_pNZBInfo->GetSize() + pFileInfo->GetSize());
+		m_pNZBInfo->SetFileCount(m_pNZBInfo->GetFileCount() + 1);
+	}
+	else
+	{
+		delete pFileInfo; 
+	}
+}
+
+void NZBFile::ParseSubject(FileInfo* pFileInfo, bool TryQuotes)
+{
+	if (TryQuotes)
+	{
+		// try to use the filename in quatation marks 
+		char* p = (char*)pFileInfo->GetSubject();
+		char* start = strchr(p, '\"');
+		if (start)
+		{
+			start++;
+			char* end = strchr(start + 1, '\"');
+			if (end)
+			{
+				int len = (int)(end - start);
+				char* point = strchr(start + 1, '.');
+				if (point && point < end)
+				{
+					char* filename = (char*)malloc(len + 1);
+					strncpy(filename, start, len);
+					filename[len] = '\0';
+					pFileInfo->SetFilename(filename);
+					free(filename);
+					return;
+				}
+			}
+		}
+	}
+
+	// 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());
+	}
+}
+
+bool NZBFile::HasDuplicateFilenames()
+{
+	for (FileInfos::iterator it = m_FileInfos.begin(); it != m_FileInfos.end(); it++)
+    {
+        FileInfo* pFileInfo1 = *it;
+		int iDupe = 1;
+		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))
+		{
+			return true;
+		}
+    }
+
+	return false;
+}
+
+/**
+ * Generate filenames from subjects and check if the parsing of subject was correct
+ */
+void NZBFile::ProcessFilenames()
+{
+	for (FileInfos::iterator it = m_FileInfos.begin(); it != m_FileInfos.end(); it++)
+    {
+        FileInfo* pFileInfo = *it;
+		ParseSubject(pFileInfo, true);
+	}
+
+	if (HasDuplicateFilenames())
+    {
+		for (FileInfos::iterator it = m_FileInfos.begin(); it != m_FileInfos.end(); it++)
+		{
+			FileInfo* pFileInfo = *it;
+			ParseSubject(pFileInfo, false);
+		}
+	}
+
+	if (HasDuplicateFilenames())
+    {
+		for (FileInfos::iterator it = m_FileInfos.begin(); it != m_FileInfos.end(); it++)
+		{
+			FileInfo* pFileInfo = *it;
+			pFileInfo->SetFilename(pFileInfo->GetSubject());
+		}
+    }
+
+	for (FileInfos::iterator it = m_FileInfos.begin(); it != m_FileInfos.end(); it++)
+    {
+        FileInfo* pFileInfo = *it;
+		pFileInfo->MakeValidFilename();
+		if (g_pOptions->GetSaveQueue() && g_pOptions->GetServerMode())
+		{
+			g_pDiskState->SaveFile(pFileInfo);
+			pFileInfo->ClearArticles();
+		}
+	}
+}
+
+#ifdef WIN32
+NZBFile* NZBFile::Create(const char* szFileName, const char* szCategory)
+{
+    CoInitialize(NULL);
+
+	HRESULT hr;
+
+	MSXML::IXMLDOMDocumentPtr doc;
+	hr = doc.CreateInstance(MSXML::CLSID_DOMDocument);
+    if (FAILED(hr))
+    {
+        return NULL;
+    }
+
+    // Load the XML document file...
+	doc->put_resolveExternals(VARIANT_FALSE);
+	doc->put_validateOnParse(VARIANT_FALSE);
+	doc->put_async(VARIANT_FALSE);
+
+	// filename needs to be properly encoded
+	char* szURL = (char*)malloc(strlen(szFileName)*3 + 1);
+	EncodeURL(szFileName, szURL);
+	debug("url=\"%s\"", szURL);
+	_variant_t v(szURL);
+	free(szURL);
+
+	VARIANT_BOOL success = doc->load(v);
+	if (success == VARIANT_FALSE)
+	{
+		_bstr_t r(doc->GetparseError()->reason);
+		const char* szErrMsg = r;
+		error("Error parsing nzb-file: %s", szErrMsg);
+		return NULL;
+	}
+
+    NZBFile* pFile = new NZBFile(szFileName, szCategory);
+    if (pFile->ParseNZB(doc))
+	{
+		pFile->ProcessFilenames();
+	}
+	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);
+
+		attribute = node->Getattributes()->getNamedItem("date");
+		if (attribute)
+		{
+			_bstr_t date(attribute->Gettext());
+			pFileInfo->SetTime(atoi(date));
+		}
+
+		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);
+
+			if (partNumber > 0)
+			{
+				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)
+{
+    NZBFile* pFile = new NZBFile(szFileName, szCategory);
+
+	xmlSAXHandler SAX_handler = {0};
+	SAX_handler.startElement = reinterpret_cast<startElementSAXFunc>(SAX_StartElement);
+	SAX_handler.endElement = reinterpret_cast<endElementSAXFunc>(SAX_EndElement);
+	SAX_handler.characters = reinterpret_cast<charactersSAXFunc>(SAX_characters);
+	SAX_handler.error = reinterpret_cast<errorSAXFunc>(SAX_error);
+	SAX_handler.getEntity = reinterpret_cast<getEntitySAXFunc>(SAX_getEntity);
+
+	pFile->m_bIgnoreNextError = false;
+
+	int ret = xmlSAXUserParseFile(&SAX_handler, pFile, szFileName);
+    
+    if (ret == 0)
+	{
+		pFile->ProcessFilenames();
+	}
+	else
+	{
+        error("Failed to parse nzb-file");
+		delete pFile;
+		pFile = NULL;
+	}
+	
+	return pFile;
+}
+
+void NZBFile::Parse_StartElement(const char *name, const char **atts)
+{
+	if (m_szTagContent)
+	{
+		free(m_szTagContent);
+		m_szTagContent = NULL;
+		m_iTagContentLen = 0;
+	}
+	
+	if (!strcmp("file", name))
+	{
+		m_pFileInfo = new FileInfo();
+		m_pFileInfo->SetFilename(m_szFileName);
+
+    	for (int i = 0; atts[i]; i += 2)
+    	{
+    		const char* attrname = atts[i];
+    		const char* attrvalue = atts[i + 1];
+			if (!strcmp("subject", attrname))
+			{
+				m_pFileInfo->SetSubject(attrvalue);
+			}
+			if (!strcmp("date", attrname))
+			{
+				m_pFileInfo->SetTime(atoi(attrvalue));
+			}
+		}
+	}
+	else if (!strcmp("segment", name))
+	{
+		if (!m_pFileInfo)
+		{
+			// error: bad nzb-file
+			return;
+		}
+	
+		long long lsize = -1;
+		int partNumber = -1;
+
+    	for (int i = 0; atts[i]; i += 2)
+    	{
+    		const char* attrname = atts[i];
+    		const char* attrvalue = atts[i + 1];
+			if (!strcmp("bytes", attrname))
+			{
+				lsize = atol(attrvalue);
+			}
+			if (!strcmp("number", attrname))
+			{
+				partNumber = atol(attrvalue);
+			}
+		}
+		if (lsize > 0)
+		{
+			m_pFileInfo->SetSize(m_pFileInfo->GetSize() + lsize);
+		}
+
+		if (partNumber > 0)
+		{
+			// new segment, add it!
+			m_pArticle = new ArticleInfo();
+			m_pArticle->SetPartNumber(partNumber);
+			m_pArticle->SetSize(lsize);
+			AddArticle(m_pFileInfo, m_pArticle);
+		}
+	}
+}
+
+void NZBFile::Parse_EndElement(const char *name)
+{
+	if (!strcmp("file", name))
+	{
+		// Close the file element, add the new file to file-list
+		AddFileInfo(m_pFileInfo);
+		m_pFileInfo = NULL;
+		m_pArticle = NULL;
+	}
+	else if (!strcmp("group", name))
+	{
+		if (!m_pFileInfo)
+		{
+			// error: bad nzb-file
+			return;
+		}
+		
+		m_pFileInfo->GetGroups()->push_back(m_szTagContent);
+		m_szTagContent = NULL;
+		m_iTagContentLen = 0;
+	}
+	else if (!strcmp("segment", name))
+	{
+		if (!m_pFileInfo || !m_pArticle)
+		{
+			// error: bad nzb-file
+			return;
+		}
+
+		// Get the #text part
+		char ID[2048];
+		snprintf(ID, 2048, "<%s>", m_szTagContent);
+		m_pArticle->SetMessageID(ID);
+		m_pArticle = NULL;
+	}
+}
+
+void NZBFile::Parse_Content(const char *buf, int len)
+{
+	m_szTagContent = (char*)realloc(m_szTagContent, m_iTagContentLen + len + 1);
+	strncpy(m_szTagContent + m_iTagContentLen, buf, len);
+	m_iTagContentLen += len;
+	m_szTagContent[m_iTagContentLen] = '\0';
+}
+
+void NZBFile::SAX_StartElement(NZBFile* pFile, const char *name, const char **atts)
+{
+	pFile->Parse_StartElement(name, atts);
+}
+
+void NZBFile::SAX_EndElement(NZBFile* pFile, const char *name)
+{
+	pFile->Parse_EndElement(name);
+}
+
+void NZBFile::SAX_characters(NZBFile* pFile, const char * xmlstr, int len)
+{
+	char* str = (char*)xmlstr;
+	
+	// trim starting blanks
+	int off = 0;
+	for (int i = 0; i < len; i++)
+	{
+		char ch = str[i];
+		if (ch == ' ' || ch == 10 || ch == 13 || ch == 9)
+		{
+			off++;
+		}
+		else
+		{
+			break;
+		}
+	}
+	
+	int newlen = len - off;
+	
+	// trim ending blanks
+	for (int i = len - 1; i >= off; i--)
+	{
+		char ch = str[i];
+		if (ch == ' ' || ch == 10 || ch == 13 || ch == 9)
+		{
+			newlen--;
+		}
+		else
+		{
+			break;
+		}
+	}
+	
+	if (newlen > 0)
+	{
+		// interpret tag content
+		pFile->Parse_Content(str + off, newlen);
+	}
+}
+
+void* NZBFile::SAX_getEntity(NZBFile* pFile, const char * name)
+{
+	xmlEntityPtr e = xmlGetPredefinedEntity((xmlChar* )name);
+	if (!e)
+	{
+		warn("entity not found");
+		pFile->m_bIgnoreNextError = true;
+	}
+
+	return e;
+}
+
+void NZBFile::SAX_error(NZBFile* pFile, const char *msg, ...)
+{
+	if (pFile->m_bIgnoreNextError)
+	{
+		pFile->m_bIgnoreNextError = false;
+		return;
+	}
+	
+    va_list argp;
+    va_start(argp, msg);
+    char szErrMsg[1024];
+    vsnprintf(szErrMsg, sizeof(szErrMsg), msg, argp);
+    szErrMsg[1024-1] = '\0';
+    va_end(argp);
+
+	// remove trailing CRLF
+	for (char* pend = szErrMsg + strlen(szErrMsg) - 1; pend >= szErrMsg && (*pend == '\n' || *pend == '\r' || *pend == ' '); pend--) *pend = '\0';
+    error("Error parsing nzb-file: %s", szErrMsg);
+}
+#endif

NZBFile.h

@@ -0,0 +1,81 @@
+/*
+ *  This file is part of nzbget
+ *
+ *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007-2013 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifndef 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, bool TryQuotes);
+	void				ProcessFilenames();
+	bool				HasDuplicateFilenames();
+#ifdef WIN32
+    bool 				ParseNZB(IUnknown* nzb);
+	static void			EncodeURL(const char* szFilename, char* szURL);
+#else
+	FileInfo*			m_pFileInfo;
+	ArticleInfo*		m_pArticle;
+	char*				m_szTagContent;
+	int					m_iTagContentLen;
+	bool				m_bIgnoreNextError;
+
+	static void			SAX_StartElement(NZBFile* pFile, const char *name, const char **atts);
+	static void			SAX_EndElement(NZBFile* pFile, const char *name);
+	static void			SAX_characters(NZBFile* pFile, const char * xmlstr, int len);
+	static void*		SAX_getEntity(NZBFile* pFile, const char * name);
+	static void			SAX_error(NZBFile* pFile, const char *msg, ...);
+	void				Parse_StartElement(const char *name, const char **atts);
+	void				Parse_EndElement(const char *name);
+	void				Parse_Content(const char *buf, int len);
+#endif
+
+public:
+	virtual 			~NZBFile();
+	static NZBFile*		Create(const char* szFileName, const char* szCategory);
+	const char* 		GetFileName() const { return m_szFileName; }
+	FileInfos*			GetFileInfos() { return &m_FileInfos; }
+	NZBInfo*			GetNZBInfo() { return m_pNZBInfo; }
+	void				DetachFileInfos();
+
+	void				LogDebugInfo();
+};
+
+#endif

NewsServer.cpp

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

NewsServer.h

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

Observer.cpp

@@ -0,0 +1,62 @@
+/*
+ *  This file if part of nzbget
+ *
+ *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef WIN32
+#include "win32.h"
+#endif
+
+#include "Observer.h"
+#include "Log.h"
+
+Subject::Subject()
+{
+	m_Observers.clear();
+}
+
+void Subject::Attach(Observer* Observer)
+{
+	m_Observers.push_back(Observer);
+}
+
+void Subject::Detach(Observer* Observer)
+{
+	m_Observers.remove(Observer);
+}
+
+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, Aspect);
+	}
+}

Observer.h

@@ -1,8 +1,8 @@
 /*
- *  This file is part of nzbget. See <http://nzbget.net>.
+ *  This file if part of nzbget
  *
- *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
- *  Copyright (C) 2007-2016 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *  Copyright (C) 2004  Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007  Andrey Prygunkov <hugbug@users.sourceforge.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -15,31 +15,39 @@
  *  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, see <http://www.gnu.org/licenses/>.
+ *  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 OBSERVER_H
 #define OBSERVER_H
 
+#include <list>
+
 class Observer;
 
 class Subject
 {
-public:
-	void Attach(Observer* observer);
-	void Detach(Observer* observer);
-	void Notify(void* aspect);
-
 private:
-	std::vector<Observer*> m_observers;
+	std::list<Observer*> 	m_Observers;
+
+public:
+					Subject();
+	void 			Attach(Observer* Observer);
+	void 			Detach(Observer* Observer);
+	void 			Notify(void* Aspect);
 };
 
 class Observer
 {
-protected:
-	virtual void Update(Subject* caller, void* aspect) = 0;
-	friend class Subject;
+public:
+	virtual			~Observer() {};
+	virtual void	Update(Subject* Caller, void* Aspect) = 0;
 };
 
 #endif

Options.h

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

ParChecker.cpp

@@ -0,0 +1,922 @@
+/*
+ *  This file is part of nzbget
+ *
+ *  Copyright (C) 2007-2013 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef WIN32
+#include "win32.h"
+#endif
+
+#ifndef DISABLE_PARCHECK
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <ctype.h>
+#ifdef WIN32
+#include <par2cmdline.h>
+#include <par2repairer.h>
+#else
+#include <unistd.h>
+#include <libpar2/par2cmdline.h>
+#include <libpar2/par2repairer.h>
+#endif
+#include <algorithm>
+
+#include "nzbget.h"
+#include "ParChecker.h"
+#include "ParCoordinator.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
+{
+private:
+    CommandLine	commandLine;
+
+public:
+	Result		PreProcess(const char *szParFilename);
+	Result		Process(bool dorepair);
+
+	friend class ParChecker;
+};
+
+Result Repairer::PreProcess(const char *szParFilename)
+{
+#ifdef HAVE_PAR2_BUGFIXES_V2
+	// Ensure linking against the patched version of libpar2
+	BugfixesPatchVersion2();
+#endif
+
+	if (g_pOptions->GetParScan() == Options::psFull)
+	{
+		char szWildcardParam[1024];
+		strncpy(szWildcardParam, szParFilename, 1024);
+		szWildcardParam[1024-1] = '\0';
+		char* szBasename = Util::BaseFileName(szWildcardParam);
+		if (szBasename != szWildcardParam && strlen(szBasename) > 0)
+		{
+			szBasename[0] = '*';
+			szBasename[1] = '\0';
+		}
+
+		const char* argv[] = { "par2", "r", "-v", "-v", szParFilename, szWildcardParam };
+		if (!commandLine.Parse(6, (char**)argv))
+		{
+			return eInvalidCommandLineArguments;
+		}
+	}
+	else
+	{
+		const char* argv[] = { "par2", "r", "-v", "-v", szParFilename };
+		if (!commandLine.Parse(5, (char**)argv))
+		{
+			return eInvalidCommandLineArguments;
+		}
+	}
+
+	return Par2Repairer::PreProcess(commandLine);
+}
+
+Result Repairer::Process(bool dorepair)
+{
+	return Par2Repairer::Process(commandLine, dorepair);
+}
+
+
+class MissingFilesComparator
+{
+private:
+	const char* m_szBaseParFilename;
+public:
+	MissingFilesComparator(const char* szBaseParFilename) : m_szBaseParFilename(szBaseParFilename) {}
+	bool operator()(CommandLine::ExtraFile* pFirst, CommandLine::ExtraFile* pSecond) const;
+};
+
+
+/*
+ * Files with the same name as in par-file (and a differnt extension) are
+ * placed at the top of the list to be scanned first.
+ */
+bool MissingFilesComparator::operator()(CommandLine::ExtraFile* pFile1, CommandLine::ExtraFile* pFile2) const
+{
+	char name1[1024];
+	strncpy(name1, Util::BaseFileName(pFile1->FileName().c_str()), 1024);
+	name1[1024-1] = '\0';
+	if (char* ext = strrchr(name1, '.')) *ext = '\0'; // trim extension
+
+	char name2[1024];
+	strncpy(name2, Util::BaseFileName(pFile2->FileName().c_str()), 1024);
+	name2[1024-1] = '\0';
+	if (char* ext = strrchr(name2, '.')) *ext = '\0'; // trim extension
+
+	return strcmp(name1, m_szBaseParFilename) == 0 && strcmp(name1, name2) != 0;
+}
+
+
+ParChecker::ParChecker()
+{
+    debug("Creating ParChecker");
+
+	m_eStatus = psFailed;
+	m_szDestDir = NULL;
+	m_szNZBName = NULL;
+	m_szParFilename = 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_bCancelled = false;
+	m_eStage = ptLoadingPars;
+}
+
+ParChecker::~ParChecker()
+{
+    debug("Destroying ParChecker");
+
+	if (m_szDestDir)
+	{
+		free(m_szDestDir);
+	}
+	if (m_szNZBName)
+	{
+		free(m_szNZBName);
+	}
+	if (m_szInfoName)
+	{
+		free(m_szInfoName);
+	}
+	if (m_szErrMsg)
+	{
+		free(m_szErrMsg);
+	}
+	free(m_szProgressLabel);
+
+	Cleanup();
+}
+
+void ParChecker::Cleanup()
+{
+	for (FileList::iterator it = m_QueuedParFiles.begin(); it != m_QueuedParFiles.end() ;it++)
+	{
+		free(*it);
+	}
+	m_QueuedParFiles.clear();
+
+	for (FileList::iterator it = m_ProcessedFiles.begin(); it != m_ProcessedFiles.end() ;it++)
+	{
+		free(*it);
+	}
+	m_ProcessedFiles.clear();
+
+	m_sourceFiles.clear();
+}
+
+void ParChecker::SetDestDir(const char * szDestDir)
+{
+	if (m_szDestDir)
+	{
+		free(m_szDestDir);
+	}
+	m_szDestDir = strdup(szDestDir);
+}
+
+void ParChecker::SetNZBName(const char * szNZBName)
+{
+	if (m_szNZBName)
+	{
+		free(m_szNZBName);
+	}
+	m_szNZBName = strdup(szNZBName);
+}
+
+void ParChecker::SetInfoName(const char * szInfoName)
+{
+	if (m_szInfoName)
+	{
+		free(m_szInfoName);
+	}
+	m_szInfoName = strdup(szInfoName);
+}
+
+void ParChecker::Run()
+{
+	ParCoordinator::FileList fileList;
+	if (!ParCoordinator::FindMainPars(m_szDestDir, &fileList))
+	{
+		PrintMessage(Message::mkError, "Could not start par-check for %s. Could not find any par-files", m_szNZBName);
+		m_eStatus = psFailed;
+		Completed();
+		return;
+	}
+
+	m_eStatus = psRepairNotNeeded;
+	m_bCancelled = false;
+
+	for (ParCoordinator::FileList::iterator it = fileList.begin(); it != fileList.end(); it++)
+	{
+		char* szParFilename = *it;
+		debug("Found par: %s", szParFilename);
+
+		if (!IsStopped() && !m_bCancelled)
+		{
+			char szFullParFilename[1024];
+			snprintf(szFullParFilename, 1024, "%s%c%s", m_szDestDir, (int)PATH_SEPARATOR, szParFilename);
+			szFullParFilename[1024-1] = '\0';
+
+			char szInfoName[1024];
+			int iBaseLen = 0;
+			ParCoordinator::ParseParFilename(szParFilename, &iBaseLen, NULL);
+			int maxlen = iBaseLen < 1024 ? iBaseLen : 1024 - 1;
+			strncpy(szInfoName, szParFilename, maxlen);
+			szInfoName[maxlen] = '\0';
+			
+			char szParInfoName[1024];
+			snprintf(szParInfoName, 1024, "%s%c%s", m_szNZBName, (int)PATH_SEPARATOR, szInfoName);
+			szParInfoName[1024-1] = '\0';
+
+			SetInfoName(szParInfoName);
+
+			EStatus eStatus = RunParCheck(szFullParFilename);
+
+			// accumulate total status, the worst status has priority
+			if (m_eStatus > eStatus)
+			{
+				m_eStatus = eStatus;
+			}
+
+			if (g_pOptions->GetCreateBrokenLog())
+			{
+				WriteBrokenLog(eStatus);
+			}
+		}
+
+		free(szParFilename);
+	}
+
+	Completed();
+}
+
+void ParChecker::WriteBrokenLog(EStatus eStatus)
+{
+	char szBrokenLogName[1024];
+	snprintf(szBrokenLogName, 1024, "%s%c_brokenlog.txt", m_szDestDir, (int)PATH_SEPARATOR);
+	szBrokenLogName[1024-1] = '\0';
+	
+	if (eStatus != psRepairNotNeeded || Util::FileExists(szBrokenLogName))
+	{
+		FILE* file = fopen(szBrokenLogName, "ab");
+		if (file)
+		{
+			if (eStatus == psFailed)
+			{
+				if (m_bCancelled)
+				{
+					fprintf(file, "Repair cancelled for %s\n", m_szInfoName);
+				}
+				else
+				{
+					fprintf(file, "Repair failed for %s: %s\n", m_szInfoName, m_szErrMsg ? m_szErrMsg : "");
+				}
+			}
+			else if (eStatus == psRepairPossible)
+			{
+				fprintf(file, "Repair possible for %s\n", m_szInfoName);
+			}
+			else if (eStatus == psRepaired)
+			{
+				fprintf(file, "Successfully repaired %s\n", m_szInfoName);
+			}
+			else if (eStatus == psRepairNotNeeded)
+			{
+				fprintf(file, "Repair not needed for %s\n", m_szInfoName);
+			}
+			fclose(file);
+		}
+		else
+		{
+			PrintMessage(Message::mkError, "Could not open file %s", szBrokenLogName);
+		}
+	}
+}
+
+ParChecker::EStatus ParChecker::RunParCheck(const char* szParFilename)
+{
+	Cleanup();
+	m_szParFilename = szParFilename;
+	m_eStage = ptLoadingPars;
+	m_iProcessedFiles = 0;
+	m_iExtraFiles = 0;
+	m_bVerifyingExtraFiles = false;
+	EStatus eStatus = psFailed;
+
+	PrintMessage(Message::mkInfo, "Verifying %s", m_szInfoName);
+
+    debug("par: %s", m_szParFilename);
+	
+    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));
+
+	snprintf(m_szProgressLabel, 1024, "Verifying %s", m_szInfoName);
+	m_szProgressLabel[1024-1] = '\0';
+	m_iFileProgress = 0;
+	m_iStageProgress = 0;
+	UpdateProgress();
+
+    res = pRepairer->PreProcess(m_szParFilename);
+    debug("ParChecker: PreProcess-result=%i", res);
+
+	if (res != eSuccess || IsStopped())
+	{
+		if (res == eInvalidCommandLineArguments)
+		{
+			PrintMessage(Message::mkError, "Could not start par-check for %s. Par-file: %s", m_szInfoName, m_szParFilename);
+			m_szErrMsg = strdup("Command line could not be parsed");
+		}
+		else
+		{
+			PrintMessage(Message::mkError, "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");
+		}
+		delete pRepairer;
+		Cleanup();
+		return psFailed;
+	}
+
+	char BufReason[1024];
+	BufReason[0] = '\0';
+	if (m_szErrMsg)
+	{
+		free(m_szErrMsg);
+	}
+	m_szErrMsg = NULL;
+	
+	m_eStage = ptVerifyingSources;
+    res = pRepairer->Process(false);
+    debug("ParChecker: Process-result=%i", res);
+
+	if (!IsStopped() && pRepairer->missingfilecount > 0 && g_pOptions->GetParScan() == Options::psAuto && AddMissingFiles())
+	{
+		res = pRepairer->Process(false);
+		debug("ParChecker: Process-result=%i", res);
+	}
+
+	if (!IsStopped() && res == eRepairNotPossible && CheckSplittedFragments())
+	{
+		pRepairer->UpdateVerificationResults();
+		res = pRepairer->Process(false);
+		debug("ParChecker: Process-result=%i", res);
+	}
+
+	bool bMoreFilesLoaded = true;
+	while (!IsStopped() && res == eRepairNotPossible)
+	{
+		int missingblockcount = pRepairer->missingblockcount - pRepairer->recoverypacketmap.size();
+		if (bMoreFilesLoaded)
+		{
+			PrintMessage(Message::mkInfo, "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_bQueuedParFilesChanged = false;
+			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)
+			{
+				// wait until new files are added by "AddParFile" or a change is signaled by "QueueChanged"
+				bool bQueuedParFilesChanged = false;
+				while (!bQueuedParFilesChanged && !IsStopped())
+				{
+					m_mutexQueuedParFiles.Lock();
+					bQueuedParFilesChanged = m_bQueuedParFilesChanged;
+					m_mutexQueuedParFiles.Unlock();
+					usleep(100 * 1000);
+				}
+			}
+		}
+
+		if (IsStopped())
+		{
+			break;
+		}
+
+		bMoreFilesLoaded = LoadMorePars();
+		if (bMoreFilesLoaded)
+		{
+			pRepairer->UpdateVerificationResults();
+			res = pRepairer->Process(false);
+			debug("ParChecker: Process-result=%i", res);
+		}
+	}
+
+	if (IsStopped())
+	{
+		delete pRepairer;
+		Cleanup();
+		return psFailed;
+	}
+	
+	eStatus = psFailed;
+	
+	if (res == eSuccess)
+	{
+    	PrintMessage(Message::mkInfo, "Repair not needed for %s", m_szInfoName);
+		eStatus = psRepairNotNeeded;
+	}
+	else if (res == eRepairPossible)
+	{
+		eStatus = psRepairPossible;
+		if (g_pOptions->GetParRepair())
+		{
+			PrintMessage(Message::mkInfo, "Repairing %s", m_szInfoName);
+
+			SaveSourceList();
+			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(true);
+    		debug("ParChecker: Process-result=%i", res);
+			if (res == eSuccess)
+			{
+    			PrintMessage(Message::mkInfo, "Successfully repaired %s", m_szInfoName);
+				eStatus = psRepaired;
+				DeleteLeftovers();
+			}
+		}
+		else
+		{
+    		PrintMessage(Message::mkInfo, "Repair possible for %s", m_szInfoName);
+		}
+	}
+	
+	if (m_bCancelled)
+	{
+		if (m_eStage >= ptRepairing)
+		{
+			PrintMessage(Message::mkWarning, "Repair cancelled for %s", m_szInfoName);
+			m_szErrMsg = strdup("repair cancelled");
+			eStatus = psRepairPossible;
+		}
+		else
+		{
+			PrintMessage(Message::mkWarning, "Par-check cancelled for %s", m_szInfoName);
+			m_szErrMsg = strdup("par-check cancelled");
+			eStatus = psFailed;
+		}
+	}
+	else if (eStatus == psFailed)
+	{
+		if (!m_szErrMsg && (int)res >= 0 && (int)res <= 8)
+		{
+			m_szErrMsg = strdup(Par2CmdLineErrStr[res]);
+		}
+		PrintMessage(Message::mkError, "Repair failed for %s: %s", m_szInfoName, m_szErrMsg ? m_szErrMsg : "");
+	}
+	
+	delete pRepairer;
+	Cleanup();
+	return eStatus;
+}
+
+bool ParChecker::LoadMorePars()
+{
+	m_mutexQueuedParFiles.Lock();
+	FileList moreFiles;
+	moreFiles.assign(m_QueuedParFiles.begin(), m_QueuedParFiles.end());
+	m_QueuedParFiles.clear();
+	m_mutexQueuedParFiles.Unlock();
+	
+	for (FileList::iterator it = moreFiles.begin(); it != moreFiles.end() ;it++)
+	{
+		char* szParFilename = *it;
+		bool loadedOK = ((Repairer*)m_pRepairer)->LoadPacketsFromFile(szParFilename);
+		if (loadedOK)
+		{
+			PrintMessage(Message::mkInfo, "File %s successfully loaded for par-check", Util::BaseFileName(szParFilename), m_szInfoName);
+		}
+		else
+		{
+			PrintMessage(Message::mkInfo, "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_bQueuedParFilesChanged = true;
+	m_mutexQueuedParFiles.Unlock();
+}
+
+void ParChecker::QueueChanged()
+{
+	m_mutexQueuedParFiles.Lock();
+	m_bQueuedParFilesChanged = true;
+	m_mutexQueuedParFiles.Unlock();
+}
+
+bool ParChecker::CheckSplittedFragments()
+{
+	bool bFragmentsAdded = false;
+
+	for (std::vector<Par2RepairerSourceFile*>::iterator it = ((Repairer*)m_pRepairer)->sourcefiles.begin();
+		it != ((Repairer*)m_pRepairer)->sourcefiles.end(); it++)
+	{
+		Par2RepairerSourceFile *sourcefile = *it;
+		if (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);
+
+	std::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;
+}
+
+bool ParChecker::AddMissingFiles()
+{
+    PrintMessage(Message::mkInfo, "Performing extra par-scan for %s", m_szInfoName);
+
+	char szDirectory[1024];
+	strncpy(szDirectory, m_szParFilename, 1024);
+	szDirectory[1024-1] = '\0';
+
+	char* szBasename = Util::BaseFileName(szDirectory);
+	if (szBasename == szDirectory)
+	{
+		return false;
+	}
+	szBasename[-1] = '\0';
+
+	std::list<CommandLine::ExtraFile*> extrafiles;
+
+	DirBrowser dir(szDirectory);
+	while (const char* filename = dir.Next())
+	{
+		if (strcmp(filename, ".") && strcmp(filename, "..") && strcmp(filename, "_brokenlog.txt"))
+		{
+			bool bAlreadyScanned = false;
+			for (FileList::iterator it = m_ProcessedFiles.begin(); it != m_ProcessedFiles.end(); it++)
+			{
+				const char* szProcessedFilename = *it;
+				if (!strcasecmp(Util::BaseFileName(szProcessedFilename), filename))
+				{
+					bAlreadyScanned = true;
+					break;
+				}
+			}
+
+			if (!bAlreadyScanned)
+			{
+				char fullfilename[1024];
+				snprintf(fullfilename, 1024, "%s%c%s", szDirectory, PATH_SEPARATOR, filename);
+				fullfilename[1024-1] = '\0';
+
+				extrafiles.push_back(new CommandLine::ExtraFile(fullfilename, Util::FileSize(fullfilename)));
+			}
+		}
+	}
+
+	// Sort the list
+	char* szBaseParFilename = strdup(Util::BaseFileName(m_szParFilename));
+	if (char* ext = strrchr(szBaseParFilename, '.')) *ext = '\0'; // trim extension
+	extrafiles.sort(MissingFilesComparator(szBaseParFilename));
+	free(szBaseParFilename);
+
+	// Scan files
+	bool bFilesAdded = false;
+	if (!extrafiles.empty())
+	{
+		m_iExtraFiles += extrafiles.size();
+		m_bVerifyingExtraFiles = true;
+
+		std::list<CommandLine::ExtraFile> extrafiles1;
+
+		// adding files one by one until all missing files are found
+
+		while (!IsStopped() && !m_bCancelled && extrafiles.size() > 0 && ((Repairer*)m_pRepairer)->missingfilecount > 0)
+		{
+			CommandLine::ExtraFile* pExtraFile = extrafiles.front();
+			extrafiles.pop_front();
+
+			extrafiles1.clear();
+			extrafiles1.push_back(*pExtraFile);
+
+			bFilesAdded = ((Repairer*)m_pRepairer)->VerifyExtraFiles(extrafiles1) || bFilesAdded;
+			((Repairer*)m_pRepairer)->UpdateVerificationResults();
+
+			delete pExtraFile;
+		}
+
+		m_bVerifyingExtraFiles = false;
+
+		// free any remaining objects
+		for (std::list<CommandLine::ExtraFile*>::iterator it = extrafiles.begin(); it != extrafiles.end() ;it++)
+		{
+			delete *it;
+		}
+	}
+
+	return bFilesAdded;
+}
+
+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;
+	}
+
+	PrintMessage(Message::mkInfo, "%s %s", szStageMessage[m_eStage], str.c_str());
+
+	if (m_eStage == ptLoadingPars || m_eStage == ptVerifyingSources)
+	{
+		m_ProcessedFiles.push_back(strdup(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 (std::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)
+			{
+				PrintMessage(Message::mkWarning, "File %s has %i bad block(s) of total %i block(s)", str.c_str(), total - available, total);
+			}
+			else
+			{
+				PrintMessage(Message::mkWarning, "File %s with %i block(s) is missing", str.c_str(), total);
+			}
+		}
+	}
+}
+
+void ParChecker::Cancel()
+{
+#ifdef HAVE_PAR2_CANCEL
+	((Repairer*)m_pRepairer)->cancelled = true;
+	m_bCancelled = true;
+#else
+	PrintMessage(Message::mkError, "Could not cancel par-repair. The program was compiled using version of libpar2 which doesn't support cancelling of par-repair. Please apply libpar2-patches supplied with NZBGet and recompile libpar2 and NZBGet (see README for details).");
+#endif
+}
+
+void ParChecker::SaveSourceList()
+{
+	// Buliding a list of DiskFile-objects, marked as source-files
+	
+	for (std::vector<Par2RepairerSourceFile*>::iterator it = ((Repairer*)m_pRepairer)->sourcefiles.begin();
+		it != ((Repairer*)m_pRepairer)->sourcefiles.end(); it++)
+	{
+		Par2RepairerSourceFile* sourcefile = (Par2RepairerSourceFile*)*it;
+		vector<DataBlock>::iterator it2 = sourcefile->SourceBlocks();
+		for (int i = 0; i < (int)sourcefile->BlockCount(); i++, it2++)
+		{
+			DataBlock block = *it2;
+			DiskFile* pSourceFile = block.GetDiskFile();
+			if (pSourceFile &&
+				std::find(m_sourceFiles.begin(), m_sourceFiles.end(), pSourceFile) == m_sourceFiles.end())
+			{
+				m_sourceFiles.push_back(pSourceFile);
+			}
+		}
+	}
+}
+
+void ParChecker::DeleteLeftovers()
+{
+	// After repairing check if all DiskFile-objects saved by "SaveSourceList()" have
+	// corresponding target-files. If not - the source file was replaced. In this case
+	// the DiskFile-object points to the renamed bak-file, which we can delete.
+	
+	for (SourceList::iterator it = m_sourceFiles.begin(); it != m_sourceFiles.end(); it++)
+	{
+		DiskFile* pSourceFile = (DiskFile*)*it;
+
+		bool bFound = false;
+		for (std::vector<Par2RepairerSourceFile*>::iterator it2 = ((Repairer*)m_pRepairer)->sourcefiles.begin();
+			it2 != ((Repairer*)m_pRepairer)->sourcefiles.end(); it2++)
+		{
+			Par2RepairerSourceFile* sourcefile = *it2;
+			if (sourcefile->GetTargetFile() == pSourceFile)
+			{
+				bFound = true;
+				break;
+			}
+		}
+
+		if (!bFound)
+		{
+			PrintMessage(Message::mkInfo, "Deleting file %s", Util::BaseFileName(pSourceFile->FileName().c_str()));
+			remove(pSourceFile->FileName().c_str());
+		}
+	}
+}
+
+#endif

ParChecker.h

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

ParCoordinator.cpp

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

ParCoordinator.h

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

ParRenamer.cpp

@@ -0,0 +1,315 @@
+/*
+ *  This file is part of nzbget
+ *
+ *  Copyright (C) 2013 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef WIN32
+#include "win32.h"
+#endif
+
+#ifndef DISABLE_PARCHECK
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <ctype.h>
+#ifdef WIN32
+#include <par2cmdline.h>
+#include <par2repairer.h>
+#include <md5.h>
+#else
+#include <unistd.h>
+#include <libpar2/par2cmdline.h>
+#include <libpar2/par2repairer.h>
+#include <libpar2/md5.h>
+#endif
+
+#include "nzbget.h"
+#include "ParRenamer.h"
+#include "ParCoordinator.h"
+#include "Log.h"
+#include "Options.h"
+#include "Util.h"
+
+extern Options* g_pOptions;
+
+class ParRenamerRepairer : public Par2Repairer
+{
+public:
+	friend class ParRenamer;
+};
+
+ParRenamer::FileHash::FileHash(const char* szFilename, const char* szHash)
+{
+	m_szFilename = strdup(szFilename);
+	m_szHash = strdup(szHash);
+}
+
+ParRenamer::FileHash::~FileHash()
+{
+	free(m_szFilename);
+	free(m_szHash);
+}
+
+ParRenamer::ParRenamer()
+{
+    debug("Creating ParRenamer");
+
+	m_eStatus = psFailed;
+	m_szDestDir = NULL;
+	m_szInfoName = NULL;
+	m_szProgressLabel = (char*)malloc(1024);
+	m_iStageProgress = 0;
+	m_bCancelled = false;
+}
+
+ParRenamer::~ParRenamer()
+{
+    debug("Destroying ParRenamer");
+
+	if (m_szDestDir)
+	{
+		free(m_szDestDir);
+	}
+	if (m_szInfoName)
+	{
+		free(m_szInfoName);
+	}
+	free(m_szProgressLabel);
+
+	Cleanup();
+}
+
+void ParRenamer::Cleanup()
+{
+	for (FileHashList::iterator it = m_fileHashList.begin(); it != m_fileHashList.end(); it++)
+	{
+		delete *it;
+	}
+	m_fileHashList.clear();
+}
+
+void ParRenamer::SetDestDir(const char * szDestDir)
+{
+	if (m_szDestDir)
+	{
+		free(m_szDestDir);
+	}
+	m_szDestDir = strdup(szDestDir);
+}
+
+void ParRenamer::SetInfoName(const char * szInfoName)
+{
+	if (m_szInfoName)
+	{
+		free(m_szInfoName);
+	}
+	m_szInfoName = strdup(szInfoName);
+}
+
+void ParRenamer::Cancel()
+{
+	m_bCancelled = true;
+}
+
+void ParRenamer::Run()
+{
+	Cleanup();
+	m_bCancelled = false;
+	m_iRenamedCount = 0;
+	m_eStatus = psFailed;
+
+	snprintf(m_szProgressLabel, 1024, "Checking renamed files for %s", m_szInfoName);
+	m_szProgressLabel[1024-1] = '\0';
+	m_iStageProgress = 0;
+	UpdateProgress();
+
+	LoadParFiles();
+	CheckFiles();
+	
+	if (m_bCancelled)
+	{
+		PrintMessage(Message::mkWarning, "Renaming cancelled for %s", m_szInfoName);
+	}
+	else if (m_iRenamedCount > 0)
+	{
+		PrintMessage(Message::mkInfo, "Successfully renamed %i file(s) for %s", m_iRenamedCount, m_szInfoName);
+		m_eStatus = psSuccess;
+	}
+	else
+	{
+		PrintMessage(Message::mkInfo, "No renamed files found for %s", m_szInfoName);
+	}
+
+	Cleanup();
+	Completed();
+}
+
+void ParRenamer::LoadParFiles()
+{
+	ParCoordinator::FileList parFileList;
+	ParCoordinator::FindMainPars(m_szDestDir, &parFileList);
+	
+	for (ParCoordinator::FileList::iterator it = parFileList.begin(); it != parFileList.end(); it++)
+	{
+		char* szParFilename = *it;
+		
+		char szFullParFilename[1024];
+		snprintf(szFullParFilename, 1024, "%s%c%s", m_szDestDir, PATH_SEPARATOR, szParFilename);
+		szFullParFilename[1024-1] = '\0';
+		
+		LoadParFile(szFullParFilename);
+		
+		free(*it);
+	}
+}
+
+void ParRenamer::LoadParFile(const char* szParFilename)
+{
+	ParRenamerRepairer* pRepairer = new ParRenamerRepairer();
+
+	if (!pRepairer->LoadPacketsFromFile(szParFilename))
+	{
+		PrintMessage(Message::mkWarning, "Could not load par2-file %s", szParFilename);
+		delete pRepairer;
+		return;
+	}
+
+	for (map<MD5Hash, Par2RepairerSourceFile*>::iterator it = pRepairer->sourcefilemap.begin(); it != pRepairer->sourcefilemap.end(); it++)
+	{
+		if (m_bCancelled)
+		{
+			break;
+		}
+		
+		Par2RepairerSourceFile* sourceFile = (*it).second;
+		m_fileHashList.push_back(new FileHash(sourceFile->GetDescriptionPacket()->FileName().c_str(),
+			sourceFile->GetDescriptionPacket()->Hash16k().print().c_str()));
+	}
+
+	delete pRepairer;
+}
+
+void ParRenamer::CheckFiles()
+{
+	int iFileCount = 0;
+	DirBrowser dir2(m_szDestDir);
+	while (const char* filename = dir2.Next())
+	{
+		if (strcmp(filename, ".") && strcmp(filename, "..") && !m_bCancelled)
+		{
+			iFileCount++;
+		}
+	}
+
+	int iCurFile = 0;
+	DirBrowser dir(m_szDestDir);
+	while (const char* filename = dir.Next())
+	{
+		if (strcmp(filename, ".") && strcmp(filename, "..") && !m_bCancelled)
+		{
+			char szFullFilename[1024];
+			snprintf(szFullFilename, 1024, "%s%c%s", m_szDestDir, PATH_SEPARATOR, filename);
+			szFullFilename[1024-1] = '\0';
+
+			snprintf(m_szProgressLabel, 1024, "Checking file %s", filename);
+			m_szProgressLabel[1024-1] = '\0';
+			m_iStageProgress = iCurFile * 1000 / iFileCount;
+			UpdateProgress();
+			iCurFile++;
+			
+			CheckFile(szFullFilename);
+		}
+	}
+}
+
+void ParRenamer::CheckFile(const char* szFilename)
+{
+	debug("Computing hash for %s", szFilename);
+
+	const int iBlockSize = 16*1024;
+	
+    FILE* pFile = fopen(szFilename, "rb");
+    if (!pFile)
+    {
+		PrintMessage(Message::mkError, "Could not open file %s", szFilename);
+        return;
+    }
+
+	// load first 16K of the file into buffer
+	
+	void* pBuffer = malloc(iBlockSize);
+	
+    int iReadBytes = fread(pBuffer, 1, iBlockSize, pFile);
+	int iError = ferror(pFile);
+	if (iReadBytes != iBlockSize && iError)
+	{
+		PrintMessage(Message::mkError, "Could not read file %s", szFilename);
+		return;
+	}
+	
+    fclose(pFile);
+	
+	MD5Hash hash16k;
+	MD5Context context;
+	context.Update(pBuffer, iReadBytes);
+	context.Final(hash16k);
+	
+	free(pBuffer);
+	
+	debug("file: %s; hash16k: %s", Util::BaseFileName(szFilename), hash16k.print().c_str());
+	
+	for (FileHashList::iterator it = m_fileHashList.begin(); it != m_fileHashList.end(); it++)
+	{
+		FileHash* pFileHash = *it;
+		if (!strcmp(pFileHash->GetHash(), hash16k.print().c_str()))
+		{
+			debug("Found correct filename: %s", pFileHash->GetFilename());
+			
+			char szDstFilename[1024];
+			snprintf(szDstFilename, 1024, "%s%c%s", m_szDestDir, PATH_SEPARATOR, pFileHash->GetFilename());
+			szDstFilename[1024-1] = '\0';
+			
+			if (!Util::FileExists(szDstFilename))
+			{
+				PrintMessage(Message::mkInfo, "Renaming %s to %s", Util::BaseFileName(szFilename), pFileHash->GetFilename());
+				if (Util::MoveFile(szFilename, szDstFilename))
+				{
+					m_iRenamedCount++;
+				}
+				else
+				{
+					PrintMessage(Message::mkError, "Could not rename %s to %s", szFilename, szDstFilename);
+				}
+			}
+			
+			break;
+		}
+	}
+}
+
+#endif

ParRenamer.h

@@ -0,0 +1,98 @@
+/*
+ *  This file is part of nzbget
+ *
+ *  Copyright (C) 2013 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifndef PARRENAMER_H
+#define PARRENAMER_H
+
+#ifndef DISABLE_PARCHECK
+
+#include <deque>
+
+#include "Thread.h"
+#include "Log.h"
+
+class ParRenamer : public Thread
+{
+public:
+	enum EStatus
+	{
+		psFailed,
+		psSuccess
+	};
+	
+	class FileHash
+	{
+	private:
+		char*			m_szFilename;
+		char*			m_szHash;
+
+	public:
+						FileHash(const char* szFilename, const char* szHash);
+						~FileHash();
+		const char*		GetFilename() { return m_szFilename; }
+		const char*		GetHash() { return m_szHash; }
+	};
+
+	typedef std::deque<FileHash*>		FileHashList;
+	
+private:
+	char*				m_szInfoName;
+	char*				m_szDestDir;
+	EStatus				m_eStatus;
+	char*				m_szProgressLabel;
+	int					m_iStageProgress;
+	bool				m_bCancelled;
+	FileHashList		m_fileHashList;
+	int					m_iRenamedCount;
+
+	void				Cleanup();
+	void				LoadParFiles();
+	void				LoadParFile(const char* szParFilename);
+	void				CheckFiles();
+	void				CheckFile(const char* szFilename);
+
+protected:
+	virtual void		UpdateProgress() {}
+	virtual void		Completed() {}
+	virtual void		PrintMessage(Message::EKind eKind, const char* szFormat, ...) {}
+	const char*			GetProgressLabel() { return m_szProgressLabel; }
+	int					GetStageProgress() { return m_iStageProgress; }
+
+public:
+						ParRenamer();
+	virtual				~ParRenamer();
+	virtual void		Run();
+	void				SetDestDir(const char* szDestDir);
+	const char*			GetInfoName() { return m_szInfoName; }
+	void				SetInfoName(const char* szInfoName);
+	void				SetStatus(EStatus eStatus);
+	EStatus				GetStatus() { return m_eStatus; }
+	void				Cancel();
+	bool				GetCancelled() { return m_bCancelled; }
+};
+
+#endif
+
+#endif

PrePostProcessor.h

@@ -0,0 +1,119 @@
+/*
+ *  This file is part of nzbget
+ *
+ *  Copyright (C) 2007-2013 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifndef PREPOSTPROCESSOR_H
+#define PREPOSTPROCESSOR_H
+
+#include <deque>
+
+#include "Thread.h"
+#include "Observer.h"
+#include "DownloadInfo.h"
+#include "ParCoordinator.h"
+
+class PrePostProcessor : public Thread
+{
+public:
+	enum EEditAction
+	{
+		eaPostMoveOffset = 51,			// move post to m_iOffset relative to the current position in post-queue
+		eaPostMoveTop,
+		eaPostMoveBottom,
+		eaPostDelete,
+		eaHistoryDelete,
+		eaHistoryReturn,
+		eaHistoryProcess,
+		eaHistorySetParameter
+	};
+
+private:
+	class QueueCoordinatorObserver: public Observer
+	{
+	public:
+		PrePostProcessor* m_pOwner;
+		virtual void	Update(Subject* Caller, void* Aspect) { m_pOwner->QueueCoordinatorUpdate(Caller, Aspect); }
+	};
+
+	class PostParCoordinator: public ParCoordinator
+	{
+	private:
+		PrePostProcessor*	m_pOwner;
+	protected:
+		virtual bool		PauseDownload() { return m_pOwner->PauseDownload(); }
+		virtual bool		UnpauseDownload() { return m_pOwner->UnpauseDownload(); }
+
+		friend class PrePostProcessor;
+	};
+	
+private:
+	PostParCoordinator	m_ParCoordinator;
+	QueueCoordinatorObserver	m_QueueCoordinatorObserver;
+	bool				m_bHasMoreJobs;
+	bool				m_bSchedulerPauseChanged;
+	bool				m_bSchedulerPause;
+	bool				m_bPostPause;
+	const char*			m_szPauseReason;
+
+	bool				IsNZBFileCompleted(DownloadQueue* pDownloadQueue, NZBInfo* pNZBInfo, 
+							bool bIgnorePausedPars, bool bAllowOnlyOneDeleted);
+	void				CheckPostQueue();
+	void				JobCompleted(DownloadQueue* pDownloadQueue, PostInfo* pPostInfo);
+	void				StartJob(DownloadQueue* pDownloadQueue, PostInfo* pPostInfo);
+	void				SaveQueue(DownloadQueue* pDownloadQueue);
+	void				SanitisePostQueue(PostQueue* pPostQueue);
+	void				CheckDiskSpace();
+	void				ApplySchedulerState();
+	void				CheckScheduledResume();
+	void				UpdatePauseState(bool bNeedPause, const char* szReason);
+	bool				PauseDownload();
+	bool				UnpauseDownload();
+	void				NZBAdded(DownloadQueue* pDownloadQueue, NZBInfo* pNZBInfo);
+	void				NZBDownloaded(DownloadQueue* pDownloadQueue, NZBInfo* pNZBInfo);
+	void				NZBDeleted(DownloadQueue* pDownloadQueue, NZBInfo* pNZBInfo);
+	void				NZBCompleted(DownloadQueue* pDownloadQueue, NZBInfo* pNZBInfo, bool bSaveQueue);
+	void				DeleteQueuedFile(const char* szQueuedFile);
+	NZBInfo*			MergeGroups(DownloadQueue* pDownloadQueue, NZBInfo* pNZBInfo);
+	bool				PostQueueMove(IDList* pIDList, EEditAction eAction, int iOffset);
+	bool				PostQueueDelete(IDList* pIDList);
+	bool				HistoryEdit(IDList* pIDList, EEditAction eAction, int iOffset, const char* szText);
+	void				HistoryDelete(DownloadQueue* pDownloadQueue, HistoryList::iterator itHistory, HistoryInfo* pHistoryInfo);
+	void				HistoryReturn(DownloadQueue* pDownloadQueue, HistoryList::iterator itHistory, HistoryInfo* pHistoryInfo, bool bReprocess);
+	void				HistorySetParameter(HistoryInfo* pHistoryInfo, const char* szText);
+	void				Cleanup();
+	FileInfo*			GetQueueGroup(DownloadQueue* pDownloadQueue, NZBInfo* pNZBInfo);
+	void				CheckHistory();
+	void				DeletePostThread(PostInfo* pPostInfo);
+
+public:
+						PrePostProcessor();
+	virtual				~PrePostProcessor();
+	virtual void		Run();
+	virtual void		Stop();
+	void				QueueCoordinatorUpdate(Subject* Caller, void* Aspect);
+	bool				HasMoreJobs() { return m_bHasMoreJobs; }
+	bool				QueueEditList(IDList* pIDList, EEditAction eAction, int iOffset, const char* szText);
+};
+
+#endif

QueueCoordinator.h

@@ -0,0 +1,131 @@
+/*
+ *  This file is part of nzbget
+ *
+ *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007-2010 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 QUEUECOORDINATOR_H
+#define QUEUECOORDINATOR_H
+
+#include <deque>
+#include <list>
+#include <time.h>
+
+#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 DownloadQueueHolder
+{
+public:
+	typedef std::list<ArticleDownloader*>	ActiveDownloads;
+	enum EAspectAction
+	{
+		eaNZBFileAdded,
+		eaFileCompleted,
+		eaFileDeleted
+	};
+	struct Aspect
+	{
+		EAspectAction eAction;
+		DownloadQueue* pDownloadQueue;
+		NZBInfo* pNZBInfo;
+		FileInfo* pFileInfo;
+	};
+
+private:
+	DownloadQueue			m_DownloadQueue;
+	ActiveDownloads			m_ActiveDownloads;
+	QueueEditor				m_QueueEditor;
+	Mutex			 		m_mutexDownloadQueue;
+	bool					m_bHasMoreJobs;
+	int						m_iDownloadsLimit;
+
+	// 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; 
+	time_t					m_tSpeedCorrection;
+#ifdef HAVE_SPINLOCK
+	SpinLock				m_spinlockSpeed;
+#else
+	Mutex					m_mutexSpeed;
+#endif
+
+    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);
+	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 int				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* pNZBFile, bool bAddFirst);
+	bool					HasMoreJobs() { return m_bHasMoreJobs; }
+	bool					GetStandBy() { return m_bStandBy; }
+	bool					DeleteQueueEntry(FileInfo* pFileInfo);
+	bool					SetQueueEntryNZBCategory(NZBInfo* pNZBInfo, const char* szCategory);
+	bool					SetQueueEntryNZBName(NZBInfo* pNZBInfo, const char* szName);
+	bool					MergeQueueEntries(NZBInfo* pDestNZBInfo, NZBInfo* pSrcNZBInfo);
+	bool					SplitQueueEntries(FileQueue* pFileList, const char* szName, NZBInfo** pNewNZBInfo);
+	void					DiscardDiskFile(FileInfo* pFileInfo);
+	QueueEditor*			GetQueueEditor() { return &m_QueueEditor; }
+
+	void					LogDebugInfo();
+};
+
+#endif

QueueEditor.cpp

@@ -0,0 +1,964 @@
+/*
+ *  This file is part of nzbget
+ *
+ *  Copyright (C) 2007-2013 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#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>
+#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 (FileQueue::iterator it = pDownloadQueue->GetFileQueue()->begin(); it != pDownloadQueue->GetFileQueue()->end(); it++)
+	{
+		FileInfo* pFileInfo = *it;
+		if (pFileInfo->GetID() == iID)
+		{
+			return pFileInfo;
+		}
+	}
+	return NULL;
+}
+
+int QueueEditor::FindFileInfoEntry(DownloadQueue* pDownloadQueue, FileInfo* pFileInfo)
+{
+	int iEntry = 0;
+	for (FileQueue::iterator it = pDownloadQueue->GetFileQueue()->begin(); it != pDownloadQueue->GetFileQueue()->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
+ * 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 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->GetFileQueue()->size() - 1)
+		{
+			iNewEntry = (int)pDownloadQueue->GetFileQueue()->size() - 1;
+		}
+
+		if (iNewEntry >= 0 && (unsigned int)iNewEntry <= pDownloadQueue->GetFileQueue()->size() - 1)
+		{
+			FileInfo* fi = pDownloadQueue->GetFileQueue()->at(iEntry);
+			pDownloadQueue->GetFileQueue()->erase(pDownloadQueue->GetFileQueue()->begin() + iEntry);
+			pDownloadQueue->GetFileQueue()->insert(pDownloadQueue->GetFileQueue()->begin() + iNewEntry, fi);
+		}
+	}
+}
+
+/*
+ * Set priority for entry
+ * returns true if successful, false if operation is not possible
+ */
+void QueueEditor::SetPriorityEntry(FileInfo* pFileInfo, const char* szPriority)
+{
+	debug("Setting priority %s for file %s", szPriority, pFileInfo->GetFilename());
+	int iPriority = atoi(szPriority);
+	pFileInfo->SetPriority(iPriority);
+}
+
+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, NULL, mmID, 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, NameList* pNameList, EMatchMode eMatchMode, bool bSmartOrder, 
+	EEditAction eAction, int iOffset, const char* szText)
+{
+	DownloadQueue* pDownloadQueue = g_pQueueCoordinator->LockQueue();
+
+	bool bOK = true;
+
+	if (pNameList)
+	{
+		pIDList = new IDList();
+		bOK = BuildIDListFromNameList(pDownloadQueue, pIDList, pNameList, eMatchMode, eAction);
+	}
+
+	bOK = bOK && (InternEditList(pDownloadQueue, pIDList, bSmartOrder, eAction, iOffset, szText) || eMatchMode == mmRegEx);
+
+	if (g_pOptions->GetSaveQueue() && g_pOptions->GetServerMode())
+	{
+		g_pDiskState->SaveDownloadQueue(pDownloadQueue);
+	}
+
+	g_pQueueCoordinator->UnlockQueue();
+
+	if (pNameList)
+	{
+		delete pIDList;
+	}
+
+	return bOK;
+}
+
+bool QueueEditor::LockedEditList(DownloadQueue* pDownloadQueue, IDList* pIDList, bool bSmartOrder, EEditAction eAction, int iOffset, const char* szText)
+{
+	return InternEditList(pDownloadQueue, pIDList, bSmartOrder, eAction, iOffset, szText);
+}
+
+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 if (eAction == eaGroupMerge)
+	{
+		return MergeGroups(pDownloadQueue, &cItemList);
+	}
+	else if (eAction == eaFileSplit)
+	{
+		return SplitGroup(pDownloadQueue, &cItemList, szText);
+	}
+	else if (eAction == eaFileReorder)
+	{
+		ReorderFiles(pDownloadQueue, &cItemList);
+	}
+	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 eaFileSetPriority:
+					SetPriorityEntry(pItem->m_pFileInfo, szText);
+					break;
+
+				case eaGroupSetCategory:
+					SetNZBCategory(pItem->m_pFileInfo->GetNZBInfo(), szText);
+					break;
+
+				case eaGroupSetName:
+					SetNZBName(pItem->m_pFileInfo->GetNZBInfo(), szText);
+					break;
+
+				case eaGroupSetParameter:
+					SetNZBParameter(pItem->m_pFileInfo->GetNZBInfo(), szText);
+					break;
+
+				case eaGroupPause:
+				case eaGroupResume:
+				case eaGroupDelete:
+				case eaGroupMoveTop:
+				case eaGroupMoveBottom:
+				case eaGroupMoveOffset:
+				case eaGroupPauseAllPars:
+				case eaGroupPauseExtraPars:
+				case eaGroupSetPriority:
+					EditGroup(pDownloadQueue, pItem->m_pFileInfo, eAction, iOffset, szText);
+					break;
+
+				case eaFilePauseAllPars:
+				case eaFilePauseExtraPars:
+				case eaGroupMerge:
+				case eaFileReorder:
+				case eaFileSplit:
+					// remove compiler warning "enumeration not handled in switch"
+					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->GetFileQueue()->size();
+			iStep = 1;
+		}
+		else
+		{
+			iStart = pDownloadQueue->GetFileQueue()->size() - 1;
+			iEnd = -1;
+			iStep = -1;
+		}
+		for (int iIndex = iStart; iIndex != iEnd; iIndex += iStep)
+		{
+			FileInfo* pFileInfo = pDownloadQueue->GetFileQueue()->at(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->GetFileQueue()->size()) - 1)
+						{
+							iWorkOffset = int(pDownloadQueue->GetFileQueue()->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 (FileQueue::iterator it = pDownloadQueue->GetFileQueue()->begin(); it != pDownloadQueue->GetFileQueue()->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::BuildIDListFromNameList(DownloadQueue* pDownloadQueue, IDList* pIDList, NameList* pNameList, EMatchMode eMatchMode, EEditAction eAction)
+{
+#ifndef HAVE_REGEX_H
+	if (eMatchMode == mmRegEx)
+	{
+		return false;
+	}
+#endif
+
+	std::set<int> uniqueIDs;
+
+	for (NameList::iterator it = pNameList->begin(); it != pNameList->end(); it++)
+	{
+		const char* szName = *it;
+
+		RegEx *pRegEx = NULL;
+		if (eMatchMode == mmRegEx)
+		{
+			pRegEx = new RegEx(szName);
+			if (!pRegEx->IsValid())
+			{
+				delete pRegEx;
+				return false;
+			}
+		}
+
+		bool bFound = false;
+
+		for (FileQueue::iterator it2 = pDownloadQueue->GetFileQueue()->begin(); it2 != pDownloadQueue->GetFileQueue()->end(); it2++)
+		{
+			FileInfo* pFileInfo = *it2;
+			if (eAction < eaGroupMoveOffset)
+			{
+				// file action
+				char szFilename[MAX_PATH];
+				snprintf(szFilename, sizeof(szFilename) - 1, "%s/%s", pFileInfo->GetNZBInfo()->GetName(), Util::BaseFileName(pFileInfo->GetFilename()));
+				if (((!pRegEx && !strcmp(szFilename, szName)) || (pRegEx && pRegEx->Match(szFilename))) &&
+					(uniqueIDs.find(pFileInfo->GetID()) == uniqueIDs.end()))
+				{
+					uniqueIDs.insert(pFileInfo->GetID());
+					pIDList->push_back(pFileInfo->GetID());
+					bFound = true;
+				}
+			}
+			else
+			{
+				// group action
+				const char *szFilename = pFileInfo->GetNZBInfo()->GetName();
+				if (((!pRegEx && !strcmp(szFilename, szName)) || (pRegEx && pRegEx->Match(szFilename))) &&
+					(uniqueIDs.find(pFileInfo->GetNZBInfo()->GetID()) == uniqueIDs.end()))
+				{
+					uniqueIDs.insert(pFileInfo->GetNZBInfo()->GetID());
+					pIDList->push_back(pFileInfo->GetID());
+					bFound = true;
+				}
+			}
+		}
+
+		if (pRegEx)
+		{
+			delete pRegEx;
+		}
+
+		if (!bFound && (eMatchMode == mmName))
+		{
+			return false;
+		}
+	}
+
+	return true;
+}
+
+bool QueueEditor::EditGroup(DownloadQueue* pDownloadQueue, FileInfo* pFileInfo, EEditAction eAction, int iOffset, const char* szText)
+{
+	IDList cIDList;
+	cIDList.clear();
+
+	// collecting files belonging to group
+	for (FileQueue::iterator it = pDownloadQueue->GetFileQueue()->begin(); it != pDownloadQueue->GetFileQueue()->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;
+	}
+	else if (eAction == eaGroupDelete)
+	{
+		pFileInfo->GetNZBInfo()->SetDeleted(true);
+		pFileInfo->GetNZBInfo()->SetCleanupDisk(CanCleanupDisk(pDownloadQueue, pFileInfo->GetNZBInfo()));
+	}
+
+	EEditAction GroupToFileMap[] = { (EEditAction)0, eaFileMoveOffset, eaFileMoveTop, eaFileMoveBottom, eaFilePause,
+		eaFileResume, eaFileDelete, eaFilePauseAllPars, eaFilePauseExtraPars, eaFileSetPriority, eaFileReorder, eaFileSplit,
+		eaFileMoveOffset, eaFileMoveTop, eaFileMoveBottom, eaFilePause, eaFileResume, eaFileDelete, 
+		eaFilePauseAllPars, eaFilePauseExtraPars, eaFileSetPriority,
+		(EEditAction)0, (EEditAction)0, (EEditAction)0 };
+
+	return InternEditList(pDownloadQueue, &cIDList, true, GroupToFileMap[eAction], iOffset, szText);
+}
+
+void QueueEditor::BuildGroupList(DownloadQueue* pDownloadQueue, FileList* pGroupList)
+{
+	pGroupList->clear();
+    for (FileQueue::iterator it = pDownloadQueue->GetFileQueue()->begin(); it != pDownloadQueue->GetFileQueue()->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->GetNZBInfo());
+	}
+}
+
+void QueueEditor::AlignGroup(DownloadQueue* pDownloadQueue, NZBInfo* pNZBInfo)
+{
+	FileInfo* pLastFileInfo = NULL;
+	unsigned int iLastNum = 0;
+	unsigned int iNum = 0;
+	while (iNum < pDownloadQueue->GetFileQueue()->size())
+	{
+		FileInfo* pFileInfo = pDownloadQueue->GetFileQueue()->at(iNum);
+		if (pFileInfo->GetNZBInfo() == pNZBInfo)
+		{
+			if (pLastFileInfo && iNum - iLastNum > 1)
+			{
+				pDownloadQueue->GetFileQueue()->erase(pDownloadQueue->GetFileQueue()->begin() + iNum);
+				pDownloadQueue->GetFileQueue()->insert(pDownloadQueue->GetFileQueue()->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);
+}
+
+void QueueEditor::SetNZBName(NZBInfo* pNZBInfo, const char* szName)
+{
+	debug("QueueEditor: renaming '%s' to '%s'", Util::BaseFileName(pNZBInfo->GetFilename()), szName);
+
+	g_pQueueCoordinator->SetQueueEntryNZBName(pNZBInfo, szName);
+}
+
+/**
+* Check if deletion of already downloaded files is possible (when nzb id deleted from queue).
+* The deletion is most always possible, except the case if all remaining files in queue 
+* (belonging to this nzb-file) are PARS.
+*/
+bool QueueEditor::CanCleanupDisk(DownloadQueue* pDownloadQueue, NZBInfo* pNZBInfo)
+{
+    for (FileQueue::iterator it = pDownloadQueue->GetFileQueue()->begin(); it != pDownloadQueue->GetFileQueue()->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"))
+		{
+			// non-par file found
+			return true;
+		}
+	}
+
+	return false;
+}
+
+bool QueueEditor::MergeGroups(DownloadQueue* pDownloadQueue, ItemList* pItemList)
+{
+	if (pItemList->size() == 0)
+	{
+		return false;
+	}
+
+	bool bOK = true;
+
+	EditItem* pDestItem = pItemList->front();
+
+	for (ItemList::iterator it = pItemList->begin() + 1; it != pItemList->end(); it++)
+	{
+		EditItem* pItem = *it;
+		if (pItem->m_pFileInfo->GetNZBInfo() != pDestItem->m_pFileInfo->GetNZBInfo())
+		{
+			debug("merge %s to %s", pItem->m_pFileInfo->GetNZBInfo()->GetFilename(), pDestItem->m_pFileInfo->GetNZBInfo()->GetFilename());
+			if (g_pQueueCoordinator->MergeQueueEntries(pDestItem->m_pFileInfo->GetNZBInfo(), pItem->m_pFileInfo->GetNZBInfo()))
+			{
+				bOK = false;
+			}
+		}
+		delete pItem;
+	}
+
+	AlignGroup(pDownloadQueue, pDestItem->m_pFileInfo->GetNZBInfo());
+
+	delete pDestItem;
+	return bOK;
+}
+
+bool QueueEditor::SplitGroup(DownloadQueue* pDownloadQueue, ItemList* pItemList, const char* szName)
+{
+	if (pItemList->size() == 0)
+	{
+		return false;
+	}
+
+	FileQueue* pFileList = new FileQueue();
+
+	for (ItemList::iterator it = pItemList->begin(); it != pItemList->end(); it++)
+	{
+		EditItem* pItem = *it;
+		pFileList->push_back(pItem->m_pFileInfo);
+		delete pItem;
+	}
+
+	NZBInfo* pNewNZBInfo = NULL;
+	bool bOK = g_pQueueCoordinator->SplitQueueEntries(pFileList, szName, &pNewNZBInfo);
+	if (bOK)
+	{
+		AlignGroup(pDownloadQueue, pNewNZBInfo);
+	}
+
+	delete pFileList;
+	return bOK;
+}
+
+void QueueEditor::ReorderFiles(DownloadQueue* pDownloadQueue, ItemList* pItemList)
+{
+	if (pItemList->size() == 0)
+	{
+		return;
+	}
+
+	EditItem* pFirstItem = pItemList->front();
+	NZBInfo* pNZBInfo = pFirstItem->m_pFileInfo->GetNZBInfo();
+	unsigned int iInsertPos = 0;
+
+	// find first file of the group
+    for (FileQueue::iterator it = pDownloadQueue->GetFileQueue()->begin(); it != pDownloadQueue->GetFileQueue()->end(); it++)
+    {
+        FileInfo* pFileInfo = *it;
+		if (pFileInfo->GetNZBInfo() == pNZBInfo)
+		{
+			break;
+		}
+		iInsertPos++;
+	}
+
+	// now can reorder
+	for (ItemList::iterator it = pItemList->begin(); it != pItemList->end(); it++)
+	{
+		EditItem* pItem = *it;
+		FileInfo* pFileInfo = pItem->m_pFileInfo;
+
+		// move file item
+		for (FileQueue::iterator it = pDownloadQueue->GetFileQueue()->begin(); it != pDownloadQueue->GetFileQueue()->end(); it++)
+		{
+			FileInfo* pFileInfo1 = *it;
+			if (pFileInfo1 == pFileInfo)
+			{
+				pDownloadQueue->GetFileQueue()->erase(it);
+				pDownloadQueue->GetFileQueue()->insert(pDownloadQueue->GetFileQueue()->begin() + iInsertPos, pFileInfo);
+				iInsertPos++;				
+				break;
+			}
+		}
+
+		delete pItem;
+	}
+}
+
+void QueueEditor::SetNZBParameter(NZBInfo* pNZBInfo, const char* szParamString)
+{
+	debug("QueueEditor: setting nzb parameter '%s' for '%s'", szParamString, Util::BaseFileName(pNZBInfo->GetFilename()));
+
+	char* szStr = strdup(szParamString);
+
+	char* szValue = strchr(szStr, '=');
+	if (szValue)
+	{
+		*szValue = '\0';
+		szValue++;
+		pNZBInfo->SetParameter(szStr, szValue);
+	}
+	else
+	{
+		error("Could not set nzb parameter for %s: invalid argument: %s", pNZBInfo->GetName(), szParamString);
+	}
+
+	free(szStr);
+}

QueueEditor.h

@@ -0,0 +1,121 @@
+/*
+ *  This file if part of nzbget
+ *
+ *  Copyright (C) 2007-2013 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifndef QUEUEEDITOR_H
+#define QUEUEEDITOR_H
+
+#include <vector>
+
+#include "DownloadInfo.h"
+
+class QueueEditor
+{
+public:
+	enum EEditAction
+	{
+		eaFileMoveOffset = 1,			// move to m_iOffset relative to the current position in queue
+		eaFileMoveTop,
+		eaFileMoveBottom,
+		eaFilePause,
+		eaFileResume,
+		eaFileDelete,
+		eaFilePauseAllPars,
+		eaFilePauseExtraPars,
+		eaFileSetPriority,
+		eaFileReorder,
+		eaFileSplit,
+		eaGroupMoveOffset,				// move to m_iOffset relative to the current position in queue
+		eaGroupMoveTop,
+		eaGroupMoveBottom,
+		eaGroupPause,
+		eaGroupResume,
+		eaGroupDelete,
+		eaGroupPauseAllPars,
+		eaGroupPauseExtraPars,
+		eaGroupSetPriority,
+		eaGroupSetCategory,
+		eaGroupMerge,
+		eaGroupSetParameter,
+		eaGroupSetName
+	};
+
+	enum EMatchMode
+	{
+		mmID = 1,
+		mmName,
+		mmRegEx
+	};
+
+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					BuildIDListFromNameList(DownloadQueue* pDownloadQueue, IDList* pIDList, NameList* pNameList, EMatchMode eMatchMode, EEditAction eAction);
+	bool					EditGroup(DownloadQueue* pDownloadQueue, FileInfo* pFileInfo, EEditAction eAction, int iOffset, const char* szText);
+	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, NZBInfo* pNZBInfo);
+	void					PauseParsInGroups(ItemList* pItemList, bool bExtraParsOnly);
+	void					PausePars(FileList* pFileList, bool bExtraParsOnly);
+	void					SetNZBCategory(NZBInfo* pNZBInfo, const char* szCategory);
+	void					SetNZBName(NZBInfo* pNZBInfo, const char* szName);
+	bool					CanCleanupDisk(DownloadQueue* pDownloadQueue, NZBInfo* pNZBInfo);
+	bool					MergeGroups(DownloadQueue* pDownloadQueue, ItemList* pItemList);
+	bool					SplitGroup(DownloadQueue* pDownloadQueue, ItemList* pItemList, const char* szName);
+	void					ReorderFiles(DownloadQueue* pDownloadQueue, ItemList* pItemList);
+	void					SetNZBParameter(NZBInfo* pNZBInfo, const char* szParamString);
+
+	void					PauseUnpauseEntry(FileInfo* pFileInfo, bool bPause);
+	void					DeleteEntry(FileInfo* pFileInfo);
+	void					MoveEntry(DownloadQueue* pDownloadQueue, FileInfo* pFileInfo, int iOffset);
+	void					SetPriorityEntry(FileInfo* pFileInfo, const char* szPriority);
+
+public:
+							QueueEditor();                
+							~QueueEditor();
+
+	bool					EditEntry(int ID, bool bSmartOrder, EEditAction eAction, int iOffset, const char* szText);
+	bool					EditList(IDList* pIDList, NameList* pNameList, EMatchMode eMatchMode, bool bSmartOrder, EEditAction eAction, int iOffset, const char* szText);
+
+	bool					LockedEditEntry(DownloadQueue* pDownloadQueue, int ID, bool bSmartOrder, EEditAction eAction, int iOffset, const char* szText);
+	bool					LockedEditList(DownloadQueue* pDownloadQueue, IDList* pIDList, bool bSmartOrder, EEditAction eAction, int iOffset, const char* szText);
+};
+
+#endif

README

@@ -4,7 +4,7 @@
 
 This is a short documentation. For more information please
 visit NZBGet home page at 
-  http://nzbget.net
+  http://nzbget.sourceforge.net
 
 Contents          
 --------
@@ -44,16 +44,25 @@ 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.
+
+It should run at least on:
+  - Linux Debian 5.0 on x86;
+  - Linux with uClibc on MIPSEL and ARM;
+  - OpenBSD 5.0 on x86;
+  - Mac OS X 10.7 Lion on x64;
+  - Windows XP SP3 on x86 and Windows 7 on x64.
 
 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 +71,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 +85,20 @@ 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 
@@ -138,13 +151,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.
+    you can not neither GnuTLS nor OpenSSL.
 
   --disable-gzip - to make without gzip support. Use this option
     if you can not use zlib.
@@ -155,13 +168,37 @@ 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 use nzbget on a very slow computer like NAS-device, it may be good to
+limit the time allowed for par-repair (option "ParTimeLimit" in nzbget 
+configuration file). This feature requires a patched version of libpar2.
+To compile that version download the original source code of libpar2
+(version 0.2) and apply patches "libpar2-0.2-bugfixes.patch" and 
+"libpar2-0.2-cancel.patch", provided with nzbget:
+
+  cd libpar2-0.2
+  cp ~/nzbget/libpar2-0.2-*.patch .
+  patch < libpar2-0.2-bugfixes.patch
+  patch < libpar2-0.2-cancel.patch
+  ./configure
+  make
+  make install
+
+If you are not able to use libpar2 or libsigc++ or do not want them you can
+make nzbget without support for par-check using option "--disable-parcheck":
 
   ./configure --disable-parcheck
 
@@ -169,10 +206,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 +219,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":
@@ -206,17 +243,32 @@ TLS/SSL support using option "--disable-tls":
 5. Compiling on Windows
 =====================================
 
-NZBGet is developed using MS Visual Studio 2015 (Community Edition). The project
-file is provided.
+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 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:
 
-To compile the program with TLS/SSL support you need either OpenSSL or GnuTLS:
-   - OpenSSL  (http://www.openssl.org)
-   or
    - 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
@@ -243,7 +295,6 @@ 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
@@ -336,18 +387,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
   
@@ -360,8 +402,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
 
@@ -402,10 +444,10 @@ Post processing scripts
 After the download of nzb-file is completed nzbget can call post-processing
 scripts, defined in configuration file.
 
-Example post-processing scripts are provided in directory "scripts".
+Example post-processing scripts are provided in directory "ppscripts".
 
 To use the scripts copy them into your local directory and set options
-<ScriptDir>, <PostScript> and <ScriptOrder>.
+<ScriptDir>, <DefScript> and <ScriptOrder>.
 
 For information on writing your own post-processing scripts please
 visit NZBGet web site.
@@ -427,14 +469,13 @@ and port defined in NZBGet configuration file in options "ControlIP" and
 
   http://localhost:6789/
 
-For login credentials type username and the password defined by
-options "ControlUsername" (default "nzbget") and "ControlPassword"
-(default "tegbzn6789").
+For login credentials type username "nzbget" (predefined and not changeable)
+and the password from the option "ControlPassword" (default is 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/
+  http://localhost:6789/nzbget: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
@@ -453,35 +494,6 @@ 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>
-
 =====================================
 9. Copyright
 =====================================
@@ -495,13 +507,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
 
-    nzbget.net/forum
+    nzbget.sourceforge.net/forum
 
 or contact me at
 

README.md

@@ -1,19 +0,0 @@
-# NZBGet #
-[![License](https://img.shields.io/badge/license-GPL-blue.svg)](http://www.gnu.org/licenses/)
-[![Build Status](https://img.shields.io/travis/nzbget/nzbget/develop.svg)](https://travis-ci.org/nzbget/nzbget)
-[![Code Quality: Cpp](https://img.shields.io/lgtm/grade/cpp/g/nzbget/nzbget.svg?label=code%20quality:%20c%2b%2b)](https://lgtm.com/projects/g/nzbget/nzbget/context:cpp)
-[![Code Quality: JavaScript](https://img.shields.io/lgtm/grade/javascript/g/nzbget/nzbget.svg?label=code%20quality:%20js)](https://lgtm.com/projects/g/nzbget/nzbget/context:javascript)
-[![Total Alerts](https://img.shields.io/lgtm/alerts/g/nzbget/nzbget.svg)](https://lgtm.com/projects/g/nzbget/nzbget/alerts)
-
-[![Total downloads](https://img.shields.io/github/downloads/nzbget/nzbget/total.svg)](https://github.com/nzbget/nzbget/releases)
-[![Downloads (latest release)](https://img.shields.io/github/downloads/nzbget/nzbget/latest/total.svg?label=latest%20release)](https://github.com/nzbget/nzbget/releases/latest)
-
-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 performance and efficiency.
-
-NZBGet can run on almost any device - classic PC, NAS, media player, SAT-receiver, WLAN-router, etc.
-The download area provides precompiled binaries for Windows, macOS, Linux (compatible with
-many CPUs and platform variants), FreeBSD and Android. For other platforms
-the program can be compiled from sources.

RemoteClient.h

@@ -0,0 +1,83 @@
+/*
+ *  This file is part of nzbget
+ *
+ *  Copyright (C) 2005 Bo Cordes Petersen <placebodk@users.sourceforge.net>
+ *  Copyright (C) 2007-2009 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 REMOTECLIENT_H
+#define REMOTECLIENT_H
+
+#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;
+	bool			m_bVerbose;
+
+	bool			InitConnection();
+	void			InitMessageBase(SNZBRequestBase* pMessageBase, int iRequest, int iSize);
+	bool			ReceiveBoolResponse();
+	void			printf(const char* msg, ...);
+	void			perror(const char* msg);
+
+public:
+					RemoteClient();
+					~RemoteClient();
+	void			SetVerbose(bool bVerbose) { m_bVerbose = bVerbose; };
+	bool 			RequestServerDownload(const char* szFilename, const char* szCategory, bool bAddFirst, bool bAddPaused, int iPriority);
+	bool			RequestServerList(bool bFiles, bool bGroups, const char* szPattern);
+	bool			RequestServerPauseUnpause(bool bPause, eRemotePauseUnpauseAction iAction);
+	bool			RequestServerSetDownloadRate(int iRate);
+	bool			RequestServerDumpDebug();
+	bool 			RequestServerEditQueue(eRemoteEditAction iAction, int iOffset, const char* szText, 
+		int* pIDList, int iIDCount, NameList* pNameList, eRemoteMatchMode iMatchMode, 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 			RequestServerDownloadUrl(const char* szURL, const char* szNZBFilename, const char* szCategory, bool bAddFirst, bool bAddPaused, int iPriority);
+	bool			RequestUrlQueue();
+	void			BuildFileList(SNZBListResponse* pListResponse, const char* pTrailingData, DownloadQueue* pDownloadQueue);
+};
+
+#endif

RemoteServer.cpp

@@ -0,0 +1,238 @@
+/*
+ *  This file is part of nzbget
+ *
+ *  Copyright (C) 2005 Bo Cordes Petersen <placebodk@sourceforge.net>
+ *  Copyright (C) 2007-2013 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef WIN32
+#include "win32.h"
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#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 "WebServer.h"
+#include "Log.h"
+#include "Options.h"
+#include "Util.h"
+
+extern Options* g_pOptions;
+
+//*****************************************************************
+// RemoteServer
+
+RemoteServer::RemoteServer(bool bTLS)
+{
+	debug("Creating RemoteServer");
+
+	m_bTLS = bTLS;
+	m_pConnection = NULL;
+}
+
+RemoteServer::~RemoteServer()
+{
+	debug("Destroying RemoteServer");
+
+	if (m_pConnection)
+	{
+		delete m_pConnection;
+	}
+}
+
+void RemoteServer::Run()
+{
+	debug("Entering RemoteServer-loop");
+
+#ifndef DISABLE_TLS
+	if (m_bTLS)
+	{
+		if (strlen(g_pOptions->GetSecureCert()) == 0 || !Util::FileExists(g_pOptions->GetSecureCert()))
+		{
+			error("Could not initialize TLS, secure certificate is not configured or the cert-file was not found. Check option <SecureCert>");
+			return;
+		}
+
+		if (strlen(g_pOptions->GetSecureKey()) == 0 || !Util::FileExists(g_pOptions->GetSecureKey()))
+		{
+			error("Could not initialize TLS, secure key is not configured or the key-file was not found. Check option <SecureKey>");
+			return;
+		}
+	}
+#endif
+
+	while (!IsStopped())
+	{
+		bool bBind = true;
+
+		if (!m_pConnection)
+		{
+			m_pConnection = new Connection(g_pOptions->GetControlIP(), 
+				m_bTLS ? g_pOptions->GetSecurePort() : g_pOptions->GetControlPort(),
+				m_bTLS);
+			m_pConnection->SetTimeout(g_pOptions->GetConnectionTimeout());
+			m_pConnection->SetSuppressErrors(false);
+			bBind = m_pConnection->Bind();
+		}
+
+		// Accept connections and store the new Connection
+		Connection* pAcceptedConnection = NULL;
+		if (bBind)
+		{
+			pAcceptedConnection = m_pConnection->Accept();
+		}
+		if (!bBind || pAcceptedConnection == NULL)
+		{
+			// 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->SetConnection(pAcceptedConnection);
+#ifndef DISABLE_TLS
+		commandThread->SetTLS(m_bTLS);
+#endif
+		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
+
+RequestProcessor::~RequestProcessor()
+{
+	m_pConnection->Disconnect();
+	delete m_pConnection;
+}
+
+void RequestProcessor::Run()
+{
+	bool bOK = false;
+
+	m_pConnection->SetSuppressErrors(true);
+
+#ifndef DISABLE_TLS
+	if (m_bTLS && !m_pConnection->StartTLS(false, g_pOptions->GetSecureCert(), g_pOptions->GetSecureKey()))
+	{
+		debug("Could not establish secure connection to web-client: Start TLS failed");
+		return;
+	}
+#endif
+
+	// Read the first 4 bytes to determine request type
+	int iSignature = 0;
+	if (!m_pConnection->Recv((char*)&iSignature, 4))
+	{
+		debug("Could not read request signature, request received on port %i from %s", m_bTLS ? g_pOptions->GetSecurePort() : g_pOptions->GetControlPort(), m_pConnection->GetRemoteAddr());
+		return;
+	}
+
+	if ((int)ntohl(iSignature) == (int)NZBMESSAGE_SIGNATURE)
+	{
+		// binary request received
+		bOK = true;
+		BinRpcProcessor processor;
+		processor.SetConnection(m_pConnection);
+		processor.Execute();
+	}
+	else if (!strncmp((char*)&iSignature, "POST", 4) || 
+		!strncmp((char*)&iSignature, "GET ", 4) ||
+		!strncmp((char*)&iSignature, "OPTI", 4))
+	{
+		// HTTP request received
+		char szBuffer[1024];
+		if (m_pConnection->ReadLine(szBuffer, sizeof(szBuffer), NULL))
+		{
+			WebProcessor::EHttpMethod eHttpMethod = WebProcessor::hmGet;
+			char* szUrl = szBuffer;
+			if (!strncmp((char*)&iSignature, "POST", 4))
+			{
+				eHttpMethod = WebProcessor::hmPost;
+				szUrl++;
+			}
+			if (!strncmp((char*)&iSignature, "OPTI", 4) && strlen(szUrl) > 4)
+			{
+				eHttpMethod = WebProcessor::hmOptions;
+				szUrl += 4;
+			}
+			if (char* p = strchr(szUrl, ' '))
+			{
+				*p = '\0';
+			}
+
+			debug("url: %s", szUrl);
+
+			WebProcessor processor;
+			processor.SetConnection(m_pConnection);
+			processor.SetUrl(szUrl);
+			processor.SetHttpMethod(eHttpMethod);
+			processor.Execute();
+			bOK = true;
+		}
+	}
+
+	if (!bOK)
+	{
+		warn("Non-nzbget request received on port %i from %s", m_bTLS ? g_pOptions->GetSecurePort() : g_pOptions->GetControlPort(), m_pConnection->GetRemoteAddr());
+	}
+}

RemoteServer.h

@@ -0,0 +1,59 @@
+/*
+ *  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>
+ *
+ *  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 REMOTESERVER_H
+#define REMOTESERVER_H
+
+#include "Thread.h"
+#include "Connection.h"
+
+class RemoteServer : public Thread
+{
+private:
+	bool				m_bTLS;
+	Connection*			m_pConnection;
+
+public:
+						RemoteServer(bool bTLS);
+						~RemoteServer();
+	virtual void		Run();
+	virtual void 		Stop();
+};
+
+class RequestProcessor : public Thread
+{
+private:
+	bool				m_bTLS;
+	Connection*			m_pConnection;
+
+public:
+						~RequestProcessor();
+	virtual void		Run();
+	void				SetTLS(bool bTLS) { m_bTLS = bTLS; }
+	void				SetConnection(Connection* pConnection) { m_pConnection = pConnection; }
+};
+
+#endif

Scanner.cpp

@@ -0,0 +1,545 @@
+/*
+ *  This file is part of nzbget
+ *
+ *  Copyright (C) 2007-2013 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#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>
+#endif
+#include <sys/stat.h>
+
+#include "nzbget.h"
+#include "Scanner.h"
+#include "Options.h"
+#include "Log.h"
+#include "QueueCoordinator.h"
+#include "ScriptController.h"
+#include "DiskState.h"
+#include "Util.h"
+
+extern QueueCoordinator* g_pQueueCoordinator;
+extern Options* g_pOptions;
+extern DiskState* g_pDiskState;
+
+Scanner::FileData::FileData(const char* szFilename)
+{
+	m_szFilename = strdup(szFilename);
+	m_iSize = 0;
+	m_tLastChange = 0;
+}
+
+Scanner::FileData::~FileData()
+{
+	free(m_szFilename);
+}
+
+
+Scanner::QueueData::QueueData(const char* szFilename, const char* szNZBName, const char* szCategory, int iPriority,
+	NZBParameterList* pParameters, bool bAddTop, bool bAddPaused)
+{
+	m_szFilename = strdup(szFilename);
+	m_szNZBName = strdup(szNZBName);
+	m_szCategory = strdup(szCategory ? szCategory : "");
+	m_iPriority = iPriority;
+	m_bAddTop = bAddTop;
+	m_bAddPaused = bAddPaused;
+
+	if (pParameters)
+	{
+		for (NZBParameterList::iterator it = pParameters->begin(); it != pParameters->end(); it++)
+		{
+			NZBParameter* pNZBParameter = *it;
+			m_Parameters.SetParameter(pNZBParameter->GetName(), pNZBParameter->GetValue());
+		}
+	}
+}
+
+Scanner::QueueData::~QueueData()
+{
+	free(m_szFilename);
+	free(m_szNZBName);
+	free(m_szCategory);
+
+	for (NZBParameterList::iterator it = m_Parameters.begin(); it != m_Parameters.end(); it++)
+	{
+		delete *it;
+	}
+	m_Parameters.clear();
+}
+
+
+Scanner::Scanner()
+{
+	debug("Creating Scanner");
+
+	m_bRequestedNZBDirScan = false;
+	m_bScanning = false;
+	m_iNZBDirInterval = g_pOptions->GetNzbDirInterval() * 1000;
+	m_iPass = 0;
+
+	const char* szNZBScript = g_pOptions->GetNZBProcess();
+	m_bNZBScript = szNZBScript && strlen(szNZBScript) > 0;
+}
+
+Scanner::~Scanner()
+{
+	debug("Destroying Scanner");
+
+	for (FileList::iterator it = m_FileList.begin(); it != m_FileList.end(); it++)
+    {
+        delete *it;
+	}
+	m_FileList.clear();
+
+	ClearQueueList();
+}
+
+void Scanner::ClearQueueList()
+{
+	for (QueueList::iterator it = m_QueueList.begin(); it != m_QueueList.end(); it++)
+    {
+        delete *it;
+	}
+	m_QueueList.clear();
+}
+
+void Scanner::Check()
+{
+	m_mutexScan.Lock();
+
+	if (m_bRequestedNZBDirScan || 
+		(!g_pOptions->GetPauseScan() && g_pOptions->GetNzbDirInterval() > 0 && 
+		 m_iNZBDirInterval >= g_pOptions->GetNzbDirInterval() * 1000))
+	{
+		// check nzbdir every g_pOptions->GetNzbDirInterval() seconds or if requested
+		bool bCheckStat = !m_bRequestedNZBDirScan;
+		m_bRequestedNZBDirScan = false;
+		m_bScanning = true;
+		CheckIncomingNZBs(g_pOptions->GetNzbDir(), "", bCheckStat);
+		if (!bCheckStat && m_bNZBScript)
+		{
+			// if immediate scan requested, we need second scan to process files extracted by NzbProcess-script
+			CheckIncomingNZBs(g_pOptions->GetNzbDir(), "", bCheckStat);
+		}
+		m_bScanning = false;
+		m_iNZBDirInterval = 0;
+
+		// if NzbDirFileAge is less than NzbDirInterval (that can happen if NzbDirInterval
+		// is set for rare scans like once per hour) we make 4 scans:
+		//   - one additional scan is neccessary to check sizes of detected files;
+		//   - another scan is required to check files which were extracted by NzbProcess-script;
+		//   - third scan is needed to check sizes of extracted files.
+		if (g_pOptions->GetNzbDirInterval() > 0 && g_pOptions->GetNzbDirFileAge() < g_pOptions->GetNzbDirInterval())
+		{
+			int iMaxPass = m_bNZBScript ? 3 : 1;
+			if (m_iPass < iMaxPass)
+			{
+				// scheduling another scan of incoming directory in NzbDirFileAge seconds.
+				m_iNZBDirInterval = (g_pOptions->GetNzbDirInterval() - g_pOptions->GetNzbDirFileAge()) * 1000;
+				m_iPass++;
+			}
+			else
+			{
+				m_iPass = 0;
+			}
+		}
+
+		DropOldFiles();
+	}
+	m_iNZBDirInterval += 200;
+
+	ClearQueueList();
+	m_mutexScan.Unlock();
+}
+
+/**
+* Check if there are files in directory for incoming nzb-files
+* and add them to download queue
+*/
+void Scanner::CheckIncomingNZBs(const char* szDirectory, const char* szCategory, bool bCheckStat)
+{
+	DirBrowser dir(szDirectory);
+	while (const char* filename = dir.Next())
+	{
+		struct stat buffer;
+		char fullfilename[1023 + 1]; // one char reserved for the trailing slash (if needed)
+		snprintf(fullfilename, 1023, "%s%s", szDirectory, filename);
+		fullfilename[1023 - 1] = '\0';
+		if (!stat(fullfilename, &buffer))
+		{
+			// check subfolders
+			if ((buffer.st_mode & S_IFDIR) != 0 && strcmp(filename, ".") && strcmp(filename, ".."))
+			{
+				fullfilename[strlen(fullfilename) + 1] = '\0';
+				fullfilename[strlen(fullfilename)] = PATH_SEPARATOR;
+				const char* szUseCategory = filename;
+				char szSubCategory[1024];
+				if (strlen(szCategory) > 0)
+				{
+					snprintf(szSubCategory, 1023, "%s%c%s", szCategory, PATH_SEPARATOR, filename);
+					szSubCategory[1024 - 1] = '\0';
+					szUseCategory = szSubCategory;
+				}
+				CheckIncomingNZBs(fullfilename, szUseCategory, bCheckStat);
+			}
+			else if ((buffer.st_mode & S_IFDIR) == 0 && CanProcessFile(fullfilename, bCheckStat))
+			{
+				ProcessIncomingFile(szDirectory, filename, fullfilename, szCategory);
+			}
+		}
+	}
+}
+
+/**
+ * Only files which were not changed during last g_pOptions->GetNzbDirFileAge() seconds
+ * can be processed. That prevents the processing of files, which are currently being
+ * copied into nzb-directory (eg. being downloaded in web-browser).
+ */
+bool Scanner::CanProcessFile(const char* szFullFilename, bool bCheckStat)
+{
+	const char* szExtension = strrchr(szFullFilename, '.');
+	if (!szExtension ||
+		!strcasecmp(szExtension, ".queued") ||
+		!strcasecmp(szExtension, ".error") ||
+		!strcasecmp(szExtension, ".processed"))
+	{
+		return false;
+	}
+
+	if (!bCheckStat)
+	{
+		return true;
+	}
+
+	long long lSize = Util::FileSize(szFullFilename);
+	time_t tCurrent = time(NULL);
+	bool bCanProcess = false;
+	bool bInList = false;
+
+	for (FileList::iterator it = m_FileList.begin(); it != m_FileList.end(); it++)
+    {
+        FileData* pFileData = *it;
+		if (!strcmp(pFileData->GetFilename(), szFullFilename))
+		{
+			bInList = true;
+			if (pFileData->GetSize() == lSize &&
+				tCurrent - pFileData->GetLastChange() >= g_pOptions->GetNzbDirFileAge())
+			{
+				bCanProcess = true;
+				delete pFileData;
+				m_FileList.erase(it);
+			}
+			else
+			{
+				pFileData->SetSize(lSize);
+				if (pFileData->GetSize() != lSize)
+				{
+					pFileData->SetLastChange(tCurrent);
+				}
+			}
+			break;
+		}
+	}
+
+	if (!bInList)
+	{
+		FileData* pFileData = new FileData(szFullFilename);
+		pFileData->SetSize(lSize);
+		pFileData->SetLastChange(tCurrent);
+		m_FileList.push_back(pFileData);
+	}
+
+	return bCanProcess;
+}
+
+/**
+ * Remove old files from the list of monitored files.
+ * Normally these files are deleted from the list when they are processed.
+ * However if a file was detected by function "CanProcessFile" once but wasn't 
+ * processed later (for example if the user deleted it), it will stay in the list,
+ * until we remove it here.
+ */
+void Scanner::DropOldFiles()
+{
+	time_t tCurrent = time(NULL);
+
+	int i = 0;
+	for (FileList::iterator it = m_FileList.begin(); it != m_FileList.end(); )
+    {
+        FileData* pFileData = *it;
+		if ((tCurrent - pFileData->GetLastChange() >= 
+			(g_pOptions->GetNzbDirInterval() + g_pOptions->GetNzbDirFileAge()) * 2) ||
+			// can occur if the system clock was adjusted
+			tCurrent < pFileData->GetLastChange())
+		{
+			debug("Removing file %s from scan file list", pFileData->GetFilename());
+
+			delete pFileData;
+			m_FileList.erase(it);
+			it = m_FileList.begin() + i;
+		}
+		else
+		{
+			it++;
+			i++;
+		}
+	}
+}
+
+void Scanner::ProcessIncomingFile(const char* szDirectory, const char* szBaseFilename, const char* szFullFilename, const char* szCategory)
+{
+	const char* szExtension = strrchr(szBaseFilename, '.');
+	if (!szExtension)
+	{
+		return;
+	}
+
+	char* szNZBName = strdup("");
+	char* szNZBCategory = strdup(szCategory);
+	NZBParameterList* pParameters = new NZBParameterList();
+	int iPriority = 0;
+	bool bAddTop = false;
+	bool bAddPaused = false;
+
+	for (QueueList::iterator it = m_QueueList.begin(); it != m_QueueList.end(); it++)
+    {
+        QueueData* pQueueData = *it;
+		if (Util::SameFilename(pQueueData->GetFilename(), szFullFilename))
+		{
+			free(szNZBName);
+			szNZBName = strdup(pQueueData->GetNZBName());
+			free(szNZBCategory);
+			szNZBCategory = strdup(pQueueData->GetCategory());
+			iPriority = pQueueData->GetPriority();
+			bAddTop = pQueueData->GetAddTop();
+			bAddPaused = pQueueData->GetAddPaused();
+		}
+	}
+
+	bool bExists = true;
+
+	if (m_bNZBScript && strcasecmp(szExtension, ".nzb_processed"))
+	{
+		NZBScriptController::ExecuteScript(g_pOptions->GetNZBProcess(), szFullFilename, szDirectory, 
+			&szNZBName, &szNZBCategory, &iPriority, pParameters, &bAddTop, &bAddPaused); 
+		bExists = Util::FileExists(szFullFilename);
+		if (bExists && strcasecmp(szExtension, ".nzb"))
+		{
+			char bakname2[1024];
+			bool bRenameOK = Util::RenameBak(szFullFilename, "processed", false, bakname2, 1024);
+			if (!bRenameOK)
+			{
+				char szSysErrStr[256];
+				error("Could not rename file %s to %s: %s", szFullFilename, bakname2, Util::GetLastErrorMessage(szSysErrStr, sizeof(szSysErrStr)));
+			}
+		}
+	}
+
+	if (!strcasecmp(szExtension, ".nzb_processed"))
+	{
+		char szRenamedName[1024];
+		bool bRenameOK = Util::RenameBak(szFullFilename, "nzb", true, szRenamedName, 1024);
+		if (bRenameOK)
+		{
+			AddFileToQueue(szRenamedName, szNZBName, szNZBCategory, iPriority, pParameters, bAddTop, bAddPaused);
+		}
+		else
+		{
+			char szSysErrStr[256];
+			error("Could not rename file %s to %s: %s", szFullFilename, szRenamedName, Util::GetLastErrorMessage(szSysErrStr, sizeof(szSysErrStr)));
+		}
+	}
+	else if (bExists && !strcasecmp(szExtension, ".nzb"))
+	{
+		AddFileToQueue(szFullFilename, szNZBName, szNZBCategory, iPriority, pParameters, bAddTop, bAddPaused);
+	}
+
+	for (NZBParameterList::iterator it = pParameters->begin(); it != pParameters->end(); it++)
+	{
+		delete *it;
+	}
+	pParameters->clear();
+	delete pParameters;
+
+	free(szNZBName);
+	free(szNZBCategory);
+}
+
+void Scanner::AddFileToQueue(const char* szFilename, const char* szNZBName, const char* szCategory, int iPriority,
+	NZBParameterList* pParameters, bool bAddTop, bool bAddPaused)
+{
+	const char* szBasename = Util::BaseFileName(szFilename);
+
+	info("Collection %s found", szBasename);
+
+	NZBFile* pNZBFile = NZBFile::Create(szFilename, szCategory);
+	if (!pNZBFile)
+	{
+		error("Could not add collection %s to queue", szBasename);
+	}
+
+	char bakname2[1024];
+	bool bRenameOK = Util::RenameBak(szFilename, pNZBFile ? "queued" : "error", false, bakname2, 1024);
+	if (!bRenameOK)
+	{
+		char szSysErrStr[256];
+		error("Could not rename file %s to %s: %s", szFilename, bakname2, Util::GetLastErrorMessage(szSysErrStr, sizeof(szSysErrStr)));
+	}
+
+	if (pNZBFile && bRenameOK)
+	{
+		pNZBFile->GetNZBInfo()->SetQueuedFilename(bakname2);
+
+		if (szNZBName && strlen(szNZBName) > 0)
+		{
+			pNZBFile->GetNZBInfo()->SetName(NULL);
+			pNZBFile->GetNZBInfo()->SetFilename(szNZBName);
+			pNZBFile->GetNZBInfo()->BuildDestDirName();
+		}
+
+		for (NZBParameterList::iterator it = pParameters->begin(); it != pParameters->end(); it++)
+		{
+			NZBParameter* pParameter = *it;
+			pNZBFile->GetNZBInfo()->SetParameter(pParameter->GetName(), pParameter->GetValue());
+		}
+
+		for (NZBFile::FileInfos::iterator it = pNZBFile->GetFileInfos()->begin(); it != pNZBFile->GetFileInfos()->end(); it++)
+		{
+			FileInfo* pFileInfo = *it;
+			pFileInfo->SetPriority(iPriority);
+			pFileInfo->SetPaused(bAddPaused);
+		}
+
+		g_pQueueCoordinator->AddNZBFileToQueue(pNZBFile, bAddTop);
+		info("Collection %s added to queue", szBasename);
+	}
+
+	if (pNZBFile)
+	{
+		delete pNZBFile;
+	}
+}
+
+void Scanner::ScanNZBDir(bool bSyncMode)
+{
+	m_mutexScan.Lock();
+	m_bScanning = true;
+	m_bRequestedNZBDirScan = true;
+	m_mutexScan.Unlock();
+
+	while (bSyncMode && (m_bScanning || m_bRequestedNZBDirScan))
+	{
+		usleep(100 * 1000);
+	}
+}
+
+bool Scanner::AddExternalFile(const char* szNZBName, const char* szCategory, int iPriority,
+	NZBParameterList* pParameters, bool bAddTop, bool bAddPaused,
+	const char* szFileName, const char* szBuffer, int iBufSize, bool bSyncMode)
+{
+	char szTempFileName[1024];
+
+	if (szFileName)
+	{
+		strncpy(szTempFileName, szFileName, 1024);
+		szTempFileName[1024-1] = '\0';
+	}
+	else
+	{
+		int iNum = 1;
+		while (iNum == 1 || Util::FileExists(szTempFileName))
+		{
+			snprintf(szTempFileName, 1024, "%snzb-%i.tmp", g_pOptions->GetTempDir(), iNum);
+			szTempFileName[1024-1] = '\0';
+			iNum++;
+		}
+
+		if (!Util::SaveBufferIntoFile(szTempFileName, szBuffer, iBufSize))
+		{
+			error("Could not create file %s", szTempFileName);
+			return false;
+		}
+	}
+
+	// move file into NzbDir, make sure the file name is unique
+	char szValidNZBName[1024];
+	strncpy(szValidNZBName, Util::BaseFileName(szNZBName), 1024);
+	szValidNZBName[1024-1] = '\0';
+	Util::MakeValidFilename(szValidNZBName, '_', false);
+
+	char szScanFileName[1024];
+	snprintf(szScanFileName, 1024, "%s%s", g_pOptions->GetNzbDir(), szValidNZBName);
+
+	char *szExt = strrchr(szValidNZBName, '.');
+	if (szExt)
+	{
+		*szExt = '\0';
+		szExt++;
+	}
+
+	int iNum = 2;
+	while (Util::FileExists(szScanFileName))
+	{
+		if (szExt)
+		{
+			snprintf(szScanFileName, 1024, "%s%s_%i.%s", g_pOptions->GetNzbDir(), szValidNZBName, iNum, szExt);
+		}
+		else
+		{
+			snprintf(szScanFileName, 1024, "%s%s_%i", g_pOptions->GetNzbDir(), szValidNZBName, iNum);
+		}
+		szScanFileName[1024-1] = '\0';
+		iNum++;
+	}
+
+	if (!Util::MoveFile(szTempFileName, szScanFileName))
+	{
+		char szSysErrStr[256];
+		error("Could not move file %s to %s: %s", szTempFileName, szScanFileName, Util::GetLastErrorMessage(szSysErrStr, sizeof(szSysErrStr)));
+		remove(szTempFileName);
+		return false;
+	}
+
+	QueueData* pQueueData = new QueueData(szScanFileName, szNZBName, szCategory, iPriority, pParameters, bAddTop, bAddPaused);
+
+	m_mutexScan.Lock();
+	m_QueueList.push_back(pQueueData);
+	m_mutexScan.Unlock();
+
+	ScanNZBDir(bSyncMode);
+
+	return true;
+}

Scanner.h

@@ -0,0 +1,109 @@
+/*
+ *  This file is part of nzbget
+ *
+ *  Copyright (C) 2007-2013 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifndef SCANNER_H
+#define SCANNER_H
+
+#include <deque>
+#include <time.h>
+#include "DownloadInfo.h"
+#include "Thread.h"
+
+class Scanner
+{
+private:
+	class FileData
+	{
+	private:
+		char*			m_szFilename;
+		long long		m_iSize;
+		time_t			m_tLastChange;
+
+	public:
+						FileData(const char* szFilename);
+						~FileData();
+		const char*		GetFilename() { return m_szFilename; }
+		long long		GetSize() { return m_iSize; }
+		void			SetSize(long long lSize) { m_iSize = lSize; }
+		time_t			GetLastChange() { return m_tLastChange; }
+		void			SetLastChange(time_t tLastChange) { m_tLastChange = tLastChange; }
+	};
+
+	typedef std::deque<FileData*>		FileList;
+
+	class QueueData
+	{
+	private:
+		char*				m_szFilename;
+		char*				m_szNZBName;
+		char*				m_szCategory;
+		int					m_iPriority;
+		NZBParameterList	m_Parameters;
+		bool				m_bAddTop;
+		bool				m_bAddPaused;
+
+	public:
+							QueueData(const char* szFilename, const char* szNZBName, const char* szCategory, int iPriority,
+								NZBParameterList* pParameters, bool bAddTop, bool bAddPaused);
+							~QueueData();
+		const char*			GetFilename() { return m_szFilename; }
+		const char*			GetNZBName() { return m_szNZBName; }
+		const char*			GetCategory() { return m_szCategory; }
+		int					GetPriority() { return m_iPriority; }
+		NZBParameterList*	GetParameters() { return &m_Parameters; }
+		bool				GetAddTop() { return m_bAddTop; }
+		bool				GetAddPaused() { return m_bAddPaused; }
+	};
+
+	typedef std::deque<QueueData*>		QueueList;
+
+	bool				m_bRequestedNZBDirScan;
+	int					m_iNZBDirInterval;
+	bool				m_bNZBScript;
+	int					m_iPass;
+	FileList			m_FileList;
+	QueueList			m_QueueList;
+	bool				m_bScanning;
+	Mutex				m_mutexScan;
+
+	void				CheckIncomingNZBs(const char* szDirectory, const char* szCategory, bool bCheckStat);
+	void				AddFileToQueue(const char* szFilename, const char* szNZBName, const char* szCategory, int iPriority,
+							NZBParameterList* pParameters, bool bAddTop, bool bAddPaused);
+	void				ProcessIncomingFile(const char* szDirectory, const char* szBaseFilename, const char* szFullFilename, const char* szCategory);
+	bool				CanProcessFile(const char* szFullFilename, bool bCheckStat);
+	void				DropOldFiles();
+	void				ClearQueueList();
+
+public:
+						Scanner();
+						~Scanner();
+	void				ScanNZBDir(bool bSyncMode);
+	void				Check();
+	bool				AddExternalFile(const char* szNZBName, const char* szCategory, int iPriority,
+							NZBParameterList* pParameters, bool bAddPaused, bool bAddTop,
+							const char* szFileName, const char* szBuffer, int iBufSize, bool bSyncMode);
+};
+
+#endif

Scheduler.cpp

@@ -0,0 +1,247 @@
+/*
+ *  This file is part of nzbget
+ *
+ *  Copyright (C) 2008-2013 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef WIN32
+#include "win32.h"
+#else
+#include <unistd.h>
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "nzbget.h"
+#include "Scheduler.h"
+#include "ScriptController.h"
+#include "Options.h"
+#include "Log.h"
+
+extern Options* g_pOptions;
+
+Scheduler::Task::Task(int iHours, int iMinutes, int iWeekDaysBits, ECommand eCommand, 
+	int iDownloadRate, const char* szProcess)
+{
+	m_iHours = iHours;
+	m_iMinutes = iMinutes;
+	m_iWeekDaysBits = iWeekDaysBits;
+	m_eCommand = eCommand;
+	m_iDownloadRate = iDownloadRate;
+	m_szProcess = NULL;
+	if (szProcess)
+	{
+		m_szProcess = strdup(szProcess);
+	}
+	m_tLastExecuted = 0;
+}
+
+Scheduler::Task::~Task()
+{
+	if (m_szProcess)
+	{
+		free(m_szProcess);
+	}
+}
+
+
+Scheduler::Scheduler()
+{
+	debug("Creating Scheduler");
+
+	m_tLastCheck = 0;
+	m_TaskList.clear();
+}
+
+Scheduler::~Scheduler()
+{
+	debug("Destroying Scheduler");
+	
+	for (TaskList::iterator it = m_TaskList.begin(); it != m_TaskList.end(); it++)
+	{
+		delete *it;
+	}
+}
+
+void Scheduler::AddTask(Task* pTask)
+{
+	m_mutexTaskList.Lock();
+	m_TaskList.push_back(pTask);
+	m_mutexTaskList.Unlock();
+}
+
+bool Scheduler::CompareTasks(Scheduler::Task* pTask1, Scheduler::Task* pTask2)
+{
+	return (pTask1->m_iHours < pTask2->m_iHours) || 
+		((pTask1->m_iHours == pTask2->m_iHours) && (pTask1->m_iMinutes < pTask2->m_iMinutes));
+}
+
+void Scheduler::FirstCheck()
+{
+	m_mutexTaskList.Lock();
+	m_TaskList.sort(CompareTasks);
+	m_mutexTaskList.Unlock();
+
+	// check all tasks for the last week
+	time_t tCurrent = time(NULL);
+	m_tLastCheck = tCurrent - 60*60*24*7;
+	m_bDetectClockChanges = false;
+	m_bExecuteProcess = false;
+	m_bDownloadRateChanged = false;
+	m_bPauseDownloadChanged = false;
+	m_bPauseScanChanged = false;
+	CheckTasks();
+}
+
+void Scheduler::IntervalCheck()
+{
+	m_bDetectClockChanges = true;
+	m_bExecuteProcess = true;
+	m_bDownloadRateChanged = false;
+	m_bPauseDownloadChanged = false;
+	m_bPauseScanChanged = false;
+	CheckTasks();
+}
+
+void Scheduler::CheckTasks()
+{
+	m_mutexTaskList.Lock();
+
+	time_t tCurrent = time(NULL);
+	struct tm tmCurrent;
+	localtime_r(&tCurrent, &tmCurrent);
+
+	struct tm tmLastCheck;
+
+	if (m_bDetectClockChanges)
+	{
+		// Detect large step changes of system time 
+		time_t tDiff = tCurrent - m_tLastCheck;
+		if (tDiff > 60*90 || tDiff < -60*90)
+		{
+			debug("Reset scheduled tasks (detected clock adjustment greater than 90 minutes)");
+			m_bExecuteProcess = false;
+			m_tLastCheck = tCurrent;
+
+			for (TaskList::iterator it = m_TaskList.begin(); it != m_TaskList.end(); it++)
+			{
+				Task* pTask = *it;
+				pTask->m_tLastExecuted = 0;
+			}
+		}
+	}
+
+	localtime_r(&m_tLastCheck, &tmLastCheck);
+
+	struct tm tmLoop;
+	memcpy(&tmLoop, &tmLastCheck, sizeof(tmLastCheck));
+	tmLoop.tm_hour = tmCurrent.tm_hour;
+	tmLoop.tm_min = tmCurrent.tm_min;
+	tmLoop.tm_sec = tmCurrent.tm_sec;
+	time_t tLoop = mktime(&tmLoop);
+
+	while (tLoop <= tCurrent)
+	{
+		for (TaskList::iterator it = m_TaskList.begin(); it != m_TaskList.end(); it++)
+		{
+			Task* pTask = *it;
+			if (pTask->m_tLastExecuted != tLoop)
+			{
+				struct tm tmAppoint;
+				memcpy(&tmAppoint, &tmLoop, sizeof(tmLoop));
+				tmAppoint.tm_hour = pTask->m_iHours;
+				tmAppoint.tm_min = pTask->m_iMinutes;
+				tmAppoint.tm_sec = 0;
+
+				time_t tAppoint = mktime(&tmAppoint);
+				int iWeekDay = tmAppoint.tm_wday;
+				if (iWeekDay == 0)
+				{
+					iWeekDay = 7;
+				}
+
+				bool bWeekDayOK = pTask->m_iWeekDaysBits == 0 || (pTask->m_iWeekDaysBits & (1 << (iWeekDay - 1)));
+				bool bDoTask = bWeekDayOK && m_tLastCheck < tAppoint && tAppoint <= tCurrent;
+
+				//debug("TEMP: 1) m_tLastCheck=%i, tCurrent=%i, tLoop=%i, tAppoint=%i, bWeekDayOK=%i, bDoTask=%i", m_tLastCheck, tCurrent, tLoop, tAppoint, (int)bWeekDayOK, (int)bDoTask);
+
+				if (bDoTask)
+				{
+					ExecuteTask(pTask);
+					pTask->m_tLastExecuted = tLoop;
+				}
+			}
+		}
+		tLoop += 60*60*24; // inc day
+		localtime_r(&tLoop, &tmLoop);
+	}
+
+	m_tLastCheck = tCurrent;
+
+	m_mutexTaskList.Unlock();
+}
+
+void Scheduler::ExecuteTask(Task* pTask)
+{
+	if (pTask->m_eCommand == scDownloadRate)
+	{
+		debug("Executing scheduled command: Set download rate to %i", pTask->m_iDownloadRate);
+	}
+	else
+	{
+		const char* szCommandName[] = { "Pause", "Unpause", "Set download rate", "Execute program", "Pause Scan", "Unpause Scan" };
+		debug("Executing scheduled command: %s", szCommandName[pTask->m_eCommand]);
+	}
+
+	switch (pTask->m_eCommand)
+	{
+		case scDownloadRate:
+			m_iDownloadRate = pTask->m_iDownloadRate;
+			m_bDownloadRateChanged = true;
+			break;
+
+		case scPauseDownload:
+		case scUnpauseDownload:
+			m_bPauseDownload = pTask->m_eCommand == scPauseDownload;
+			m_bPauseDownloadChanged = true;
+			break;
+
+		case scProcess:
+			if (m_bExecuteProcess)
+			{
+				SchedulerScriptController::StartScript(pTask->m_szProcess);
+			}
+			break;
+
+		case scPauseScan:
+		case scUnpauseScan:
+			m_bPauseScan = pTask->m_eCommand == scPauseScan;
+			m_bPauseScanChanged = true;
+			break;
+	}
+}

Scheduler.h

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

ScriptController.h

@@ -0,0 +1,162 @@
+/*
+ *  This file is part of nzbget
+ *
+ *  Copyright (C) 2007-2013 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifndef SCRIPTCONTROLLER_H
+#define SCRIPTCONTROLLER_H
+
+#include <list>
+
+#include "Log.h"
+#include "Thread.h"
+#include "DownloadInfo.h"
+#include "Options.h"
+
+class EnvironmentStrings
+{
+private:
+	typedef std::vector<char*>		Strings;
+	
+	Strings				m_strings;
+
+public:
+						EnvironmentStrings();
+						~EnvironmentStrings();
+	void				Clear();
+	void				InitFromCurrentProcess();
+	void				Append(char* szString);
+#ifdef WIN32
+	char*				GetStrings();
+#else	
+	char**				GetStrings();
+#endif
+};
+
+class ScriptController
+{
+private:
+	const char*			m_szScript;
+	const char*			m_szWorkingDir;
+	const char**		m_szArgs;
+	bool				m_bFreeArgs;
+	const char*			m_szStdArgs[2];
+	const char*			m_szInfoName;
+	const char*			m_szLogPrefix;
+	EnvironmentStrings	m_environmentStrings;
+	bool				m_bTerminated;
+#ifdef WIN32
+	HANDLE				m_hProcess;
+	char				m_szCmdLine[2048];
+#else
+	pid_t				m_hProcess;
+#endif
+
+protected:
+	void				ProcessOutput(char* szText);
+	virtual bool		ReadLine(char* szBuf, int iBufSize, FILE* pStream);
+	void				PrintMessage(Message::EKind eKind, const char* szFormat, ...);
+	virtual void		AddMessage(Message::EKind eKind, const char* szText);
+	bool				GetTerminated() { return m_bTerminated; }
+	void				ResetEnv();
+	void				PrepareEnvOptions(const char* szStripPrefix);
+	void				PrepareEnvParameters(NZBInfo* pNZBInfo, const char* szStripPrefix);
+	void				PrepareArgs();
+
+public:
+						ScriptController();
+	virtual				~ScriptController();
+	int					Execute();
+	void				Terminate();
+
+	void				SetScript(const char* szScript) { m_szScript = szScript; }
+	const char*			GetScript() { return m_szScript; }
+	void				SetWorkingDir(const char* szWorkingDir) { m_szWorkingDir = szWorkingDir; }
+	void				SetArgs(const char** szArgs, bool bFreeArgs) { m_szArgs = szArgs; m_bFreeArgs = bFreeArgs; }
+	void				SetInfoName(const char* szInfoName) { m_szInfoName = szInfoName; }
+	const char*			GetInfoName() { return m_szInfoName; }
+	void				SetLogPrefix(const char* szLogPrefix) { m_szLogPrefix = szLogPrefix; }
+	void				SetEnvVar(const char* szName, const char* szValue);
+	void				SetEnvVarSpecial(const char* szPrefix, const char* szName, const char* szValue);
+};
+
+class PostScriptController : public Thread, public ScriptController
+{
+private:
+	PostInfo*			m_pPostInfo;
+	char				m_szNZBName[1024];
+ 
+	void				ExecuteScript(const char* szScriptName, const char* szDisplayName, const char* szLocation);
+	void				PrepareParams(const char* szScriptName);
+	ScriptStatus::EStatus	AnalyseExitCode(int iExitCode);
+
+	typedef std::deque<char*>		FileList;
+
+protected:
+	virtual void		AddMessage(Message::EKind eKind, const char* szText);
+
+public:
+	virtual void		Run();
+	virtual void		Stop();
+	static void			StartJob(PostInfo* pPostInfo);
+	static void			InitParamsForNewNZB(NZBInfo* pNZBInfo);
+};
+
+class NZBScriptController : public ScriptController
+{
+private:
+	char**				m_pNZBName;
+	char**				m_pCategory;
+	int*				m_iPriority;
+	NZBParameterList*	m_pParameters;
+	bool*				m_bAddTop;
+	bool*				m_bAddPaused;
+	int					m_iPrefixLen;
+
+protected:
+	virtual void		AddMessage(Message::EKind eKind, const char* szText);
+
+public:
+	static void			ExecuteScript(const char* szScript, const char* szNZBFilename, const char* szDirectory,
+							char** pNZBName, char** pCategory, int* iPriority, NZBParameterList* pParameters,
+							bool* bAddTop, bool* bAddPaused);
+};
+
+class NZBAddedScriptController : public Thread, public ScriptController
+{
+private:
+	char*				m_szNZBName;
+
+public:
+	virtual void		Run();
+	static void			StartScript(DownloadQueue* pDownloadQueue, NZBInfo *pNZBInfo, const char* szScript);
+};
+
+class SchedulerScriptController : public Thread, public ScriptController
+{
+public:
+	virtual void		Run();
+	static void			StartScript(const char* szCommandLine);
+};
+
+#endif

ServerPool.cpp

@@ -0,0 +1,265 @@
+/*
+ *  This file is part of nzbget
+ *
+ *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007-2009 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef WIN32
+#include "win32.h"
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#ifndef WIN32
+#include <unistd.h>
+#include <errno.h>
+#endif
+#include <algorithm>
+
+#include "nzbget.h"
+#include "ServerPool.h"
+#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;
+}
+
+ServerPool::~ ServerPool()
+{
+	debug("Destroying ServerPool");
+
+	m_Levels.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");
+
+	if (pNewsServer->GetMaxConnections() > 0)
+	{
+		m_Servers.push_back(pNewsServer);
+	}
+	else
+	{
+		delete pNewsServer;
+	}
+}
+
+void ServerPool::NormalizeLevels()
+{
+	if (m_Servers.empty())
+	{
+		return;
+	}
+
+	std::sort(m_Servers.begin(), m_Servers.end(), CompareServers);
+
+	NewsServer* pNewsServer = m_Servers.front();
+
+	m_iMaxLevel = 0;
+	int iCurLevel = pNewsServer->GetLevel();
+	for (Servers::iterator it = m_Servers.begin(); it != m_Servers.end(); it++)
+	{
+		NewsServer* pNewsServer = *it;
+		if (pNewsServer->GetLevel() != iCurLevel)
+		{
+			m_iMaxLevel++;
+		}
+
+		pNewsServer->SetLevel(m_iMaxLevel);
+	}
+}
+
+bool ServerPool::CompareServers(NewsServer* pServer1, NewsServer* pServer2)
+{
+	return pServer1->GetLevel() < pServer2->GetLevel();
+}
+
+void ServerPool::InitConnections()
+{
+	debug("Initializing connections in ServerPool");
+
+	NormalizeLevels();
+
+	for (Servers::iterator it = m_Servers.begin(); it != m_Servers.end(); it++)
+	{
+		NewsServer* pNewsServer = *it;
+		for (int i = 0; i < pNewsServer->GetMaxConnections(); i++)
+		{
+			PooledConnection* pConnection = new PooledConnection(pNewsServer);
+			pConnection->SetTimeout(m_iTimeout);
+			m_Connections.push_back(pConnection);
+		}
+		if ((int)m_Levels.size() <= pNewsServer->GetLevel())
+		{
+			m_Levels.push_back(0);
+		}
+		m_Levels[pNewsServer->GetLevel()] += pNewsServer->GetMaxConnections();
+	}
+
+	if (m_Levels.empty())
+	{
+		warn("No news servers defined, download is not possible");
+	}
+}
+
+NNTPConnection* ServerPool::GetConnection(int iLevel, NewsServer* pWantServer, Servers* pIgnoreServers)
+{
+	PooledConnection* pConnection = NULL;
+
+	m_mutexConnections.Lock();
+
+	if (iLevel < (int)m_Levels.size() && m_Levels[iLevel] > 0)
+	{
+		for (Connections::iterator it = m_Connections.begin(); it != m_Connections.end(); it++)
+		{
+			PooledConnection* pCandidateConnection = *it;
+			NewsServer* pCandidateServer = pCandidateConnection->GetNewsServer();
+			if (!pCandidateConnection->GetInUse() && pCandidateServer->GetLevel() == iLevel && 
+				(!pWantServer || pCandidateServer == pWantServer ||
+				 (pWantServer->GetGroup() > 0 && pWantServer->GetGroup() == pCandidateServer->GetGroup())))
+			{
+				// free connection found, check if it's not from the server which should be ignored
+				bool bUseConnection = true;
+				if (pIgnoreServers && !pWantServer)
+				{
+					for (Servers::iterator it = pIgnoreServers->begin(); it != pIgnoreServers->end(); it++)
+					{
+						NewsServer* pIgnoreServer = *it;
+						if (pIgnoreServer == pCandidateServer ||
+							(pIgnoreServer->GetGroup() > 0 && pIgnoreServer->GetGroup() == pCandidateServer->GetGroup() &&
+							 pIgnoreServer->GetLevel() == pCandidateServer->GetLevel()))
+						{
+							bUseConnection = false;
+							break;
+						}
+					}
+				}
+
+				if (bUseConnection)
+				{
+					pConnection = pCandidateConnection;
+					pConnection->SetInUse(true);
+					break;
+				}
+			}
+		}
+
+		if (pConnection)
+		{
+			m_Levels[iLevel]--;
+		}
+	}
+
+	m_mutexConnections.Unlock();
+
+	return pConnection;
+}
+
+void ServerPool::FreeConnection(NNTPConnection* pConnection, bool bUsed)
+{
+	if (bUsed)
+	{
+		debug("Freeing used connection");
+	}
+
+	m_mutexConnections.Lock();
+
+	((PooledConnection*)pConnection)->SetInUse(false);
+	if (bUsed)
+	{
+		((PooledConnection*)pConnection)->SetFreeTimeNow();
+	}
+	m_Levels[pConnection->GetNewsServer()->GetLevel()]++;
+
+	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->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("      %s: Level=%i, InUse:%i", (*it)->GetNewsServer()->GetHost(), (*it)->GetNewsServer()->GetLevel(), (int)(*it)->GetInUse());
+	}
+
+	m_mutexConnections.Unlock();
+}

ServerPool.h

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

TLS.cpp

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

TLS.h

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

Thread.cpp

@@ -0,0 +1,279 @@
+/*
+ *  This file is part of nzbget
+ *
+ *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007-2010 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 <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::Mutex()
+{
+#ifdef WIN32
+	m_pMutexObj = (CRITICAL_SECTION*)malloc(sizeof(CRITICAL_SECTION));
+	InitializeCriticalSection((CRITICAL_SECTION*)m_pMutexObj);
+#else
+	m_pMutexObj = (pthread_mutex_t*)malloc(sizeof(pthread_mutex_t));
+	pthread_mutex_init((pthread_mutex_t*)m_pMutexObj, NULL);
+#endif
+}
+
+Mutex::~ Mutex()
+{
+#ifdef WIN32
+	DeleteCriticalSection((CRITICAL_SECTION*)m_pMutexObj);
+#else
+	pthread_mutex_destroy((pthread_mutex_t*)m_pMutexObj);
+#endif
+	free(m_pMutexObj);
+}
+
+void Mutex::Lock()
+{
+#ifdef WIN32
+	EnterCriticalSection((CRITICAL_SECTION*)m_pMutexObj);
+#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)
+	{
+		error("Internal program error: inconsistent thread-lock detected");
+	}
+#endif
+#else
+	pthread_mutex_lock((pthread_mutex_t*)m_pMutexObj);
+#endif
+}
+
+void Mutex::Unlock()
+{
+#ifdef WIN32
+	LeaveCriticalSection((CRITICAL_SECTION*)m_pMutexObj);
+#else
+	pthread_mutex_unlock((pthread_mutex_t*)m_pMutexObj);
+#endif
+}
+
+
+#ifdef HAVE_SPINLOCK
+SpinLock::SpinLock()
+{
+#ifdef WIN32
+	m_pSpinLockObj = (CRITICAL_SECTION *)malloc(sizeof(CRITICAL_SECTION));
+	InitializeCriticalSectionAndSpinCount((CRITICAL_SECTION *)m_pSpinLockObj, 0x00FFFFFF);
+#else
+	m_pSpinLockObj = (pthread_spinlock_t *)malloc(sizeof(pthread_spinlock_t));
+	pthread_spin_init((pthread_spinlock_t *)m_pSpinLockObj, PTHREAD_PROCESS_PRIVATE);
+#endif
+}
+
+SpinLock::~SpinLock()
+{
+#ifdef WIN32
+	DeleteCriticalSection((CRITICAL_SECTION *)m_pSpinLockObj);
+#else
+	pthread_spin_destroy((pthread_spinlock_t *)m_pSpinLockObj);
+#endif
+	free((void*)m_pSpinLockObj);
+}
+
+void SpinLock::Lock()
+{
+#ifdef WIN32
+	EnterCriticalSection((CRITICAL_SECTION *)m_pSpinLockObj);
+#else
+	pthread_spin_lock((pthread_spinlock_t *)m_pSpinLockObj);
+#endif
+}
+
+void SpinLock::Unlock()
+{
+#ifdef WIN32
+	LeaveCriticalSection((CRITICAL_SECTION *)m_pSpinLockObj);
+#else
+	pthread_spin_unlock((pthread_spinlock_t *)m_pSpinLockObj);
+#endif
+}
+#endif
+
+
+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_bRunning = false;
+	m_bStopped = false;
+	m_bAutoDestroy = false;
+}
+
+Thread::~Thread()
+{
+	debug("Destroying Thread");
+#ifndef WIN32
+	free(m_pThreadObj);
+#endif
+}
+
+void Thread::Start()
+{
+	debug("Starting Thread");
+
+	m_bRunning = true;
+	
+	// NOTE: we must guarantee, that in a time we set 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
+	// then also try to lock the mutex (see thread_handler) and therefore
+	// must wait until we unlock it
+	m_pMutexThread->Lock();
+
+#ifdef WIN32
+	m_pThreadObj = (HANDLE)_beginthread(Thread::thread_handler, 0, (void *)this);
+	m_bRunning = m_pThreadObj != 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);
+	pthread_attr_destroy(&m_Attr);
+#endif
+
+	m_pMutexThread->Unlock();
+}
+
+void Thread::Stop()
+{
+	debug("Stopping Thread");
+
+	m_bStopped = true;
+} 
+
+bool Thread::Kill()
+{
+	debug("Killing Thread");
+
+	m_pMutexThread->Lock();
+
+#ifdef WIN32
+	bool terminated = TerminateThread((HANDLE)m_pThreadObj, 0) != 0;
+#else
+	bool terminated = pthread_cancel(*(pthread_t*)m_pThreadObj) == 0;
+#endif
+
+	if (terminated)
+	{
+		m_iThreadCount--;
+	}
+	m_pMutexThread->Unlock();
+	return terminated;
+}
+
+#ifdef WIN32
+void __cdecl Thread::thread_handler(void* pObject)
+#else
+void* Thread::thread_handler(void* pObject)
+#endif
+{
+	m_pMutexThread->Lock();
+	m_iThreadCount++;
+	m_pMutexThread->Unlock();
+
+	debug("Entering Thread-func");
+
+	Thread* pThread = (Thread*)pObject;
+
+	pThread->Run();
+
+	debug("Thread-func exited");
+	
+	pThread->m_bRunning = false;
+	
+	if (pThread->m_bAutoDestroy)
+	{
+		debug("Autodestroying Thread-object");
+		delete pThread;
+	}
+
+	m_pMutexThread->Lock();
+	m_iThreadCount--;
+	m_pMutexThread->Unlock();
+
+#ifndef WIN32
+	return NULL;
+#endif
+}
+
+int Thread::GetThreadCount()
+{
+	m_pMutexThread->Lock();
+	int iThreadCount = m_iThreadCount;
+	m_pMutexThread->Unlock();
+	return iThreadCount;
+}

Thread.h

@@ -0,0 +1,97 @@
+/*
+ *  This file is part of nzbget
+ *
+ *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
+ *  Copyright (C) 2007-2010 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 THREAD_H
+#define THREAD_H
+
+class Mutex
+{
+private:
+	void*					m_pMutexObj;
+	
+public:
+							Mutex();
+							~Mutex();
+	void					Lock();
+	void					Unlock();
+};
+
+#ifdef HAVE_SPINLOCK
+class SpinLock
+{
+private:
+#ifdef WIN32
+	void*					m_pSpinLockObj;
+#else
+	volatile void*			m_pSpinLockObj;
+#endif
+	
+public:
+							SpinLock();
+							~SpinLock();
+	void					Lock();
+	void					Unlock();
+};
+#endif
+
+class Thread
+{
+private:
+	static Mutex*			m_pMutexThread;
+	static int				m_iThreadCount;
+	void*	 				m_pThreadObj;
+	bool 					m_bRunning;
+	bool					m_bStopped;
+	bool					m_bAutoDestroy;
+
+#ifdef WIN32
+	static void __cdecl 	thread_handler(void* pObject);
+#else
+	static void				*thread_handler(void* pObject);
+#endif
+
+public:
+							Thread();
+	virtual 				~Thread();
+	static void				Init();
+	static void				Final();
+
+	virtual void 			Start();
+	virtual void 			Stop();
+	bool					Kill();
+
+	bool 					IsStopped() { return m_bStopped; };
+	bool 					IsRunning()	const { return m_bRunning; }
+	void 					SetRunning(bool bOnOff) { m_bRunning = bOnOff; }
+	bool					GetAutoDestroy() { return m_bAutoDestroy; }
+	void					SetAutoDestroy(bool bAutoDestroy) { m_bAutoDestroy = bAutoDestroy; }
+	static int				GetThreadCount();
+
+protected:
+	virtual void 			Run() {}; // Virtual function - override in derivatives
+};
+
+#endif

Unpack.cpp

@@ -0,0 +1,888 @@
+/*
+ *  This file is part of nzbget
+ *
+ *  Copyright (C) 2013 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef WIN32
+#include "win32.h"
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <ctype.h>
+#ifndef WIN32
+#include <unistd.h>
+#endif
+#include <errno.h>
+
+#include "nzbget.h"
+#include "Unpack.h"
+#include "Log.h"
+#include "Util.h"
+#include "ParCoordinator.h"
+
+extern Options* g_pOptions;
+extern DownloadQueueHolder* g_pDownloadQueueHolder;
+
+void UnpackController::FileList::Clear()
+{
+	for (iterator it = begin(); it != end(); it++)
+	{
+		free(*it);
+	}
+	clear();
+}
+
+bool UnpackController::FileList::Exists(const char* szFilename)
+{
+	for (iterator it = begin(); it != end(); it++)
+	{
+		char* szFilename1 = *it;
+		if (!strcmp(szFilename1, szFilename))
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
+UnpackController::~UnpackController()
+{
+	m_archiveFiles.Clear();
+}
+
+void UnpackController::StartJob(PostInfo* pPostInfo)
+{
+	UnpackController* pUnpackController = new UnpackController();
+	pUnpackController->m_pPostInfo = pPostInfo;
+	pUnpackController->SetAutoDestroy(false);
+
+	pPostInfo->SetPostThread(pUnpackController);
+
+	pUnpackController->Start();
+}
+
+void UnpackController::Run()
+{
+	// the locking is needed for accessing the members of NZBInfo
+	g_pDownloadQueueHolder->LockQueue();
+
+	strncpy(m_szDestDir, m_pPostInfo->GetNZBInfo()->GetDestDir(), 1024);
+	m_szDestDir[1024-1] = '\0';
+
+	strncpy(m_szName, m_pPostInfo->GetNZBInfo()->GetName(), 1024);
+	m_szName[1024-1] = '\0';
+
+	m_bCleanedUpDisk = false;
+	bool bUnpack = true;
+	m_szPassword[0] = '\0';
+	m_szFinalDir[0] = '\0';
+	
+	for (NZBParameterList::iterator it = m_pPostInfo->GetNZBInfo()->GetParameters()->begin(); it != m_pPostInfo->GetNZBInfo()->GetParameters()->end(); it++)
+	{
+		NZBParameter* pParameter = *it;
+		if (!strcasecmp(pParameter->GetName(), "*Unpack:") && !strcasecmp(pParameter->GetValue(), "no"))
+		{
+			bUnpack = false;
+		}
+		if (!strcasecmp(pParameter->GetName(), "*Unpack:Password"))
+		{
+			strncpy(m_szPassword, pParameter->GetValue(), 1024-1);
+			m_szPassword[1024-1] = '\0';
+		}
+	}
+	
+	g_pDownloadQueueHolder->UnlockQueue();
+
+	snprintf(m_szInfoName, 1024, "unpack for %s", m_szName);
+	m_szInfoName[1024-1] = '\0';
+
+	snprintf(m_szInfoNameUp, 1024, "Unpack for %s", m_szName); // first letter in upper case
+	m_szInfoNameUp[1024-1] = '\0';
+
+	CheckStateFiles();
+
+#ifndef DISABLE_PARCHECK
+	if (bUnpack && m_bHasBrokenFiles && m_pPostInfo->GetNZBInfo()->GetParStatus() <= NZBInfo::psSkipped && m_bHasParFiles)
+	{
+		PrintMessage(Message::mkInfo, "%s has broken files", m_szName);
+		RequestParCheck(false);
+		m_pPostInfo->SetWorking(false);
+		return;
+	}
+#endif
+
+	if (bUnpack)
+	{
+		bool bScanNonStdFiles = m_pPostInfo->GetNZBInfo()->GetRenameStatus() > NZBInfo::rsSkipped ||
+			m_pPostInfo->GetNZBInfo()->GetParStatus() == NZBInfo::psSuccess ||
+			!m_bHasParFiles;
+		CheckArchiveFiles(bScanNonStdFiles);
+	}
+
+	if (bUnpack && (m_bHasRarFiles || m_bHasNonStdRarFiles || m_bHasSevenZipFiles || m_bHasSevenZipMultiFiles))
+	{
+		SetInfoName(m_szInfoName);
+		SetWorkingDir(m_szDestDir);
+
+		PrintMessage(Message::mkInfo, "Unpacking %s", m_szName);
+
+		CreateUnpackDir();
+
+		m_bUnpackOK = true;
+		m_bUnpackStartError = false;
+
+		if (m_bHasRarFiles || m_bHasNonStdRarFiles)
+		{
+			ExecuteUnrar();
+		}
+
+		if (m_bHasSevenZipFiles && m_bUnpackOK)
+		{
+			ExecuteSevenZip(false);
+		}
+
+		if (m_bHasSevenZipMultiFiles && m_bUnpackOK)
+		{
+			ExecuteSevenZip(true);
+		}
+
+		Completed();
+	}
+	else
+	{
+		PrintMessage(Message::mkInfo, (bUnpack ? "Nothing to unpack for %s" : "Unpack for %s skipped"), m_szName);
+
+#ifndef DISABLE_PARCHECK
+		if (bUnpack && m_pPostInfo->GetNZBInfo()->GetParStatus() <= NZBInfo::psSkipped && m_bHasParFiles)
+		{
+			RequestParCheck(m_pPostInfo->GetNZBInfo()->GetRenameStatus() <= NZBInfo::rsSkipped);
+		}
+		else
+#endif
+		{
+			m_pPostInfo->GetNZBInfo()->SetUnpackStatus(NZBInfo::usSkipped);
+			m_pPostInfo->SetStage(PostInfo::ptQueued);
+		}
+	}
+
+	m_pPostInfo->SetWorking(false);
+}
+
+void UnpackController::ExecuteUnrar()
+{
+	// Format: 
+	//   unrar x -y -p- -o+ *.rar ./_unpack
+
+	char szPasswordParam[1024];
+	const char* szArgs[8];
+	szArgs[0] = g_pOptions->GetUnrarCmd();
+	szArgs[1] = "x";
+	szArgs[2] = "-y";
+	szArgs[3] = "-p-";
+	if (strlen(m_szPassword) > 0)
+	{
+		snprintf(szPasswordParam, 1024, "-p%s", m_szPassword);
+		szArgs[3] = szPasswordParam;
+	}
+	szArgs[4] = "-o+";
+	szArgs[5] = m_bHasNonStdRarFiles ? "*.*" : "*.rar";
+	szArgs[6] = m_szUnpackDir;
+	szArgs[7] = NULL;
+	SetArgs(szArgs, false);
+
+	SetScript(g_pOptions->GetUnrarCmd());
+	SetLogPrefix("Unrar");
+
+	m_bAllOKMessageReceived = false;
+	m_eUnpacker = upUnrar;
+	
+	SetProgressLabel("");
+	int iExitCode = Execute();
+	SetLogPrefix(NULL);
+	SetProgressLabel("");
+
+	m_bUnpackOK = iExitCode == 0 && m_bAllOKMessageReceived && !GetTerminated();
+	m_bUnpackStartError = iExitCode == -1;
+
+	if (!m_bUnpackOK && iExitCode > 0)
+	{
+		PrintMessage(Message::mkError, "Unrar error code: %i", iExitCode);
+	}
+}
+
+void UnpackController::ExecuteSevenZip(bool bMultiVolumes)
+{
+	// Format: 
+	//   7z x -y -p- -o./_unpack *.7z
+	// OR
+	//   7z x -y -p- -o./_unpack *.7z.001
+
+	char szPasswordParam[1024];
+	const char* szArgs[7];
+	szArgs[0] = g_pOptions->GetSevenZipCmd();
+	szArgs[1] = "x";
+	szArgs[2] = "-y";
+
+	szArgs[3] = "-p-";
+	if (strlen(m_szPassword) > 0)
+	{
+		snprintf(szPasswordParam, 1024, "-p%s", m_szPassword);
+		szArgs[3] = szPasswordParam;
+	}
+
+	char szUnpackDirParam[1024];
+	snprintf(szUnpackDirParam, 1024, "-o%s", m_szUnpackDir);
+	szArgs[4] = szUnpackDirParam;
+
+	szArgs[5] = bMultiVolumes ? "*.7z.001" : "*.7z";
+	szArgs[6] = NULL;
+	SetArgs(szArgs, false);
+
+	SetScript(g_pOptions->GetSevenZipCmd());
+
+	m_bAllOKMessageReceived = false;
+	m_eUnpacker = upSevenZip;
+
+	PrintMessage(Message::mkInfo, "Executing 7-Zip");
+	SetLogPrefix("7-Zip");
+	SetProgressLabel("");
+	int iExitCode = Execute();
+	SetLogPrefix(NULL);
+	SetProgressLabel("");
+
+	m_bUnpackOK = iExitCode == 0 && m_bAllOKMessageReceived && !GetTerminated();
+	m_bUnpackStartError = iExitCode == -1;
+
+	if (!m_bUnpackOK && iExitCode > 0)
+	{
+		PrintMessage(Message::mkError, "7-Zip error code: %i", iExitCode);
+	}
+}
+
+void UnpackController::Completed()
+{
+	bool bCleanupSuccess = Cleanup();
+
+	if (m_bUnpackOK && bCleanupSuccess)
+	{
+		PrintMessage(Message::mkInfo, "%s %s", m_szInfoNameUp, "successful");
+		m_pPostInfo->GetNZBInfo()->SetUnpackStatus(NZBInfo::usSuccess);
+		m_pPostInfo->GetNZBInfo()->SetUnpackCleanedUpDisk(m_bCleanedUpDisk);
+		m_pPostInfo->SetStage(PostInfo::ptQueued);
+	}
+	else
+	{
+#ifndef DISABLE_PARCHECK
+		if (!m_bUnpackOK && m_pPostInfo->GetNZBInfo()->GetParStatus() <= NZBInfo::psSkipped && !m_bUnpackStartError && !GetTerminated() && m_bHasParFiles)
+		{
+			RequestParCheck(false);
+		}
+		else
+#endif
+		{
+			PrintMessage(Message::mkError, "%s failed", m_szInfoNameUp);
+			m_pPostInfo->GetNZBInfo()->SetUnpackStatus(NZBInfo::usFailure);
+			m_pPostInfo->SetStage(PostInfo::ptQueued);
+		}
+	}
+}
+
+#ifndef DISABLE_PARCHECK
+void UnpackController::RequestParCheck(bool bRename)
+{
+	PrintMessage(Message::mkInfo, "%s requested %s", m_szInfoNameUp, bRename ? "par-rename": "par-check/repair");
+	if (bRename)
+	{
+		m_pPostInfo->SetRequestParRename(true);
+	}
+	else
+	{
+		m_pPostInfo->SetRequestParCheck(true);
+	}
+	m_pPostInfo->SetStage(PostInfo::ptFinished);
+}
+#endif
+
+void UnpackController::CheckStateFiles()
+{
+	char szBrokenLog[1024];
+	snprintf(szBrokenLog, 1024, "%s%c%s", m_szDestDir, PATH_SEPARATOR, "_brokenlog.txt");
+	szBrokenLog[1024-1] = '\0';
+	m_bHasBrokenFiles = Util::FileExists(szBrokenLog);
+
+	m_bHasParFiles = ParCoordinator::FindMainPars(m_szDestDir, NULL);
+}
+
+void UnpackController::CreateUnpackDir()
+{
+	m_bInterDir = strlen(g_pOptions->GetInterDir()) > 0 &&
+		!strncmp(m_szDestDir, g_pOptions->GetInterDir(), strlen(g_pOptions->GetInterDir()));
+	if (m_bInterDir)
+	{
+		m_pPostInfo->GetNZBInfo()->BuildFinalDirName(m_szFinalDir, 1024);
+		m_szFinalDir[1024-1] = '\0';
+		snprintf(m_szUnpackDir, 1024, "%s%c%s", m_szFinalDir, PATH_SEPARATOR, "_unpack");
+	}
+	else
+	{
+		snprintf(m_szUnpackDir, 1024, "%s%c%s", m_szDestDir, PATH_SEPARATOR, "_unpack");
+	}
+	m_szUnpackDir[1024-1] = '\0';
+
+	char szErrBuf[1024];
+	if (!Util::ForceDirectories(m_szUnpackDir, szErrBuf, sizeof(szErrBuf)))
+	{
+		error("Could not create directory %s: %s", m_szUnpackDir, szErrBuf);
+	}
+}
+
+
+void UnpackController::CheckArchiveFiles(bool bScanNonStdFiles)
+{
+	m_bHasRarFiles = false;
+	m_bHasNonStdRarFiles = false;
+	m_bHasSevenZipFiles = false;
+	m_bHasSevenZipMultiFiles = false;
+
+	RegEx regExRar(".*\\.rar$");
+	RegEx regExRarMultiSeq(".*\\.(r|s)[0-9][0-9]$");
+	RegEx regExSevenZip(".*\\.7z$");
+	RegEx regExSevenZipMulti(".*\\.7z\\.[0-9]*$");
+
+	DirBrowser dir(m_szDestDir);
+	while (const char* filename = dir.Next())
+	{
+		char szFullFilename[1024];
+		snprintf(szFullFilename, 1024, "%s%c%s", m_szDestDir, PATH_SEPARATOR, filename);
+		szFullFilename[1024-1] = '\0';
+
+		if (strcmp(filename, ".") && strcmp(filename, "..") && !Util::DirectoryExists(szFullFilename))
+		{
+			if (regExRar.Match(filename))
+			{
+				m_bHasRarFiles = true;
+			}
+			else if (regExSevenZip.Match(filename))
+			{
+				m_bHasSevenZipFiles = true;
+			}
+			else if (regExSevenZipMulti.Match(filename))
+			{
+				m_bHasSevenZipMultiFiles = true;
+			}
+			else if (bScanNonStdFiles && !m_bHasNonStdRarFiles && !regExRarMultiSeq.Match(filename))
+			{
+				// Check if file has RAR signature
+				char rarSignature[] = {0x52, 0x61, 0x72, 0x21, 0x1A, 0x07, 0x00};
+				char fileSignature[7];
+
+				FILE* infile;
+				infile = fopen(szFullFilename, "rb");
+				if (infile)
+				{
+					int cnt = (int)fread(fileSignature, 1, sizeof(fileSignature), infile);
+					fclose(infile);
+					if (cnt == sizeof(fileSignature) && !strcmp(rarSignature, fileSignature))
+					{
+						m_bHasNonStdRarFiles = true;
+					}
+				}
+			}
+		}
+	}
+}
+
+bool UnpackController::Cleanup()
+{
+	// By success:
+	//   - move unpacked files to destination dir;
+	//   - remove _unpack-dir;
+	//   - delete archive-files.
+	// By failure:
+	//   - remove _unpack-dir.
+
+	bool bOK = true;
+
+	FileList extractedFiles;
+
+	if (m_bUnpackOK)
+	{
+		// moving files back
+		DirBrowser dir(m_szUnpackDir);
+		while (const char* filename = dir.Next())
+		{
+			if (strcmp(filename, ".") && strcmp(filename, ".."))
+			{
+				char szSrcFile[1024];
+				snprintf(szSrcFile, 1024, "%s%c%s", m_szUnpackDir, PATH_SEPARATOR, filename);
+				szSrcFile[1024-1] = '\0';
+
+				char szDstFile[1024];
+				snprintf(szDstFile, 1024, "%s%c%s", m_szFinalDir[0] != '\0' ? m_szFinalDir : m_szDestDir, PATH_SEPARATOR, filename);
+				szDstFile[1024-1] = '\0';
+
+				// silently overwrite existing files
+				remove(szDstFile);
+
+				if (!Util::MoveFile(szSrcFile, szDstFile))
+				{
+					PrintMessage(Message::mkError, "Could not move file %s to %s", szSrcFile, szDstFile);
+					bOK = false;
+				}
+
+				extractedFiles.push_back(strdup(filename));
+			}
+		}
+	}
+
+	if (bOK && !Util::DeleteDirectoryWithContent(m_szUnpackDir))
+	{
+		PrintMessage(Message::mkError, "Could not remove temporary directory %s", m_szUnpackDir);
+	}
+
+	if (m_bUnpackOK && bOK && g_pOptions->GetUnpackCleanupDisk())
+	{
+		PrintMessage(Message::mkInfo, "Deleting archive files");
+
+		// Delete rar-files (only files which were used by unrar)
+		for (FileList::iterator it = m_archiveFiles.begin(); it != m_archiveFiles.end(); it++)
+		{
+			char* szFilename = *it;
+
+			if (m_bInterDir || !extractedFiles.Exists(szFilename))
+			{
+				char szFullFilename[1024];
+				snprintf(szFullFilename, 1024, "%s%c%s", m_szDestDir, PATH_SEPARATOR, szFilename);
+				szFullFilename[1024-1] = '\0';
+
+				PrintMessage(Message::mkInfo, "Deleting file %s", szFilename);
+
+				if (remove(szFullFilename) != 0)
+				{
+					PrintMessage(Message::mkError, "Could not delete file %s", szFullFilename);
+				}
+			}
+		}
+
+		// Unfortunately 7-Zip doesn't print the processed archive-files to the output.
+		// Therefore we don't know for sure which files were extracted.
+		// We just delete all 7z-files in the directory.
+
+		RegEx regExSevenZip(".*\\.7z$|.*\\.7z\\.[0-9]*$");
+
+		DirBrowser dir(m_szDestDir);
+		while (const char* filename = dir.Next())
+		{
+			char szFullFilename[1024];
+			snprintf(szFullFilename, 1024, "%s%c%s", m_szDestDir, PATH_SEPARATOR, filename);
+			szFullFilename[1024-1] = '\0';
+
+			if (strcmp(filename, ".") && strcmp(filename, "..") && !Util::DirectoryExists(szFullFilename) 
+				&& regExSevenZip.Match(filename) && (m_bInterDir || !extractedFiles.Exists(filename)))
+			{
+				PrintMessage(Message::mkInfo, "Deleting file %s", filename);
+
+				if (remove(szFullFilename) != 0)
+				{
+					PrintMessage(Message::mkError, "Could not delete file %s", szFullFilename);
+				}
+			}
+		}
+
+		m_bCleanedUpDisk = true;
+	}
+
+	extractedFiles.Clear();
+
+	return bOK;
+}
+
+/**
+ * Unrar prints progress information into the same line using backspace control character.
+ * In order to print progress continuously we analyze the output after every char
+ * and update post-job progress information.
+ */
+bool UnpackController::ReadLine(char* szBuf, int iBufSize, FILE* pStream)
+{
+	bool bPrinted = false;
+
+	int i = 0;
+
+	for (; i < iBufSize - 1; i++)
+	{
+		int ch = fgetc(pStream);
+		szBuf[i] = ch;
+		szBuf[i+1] = '\0';
+		if (ch == EOF)
+		{
+			break;
+		}
+		if (ch == '\n')
+		{
+			i++;
+			break;
+		}
+
+		char* szBackspace = strrchr(szBuf, '\b');
+		if (szBackspace)
+		{
+			if (!bPrinted)
+			{
+				char tmp[1024];
+				strncpy(tmp, szBuf, 1024);
+				tmp[1024-1] = '\0';
+				char* szTmpPercent = strrchr(tmp, '\b');
+				if (szTmpPercent)
+				{
+					*szTmpPercent = '\0';
+				}
+				if (strncmp(szBuf, "...", 3))
+				{
+					ProcessOutput(tmp);
+				}
+				bPrinted = true;
+			}
+			if (strchr(szBackspace, '%'))
+			{
+				int iPercent = atoi(szBackspace + 1);
+				m_pPostInfo->SetStageProgress(iPercent * 10);
+			}
+		}
+	}
+
+	szBuf[i] = '\0';
+
+	if (bPrinted)
+	{
+		szBuf[0] = '\0';
+	}
+
+	return i > 0;
+}
+
+void UnpackController::AddMessage(Message::EKind eKind, const char* szText)
+{
+	char szMsgText[1024];
+	strncpy(szMsgText, szText, 1024);
+	szMsgText[1024-1] = '\0';
+	
+	// Modify unrar messages for better readability:
+	// remove the destination path part from message "Extracting file.xxx"
+	if (m_eUnpacker == upUnrar && !strncmp(szText, "Unrar: Extracting  ", 19) &&
+		!strncmp(szText + 19, m_szUnpackDir, strlen(m_szUnpackDir)))
+	{
+		snprintf(szMsgText, 1024, "Unrar: Extracting %s", szText + 19 + strlen(m_szUnpackDir) + 1);
+		szMsgText[1024-1] = '\0';
+	}
+
+	ScriptController::AddMessage(eKind, szMsgText);
+	m_pPostInfo->AppendMessage(eKind, szMsgText);
+
+	if (m_eUnpacker == upUnrar && !strncmp(szMsgText, "Unrar: UNRAR ", 6) &&
+		strstr(szMsgText, " Copyright ") && strstr(szMsgText, " Alexander Roshal"))
+	{
+		// reset start time for a case if user uses unpack-script to do some things
+		// (like sending Wake-On-Lan message) before executing unrar
+		m_pPostInfo->SetStageTime(time(NULL));
+	}
+
+	if (m_eUnpacker == upUnrar && !strncmp(szMsgText, "Unrar: Extracting ", 18))
+	{
+		SetProgressLabel(szMsgText + 7);
+	}
+
+	if (m_eUnpacker == upUnrar && !strncmp(szText, "Unrar: Extracting from ", 23))
+	{
+		const char *szFilename = szText + 23;
+		debug("Filename: %s", szFilename);
+		m_archiveFiles.push_back(strdup(szFilename));
+		SetProgressLabel(szText + 7);
+	}
+
+	if ((m_eUnpacker == upUnrar && !strncmp(szText, "Unrar: All OK", 13)) ||
+		(m_eUnpacker == upSevenZip && !strncmp(szText, "7-Zip: Everything is Ok", 23)))
+	{
+		m_bAllOKMessageReceived = true;
+	}
+}
+
+void UnpackController::Stop()
+{
+	debug("Stopping unpack");
+	Thread::Stop();
+	Terminate();
+}
+
+void UnpackController::SetProgressLabel(const char* szProgressLabel)
+{
+	g_pDownloadQueueHolder->LockQueue();
+	m_pPostInfo->SetProgressLabel(szProgressLabel);
+	g_pDownloadQueueHolder->UnlockQueue();
+}
+
+
+void MoveController::StartJob(PostInfo* pPostInfo)
+{
+	MoveController* pMoveController = new MoveController();
+	pMoveController->m_pPostInfo = pPostInfo;
+	pMoveController->SetAutoDestroy(false);
+
+	pPostInfo->SetPostThread(pMoveController);
+
+	pMoveController->Start();
+}
+
+void MoveController::Run()
+{
+	// the locking is needed for accessing the members of NZBInfo
+	g_pDownloadQueueHolder->LockQueue();
+
+	char szNZBName[1024];
+	strncpy(szNZBName, m_pPostInfo->GetNZBInfo()->GetName(), 1024);
+	szNZBName[1024-1] = '\0';
+
+	char szInfoName[1024];
+	snprintf(szInfoName, 1024, "move for %s", m_pPostInfo->GetNZBInfo()->GetName());
+	szInfoName[1024-1] = '\0';
+	SetInfoName(szInfoName);
+
+	strncpy(m_szInterDir, m_pPostInfo->GetNZBInfo()->GetDestDir(), 1024);
+	m_szInterDir[1024-1] = '\0';
+
+	m_pPostInfo->GetNZBInfo()->BuildFinalDirName(m_szDestDir, 1024);
+	m_szDestDir[1024-1] = '\0';
+
+	g_pDownloadQueueHolder->UnlockQueue();
+
+	info("Moving completed files for %s", szNZBName);
+
+	bool bOK = MoveFiles();
+
+	szInfoName[0] = 'M'; // uppercase
+
+	if (bOK)
+	{
+		info("%s successful", szInfoName);
+		// save new dest dir
+		g_pDownloadQueueHolder->LockQueue();
+		m_pPostInfo->GetNZBInfo()->SetDestDir(m_szDestDir);
+		m_pPostInfo->GetNZBInfo()->SetMoveStatus(NZBInfo::msSuccess);
+		g_pDownloadQueueHolder->UnlockQueue();
+	}
+	else
+	{
+		error("%s failed", szInfoName);
+		m_pPostInfo->GetNZBInfo()->SetMoveStatus(NZBInfo::msFailure);
+	}
+
+	m_pPostInfo->SetStage(PostInfo::ptQueued);
+	m_pPostInfo->SetWorking(false);
+}
+
+bool MoveController::MoveFiles()
+{
+	char szErrBuf[1024];
+	if (!Util::ForceDirectories(m_szDestDir, szErrBuf, sizeof(szErrBuf)))
+	{
+		error("Could not create directory %s: %s", m_szDestDir, szErrBuf);
+		return false;
+	}
+
+	bool bOK = true;
+	DirBrowser dir(m_szInterDir);
+	while (const char* filename = dir.Next())
+	{
+		if (strcmp(filename, ".") && strcmp(filename, ".."))
+		{
+			char szSrcFile[1024];
+			snprintf(szSrcFile, 1024, "%s%c%s", m_szInterDir, PATH_SEPARATOR, filename);
+			szSrcFile[1024-1] = '\0';
+
+			char szDstFile[1024];
+			snprintf(szDstFile, 1024, "%s%c%s", m_szDestDir, PATH_SEPARATOR, filename);
+			szDstFile[1024-1] = '\0';
+
+			// prevent overwriting of existing files
+			int dupcount = 0;
+			while (Util::FileExists(szDstFile))
+			{
+				dupcount++;
+				snprintf(szDstFile, 1024, "%s%c%s_duplicate%d", m_szDestDir, PATH_SEPARATOR, filename, dupcount);
+				szDstFile[1024-1] = '\0';
+			}
+
+			PrintMessage(Message::mkInfo, "Moving file %s to %s", Util::BaseFileName(szSrcFile), m_szDestDir);
+			if (!Util::MoveFile(szSrcFile, szDstFile))
+			{
+				PrintMessage(Message::mkError, "Could not move file %s to %s! Errcode: %i", szSrcFile, szDstFile, errno);
+				bOK = false;
+			}
+		}
+	}
+
+	Util::RemoveDirectory(m_szInterDir);
+
+	return bOK;
+}
+
+
+void CleanupController::StartJob(PostInfo* pPostInfo)
+{
+	CleanupController* pCleanupController = new CleanupController();
+	pCleanupController->m_pPostInfo = pPostInfo;
+	pCleanupController->SetAutoDestroy(false);
+
+	pPostInfo->SetPostThread(pCleanupController);
+
+	pCleanupController->Start();
+}
+
+void CleanupController::Run()
+{
+	// the locking is needed for accessing the members of NZBInfo
+	g_pDownloadQueueHolder->LockQueue();
+
+	char szNZBName[1024];
+	strncpy(szNZBName, m_pPostInfo->GetNZBInfo()->GetName(), 1024);
+	szNZBName[1024-1] = '\0';
+
+	char szInfoName[1024];
+	snprintf(szInfoName, 1024, "cleanup for %s", m_pPostInfo->GetNZBInfo()->GetName());
+	szInfoName[1024-1] = '\0';
+	SetInfoName(szInfoName);
+
+	strncpy(m_szDestDir, m_pPostInfo->GetNZBInfo()->GetDestDir(), 1024);
+	m_szDestDir[1024-1] = '\0';
+
+	bool bInterDir = strlen(g_pOptions->GetInterDir()) > 0 &&
+		!strncmp(m_szDestDir, g_pOptions->GetInterDir(), strlen(g_pOptions->GetInterDir()));
+	if (bInterDir)
+	{
+		m_pPostInfo->GetNZBInfo()->BuildFinalDirName(m_szFinalDir, 1024);
+		m_szFinalDir[1024-1] = '\0';
+	}
+	else
+	{
+		m_szFinalDir[0] = '\0';
+	}
+
+	g_pDownloadQueueHolder->UnlockQueue();
+
+	info("Cleaning up %s", szNZBName);
+
+	bool bDeleted = false;
+	bool bOK = Cleanup(m_szDestDir, &bDeleted);
+
+	if (bOK && m_szFinalDir[0] != '\0')
+	{
+		bool bDeleted2 = false;
+		bOK = Cleanup(m_szFinalDir, &bDeleted2);
+		bDeleted = bDeleted || bDeleted2;
+	}
+
+	szInfoName[0] = 'C'; // uppercase
+
+	if (bOK && bDeleted)
+	{
+		info("%s successful", szInfoName);
+		m_pPostInfo->GetNZBInfo()->SetCleanupStatus(NZBInfo::csSuccess);
+	}
+	else if (bOK)
+	{
+		info("Nothing to cleanup for %s", szNZBName);
+		m_pPostInfo->GetNZBInfo()->SetCleanupStatus(NZBInfo::csSuccess);
+	}
+	else
+	{
+		error("%s failed", szInfoName);
+		m_pPostInfo->GetNZBInfo()->SetCleanupStatus(NZBInfo::csFailure);
+	}
+
+	m_pPostInfo->SetStage(PostInfo::ptQueued);
+	m_pPostInfo->SetWorking(false);
+}
+
+bool CleanupController::Cleanup(const char* szDestDir, bool *bDeleted)
+{
+	*bDeleted = false;
+	bool bOK = true;
+
+	ExtList extList;
+	
+	// split ExtCleanupDisk into tokens and create a list
+	char* szExtCleanupDisk = strdup(g_pOptions->GetExtCleanupDisk());
+	
+	char* saveptr;
+	char* szExt = strtok_r(szExtCleanupDisk, ",; ", &saveptr);
+	while (szExt)
+	{
+		extList.push_back(szExt);
+		szExt = strtok_r(NULL, ",; ", &saveptr);
+	}
+	
+	DirBrowser dir(szDestDir);
+	while (const char* filename = dir.Next())
+	{
+		// check file extension
+		
+		int iFilenameLen = strlen(filename);
+		bool bDeleteIt = false;
+		for (ExtList::iterator it = extList.begin(); it != extList.end(); it++)
+		{
+			const char* szExt = *it;
+			int iExtLen = strlen(szExt);
+			if (iFilenameLen >= iExtLen && !strcasecmp(szExt, filename + iFilenameLen - iExtLen))
+			{
+				bDeleteIt = true;
+				break;
+			}
+		}
+
+		if (bDeleteIt)
+		{
+			char szFullFilename[1024];
+			snprintf(szFullFilename, 1024, "%s%c%s", szDestDir, PATH_SEPARATOR, filename);
+			szFullFilename[1024-1] = '\0';
+
+			PrintMessage(Message::mkInfo, "Deleting file %s", filename);
+			if (remove(szFullFilename) != 0)
+			{
+				PrintMessage(Message::mkError, "Could not delete file %s! Errcode: %i", szFullFilename, errno);
+				bOK = false;
+			}
+
+			*bDeleted = true;
+		}
+	}
+
+	free(szExtCleanupDisk);
+
+	return bOK;
+}

Unpack.h

@@ -0,0 +1,129 @@
+/*
+ *  This file is part of nzbget
+ *
+ *  Copyright (C) 2013 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifndef UNPACK_H
+#define UNPACK_H
+
+#include <deque>
+
+#include "Log.h"
+#include "Thread.h"
+#include "DownloadInfo.h"
+#include "ScriptController.h"
+
+class UnpackController : public Thread, public ScriptController
+{
+private:
+	enum EUnpacker
+	{
+		upUnrar,
+		upSevenZip
+	};
+
+	typedef std::deque<char*>		FileListBase;
+	class FileList : public FileListBase
+	{
+	public:
+		void			Clear();
+		bool			Exists(const char* szFilename);
+	};
+
+private:
+	PostInfo*			m_pPostInfo;
+	char				m_szName[1024];
+	char				m_szInfoName[1024];
+	char				m_szInfoNameUp[1024];
+	char				m_szDestDir[1024];
+	char				m_szFinalDir[1024];
+	char				m_szUnpackDir[1024];
+	char				m_szPassword[1024];
+	bool				m_bInterDir;
+	bool				m_bAllOKMessageReceived;
+	bool				m_bNoFilesMessageReceived;
+	bool				m_bHasParFiles;
+	bool				m_bHasBrokenFiles;
+	bool				m_bHasRarFiles;
+	bool				m_bHasNonStdRarFiles;
+	bool				m_bHasSevenZipFiles;
+	bool				m_bHasSevenZipMultiFiles;
+	bool				m_bUnpackOK;
+	bool				m_bUnpackStartError;
+	bool				m_bCleanedUpDisk;
+	EUnpacker			m_eUnpacker;
+	FileList			m_archiveFiles;
+
+protected:
+	virtual bool		ReadLine(char* szBuf, int iBufSize, FILE* pStream);
+	virtual void		AddMessage(Message::EKind eKind, const char* szText);
+	void				ExecuteUnrar();
+	void				ExecuteSevenZip(bool bMultiVolumes);
+	void				Completed();
+	void				CreateUnpackDir();
+	bool				Cleanup();
+	void				CheckStateFiles();
+	void				CheckArchiveFiles(bool bScanNonStdFiles);
+	void				SetProgressLabel(const char* szProgressLabel);
+#ifndef DISABLE_PARCHECK
+	void				RequestParCheck(bool bRename);
+#endif
+
+public:
+	virtual				~UnpackController();
+	virtual void		Run();
+	virtual void		Stop();
+	static void			StartJob(PostInfo* pPostInfo);
+};
+
+class MoveController : public Thread, public ScriptController
+{
+private:
+	PostInfo*			m_pPostInfo;
+	char				m_szInterDir[1024];
+	char				m_szDestDir[1024];
+
+	bool				MoveFiles();
+
+public:
+	virtual void		Run();
+	static void			StartJob(PostInfo* pPostInfo);
+};
+
+class CleanupController : public Thread, public ScriptController
+{
+private:
+	PostInfo*			m_pPostInfo;
+	char				m_szDestDir[1024];
+	char				m_szFinalDir[1024];
+
+	bool				Cleanup(const char* szDestDir, bool *bDeleted);
+
+	typedef std::deque<char*>	ExtList;
+
+public:
+	virtual void		Run();
+	static void			StartJob(PostInfo* pPostInfo);
+};
+
+#endif

UrlCoordinator.cpp

@@ -0,0 +1,428 @@
+/*
+ *  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$
+ *
+ */
+
+
+#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 "UrlCoordinator.h"
+#include "Options.h"
+#include "WebDownloader.h"
+#include "DiskState.h"
+#include "Log.h"
+#include "Util.h"
+#include "NZBFile.h"
+#include "QueueCoordinator.h"
+#include "Scanner.h"
+
+extern Options* g_pOptions;
+extern DiskState* g_pDiskState;
+extern QueueCoordinator* g_pQueueCoordinator;
+extern Scanner* g_pScanner;
+
+
+UrlDownloader::UrlDownloader() : WebDownloader()
+{
+	m_szCategory = NULL;
+}
+
+UrlDownloader::~UrlDownloader()
+{
+	if (m_szCategory)
+	{
+		free(m_szCategory);
+	}
+}
+
+void UrlDownloader::ProcessHeader(const char* szLine)
+{
+	WebDownloader::ProcessHeader(szLine);
+
+	if (!strncmp(szLine, "X-DNZB-Category: ", 17))
+	{
+		if (m_szCategory)
+		{
+			free(m_szCategory);
+		}
+
+		const char *szCat = szLine + 17;
+
+		int iCatLen = strlen(szCat);
+
+		// trim trailing CR/LF/spaces
+		while (iCatLen > 0 && (szCat[iCatLen-1] == '\n' || szCat[iCatLen-1] == '\r' || szCat[iCatLen-1] == ' ')) iCatLen--; 
+
+		m_szCategory = (char*)malloc(iCatLen + 1);
+		strncpy(m_szCategory, szCat, iCatLen);
+		m_szCategory[iCatLen] = '\0';
+
+		debug("Category: %s", m_szCategory);
+	}
+}
+
+UrlCoordinator::UrlCoordinator()
+{
+	debug("Creating UrlCoordinator");
+
+	m_bHasMoreJobs = true;
+}
+
+UrlCoordinator::~UrlCoordinator()
+{
+	debug("Destroying UrlCoordinator");
+	// Cleanup
+
+	debug("Deleting UrlDownloaders");
+	for (ActiveDownloads::iterator it = m_ActiveDownloads.begin(); it != m_ActiveDownloads.end(); it++)
+	{
+		delete *it;
+	}
+	m_ActiveDownloads.clear();
+
+	DownloadQueue* pDownloadQueue = g_pQueueCoordinator->LockQueue();
+	for (UrlQueue::iterator it = pDownloadQueue->GetUrlQueue()->begin(); it != pDownloadQueue->GetUrlQueue()->end(); it++)
+	{
+		delete *it;
+	}
+	pDownloadQueue->GetUrlQueue()->clear();
+	g_pQueueCoordinator->UnlockQueue();
+
+	debug("UrlCoordinator destroyed");
+}
+
+void UrlCoordinator::Run()
+{
+	debug("Entering UrlCoordinator-loop");
+
+	int iResetCounter = 0;
+
+	while (!IsStopped())
+	{
+		if (!(g_pOptions->GetPauseDownload() || g_pOptions->GetPauseDownload2()))
+		{
+			// start download for next URL
+			DownloadQueue* pDownloadQueue = g_pQueueCoordinator->LockQueue();
+
+			if ((int)m_ActiveDownloads.size() < g_pOptions->GetUrlConnections())
+			{
+				UrlInfo* pUrlInfo;
+				bool bHasMoreUrls = GetNextUrl(pDownloadQueue, pUrlInfo);
+				bool bUrlDownloadsRunning = !m_ActiveDownloads.empty();
+				m_bHasMoreJobs = bHasMoreUrls || bUrlDownloadsRunning;
+				if (bHasMoreUrls && !IsStopped())
+				{
+					StartUrlDownload(pUrlInfo);
+				}
+			}
+			g_pQueueCoordinator->UnlockQueue();
+		}
+
+		int iSleepInterval = 100;
+		usleep(iSleepInterval * 1000);
+
+		iResetCounter += iSleepInterval;
+		if (iResetCounter >= 1000)
+		{
+			// this code should not be called too often, once per second is OK
+			ResetHangingDownloads();
+			iResetCounter = 0;
+		}
+	}
+
+	// waiting for downloads
+	debug("UrlCoordinator: waiting for Downloads to complete");
+	bool completed = false;
+	while (!completed)
+	{
+		g_pQueueCoordinator->LockQueue();
+		completed = m_ActiveDownloads.size() == 0;
+		g_pQueueCoordinator->UnlockQueue();
+		usleep(100 * 1000);
+		ResetHangingDownloads();
+	}
+	debug("UrlCoordinator: Downloads are completed");
+
+	debug("Exiting UrlCoordinator-loop");
+}
+
+void UrlCoordinator::Stop()
+{
+	Thread::Stop();
+
+	debug("Stopping UrlDownloads");
+	g_pQueueCoordinator->LockQueue();
+	for (ActiveDownloads::iterator it = m_ActiveDownloads.begin(); it != m_ActiveDownloads.end(); it++)
+	{
+		(*it)->Stop();
+	}
+	g_pQueueCoordinator->UnlockQueue();
+	debug("UrlDownloads are notified");
+}
+
+void UrlCoordinator::ResetHangingDownloads()
+{
+	const int TimeOut = g_pOptions->GetTerminateTimeout();
+	if (TimeOut == 0)
+	{
+		return;
+	}
+
+	g_pQueueCoordinator->LockQueue();
+	time_t tm = ::time(NULL);
+
+	for (ActiveDownloads::iterator it = m_ActiveDownloads.begin(); it != m_ActiveDownloads.end();)
+	{
+		UrlDownloader* pUrlDownloader = *it;
+		if (tm - pUrlDownloader->GetLastUpdateTime() > TimeOut &&
+		   pUrlDownloader->GetStatus() == UrlDownloader::adRunning)
+		{
+			UrlInfo* pUrlInfo = pUrlDownloader->GetUrlInfo();
+			debug("Terminating hanging download %s", pUrlDownloader->GetInfoName());
+			if (pUrlDownloader->Terminate())
+			{
+				error("Terminated hanging download %s", pUrlDownloader->GetInfoName());
+				pUrlInfo->SetStatus(UrlInfo::aiUndefined);
+			}
+			else
+			{
+				error("Could not terminate hanging download %s", pUrlDownloader->GetInfoName());
+			}
+			m_ActiveDownloads.erase(it);
+			// it's not safe to destroy pUrlDownloader, because the state of object is unknown
+			delete pUrlDownloader;
+			it = m_ActiveDownloads.begin();
+			continue;
+		}
+		it++;
+	}                                              
+
+	g_pQueueCoordinator->UnlockQueue();
+}
+
+void UrlCoordinator::LogDebugInfo()
+{
+	debug("   UrlCoordinator");
+	debug("   ----------------");
+
+	g_pQueueCoordinator->LockQueue();
+	debug("    Active Downloads: %i", m_ActiveDownloads.size());
+	for (ActiveDownloads::iterator it = m_ActiveDownloads.begin(); it != m_ActiveDownloads.end(); it++)
+	{
+		UrlDownloader* pUrlDownloader = *it;
+		pUrlDownloader->LogDebugInfo();
+	}
+	g_pQueueCoordinator->UnlockQueue();
+}
+
+void UrlCoordinator::AddUrlToQueue(UrlInfo* pUrlInfo, bool AddFirst)
+{
+	debug("Adding NZB-URL to queue");
+
+	DownloadQueue* pDownloadQueue = g_pQueueCoordinator->LockQueue();
+
+	pDownloadQueue->GetUrlQueue()->push_back(pUrlInfo);
+
+	if (g_pOptions->GetSaveQueue() && g_pOptions->GetServerMode())
+	{
+		g_pDiskState->SaveDownloadQueue(pDownloadQueue);
+	}
+
+	g_pQueueCoordinator->UnlockQueue();
+}
+
+/*
+ * Returns next URL for download.
+ */
+bool UrlCoordinator::GetNextUrl(DownloadQueue* pDownloadQueue, UrlInfo* &pUrlInfo)
+{
+	bool bOK = false;
+
+	for (UrlQueue::iterator at = pDownloadQueue->GetUrlQueue()->begin(); at != pDownloadQueue->GetUrlQueue()->end(); at++)
+	{
+		pUrlInfo = *at;
+		if (pUrlInfo->GetStatus() == 0)
+		{
+			bOK = true;
+			break;
+		}
+	}
+
+	return bOK;
+}
+
+void UrlCoordinator::StartUrlDownload(UrlInfo* pUrlInfo)
+{
+	debug("Starting new UrlDownloader");
+
+	UrlDownloader* pUrlDownloader = new UrlDownloader();
+	pUrlDownloader->SetAutoDestroy(true);
+	pUrlDownloader->Attach(this);
+	pUrlDownloader->SetUrlInfo(pUrlInfo);
+	pUrlDownloader->SetURL(pUrlInfo->GetURL());
+
+	char tmp[1024];
+
+	pUrlInfo->GetName(tmp, 1024);
+	pUrlDownloader->SetInfoName(tmp);
+
+	snprintf(tmp, 1024, "%surl-%i.tmp", g_pOptions->GetTempDir(), pUrlInfo->GetID());
+	tmp[1024-1] = '\0';
+	pUrlDownloader->SetOutputFilename(tmp);
+
+	pUrlInfo->SetStatus(UrlInfo::aiRunning);
+
+	m_ActiveDownloads.push_back(pUrlDownloader);
+	pUrlDownloader->Start();
+}
+
+void UrlCoordinator::Update(Subject* Caller, void* Aspect)
+{
+	debug("Notification from UrlDownloader received");
+
+	UrlDownloader* pUrlDownloader = (UrlDownloader*) Caller;
+	if ((pUrlDownloader->GetStatus() == WebDownloader::adFinished) ||
+		(pUrlDownloader->GetStatus() == WebDownloader::adFailed) ||
+		(pUrlDownloader->GetStatus() == WebDownloader::adRetry))
+	{
+		UrlCompleted(pUrlDownloader);
+	}
+}
+
+void UrlCoordinator::UrlCompleted(UrlDownloader* pUrlDownloader)
+{
+	debug("URL downloaded");
+
+	UrlInfo* pUrlInfo = pUrlDownloader->GetUrlInfo();
+
+	if (pUrlDownloader->GetStatus() == WebDownloader::adFinished)
+	{
+		pUrlInfo->SetStatus(UrlInfo::aiFinished);
+	}
+	else if (pUrlDownloader->GetStatus() == WebDownloader::adFailed)
+	{
+		pUrlInfo->SetStatus(UrlInfo::aiFailed);
+	}
+	else if (pUrlDownloader->GetStatus() == WebDownloader::adRetry)
+	{
+		pUrlInfo->SetStatus(UrlInfo::aiUndefined);
+	}
+
+	char filename[1024];
+	if (pUrlDownloader->GetOriginalFilename())
+	{
+		strncpy(filename, pUrlDownloader->GetOriginalFilename(), 1024);
+		filename[1024-1] = '\0';
+	}
+	else
+	{
+		strncpy(filename, Util::BaseFileName(pUrlInfo->GetURL()), 1024);
+		filename[1024-1] = '\0';
+
+		// TODO: decode URL escaping
+	}
+
+	Util::MakeValidFilename(filename, '_', false);
+
+	debug("Filename: [%s]", filename);
+
+	DownloadQueue* pDownloadQueue = g_pQueueCoordinator->LockQueue();
+
+	// delete Download from Queue
+	for (ActiveDownloads::iterator it = m_ActiveDownloads.begin(); it != m_ActiveDownloads.end(); it++)
+	{
+		UrlDownloader* pa = *it;
+		if (pa == pUrlDownloader)
+		{
+			m_ActiveDownloads.erase(it);
+			break;
+		}
+	}
+
+	bool bDeleteObj = false;
+
+	if (pUrlInfo->GetStatus() == UrlInfo::aiFinished || pUrlInfo->GetStatus() == UrlInfo::aiFailed)
+	{
+		// delete UrlInfo from Queue
+		for (UrlQueue::iterator it = pDownloadQueue->GetUrlQueue()->begin(); it != pDownloadQueue->GetUrlQueue()->end(); it++)
+		{
+			UrlInfo* pa = *it;
+			if (pa == pUrlInfo)
+			{
+				pDownloadQueue->GetUrlQueue()->erase(it);
+				break;
+			}
+		}
+
+		bDeleteObj = true;
+
+		if (g_pOptions->GetKeepHistory() > 0 && pUrlInfo->GetStatus() == UrlInfo::aiFailed)
+		{
+			HistoryInfo* pHistoryInfo = new HistoryInfo(pUrlInfo);
+			pHistoryInfo->SetTime(time(NULL));
+			pDownloadQueue->GetHistoryList()->push_front(pHistoryInfo);
+			bDeleteObj = false;
+		}
+			
+		if (g_pOptions->GetSaveQueue() && g_pOptions->GetServerMode())
+		{
+			g_pDiskState->SaveDownloadQueue(pDownloadQueue);
+		}
+	}
+
+	g_pQueueCoordinator->UnlockQueue();
+
+	if (pUrlInfo->GetStatus() == UrlInfo::aiFinished)
+	{
+		// add nzb-file to download queue
+		AddToNZBQueue(pUrlInfo, pUrlDownloader->GetOutputFilename(), filename, pUrlDownloader->GetCategory());
+	}
+
+	if (bDeleteObj)
+	{
+		delete pUrlInfo;
+	}
+}
+
+void UrlCoordinator::AddToNZBQueue(UrlInfo* pUrlInfo, const char* szTempFilename, const char* szOriginalFilename, const char* szOriginalCategory)
+{
+	g_pScanner->AddExternalFile(
+		pUrlInfo->GetNZBFilename() && strlen(pUrlInfo->GetNZBFilename()) > 0 ? pUrlInfo->GetNZBFilename() : szOriginalFilename,
+		strlen(pUrlInfo->GetCategory()) > 0 ? pUrlInfo->GetCategory() : szOriginalCategory,
+		pUrlInfo->GetPriority(), NULL, pUrlInfo->GetAddTop(), pUrlInfo->GetAddPaused(), szTempFilename, NULL, 0, false);
+}

UrlCoordinator.h

@@ -0,0 +1,86 @@
+/*
+ *  This file is part of nzbget
+ *
+ *  Copyright (C) 2012 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 URLCOORDINATOR_H
+#define URLCOORDINATOR_H
+
+#include <deque>
+#include <list>
+#include <time.h>
+
+#include "Thread.h"
+#include "WebDownloader.h"
+#include "DownloadInfo.h"
+#include "Observer.h"
+
+class UrlDownloader;
+
+class UrlCoordinator : public Thread, public Observer, public Subject
+{
+public:
+	typedef std::list<UrlDownloader*>	ActiveDownloads;
+
+private:
+	ActiveDownloads			m_ActiveDownloads;
+	bool					m_bHasMoreJobs;
+
+	bool					GetNextUrl(DownloadQueue* pDownloadQueue, UrlInfo* &pUrlInfo);
+	void					StartUrlDownload(UrlInfo* pUrlInfo);
+	void					UrlCompleted(UrlDownloader* pUrlDownloader);
+	void					ResetHangingDownloads();
+	void					AddToNZBQueue(UrlInfo* pUrlInfo, const char* szTempFilename, const char* szOriginalFilename, const char* szOriginalCategory);
+
+public:
+							UrlCoordinator();                
+	virtual					~UrlCoordinator();
+	virtual void			Run();
+	virtual void 			Stop();
+	void					Update(Subject* Caller, void* Aspect);
+
+	// Editing the queue
+	void					AddUrlToQueue(UrlInfo* pUrlInfo, bool AddFirst);
+	bool					HasMoreJobs() { return m_bHasMoreJobs; }
+
+	void					LogDebugInfo();
+};
+
+class UrlDownloader : public WebDownloader
+{
+private:
+	UrlInfo*				m_pUrlInfo;
+	char*					m_szCategory;
+
+protected:
+	virtual void			ProcessHeader(const char* szLine);
+
+public:
+							UrlDownloader();
+							~UrlDownloader();
+	void					SetUrlInfo(UrlInfo* pUrlInfo) { m_pUrlInfo = pUrlInfo; }
+	UrlInfo*				GetUrlInfo() { return m_pUrlInfo; }
+	const char*				GetCategory() { return m_szCategory; }
+};
+
+#endif

Util.h

@@ -0,0 +1,300 @@
+/*
+ *  This file is part of nzbget
+ *
+ *  Copyright (C) 2007-2013 Andrey Prygunkov <hugbug@users.sourceforge.net>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * $Revision$
+ * $Date$
+ *
+ */
+
+
+#ifndef UTIL_H
+#define UTIL_H
+
+#ifdef WIN32
+#include <stdio.h>
+#include <io.h>
+#else
+#include <dirent.h>
+#endif
+
+#ifdef WIN32
+extern int optind, opterr;
+extern char *optarg;
+int getopt(int argc, char *argv[], char *optstring);
+#endif
+
+class DirBrowser
+{
+private:
+#ifdef WIN32
+	struct _finddata_t	m_FindData;
+	intptr_t			m_hFile;
+	bool				m_bFirst;
+#else
+	DIR*				m_pDir;
+	struct dirent*		m_pFindData;
+#endif
+
+public:
+						DirBrowser(const char* szPath);
+						~DirBrowser();
+	const char*			Next();
+};
+
+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 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 SaveBufferIntoFile(const char* szFileName, const char* szBuffer, int iBufLen);
+	static bool CreateSparseFile(const char* szFilename, int iSize);
+	static bool TruncateFile(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 RemoveDirectory(const char* szDirFilename);
+	static bool DeleteDirectoryWithContent(const char* szDirFilename);
+	static bool ForceDirectories(const char* szPath, char* szErrBuf, int iBufSize);
+	static bool GetCurrentDirectory(char* szBuffer, int iBufSize);
+	static bool SetCurrentDirectory(const char* szDirFilename);
+	static long long FileSize(const char* szFilename);
+	static long long FreeDiskSize(const char* szPath);
+	static bool DirEmpty(const char* szDirFilename);
+	static bool RenameBak(const char* szFilename, const char* szBakPart, bool bRemoveOldExtension, char* szNewNameBuf, int iNewNameBufSize);
+#ifndef WIN32
+	static bool ExpandHomePath(const char* szFilename, char* szBuffer, int iBufSize);
+#endif
+	static void ExpandFileName(const char* szFilename, char* szBuffer, int iBufSize);
+	static void FormatFileSize(char* szBuffer, int iBufLen, long long lFileSize);
+	static bool SameFilename(const char* szFilename1, const char* szFilename2);
+	static char* GetLastErrorMessage(char* szBuffer, int iBufLen);
+
+	/*
+	 * Split command line int arguments.
+	 * Uses spaces and single quotation marks as separators.
+	 * Returns bool if sucessful or false if bad escaping was detected.
+	 * Parameter "argv" may be NULL if only a syntax check is needed.
+	 * Parsed parameters returned in Array "argv", which contains at least one element.
+	 * The last element in array is NULL.
+	 * Restrictions: the number of arguments is limited to 100 and each arguments must
+	 * be maximum 1024 chars long.
+	 * If these restrictions are exceeded, only first 100 arguments and only first 1024
+	 * for each argument are returned (the functions still returns "true").
+	 */
+	static bool SplitCommandLine(const char* szCommandLine, char*** argv);
+
+	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 void TrimRight(char* szStr);
+
+	static char* Trim(char* szStr);
+
+#ifdef WIN32
+	static bool RegReadStr(HKEY hKey, const char* szKeyName, const char* szValueName, char* szBuffer, int* iBufLen);
+#endif
+
+	/*
+	 * Returns program version and revision number as string formatted like "0.7.0-r295".
+	 * If revision number is not available only version is returned ("0.7.0").
+	 */
+	static const char* VersionRevision() { return VersionRevisionBuf; };
+	
+	/*
+	 * Initialize buffer for program version and revision number.
+	 * This function must be called during program initialization before any
+	 * call to "VersionRevision()".
+	 */
+	static void InitVersionRevision();
+	
+	static char VersionRevisionBuf[40];
+};
+
+class WebUtil
+{
+public:
+	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);
+
+	/*
+	 * Unquote http quoted string.
+	 * The string is decoded on the place overwriting the content of raw-data.
+	 */
+	static void HttpUnquote(char* raw);
+};
+
+class URL
+{
+private:
+	char*				m_szAddress;
+	char*				m_szProtocol;
+	char*				m_szUser;
+	char*				m_szPassword;
+	char*				m_szHost;
+	char*				m_szResource;
+	int					m_iPort;
+	bool				m_bTLS;
+	bool				m_bValid;
+	void				ParseURL();
+
+public:
+	 					URL(const char* szAddress);
+						~URL();
+	bool				IsValid() { return m_bValid; }
+	const char*			GetAddress() { return m_szAddress; }
+	const char*			GetProtocol() { return m_szProtocol; }
+	const char*			GetUser() { return m_szUser; }
+	const char*			GetPassword() { return m_szPassword; }
+	const char*			GetHost() { return m_szHost; }
+	const char*			GetResource() { return m_szResource; }
+	int					GetPort() { return m_iPort; }
+	bool				GetTLS() { return m_bTLS; }
+};
+
+class RegEx
+{
+private:
+	void*				m_pContext;
+	bool				m_bValid;
+
+public:
+						RegEx(const char *szPattern);
+						~RegEx();
+	bool				IsValid() { return m_bValid; }
+	bool				Match(const char *szStr);
+};
+
+#ifndef DISABLE_GZIP
+class ZLib
+{
+public:
+	/*
+	 * calculates the size required for output buffer
+	 */
+	static unsigned int GZipLen(int iInputBufferLength);
+	
+	/*
+	 * returns the size of bytes written to szOutputBuffer or 0 if the buffer is too small or an error occured.
+	 */
+	static unsigned int GZip(const void* szInputBuffer, int iInputBufferLength, void* szOutputBuffer, int iOutputBufferLength);
+};
+
+class GUnzipStream
+{
+public:
+	enum EStatus
+	{
+		zlError,
+		zlFinished,
+		zlOK
+	};
+
+private:
+	void*				m_pZStream;
+	void*				m_pOutputBuffer;
+	int					m_iBufferSize;
+
+public:
+						GUnzipStream(int BufferSize);
+						~GUnzipStream();
+
+	/*
+	 * set next memory block for uncompression
+	 */
+	void				Write(const void *pInputBuffer, int iInputBufferLength);
+
+	/*
+	 * get next uncompressed memory block.
+	 * iOutputBufferLength - the size of uncompressed block. if it is "0" the next compressed block must be provided via "Write".
+	 */
+	EStatus				Read(const void **pOutputBuffer, int *iOutputBufferLength);
+};
+#endif
+
+#endif

WebDownloader.cpp

@@ -0,0 +1,679 @@
+/*
+ *  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$
+ *
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef WIN32
+#include "win32.h"
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#ifdef WIN32
+#include <direct.h>
+#else
+#include <unistd.h>
+#include <sys/time.h>
+#endif
+#include <sys/stat.h>
+#include <errno.h>
+
+#include "nzbget.h"
+#include "WebDownloader.h"
+#include "Log.h"
+#include "Options.h"
+#include "Util.h"
+
+extern Options* g_pOptions;
+
+WebDownloader::WebDownloader()
+{
+	debug("Creating WebDownloader");
+
+	m_szURL	= NULL;
+	m_szOutputFilename	= NULL;
+	m_pConnection = NULL;
+	m_szInfoName = NULL;
+	m_bConfirmedLength = false;
+	m_eStatus = adUndefined;
+	m_szOriginalFilename = NULL;
+	SetLastUpdateTimeNow();
+}
+
+WebDownloader::~WebDownloader()
+{
+	debug("Destroying WebDownloader");
+
+	if (m_szURL)
+	{
+		free(m_szURL);
+	}
+	if (m_szInfoName)
+	{
+		free(m_szInfoName);
+	}
+	if (m_szOutputFilename)
+	{
+		free(m_szOutputFilename);
+	}
+	if (m_szOriginalFilename)
+	{
+		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)
+{
+	m_szURL = strdup(szURL);
+}
+
+void WebDownloader::SetStatus(EStatus eStatus)
+{
+	m_eStatus = eStatus;
+	Notify(NULL);
+}
+
+void WebDownloader::Run()
+{
+	debug("Entering WebDownloader-loop");
+
+	SetStatus(adRunning);
+
+	int iRemainedDownloadRetries = g_pOptions->GetRetries() > 0 ? g_pOptions->GetRetries() : 1;
+	int iRemainedConnectRetries = iRemainedDownloadRetries > 10 ? iRemainedDownloadRetries : 10;
+
+	EStatus Status = adFailed;
+
+	while (!IsStopped() && iRemainedDownloadRetries > 0 && iRemainedConnectRetries > 0)
+	{
+		SetLastUpdateTimeNow();
+
+		Status = Download();
+
+		if ((((Status == adFailed) && (iRemainedDownloadRetries > 1)) ||
+			((Status == adConnectError) && (iRemainedConnectRetries > 1)))
+			&& !IsStopped() && !(g_pOptions->GetPauseDownload() || g_pOptions->GetPauseDownload2()))
+		{
+			detail("Waiting %i sec to retry", g_pOptions->GetRetryInterval());
+			int msec = 0;
+			while (!IsStopped() && (msec < g_pOptions->GetRetryInterval() * 1000) && 
+				!(g_pOptions->GetPauseDownload() || g_pOptions->GetPauseDownload2()))
+			{
+				usleep(100 * 1000);
+				msec += 100;
+			}
+		}
+
+		if (IsStopped() || g_pOptions->GetPauseDownload() || g_pOptions->GetPauseDownload2())
+		{
+			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->SetSuppressErrors(false);
+
+	// connection
+	bool bConnected = m_pConnection->Connect();
+	if (!bConnected || IsStopped())
+	{
+		FreeConnection();
+		return adConnectError;
+	}
+
+	// Okay, we got a Connection. Now start downloading.
+	detail("Downloading %s", m_szInfoName);
+
+	SendHeaders(&url);
+
+	Status = DownloadHeaders();
+
+	if (Status == adRunning)
+	{
+		Status = DownloadBody();
+	}
+
+	if (IsStopped())
+	{
+		Status = adFailed;
+	}
+
+	FreeConnection();
+
+	if (Status != adFinished)
+	{
+		// Download failed, delete broken output file
+		remove(m_szOutputFilename);
+	}
+
+	return Status;
+}
+
+
+WebDownloader::EStatus WebDownloader::CreateConnection(URL *pUrl)
+{
+	if (!pUrl->IsValid())
+	{
+		error("URL is not valid: %s", pUrl->GetAddress());
+		return adFatalError;
+	}
+
+	int iPort = pUrl->GetPort();
+	if (iPort == 0 && !strcasecmp(pUrl->GetProtocol(), "http"))
+	{
+		iPort = 80;
+	}
+	if (iPort == 0 && !strcasecmp(pUrl->GetProtocol(), "https"))
+	{
+		iPort = 443;
+	}
+
+	if (strcasecmp(pUrl->GetProtocol(), "http") && strcasecmp(pUrl->GetProtocol(), "https"))
+	{
+		error("Unsupported protocol in URL: %s", pUrl->GetAddress());
+		return adFatalError;
+	}
+
+#ifdef DISABLE_TLS
+	if (!strcasecmp(pUrl->GetProtocol(), "https"))
+	{
+		error("Program was compiled without TLS/SSL-support. Cannot download using https protocol. URL: %s", pUrl->GetAddress());
+		return adFatalError;
+	}
+#endif
+
+	bool bTLS = !strcasecmp(pUrl->GetProtocol(), "https");
+
+	m_pConnection = new Connection(pUrl->GetHost(), iPort, bTLS);
+
+	return adRunning;
+}
+
+void WebDownloader::SendHeaders(URL *pUrl)
+{
+	char tmp[1024];
+
+	// retrieve file
+	snprintf(tmp, 1024, "GET %s HTTP/1.0\r\n", pUrl->GetResource());
+	tmp[1024-1] = '\0';
+	m_pConnection->WriteLine(tmp);
+
+	snprintf(tmp, 1024, "User-Agent: nzbget/%s\r\n", Util::VersionRevision());
+	tmp[1024-1] = '\0';
+	m_pConnection->WriteLine(tmp);
+
+	snprintf(tmp, 1024, "Host: %s\r\n", pUrl->GetHost());
+	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;
+
+	// Headers
+	while (!IsStopped())
+	{
+		SetLastUpdateTimeNow();
+
+		int iLen = 0;
+		char* line = m_pConnection->ReadLine(szLineBuf, LineBufSize, &iLen);
+
+		if (bFirstLine)
+		{
+			Status = CheckResponse(szLineBuf);
+			if (Status != adRunning)
+			{
+				break;
+			}
+			bFirstLine = false;
+		}
+
+		// Have we encountered a timeout?
+		if (!line)
+		{
+			if (!IsStopped())
+			{
+				warn("URL %s failed: Unexpected end of file", m_szInfoName);
+			}
+			Status = adFailed;
+			break;
+		}
+
+		debug("Header: %s", line);
+
+		// detect body of response
+		if (*line == '\r' || *line == '\n')
+		{
+			if (m_iContentLen == -1 && !m_bGZip)
+			{
+				warn("URL %s: Content-Length is not submitted by server, cannot verify whether the file is complete", m_szInfoName);
+			}
+			break;
+		}
+
+		ProcessHeader(line);
+	}
+
+	free(szLineBuf);
+
+	return Status;
+}
+
+WebDownloader::EStatus WebDownloader::DownloadBody()
+{
+	EStatus Status = adRunning;
+
+	m_pOutFile = NULL;
+	bool bEnd = false;
+	const int LineBufSize = 1024*10;
+	char* szLineBuf = (char*)malloc(LineBufSize);
+	int iWrittenLen = 0;
+
+#ifndef DISABLE_GZIP
+	m_pGUnzipStream = NULL;
+	if (m_bGZip)
+	{
+		m_pGUnzipStream = new GUnzipStream(1024*10);
+	}
+#endif
+
+	// Body
+	while (!IsStopped())
+	{
+		SetLastUpdateTimeNow();
+
+		char* szBuffer;
+		int iLen;
+		m_pConnection->ReadBuffer(&szBuffer, &iLen);
+		if (iLen == 0)
+		{
+			iLen = m_pConnection->TryRecv(szLineBuf, LineBufSize);
+			szBuffer = szLineBuf;
+		}
+
+		// Have we encountered a timeout?
+		if (iLen <= 0)
+		{
+			if (m_iContentLen == -1)
+			{
+				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
+	if (m_pGUnzipStream)
+	{
+		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, "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 (!strncmp(szLine, "Content-Length: ", 16))
+	{
+		m_iContentLen = atoi(szLine + 16);
+		m_bConfirmedLength = true;
+	}
+
+	if (!strncmp(szLine, "Content-Encoding: gzip", 22))
+	{
+		m_bGZip = true;
+	}
+
+	if (!strncmp(szLine, "Content-Disposition: ", 21))
+	{
+		ParseFilename(szLine);
+	}
+}
+
+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);
+
+	if (m_szOriginalFilename)
+	{
+		free(m_szOriginalFilename);
+	}
+	m_szOriginalFilename = strdup(Util::BaseFileName(fname));
+
+	debug("OriginalFilename: %s", m_szOriginalFilename);
+}
+
+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, "wb");
+	if (!m_pOutFile)
+	{
+		error("Could not %s file %s", "create", szFilename);
+		return false;
+	}
+	if (g_pOptions->GetWriteBufferSize() > 0)
+	{
+		setvbuf(m_pOutFile, (char *)NULL, _IOFBF, g_pOptions->GetWriteBufferSize());
+	}
+
+	return true;
+}
+
+void WebDownloader::LogDebugInfo()
+{
+	char szTime[50];
+#ifdef HAVE_CTIME_R_3
+		ctime_r(&m_tLastUpdateTime, szTime, 50);
+#else
+		ctime_r(&m_tLastUpdateTime, szTime);
+#endif
+
+	debug("      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();
+	}
+}

WebDownloader.h

@@ -0,0 +1,103 @@
+/*
+ *  This file is part of nzbget
+ *
+ *  Copyright (C) 2012 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,
+		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_bGZip;
+#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				Download();
+	EStatus				CreateConnection(URL *pUrl);
+	void				ParseFilename(const char* szContentDisposition);
+	void				SendHeaders(URL *pUrl);
+	EStatus				DownloadHeaders();
+	EStatus				DownloadBody();
+
+protected:
+	virtual void		ProcessHeader(const char* szLine);
+
+public:
+						WebDownloader();
+						~WebDownloader();
+	EStatus				GetStatus() { return m_eStatus; }
+	virtual void		Run();
+	virtual void		Stop();
+	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				LogDebugInfo();
+};
+
+#endif

WebServer.cpp

@@ -0,0 +1,485 @@
+/*
+ *  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$
+ *
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef WIN32
+#include "win32.h"
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#ifndef WIN32
+#include <unistd.h>
+#endif
+
+#include "nzbget.h"
+#include "WebServer.h"
+#include "XmlRpc.h"
+#include "Log.h"
+#include "Options.h"
+#include "Util.h"
+
+extern Options* g_pOptions;
+
+static const char* ERR_HTTP_BAD_REQUEST = "400 Bad Request";
+static const char* ERR_HTTP_NOT_FOUND = "404 Not Found";
+static const char* ERR_HTTP_SERVICE_UNAVAILABLE = "503 Service Unavailable";
+
+static const int MAX_UNCOMPRESSED_SIZE = 500;
+
+//*****************************************************************
+// WebProcessor
+
+WebProcessor::WebProcessor()
+{
+	m_pConnection = NULL;
+	m_szRequest = NULL;
+	m_szUrl = NULL;
+	m_szOrigin = NULL;
+}
+
+WebProcessor::~WebProcessor()
+{
+	if (m_szRequest)
+	{
+		free(m_szRequest);
+	}
+	if (m_szUrl)
+	{
+		free(m_szUrl);
+	}
+	if (m_szOrigin)
+	{
+		free(m_szOrigin);
+	}
+}
+
+void WebProcessor::SetUrl(const char* szUrl)
+{
+	m_szUrl = strdup(szUrl);
+}
+
+void WebProcessor::Execute()
+{
+	m_bGZip =false;
+	char szAuthInfo[1024];
+	szAuthInfo[0] = '\0';
+
+	// reading http header
+	char szBuffer[1024];
+	int iContentLen = 0;
+	while (char* p = m_pConnection->ReadLine(szBuffer, sizeof(szBuffer), NULL))
+	{
+		if (char* pe = strrchr(p, '\r')) *pe = '\0';
+		debug("header=%s", p);
+		if (!strncasecmp(p, "Content-Length: ", 16))
+		{
+			iContentLen = atoi(p + 16);
+		}
+		if (!strncasecmp(p, "Authorization: Basic ", 21))
+		{
+			char* szAuthInfo64 = p + 21;
+			if (strlen(szAuthInfo64) > sizeof(szAuthInfo))
+			{
+				error("Invalid-request: auth-info too big");
+				return;
+			}
+			szAuthInfo[WebUtil::DecodeBase64(szAuthInfo64, 0, szAuthInfo)] = '\0';
+		}
+		if (!strncasecmp(p, "Accept-Encoding: ", 17))
+		{
+			m_bGZip = strstr(p, "gzip");
+		}
+		if (!strncasecmp(p, "Origin: ", 8))
+		{
+			m_szOrigin = strdup(p + 8);
+		}
+		if (*p == '\0')
+		{
+			break;
+		}
+	}
+
+	debug("URL=%s", m_szUrl);
+	debug("Authorization=%s", szAuthInfo);
+
+	if (m_eHttpMethod == hmPost && iContentLen <= 0)
+	{
+		error("Invalid-request: content length is 0");
+		return;
+	}
+
+	if (m_eHttpMethod == hmOptions)
+	{
+		SendOptionsResponse();
+		return;
+	}
+
+	// remove subfolder "nzbget" from the path (if exists)
+	// http://localhost:6789/nzbget/username:password/jsonrpc -> http://localhost:6789/username:password/jsonrpc
+	if (!strncmp(m_szUrl, "/nzbget/", 8))
+	{
+		char* sz_OldUrl = m_szUrl;
+		m_szUrl = strdup(m_szUrl + 7);
+		free(sz_OldUrl);
+	}
+	// http://localhost:6789/nzbget -> http://localhost:6789
+	if (!strcmp(m_szUrl, "/nzbget"))
+	{
+		char szRedirectURL[1024];
+		snprintf(szRedirectURL, 1024, "%s/", m_szUrl);
+		szRedirectURL[1024-1] = '\0';
+		SendRedirectResponse(szRedirectURL);
+		return;
+	}
+
+	// authorization via URL in format:
+	// http://localhost:6789/username:password/jsonrpc
+	char* pauth1 = strchr(m_szUrl + 1, ':');
+	char* pauth2 = strchr(m_szUrl + 1, '/');
+	if (pauth1 && pauth1 < pauth2)
+	{
+		char* pstart = m_szUrl + 1;
+		int iLen = 0;
+		char* pend = strchr(pstart + 1, '/');
+		if (pend) 
+		{
+			iLen = (int)(pend - pstart < (int)sizeof(szAuthInfo) - 1 ? pend - pstart : (int)sizeof(szAuthInfo) - 1);
+		}
+		else
+		{
+			iLen = strlen(pstart);
+		}
+		strncpy(szAuthInfo, pstart, iLen);
+		szAuthInfo[iLen] = '\0';
+		char* sz_OldUrl = m_szUrl;
+		m_szUrl = strdup(pend);
+		free(sz_OldUrl);
+	}
+
+	debug("Final URL=%s", m_szUrl);
+
+	if (strlen(g_pOptions->GetControlPassword()) > 0)
+	{
+		if (strlen(szAuthInfo) == 0)
+		{
+			SendAuthResponse();
+			return;
+		}
+
+		// Authorization
+		char* pw = strchr(szAuthInfo, ':');
+		if (pw) *pw++ = '\0';
+		if ((strlen(g_pOptions->GetControlUsername()) > 0 && strcmp(szAuthInfo, g_pOptions->GetControlUsername())) ||
+			strcmp(pw, g_pOptions->GetControlPassword()))
+		{
+			warn("Request received on port %i from %s, but username or password invalid (%s:%s)",
+				g_pOptions->GetControlPort(), m_pConnection->GetRemoteAddr(), szAuthInfo, pw);
+			SendAuthResponse();
+			return;
+		}
+	}
+
+	if (m_eHttpMethod == hmPost)
+	{
+		// reading http body (request content)
+		m_szRequest = (char*)malloc(iContentLen + 1);
+		m_szRequest[iContentLen] = '\0';
+		
+		if (!m_pConnection->Recv(m_szRequest, iContentLen))
+		{
+			error("Invalid-request: could not read data");
+			return;
+		}
+		debug("Request=%s", m_szRequest);
+	}
+	
+	debug("request received from %s", m_pConnection->GetRemoteAddr());
+
+	Dispatch();
+}
+
+void WebProcessor::Dispatch()
+{
+	if (*m_szUrl != '/')
+	{
+		SendErrorResponse(ERR_HTTP_BAD_REQUEST);
+		return;
+	}
+
+	if (XmlRpcProcessor::IsRpcRequest(m_szUrl))
+	{
+		XmlRpcProcessor processor;
+		processor.SetRequest(m_szRequest);
+		processor.SetHttpMethod(m_eHttpMethod == hmGet ? XmlRpcProcessor::hmGet : XmlRpcProcessor::hmPost);
+		processor.SetUrl(m_szUrl);
+		processor.Execute();
+		SendBodyResponse(processor.GetResponse(), strlen(processor.GetResponse()), processor.GetContentType()); 
+		return;
+	}
+
+	if (!g_pOptions->GetWebDir() || strlen(g_pOptions->GetWebDir()) == 0)
+	{
+		SendErrorResponse(ERR_HTTP_SERVICE_UNAVAILABLE);
+		return;
+	}
+	
+	if (m_eHttpMethod != hmGet)
+	{
+		SendErrorResponse(ERR_HTTP_BAD_REQUEST);
+		return;
+	}
+	
+	// for security reasons we allow only characters "0..9 A..Z a..z . - _ /" in the URLs
+	// we also don't allow ".." in the URLs
+	for (char *p = m_szUrl; *p; p++)
+	{
+		if (!((*p >= '0' && *p <= '9') || (*p >= 'A' && *p <= 'Z') || (*p >= 'a' && *p <= 'z') ||
+			*p == '.' || *p == '-' || *p == '_' || *p == '/') || (*p == '.' && p[1] == '.'))
+		{
+			SendErrorResponse(ERR_HTTP_NOT_FOUND);
+			return;
+		}
+	}
+
+	const char *szDefRes = "";
+	if (m_szUrl[strlen(m_szUrl)-1] == '/')
+	{
+		// default file in directory (if not specified) is "index.html"
+		szDefRes = "index.html";
+	}
+
+	char disk_filename[1024];
+	snprintf(disk_filename, sizeof(disk_filename), "%s%s%s", g_pOptions->GetWebDir(), m_szUrl + 1, szDefRes);
+
+	disk_filename[sizeof(disk_filename)-1] = '\0';
+
+	SendFileResponse(disk_filename);
+}
+
+void WebProcessor::SendAuthResponse()
+{
+	const char* AUTH_RESPONSE_HEADER =
+		"HTTP/1.0 401 Unauthorized\r\n"
+		"WWW-Authenticate: Basic realm=\"NZBGet\"\r\n"
+		"Connection: close\r\n"
+		"Content-Type: text/plain\r\n"
+		"Server: nzbget-%s\r\n"
+		"\r\n";
+	char szResponseHeader[1024];
+	snprintf(szResponseHeader, 1024, AUTH_RESPONSE_HEADER, Util::VersionRevision());
+	 
+	// Send the response answer
+	debug("ResponseHeader=%s", szResponseHeader);
+	m_pConnection->Send(szResponseHeader, strlen(szResponseHeader));
+}
+
+void WebProcessor::SendOptionsResponse()
+{
+	const char* OPTIONS_RESPONSE_HEADER =
+		"HTTP/1.1 200 OK\r\n"
+		"Connection: close\r\n"
+		//"Content-Type: plain/text\r\n"
+		"Access-Control-Allow-Methods: GET, POST, OPTIONS\r\n"
+		"Access-Control-Allow-Origin: %s\r\n"
+		"Access-Control-Allow-Credentials: true\r\n"
+		"Access-Control-Max-Age: 86400\r\n"
+		"Access-Control-Allow-Headers: Content-Type, Authorization\r\n"
+		"Server: nzbget-%s\r\n"
+		"\r\n";
+	char szResponseHeader[1024];
+	snprintf(szResponseHeader, 1024, OPTIONS_RESPONSE_HEADER, 
+		m_szOrigin ? m_szOrigin : "",
+		Util::VersionRevision());
+	 
+	// Send the response answer
+	debug("ResponseHeader=%s", szResponseHeader);
+	m_pConnection->Send(szResponseHeader, strlen(szResponseHeader));
+}
+
+void WebProcessor::SendErrorResponse(const char* szErrCode)
+{
+	const char* RESPONSE_HEADER = 
+		"HTTP/1.0 %s\r\n"
+		"Connection: close\r\n"
+		"Content-Length: %i\r\n"
+		"Content-Type: text/html\r\n"
+		"Server: nzbget-%s\r\n"
+		"\r\n";
+
+	warn("Web-Server: %s, Resource: %s", szErrCode, m_szUrl);
+
+	char szResponseBody[1024];
+	snprintf(szResponseBody, 1024, "<html><head><title>%s</title></head><body>Error: %s</body></html>", szErrCode, szErrCode);
+	int iPageContentLen = strlen(szResponseBody);
+
+	char szResponseHeader[1024];
+	snprintf(szResponseHeader, 1024, RESPONSE_HEADER, szErrCode, iPageContentLen, Util::VersionRevision());
+
+	// Send the response answer
+	m_pConnection->Send(szResponseHeader, strlen(szResponseHeader));
+	m_pConnection->Send(szResponseBody, iPageContentLen);
+}
+
+void WebProcessor::SendRedirectResponse(const char* szURL)
+{
+	const char* REDIRECT_RESPONSE_HEADER =
+		"HTTP/1.0 301 Moved Permanently\r\n"
+		"Location: %s\r\n"
+		"Connection: close\r\n"
+		"Server: nzbget-%s\r\n"
+		"\r\n";
+	char szResponseHeader[1024];
+	snprintf(szResponseHeader, 1024, REDIRECT_RESPONSE_HEADER, szURL, Util::VersionRevision());
+	 
+	// Send the response answer
+	debug("ResponseHeader=%s", szResponseHeader);
+	m_pConnection->Send(szResponseHeader, strlen(szResponseHeader));
+}
+
+void WebProcessor::SendBodyResponse(const char* szBody, int iBodyLen, const char* szContentType)
+{
+	const char* RESPONSE_HEADER = 
+		"HTTP/1.1 200 OK\r\n"
+		"Connection: close\r\n"
+		"Access-Control-Allow-Methods: GET, POST, OPTIONS\r\n"
+		"Access-Control-Allow-Origin: %s\r\n"
+		"Access-Control-Allow-Credentials: true\r\n"
+		"Access-Control-Max-Age: 86400\r\n"
+		"Access-Control-Allow-Headers: Content-Type, Authorization\r\n"
+		"Content-Length: %i\r\n"
+		"%s"					// Content-Type: xxx
+		"%s"					// Content-Encoding: gzip
+		"Server: nzbget-%s\r\n"
+		"\r\n";
+	
+#ifndef DISABLE_GZIP
+	char *szGBuf = NULL;
+	bool bGZip = m_bGZip && iBodyLen > MAX_UNCOMPRESSED_SIZE;
+	if (bGZip)
+	{
+		unsigned int iOutLen = ZLib::GZipLen(iBodyLen);
+		szGBuf = (char*)malloc(iOutLen);
+		int iGZippedLen = ZLib::GZip(szBody, iBodyLen, szGBuf, iOutLen);
+		if (iGZippedLen > 0 && iGZippedLen < iBodyLen)
+		{
+			szBody = szGBuf;
+			iBodyLen = iGZippedLen;
+		}
+		else
+		{
+			free(szGBuf);
+			szGBuf = NULL;
+			bGZip = false;
+		}
+	}
+#else
+	bool bGZip = false;
+#endif
+	
+	char szContentTypeHeader[1024];
+	if (szContentType)
+	{
+		snprintf(szContentTypeHeader, 1024, "Content-Type: %s\r\n", szContentType);
+	}
+	else
+	{
+		szContentTypeHeader[0] = '\0';
+	}
+	
+	char szResponseHeader[1024];
+	snprintf(szResponseHeader, 1024, RESPONSE_HEADER, 
+		m_szOrigin ? m_szOrigin : "",
+		iBodyLen, szContentTypeHeader,
+		bGZip ? "Content-Encoding: gzip\r\n" : "",
+		Util::VersionRevision());
+	
+	// Send the request answer
+	m_pConnection->Send(szResponseHeader, strlen(szResponseHeader));
+	m_pConnection->Send(szBody, iBodyLen);
+	
+#ifndef DISABLE_GZIP
+	if (szGBuf)
+	{
+		free(szGBuf);
+	}
+#endif
+}
+
+void WebProcessor::SendFileResponse(const char* szFilename)
+{
+	debug("serving file: %s", szFilename);
+
+	char *szBody;
+	int iBodyLen;
+	if (!Util::LoadFileIntoBuffer(szFilename, &szBody, &iBodyLen))
+	{
+		SendErrorResponse(ERR_HTTP_NOT_FOUND);
+		return;
+	}
+	
+	// "LoadFileIntoBuffer" adds a trailing NULL, which we don't need here
+	iBodyLen--;
+	
+	SendBodyResponse(szBody, iBodyLen, DetectContentType(szFilename));
+
+	free(szBody);
+}
+
+const char* WebProcessor::DetectContentType(const char* szFilename)
+{
+	if (const char *szExt = strrchr(szFilename, '.'))
+	{
+		if (!strcasecmp(szExt, ".css"))
+		{
+			return "text/css";
+		}
+		else if (!strcasecmp(szExt, ".html"))
+		{
+			return "text/html";
+		}
+		else if (!strcasecmp(szExt, ".js"))
+		{
+			return "application/javascript";
+		}
+		else if (!strcasecmp(szExt, ".png"))
+		{
+			return "image/png";
+		}
+		else if (!strcasecmp(szExt, ".jpeg"))
+		{
+			return "image/jpeg";
+		}
+		else if (!strcasecmp(szExt, ".gif"))
+		{
+			return "image/gif";
+		}
+	}
+	return NULL;
+}

WebServer.h

@@ -0,0 +1,67 @@
+/*
+ *  This file is part of nzbget
+ *
+ *  Copyright (C) 2012 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 WEBSERVER_H
+#define WEBSERVER_H
+
+#include "Connection.h"
+
+class WebProcessor
+{
+public:
+	enum EHttpMethod
+	{
+		hmPost,
+		hmGet,
+		hmOptions
+	};
+
+private:
+	Connection*			m_pConnection;
+	char*				m_szRequest;
+	char*				m_szUrl;
+	EHttpMethod			m_eHttpMethod;
+	bool				m_bGZip;
+	char*				m_szOrigin;
+
+	void				Dispatch();
+	void				SendAuthResponse();
+	void				SendOptionsResponse();
+	void				SendErrorResponse(const char* szErrCode);
+	void				SendFileResponse(const char* szFilename);
+	void				SendBodyResponse(const char* szBody, int iBodyLen, const char* szContentType);
+	void				SendRedirectResponse(const char* szURL);
+	const char*			DetectContentType(const char* szFilename);
+
+public:
+						WebProcessor();
+						~WebProcessor();
+	void				Execute();
+	void				SetConnection(Connection* pConnection) { m_pConnection = pConnection; }
+	void				SetUrl(const char* szUrl);
+	void				SetHttpMethod(EHttpMethod eHttpMethod) { m_eHttpMethod = eHttpMethod; }
+};
+
+#endif

XmlRpc.h

@@ -0,0 +1,281 @@
+/*
+ *  This file is part of nzbget
+ *
+ *  Copyright (C) 2007-2010 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 XMLRPC_H
+#define XMLRPC_H
+
+#include "Connection.h"
+#include "Util.h"
+
+class XmlCommand;
+
+class XmlRpcProcessor
+{
+public:
+	enum ERpcProtocol
+	{
+		rpUndefined,
+		rpXmlRpc,
+		rpJsonRpc,
+		rpJsonPRpc
+	};
+
+	enum EHttpMethod
+	{
+		hmPost,
+		hmGet
+	};
+
+private:
+	char*				m_szRequest;
+	const char*			m_szContentType;
+	ERpcProtocol		m_eProtocol;
+	EHttpMethod			m_eHttpMethod;
+	char*				m_szUrl;
+	StringBuilder		m_cResponse;
+
+	void				Dispatch();
+	XmlCommand*			CreateCommand(const char* szMethodName);
+	void				MutliCall();
+	void				BuildResponse(const char* szResponse, const char* szCallbackFunc, bool bFault);
+
+public:
+						XmlRpcProcessor();
+						~XmlRpcProcessor();
+	void				Execute();
+	void				SetHttpMethod(EHttpMethod eHttpMethod) { m_eHttpMethod = eHttpMethod; }
+	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);
+};
+
+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;
+
+	void				BuildErrorResponse(int iErrCode, const char* szErrText, ...);
+	void				BuildBoolResponse(bool bOK);
+	void				AppendResponse(const char* szPart);
+	bool				IsJson();
+	bool				CheckSafeMethod();
+	bool				NextParamAsInt(int* iValue);
+	bool				NextParamAsBool(bool* bValue);
+	bool				NextParamAsStr(char** szValueBuf);
+	const char*			BoolToStr(bool bValue);
+	char*				EncodeStr(const char* szStr);
+	void				DecodeStr(char* szStr);
+
+public:
+						XmlCommand();
+	virtual 			~XmlCommand() {}
+	virtual void		Execute() = 0;
+	void				PrepareParams();
+	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; }
+	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 PauseUnpauseXmlCommand: public XmlCommand
+{
+public:
+	enum EPauseAction
+	{
+		paDownload,
+		paDownload2,
+		paPostProcess,
+		paScan
+	};
+
+private:
+	bool			m_bPause;
+	EPauseAction	m_eEPauseAction;
+
+public:
+						PauseUnpauseXmlCommand(bool bPause, EPauseAction eEPauseAction);
+	virtual void		Execute();
+};
+
+class ScheduleResumeXmlCommand: public XmlCommand
+{
+public:
+	virtual void		Execute();
+};
+
+class ShutdownXmlCommand: public XmlCommand
+{
+public:
+	virtual void		Execute();
+};
+
+class ReloadXmlCommand: 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();
+};
+
+class ClearLogXmlCommand: public XmlCommand
+{
+public:
+	virtual void		Execute();
+};
+
+class ScanXmlCommand: public XmlCommand
+{
+public:
+	virtual void		Execute();
+};
+
+class HistoryXmlCommand: public XmlCommand
+{
+public:
+	virtual void		Execute();
+};
+
+class DownloadUrlXmlCommand: public XmlCommand
+{
+public:
+	virtual void		Execute();
+};
+
+class UrlQueueXmlCommand: public XmlCommand
+{
+public:
+	virtual void		Execute();
+};
+
+class ConfigXmlCommand: public XmlCommand
+{
+public:
+	virtual void		Execute();
+};
+
+class LoadConfigXmlCommand: public XmlCommand
+{
+public:
+	virtual void		Execute();
+};
+
+class SaveConfigXmlCommand: public XmlCommand
+{
+public:
+	virtual void		Execute();
+};
+
+class ConfigTemplatesXmlCommand: public XmlCommand
+{
+public:
+	virtual void		Execute();
+};
+
+#endif

config.h.in

@@ -9,18 +9,12 @@
 /* Define to 1 to disable gzip-support */
 #undef DISABLE_GZIP
 
-/* Define to 1 to not use libxml2, only for development purposes */
-#undef DISABLE_LIBXML2
-
-/* 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
@@ -37,21 +31,6 @@
 /* Define to 1 if you have the <curses.h> header file. */
 #undef HAVE_CURSES_H
 
-/* define if the compiler supports basic C++14 syntax */
-#undef HAVE_CXX14
-
-/* 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
 
@@ -67,12 +46,6 @@
 /* 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
 
@@ -82,9 +55,6 @@
 /* Define to 1 to use GnuTLS library for TLS/SSL-support. */
 #undef HAVE_LIBGNUTLS
 
-/* Define to 1 if lockf is supported */
-#undef HAVE_LOCKF
-
 /* Define to 1 if you have the <memory.h> header file. */
 #undef HAVE_MEMORY_H
 
@@ -94,20 +64,20 @@
 /* Define to 1 if you have the <ncurses/ncurses.h> header file. */
 #undef HAVE_NCURSES_NCURSES_H
 
-/* Define to 1 to use Nettle library for decryption. */
-#undef HAVE_NETTLE
-
-/* Define to 1 to use OpenSSL library for TLS/SSL-support and decryption. */
+/* Define to 1 to use OpenSSL library for TLS/SSL-support. */
 #undef HAVE_OPENSSL
 
-/* Define to 1 if pthread_cancel is supported */
-#undef HAVE_PTHREAD_CANCEL
+/* Define to 1 if libpar2 has recent bugfixes-patch (version 2) */
+#undef HAVE_PAR2_BUGFIXES_V2
+
+/* Define to 1 if libpar2 supports cancelling (needs a special patch) */
+#undef HAVE_PAR2_CANCEL
 
 /* Define to 1 if you have the <regex.h> header file. */
 #undef HAVE_REGEX_H
 
-/* Define to 1 if _SC_NPROCESSORS_ONLN is present in unistd.h */
-#undef HAVE_SC_NPROCESSORS_ONLN
+/* Define to 1 if spinlocks are supported */
+#undef HAVE_SPINLOCK
 
 /* Define to 1 if you have the <stdint.h> header file. */
 #undef HAVE_STDINT_H
@@ -115,9 +85,6 @@
 /* Define to 1 if you have the <stdlib.h> header file. */
 #undef HAVE_STDLIB_H
 
-/* 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
 
@@ -139,12 +106,6 @@
 /* Define to 1 if variadic macros are supported */
 #undef HAVE_VARIADIC_MACROS
 
-/* Define to 1 if OpenSSL supports function "X509_check_host". */
-#undef HAVE_X509_CHECK_HOST
-
-/* Define to 1 to exclude debug-code */
-#undef NDEBUG
-
 /* Name of package */
 #undef PACKAGE
 
@@ -160,9 +121,6 @@
 /* Define to the one symbol short name of this package. */
 #undef PACKAGE_TARNAME
 
-/* Define to the home page for this package. */
-#undef PACKAGE_URL
-
 /* Define to the version of this package. */
 #undef PACKAGE_VERSION
 
@@ -178,19 +136,8 @@
 /* Version number of package */
 #undef VERSION
 
-/* Enable large inode numbers on Mac OS X 10.5.  */
-#ifndef _DARWIN_USE_64_BIT_INODE
-# define _DARWIN_USE_64_BIT_INODE 1
-#endif
-
 /* 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 `unsigned int' if <sys/types.h> does not define. */
-#undef size_t

config.sub

@@ -1,40 +1,44 @@
 #! /bin/sh
 # Configuration validation subroutine script.
-#   Copyright 1992-2014 Free Software Foundation, Inc.
+#   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
+#   2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation,
+#   Inc.
 
-timestamp='2014-12-03'
+timestamp='2006-09-20'
 
-# This file 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 3 of the License, or
+# This file is (in principle) common to ALL GNU software.
+# The presence of a machine in this file suggests that SOME GNU software
+# can handle that machine.  It does not imply ALL GNU software can.
+#
+# This file 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.
+# 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, see <http://www.gnu.org/licenses/>.
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
+# 02110-1301, USA.
 #
 # As a special exception to the GNU General Public License, if you
 # distribute this file as part of a program that contains a
 # configuration script generated by Autoconf, you may include it under
-# the same distribution terms that you use for the rest of that
-# program.  This Exception is an additional permission under section 7
-# of the GNU General Public License, version 3 ("GPLv3").
+# the same distribution terms that you use for the rest of that program.
 
 
-# Please send patches to <config-patches@gnu.org>.
+# Please send patches to <config-patches@gnu.org>.  Submit a context
+# diff and a properly formatted ChangeLog entry.
 #
 # Configuration subroutine to validate and canonicalize a configuration type.
 # Supply the specified configuration type as an argument.
 # If it is invalid, we print an error message on stderr and exit with code 1.
 # Otherwise, we print the canonical config type on stdout and succeed.
 
-# You can get the latest version of this script from:
-# http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub;hb=HEAD
-
 # This file is supposed to be the same for all GNU packages
 # and recognize all the CPU types, system types and aliases
 # that are meaningful with *any* GNU software.
@@ -68,7 +72,8 @@ Report bugs and patches to <config-patches@gnu.org>."
 version="\
 GNU config.sub ($timestamp)
 
-Copyright 1992-2014 Free Software Foundation, Inc.
+Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
+Free Software Foundation, Inc.
 
 This is free software; see the source for copying conditions.  There is NO
 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
@@ -115,18 +120,12 @@ esac
 # Here we must recognize all the valid KERNEL-OS combinations.
 maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'`
 case $maybe_os in
-  nto-qnx* | linux-gnu* | linux-android* | linux-dietlibc | linux-newlib* | \
-  linux-musl* | linux-uclibc* | uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | \
-  knetbsd*-gnu* | netbsd*-gnu* | \
-  kopensolaris*-gnu* | \
+  nto-qnx* | linux-gnu* | linux-dietlibc | linux-newlib* | linux-uclibc* | \
+  uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | knetbsd*-gnu* | netbsd*-gnu* | \
   storm-chaos* | os2-emx* | rtmk-nova*)
     os=-$maybe_os
     basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`
     ;;
-  android-linux)
-    os=-linux-android
-    basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`-unknown
-    ;;
   *)
     basic_machine=`echo $1 | sed 's/-[^-]*$//'`
     if [ $basic_machine != $1 ]
@@ -149,13 +148,10 @@ case $os in
 	-convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\
 	-c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \
 	-harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \
-	-apple | -axis | -knuth | -cray | -microblaze*)
+	-apple | -axis | -knuth | -cray)
 		os=
 		basic_machine=$1
 		;;
-	-bluegene*)
-		os=-cnk
-		;;
 	-sim | -cisco | -oki | -wec | -winbond)
 		os=
 		basic_machine=$1
@@ -170,10 +166,10 @@ case $os in
 		os=-chorusos
 		basic_machine=$1
 		;;
-	-chorusrdb)
-		os=-chorusrdb
+ 	-chorusrdb)
+ 		os=-chorusrdb
 		basic_machine=$1
-		;;
+ 		;;
 	-hiux*)
 		os=-hiuxwe2
 		;;
@@ -218,12 +214,6 @@ case $os in
 	-isc*)
 		basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'`
 		;;
-	-lynx*178)
-		os=-lynxos178
-		;;
-	-lynx*5)
-		os=-lynxos5
-		;;
 	-lynx*)
 		os=-lynxos
 		;;
@@ -248,90 +238,59 @@ case $basic_machine in
 	# Some are omitted here because they have special meanings below.
 	1750a | 580 \
 	| a29k \
-	| aarch64 | aarch64_be \
 	| alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \
 	| alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \
 	| am33_2.0 \
-	| arc | arceb \
-	| arm | arm[bl]e | arme[lb] | armv[2-8] | armv[3-8][lb] | armv7[arm] \
-	| avr | avr32 \
-	| be32 | be64 \
+	| arc | arm | arm[bl]e | arme[lb] | armv[2345] | armv[345][lb] | avr | avr32 \
 	| bfin \
-	| c4x | c8051 | clipper \
+	| c4x | clipper \
 	| d10v | d30v | dlx | dsp16xx \
-	| epiphany \
-	| fido | fr30 | frv \
+	| fr30 | frv \
 	| h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \
-	| hexagon \
 	| i370 | i860 | i960 | ia64 \
 	| ip2k | iq2000 \
-	| k1om \
-	| le32 | le64 \
-	| lm32 \
 	| m32c | m32r | m32rle | m68000 | m68k | m88k \
-	| maxq | mb | microblaze | microblazeel | mcore | mep | metag \
+	| maxq | mb | microblaze | mcore \
 	| mips | mipsbe | mipseb | mipsel | mipsle \
 	| mips16 \
 	| mips64 | mips64el \
-	| mips64octeon | mips64octeonel \
-	| mips64orion | mips64orionel \
-	| mips64r5900 | mips64r5900el \
 	| mips64vr | mips64vrel \
+	| mips64orion | mips64orionel \
 	| mips64vr4100 | mips64vr4100el \
 	| mips64vr4300 | mips64vr4300el \
 	| mips64vr5000 | mips64vr5000el \
 	| mips64vr5900 | mips64vr5900el \
 	| mipsisa32 | mipsisa32el \
 	| mipsisa32r2 | mipsisa32r2el \
-	| mipsisa32r6 | mipsisa32r6el \
 	| mipsisa64 | mipsisa64el \
 	| mipsisa64r2 | mipsisa64r2el \
-	| mipsisa64r6 | mipsisa64r6el \
 	| mipsisa64sb1 | mipsisa64sb1el \
 	| mipsisa64sr71k | mipsisa64sr71kel \
-	| mipsr5900 | mipsr5900el \
 	| mipstx39 | mipstx39el \
 	| mn10200 | mn10300 \
-	| moxie \
 	| mt \
 	| msp430 \
-	| nds32 | nds32le | nds32be \
-	| nios | nios2 | nios2eb | nios2el \
+	| nios | nios2 \
 	| ns16k | ns32k \
-	| open8 | or1k | or1knd | or32 \
+	| or32 \
 	| pdp10 | pdp11 | pj | pjl \
-	| powerpc | powerpc64 | powerpc64le | powerpcle \
+	| powerpc | powerpc64 | powerpc64le | powerpcle | ppcbe \
 	| pyramid \
-	| riscv32 | riscv64 \
-	| rl78 | rx \
 	| score \
-	| sh | sh[1234] | sh[24]a | sh[24]aeb | sh[23]e | sh[34]eb | sheb | shbe | shle | sh[1234]le | sh3ele \
+	| sh | sh[1234] | sh[24]a | sh[23]e | sh[34]eb | sheb | shbe | shle | sh[1234]le | sh3ele \
 	| sh64 | sh64le \
 	| sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet | sparclite \
 	| sparcv8 | sparcv9 | sparcv9b | sparcv9v \
-	| spu \
-	| tahoe | tic4x | tic54x | tic55x | tic6x | tic80 | tron \
-	| ubicom32 \
-	| v850 | v850e | v850e1 | v850e2 | v850es | v850e2v3 \
-	| visium \
+	| spu | strongarm \
+	| tahoe | thumb | tic4x | tic80 | tron \
+	| v850 | v850e \
 	| we32k \
-	| x86 | xc16x | xstormy16 | xtensa \
-	| z8k | z80)
+	| x86 | xc16x | xscale | xscalee[bl] | xstormy16 | xtensa \
+	| z8k)
 		basic_machine=$basic_machine-unknown
 		;;
-	c54x)
-		basic_machine=tic54x-unknown
-		;;
-	c55x)
-		basic_machine=tic55x-unknown
-		;;
-	c6x)
-		basic_machine=tic6x-unknown
-		;;
-	leon|leon[3-9])
-		basic_machine=sparc-$basic_machine
-		;;
-	m6811 | m68hc11 | m6812 | m68hc12 | m68hcs12x | nvptx | picochip)
+	m6811 | m68hc11 | m6812 | m68hc12)
+		# Motorola 68HC11/12.
 		basic_machine=$basic_machine-unknown
 		os=-none
 		;;
@@ -341,21 +300,6 @@ case $basic_machine in
 		basic_machine=mt-unknown
 		;;
 
-	strongarm | thumb | xscale)
-		basic_machine=arm-unknown
-		;;
-	xgate)
-		basic_machine=$basic_machine-unknown
-		os=-none
-		;;
-	xscaleeb)
-		basic_machine=armeb-unknown
-		;;
-
-	xscaleel)
-		basic_machine=armel-unknown
-		;;
-
 	# We use `pc' rather than `unknown'
 	# because (1) that's what they normally are, and
 	# (2) the word "unknown" tends to confuse beginning users.
@@ -370,87 +314,64 @@ case $basic_machine in
 	# Recognize the basic CPU types with company name.
 	580-* \
 	| a29k-* \
-	| aarch64-* | aarch64_be-* \
 	| alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \
 	| alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \
-	| alphapca5[67]-* | alpha64pca5[67]-* | arc-* | arceb-* \
+	| alphapca5[67]-* | alpha64pca5[67]-* | arc-* \
 	| arm-*  | armbe-* | armle-* | armeb-* | armv*-* \
 	| avr-* | avr32-* \
-	| be32-* | be64-* \
 	| bfin-* | bs2000-* \
-	| c[123]* | c30-* | [cjt]90-* | c4x-* \
-	| c8051-* | clipper-* | craynv-* | cydra-* \
+	| c[123]* | c30-* | [cjt]90-* | c4x-* | c54x-* | c55x-* | c6x-* \
+	| clipper-* | craynv-* | cydra-* \
 	| d10v-* | d30v-* | dlx-* \
 	| elxsi-* \
-	| f30[01]-* | f700-* | fido-* | fr30-* | frv-* | fx80-* \
+	| f30[01]-* | f700-* | fr30-* | frv-* | fx80-* \
 	| h8300-* | h8500-* \
 	| hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \
-	| hexagon-* \
 	| i*86-* | i860-* | i960-* | ia64-* \
 	| ip2k-* | iq2000-* \
-	| k1om-* \
-	| le32-* | le64-* \
-	| lm32-* \
 	| m32c-* | m32r-* | m32rle-* \
 	| m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \
-	| m88110-* | m88k-* | maxq-* | mcore-* | metag-* \
-	| microblaze-* | microblazeel-* \
+	| m88110-* | m88k-* | maxq-* | mcore-* \
 	| mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \
 	| mips16-* \
 	| mips64-* | mips64el-* \
-	| mips64octeon-* | mips64octeonel-* \
-	| mips64orion-* | mips64orionel-* \
-	| mips64r5900-* | mips64r5900el-* \
 	| mips64vr-* | mips64vrel-* \
+	| mips64orion-* | mips64orionel-* \
 	| mips64vr4100-* | mips64vr4100el-* \
 	| mips64vr4300-* | mips64vr4300el-* \
 	| mips64vr5000-* | mips64vr5000el-* \
 	| mips64vr5900-* | mips64vr5900el-* \
 	| mipsisa32-* | mipsisa32el-* \
 	| mipsisa32r2-* | mipsisa32r2el-* \
-	| mipsisa32r6-* | mipsisa32r6el-* \
 	| mipsisa64-* | mipsisa64el-* \
 	| mipsisa64r2-* | mipsisa64r2el-* \
-	| mipsisa64r6-* | mipsisa64r6el-* \
 	| mipsisa64sb1-* | mipsisa64sb1el-* \
 	| mipsisa64sr71k-* | mipsisa64sr71kel-* \
-	| mipsr5900-* | mipsr5900el-* \
 	| mipstx39-* | mipstx39el-* \
 	| mmix-* \
 	| mt-* \
 	| msp430-* \
-	| nds32-* | nds32le-* | nds32be-* \
-	| nios-* | nios2-* | nios2eb-* | nios2el-* \
+	| nios-* | nios2-* \
 	| none-* | np1-* | ns16k-* | ns32k-* \
-	| open8-* \
-	| or1k*-* \
 	| orion-* \
 	| pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \
-	| powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* \
+	| powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* | ppcbe-* \
 	| pyramid-* \
-	| rl78-* | romp-* | rs6000-* | rx-* \
-	| sh-* | sh[1234]-* | sh[24]a-* | sh[24]aeb-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \
+	| romp-* | rs6000-* \
+	| sh-* | sh[1234]-* | sh[24]a-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \
 	| shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \
 	| sparc-* | sparc64-* | sparc64b-* | sparc64v-* | sparc86x-* | sparclet-* \
 	| sparclite-* \
-	| sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | sv1-* | sx?-* \
-	| tahoe-* \
+	| sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | strongarm-* | sv1-* | sx?-* \
+	| tahoe-* | thumb-* \
 	| tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \
-	| tile*-* \
 	| tron-* \
-	| ubicom32-* \
-	| v850-* | v850e-* | v850e1-* | v850es-* | v850e2-* | v850e2v3-* \
-	| vax-* \
-	| visium-* \
+	| v850-* | v850e-* | vax-* \
 	| we32k-* \
-	| x86-* | x86_64-* | xc16x-* | xps100-* \
-	| xstormy16-* | xtensa*-* \
+	| x86-* | x86_64-* | xc16x-* | xps100-* | xscale-* | xscalee[bl]-* \
+	| xstormy16-* | xtensa-* \
 	| ymp-* \
-	| z8k-* | z80-*)
-		;;
-	# Recognize the basic CPU types without company name, with glob match.
-	xtensa*)
-		basic_machine=$basic_machine-unknown
+	| z8k-*)
 		;;
 	# Recognize the various machine names and aliases which stand
 	# for a CPU type and a company and sometimes even an OS.
@@ -468,7 +389,7 @@ case $basic_machine in
 		basic_machine=a29k-amd
 		os=-udi
 		;;
-	abacus)
+    	abacus)
 		basic_machine=abacus-unknown
 		;;
 	adobe68k)
@@ -514,10 +435,6 @@ case $basic_machine in
 		basic_machine=m68k-apollo
 		os=-bsd
 		;;
-	aros)
-		basic_machine=i386-pc
-		os=-aros
-		;;
 	aux)
 		basic_machine=m68k-apple
 		os=-aux
@@ -526,35 +443,10 @@ case $basic_machine in
 		basic_machine=ns32k-sequent
 		os=-dynix
 		;;
-	blackfin)
-		basic_machine=bfin-unknown
-		os=-linux
-		;;
-	blackfin-*)
-		basic_machine=bfin-`echo $basic_machine | sed 's/^[^-]*-//'`
-		os=-linux
-		;;
-	bluegene*)
-		basic_machine=powerpc-ibm
-		os=-cnk
-		;;
-	c54x-*)
-		basic_machine=tic54x-`echo $basic_machine | sed 's/^[^-]*-//'`
-		;;
-	c55x-*)
-		basic_machine=tic55x-`echo $basic_machine | sed 's/^[^-]*-//'`
-		;;
-	c6x-*)
-		basic_machine=tic6x-`echo $basic_machine | sed 's/^[^-]*-//'`
-		;;
 	c90)
 		basic_machine=c90-cray
 		os=-unicos
 		;;
-	cegcc)
-		basic_machine=arm-unknown
-		os=-cegcc
-		;;
 	convex-c1)
 		basic_machine=c1-convex
 		os=-bsd
@@ -583,8 +475,8 @@ case $basic_machine in
 		basic_machine=craynv-cray
 		os=-unicosmp
 		;;
-	cr16 | cr16-*)
-		basic_machine=cr16-unknown
+	cr16c)
+		basic_machine=cr16c-unknown
 		os=-elf
 		;;
 	crds | unos)
@@ -622,10 +514,6 @@ case $basic_machine in
 		basic_machine=m88k-motorola
 		os=-sysv3
 		;;
-	dicos)
-		basic_machine=i686-pc
-		os=-dicos
-		;;
 	djgpp)
 		basic_machine=i586-pc
 		os=-msdosdjgpp
@@ -741,6 +629,7 @@ case $basic_machine in
 	i370-ibm* | ibm*)
 		basic_machine=i370-ibm
 		;;
+# I'm not sure what "Sysv32" means.  Should this be sysv3.2?
 	i*86v32)
 		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
 		os=-sysv32
@@ -779,17 +668,6 @@ case $basic_machine in
 		basic_machine=m68k-isi
 		os=-sysv
 		;;
-	leon-*|leon[3-9]-*)
-		basic_machine=sparc-`echo $basic_machine | sed 's/-.*//'`
-		;;
-	m68knommu)
-		basic_machine=m68k-unknown
-		os=-linux
-		;;
-	m68knommu-*)
-		basic_machine=m68k-`echo $basic_machine | sed 's/^[^-]*-//'`
-		os=-linux
-		;;
 	m88k-omron*)
 		basic_machine=m88k-omron
 		;;
@@ -801,21 +679,10 @@ case $basic_machine in
 		basic_machine=ns32k-utek
 		os=-sysv
 		;;
-	microblaze*)
-		basic_machine=microblaze-xilinx
-		;;
-	mingw64)
-		basic_machine=x86_64-pc
-		os=-mingw64
-		;;
 	mingw32)
-		basic_machine=i686-pc
+		basic_machine=i386-pc
 		os=-mingw32
 		;;
-	mingw32ce)
-		basic_machine=arm-unknown
-		os=-mingw32ce
-		;;
 	miniframe)
 		basic_machine=m68000-convergent
 		;;
@@ -837,10 +704,6 @@ case $basic_machine in
 		basic_machine=powerpc-unknown
 		os=-morphos
 		;;
-	moxiebox)
-		basic_machine=moxie-unknown
-		os=-moxiebox
-		;;
 	msdos)
 		basic_machine=i386-pc
 		os=-msdos
@@ -848,18 +711,10 @@ case $basic_machine in
 	ms1-*)
 		basic_machine=`echo $basic_machine | sed -e 's/ms1-/mt-/'`
 		;;
-	msys)
-		basic_machine=i686-pc
-		os=-msys
-		;;
 	mvs)
 		basic_machine=i370-ibm
 		os=-mvs
 		;;
-	nacl)
-		basic_machine=le32-unknown
-		os=-nacl
-		;;
 	ncr3000)
 		basic_machine=i486-ncr
 		os=-sysv4
@@ -924,12 +779,6 @@ case $basic_machine in
 	np1)
 		basic_machine=np1-gould
 		;;
-	neo-tandem)
-		basic_machine=neo-tandem
-		;;
-	nse-tandem)
-		basic_machine=nse-tandem
-		;;
 	nsr-tandem)
 		basic_machine=nsr-tandem
 		;;
@@ -960,14 +809,6 @@ case $basic_machine in
 		basic_machine=i860-intel
 		os=-osf
 		;;
-	parisc)
-		basic_machine=hppa-unknown
-		os=-linux
-		;;
-	parisc-*)
-		basic_machine=hppa-`echo $basic_machine | sed 's/^[^-]*-//'`
-		os=-linux
-		;;
 	pbd)
 		basic_machine=sparc-tti
 		;;
@@ -1012,10 +853,9 @@ case $basic_machine in
 		;;
 	power)	basic_machine=power-ibm
 		;;
-	ppc | ppcbe)	basic_machine=powerpc-unknown
+	ppc)	basic_machine=powerpc-unknown
 		;;
-	ppc-* | ppcbe-*)
-		basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'`
+	ppc-*)	basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'`
 		;;
 	ppcle | powerpclittle | ppc-le | powerpc-little)
 		basic_machine=powerpcle-unknown
@@ -1040,11 +880,7 @@ case $basic_machine in
 		basic_machine=i586-unknown
 		os=-pw32
 		;;
-	rdos | rdos64)
-		basic_machine=x86_64-pc
-		os=-rdos
-		;;
-	rdos32)
+	rdos)
 		basic_machine=i386-pc
 		os=-rdos
 		;;
@@ -1089,9 +925,6 @@ case $basic_machine in
 		basic_machine=sh-hitachi
 		os=-hms
 		;;
-	sh5el)
-		basic_machine=sh5le-unknown
-		;;
 	sh64)
 		basic_machine=sh64-unknown
 		;;
@@ -1113,9 +946,6 @@ case $basic_machine in
 		basic_machine=i860-stratus
 		os=-sysv4
 		;;
-	strongarm-* | thumb-*)
-		basic_machine=arm-`echo $basic_machine | sed 's/^[^-]*-//'`
-		;;
 	sun2)
 		basic_machine=m68000-sun
 		;;
@@ -1172,9 +1002,17 @@ case $basic_machine in
 		basic_machine=t90-cray
 		os=-unicos
 		;;
-	tile*)
-		basic_machine=$basic_machine-unknown
-		os=-linux-gnu
+	tic54x | c54x*)
+		basic_machine=tic54x-unknown
+		os=-coff
+		;;
+	tic55x | c55x*)
+		basic_machine=tic55x-unknown
+		os=-coff
+		;;
+	tic6x | c6x*)
+		basic_machine=tic6x-unknown
+		os=-coff
 		;;
 	tx39)
 		basic_machine=mipstx39-unknown
@@ -1243,9 +1081,6 @@ case $basic_machine in
 	xps | xps100)
 		basic_machine=xps100-honeywell
 		;;
-	xscale-* | xscalee[bl]-*)
-		basic_machine=`echo $basic_machine | sed 's/^xscale/arm/'`
-		;;
 	ymp)
 		basic_machine=ymp-cray
 		os=-unicos
@@ -1254,10 +1089,6 @@ case $basic_machine in
 		basic_machine=z8k-unknown
 		os=-sim
 		;;
-	z80-*-coff)
-		basic_machine=z80-unknown
-		os=-sim
-		;;
 	none)
 		basic_machine=none-none
 		os=-none
@@ -1296,7 +1127,7 @@ case $basic_machine in
 	we32k)
 		basic_machine=we32k-att
 		;;
-	sh[1234] | sh[24]a | sh[24]aeb | sh[34]eb | sh[1234]le | sh[23]ele)
+	sh[1234] | sh[24]a | sh[34]eb | sh[1234]le | sh[23]ele)
 		basic_machine=sh-unknown
 		;;
 	sparc | sparcv8 | sparcv9 | sparcv9b | sparcv9v)
@@ -1343,12 +1174,9 @@ esac
 if [ x"$os" != x"" ]
 then
 case $os in
-	# First match some system type aliases
-	# that might get confused with valid system types.
+        # First match some system type aliases
+        # that might get confused with valid system types.
 	# -solaris* is a basic system type, with this one exception.
-	-auroraux)
-		os=-auroraux
-		;;
 	-solaris1 | -solaris1.*)
 		os=`echo $os | sed -e 's|solaris1|sunos4|'`
 		;;
@@ -1369,31 +1197,29 @@ case $os in
 	# Each alternative MUST END IN A *, to match a version number.
 	# -sysv* is not here because it comes later, after sysvr4.
 	-gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \
-	      | -*vms* | -sco* | -esix* | -isc* | -aix* | -cnk* | -sunos | -sunos[34]*\
-	      | -hpux* | -unos* | -osf* | -luna* | -dgux* | -auroraux* | -solaris* \
-	      | -sym* | -kopensolaris* | -plan9* \
+	      | -*vms* | -sco* | -esix* | -isc* | -aix* | -sunos | -sunos[34]*\
+	      | -hpux* | -unos* | -osf* | -luna* | -dgux* | -solaris* | -sym* \
 	      | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \
-	      | -aos* | -aros* \
+	      | -aos* \
 	      | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \
 	      | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \
 	      | -hiux* | -386bsd* | -knetbsd* | -mirbsd* | -netbsd* \
-	      | -bitrig* | -openbsd* | -solidbsd* \
+	      | -openbsd* | -solidbsd* \
 	      | -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \
 	      | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \
 	      | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \
 	      | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \
-	      | -chorusos* | -chorusrdb* | -cegcc* \
-	      | -cygwin* | -msys* | -pe* | -psos* | -moss* | -proelf* | -rtems* \
-	      | -mingw32* | -mingw64* | -linux-gnu* | -linux-android* \
-	      | -linux-newlib* | -linux-musl* | -linux-uclibc* \
-	      | -uxpv* | -beos* | -mpeix* | -udk* | -moxiebox* \
+	      | -chorusos* | -chorusrdb* \
+	      | -cygwin* | -pe* | -psos* | -moss* | -proelf* | -rtems* \
+	      | -mingw32* | -linux-gnu* | -linux-newlib* | -linux-uclibc* \
+	      | -uxpv* | -beos* | -mpeix* | -udk* \
 	      | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \
 	      | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \
 	      | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \
 	      | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \
 	      | -morphos* | -superux* | -rtmk* | -rtmk-nova* | -windiss* \
 	      | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \
-	      | -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es* | -tirtos*)
+	      | -skyos* | -haiku* | -rdos* | -toppers*)
 	# Remember, each alternative MUST END IN *, to match a version number.
 		;;
 	-qnx*)
@@ -1432,7 +1258,7 @@ case $os in
 	-opened*)
 		os=-openedition
 		;;
-	-os400*)
+        -os400*)
 		os=-os400
 		;;
 	-wince*)
@@ -1481,7 +1307,7 @@ case $os in
 	-sinix*)
 		os=-sysv4
 		;;
-	-tpf*)
+        -tpf*)
 		os=-tpf
 		;;
 	-triton*)
@@ -1517,14 +1343,12 @@ case $os in
 	-aros*)
 		os=-aros
 		;;
+	-kaos*)
+		os=-kaos
+		;;
 	-zvmoe)
 		os=-zvmoe
 		;;
-	-dicos*)
-		os=-dicos
-		;;
-	-nacl*)
-		;;
 	-none)
 		;;
 	*)
@@ -1547,10 +1371,10 @@ else
 # system, and we'll never get to this point.
 
 case $basic_machine in
-	score-*)
+        score-*)
 		os=-elf
 		;;
-	spu-*)
+        spu-*)
 		os=-elf
 		;;
 	*-acorn)
@@ -1562,23 +1386,8 @@ case $basic_machine in
 	arm*-semi)
 		os=-aout
 		;;
-	c4x-* | tic4x-*)
-		os=-coff
-		;;
-	c8051-*)
-		os=-elf
-		;;
-	hexagon-*)
-		os=-elf
-		;;
-	tic54x-*)
-		os=-coff
-		;;
-	tic55x-*)
-		os=-coff
-		;;
-	tic6x-*)
-		os=-coff
+        c4x-* | tic4x-*)
+        	os=-coff
 		;;
 	# This must come before the *-dec entry.
 	pdp10-*)
@@ -1598,13 +1407,13 @@ case $basic_machine in
 		;;
 	m68000-sun)
 		os=-sunos3
+		# This also exists in the configure program, but was not the
+		# default.
+		# os=-sunos4
 		;;
 	m68*-cisco)
 		os=-aout
 		;;
-	mep-*)
-		os=-elf
-		;;
 	mips*-cisco)
 		os=-elf
 		;;
@@ -1629,7 +1438,7 @@ case $basic_machine in
 	*-ibm)
 		os=-aix
 		;;
-	*-knuth)
+    	*-knuth)
 		os=-mmixware
 		;;
 	*-wec)
@@ -1734,7 +1543,7 @@ case $basic_machine in
 			-sunos*)
 				vendor=sun
 				;;
-			-cnk*|-aix*)
+			-aix*)
 				vendor=ibm
 				;;
 			-beos*)

configure.ac

@@ -1,35 +1,20 @@
-#
-#  This file is part of nzbget. See <http://nzbget.net>.
-#
-# Copyright (C) 2008-2021 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, see <http://www.gnu.org/licenses/>.
-#
-
 #                                               -*- Autoconf -*-
 # Process this file with autoconf to produce a configure script.
 
-AC_PREREQ(2.65)
-AC_INIT(nzbget, 21.1, hugbug@users.sourceforge.net)
-AC_CONFIG_AUX_DIR(posix)
-AC_CANONICAL_TARGET
-AM_INIT_AUTOMAKE([foreign subdir-objects])
-AC_CONFIG_SRCDIR([daemon/main/nzbget.cpp])
+AC_PREREQ(2.59)
+AC_INIT(nzbget, 11.0, hugbug@users.sourceforge.net)
+AC_CANONICAL_SYSTEM
+AM_INIT_AUTOMAKE(nzbget, 11.0)
+AC_CONFIG_SRCDIR([nzbget.cpp])
 AC_CONFIG_HEADERS([config.h])
-AM_MAINTAINER_MODE
 
-m4_include([posix/ax_cxx_compile_stdcxx.m4])
+
+dnl
+dnl Set default library path, if not specified in environment variable "LIBPREF".
+dnl
+if test "$LIBPREF" = ""; then
+	LIBPREF="/usr"
+fi
 
 
 dnl
@@ -46,26 +31,12 @@ dnl Do all tests with c++ compiler.
 dnl
 AC_LANG(C++)
 
-dnl
-dnl Determine compiler switches to support C++14 standard.
-dnl
-AC_MSG_CHECKING(whether to test compiler features)
-AC_ARG_ENABLE(cpp-check,
-	[AS_HELP_STRING([--disable-cpp-check], [disable check for C++14 compiler features])],
-	[ ENABLECPPCHECK=$enableval ],
-	[ ENABLECPPCHECK=yes] )
-AC_MSG_RESULT($ENABLECPPCHECK)
-if test "$ENABLECPPCHECK" = "yes"; then
-	AX_CXX_COMPILE_STDCXX(14,,[optional])
-	if test "$HAVE_CXX14" != "1"; then
-		AC_MSG_ERROR("A compiler with support for C++14 language features is required. For details visit http://nzbget.net/cpp14")
-	fi
-fi
 
 dnl
 dnl Checks for header files.
 dnl
-AC_CHECK_HEADERS(sys/prctl.h regex.h endian.h getopt.h)
+AC_CHECK_HEADERS(sys/prctl.h)
+AC_CHECK_HEADERS(regex.h)
 
 
 dnl
@@ -77,19 +48,6 @@ AC_SEARCH_LIBS([inet_addr], [nsl])
 AC_SEARCH_LIBS([hstrerror], [resolv])
 
 
-dnl
-dnl Android NDK restrictions
-dnl
-AC_CHECK_FUNC(lockf,
-	[AC_CHECK_DECL(lockf,
-		[AC_DEFINE([HAVE_LOCKF], 1, [Define to 1 if lockf is supported])],,
-		[#include <unistd.h>])])
-AC_CHECK_FUNC(pthread_cancel,
-	[AC_CHECK_DECL(pthread_cancel,
-		[AC_DEFINE([HAVE_PTHREAD_CANCEL], 1, [Define to 1 if pthread_cancel is supported])],,
-		[#include <pthread.h>])])
-
-
 dnl
 dnl Getopt
 dnl
@@ -97,14 +55,6 @@ AC_CHECK_FUNC(getopt_long,
 	[AC_DEFINE([HAVE_GETOPT_LONG], 1, [Define to 1 if getopt_long is supported])],)
 
 
-dnl
-dnl fsync
-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
@@ -158,7 +108,7 @@ if test "$FOUND" = "no"; then
 		[	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"
+		FOUND="yes"                      
 		AC_DEFINE([HAVE_GETHOSTBYNAME_R_5], 1, [Define to 1 if gethostbyname_r takes 5 arguments]),
 		FOUND="no")
 	
@@ -192,6 +142,14 @@ if test "$FOUND" = "no"; then
 fi
 
 
+dnl
+dnl cCheck if spinlocks are available
+dnl
+AC_CHECK_FUNC(pthread_spin_init,
+	[AC_DEFINE([HAVE_SPINLOCK], 1, [Define to 1 if spinlocks are supported])]
+	AC_SEARCH_LIBS([pthread_spin_init], [pthread]),)
+
+
 dnl
 dnl Determine what socket length (socklen_t) data type is
 dnl
@@ -208,66 +166,42 @@ AC_TRY_COMPILE([
 #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([
+    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_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 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
-AC_MSG_CHECKING(whether to use libxml2)
-AC_ARG_ENABLE(libxml2,
-	[AS_HELP_STRING([--disable-libxml2], [do not use libxml2 (removes dependency from libxml2-library, only for development purposes)])],
-	[USELIBXML2=$enableval],
-	[USELIBXML2=yes] )
-AC_MSG_RESULT($USELIBXML2)
-if test "$USELIBXML2" = "yes"; then
-	AC_ARG_WITH(libxml2_includes,
-		[AS_HELP_STRING([--with-libxml2-includes=DIR], [libxml2 include directory])],
-		[CPPFLAGS="${CPPFLAGS} -I${withval}"]
-		[INCVAL="yes"],
-		[INCVAL="no"])
-	AC_ARG_WITH(libxml2_libraries,
-		[AS_HELP_STRING([--with-libxml2-libraries=DIR], [libxml2 library directory])],
-		[LDFLAGS="${LDFLAGS} -L${withval}"]
-		[LIBVAL="yes"],
-		[LIBVAL="no"])
-	if test "$INCVAL" = "no" -o "$LIBVAL" = "no"; then
-		PKG_CHECK_MODULES(libxml2, libxml-2.0,
-			[LIBS="${LIBS} $libxml2_LIBS"]
-			[CPPFLAGS="${CPPFLAGS} $libxml2_CFLAGS"],
-			AC_MSG_ERROR("libxml2 library not found"))
-	fi
-	AC_CHECK_HEADER(libxml/tree.h,,
-		AC_MSG_ERROR("libxml2 header files not found"))
-	AC_SEARCH_LIBS([xmlNewNode], [xml2], ,
-		AC_MSG_ERROR("libxml2 library not found"))
-else
-	AC_DEFINE([DISABLE_LIBXML2],1,[Define to 1 to not use libxml2, only for development purposes])
+AC_ARG_WITH(libxml2_includes,
+	[AS_HELP_STRING([--with-libxml2-includes=DIR], [libxml2 include directory])],
+	[CPPFLAGS="${CPPFLAGS} -I${withval}"]
+	[INCVAL="yes"],
+	[INCVAL="no"])
+AC_ARG_WITH(libxml2_libraries,
+	[AS_HELP_STRING([--with-libxml2-libraries=DIR], [libxml2 library directory])],
+	[LDFLAGS="${LDFLAGS} -L${withval}"]
+	[LIBVAL="yes"],
+	[LIBVAL="no"])
+if test "$INCVAL" = "no" -o "$LIBVAL" = "no"; then
+	PKG_CHECK_MODULES(libxml2, libxml-2.0,
+		[LIBS="${LIBS} $libxml2_LIBS"]
+		[CPPFLAGS="${CPPFLAGS} $libxml2_CFLAGS"])
 fi
+AC_CHECK_HEADER(libxml/tree.h,,
+	AC_MSG_ERROR("libxml2 header files not found"))
+AC_SEARCH_LIBS([xmlNewNode], [xml2], ,
+	AC_MSG_ERROR("libxml2 library not found"))
 
 
 dnl
@@ -280,23 +214,17 @@ AC_ARG_ENABLE(curses,
 	[USECURSES=yes] )
 AC_MSG_RESULT($USECURSES)
 if test "$USECURSES" = "yes"; then
+	INCVAL="${LIBPREF}/include"
+	LIBVAL="${LIBPREF}/lib"
 	AC_ARG_WITH(libcurses_includes,
 		[AS_HELP_STRING([--with-libcurses-includes=DIR], [libcurses include directory])],
-		[CPPFLAGS="${CPPFLAGS} -I${withval}"]
-		[INCVAL="yes"],
-		[INCVAL="no"])
+		[INCVAL="$withval"])
+	CPPFLAGS="${CPPFLAGS} -I${INCVAL}"
 	AC_ARG_WITH(libcurses_libraries,
 		[AS_HELP_STRING([--with-libcurses-libraries=DIR], [libcurses library directory])],
-		[LDFLAGS="${LDFLAGS} -L${withval}"]
-		[LIBVAL="yes"],
-		[LIBVAL="no"])
-	if test "$INCVAL" = "no" -o "$LIBVAL" = "no"; then
-		PKG_CHECK_MODULES(ncurses, ncurses,
-			[LIBS="${LIBS} $ncurses_LIBS"]
-			[CPPFLAGS="${CPPFLAGS} $ncurses_CFLAGS"],
-			AC_MSG_ERROR("ncurses library not found"))
-	fi
-
+		[LIBVAL="$withval"])
+	LDFLAGS="${LDFLAGS} -L${LIBVAL}"
+	
 	AC_CHECK_HEADER(ncurses.h,
 		FOUND=yes
 		AC_DEFINE([HAVE_NCURSES_H],1,[Define to 1 if you have the <ncurses.h> header file.]),
@@ -318,35 +246,122 @@ if test "$USECURSES" = "yes"; then
 	fi
 	AC_SEARCH_LIBS([refresh], [ncurses curses],, 
 		AC_ERROR([Couldn't find curses library]))
-	AC_SEARCH_LIBS([nodelay], [ncurses curses tinfo],, 
-		AC_ERROR([Couldn't find curses library]))
 else
 	AC_DEFINE([DISABLE_CURSES],1,[Define to 1 to not use curses])
 fi
 
 
 dnl
-dnl Use par-checking. Deafult: yes.
+dnl Use libpar2 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 typedefs, structures, and compiler characteristics.
-	AC_TYPE_SIZE_T
-	AC_FUNC_FSEEKO
-	dnl Checks for library functions.
-	AC_CHECK_FUNCS([stricmp])
-	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,
+			[LIBS="${LIBS} $libsigc_LIBS"]
+			[CPPFLAGS="${CPPFLAGS} $libsigc_CFLAGS"])
+	fi
+	
+	AC_CHECK_HEADER(sigc++/type_traits.h,,
+		AC_MSG_ERROR("libsigc++-2.0 header files not found"))
+
+	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_CHECK_HEADER(libpar2/libpar2.h,,
+		AC_MSG_ERROR("libpar2 header files not found"))
+
+	AC_ARG_WITH(libpar2_libraries,
+		[AS_HELP_STRING([--with-libpar2-libraries=DIR], [libpar2 library directory])],
+		[LIBVAL="$withval"])
+
+	LDFLAGS="${LDFLAGS} -L${LIBVAL}"
+
+	AC_SEARCH_LIBS([_ZN12Par2RepairerC1Ev], [par2], ,
+		AC_MSG_ERROR("libpar2 library not found"))
+
+	dnl
+	dnl check if libpar2 library is linkable
+	dnl
+	AC_MSG_CHECKING(for libpar2 linking)
+	AC_TRY_LINK(
+		[#include <libpar2/par2cmdline.h>]
+		[#include <libpar2/par2repairer.h>]
+		[ class Repairer : public Par2Repairer { }; ],
+		[ Repairer* p = new Repairer(); ],
+		AC_MSG_RESULT([[yes]]),
+		AC_MSG_RESULT([[no]])
+		AC_MSG_ERROR("libpar2 library not found"))
+
+	dnl
+	dnl check if libpar2 has support for cancelling
+	dnl
+	AC_MSG_CHECKING(whether libpar2 supports cancelling)
+	AC_TRY_COMPILE(
+		[#include <libpar2/par2cmdline.h>]
+		[#include <libpar2/par2repairer.h>]
+		[ class Repairer : public Par2Repairer { void test() { cancelled = true; } }; ],
+		[],
+		AC_MSG_RESULT([[yes]])
+		AC_DEFINE([HAVE_PAR2_CANCEL], 1, [Define to 1 if libpar2 supports cancelling (needs a special patch)]),
+		AC_MSG_RESULT([[no]]))
+
+	dnl
+	dnl check if libpar2 has recent bugfixes-patch
+	dnl
+	AC_MSG_CHECKING(whether libpar2 has recent bugfixes-patch (version 2))
+	AC_TRY_COMPILE(
+		[#include <libpar2/par2cmdline.h>]
+		[#include <libpar2/par2repairer.h>]
+		[ class Repairer : public Par2Repairer { void test() { BugfixesPatchVersion2(); } }; ],
+		[],
+		AC_MSG_RESULT([[yes]])
+		PAR2PATCHV2=yes
+		AC_DEFINE([HAVE_PAR2_BUGFIXES_V2], 1, [Define to 1 if libpar2 has recent bugfixes-patch (version 2)]),
+		AC_MSG_RESULT([[no]])
+		PAR2PATCHV2=no)
+
+	if test "$PAR2PATCHV2" = "no" ; then
+		AC_ARG_ENABLE(libpar2-bugfixes-check,
+			[AS_HELP_STRING([--disable-libpar2-bugfixes-check], [do not check if libpar2 has recent bugfixes-patch applied])],
+			[ PAR2PATCHCHECK=$enableval ],
+			[ PAR2PATCHCHECK=yes] )
+		if test "$PAR2PATCHCHECK" = "yes"; then
+			AC_ERROR([Your version of libpar2 doesn't include the recent bugfixes-patch (version 2, updated Dec 3, 2012). Please patch libpar2 with the patches supplied with NZBGet (see README for details). If you cannot patch libpar2, you can use configure parameter --disable-libpar2-bugfixes-check to suppress the check. Please note however that in this case the program may crash during par-check/repair. The patch is highly recommended!])
+		fi
+	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
 
 
@@ -361,12 +376,47 @@ 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])
 	fi
+	
+	if test "$TLSLIB" = "GnuTLS" -o "$TLSLIB" = ""; then
+		INCVAL="${LIBPREF}/include"
+		LIBVAL="${LIBPREF}/lib"
+		AC_ARG_WITH(libgnutls_includes,
+			[AS_HELP_STRING([--with-libgnutls-includes=DIR], [GnuTLS include directory])],
+			[INCVAL="$withval"])
+		CPPFLAGS="${CPPFLAGS} -I${INCVAL}"
+		AC_ARG_WITH(libgnutls_libraries,
+			[AS_HELP_STRING([--with-libgnutls-libraries=DIR], [GnuTLS library directory])],
+			[LIBVAL="$withval"])
+		LDFLAGS="${LDFLAGS} -L${LIBVAL}"
 
+		AC_CHECK_HEADER(gnutls/gnutls.h,
+			FOUND=yes
+			TLSHEADERS=yes,
+			FOUND=no)
+		if test "$FOUND" = "no" -a "$TLSLIB" = "GnuTLS"; then
+			AC_MSG_ERROR([Couldn't find GnuTLS headers (gnutls.h)])
+		fi
+		if test "$FOUND" = "yes"; then
+			AC_SEARCH_LIBS([gnutls_global_init], [gnutls],
+				AC_SEARCH_LIBS([gcry_control], [gnutls gcrypt],
+					FOUND=yes,
+					FOUND=no),
+				FOUND=no)
+			if test "$FOUND" = "no" -a "$TLSLIB" = "GnuTLS"; then
+				AC_MSG_ERROR([Couldn't find GnuTLS library])
+			fi
+			if test "$FOUND" = "yes"; then
+				TLSLIB="GnuTLS"
+				AC_DEFINE([HAVE_LIBGNUTLS],1,[Define to 1 to use GnuTLS library for TLS/SSL-support.])
+			fi
+		fi
+	fi
+	
 	if test "$TLSLIB" = "OpenSSL" -o "$TLSLIB" = ""; then
 		AC_ARG_WITH(openssl_includes,
 			[AS_HELP_STRING([--with-openssl-includes=DIR], [OpenSSL include directory])],
@@ -379,7 +429,7 @@ if test "$USETLS" = "yes"; then
 			[LIBVAL="yes"],
 			[LIBVAL="no"])
 		if test "$INCVAL" = "no" -o "$LIBVAL" = "no"; then
-			PKG_CHECK_MODULES([openssl], [openssl],
+			PKG_CHECK_MODULES(openssl, openssl,
 				[LIBS="${LIBS} $openssl_LIBS"]
 				[CPPFLAGS="${CPPFLAGS} $openssl_CFLAGS"])
 		fi
@@ -392,8 +442,8 @@ if test "$USETLS" = "yes"; then
 			AC_MSG_ERROR([Couldn't find OpenSSL headers (ssl.h)])
 		fi
 		if test "$FOUND" = "yes"; then
-			AC_SEARCH_LIBS([ASN1_OBJECT_free], [crypto],
-				AC_SEARCH_LIBS([SSL_CTX_new], [ssl],
+			AC_SEARCH_LIBS([CRYPTO_set_locking_callback], [crypto],
+				AC_SEARCH_LIBS([SSL_library_init], [ssl],
 					FOUND=yes,
 					FOUND=no),
 				FOUND=no)
@@ -402,110 +452,16 @@ if test "$USETLS" = "yes"; then
 			fi
 			if test "$FOUND" = "yes"; then
 				TLSLIB="OpenSSL"
-				AC_DEFINE([HAVE_OPENSSL],1,[Define to 1 to use OpenSSL library for TLS/SSL-support and decryption.])
-				AC_SEARCH_LIBS([X509_check_host], [crypto],
-					AC_DEFINE([HAVE_X509_CHECK_HOST],1,[Define to 1 if OpenSSL supports function "X509_check_host".]))
+				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
-		AC_ARG_WITH(libgnutls_includes,
-			[AS_HELP_STRING([--with-libgnutls-includes=DIR], [GnuTLS include directory])],
-			[CPPFLAGS="${CPPFLAGS} -I${withval}"]
-			[INCVAL="yes"],
-			[INCVAL="no"])
-		AC_ARG_WITH(libgnutls_libraries,
-			[AS_HELP_STRING([--with-libgnutls-libraries=DIR], [GnuTLS library directory])],
-			[LDFLAGS="${LDFLAGS} -L${withval}"]
-			[LIBVAL="yes"],
-			[LIBVAL="no"])
-		if test "$INCVAL" = "no" -o "$LIBVAL" = "no"; then
-			PKG_CHECK_MODULES([gnutls], [gnutls],
-				[LIBS="${LIBS} $gnutls_LIBS"]
-				[CPPFLAGS="${CPPFLAGS} $gnutls_CFLAGS"])
-		fi
-
-		AC_CHECK_HEADER(gnutls/gnutls.h,
-			FOUND=yes
-			TLSHEADERS=yes,
-			FOUND=no)
-		if test "$FOUND" = "no" -a "$TLSLIB" = "GnuTLS"; then
-			AC_MSG_ERROR([Couldn't find GnuTLS headers (gnutls.h)])
-		fi
-		if test "$FOUND" = "yes"; then
-			AC_SEARCH_LIBS([gnutls_global_init], [gnutls],
-				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])
-			fi
-			if test "$FOUND" = "yes"; then
-				TLSLIB="GnuTLS"
-				AC_DEFINE([HAVE_LIBGNUTLS],1,[Define to 1 to use GnuTLS library for TLS/SSL-support.])
-			fi
-		fi
-
-		if test "$TLSLIB" = "GnuTLS"; then
-			AC_ARG_WITH(libnettle_includes,
-				[AS_HELP_STRING([--with-libnettle-includes=DIR], [Nettle include directory])],
-				[CPPFLAGS="${CPPFLAGS} -I${withval}"]
-				[INCVAL="yes"],
-				[INCVAL="no"])
-			AC_ARG_WITH(libnettle_libraries,
-				[AS_HELP_STRING([--with-libnettle-libraries=DIR], [Nettle library directory])],
-				[LDFLAGS="${LDFLAGS} -L${withval}"]
-				[LIBVAL="yes"],
-				[LIBVAL="no"])
-			if test "$INCVAL" = "no" -o "$LIBVAL" = "no"; then
-				PKG_CHECK_MODULES([nettle], [nettle],
-					[LIBS="${LIBS} $nettle_LIBS"]
-					[CPPFLAGS="${CPPFLAGS} $nettle_CFLAGS"])
-			fi
-			AC_CHECK_HEADER(nettle/sha.h,
-				FOUND=yes,
-				FOUND=no)
-			if test "$FOUND" = "no"; then
-				AC_MSG_ERROR([Couldn't find Nettle headers (sha.h)])
-			fi
-			AC_SEARCH_LIBS([nettle_pbkdf2_hmac_sha256], [nettle],
-				FOUND=yes,
-				FOUND=no)
-			if test "$FOUND" = "no"; then
-				AC_MSG_ERROR([Couldn't find Nettle library, required when using GnuTLS])
-			fi
-			if test "$FOUND" = "yes"; then
-				AC_DEFINE([HAVE_NETTLE],1,[Define to 1 to use Nettle library for decryption.])
-			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
@@ -523,21 +479,16 @@ AC_ARG_ENABLE(gzip,
 	[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])],
-		[CPPFLAGS="${CPPFLAGS} -I${withval}"]
-		[INCVAL="yes"],
-		[INCVAL="no"])
+		[INCVAL="$withval"])
+	CPPFLAGS="${CPPFLAGS} -I${INCVAL}"
 	AC_ARG_WITH(zlib_libraries,
 		[AS_HELP_STRING([--with-zlib-libraries=DIR], [zlib library directory])],
-		[LDFLAGS="${LDFLAGS} -L${withval}"]
-		[LIBVAL="yes"],
-		[LIBVAL="no"])
-	if test "$INCVAL" = "no" -o "$LIBVAL" = "no"; then
-		PKG_CHECK_MODULES([zlib], [zlib],
-			[LIBS="${LIBS} $zlib_LIBS"]
-			[CPPFLAGS="${CPPFLAGS} $zlib_CFLAGS"])
-	fi
+		[LIBVAL="$withval"])
+	LDFLAGS="${LDFLAGS} -L${LIBVAL}"
 	
 	AC_CHECK_HEADER(zlib.h,,
 		AC_MSG_ERROR("zlib header files not found"))
@@ -548,36 +499,6 @@ else
 fi
 
 
-dnl
-dnl Determine if CPU supports SIMD instructions
-dnl
-AC_MSG_CHECKING(whether to use SIMD-optimized routines)
-USE_SIMD=no
-case $host_cpu in
-	i?86|x86_64)
-		SSE2_CXXFLAGS="-msse2"
-		SSSE3_CXXFLAGS="-mssse3"
-		PCLMUL_CXXFLAGS="-msse4.1 -mpclmul"
-		USE_SIMD=yes
-		;;
-	arm*)
-		NEON_CXXFLAGS="-mfpu=neon"
-		ACLECRC_CXXFLAGS="-march=armv8-a+crc -fpermissive"
-		USE_SIMD=yes
-		;;
-	aarch64)
-		ACLECRC_CXXFLAGS="-march=armv8-a+crc -fpermissive"
-		USE_SIMD=yes
-		;;
-esac
-AC_MSG_RESULT($USE_SIMD)
-AC_SUBST([SSE2_CXXFLAGS])
-AC_SUBST([SSSE3_CXXFLAGS])
-AC_SUBST([PCLMUL_CXXFLAGS])
-AC_SUBST([NEON_CXXFLAGS])
-AC_SUBST([ACLECRC_CXXFLAGS])
-
-
 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.
@@ -615,6 +536,16 @@ dnl
 AC_DEFINE([DEBUG],1,Define to 1 to include debug-code)
 
 
+dnl
+dnl Set debug flags for gcc (if gcc is used)
+dnl
+if test "$CC" = "gcc"; then
+	CXXFLAGS="-g -Wall"
+else
+	CXXFLAGS=""
+fi
+
+
 dnl
 dnl check for __FUNCTION__ or __func__ macro
 dnl
@@ -636,10 +567,11 @@ dnl
 dnl variadic macros
 dnl 
 AC_MSG_CHECKING(for variadic macros)
-AC_TRY_COMPILE(
-	[ #define macro(...)   macrofunc(__VA_ARGS__) ]
-	[ int macrofunc(int a, int b) { return a + b; } ],
-	[ int a=macro(1, 2); ],
+AC_COMPILE_IFELSE([
+	#define macro(...)   macrofunc(__VA_ARGS__)
+	int macrofunc(int a, int b) { return a + b; }
+	int test() { return macro(1, 2); }
+	],
 	AC_MSG_RESULT([yes])
 	AC_DEFINE([HAVE_VARIADIC_MACROS], 1, Define to 1 if variadic macros are supported),
 	AC_MSG_RESULT([no]))
@@ -677,26 +609,8 @@ AC_MSG_CHECKING(for rdynamic linker flag)
 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,157 +0,0 @@
-/*
- *  This file is part of nzbget. See <http://nzbget.net>.
- *
- *  Copyright (C) 2004 Sven Henkel <sidddy@users.sourceforge.net>
- *  Copyright (C) 2007-2017 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, see <http://www.gnu.org/licenses/>.
- */
-
-
-#ifndef CONNECTION_H
-#define CONNECTION_H
-
-#include "NString.h"
-
-#ifndef HAVE_GETADDRINFO
-#ifndef HAVE_GETHOSTBYNAME_R
-#include "Thread.h"
-#endif
-#endif
-#ifndef DISABLE_TLS
-#include "TlsSocket.h"
-#endif
-
-class Connection
-{
-public:
-	enum EStatus
-	{
-		csConnected,
-		csDisconnected,
-		csListening,
-		csCancelled,
-		csBroken
-	};
-
-	enum EIPVersion
-	{
-		ipAuto,
-		ipV4,
-		ipV6
-	};
-
-	Connection(const char* host, int port, bool tls);
-	Connection(SOCKET socket, bool tls);
-	virtual ~Connection();
-	static void Init();
-	static void Final();
-	virtual bool Connect();
-	virtual bool Disconnect();
-	bool Bind();
-	bool Send(const char* buffer, int size);
-	bool Recv(char* buffer, int size);
-	int TryRecv(char* buffer, int size);
-	char* ReadLine(char* buffer, int size, int* bytesRead);
-	void ReadBuffer(char** buffer, int *bufLen);
-	int WriteLine(const char* buffer);
-	std::unique_ptr<Connection> Accept();
-	void Cancel();
-	const char* GetHost() { return m_host; }
-	int GetPort() { return m_port; }
-	bool GetTls() { return m_tls; }
-	const char* GetCipher() { return m_cipher; }
-	void SetCipher(const char* cipher) { m_cipher = cipher; }
-	void SetTimeout(int timeout) { m_timeout = timeout; }
-	void SetIPVersion(EIPVersion ipVersion) { m_ipVersion = ipVersion; }
-	EStatus GetStatus() { return m_status; }
-	void SetSuppressErrors(bool suppressErrors);
-	bool GetSuppressErrors() { return m_suppressErrors; }
-	const char* GetRemoteAddr();
-	bool GetGracefull() { return m_gracefull; }
-	void SetGracefull(bool gracefull) { m_gracefull = gracefull; }
-	void SetForceClose(bool forceClose) { m_forceClose = forceClose; }
-#ifndef DISABLE_TLS
-	bool StartTls(bool isClient, const char* certFile, const char* keyFile);
-#endif
-	int FetchTotalBytesRead();
-
-protected:
-	CString m_host;
-	int m_port;
-	bool m_tls;
-	EIPVersion m_ipVersion = ipAuto;
-	SOCKET m_socket = INVALID_SOCKET;
-	CString m_cipher;
-	CharBuffer m_readBuf;
-	int m_bufAvail = 0;
-	char* m_bufPtr = nullptr;
-	EStatus m_status = csDisconnected;
-	int m_timeout = 60;
-	bool m_suppressErrors = true;
-	BString<100> m_remoteAddr;
-	int m_totalBytesRead = 0;
-	bool m_gracefull = false;
-	bool m_forceClose = false;
-
-	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
-	{
-	public:
-		ConTlsSocket(SOCKET socket, bool isClient, const char* host,
-			const char* certFile, const char* keyFile, const char* cipher, Connection* owner) :
-			TlsSocket(socket, isClient, host, certFile, keyFile, cipher), m_owner(owner) {}
-	protected:
-		virtual void PrintError(const char* errMsg) { m_owner->PrintError(errMsg); }
-	private:
-		Connection* m_owner;
-	};
-
-	std::unique_ptr<ConTlsSocket> m_tlsSocket;
-	bool m_tlsError = false;
-#endif
-#ifndef HAVE_GETADDRINFO
-#ifndef HAVE_GETHOSTBYNAME_R
-	static std::unique_ptr<Mutex> m_getHostByNameMutex;
-#endif
-#endif
-
-	void ReportError(const char* msgPrefix, const char* msgArg, bool printErrCode, int errCode = 0,
-		const char* errMsg = nullptr);
-	virtual void PrintError(const char* errMsg);
-	int GetLastNetworkError();
-	bool DoConnect();
-	bool DoDisconnect();
-	bool InitSocketOpts(SOCKET socket);
-	bool ConnectWithTimeout(void* address, int address_len);
-#ifndef HAVE_GETADDRINFO
-	in_addr_t ResolveHostAddr(const char* host);
-#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
-};
-
-#endif

daemon/connect/TlsSocket.cpp

@@ -1,696 +0,0 @@
-/*
- *  This file is part of nzbget. See <http://nzbget.net>.
- *
- *  Copyright (C) 2008-2017 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, see <http://www.gnu.org/licenses/>.
- */
-
-
-#include "nzbget.h"
-
-#ifndef DISABLE_TLS
-
-#include "TlsSocket.h"
-#include "Thread.h"
-#include "Log.h"
-#include "Util.h"
-#include "FileSystem.h"
-
-CString TlsSocket::m_certStore;
-
-#ifdef HAVE_LIBGNUTLS
-#ifdef NEED_GCRYPT_LOCKING
-
-/**
- * Mutexes for gcryptlib
- */
-
-std::vector<std::unique_ptr<Mutex>> g_GCryptLibMutexes;
-
-static int gcry_mutex_init(void **priv)
-{
-	g_GCryptLibMutexes.emplace_back(std::make_unique<Mutex>());
-	*priv = g_GCryptLibMutexes.back().get();
-	return 0;
-}
-
-static int gcry_mutex_destroy(void **lock)
-{
-	Mutex* mutex = ((Mutex*)*lock);
-	g_GCryptLibMutexes.erase(std::find_if(g_GCryptLibMutexes.begin(), g_GCryptLibMutexes.end(),
-		[mutex](std::unique_ptr<Mutex>& itMutex)
-		{
-			return itMutex.get() == mutex;
-		}));
-	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, nullptr,
-	gcry_mutex_init, gcry_mutex_destroy,
-	gcry_mutex_lock, gcry_mutex_unlock,
-	nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr
-};
-
-#endif /* NEED_GCRYPT_LOCKING */
-#endif /* HAVE_LIBGNUTLS */
-
-
-#ifdef HAVE_OPENSSL
-
-#ifndef CRYPTO_set_locking_callback
-#define NEED_CRYPTO_LOCKING
-#endif
-
-#ifdef NEED_CRYPTO_LOCKING
-
-/**
- * Mutexes for OpenSSL
- */
-
-std::vector<std::unique_ptr<Mutex>> g_OpenSSLMutexes;
-
-static void openssl_locking(int mode, int n, const char* file, int line)
-{
-	Mutex* mutex = g_OpenSSLMutexes[n].get();
-	if (mode & CRYPTO_LOCK)
-	{
-		mutex->Lock();
-	}
-	else
-	{
-		mutex->Unlock();
-	}
-}
-
-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 /* NEED_CRYPTO_LOCKING */
-#endif /* HAVE_OPENSSL */
-
-
-void TlsSocket::Init()
-{
-	debug("Initializing TLS library");
-
-#ifdef HAVE_LIBGNUTLS
-	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
-
-#ifdef NEED_CRYPTO_LOCKING
-	for (int i = 0, num = CRYPTO_num_locks(); i < num; i++)
-	{
-		g_OpenSSLMutexes.emplace_back(std::make_unique<Mutex>());
-	}
-
-	CRYPTO_set_locking_callback(openssl_locking);
-	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 /* NEED_CRYPTO_LOCKING */
-
-	SSL_load_error_strings();
-	SSL_library_init();
-	OpenSSL_add_all_algorithms();
-
-#endif /* HAVE_OPENSSL */
-}
-
-void TlsSocket::Final()
-{
-#ifdef HAVE_LIBGNUTLS
-	gnutls_global_deinit();
-#endif /* HAVE_LIBGNUTLS */
-
-#ifdef HAVE_OPENSSL
-#ifndef LIBRESSL_VERSION_NUMBER
-	FIPS_mode_set(0);
-#endif
-#ifdef NEED_CRYPTO_LOCKING
-	CRYPTO_set_locking_callback(nullptr);
-	CRYPTO_set_id_callback(nullptr);
-#endif
-#if OPENSSL_VERSION_NUMBER < 0x10100000L
-	ERR_remove_state(0);
-#endif
-#if	OPENSSL_VERSION_NUMBER >= 0x10002000L && ! defined (LIBRESSL_VERSION_NUMBER)
-	SSL_COMP_free_compression_methods();
-#endif
-	//ENGINE_cleanup();
-	CONF_modules_free();
-	CONF_modules_unload(1);
-#ifndef OPENSSL_NO_COMP
-	COMP_zlib_cleanup();
-#endif
-	ERR_free_strings();
-	EVP_cleanup();
-	CRYPTO_cleanup_all_ex_data();
-#endif /* HAVE_OPENSSL */
-}
-
-TlsSocket::~TlsSocket()
-{
-	Close();
-
-#ifdef HAVE_OPENSSL
-#if OPENSSL_VERSION_NUMBER < 0x10100000L
-	ERR_remove_state(0);
-#endif
-#endif
-}
-
-void TlsSocket::ReportError(const char* errMsg, bool suppressable)
-{
-#ifdef HAVE_LIBGNUTLS
-	const char* errstr = gnutls_strerror(m_retCode);
-	if (suppressable && m_suppressErrors)
-	{
-		debug("%s: %s", errMsg, errstr);
-	}
-	else
-	{
-		PrintError(BString<1024>("%s: %s", errMsg, errstr));
-	}
-#endif /* HAVE_LIBGNUTLS */
-
-#ifdef HAVE_OPENSSL
-	int errcode = ERR_get_error();
-	do
-	{
-		char errstr[1024];
-		ERR_error_string_n(errcode, errstr, sizeof(errstr));
-		errstr[1024-1] = '\0';
-
-		if (suppressable && m_suppressErrors)
-		{
-			debug("%s: %s", errMsg, errstr);
-		}
-		else if (errcode != 0)
-		{
-			PrintError(BString<1024>("%s: %s", errMsg, errstr));
-		}
-		else
-		{
-			PrintError(errMsg);
-		}
-
-		errcode = ERR_get_error();
-	} while (errcode);
-#endif /* HAVE_OPENSSL */
-}
-
-void TlsSocket::PrintError(const char* errMsg)
-{
-	error("%s", errMsg);
-}
-
-bool TlsSocket::Start()
-{
-#ifdef HAVE_LIBGNUTLS
-	gnutls_certificate_credentials_t cred;
-	m_retCode = gnutls_certificate_allocate_credentials(&cred);
-	if (m_retCode != 0)
-	{
-		ReportError("Could not create TLS context", false);
-		return false;
-	}
-
-	m_context = cred;
-
-	if (m_certFile && m_keyFile)
-	{
-		m_retCode = gnutls_certificate_set_x509_key_file((gnutls_certificate_credentials_t)m_context,
-			m_certFile, m_keyFile, GNUTLS_X509_FMT_PEM);
-		if (m_retCode != 0)
-		{
-			ReportError("Could not load certificate or key file", false);
-			Close();
-			return false;
-		}
-	}
-
-	gnutls_session_t sess;
-	m_retCode = gnutls_init(&sess, m_isClient ? GNUTLS_CLIENT : GNUTLS_SERVER);
-	if (m_retCode != 0)
-	{
-		ReportError("Could not create TLS session", false);
-		Close();
-		return false;
-	}
-
-	m_session = sess;
-
-	m_initialized = true;
-
-	const char* priority = !m_cipher.Empty() ? m_cipher.Str() :
-		(m_certFile && m_keyFile ? "NORMAL:!VERS-SSL3.0" : "NORMAL");
-
-	m_retCode = gnutls_priority_set_direct((gnutls_session_t)m_session, priority, nullptr);
-	if (m_retCode != 0)
-	{
-		ReportError("Could not select cipher for TLS", false);
-		Close();
-		return false;
-	}
-
-	if (m_host)
-	{
-		m_retCode = gnutls_server_name_set((gnutls_session_t)m_session, GNUTLS_NAME_DNS, m_host, m_host.Length());
-		if (m_retCode != 0)
-		{
-			ReportError("Could not set hostname for TLS");
-			Close();
-			return false;
-		}
-	}
-
-	m_retCode = gnutls_credentials_set((gnutls_session_t)m_session, GNUTLS_CRD_CERTIFICATE,
-		(gnutls_certificate_credentials_t*)m_context);
-	if (m_retCode != 0)
-	{
-		ReportError("Could not initialize TLS session", false);
-		Close();
-		return false;
-	}
-
-	gnutls_transport_set_ptr((gnutls_session_t)m_session, (gnutls_transport_ptr_t)(size_t)m_socket);
-
-	m_retCode = gnutls_handshake((gnutls_session_t)m_session);
-	if (m_retCode != 0)
-	{
-		ReportError(BString<1024>("TLS handshake failed for %s", *m_host));
-		Close();
-		return false;
-	}
-
-	if (m_isClient && !m_certStore.Empty() && !ValidateCert())
-	{
-		Close();
-		return false;
-	}
-
-	m_connected = true;
-	return true;
-#endif /* HAVE_LIBGNUTLS */
-
-#ifdef HAVE_OPENSSL
-	m_context = SSL_CTX_new(SSLv23_method());
-
-	if (!m_context)
-	{
-		ReportError("Could not create TLS context", false);
-		return false;
-	}
-
-	if (m_certFile && m_keyFile)
-	{
-		if (SSL_CTX_use_certificate_chain_file((SSL_CTX*)m_context, m_certFile) != 1)
-		{
-			ReportError("Could not load certificate file", false);
-			Close();
-			return false;
-		}
-		if (SSL_CTX_use_PrivateKey_file((SSL_CTX*)m_context, m_keyFile, SSL_FILETYPE_PEM) != 1)
-		{
-			ReportError("Could not load key file", false);
-			Close();
-			return false;
-		}
-		if (!SSL_CTX_set_options((SSL_CTX*)m_context, SSL_OP_NO_SSLv3))
-		{
-			ReportError("Could not select minimum protocol version for TLS", false);
-			Close();
-			return false;
-		}
-
-		// For ECC certificates
-		EC_KEY* ecdh = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);
-		if (!ecdh)
-		{
-			ReportError("Could not generate ecdh parameters for TLS", false);
-			Close();
-			return false;
-		}
-		if (!SSL_CTX_set_tmp_ecdh((SSL_CTX*)m_context, ecdh))
-		{
-			ReportError("Could not set ecdh parameters for TLS", false);
-			EC_KEY_free(ecdh);
-			Close();
-			return false;
-		}
-		EC_KEY_free(ecdh);
-	}
-
-	if (m_isClient && !m_certStore.Empty())
-	{
-		// Enable certificate validation
-		if (SSL_CTX_load_verify_locations((SSL_CTX*)m_context, m_certStore, nullptr) != 1)
-		{
-			ReportError("Could not set certificate store location", false);
-			Close();
-			return false;
-		}
-
-		SSL_CTX_set_verify((SSL_CTX*)m_context, SSL_VERIFY_PEER, nullptr);
-	}
-
-	m_session = SSL_new((SSL_CTX*)m_context);
-	if (!m_session)
-	{
-		ReportError("Could not create TLS session", false);
-		Close();
-		return false;
-	}
-
-	if (!m_cipher.Empty() && !SSL_set_cipher_list((SSL*)m_session, m_cipher))
-	{
-		ReportError("Could not select cipher for TLS", false);
-		Close();
-		return false;
-	}
-
-	if (m_isClient && m_host && !SSL_set_tlsext_host_name((SSL*)m_session, m_host))
-	{
-		ReportError("Could not set host name for TLS");
-		Close();
-		return false;
-	}
-
-	if (!SSL_set_fd((SSL*)m_session, (int)m_socket))
-	{
-		ReportError("Could not set the file descriptor for TLS");
-		Close();
-		return false;
-	}
-
-	int error_code = m_isClient ? SSL_connect((SSL*)m_session) : SSL_accept((SSL*)m_session);
-	if (error_code < 1)
-	{
-		long verifyRes = SSL_get_verify_result((SSL*)m_session);
-		if (verifyRes != X509_V_OK)
-		{
-			PrintError(BString<1024>("TLS certificate verification failed for %s: %s."
-				" For more info visit http://nzbget.net/certificate-verification",
-				*m_host, X509_verify_cert_error_string(verifyRes)));
-		}
-		else
-		{
-			ReportError(BString<1024>("TLS handshake failed for %s", *m_host));
-		}
-		Close();
-		return false;
-	}
-
-	if (m_isClient && !m_certStore.Empty() && !ValidateCert())
-	{
-		Close();
-		return false;
-	}
-
-	m_connected = true;
-	return true;
-#endif /* HAVE_OPENSSL */
-}
-
-bool TlsSocket::ValidateCert()
-{
-#ifdef HAVE_LIBGNUTLS
-#if	GNUTLS_VERSION_NUMBER >= 0x030104
-#if	GNUTLS_VERSION_NUMBER >= 0x030306
-	if (FileSystem::DirectoryExists(m_certStore))
-	{
-		if (gnutls_certificate_set_x509_trust_dir((gnutls_certificate_credentials_t)m_context, m_certStore, GNUTLS_X509_FMT_PEM) < 0)
-		{
-			ReportError("Could not set certificate store location");
-			return false;
-		}
-	}
-	else
-#endif
-	{
-		if (gnutls_certificate_set_x509_trust_file((gnutls_certificate_credentials_t)m_context, m_certStore, GNUTLS_X509_FMT_PEM) < 0)
-		{
-			ReportError("Could not set certificate store location");
-			return false;
-		}
-	}
-
-	unsigned int status = 0;
-	if (gnutls_certificate_verify_peers3((gnutls_session_t)m_session, m_host, &status) != 0 ||
-		gnutls_certificate_type_get((gnutls_session_t)m_session) != GNUTLS_CRT_X509)
-	{
-		ReportError("Could not verify TLS certificate");
-		return false;
-	}
-
-	if (status != 0)
-	{
-		if (status & GNUTLS_CERT_UNEXPECTED_OWNER)
-		{
-			// Extracting hostname from the certificate
-			unsigned int cert_list_size = 0;
-			const gnutls_datum_t* cert_list = gnutls_certificate_get_peers((gnutls_session_t)m_session, &cert_list_size);
-			if (cert_list_size > 0)
-			{
-				gnutls_x509_crt_t cert;
-				gnutls_x509_crt_init(&cert);
-				gnutls_x509_crt_import(cert, &cert_list[0], GNUTLS_X509_FMT_DER);
-				char dn[256];
-				size_t size = sizeof(dn);
-				if (gnutls_x509_crt_get_dn_by_oid(cert, GNUTLS_OID_X520_COMMON_NAME, 0, 0, dn, &size) == 0)
-				{
-					PrintError(BString<1024>("TLS certificate verification failed for %s: certificate hostname mismatch (%s)."
-						" For more info visit http://nzbget.net/certificate-verification", *m_host, dn));
-					gnutls_x509_crt_deinit(cert);
-					return false;
-				}
-				gnutls_x509_crt_deinit(cert);
-			}
-		}
-
-		gnutls_datum_t msgdata;
-		if (gnutls_certificate_verification_status_print(status, GNUTLS_CRT_X509, &msgdata, 0) == 0)
-		{
-			PrintError(BString<1024>("TLS certificate verification failed for %s: %s."
-				" For more info visit http://nzbget.net/certificate-verification", *m_host, msgdata.data));
-			gnutls_free(&msgdata);
-		}
-		else
-		{
-			ReportError(BString<1024>("TLS certificate verification failed for %s."
-				" For more info visit http://nzbget.net/certificate-verification", *m_host));
-		}
-		return false;
-	}
-#endif
-	return true;
-#endif /* HAVE_LIBGNUTLS */
-
-#ifdef HAVE_OPENSSL
-	// verify a server certificate was presented during the negotiation
-	X509* cert = SSL_get_peer_certificate((SSL*)m_session);
-	if (!cert)
-	{
-		PrintError(BString<1024>("TLS certificate verification failed for %s: no certificate provided by server."
-			" For more info visit http://nzbget.net/certificate-verification", *m_host));
-		return false;
-	}
-
-#ifdef HAVE_X509_CHECK_HOST
-	// hostname verification
-	if (!m_host.Empty() && X509_check_host(cert, m_host, m_host.Length(), 0, nullptr) != 1)
-	{
-		const unsigned char* certHost = nullptr;
-        // Find the position of the CN field in the Subject field of the certificate
-        int common_name_loc = X509_NAME_get_index_by_NID(X509_get_subject_name(cert), NID_commonName, -1);
-        if (common_name_loc >= 0)
-		{
-			// Extract the CN field
-			X509_NAME_ENTRY* common_name_entry = X509_NAME_get_entry(X509_get_subject_name(cert), common_name_loc);
-			if (common_name_entry != nullptr)
-			{
-				// Convert the CN field to a C string
-				ASN1_STRING* common_name_asn1 = X509_NAME_ENTRY_get_data(common_name_entry);
-				if (common_name_asn1 != nullptr)
-				{
-#if OPENSSL_VERSION_NUMBER >= 0x10100000L
-					certHost = ASN1_STRING_get0_data(common_name_asn1);
-#else
-					certHost = ASN1_STRING_data(common_name_asn1);
-#endif
-				}
-			}
-        }
-
-		PrintError(BString<1024>("TLS certificate verification failed for %s: certificate hostname mismatch (%s)."
-			" For more info visit http://nzbget.net/certificate-verification", *m_host, certHost));
-		X509_free(cert);
-		return false;
-	}
-#endif
-
-	X509_free(cert);
-	return true;
-#endif /* HAVE_OPENSSL */
-}
-
-void TlsSocket::Close()
-{
-	if (m_session)
-	{
-#ifdef HAVE_LIBGNUTLS
-		if (m_connected)
-		{
-			gnutls_bye((gnutls_session_t)m_session, GNUTLS_SHUT_WR);
-		}
-		if (m_initialized)
-		{
-			gnutls_deinit((gnutls_session_t)m_session);
-		}
-#endif /* HAVE_LIBGNUTLS */
-
-#ifdef HAVE_OPENSSL
-		if (m_connected)
-		{
-			SSL_shutdown((SSL*)m_session);
-		}
-		SSL_free((SSL*)m_session);
-#endif /* HAVE_OPENSSL */
-
-		m_session = nullptr;
-	}
-
-	if (m_context)
-	{
-#ifdef HAVE_LIBGNUTLS
-		gnutls_certificate_free_credentials((gnutls_certificate_credentials_t)m_context);
-#endif /* HAVE_LIBGNUTLS */
-
-#ifdef HAVE_OPENSSL
-		SSL_CTX_free((SSL_CTX*)m_context);
-#endif /* HAVE_OPENSSL */
-
-		m_context = nullptr;
-	}
-}
-
-int TlsSocket::Send(const char* buffer, int size)
-{
-#ifdef HAVE_LIBGNUTLS
-	m_retCode = gnutls_record_send((gnutls_session_t)m_session, buffer, size);
-#endif /* HAVE_LIBGNUTLS */
-
-#ifdef HAVE_OPENSSL
-	m_retCode = SSL_write((SSL*)m_session, buffer, size);
-#endif /* HAVE_OPENSSL */
-
-	if (m_retCode < 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 m_retCode;
-}
-
-int TlsSocket::Recv(char* buffer, int size)
-{
-#ifdef HAVE_LIBGNUTLS
-	m_retCode = gnutls_record_recv((gnutls_session_t)m_session, buffer, size);
-#endif /* HAVE_LIBGNUTLS */
-
-#ifdef HAVE_OPENSSL
-	m_retCode = SSL_read((SSL*)m_session, buffer, size);
-#endif /* HAVE_OPENSSL */
-
-	if (m_retCode < 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 m_retCode;
-}
-
-#endif

daemon/connect/TlsSocket.h

@@ -1,69 +0,0 @@
-/*
- *  This file is part of nzbget. See <http://nzbget.net>.
- *
- *  Copyright (C) 2008-2016 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, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef TLSSOCKET_H
-#define TLSSOCKET_H
-
-#ifndef DISABLE_TLS
-
-#include "NString.h"
-
-class TlsSocket
-{
-public:
-	TlsSocket(SOCKET socket, bool isClient, const char* host,
-		const char* certFile, const char* keyFile, const char* cipher) :
-		m_socket(socket), m_isClient(isClient), m_host(host),
-		m_certFile(certFile), m_keyFile(keyFile), m_cipher(cipher) {}
-	virtual ~TlsSocket();
-	static void Init();
-	static void InitOptions(const char* certStore) { m_certStore = certStore; }
-	static void Final();
-	bool Start();
-	void Close();
-	int Send(const char* buffer, int size);
-	int Recv(char* buffer, int size);
-	void SetSuppressErrors(bool suppressErrors) { m_suppressErrors = suppressErrors; }
-
-protected:
-	virtual void PrintError(const char* errMsg);
-
-private:
-	SOCKET m_socket;
-	bool m_isClient;
-	CString m_host;
-	CString m_certFile;
-	CString m_keyFile;
-	CString m_cipher;
-	bool m_suppressErrors = false;
-	bool m_initialized = false;
-	bool m_connected = false;
-	int m_retCode;
-	static CString m_certStore;
-
-	// using "void*" to prevent the including of GnuTLS/OpenSSL header files into TlsSocket.h
-	void* m_context = nullptr;
-	void* m_session = nullptr;
-
-	void ReportError(const char* errMsg, bool suppressable = true);
-	bool ValidateCert();
-};
-
-#endif
-#endif

daemon/connect/WebDownloader.cpp

@@ -1,666 +0,0 @@
-/*
- *  This file is part of nzbget. See <http://nzbget.net>.
- *
- *  Copyright (C) 2012-2019 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, see <http://www.gnu.org/licenses/>.
- */
-
-
-#include "nzbget.h"
-#include "WebDownloader.h"
-#include "Log.h"
-#include "Options.h"
-#include "WorkState.h"
-#include "Util.h"
-#include "FileSystem.h"
-
-WebDownloader::WebDownloader()
-{
-	debug("Creating WebDownloader");
-
-	SetLastUpdateTimeNow();
-}
-
-void WebDownloader::SetUrl(const char* url)
-{
-	m_url = WebUtil::UrlEncode(url);
-}
-
-void WebDownloader::SetStatus(EStatus status)
-{
-	m_status = status;
-	Notify(nullptr);
-}
-
-void WebDownloader::SetLastUpdateTimeNow()
-{
-	m_lastUpdateTime = Util::CurrentTime();
-}
-
-void WebDownloader::Run()
-{
-	debug("Entering WebDownloader-loop");
-
-	SetStatus(adRunning);
-
-	int remainedDownloadRetries = g_Options->GetUrlRetries() > 0 ? g_Options->GetUrlRetries() : 1;
-	int remainedConnectRetries = remainedDownloadRetries > 10 ? remainedDownloadRetries : 10;
-	if (!m_retry)
-	{
-		remainedDownloadRetries = 1;
-		remainedConnectRetries = 1;
-	}
-
-	EStatus Status = adFailed;
-
-	while (!IsStopped() && remainedDownloadRetries > 0 && remainedConnectRetries > 0)
-	{
-		SetLastUpdateTimeNow();
-
-		Status = DownloadWithRedirects(5);
-
-		if ((((Status == adFailed) && (remainedDownloadRetries > 1)) ||
-			((Status == adConnectError) && (remainedConnectRetries > 1)))
-			&& !IsStopped() && !(!m_force && g_WorkState->GetPauseDownload()))
-		{
-			detail("Waiting %i sec to retry", g_Options->GetUrlInterval());
-			int msec = 0;
-			while (!IsStopped() && (msec < g_Options->GetUrlInterval() * 1000) &&
-				!(!m_force && g_WorkState->GetPauseDownload()))
-			{
-				Util::Sleep(100);
-				msec += 100;
-			}
-		}
-
-		if (IsStopped() || (!m_force && g_WorkState->GetPauseDownload()))
-		{
-			Status = adRetry;
-			break;
-		}
-
-		if (Status == adFinished || Status == adFatalError || Status == adNotFound)
-		{
-			break;
-		}
-
-		if (Status != adConnectError)
-		{
-			remainedDownloadRetries--;
-		}
-		else
-		{
-			remainedConnectRetries--;
-		}
-	}
-
-	if (Status != adFinished && Status != adRetry)
-	{
-		Status = adFailed;
-	}
-
-	if (Status == adFailed)
-	{
-		if (IsStopped())
-		{
-			detail("Download %s cancelled", *m_infoName);
-		}
-		else
-		{
-			error("Download %s failed", *m_infoName);
-		}
-	}
-
-	if (Status == adFinished)
-	{
-		detail("Download %s completed", *m_infoName);
-	}
-
-	SetStatus(Status);
-
-	debug("Exiting WebDownloader-loop");
-}
-
-WebDownloader::EStatus WebDownloader::Download()
-{
-	EStatus Status = adRunning;
-
-	URL url(m_url);
-
-	Status = CreateConnection(&url);
-	if (Status != adRunning)
-	{
-		return Status;
-	}
-
-	m_connection->SetTimeout(g_Options->GetUrlTimeout());
-	m_connection->SetSuppressErrors(false);
-
-	// connection
-	bool connected = m_connection->Connect();
-	if (!connected || IsStopped())
-	{
-		FreeConnection();
-		return adConnectError;
-	}
-
-	// Okay, we got a Connection. Now start downloading.
-	detail("Downloading %s", *m_infoName);
-
-	SendHeaders(&url);
-
-	Status = DownloadHeaders();
-
-	if (Status == adRunning)
-	{
-		Status = DownloadBody();
-	}
-
-	if (IsStopped())
-	{
-		Status = adFailed;
-	}
-
-	FreeConnection();
-
-	if (Status != adFinished)
-	{
-		// Download failed, delete broken output file
-		FileSystem::DeleteFile(m_outputFilename);
-	}
-
-	return Status;
-}
-
-WebDownloader::EStatus WebDownloader::DownloadWithRedirects(int maxRedirects)
-{
-	// do sync download, following redirects
-	EStatus status = adRedirect;
-	while (status == adRedirect && maxRedirects >= 0)
-	{
-		maxRedirects--;
-		status = Download();
-	}
-
-	if (status == adRedirect && maxRedirects < 0)
-	{
-		warn("Too many redirects for %s", *m_infoName);
-		status = adFailed;
-	}
-
-	return status;
-}
-
-WebDownloader::EStatus WebDownloader::CreateConnection(URL *url)
-{
-	if (!url->IsValid())
-	{
-		error("URL is not valid: %s", url->GetAddress());
-		return adFatalError;
-	}
-
-	int port = url->GetPort();
-	if (port == 0 && !strcasecmp(url->GetProtocol(), "http"))
-	{
-		port = 80;
-	}
-	if (port == 0 && !strcasecmp(url->GetProtocol(), "https"))
-	{
-		port = 443;
-	}
-
-	if (strcasecmp(url->GetProtocol(), "http") && strcasecmp(url->GetProtocol(), "https"))
-	{
-		error("Unsupported protocol in URL: %s", url->GetAddress());
-		return adFatalError;
-	}
-
-#ifdef DISABLE_TLS
-	if (!strcasecmp(url->GetProtocol(), "https"))
-	{
-		error("Program was compiled without TLS/SSL-support. Cannot download using https protocol. URL: %s", url->GetAddress());
-		return adFatalError;
-	}
-#endif
-
-	bool tls = !strcasecmp(url->GetProtocol(), "https");
-
-	m_connection = std::make_unique<Connection>(url->GetHost(), port, tls);
-
-	return adRunning;
-}
-
-void WebDownloader::SendHeaders(URL *url)
-{
-	// retrieve file
-	m_connection->WriteLine(BString<1024>("GET %s HTTP/1.0\r\n", url->GetResource()));
-	m_connection->WriteLine(BString<1024>("User-Agent: nzbget/%s\r\n", Util::VersionRevision()));
-
-	if ((!strcasecmp(url->GetProtocol(), "http") && (url->GetPort() == 80 || url->GetPort() == 0)) ||
-		(!strcasecmp(url->GetProtocol(), "https") && (url->GetPort() == 443 || url->GetPort() == 0)))
-	{
-		m_connection->WriteLine(BString<1024>("Host: %s\r\n", url->GetHost()));
-	}
-	else
-	{
-		m_connection->WriteLine(BString<1024>("Host: %s:%i\r\n", url->GetHost(), url->GetPort()));
-	}
-
-	m_connection->WriteLine("Accept: */*\r\n");
-#ifndef DISABLE_GZIP
-	m_connection->WriteLine("Accept-Encoding: gzip\r\n");
-#endif
-	m_connection->WriteLine("Connection: close\r\n");
-	m_connection->WriteLine("\r\n");
-}
-
-WebDownloader::EStatus WebDownloader::DownloadHeaders()
-{
-	EStatus Status = adRunning;
-
-	m_confirmedLength = false;
-	CharBuffer lineBuf(1024*10);
-	m_contentLen = -1;
-	bool firstLine = true;
-	m_gzip = false;
-	m_redirecting = false;
-	m_redirected = false;
-
-	// Headers
-	while (!IsStopped())
-	{
-		SetLastUpdateTimeNow();
-
-		int len = 0;
-		char* line = m_connection->ReadLine(lineBuf, lineBuf.Size(), &len);
-
-		if (firstLine)
-		{
-			Status = CheckResponse(lineBuf);
-			if (Status != adRunning)
-			{
-				break;
-			}
-			firstLine = false;
-		}
-
-		// Have we encountered a timeout?
-		if (!line)
-		{
-			if (!IsStopped())
-			{
-				warn("URL %s failed: Unexpected end of file", *m_infoName);
-			}
-			Status = adFailed;
-			break;
-		}
-
-		debug("Header: %s", line);
-
-		// detect body of response
-		if (*line == '\r' || *line == '\n')
-		{
-			break;
-		}
-
-		Util::TrimRight(line);
-		ProcessHeader(line);
-
-		if (m_redirected)
-		{
-			Status = adRedirect;
-			break;
-		}
-	}
-
-	return Status;
-}
-
-WebDownloader::EStatus WebDownloader::DownloadBody()
-{
-	EStatus Status = adRunning;
-
-	m_outFile.Close();
-	bool end = false;
-	CharBuffer lineBuf(1024*10);
-	int writtenLen = 0;
-
-#ifndef DISABLE_GZIP
-	m_gUnzipStream.reset();
-	if (m_gzip)
-	{
-		m_gUnzipStream = std::make_unique<GUnzipStream>(1024*10);
-	}
-#endif
-
-	// Body
-	while (!IsStopped())
-	{
-		SetLastUpdateTimeNow();
-
-		char* buffer;
-		int len;
-		m_connection->ReadBuffer(&buffer, &len);
-		if (len == 0)
-		{
-			len = m_connection->TryRecv(lineBuf, lineBuf.Size());
-			buffer = lineBuf;
-		}
-
-		// Connection closed or timeout?
-		if (len <= 0)
-		{
-			if (len == 0 && m_contentLen == -1 && writtenLen > 0)
-			{
-				end = true;
-				break;
-			}
-
-			if (!IsStopped())
-			{
-				warn("URL %s failed: Unexpected end of file", *m_infoName);
-			}
-			Status = adFailed;
-			break;
-		}
-
-		// write to output file
-		if (!Write(buffer, len))
-		{
-			Status = adFatalError;
-			break;
-		}
-		writtenLen += len;
-
-		//detect end of file
-		if (writtenLen == m_contentLen || (m_contentLen == -1 && m_gzip && m_confirmedLength))
-		{
-			end = true;
-			break;
-		}
-	}
-
-#ifndef DISABLE_GZIP
-	m_gUnzipStream.reset();
-#endif
-
-	m_outFile.Close();
-
-	if (!end && Status == adRunning && !IsStopped())
-	{
-		warn("URL %s failed: file incomplete", *m_infoName);
-		Status = adFailed;
-	}
-
-	if (end)
-	{
-		Status = adFinished;
-	}
-
-	return Status;
-}
-
-WebDownloader::EStatus WebDownloader::CheckResponse(const char* response)
-{
-	if (!response)
-	{
-		if (!IsStopped())
-		{
-			warn("URL %s: Connection closed by remote host", *m_infoName);
-		}
-		return adConnectError;
-	}
-
-	const char* hTTPResponse = strchr(response, ' ');
-	if (strncmp(response, "HTTP", 4) || !hTTPResponse)
-	{
-		warn("URL %s failed: %s", *m_infoName, response);
-		return adFailed;
-	}
-
-	hTTPResponse++;
-
-	if (!strncmp(hTTPResponse, "400", 3) || !strncmp(hTTPResponse, "499", 3))
-	{
-		warn("URL %s failed: %s", *m_infoName, hTTPResponse);
-		return adConnectError;
-	}
-	else if (!strncmp(hTTPResponse, "404", 3))
-	{
-		warn("URL %s failed: %s", *m_infoName, hTTPResponse);
-		return adNotFound;
-	}
-	else if (!strncmp(hTTPResponse, "301", 3) || !strncmp(hTTPResponse, "302", 3) ||
-		 !strncmp(hTTPResponse, "303", 3) || !strncmp(hTTPResponse, "307", 3) ||
-		 !strncmp(hTTPResponse, "308", 3))
-	{
-		m_redirecting = true;
-		return adRunning;
-	}
-	else if (!strncmp(hTTPResponse, "200", 3))
-	{
-		// OK
-		return adRunning;
-	}
-	else
-	{
-		// unknown error, no special handling
-		warn("URL %s failed: %s", *m_infoName, response);
-		return adFailed;
-	}
-}
-
-void WebDownloader::ProcessHeader(const char* line)
-{
-	if (!strncasecmp(line, "Content-Length: ", 16))
-	{
-		m_contentLen = atoi(line + 16);
-		m_confirmedLength = true;
-	}
-	else if (!strncasecmp(line, "Content-Encoding: gzip", 22))
-	{
-		m_gzip = true;
-	}
-	else if (!strncasecmp(line, "Content-Disposition: ", 21))
-	{
-		ParseFilename(line);
-	}
-	else if (m_redirecting && !strncasecmp(line, "Location: ", 10))
-	{
-		ParseRedirect(line + 10);
-		m_redirected = true;
-	}
-}
-
-void WebDownloader::ParseFilename(const char* contentDisposition)
-{
-	// Examples:
-	// Content-Disposition: attachment; filename="fname.ext"
-	// Content-Disposition: attachement;filename=fname.ext
-	// Content-Disposition: attachement;filename=fname.ext;
-	const char *p = strstr(contentDisposition, "filename");
-	if (!p)
-	{
-		return;
-	}
-
-	p = strchr(p, '=');
-	if (!p)
-	{
-		return;
-	}
-
-	p++;
-
-	while (*p == ' ') p++;
-
-	BString<1024> fname = p;
-
-	char *pe = fname + strlen(fname) - 1;
-	while ((*pe == ' ' || *pe == '\n' || *pe == '\r' || *pe == ';') && pe > fname) {
-		*pe = '\0';
-		pe--;
-	}
-
-	WebUtil::HttpUnquote(fname);
-
-	m_originalFilename = FileSystem::BaseFileName(fname);
-
-	debug("OriginalFilename: %s", *m_originalFilename);
-}
-
-void WebDownloader::ParseRedirect(const char* location)
-{
-	const char* newLocation = location;
-	BString<1024> urlBuf;
-	URL newUrl(newLocation);
-	if (!newUrl.IsValid())
-	{
-		// redirect within host
-
-		BString<1024> resource;
-		URL oldUrl(m_url);
-
-		if (*location == '/')
-		{
-			// absolute path within host
-			resource = location;
-		}
-		else
-		{
-			// relative path within host
-			resource = oldUrl.GetResource();
-
-			char* p = strchr(resource, '?');
-			if (p)
-			{
-				*p = '\0';
-			}
-
-			p = strrchr(resource, '/');
-			if (p)
-			{
-				p[1] = '\0';
-			}
-
-			resource.Append(location);
-		}
-
-		if (oldUrl.GetPort() > 0)
-		{
-			urlBuf.Format("%s://%s:%i%s", oldUrl.GetProtocol(), oldUrl.GetHost(), oldUrl.GetPort(), *resource);
-		}
-		else
-		{
-			urlBuf.Format("%s://%s%s", oldUrl.GetProtocol(), oldUrl.GetHost(), *resource);
-		}
-		newLocation = urlBuf;
-	}
-	detail("URL %s redirected to %s", *m_url, newLocation);
-	SetUrl(newLocation);
-}
-
-bool WebDownloader::Write(void* buffer, int len)
-{
-	if (!m_outFile.Active() && !PrepareFile())
-	{
-		return false;
-	}
-
-#ifndef DISABLE_GZIP
-	if (m_gzip)
-	{
-		m_gUnzipStream->Write(buffer, len);
-		const void *outBuf;
-		int outLen = 1;
-		while (outLen > 0)
-		{
-			GUnzipStream::EStatus gZStatus = m_gUnzipStream->Read(&outBuf, &outLen);
-
-			if (gZStatus == GUnzipStream::zlError)
-			{
-				error("URL %s: GUnzip failed", *m_infoName);
-				return false;
-			}
-
-			if (outLen > 0 && m_outFile.Write(outBuf, outLen) <= 0)
-			{
-				return false;
-			}
-
-			if (gZStatus == GUnzipStream::zlFinished)
-			{
-				m_confirmedLength = true;
-				return true;
-			}
-		}
-		return true;
-	}
-	else
-#endif
-
-	return m_outFile.Write(buffer, len) > 0;
-}
-
-bool WebDownloader::PrepareFile()
-{
-	// prepare file for writing
-
-	const char* filename = m_outputFilename;
-	if (!m_outFile.Open(filename, DiskFile::omWrite))
-	{
-		error("Could not %s file %s", "create", filename);
-		return false;
-	}
-	if (g_Options->GetWriteBuffer() > 0)
-	{
-		m_outFile.SetWriteBuffer(g_Options->GetWriteBuffer() * 1024);
-	}
-
-	return true;
-}
-
-void WebDownloader::LogDebugInfo()
-{
-	info("      Web-Download: status=%i, LastUpdateTime=%s, filename=%s", m_status,
-		*Util::FormatTime(m_lastUpdateTime), FileSystem::BaseFileName(m_outputFilename));
-}
-
-void WebDownloader::Stop()
-{
-	debug("Trying to stop WebDownloader");
-	Thread::Stop();
-	Guard guard(m_connectionMutex);
-	if (m_connection)
-	{
-		m_connection->SetSuppressErrors(true);
-		m_connection->Cancel();
-	}
-	debug("WebDownloader stopped successfully");
-}
-
-void WebDownloader::FreeConnection()
-{
-	if (m_connection)
-	{
-		debug("Releasing connection");
-		Guard guard(m_connectionMutex);
-		if (m_connection->GetStatus() == Connection::csCancelled)
-		{
-			m_connection->Disconnect();
-		}
-		m_connection.reset();
-	}
-}