Merge pull request #35 from pocoproject/develop

Sync 16.12.2016

CMakeLists.txt

@@ -143,7 +143,7 @@ set(Poco_COMPONENTS "")
 # Pthreads/threads support
 find_package(Threads REQUIRED)
 
-if (ENABLE_TESTS)
+if (ENABLE_TESTS OR ENABLE_CPPUNIT)
    add_subdirectory(CppUnit)
    list(APPEND Poco_COMPONENTS "CppUnit")
 endif ()
@@ -182,18 +182,20 @@ if(WIN32 AND ENABLE_NETSSL_WIN)
     list(APPEND Poco_COMPONENTS "NetSSL_Win")
 endif(WIN32 AND ENABLE_NETSSL_WIN)
 
-find_package(OpenSSL)
+if(ENABLE_NETSSL OR ENABLE_CRYPTO)
-if(OPENSSL_FOUND)
+    find_package(OpenSSL REQUIRED)
-    include_directories("${OPENSSL_INCLUDE_DIR}")
+    if(OPENSSL_FOUND)
-    if(ENABLE_NETSSL)
+        include_directories("${OPENSSL_INCLUDE_DIR}")
-    add_subdirectory(NetSSL_OpenSSL)
+        if(ENABLE_NETSSL)
-    list(APPEND Poco_COMPONENTS "NetSSL_OpenSSL")
+        add_subdirectory(NetSSL_OpenSSL)
-    endif()
+        list(APPEND Poco_COMPONENTS "NetSSL_OpenSSL")
-    if(ENABLE_CRYPTO)
+        endif()
-    add_subdirectory(Crypto)
+        if(ENABLE_CRYPTO)
-    list(APPEND Poco_COMPONENTS "Crypto")
+        add_subdirectory(Crypto)
-    endif()
+        list(APPEND Poco_COMPONENTS "Crypto")
-endif(OPENSSL_FOUND)
+        endif()
+    endif(OPENSSL_FOUND)
+endif(ENABLE_NETSSL OR ENABLE_CRYPTO)
 
 if(ENABLE_DATA)
 add_subdirectory(Data)
@@ -314,4 +316,3 @@ message(STATUS "CMAKE_CXX_FLAGS_RELWITHDEBINFO:=${CMAKE_CXX_FLAGS_RELWITHDEBINFO
 foreach(component ${Poco_COMPONENTS})
 message(STATUS "Building: ${component}")
 endforeach()
-

CppUnit/include/Poco/CppUnit/TestCaller.h

@@ -89,7 +89,11 @@ protected:
 
 private:
 	TestMethod             _test;
+#if __cplusplus < 201103L
 	std::auto_ptr<Fixture> _fixture;
+#else
+	std::unique_ptr<Fixture> _fixture;
+#endif
 };
 
 

Crypto/include/Poco/Crypto/DigestEngine.h

@@ -61,7 +61,7 @@ protected:
 	
 private:
 	std::string _name;
-	EVP_MD_CTX* _ctx;
+	EVP_MD_CTX* _pContext;
 	Poco::DigestEngine::Digest _digest;
 	OpenSSLInitializer _openSSLInitializer;
 };

Crypto/src/CipherImpl.cpp

@@ -77,7 +77,11 @@ namespace
 
 	private:
 		const EVP_CIPHER* _pCipher;
-		EVP_CIPHER_CTX    _ctx;
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+		EVP_CIPHER_CTX*   _pContext;
+#else
+		EVP_CIPHER_CTX    _context;
+#endif
 		ByteVec           _key;
 		ByteVec           _iv;
 	};
@@ -92,30 +96,52 @@ namespace
 		_key(key),
 		_iv(iv)
 	{
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+		_pContext = EVP_CIPHER_CTX_new();
 		EVP_CipherInit(
-			&_ctx,
+			_pContext,
 			_pCipher,
 			&_key[0],
 			_iv.empty() ? 0 : &_iv[0],
 			(dir == DIR_ENCRYPT) ? 1 : 0);
+#else
+		EVP_CipherInit(
+			&_context,
+			_pCipher,
+			&_key[0],
+			_iv.empty() ? 0 : &_iv[0],
+			(dir == DIR_ENCRYPT) ? 1 : 0);
+#endif
 	}
 
 
 	CryptoTransformImpl::~CryptoTransformImpl()
 	{
-		EVP_CIPHER_CTX_cleanup(&_ctx);
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+		EVP_CIPHER_CTX_cleanup(_pContext);
+#else
+		EVP_CIPHER_CTX_cleanup(&_context);
+#endif
 	}
 
 
 	std::size_t CryptoTransformImpl::blockSize() const
 	{
-		return EVP_CIPHER_CTX_block_size(&_ctx);
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+		return EVP_CIPHER_CTX_block_size(_pContext);
+#else
+		return EVP_CIPHER_CTX_block_size(&_context);
+#endif
 	}
 
 	
 	int CryptoTransformImpl::setPadding(int padding)
 	{
-		return EVP_CIPHER_CTX_set_padding(&_ctx, padding);
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+		return EVP_CIPHER_CTX_block_size(_pContext);
+#else
+		return EVP_CIPHER_CTX_set_padding(&_context, padding);
+#endif
 	}
 	
 
@@ -128,13 +154,21 @@ namespace
 		poco_assert (outputLength >= (inputLength + blockSize() - 1));
 
 		int outLen = static_cast<int>(outputLength);
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
 		int rc = EVP_CipherUpdate(
-			&_ctx,
+			_pContext,
 			output,
 			&outLen,
 			input,
 			static_cast<int>(inputLength));
-
+#else
+		int rc = EVP_CipherUpdate(
+			&_context,
+			output,
+			&outLen,
+			input,
+			static_cast<int>(inputLength));
+#endif
 		if (rc == 0)
 			throwError();
 
@@ -153,7 +187,11 @@ namespace
 		// Use the '_ex' version that does not perform implicit cleanup since we
 		// will call EVP_CIPHER_CTX_cleanup() from the dtor as there is no
 		// guarantee that finalize() will be called if an error occurred.
-		int rc = EVP_CipherFinal_ex(&_ctx, output, &len);
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+		int rc = EVP_CipherFinal_ex(_pContext, output, &len);
+#else
+		int rc = EVP_CipherFinal_ex(&_context, output, &len);
+#endif
 
 		if (rc == 0)
 			throwError();

Crypto/src/DigestEngine.cpp

@@ -23,46 +23,51 @@ namespace Crypto {
 
 
 DigestEngine::DigestEngine(const std::string& name):
-	_name(name)
+	_name(name),
+	_pContext(EVP_MD_CTX_create())
 {
 	const EVP_MD* md = EVP_get_digestbyname(_name.c_str());
 	if (!md) throw Poco::NotFoundException(_name);
-	_ctx = EVP_MD_CTX_create();
+	EVP_DigestInit_ex(_pContext, md, NULL);	
-	EVP_DigestInit_ex(_ctx, md, NULL);	
 }
 
 	
 DigestEngine::~DigestEngine()
 {
-	EVP_MD_CTX_destroy(_ctx);
+	EVP_MD_CTX_destroy(_pContext);
 }
 
 int DigestEngine::nid() const
 {
-	return EVP_MD_nid(_ctx->digest);
+	return EVP_MD_nid(EVP_MD_CTX_md(_pContext));
 }
 
 std::size_t DigestEngine::digestLength() const
 {
-	return EVP_MD_CTX_size(_ctx);
+	return EVP_MD_CTX_size(_pContext);
 }
 
 
 void DigestEngine::reset()
 {
-	EVP_MD_CTX_cleanup(_ctx);
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+	EVP_MD_CTX_free(_pContext);
+	_pContext = EVP_MD_CTX_create();
+#else
+	EVP_MD_CTX_cleanup(_pContext);
+#endif
 	const EVP_MD* md = EVP_get_digestbyname(_name.c_str());
 	if (!md) throw Poco::NotFoundException(_name);
-	EVP_DigestInit_ex(_ctx, md, NULL);
+	EVP_DigestInit_ex(_pContext, md, NULL);
 }
 
 
 const Poco::DigestEngine::Digest& DigestEngine::digest()
 {
 	_digest.clear();
-	unsigned len = EVP_MD_CTX_size(_ctx);
+	unsigned len = EVP_MD_CTX_size(_pContext);
 	_digest.resize(len);
-	EVP_DigestFinal_ex(_ctx, &_digest[0], &len);
+	EVP_DigestFinal_ex(_pContext, &_digest[0], &len);
 	reset();
 	return _digest;
 }
@@ -70,7 +75,7 @@ const Poco::DigestEngine::Digest& DigestEngine::digest()
 
 void DigestEngine::updateImpl(const void* data, std::size_t length)
 {
-	EVP_DigestUpdate(_ctx, data, length);
+	EVP_DigestUpdate(_pContext, data, length);
 }
 
 

Crypto/src/RSAKeyImpl.cpp

@@ -207,19 +207,43 @@ int RSAKeyImpl::size() const
 
 RSAKeyImpl::ByteVec RSAKeyImpl::modulus() const
 {
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+	const BIGNUM* n = 0;
+	const BIGNUM* e = 0;
+	const BIGNUM* d = 0;
+	RSA_get0_key(_pRSA, &n, &e, &d);
+	return convertToByteVec(n);
+#else
 	return convertToByteVec(_pRSA->n);
+#endif
 }
 
 
 RSAKeyImpl::ByteVec RSAKeyImpl::encryptionExponent() const
 {
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+	const BIGNUM* n = 0;
+	const BIGNUM* e = 0;
+	const BIGNUM* d = 0;
+	RSA_get0_key(_pRSA, &n, &e, &d);
+	return convertToByteVec(e);
+#else
 	return convertToByteVec(_pRSA->e);
+#endif
 }
 
 
 RSAKeyImpl::ByteVec RSAKeyImpl::decryptionExponent() const
 {
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+	const BIGNUM* n = 0;
+	const BIGNUM* e = 0;
+	const BIGNUM* d = 0;
+	RSA_get0_key(_pRSA, &n, &e, &d);
+	return convertToByteVec(d);
+#else
 	return convertToByteVec(_pRSA->d);
+#endif
 }
 
 

Crypto/src/X509Certificate.cpp

@@ -63,7 +63,11 @@ X509Certificate::X509Certificate(X509* pCert, bool shared):
 	
 	if (shared)
 	{
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+		X509_up_ref(_pCert);
+#else
 		_pCert->references++;
+#endif
 	}
 
 	init();

Data/ODBC/include/Poco/Data/ODBC/Preparator.h

@@ -633,7 +633,7 @@ private:
 			(SQLUSMALLINT) pos + 1, 
 			valueType, 
 			(SQLPOINTER) pCache, 
-			(SQLINTEGER) size, 
+			(SQLINTEGER) size*sizeof(T), 
 			&_lengths[pos])))
 		{
 			throw StatementException(_rStmt, "SQLBindCol()");
@@ -1040,7 +1040,7 @@ inline void Preparator::prepare(std::size_t pos, const std::list<std::string>& v
 
 inline void Preparator::prepare(std::size_t pos, const UTF16String&)
 {
-	prepareVariableLen<UTF16String::value_type>(pos, SQL_C_WCHAR, maxDataSize(pos), DT_CHAR);
+	prepareVariableLen<UTF16String::value_type>(pos, SQL_C_WCHAR, maxDataSize(pos), DT_WCHAR);
 }
 
 

Data/ODBC/src/ODBCMetaColumn.cpp

@@ -88,6 +88,9 @@ void ODBCMetaColumn::init()
 	case SQL_CHAR:
 	case SQL_VARCHAR:
 	case SQL_LONGVARCHAR:
+#ifdef SQL_GUID
+	case SQL_GUID:
+#endif
 		setType(MetaColumn::FDT_STRING); break;
 
 	case SQL_WCHAR:

Data/ODBC/src/ODBCStatementImpl.cpp

@@ -499,7 +499,7 @@ int ODBCStatementImpl::affectedRowCount() const
 {
 	if (0 == _affectedRowCount)
 	{
-		SQLLEN rows;
+		SQLLEN rows = 0;
 		if (!Utility::isError(SQLRowCount(_stmt, &rows)))
 			_affectedRowCount = static_cast<std::size_t>(rows);
 	}

Data/testsuite/src/DataTest.cpp

@@ -952,7 +952,7 @@ void DataTest::testRow()
 	row3.append("field4", 4);
 
 	assert (row3 == row);
-	assert (!(row < row3 | row3 < row));
+	assert (!(row < row3 || row3 < row));
 
 	Row row4(row3.names());
 	try

Foundation/include/Poco/AtomicCounter.h

@@ -24,7 +24,13 @@
 #if POCO_OS == POCO_OS_WINDOWS_NT
 	#include "Poco/UnWindows.h"
 #elif POCO_OS == POCO_OS_MAC_OS_X
-	#include <libkern/OSAtomic.h>
+	#if __MAC_OS_X_VERSION_MAX_ALLOWED >= __MAC_10_12 || __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_10_0 || __TV_OS_VERSION_MAX_ALLOWED >= __TVOS_10_0 || __WATCH_OS_VERSION_MAX_ALLOWED >= __WATCHOS_3_0
+		#ifndef POCO_HAVE_STD_ATOMICS
+			#define POCO_HAVE_STD_ATOMICS
+		#endif
+	#else
+		#include <libkern/OSAtomic.h>
+	#endif
 #elif ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 2) || __GNUC__ > 4) && (defined(__x86_64__) || defined(__i386__))
 	#if !defined(POCO_HAVE_GCC_ATOMICS) && !defined(POCO_NO_GCC_ATOMICS)
 		#define POCO_HAVE_GCC_ATOMICS
@@ -35,6 +41,9 @@
 	#endif
 #endif // POCO_OS
 #include "Poco/Mutex.h"
+#ifdef POCO_HAVE_STD_ATOMICS
+#include <atomic>
+#endif
 
 
 namespace Poco {
@@ -104,7 +113,9 @@ public:
 		/// Returns true if the counter is zero, false otherwise.
 
 private:
-#if POCO_OS == POCO_OS_WINDOWS_NT
+#if defined(POCO_HAVE_STD_ATOMICS)
+	typedef std::atomic<int> ImplType;
+#elif POCO_OS == POCO_OS_WINDOWS_NT
 	typedef volatile LONG ImplType;
 #elif POCO_OS == POCO_OS_MAC_OS_X
 	typedef int32_t ImplType;
@@ -127,7 +138,53 @@ private:
 //
 
 
-#if POCO_OS == POCO_OS_WINDOWS_NT
+#if defined(POCO_HAVE_STD_ATOMICS)
+//
+// C++11 atomics
+//
+inline AtomicCounter::operator AtomicCounter::ValueType () const
+{
+	return _counter.load();
+}
+
+	
+inline AtomicCounter::ValueType AtomicCounter::value() const
+{
+	return _counter.load();
+}
+
+
+inline AtomicCounter::ValueType AtomicCounter::operator ++ () // prefix
+{
+	return ++_counter;
+}
+
+	
+inline AtomicCounter::ValueType AtomicCounter::operator ++ (int) // postfix
+{
+	return _counter++;
+}
+
+
+inline AtomicCounter::ValueType AtomicCounter::operator -- () // prefix
+{
+	return --_counter;
+}
+
+	
+inline AtomicCounter::ValueType AtomicCounter::operator -- (int) // postfix
+{
+	return _counter--;
+}
+
+	
+inline bool AtomicCounter::operator ! () const
+{
+	return _counter.load() == 0;
+}
+
+
+#elif POCO_OS == POCO_OS_WINDOWS_NT
 //
 // Windows
 //

Foundation/include/Poco/Config.h

@@ -9,7 +9,7 @@
 //
 // Feature configuration for the POCO libraries.
 //
-// Copyright (c) 2006-2010, Applied Informatics Software Engineering GmbH.
+// Copyright (c) 2006-2016, Applied Informatics Software Engineering GmbH.
 // and Contributors.
 //
 // SPDX-License-Identifier:	BSL-1.0
@@ -93,8 +93,10 @@
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 //
 #ifndef POCO_NO_SOO
+#ifndef POCO_ENABLE_SOO
 #define POCO_NO_SOO
 #endif
+#endif
 
 
 
@@ -168,13 +170,21 @@
 	#define POCO_NO_LOCALE
 #endif
 
+
 // Enable the poco_debug_* and poco_trace_* macros
 // even if the _DEBUG variable is not set.
 // This allows the use of these macros in a release version.
 // #define POCO_LOG_DEBUG
 
+
 // Uncomment to disable the use of bundled OpenSSL binaries
 // (Windows only)
 // #define POCO_EXTERNAL_OPENSSL
 
+
+// Define to prevent changing the suffix for shared libraries
+// to "d.so", "d.dll", etc. for _DEBUG builds in Poco::SharedLibrary.
+// #define POCO_NO_SHARED_LIBRARY_DEBUG_SUFFIX
+
+
 #endif // Foundation_Config_INCLUDED

Foundation/include/Poco/DeflatingStream.h

@@ -139,7 +139,7 @@ protected:
 };
 
 
-class Foundation_API DeflatingOutputStream: public DeflatingIOS, public std::ostream
+class Foundation_API DeflatingOutputStream: public std::ostream, public DeflatingIOS
 	/// This stream compresses all data passing through it
 	/// using zlib's deflate algorithm.
 	/// After all data has been written to the stream, close()
@@ -176,7 +176,7 @@ protected:
 };
 
 
-class Foundation_API DeflatingInputStream: public DeflatingIOS, public std::istream
+class Foundation_API DeflatingInputStream: public std::istream, public DeflatingIOS
 	/// This stream compresses all data passing through it
 	/// using zlib's deflate algorithm.
 {

Foundation/include/Poco/DynamicFactory.h

@@ -89,7 +89,11 @@ public:
 
 		FastMutex::ScopedLock lock(_mutex);
 
+#if __cplusplus < 201103L
 		std::auto_ptr<AbstractFactory> ptr(pAbstractFactory);
+#else
+		std::unique_ptr<AbstractFactory> ptr(pAbstractFactory);
+#endif
 		typename FactoryMap::iterator it = _map.find(className);
 		if (it == _map.end())
 			_map[className] = ptr.release();

Foundation/include/Poco/Exception.h

@@ -254,6 +254,7 @@ POCO_DECLARE_EXCEPTION(Foundation_API, CreateFileException, FileException)
 POCO_DECLARE_EXCEPTION(Foundation_API, OpenFileException, FileException)
 POCO_DECLARE_EXCEPTION(Foundation_API, WriteFileException, FileException)
 POCO_DECLARE_EXCEPTION(Foundation_API, ReadFileException, FileException)
+POCO_DECLARE_EXCEPTION(Foundation_API, DirectoryNotEmptyException, FileException)
 POCO_DECLARE_EXCEPTION(Foundation_API, UnknownURISchemeException, RuntimeException)
 POCO_DECLARE_EXCEPTION(Foundation_API, TooManyURIRedirectsException, RuntimeException)
 POCO_DECLARE_EXCEPTION(Foundation_API, URISyntaxException, SyntaxException)

Foundation/include/Poco/FIFOBuffer.h

@@ -325,7 +325,7 @@ public:
 		if (!isWritable())
 			throw Poco::InvalidAccessException("Buffer not writable.");
 
-		std::memcpy(&_buffer[_used], ptr, length * sizeof(T));
+		std::memcpy(begin() + _used, ptr, length * sizeof(T));
 		std::size_t usedBefore = _used;
 		_used += length;
 		if (_notify) notify(usedBefore);

Foundation/include/Poco/InflatingStream.h

@@ -143,7 +143,7 @@ protected:
 };
 
 
-class Foundation_API InflatingOutputStream: public InflatingIOS, public std::ostream
+class Foundation_API InflatingOutputStream: public std::ostream, public InflatingIOS
 	/// This stream decompresses all data passing through it
 	/// using zlib's inflate algorithm.
 	///
@@ -173,7 +173,7 @@ public:
 };
 
 
-class Foundation_API InflatingInputStream: public InflatingIOS, public std::istream
+class Foundation_API InflatingInputStream: public std::istream, public InflatingIOS
 	/// This stream decompresses all data passing through it
 	/// using zlib's inflate algorithm.
 	/// Example:

Foundation/include/Poco/ObjectPool.h

@@ -259,19 +259,19 @@ public:
 			_factory.deactivateObject(pObject);
 			if (_pool.size() < _capacity)
 			{
-				_pool.push_back(pObject);
+				try
-			}
+				{
-			else
+					_pool.push_back(pObject);
-			{
+					return;
-				_factory.destroyObject(pObject);
+				}
-				_size--;
+				catch (...)
-				_availableCondition.signal();
+				{
+				}
 			}
 		}
-		else
+		_factory.destroyObject(pObject);
-		{
+		_size--;
-			_factory.destroyObject(pObject);
+		_availableCondition.signal();
-		}
 	}
 
 	std::size_t capacity() const

Foundation/src/AtomicCounter.cpp

@@ -20,7 +20,48 @@
 namespace Poco {
 
 
-#if POCO_OS == POCO_OS_WINDOWS_NT
+#if defined(POCO_HAVE_STD_ATOMICS)
+//
+// C++11 atomics
+//
+AtomicCounter::AtomicCounter():
+	_counter(0)
+{
+}
+
+	
+AtomicCounter::AtomicCounter(AtomicCounter::ValueType initialValue):
+	_counter(initialValue)
+{
+}
+
+
+AtomicCounter::AtomicCounter(const AtomicCounter& counter):
+	_counter(counter.value())
+{
+}
+
+
+AtomicCounter::~AtomicCounter()
+{
+}
+
+
+AtomicCounter& AtomicCounter::operator = (const AtomicCounter& counter)
+{
+	_counter.store(counter._counter.load());
+	return *this;
+}
+
+	
+AtomicCounter& AtomicCounter::operator = (AtomicCounter::ValueType value)
+{
+	_counter.store(value);
+	return *this;
+}
+
+
+#elif POCO_OS == POCO_OS_WINDOWS_NT
 //
 // Windows
 //

Foundation/src/Clock.cpp

@@ -34,6 +34,15 @@
 #include <limits>
 
 
+#ifndef POCO_HAVE_CLOCK_GETTIME
+	#if (defined(_POSIX_TIMERS) && defined(CLOCK_REALTIME)) || defined(POCO_VXWORKS) || defined(__QNX__)
+		#ifndef __APPLE__ // See GitHub issue #1453 - not available before Mac OS 10.12/iOS 10
+			#define POCO_HAVE_CLOCK_GETTIME
+		#endif
+	#endif
+#endif
+
+
 namespace Poco {
 
 
@@ -120,7 +129,7 @@ void Clock::update()
 #endif
 	_clock = ClockVal(ts.tv_sec)*resolution() + ts.tv_nsec/1000;
 
-#elif (defined(_POSIX_TIMERS) && defined(_POSIX_MONOTONIC_CLOCK)) || defined(__QNX__)
+#elif defined(POCO_HAVE_CLOCK_GETTIME)
 
 	struct timespec ts;
 	if (clock_gettime(CLOCK_MONOTONIC, &ts))

Foundation/src/DeflatingStream.cpp

@@ -334,15 +334,15 @@ DeflatingStreamBuf* DeflatingIOS::rdbuf()
 
 
 DeflatingOutputStream::DeflatingOutputStream(std::ostream& ostr, DeflatingStreamBuf::StreamType type, int level):
-	DeflatingIOS(ostr, type, level),
+	std::ostream(&_buf),
-	std::ostream(&_buf)
+	DeflatingIOS(ostr, type, level)
 {
 }
 
 
 DeflatingOutputStream::DeflatingOutputStream(std::ostream& ostr, int windowBits, int level):
-	DeflatingIOS(ostr, windowBits, level),
+	std::ostream(&_buf),
-	std::ostream(&_buf)
+	DeflatingIOS(ostr, windowBits, level)
 {
 }
 
@@ -365,15 +365,15 @@ int DeflatingOutputStream::sync()
 
 
 DeflatingInputStream::DeflatingInputStream(std::istream& istr, DeflatingStreamBuf::StreamType type, int level):
-	DeflatingIOS(istr, type, level),
+	std::istream(&_buf),
-	std::istream(&_buf)
+	DeflatingIOS(istr, type, level)
 {
 }
 
 
 DeflatingInputStream::DeflatingInputStream(std::istream& istr, int windowBits, int level):
-	DeflatingIOS(istr, windowBits, level),
+	std::istream(&_buf),
-	std::istream(&_buf)
+	DeflatingIOS(istr, windowBits, level)
 {
 }
 

Foundation/src/Event_POSIX.cpp

@@ -24,6 +24,28 @@
 #endif
 
 
+//
+// Note: pthread_cond_timedwait() with CLOCK_MONOTONIC is supported
+// on Linux and QNX, as well as on Android >= 5.0. On Android < 5.0,
+// HAVE_PTHREAD_COND_TIMEDWAIT_MONOTONIC is defined to indicate 
+// availability of non-standard pthread_cond_timedwait_monotonic().
+//
+#ifndef POCO_HAVE_MONOTONIC_PTHREAD_COND_TIMEDWAIT
+	#if (defined(__linux__) || defined(__QNX__)) && !(defined(__ANDROID__) && defined(HAVE_PTHREAD_COND_TIMEDWAIT_MONOTONIC))
+		#define POCO_HAVE_MONOTONIC_PTHREAD_COND_TIMEDWAIT 1
+	#endif
+#endif
+
+
+#ifndef POCO_HAVE_CLOCK_GETTIME
+	#if (defined(_POSIX_TIMERS) && defined(CLOCK_REALTIME)) || defined(POCO_VXWORKS) || defined(__QNX__)
+		#ifndef __APPLE__ // See GitHub issue #1453 - not available before Mac OS 10.12/iOS 10
+			#define POCO_HAVE_CLOCK_GETTIME
+		#endif
+	#endif
+#endif
+
+
 namespace Poco {
 
 
@@ -40,7 +62,7 @@ EventImpl::EventImpl(EventTypeImpl type): _auto(type == EVENT_AUTORESET_IMPL), _
 	if (pthread_mutex_init(&_mutex, NULL))
 		throw SystemException("cannot create event (mutex)");
 
-#if defined(__linux__) || defined(__QNX__)
+#if defined(POCO_HAVE_MONOTONIC_PTHREAD_COND_TIMEDWAIT)
 	pthread_condattr_t attr;
 	if (pthread_condattr_init(&attr))
 	{
@@ -105,7 +127,7 @@ bool EventImpl::waitImpl(long milliseconds)
 	delta.tv_sec  = milliseconds / 1000;
 	delta.tv_nsec = (milliseconds % 1000)*1000000;
 	pthread_get_expiration_np(&delta, &abstime);
-#elif defined(__linux__) || defined(__QNX__)
+#elif defined(POCO_HAVE_MONOTONIC_PTHREAD_COND_TIMEDWAIT)
 	clock_gettime(CLOCK_MONOTONIC, &abstime);
 	abstime.tv_sec  += milliseconds / 1000;
 	abstime.tv_nsec += (milliseconds % 1000)*1000000;
@@ -114,7 +136,7 @@ bool EventImpl::waitImpl(long milliseconds)
 		abstime.tv_nsec -= 1000000000;
 		abstime.tv_sec++;
 	}
-#elif (defined(_POSIX_TIMERS) && defined(CLOCK_REALTIME)) || defined(POCO_VXWORKS)
+#elif defined(POCO_HAVE_CLOCK_GETTIME)
 	clock_gettime(CLOCK_REALTIME, &abstime);
 	abstime.tv_sec  += milliseconds / 1000;
 	abstime.tv_nsec += (milliseconds % 1000)*1000000;

Foundation/src/Exception.cpp

@@ -178,6 +178,7 @@ POCO_IMPLEMENT_EXCEPTION(CreateFileException, FileException, "Cannot create file
 POCO_IMPLEMENT_EXCEPTION(OpenFileException, FileException, "Cannot open file")
 POCO_IMPLEMENT_EXCEPTION(WriteFileException, FileException, "Cannot write file")
 POCO_IMPLEMENT_EXCEPTION(ReadFileException, FileException, "Cannot read file")
+POCO_IMPLEMENT_EXCEPTION(DirectoryNotEmptyException, FileException, "Directory not empty")
 POCO_IMPLEMENT_EXCEPTION(UnknownURISchemeException, RuntimeException, "Unknown URI scheme")
 POCO_IMPLEMENT_EXCEPTION(TooManyURIRedirectsException, RuntimeException, "Too many URI redirects")
 POCO_IMPLEMENT_EXCEPTION(URISyntaxException, SyntaxException, "Bad URI syntax")

Foundation/src/File.cpp

@@ -34,6 +34,7 @@
 #else
 #include "File_VMS.cpp"
 #endif
+#include "Poco/Thread.h"
 
 
 namespace Poco {
@@ -269,8 +270,37 @@ void File::remove(bool recursive)
 		{
 			it->remove(true);
 		}
+
+		// Note: On Windows, removing a directory may not succeed at first 
+		// try because deleting files is not a synchronous operation. Files
+		// are merely marked as deleted, and actually removed at a later time.
+		//
+		// An alternate strategy would be moving files to a different directory
+		// first (on the same drive, but outside the deleted tree), and marking
+		// them as hidden, before deleting them, but this could lead to other issues.
+		// So we simply retry after some time until we succeed, or give up.
+
+		int retry = 8;
+		long sleep = 10;
+		while (retry > 0)
+		{ 
+			try
+			{
+				removeImpl();
+				retry = 0;
+			}
+			catch (DirectoryNotEmptyException&)
+			{
+				if (--retry == 0) throw;
+				Poco::Thread::sleep(sleep);
+				sleep *= 2;
+			}
+		}
+	}
+	else
+	{
+		removeImpl();
 	}
-	removeImpl();
 }
 
 

Foundation/src/File_UNIX.cpp

@@ -507,7 +507,7 @@ void FileImpl::handleLastErrorImpl(const std::string& path)
 		throw FileException("disk quota exceeded", path, errno);
 #if !defined(_AIX)
 	case ENOTEMPTY:
-		throw FileException("directory not empty", path, errno);
+		throw DirectoryNotEmptyException(path, errno);
 #endif
 	case ENAMETOOLONG:
 		throw PathSyntaxException(path, errno);

Foundation/src/File_VMS.cpp

@@ -405,7 +405,7 @@ void FileImpl::handleLastErrorImpl(const std::string& path)
 	case EDQUOT:
 		throw FileException("disk quota exceeded", path);
 	case ENOTEMPTY:
-		throw FileException("directory not empty", path);
+		throw DirectoryNotEmptyException(path, err);
 	case ENAMETOOLONG:
 		throw PathSyntaxException(path);
 	default:

Foundation/src/File_VX.cpp

@@ -389,7 +389,7 @@ void FileImpl::handleLastErrorImpl(const std::string& path)
 	case ENOSPC:
 		throw FileException("no space left on device", path);
 	case ENOTEMPTY:
-		throw FileException("directory not empty", path);
+		throw DirectoryNotEmptyException(path);
 	case ENAMETOOLONG:
 		throw PathSyntaxException(path);
 	case ENFILE:

Foundation/src/File_WIN32.cpp

@@ -409,7 +409,7 @@ void FileImpl::handleLastErrorImpl(const std::string& path)
 	case ERROR_CANNOT_MAKE:
 		throw CreateFileException(path, err);
 	case ERROR_DIR_NOT_EMPTY:
-		throw FileException("directory not empty", path, err);
+		throw DirectoryNotEmptyException(path, err);
 	case ERROR_WRITE_FAULT:
 		throw WriteFileException(path, err);
 	case ERROR_READ_FAULT:

Foundation/src/File_WIN32U.cpp

@@ -417,7 +417,7 @@ void FileImpl::handleLastErrorImpl(const std::string& path)
 	case ERROR_CANNOT_MAKE:
 		throw CreateFileException(path, err);
 	case ERROR_DIR_NOT_EMPTY:
-		throw FileException("directory not empty", path, err);
+		throw DirectoryNotEmptyException(path, err);
 	case ERROR_WRITE_FAULT:
 		throw WriteFileException(path, err);
 	case ERROR_READ_FAULT:

Foundation/src/File_WINCE.cpp

@@ -407,7 +407,7 @@ void FileImpl::handleLastErrorImpl(const std::string& path)
 	case ERROR_CANNOT_MAKE:
 		throw CreateFileException(path);
 	case ERROR_DIR_NOT_EMPTY:
-		throw FileException("directory not empty", path);
+		throw DirectoryNotEmptyException(path);
 	case ERROR_WRITE_FAULT:
 		throw WriteFileException(path);
 	case ERROR_READ_FAULT:

Foundation/src/InflatingStream.cpp

@@ -309,15 +309,15 @@ InflatingStreamBuf* InflatingIOS::rdbuf()
 
 
 InflatingOutputStream::InflatingOutputStream(std::ostream& ostr, InflatingStreamBuf::StreamType type):
-	InflatingIOS(ostr, type),
+	std::ostream(&_buf),
-	std::ostream(&_buf)
+	InflatingIOS(ostr, type)
 {
 }
 
 
 InflatingOutputStream::InflatingOutputStream(std::ostream& ostr, int windowBits):
-	InflatingIOS(ostr, windowBits),
+	std::ostream(&_buf),
-	std::ostream(&_buf)
+	InflatingIOS(ostr, windowBits)
 {
 }
 
@@ -334,15 +334,15 @@ int InflatingOutputStream::close()
 
 
 InflatingInputStream::InflatingInputStream(std::istream& istr, InflatingStreamBuf::StreamType type):
-	InflatingIOS(istr, type),
+	std::istream(&_buf),
-	std::istream(&_buf)
+	InflatingIOS(istr, type)
 {
 }
 
 
 InflatingInputStream::InflatingInputStream(std::istream& istr, int windowBits):
-	InflatingIOS(istr, windowBits),
+	std::istream(&_buf),
-	std::istream(&_buf)
+	InflatingIOS(istr, windowBits)
 {
 }
 

Foundation/src/Mutex_POSIX.cpp

@@ -29,9 +29,18 @@
 
 
 #if defined(_POSIX_TIMEOUTS) && (_POSIX_TIMEOUTS - 200112L) >= 0L
-#if defined(_POSIX_THREADS) && (_POSIX_THREADS - 200112L) >= 0L
+	#if defined(_POSIX_THREADS) && (_POSIX_THREADS - 200112L) >= 0L
-#define POCO_HAVE_MUTEX_TIMEOUT
+		#define POCO_HAVE_MUTEX_TIMEOUT
+	#endif
 #endif
+
+
+#ifndef POCO_HAVE_CLOCK_GETTIME
+	#if (defined(_POSIX_TIMERS) && defined(CLOCK_REALTIME)) || defined(POCO_VXWORKS) || defined(__QNX__)
+		#ifndef __APPLE__ // See GitHub issue #1453 - not available before Mac OS 10.12/iOS 10
+			#define POCO_HAVE_CLOCK_GETTIME
+		#endif
+	#endif
 #endif
 
 
@@ -73,7 +82,7 @@ bool MutexImpl::tryLockImpl(long milliseconds)
 {
 #if defined(POCO_HAVE_MUTEX_TIMEOUT)
 	struct timespec abstime;
-#if defined(_POSIX_TIMERS) && defined(CLOCK_REALTIME)
+#if defined(POCO_HAVE_CLOCK_GETTIME)
 	clock_gettime(CLOCK_REALTIME, &abstime);
 	abstime.tv_sec  += milliseconds / 1000;
 	abstime.tv_nsec += (milliseconds % 1000)*1000000;

Foundation/src/NumericString.cpp

@@ -59,7 +59,11 @@ void pad(std::string& str, int precision, int width, char prefix = ' ', char dec
 	std::string::size_type frac = str.length() - decSepPos - 1;
 
 	std::string::size_type ePos = str.find_first_of("eE");
+#if __cplusplus < 201103L
 	std::auto_ptr<std::string> eStr;
+#else
+	std::unique_ptr<std::string> eStr;
+#endif
 	if (ePos != std::string::npos)
 	{
 		eStr.reset(new std::string(str.substr(ePos, std::string::npos)));

Foundation/src/Semaphore_POSIX.cpp

@@ -24,6 +24,28 @@
 #endif
 
 
+//
+// Note: pthread_cond_timedwait() with CLOCK_MONOTONIC is supported
+// on Linux and QNX, as well as on Android >= 5.0. On Android < 5.0,
+// HAVE_PTHREAD_COND_TIMEDWAIT_MONOTONIC is defined to indicate 
+// availability of non-standard pthread_cond_timedwait_monotonic().
+//
+#ifndef POCO_HAVE_MONOTONIC_PTHREAD_COND_TIMEDWAIT
+	#if (defined(__linux__) || defined(__QNX__)) && !(defined(__ANDROID__) && defined(HAVE_PTHREAD_COND_TIMEDWAIT_MONOTONIC))
+		#define POCO_HAVE_MONOTONIC_PTHREAD_COND_TIMEDWAIT 1
+	#endif
+#endif
+
+
+#ifndef POCO_HAVE_CLOCK_GETTIME
+	#if (defined(_POSIX_TIMERS) && defined(CLOCK_REALTIME)) || defined(POCO_VXWORKS) || defined(__QNX__)
+		#ifndef __APPLE__ // See GitHub issue #1453 - not available before Mac OS 10.12/iOS 10
+			#define POCO_HAVE_CLOCK_GETTIME
+		#endif
+	#endif
+#endif
+
+
 namespace Poco {
 
 
@@ -41,7 +63,7 @@ SemaphoreImpl::SemaphoreImpl(int n, int max): _n(n), _max(max)
 	if (pthread_mutex_init(&_mutex, NULL))
 		throw SystemException("cannot create semaphore (mutex)");
 
-#if defined(__linux__) || defined(__QNX__)
+#if defined(POCO_HAVE_MONOTONIC_PTHREAD_COND_TIMEDWAIT)
 	pthread_condattr_t attr;
 	if (pthread_condattr_init(&attr))
 	{
@@ -105,7 +127,7 @@ bool SemaphoreImpl::waitImpl(long milliseconds)
 	delta.tv_sec  = milliseconds / 1000;
 	delta.tv_nsec = (milliseconds % 1000)*1000000;
 	pthread_get_expiration_np(&delta, &abstime);
-#elif defined(__linux__) || defined(__QNX__)
+#elif defined(POCO_HAVE_MONOTONIC_PTHREAD_COND_TIMEDWAIT)
 	clock_gettime(CLOCK_MONOTONIC, &abstime);
 	abstime.tv_sec  += milliseconds / 1000;
 	abstime.tv_nsec += (milliseconds % 1000)*1000000;
@@ -114,7 +136,7 @@ bool SemaphoreImpl::waitImpl(long milliseconds)
 		abstime.tv_nsec -= 1000000000;
 		abstime.tv_sec++;
 	}
-#elif (defined(_POSIX_TIMERS) && defined(CLOCK_REALTIME)) || defined(POCO_VXWORKS)
+#elif defined(POCO_HAVE_CLOCK_GETTIME)
 	clock_gettime(CLOCK_REALTIME, &abstime);
 	abstime.tv_sec  += milliseconds / 1000;
 	abstime.tv_nsec += (milliseconds % 1000)*1000000;

Foundation/src/SharedLibrary_HPUX.cpp

@@ -91,7 +91,7 @@ std::string SharedLibraryImpl::prefixImpl()
 
 std::string SharedLibraryImpl::suffixImpl()
 {
-#if defined(_DEBUG)
+#if defined(_DEBUG) && !defined(POCO_NO_SHARED_LIBRARY_DEBUG_SUFFIX)
 	return "d.sl";
 #else
 	return ".sl";

Foundation/src/SharedLibrary_UNIX.cpp

@@ -112,25 +112,25 @@ std::string SharedLibraryImpl::prefixImpl()
 std::string SharedLibraryImpl::suffixImpl()
 {
 #if POCO_OS == POCO_OS_MAC_OS_X
-	#if defined(_DEBUG)
+	#if defined(_DEBUG) && !defined(POCO_NO_SHARED_LIBRARY_DEBUG_SUFFIX)
 		return "d.dylib";
 	#else
 		return ".dylib";
 	#endif
 #elif POCO_OS == POCO_OS_HPUX
-	#if defined(_DEBUG)
+	#if defined(_DEBUG) && !defined(POCO_NO_SHARED_LIBRARY_DEBUG_SUFFIX)
 		return "d.sl";
 	#else
 		return ".sl";
 	#endif
 #elif POCO_OS == POCO_OS_CYGWIN
-	#if defined(_DEBUG)
+	#if defined(_DEBUG) && !defined(POCO_NO_SHARED_LIBRARY_DEBUG_SUFFIX)
 		return "d.dll";
 	#else
 		return ".dll";
 	#endif
 #else
-	#if defined(_DEBUG)
+	#if defined(_DEBUG) && !defined(POCO_NO_SHARED_LIBRARY_DEBUG_SUFFIX)
 		return "d.so";
 	#else
 		return ".so";

Foundation/src/SharedLibrary_VMS.cpp

@@ -114,7 +114,7 @@ std::string SharedLibraryImpl::prefixImpl()
 
 std::string SharedLibraryImpl::suffixImpl()
 {
-#if defined(_DEBUG)
+#if defined(_DEBUG) && !defined(POCO_NO_SHARED_LIBRARY_DEBUG_SUFFIX)
 	return "d.exe";
 #else
 	return ".exe";

Foundation/src/SharedLibrary_WIN32.cpp

@@ -95,7 +95,7 @@ std::string SharedLibraryImpl::prefixImpl()
 
 std::string SharedLibraryImpl::suffixImpl()
 {
-#if defined(_DEBUG)
+#if defined(_DEBUG) && !defined(POCO_NO_SHARED_LIBRARY_DEBUG_SUFFIX)
 	return "d.dll";
 #else
 	return ".dll";

Foundation/src/SharedLibrary_WIN32U.cpp

@@ -106,7 +106,7 @@ std::string SharedLibraryImpl::prefixImpl()
 
 std::string SharedLibraryImpl::suffixImpl()
 {
-#if defined(_DEBUG)
+#if defined(_DEBUG) && !defined(POCO_NO_SHARED_LIBRARY_DEBUG_SUFFIX)
 	return "d.dll";
 #else
 	return ".dll";

Foundation/src/Timestamp.cpp

@@ -39,6 +39,15 @@
 #endif
 
 
+#ifndef POCO_HAVE_CLOCK_GETTIME
+	#if (defined(_POSIX_TIMERS) && defined(CLOCK_REALTIME)) || defined(POCO_VXWORKS) || defined(__QNX__)
+		#ifndef __APPLE__ // See GitHub issue #1453 - not available before Mac OS 10.12/iOS 10
+			#define POCO_HAVE_CLOCK_GETTIME
+		#endif
+	#endif
+#endif
+
+
 #if defined(_WIN32_WCE) && defined(POCO_WINCE_TIMESTAMP_HACK)
 
 
@@ -227,7 +236,7 @@ void Timestamp::update()
 	ts.QuadPart -= epoch.QuadPart;
 	_ts = ts.QuadPart/10;
 
-#elif (defined(_POSIX_TIMERS) && defined(CLOCK_REALTIME)) || defined(POCO_VXWORKS) || defined(__QNX__)
+#elif defined(POCO_HAVE_CLOCK_GETTIME)
 
 	struct timespec ts;
 	if (clock_gettime(CLOCK_REALTIME, &ts))

Foundation/src/UTF8Encoding.cpp

@@ -224,23 +224,23 @@ bool UTF8Encoding::isLegal(const unsigned char *bytes, int length)
 	case 3: 
 		if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false;
 	case 2:
-		if ((a = (*--srcptr)) > 0xBF) return false;
+		a = (*--srcptr);
-		switch (*bytes) 
+		switch (*bytes)
 		{
 		case 0xE0:
-			if (a < 0xA0) return false; 
+			if (a < 0xA0 || a > 0xBF) return false;
 			break;
 		case 0xED:
-			if (a > 0x9F) return false; 
+			if (a < 0x80 || a > 0x9F) return false;
 			break;
 		case 0xF0:
-			if (a < 0x90) return false; 
+			if (a < 0x90 || a > 0xBF) return false;
 			break;
 		case 0xF4:
-			if (a > 0x8F) return false; 
+			if (a < 0x80 || a > 0x8F) return false;
 			break;
 		default:
-			if (a < 0x80) return false;
+			if (a < 0x80 || a > 0xBF) return false;
 		}
 	case 1:
 		if (*bytes >= 0x80 && *bytes < 0xC2) return false;

MongoDB/testsuite/src/MongoDBTest.cpp

@@ -287,7 +287,7 @@ void MongoDBTest::testBuildInfo()
 
 void MongoDBTest::testConnectionPool()
 {
-	Poco::Net::SocketAddress sa("localhost", 27017);
+	Poco::Net::SocketAddress sa("127.0.0.1", 27017);
 	Poco::PoolableObjectFactory<Poco::MongoDB::Connection, Poco::MongoDB::Connection::Ptr> factory(sa);
 	Poco::ObjectPool<Poco::MongoDB::Connection, Poco::MongoDB::Connection::Ptr> pool(factory, 10, 15);
 
@@ -394,8 +394,8 @@ CppUnit::Test* MongoDBTest::suite()
 {
 	try
 	{
-		_mongo = new Poco::MongoDB::Connection("localhost", 27017);
+		_mongo = new Poco::MongoDB::Connection("127.0.0.1", 27017);
-		std::cout << "Connected to [localhost:27017]" << std::endl;
+		std::cout << "Connected to [127.0.0.1:27017]" << std::endl;
 	}
 	catch (Poco::Net::ConnectionRefusedException& e)
 	{

Net/include/Poco/Net/DatagramSocket.h

@@ -89,6 +89,20 @@ public:
 		///
 		/// Calls to connect cannot() come before calls to bind().
 
+	void bind(const SocketAddress& address, bool reuseAddress, bool reusePort);
+		/// Bind a local address to the socket.
+		///
+		/// This is usually only done when establishing a server
+		/// socket. 
+		///
+		/// If reuseAddress is true, sets the SO_REUSEADDR
+		/// socket option.
+		///
+		/// If reusePort is true, sets the SO_REUSEPORT
+		/// socket option.
+		///
+		/// Calls to connect cannot() come before calls to bind().
+
 	int sendBytes(const void* buffer, int length, int flags = 0);
 		/// Sends the contents of the given buffer through
 		/// the socket.

Net/include/Poco/Net/NetException.h

@@ -53,6 +53,7 @@ POCO_DECLARE_EXCEPTION(Net_API, NTPException, NetException)
 POCO_DECLARE_EXCEPTION(Net_API, HTMLFormException, NetException)
 POCO_DECLARE_EXCEPTION(Net_API, WebSocketException, NetException)
 POCO_DECLARE_EXCEPTION(Net_API, UnsupportedFamilyException, NetException)
+POCO_DECLARE_EXCEPTION(Net_API, AddressFamilyMismatchException, NetException)
 
 
 } } // namespace Poco::Net

Net/include/Poco/Net/RawSocket.h

@@ -82,6 +82,20 @@ public:
 		///
 		/// Calls to connect() cannot come before calls to bind().
 
+	void bind(const SocketAddress& address, bool reuseAddress, bool reusePort);
+		/// Bind a local address to the socket.
+		///
+		/// This is usually only done when establishing a server
+		/// socket. 
+		///
+		/// If reuseAddress is true, sets the SO_REUSEADDR
+		/// socket option.
+		///
+		/// If reusePort is true, sets the SO_REUSEPORT
+		/// socket option.
+		///
+		/// Calls to connect() cannot come before calls to bind().
+
 	int sendBytes(const void* buffer, int length, int flags = 0);
 		/// Sends the contents of the given buffer through
 		/// the socket.

Net/include/Poco/Net/ServerSocket.h

@@ -82,6 +82,19 @@ public:
 		/// If reuseAddress is true, sets the SO_REUSEADDR
 		/// socket option.
 
+	virtual void bind(const SocketAddress& address, bool reuseAddress, bool reusePort);
+		/// Binds a local address to the socket.
+		///
+		/// This is usually only done when establishing a server
+		/// socket. TCP clients should not bind a socket to a
+		/// specific address.
+		///
+		/// If reuseAddress is true, sets the SO_REUSEADDR
+		/// socket option.
+		///
+		/// If reuseAddress is true, sets the SO_REUSEPORT
+		/// socket option.
+
 	virtual void bind(Poco::UInt16 port, bool reuseAddress = false);
 		/// Binds a local port to the socket.
 		///
@@ -91,6 +104,18 @@ public:
 		/// If reuseAddress is true, sets the SO_REUSEADDR
 		/// socket option.
 
+	virtual void bind(Poco::UInt16 port, bool reuseAddress, bool reusePort);
+		/// Binds a local port to the socket.
+		///
+		/// This is usually only done when establishing a server
+		/// socket. 
+		///
+		/// If reuseAddress is true, sets the SO_REUSEADDR
+		/// socket option.
+        	///
+		/// If reusePort is true, sets the SO_REUSEPORT
+		/// socket option.
+
 	virtual void bind6(const SocketAddress& address, bool reuseAddress = false, bool ipV6Only = false);
 		/// Binds a local IPv6 address to the socket.
 		///
@@ -108,6 +133,26 @@ public:
 		/// If the library has not been built with IPv6 support,
 		/// a Poco::NotImplementedException will be thrown.
 
+	virtual void bind6(const SocketAddress& address, bool reuseAddress, bool reusePort,  bool ipV6Only);
+		/// Binds a local IPv6 address to the socket.
+		///
+		/// This is usually only done when establishing a server
+		/// socket. TCP clients should not bind a socket to a
+		/// specific address.
+		///
+		/// If reuseAddress is true, sets the SO_REUSEADDR
+		/// socket option.
+		///
+		/// If reusePort is true, sets the SO_REUSEPORT
+		/// socket option.
+		///
+		/// The given address must be an IPv6 address. The
+		/// IPPROTO_IPV6/IPV6_V6ONLY option is set on the socket
+		/// according to the ipV6Only parameter.
+		///
+		/// If the library has not been built with IPv6 support,
+		/// a Poco::NotImplementedException will be thrown.
+
 	virtual void bind6(Poco::UInt16 port, bool reuseAddress = false, bool ipV6Only = false);
 		/// Binds a local IPv6 port to the socket.
 		///
@@ -124,6 +169,24 @@ public:
 		/// If the library has not been built with IPv6 support,
 		/// a Poco::NotImplementedException will be thrown.
 		
+	virtual void bind6(Poco::UInt16 port, bool reuseAddress, bool reusePort, bool ipV6Only);
+		/// Binds a local IPv6 port to the socket.
+		///
+		/// This is usually only done when establishing a server
+		/// socket. 
+		///
+		/// If reuseAddress is true, sets the SO_REUSEADDR
+		/// socket option.
+		///
+		/// If reusePort is true, sets the SO_REUSEPORT
+		/// socket option.
+		/// The given address must be an IPv6 address. The
+		/// IPPROTO_IPV6/IPV6_V6ONLY option is set on the socket
+		/// according to the ipV6Only parameter.
+		///
+		/// If the library has not been built with IPv6 support,
+		/// a Poco::NotImplementedException will be thrown.
+
 	virtual void listen(int backlog = 64);
 		/// Puts the socket into listening state.
 		///

Net/include/Poco/Net/SocketAddress.h

@@ -58,19 +58,38 @@ public:
 	SocketAddress();
 		/// Creates a wildcard (all zero) IPv4 SocketAddress.
 
+	explicit SocketAddress(Family family);
+		/// Creates a SocketAddress with unspecified (wildcard) IP address 
+		/// of the given family.
+
 	SocketAddress(const IPAddress& hostAddress, Poco::UInt16 portNumber);
 		/// Creates a SocketAddress from an IP address and given port number.
 
-	SocketAddress(Poco::UInt16 port);
+	explicit SocketAddress(Poco::UInt16 port);
 		/// Creates a SocketAddress with unspecified (wildcard) IP address 
 		/// and given port number.
 
+	SocketAddress(Family family, Poco::UInt16 port);
+		/// Creates a SocketAddress with unspecified (wildcard) IP address 
+		/// of the given family, and given port number.
+
 	SocketAddress(const std::string& hostAddress, Poco::UInt16 portNumber);
 		/// Creates a SocketAddress from an IP address and given port number.
 		///
 		/// The IP address must either be a domain name, or it must
 		/// be in dotted decimal (IPv4) or hex string (IPv6) format.
 
+	SocketAddress(Family family, const std::string& hostAddress, Poco::UInt16 portNumber);
+		/// Creates a SocketAddress from an IP address and given port number.
+		///
+		/// The IP address must either be a domain name, or it must
+		/// be in dotted decimal (IPv4) or hex string (IPv6) format.
+		///
+		/// If a domain name is given in hostAddress, it is resolved and the address
+		/// matching the given family is used. If no address matching the given family
+		/// is found, or the IP address given in hostAddress does not match the given
+		/// family, an AddressFamilyMismatchException is thrown.
+
 	SocketAddress(const std::string& hostAddress, const std::string& portNumber);
 		/// Creates a SocketAddress from an IP address and the
 		/// service name or port number.
@@ -81,6 +100,21 @@ public:
 		/// The given port must either be a decimal port number, or
 		/// a service name.
 
+	SocketAddress(Family family, const std::string& hostAddress, const std::string& portNumber);
+		/// Creates a SocketAddress from an IP address and the
+		/// service name or port number.
+		///
+		/// The IP address must either be a domain name, or it must
+		/// be in dotted decimal (IPv4) or hex string (IPv6) format.
+		///
+		/// The given port must either be a decimal port number, or
+		/// a service name.
+		///
+		/// If a domain name is given in hostAddress, it is resolved and the address
+		/// matching the given family is used. If no address matching the given family
+		/// is found, or the IP address given in hostAddress does not match the given
+		/// family, an AddressFamilyMismatchException is thrown.
+
 	explicit SocketAddress(const std::string& hostAndPort);
 		/// Creates a SocketAddress from an IP address or host name and the
 		/// port number/service name. Host name/address and port number must
@@ -156,6 +190,7 @@ public:
 protected:
 	void init(const IPAddress& hostAddress, Poco::UInt16 portNumber);
 	void init(const std::string& hostAddress, Poco::UInt16 portNumber);
+	void init(Family family, const std::string& hostAddress, Poco::UInt16 portNumber);
 	void init(Family family, const std::string& address);
 	void init(const std::string& hostAndPort);
 	Poco::UInt16 resolveService(const std::string& service);

Net/include/Poco/Net/SocketImpl.h

@@ -86,6 +86,19 @@ public:
 		/// If reuseAddress is true, sets the SO_REUSEADDR
 		/// socket option.
 
+	virtual void bind(const SocketAddress& address, bool reuseAddress, bool reusePort );
+		/// Bind a local address to the socket.
+		///
+		/// This is usually only done when establishing a server
+		/// socket. TCP clients should not bind a socket to a
+		/// specific address.
+		///
+		/// If reuseAddress is true, sets the SO_REUSEADDR
+		/// socket option.
+		///
+		/// If reusePort is true, sets the SO_REUSEPORT
+		/// socket option.
+
 	virtual void bind6(const SocketAddress& address, bool reuseAddress = false, bool ipV6Only = false);
 		/// Bind a local IPv6 address to the socket.
 		///
@@ -103,6 +116,26 @@ public:
 		/// If the library has not been built with IPv6 support,
 		/// a Poco::NotImplementedException will be thrown.
 
+	virtual void bind6(const SocketAddress& address, bool reuseAddress, bool reusePort,  bool ipV6Only);
+		/// Bind a local IPv6 address to the socket.
+		///
+		/// This is usually only done when establishing a server
+		/// socket. TCP clients should not bind a socket to a
+		/// specific address.
+		///
+		/// If reuseAddress is true, sets the SO_REUSEADDR
+		/// socket option.
+		///
+		/// If reusePort is true, sets the SO_REUSEPORT
+		/// socket option.
+		///
+		/// The given address must be an IPv6 address. The
+		/// IPPROTO_IPV6/IPV6_V6ONLY option is set on the socket
+		/// according to the ipV6Only parameter.
+		///
+		/// If the library has not been built with IPv6 support,
+		/// a Poco::NotImplementedException will be thrown.
+
 	virtual void listen(int backlog = 64);
 		/// Puts the socket into listening state.
 		///

Net/include/Poco/Net/TCPServer.h

@@ -24,6 +24,8 @@
 #include "Poco/Net/ServerSocket.h"
 #include "Poco/Net/TCPServerConnectionFactory.h"
 #include "Poco/Net/TCPServerParams.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/AutoPtr.h"
 #include "Poco/Runnable.h"
 #include "Poco/Thread.h"
 #include "Poco/ThreadPool.h"
@@ -34,6 +36,35 @@ namespace Net {
 
 
 class TCPServerDispatcher;
+class StreamSocket;
+
+
+class Net_API TCPServerConnectionFilter: public Poco::RefCountedObject
+	/// A TCPServerConnectionFilter can be used to reject incoming connections
+	/// before passing them on to the TCPServerDispatcher and
+	/// starting a thread to handle them.
+	///
+	/// An example use case is white-list or black-list IP address filtering.
+	///
+	/// Subclasses must override the accept() method.
+{
+public:
+	typedef Poco::AutoPtr<TCPServerConnectionFilter> Ptr;
+	
+	virtual bool accept(const StreamSocket& socket) = 0;
+		/// Returns true if the given StreamSocket connection should
+		/// be handled, and passed on to the TCPServerDispatcher.
+		///
+		/// Returns false if the socket should be closed immediately.
+		///
+		/// The socket can be prevented from being closed immediately
+		/// if false is returned by creating a copy of the socket.
+		/// This can be used to handle certain socket connections in
+		/// a special way, outside the TCPServer framework.
+
+protected:
+	virtual ~TCPServerConnectionFilter();
+};
 
 
 class Net_API TCPServer: public Poco::Runnable
@@ -165,6 +196,19 @@ public:
 
 	Poco::UInt16 port() const;
 		/// Returns the port the server socket listens on.
+		
+	void setConnectionFilter(const TCPServerConnectionFilter::Ptr& pFilter);
+		/// Sets a TCPServerConnectionFilter. Can also be used to remove
+		/// a filter by passing a null pointer.
+		///
+		/// To avoid a potential race condition, the filter must
+		/// be set before the TCPServer is started. Trying to set
+		/// the filter after start() has been called will trigger
+		/// an assertion.
+		
+	TCPServerConnectionFilter::Ptr getConnectionFilter() const;
+		/// Returns the TCPServerConnectionFilter set with setConnectionFilter(), 
+		/// or null pointer if no filter has been set.
 
 protected:
 	void run();
@@ -181,13 +225,17 @@ private:
 	TCPServer(const TCPServer&);
 	TCPServer& operator = (const TCPServer&);
 	
-	ServerSocket         _socket;
+	ServerSocket _socket;
 	TCPServerDispatcher* _pDispatcher;
-	Poco::Thread         _thread;
+	TCPServerConnectionFilter::Ptr _pConnectionFilter;
-	bool                 _stopped;
+	Poco::Thread _thread;
+	bool _stopped;
 };
 
 
+//
+// inlines
+//
 inline const ServerSocket& TCPServer::socket() const
 {
 	return _socket;
@@ -200,6 +248,12 @@ inline Poco::UInt16 TCPServer::port() const
 }
 
 
+inline TCPServerConnectionFilter::Ptr TCPServer::getConnectionFilter() const
+{
+	return _pConnectionFilter;
+}
+
+
 } } // namespace Poco::Net
 
 

Net/include/Poco/Net/WebSocketImpl.h

@@ -52,7 +52,9 @@ public:
 	virtual void connect(const SocketAddress& address, const Poco::Timespan& timeout);
 	virtual void connectNB(const SocketAddress& address);
 	virtual void bind(const SocketAddress& address, bool reuseAddress = false);
+	virtual void bind(const SocketAddress& address, bool reuseAddress, bool reusePort);
 	virtual void bind6(const SocketAddress& address, bool reuseAddress = false, bool ipV6Only = false);
+	virtual void bind6(const SocketAddress& address, bool reuseAddress, bool reusePort, bool ipV6Only);
 	virtual void listen(int backlog = 64);
 	virtual void close();
 	virtual void shutdownReceive();

Net/samples/EchoServer/src/EchoServer.cpp

@@ -111,18 +111,38 @@ public:
 	
 	void onSocketReadable(const AutoPtr<ReadableNotification>& pNf)
 	{
-		// some socket implementations (windows) report available 
+		try
-		// bytes on client disconnect, so we  double-check here
-		if (_socket.available())
 		{
 			int len = _socket.receiveBytes(_fifoIn);
-			_fifoIn.drain(_fifoOut.write(_fifoIn.buffer(), _fifoIn.used()));
+			if (len > 0)
+			{
+				_fifoIn.drain(_fifoOut.write(_fifoIn.buffer(), _fifoIn.used()));
+			}
+			else
+			{
+				delete this;
+			}
+		}
+		catch (Poco::Exception& exc)
+		{
+			Application& app = Application::instance();
+			app.logger().log(exc);
+			delete this;
 		}
 	}
 	
 	void onSocketWritable(const AutoPtr<WritableNotification>& pNf)
 	{
-		_socket.sendBytes(_fifoOut);
+		try
+		{
+			_socket.sendBytes(_fifoOut);
+		}
+		catch (Poco::Exception& exc)
+		{
+			Application& app = Application::instance();
+			app.logger().log(exc);
+			delete this;
+		}
 	}
 
 	void onSocketShutdown(const AutoPtr<ShutdownNotification>& pNf)

Net/samples/WebSocketServer/src/WebSocketServer.cpp

@@ -119,7 +119,7 @@ public:
 				app.logger().information(Poco::format("Frame received (length=%d, flags=0x%x).", n, unsigned(flags)));
 				ws.sendFrame(buffer, n, flags);
 			}
-			while (n > 0 || (flags & WebSocket::FRAME_OP_BITMASK) != WebSocket::FRAME_OP_CLOSE);
+			while (n > 0 && (flags & WebSocket::FRAME_OP_BITMASK) != WebSocket::FRAME_OP_CLOSE);
 			app.logger().information("WebSocket connection closed.");
 		}
 		catch (WebSocketException& exc)

Net/src/DatagramSocket.cpp

@@ -83,6 +83,12 @@ void DatagramSocket::bind(const SocketAddress& address, bool reuseAddress)
 }
 
 
+void DatagramSocket::bind(const SocketAddress& address, bool reuseAddress, bool reusePort)
+{
+	impl()->bind(address, reuseAddress, reusePort);
+}
+
+
 int DatagramSocket::sendBytes(const void* buffer, int length, int flags)
 {
 	return impl()->sendBytes(buffer, length, flags);

Net/src/HTTPServerConnection.cpp

@@ -78,7 +78,11 @@ void HTTPServerConnection::run()
 					response.set("Server", server);
 				try
 				{
+#if __cplusplus < 201103L
 					std::auto_ptr<HTTPRequestHandler> pHandler(_pFactory->createRequestHandler(request));
+#else
+					std::unique_ptr<HTTPRequestHandler> pHandler(_pFactory->createRequestHandler(request));
+#endif
 					if (pHandler.get())
 					{
 						if (request.getExpectContinue() && response.getStatus() == HTTPResponse::HTTP_OK)

Net/src/HTTPStreamFactory.cpp

@@ -26,6 +26,8 @@
 #include "Poco/UnbufferedStreamBuf.h"
 #include "Poco/NullStream.h"
 #include "Poco/StreamCopier.h"
+#include "Poco/Format.h"
+#include "Poco/Version.h"
 
 
 using Poco::URIStreamFactory;
@@ -115,6 +117,12 @@ std::istream* HTTPStreamFactory::open(const URI& uri)
 				cred.authenticate(req, res);
 			}
 			
+			req.set("User-Agent", Poco::format("poco/%d.%d.%d", 
+				(POCO_VERSION >> 24) & 0xFF,
+				(POCO_VERSION >> 16) & 0xFF,
+				(POCO_VERSION >> 8) & 0xFF));
+			req.set("Accept", "*/*");
+			
 			pSession->sendRequest(req);
 			std::istream& rs = pSession->receiveResponse(res);
 			bool moved = (res.getStatus() == HTTPResponse::HTTP_MOVED_PERMANENTLY || 

Net/src/MailMessage.cpp

@@ -119,6 +119,10 @@ namespace
 					
 					pPS->headers().set(it->first, it->second);
 				}
+
+				if (contentDisp.empty())
+					_pMsg->addContent(pPS, cte);
+
 				if (!added) delete pPS;
 			}
 		}

Net/src/NetException.cpp

@@ -49,7 +49,8 @@ POCO_IMPLEMENT_EXCEPTION(ICMPException, NetException, "ICMP Exception")
 POCO_IMPLEMENT_EXCEPTION(NTPException, NetException, "NTP Exception")
 POCO_IMPLEMENT_EXCEPTION(HTMLFormException, NetException, "HTML Form Exception")
 POCO_IMPLEMENT_EXCEPTION(WebSocketException, NetException, "WebSocket Exception")
-POCO_IMPLEMENT_EXCEPTION(UnsupportedFamilyException, NetException, "Unknown or unsupported socket family.")
+POCO_IMPLEMENT_EXCEPTION(UnsupportedFamilyException, NetException, "Unknown or unsupported socket family")
+POCO_IMPLEMENT_EXCEPTION(AddressFamilyMismatchException, NetException, "Address family mismatch")
 
 
 } } // namespace Poco::Net

Net/src/RawSocket.cpp

@@ -86,6 +86,12 @@ void RawSocket::bind(const SocketAddress& address, bool reuseAddress)
 }
 
 
+void RawSocket::bind(const SocketAddress& address, bool reuseAddress, bool reusePort)
+{
+	impl()->bind(address, reuseAddress, reusePort);
+}
+
+
 int RawSocket::sendBytes(const void* buffer, int length, int flags)
 {
 	return impl()->sendBytes(buffer, length, flags);

Net/src/ServerSocket.cpp

@@ -80,6 +80,12 @@ void ServerSocket::bind(const SocketAddress& address, bool reuseAddress)
 }
 
 
+void ServerSocket::bind(const SocketAddress& address, bool reuseAddress, bool reusePort)
+{
+	impl()->bind(address, reuseAddress, reusePort);
+}
+
+
 void ServerSocket::bind(Poco::UInt16 port, bool reuseAddress)
 {
 	IPAddress wildcardAddr;
@@ -88,12 +94,26 @@ void ServerSocket::bind(Poco::UInt16 port, bool reuseAddress)
 }
 
 
+void ServerSocket::bind(Poco::UInt16 port, bool reuseAddress, bool reusePort)
+{
+	IPAddress wildcardAddr;
+	SocketAddress address(wildcardAddr, port);
+	impl()->bind(address, reuseAddress, reusePort);
+}
+
+
 void ServerSocket::bind6(const SocketAddress& address, bool reuseAddress, bool ipV6Only)
 {
 	impl()->bind6(address, reuseAddress, ipV6Only);
 }
 
 
+void ServerSocket::bind6(const SocketAddress& address, bool reuseAddress, bool reusePort, bool ipV6Only)
+{
+	impl()->bind6(address, reuseAddress, reusePort, ipV6Only);
+}
+
+
 void ServerSocket::bind6(Poco::UInt16 port, bool reuseAddress, bool ipV6Only)
 {
 #if defined(POCO_HAVE_IPv6)
@@ -106,6 +126,18 @@ void ServerSocket::bind6(Poco::UInt16 port, bool reuseAddress, bool ipV6Only)
 }
 
 	
+void ServerSocket::bind6(Poco::UInt16 port, bool reuseAddress, bool reusePort, bool ipV6Only)
+{
+#if defined(POCO_HAVE_IPv6)
+	IPAddress wildcardAddr(IPAddress::IPv6);
+	SocketAddress address(wildcardAddr, port);
+	impl()->bind6(address, reuseAddress, reusePort, ipV6Only);
+#else
+	throw Poco::NotImplementedException("No IPv6 support available");
+#endif // POCO_HAVE_IPv6
+}
+
+
 void ServerSocket::listen(int backlog)
 {
 	impl()->listen(backlog);

Net/src/Socket.cpp

@@ -144,7 +144,9 @@ int Socket::select(SocketList& readList, SocketList& writeList, SocketList& exce
 		}
 
 		epollSize = eventLast - eventsIn;
-		epollfd = epoll_create(epollSize);
+		if (epollSize == 0) return 0;
+		
+		epollfd = epoll_create(1);
 		if (epollfd < 0)
 		{
 			SocketImpl::error("Can't create epoll queue");

Net/src/SocketAddress.cpp

@@ -77,6 +77,12 @@ SocketAddress::SocketAddress()
 }
 
 
+SocketAddress::SocketAddress(Family fam)
+{
+		init(IPAddress(fam), 0);
+}
+
+
 SocketAddress::SocketAddress(const IPAddress& hostAddress, Poco::UInt16 portNumber)
 {
 	init(hostAddress, portNumber);
@@ -89,21 +95,39 @@ SocketAddress::SocketAddress(Poco::UInt16 portNumber)
 }
 
 
+SocketAddress::SocketAddress(Family fam, Poco::UInt16 portNumber)
+{
+	init(IPAddress(fam), portNumber);
+}
+
+
 SocketAddress::SocketAddress(const std::string& hostAddress, Poco::UInt16 portNumber)
 {
 	init(hostAddress, portNumber);
 }
 
 
+SocketAddress::SocketAddress(Family fam, const std::string& hostAddress, Poco::UInt16 portNumber)
+{
+	init(fam, hostAddress, portNumber);
+}
+
+
 SocketAddress::SocketAddress(const std::string& hostAddress, const std::string& portNumber)
 {
 	init(hostAddress, resolveService(portNumber));
 }
 
 
-SocketAddress::SocketAddress(Family family, const std::string& addr)
+SocketAddress::SocketAddress(Family fam, const std::string& hostAddress, const std::string& portNumber)
 {
-	init(family, addr);
+	init(fam, hostAddress, resolveService(portNumber));
+}
+
+
+SocketAddress::SocketAddress(Family fam, const std::string& addr)
+{
+	init(fam, addr);
 }
 
 
@@ -250,7 +274,7 @@ void SocketAddress::init(const std::string& hostAddress, Poco::UInt16 portNumber
 		HostEntry::AddressList addresses = he.addresses();
 		if (addresses.size() > 0)
 		{
-#if defined(POCO_HAVE_IPv6)
+#if defined(POCO_HAVE_IPv6) && defined(POCO_SOCKETADDRESS_PREFER_IPv4)
 			// if we get both IPv4 and IPv6 addresses, prefer IPv4
 			std::stable_sort(addresses.begin(), addresses.end(), AFLT());
 #endif
@@ -261,6 +285,35 @@ void SocketAddress::init(const std::string& hostAddress, Poco::UInt16 portNumber
 }
 
 
+void SocketAddress::init(Family fam, const std::string& hostAddress, Poco::UInt16 portNumber)
+{
+	IPAddress ip;
+	if (IPAddress::tryParse(hostAddress, ip))
+	{
+		if (ip.family() != fam) throw AddressFamilyMismatchException(hostAddress);
+		init(ip, portNumber);
+	}
+	else
+	{
+		HostEntry he = DNS::hostByName(hostAddress);
+		HostEntry::AddressList addresses = he.addresses();
+		if (addresses.size() > 0)
+		{
+			for (HostEntry::AddressList::const_iterator it = addresses.begin(); it != addresses.end(); ++it)
+			{
+				if (it->family() == fam)
+				{
+					init(*it, portNumber);
+					return;
+				}
+			}
+			throw AddressFamilyMismatchException(hostAddress);
+		}
+		else throw HostNotFoundException("No address found for host", hostAddress);
+	}
+}
+
+
 void SocketAddress::init(Family fam, const std::string& address)
 {
 #if defined(POCO_OS_FAMILY_UNIX)
@@ -271,8 +324,29 @@ void SocketAddress::init(Family fam, const std::string& address)
 	else
 #endif
 	{
-		init(address);
+		std::string host;
-		if (fam != family()) throw Poco::InvalidArgumentException("address does not fit family");
+		std::string port;
+		std::string::const_iterator it  = address.begin();
+		std::string::const_iterator end = address.end();
+
+		if (*it == '[')
+		{
+			++it;
+			while (it != end && *it != ']') host += *it++;
+			if (it == end) throw InvalidArgumentException("Malformed IPv6 address");
+			++it;
+		}
+		else
+		{
+			while (it != end && *it != ':') host += *it++;
+		}
+		if (it != end && *it == ':')
+		{
+			++it;
+			while (it != end) port += *it++;
+		}
+		else throw InvalidArgumentException("Missing port number");
+		init(fam, host, resolveService(port));
 	}
 }
 

Net/src/SocketImpl.cpp

@@ -190,16 +190,21 @@ void SocketImpl::connectNB(const SocketAddress& address)
 
 
 void SocketImpl::bind(const SocketAddress& address, bool reuseAddress)
+{
+    bind(address, reuseAddress, true);
+}
+
+
+void SocketImpl::bind(const SocketAddress& address, bool reuseAddress, bool reusePort)
 {
 	if (_sockfd == POCO_INVALID_SOCKET)
 	{
 		init(address.af());
 	}
 	if (reuseAddress)
-	{
 		setReuseAddress(true);
+    if (reusePort)
 		setReusePort(true);
-	}
 #if defined(POCO_VXWORKS)
 	int rc = ::bind(_sockfd, (sockaddr*) address.addr(), address.length());
 #else
@@ -210,6 +215,12 @@ void SocketImpl::bind(const SocketAddress& address, bool reuseAddress)
 
 
 void SocketImpl::bind6(const SocketAddress& address, bool reuseAddress, bool ipV6Only)
+{
+    bind6(address, reuseAddress, true, ipV6Only);
+}
+
+
+void SocketImpl::bind6(const SocketAddress& address, bool reuseAddress, bool reusePort, bool ipV6Only)
 {
 #if defined(POCO_HAVE_IPv6)
 	if (address.family() != SocketAddress::IPv6)
@@ -225,10 +236,9 @@ void SocketImpl::bind6(const SocketAddress& address, bool reuseAddress, bool ipV
 	if (ipV6Only) throw Poco::NotImplementedException("IPV6_V6ONLY not defined.");
 #endif
 	if (reuseAddress)
-	{
 		setReuseAddress(true);
+    if (reusePort)
 		setReusePort(true);
-	}
 	int rc = ::bind(_sockfd, address.addr(), address.length());
 	if (rc != 0) error(address.toString());
 #else

Net/src/TCPServer.cpp

@@ -30,6 +30,21 @@ namespace Poco {
 namespace Net {
 
 
+//
+// TCPServerConnectionFilter
+//
+
+
+TCPServerConnectionFilter::~TCPServerConnectionFilter()
+{
+}
+
+
+//
+// TCPServer
+//
+
+
 TCPServer::TCPServer(TCPServerConnectionFactory::Ptr pFactory, Poco::UInt16 portNumber, TCPServerParams::Ptr pParams):
 	_socket(ServerSocket(portNumber)),
 	_thread(threadName(_socket)),
@@ -122,14 +137,18 @@ void TCPServer::run()
 				try
 				{
 					StreamSocket ss = _socket.acceptConnection();
-					// enable nodelay per default: OSX really needs that
+					
-#if defined(POCO_OS_FAMILY_UNIX)
+					if (!_pConnectionFilter || _pConnectionFilter->accept(ss))
-					if (ss.address().family() != AddressFamily::UNIX_LOCAL)
-#endif
 					{
-						ss.setNoDelay(true);
+						// enable nodelay per default: OSX really needs that
+#if defined(POCO_OS_FAMILY_UNIX)
+						if (ss.address().family() != AddressFamily::UNIX_LOCAL)
+#endif
+						{
+							ss.setNoDelay(true);
+						}
+						_pDispatcher->enqueue(ss);
 					}
-					_pDispatcher->enqueue(ss);
 				}
 				catch (Poco::Exception& exc)
 				{
@@ -161,6 +180,7 @@ int TCPServer::currentThreads() const
 	return _pDispatcher->currentThreads();
 }
 
+
 int TCPServer::maxThreads() const
 {
 	return _pDispatcher->maxThreads();
@@ -197,6 +217,14 @@ int TCPServer::refusedConnections() const
 }
 
 
+void TCPServer::setConnectionFilter(const TCPServerConnectionFilter::Ptr& pConnectionFilter)
+{
+	poco_assert (_stopped);
+
+	_pConnectionFilter = pConnectionFilter;
+}
+
+
 std::string TCPServer::threadName(const ServerSocket& socket)
 {
 #if _WIN32_WCE == 0x0800

Net/src/TCPServerDispatcher.cpp

@@ -110,7 +110,11 @@ void TCPServerDispatcher::run()
 			TCPConnectionNotification* pCNf = dynamic_cast<TCPConnectionNotification*>(pNf.get());
 			if (pCNf)
 			{
+#if __cplusplus < 201103L
 				std::auto_ptr<TCPServerConnection> pConnection(_pConnectionFactory->createConnection(pCNf->socket()));
+#else
+				std::unique_ptr<TCPServerConnection> pConnection(_pConnectionFactory->createConnection(pCNf->socket()));
+#endif
 				poco_check_ptr(pConnection.get());
 				beginConnection();
 				pConnection->start();

Net/src/WebSocketImpl.cpp

@@ -257,12 +257,24 @@ void WebSocketImpl::bind(const SocketAddress& address, bool reuseAddress)
 }
 
 
+void WebSocketImpl::bind(const SocketAddress& address, bool reuseAddress, bool reusePort)
+{
+	throw Poco::InvalidAccessException("Cannot bind() a WebSocketImpl");
+}
+
+
 void WebSocketImpl::bind6(const SocketAddress& address, bool reuseAddress, bool ipV6Only)
 {
 	throw Poco::InvalidAccessException("Cannot bind6() a WebSocketImpl");
 }
 
 
+void WebSocketImpl::bind6(const SocketAddress& address, bool reuseAddress, bool reusePort, bool ipV6Only)
+{
+	throw Poco::InvalidAccessException("Cannot bind6() a WebSocketImpl");
+}
+
+
 void WebSocketImpl::listen(int backlog)
 {
 	throw Poco::InvalidAccessException("Cannot listen() on a WebSocketImpl");

Net/testsuite/src/DNSTest.cpp

@@ -39,20 +39,20 @@ DNSTest::~DNSTest()
 
 void DNSTest::testHostByName()
 {
-	HostEntry he1 = DNS::hostByName("aliastest.appinf.com");
+	HostEntry he1 = DNS::hostByName("aliastest.pocoproject.org");
 	// different systems report different canonical names, unfortunately.
-	assert (he1.name() == "dnstest.appinf.com" || he1.name() == "aliastest.appinf.com");
+	assert (he1.name() == "dnstest.pocoproject.org" || he1.name() == "aliastest.pocoproject.org");
 #if !defined(POCO_HAVE_ADDRINFO)
 	// getaddrinfo() does not report any aliases
 	assert (!he1.aliases().empty());
-	assert (he1.aliases()[0] == "aliastest.appinf.com");
+	assert (he1.aliases()[0] == "aliastest.pocoproject.org");
 #endif
 	assert (he1.addresses().size() >= 1);
 	assert (he1.addresses()[0].toString() == "1.2.3.4");
 	
 	try
 	{
-		HostEntry he1 = DNS::hostByName("nohost.appinf.com");
+		HostEntry he1 = DNS::hostByName("nohost.pocoproject.org");
 		fail("host not found - must throw");
 	}
 	catch (HostNotFoundException&)

Net/testsuite/src/DatagramSocketTest.cpp

@@ -51,7 +51,7 @@ void DatagramSocketTest::testEcho()
 	UDPEchoServer echoServer;
 	DatagramSocket ss;
 	char buffer[256];
-	ss.connect(SocketAddress("localhost", echoServer.port()));
+	ss.connect(SocketAddress("127.0.0.1", echoServer.port()));
 	int n = ss.sendBytes("hello", 5);
 	assert (n == 5);
 	n = ss.receiveBytes(buffer, sizeof(buffer));
@@ -63,9 +63,9 @@ void DatagramSocketTest::testEcho()
 
 void DatagramSocketTest::testSendToReceiveFrom()
 {
-	UDPEchoServer echoServer(SocketAddress("localhost", 0));
+	UDPEchoServer echoServer(SocketAddress("127.0.0.1", 0));
 	DatagramSocket ss(SocketAddress::IPv4);
-	int n = ss.sendTo("hello", 5, SocketAddress("localhost", echoServer.port()));
+	int n = ss.sendTo("hello", 5, SocketAddress("127.0.0.1", echoServer.port()));
 	assert (n == 5);
 	char buffer[256];
 	SocketAddress sa;
@@ -83,7 +83,7 @@ void DatagramSocketTest::testUnbound()
 	UDPEchoServer echoServer;
 	DatagramSocket ss;
 	char buffer[256];
-	ss.connect(SocketAddress("localhost", echoServer.port()));
+	ss.connect(SocketAddress("127.0.0.1", echoServer.port()));
 	int n = ss.sendBytes("hello", 5);
 	assert (n == 5);
 	n = ss.receiveBytes(buffer, sizeof(buffer));

Net/testsuite/src/DialogSocketTest.cpp

@@ -37,7 +37,7 @@ void DialogSocketTest::testDialogSocket()
 {
 	EchoServer echoServer;
 	DialogSocket ds;
-	ds.connect(SocketAddress("localhost", echoServer.port()));
+	ds.connect(SocketAddress("127.0.0.1", echoServer.port()));
 
 	ds.sendMessage("Hello, world!");
 	std::string str;

Net/testsuite/src/FTPClientSessionTest.cpp

@@ -94,7 +94,7 @@ void FTPClientSessionTest::testLogin1()
 {
 	DialogServer server;
 	server.addResponse("220 localhost FTP ready");
-	FTPClientSession session("localhost", server.port());
+	FTPClientSession session("127.0.0.1", server.port());
 	assert (session.isOpen());
 	assert (!session.isLoggedIn());
 	login(server, session);
@@ -125,7 +125,7 @@ void FTPClientSessionTest::testLogin2()
 	server.addResponse("230 Welcome");
 	server.addResponse("200 Type set to I");
 	Poco::UInt16 serverPort = server.port();
-	FTPClientSession session("localhost", serverPort, "user", "password");
+	FTPClientSession session("127.0.0.1", serverPort, "user", "password");
 	assert (session.isOpen());
 	assert (session.isLoggedIn());
 	server.addResponse("221 Good Bye");
@@ -139,7 +139,7 @@ void FTPClientSessionTest::testLogin2()
 	server.addResponse("331 Password required");
 	server.addResponse("230 Welcome");
 	server.addResponse("200 Type set to I");
-	session.open("localhost", serverPort, "user", "password");
+	session.open("127.0.0.1", serverPort, "user", "password");
 	assert (session.isOpen());
 	assert (session.isLoggedIn());
 	server.addResponse("221 Good Bye");
@@ -159,7 +159,7 @@ void FTPClientSessionTest::testLogin3()
 	FTPClientSession session;
 	assert (!session.isOpen());
 	assert (!session.isLoggedIn());
-	session.open("localhost", server.port(), "user", "password");
+	session.open("127.0.0.1", server.port(), "user", "password");
 	server.addResponse("221 Good Bye");
 	session.close();
 	assert (!session.isOpen());
@@ -172,7 +172,7 @@ void FTPClientSessionTest::testLoginFailed1()
 {
 	DialogServer server;
 	server.addResponse("421 localhost FTP not ready");
-	FTPClientSession session("localhost", server.port());
+	FTPClientSession session("127.0.0.1", server.port());
 	try
 	{
 		session.login("user", "password");
@@ -192,7 +192,7 @@ void FTPClientSessionTest::testLoginFailed2()
 	server.addResponse("220 localhost FTP ready");
 	server.addResponse("331 Password required");
 	server.addResponse("530 Login incorrect");
-	FTPClientSession session("localhost", server.port());
+	FTPClientSession session("127.0.0.1", server.port());
 	try
 	{
 		session.login("user", "password");
@@ -213,7 +213,7 @@ void FTPClientSessionTest::testCommands()
 	server.addResponse("331 Password required");
 	server.addResponse("230 Welcome");
 	server.addResponse("200 Type set to I");
-	FTPClientSession session("localhost", server.port());
+	FTPClientSession session("127.0.0.1", server.port());
 	session.login("user", "password");
 	std::string cmd = server.popCommand();
 	assert (cmd == "USER user");
@@ -342,7 +342,7 @@ void FTPClientSessionTest::testDownloadPORT()
 	server.addResponse("331 Password required");
 	server.addResponse("230 Welcome");
 	server.addResponse("200 Type set to I");
-	FTPClientSession session("localhost", server.port());
+	FTPClientSession session("127.0.0.1", server.port());
 	session.setPassive(false);
 	session.login("user", "password");
 	server.clearCommands();
@@ -373,7 +373,7 @@ void FTPClientSessionTest::testDownloadPORT()
 	cmd = server.popCommandWait();
 	assert (cmd == "RETR test.txt");
 
-	SocketAddress sa("localhost", (Poco::UInt16) port);
+	SocketAddress sa("127.0.0.1", (Poco::UInt16) port);
 	DialogSocket dataSock;
 	dataSock.connect(sa);
 
@@ -397,7 +397,7 @@ void FTPClientSessionTest::testDownloadEPRT()
 	server.addResponse("331 Password required");
 	server.addResponse("230 Welcome");
 	server.addResponse("200 Type set to I");
-	FTPClientSession session("localhost", server.port());
+	FTPClientSession session("127.0.0.1", server.port());
 	session.setPassive(false);
 	session.login("user", "password");
 	server.clearCommands();
@@ -421,7 +421,7 @@ void FTPClientSessionTest::testDownloadEPRT()
 	cmd = server.popCommandWait();
 	assert (cmd == "RETR test.txt");
 	
-	SocketAddress sa("localhost", (Poco::UInt16) port);
+	SocketAddress sa("127.0.0.1", (Poco::UInt16) port);
 	DialogSocket dataSock;
 	dataSock.connect(sa);
 
@@ -445,7 +445,7 @@ void FTPClientSessionTest::testDownloadPASV()
 	server.addResponse("331 Password required");
 	server.addResponse("230 Welcome");
 	server.addResponse("200 Type set to I");
-	FTPClientSession session("localhost", server.port());
+	FTPClientSession session("127.0.0.1", server.port());
 	session.login("user", "password");
 	server.clearCommands();
 
@@ -478,7 +478,7 @@ void FTPClientSessionTest::testDownloadEPSV()
 	server.addResponse("331 Password required");
 	server.addResponse("230 Welcome");
 	server.addResponse("200 Type set to I");
-	FTPClientSession session("localhost", server.port());
+	FTPClientSession session("127.0.0.1", server.port());
 	session.login("user", "password");
 	server.clearCommands();
 
@@ -513,7 +513,7 @@ void FTPClientSessionTest::testUpload()
 	server.addResponse("331 Password required");
 	server.addResponse("230 Welcome");
 	server.addResponse("200 Type set to I");
-	FTPClientSession session("localhost", server.port());
+	FTPClientSession session("127.0.0.1", server.port());
 	session.login("user", "password");
 	server.clearCommands();
 
@@ -546,7 +546,7 @@ void FTPClientSessionTest::testList()
 	server.addResponse("331 Password required");
 	server.addResponse("230 Welcome");
 	server.addResponse("200 Type set to I");
-	FTPClientSession session("localhost", server.port());
+	FTPClientSession session("127.0.0.1", server.port());
 	session.login("user", "password");
 	server.clearCommands();
 

Net/testsuite/src/FTPStreamFactoryTest.cpp

@@ -77,7 +77,7 @@ void FTPStreamFactoryTest::testDownload()
 
 	URI uri;
 	uri.setScheme("ftp");
-	uri.setHost("localhost");
+	uri.setHost("127.0.0.1");
 	uri.setPort(server.port());
 	uri.setPath("/test.txt;type=a");
 	FTPStreamFactory sf;
@@ -115,7 +115,7 @@ void FTPStreamFactoryTest::testList()
 
 	URI uri;
 	uri.setScheme("ftp");
-	uri.setHost("localhost");
+	uri.setHost("127.0.0.1");
 	uri.setPort(server.port());
 	uri.setPath("/usr/guest/data;type=d");
 	FTPStreamFactory sf;
@@ -152,7 +152,7 @@ void FTPStreamFactoryTest::testUserInfo()
 
 	URI uri;
 	uri.setScheme("ftp");
-	uri.setHost("localhost");
+	uri.setHost("127.0.0.1");
 	uri.setPort(server.port());
 	uri.setPath("/test.txt;type=a");
 	uri.setUserInfo("user:secret");
@@ -191,7 +191,7 @@ void FTPStreamFactoryTest::testPasswordProvider()
 
 	URI uri;
 	uri.setScheme("ftp");
-	uri.setHost("localhost");
+	uri.setHost("127.0.0.1");
 	uri.setPort(server.port());
 	uri.setPath("/test.txt;type=a");
 	uri.setUserInfo("user");
@@ -218,7 +218,7 @@ void FTPStreamFactoryTest::testMissingPasswordProvider()
 
 	URI uri;
 	uri.setScheme("ftp");
-	uri.setHost("localhost");
+	uri.setHost("127.0.0.1");
 	uri.setPort(server.port());
 	uri.setPath("/test.txt;type=a");
 	uri.setUserInfo("user");

Net/testsuite/src/HTTPClientSessionTest.cpp

@@ -43,7 +43,7 @@ HTTPClientSessionTest::~HTTPClientSessionTest()
 void HTTPClientSessionTest::testGetSmall()
 {
 	HTTPTestServer srv;
-	HTTPClientSession s("localhost", srv.port());
+	HTTPClientSession s("127.0.0.1", srv.port());
 	HTTPRequest request(HTTPRequest::HTTP_GET, "/small");
 	s.sendRequest(request);
 	HTTPResponse response;
@@ -59,7 +59,7 @@ void HTTPClientSessionTest::testGetSmall()
 void HTTPClientSessionTest::testGetLarge()
 {
 	HTTPTestServer srv;
-	HTTPClientSession s("localhost", srv.port());
+	HTTPClientSession s("127.0.0.1", srv.port());
 	HTTPRequest request(HTTPRequest::HTTP_GET, "/large");
 	s.sendRequest(request);
 	HTTPResponse response;
@@ -75,7 +75,7 @@ void HTTPClientSessionTest::testGetLarge()
 void HTTPClientSessionTest::testHead()
 {
 	HTTPTestServer srv;
-	HTTPClientSession s("localhost", srv.port());
+	HTTPClientSession s("127.0.0.1", srv.port());
 	HTTPRequest request(HTTPRequest::HTTP_HEAD, "/large");
 	s.sendRequest(request);
 	HTTPResponse response;
@@ -90,7 +90,7 @@ void HTTPClientSessionTest::testHead()
 void HTTPClientSessionTest::testPostSmallIdentity()
 {
 	HTTPTestServer srv;
-	HTTPClientSession s("localhost", srv.port());
+	HTTPClientSession s("127.0.0.1", srv.port());
 	HTTPRequest request(HTTPRequest::HTTP_POST, "/echo");
 	std::string body("this is a random request body\r\n0\r\n");
 	request.setContentLength((int) body.length());
@@ -107,7 +107,7 @@ void HTTPClientSessionTest::testPostSmallIdentity()
 void HTTPClientSessionTest::testPostLargeIdentity()
 {
 	HTTPTestServer srv;
-	HTTPClientSession s("localhost", srv.port());
+	HTTPClientSession s("127.0.0.1", srv.port());
 	HTTPRequest request(HTTPRequest::HTTP_POST, "/echo");
 	std::string body(8000, 'x');
 	body.append("\r\n0\r\n");
@@ -125,7 +125,7 @@ void HTTPClientSessionTest::testPostLargeIdentity()
 void HTTPClientSessionTest::testPostSmallChunked()
 {
 	HTTPTestServer srv;
-	HTTPClientSession s("localhost", srv.port());
+	HTTPClientSession s("127.0.0.1", srv.port());
 	HTTPRequest request(HTTPRequest::HTTP_POST, "/echo");
 	std::string body("this is a random request body");
 	request.setChunkedTransferEncoding(true);
@@ -143,7 +143,7 @@ void HTTPClientSessionTest::testPostSmallChunked()
 void HTTPClientSessionTest::testPostLargeChunked()
 {
 	HTTPTestServer srv;
-	HTTPClientSession s("localhost", srv.port());
+	HTTPClientSession s("127.0.0.1", srv.port());
 	HTTPRequest request(HTTPRequest::HTTP_POST, "/echo");
 	std::string body(16000, 'x');
 	request.setChunkedTransferEncoding(true);
@@ -163,7 +163,7 @@ void HTTPClientSessionTest::testPostLargeChunked()
 void HTTPClientSessionTest::testPostSmallClose()
 {
 	HTTPTestServer srv;
-	HTTPClientSession s("localhost", srv.port());
+	HTTPClientSession s("127.0.0.1", srv.port());
 	HTTPRequest request(HTTPRequest::HTTP_POST, "/echo");
 	std::string body("this is a random request body");
 	s.sendRequest(request) << body;
@@ -180,7 +180,7 @@ void HTTPClientSessionTest::testPostSmallClose()
 void HTTPClientSessionTest::testPostLargeClose()
 {
 	HTTPTestServer srv;
-	HTTPClientSession s("localhost", srv.port());
+	HTTPClientSession s("127.0.0.1", srv.port());
 	HTTPRequest request(HTTPRequest::HTTP_POST, "/echo");
 	std::string body(8000, 'x');
 	s.sendRequest(request) << body;
@@ -197,7 +197,7 @@ void HTTPClientSessionTest::testPostLargeClose()
 void HTTPClientSessionTest::testKeepAlive()
 {
 	HTTPTestServer srv;
-	HTTPClientSession s("localhost", srv.port());
+	HTTPClientSession s("127.0.0.1", srv.port());
 	s.setKeepAlive(true);
 	HTTPRequest request(HTTPRequest::HTTP_HEAD, "/keepAlive", HTTPMessage::HTTP_1_1);
 	s.sendRequest(request);
@@ -246,7 +246,7 @@ void HTTPClientSessionTest::testProxy()
 {
 	HTTPTestServer srv;
 	HTTPClientSession s("www.somehost.com");
-	s.setProxy("localhost", srv.port());
+	s.setProxy("127.0.0.1", srv.port());
 	HTTPRequest request(HTTPRequest::HTTP_GET, "/large");
 	s.sendRequest(request);
 	HTTPResponse response;
@@ -263,7 +263,7 @@ void HTTPClientSessionTest::testProxyAuth()
 {
 	HTTPTestServer srv;
 	HTTPClientSession s("www.somehost.com");
-	s.setProxy("localhost", srv.port());
+	s.setProxy("127.0.0.1", srv.port());
 	s.setProxyCredentials("user", "pass");
 	HTTPRequest request(HTTPRequest::HTTP_GET, "/large");
 	s.sendRequest(request);
@@ -286,7 +286,7 @@ void HTTPClientSessionTest::testBypassProxy()
 	proxyConfig.port = 80;
 	proxyConfig.nonProxyHosts = "localhost|127\\.0\\.0\\.1";
 	
-	HTTPClientSession s1("localhost", 80);
+	HTTPClientSession s1("127.0.0.1", 80);
 	s1.setProxyConfig(proxyConfig);
 	assert (s1.bypassProxy());
 	
@@ -303,7 +303,7 @@ void HTTPClientSessionTest::testBypassProxy()
 void HTTPClientSessionTest::testExpectContinue()
 {
 	HTTPTestServer srv;
-	HTTPClientSession s("localhost", srv.port());
+	HTTPClientSession s("127.0.0.1", srv.port());
 	HTTPRequest request(HTTPRequest::HTTP_POST, "/expect");
 	std::string body("this is a random request body\r\n0\r\n");
 	request.setContentLength((int) body.length());
@@ -324,7 +324,7 @@ void HTTPClientSessionTest::testExpectContinue()
 void HTTPClientSessionTest::testExpectContinueFail()
 {
 	HTTPTestServer srv;
-	HTTPClientSession s("localhost", srv.port());
+	HTTPClientSession s("127.0.0.1", srv.port());
 	HTTPRequest request(HTTPRequest::HTTP_POST, "/fail");
 	std::string body("this is a random request body\r\n0\r\n");
 	request.setContentLength((int) body.length());

Net/testsuite/src/HTTPServerTest.cpp

@@ -146,7 +146,7 @@ void HTTPServerTest::testIdentityRequest()
 	HTTPServer srv(new RequestHandlerFactory, svs, pParams);
 	srv.start();
 	
-	HTTPClientSession cs("localhost", svs.address().port());
+	HTTPClientSession cs("127.0.0.1", svs.address().port());
 	std::string body(5000, 'x');
 	HTTPRequest request("POST", "/echoBody");
 	request.setContentLength((int) body.length());
@@ -169,7 +169,7 @@ void HTTPServerTest::testPutIdentityRequest()
 	HTTPServer srv(new RequestHandlerFactory, svs, pParams);
 	srv.start();
 	
-	HTTPClientSession cs("localhost", svs.address().port());
+	HTTPClientSession cs("127.0.0.1", svs.address().port());
 	std::string body(5000, 'x');
 	HTTPRequest request("PUT", "/echoBody");
 	request.setContentLength((int) body.length());
@@ -192,7 +192,7 @@ void HTTPServerTest::testChunkedRequest()
 	HTTPServer srv(new RequestHandlerFactory, svs, pParams);
 	srv.start();
 	
-	HTTPClientSession cs("localhost", svs.address().port());
+	HTTPClientSession cs("127.0.0.1", svs.address().port());
 	std::string body(5000, 'x');
 	HTTPRequest request("POST", "/echoBody");
 	request.setContentType("text/plain");
@@ -216,7 +216,7 @@ void HTTPServerTest::testClosedRequest()
 	HTTPServer srv(new RequestHandlerFactory, svs, pParams);
 	srv.start();
 	
-	HTTPClientSession cs("localhost", svs.address().port());
+	HTTPClientSession cs("127.0.0.1", svs.address().port());
 	std::string body(5000, 'x');
 	HTTPRequest request("POST", "/echoBody");
 	request.setContentType("text/plain");
@@ -236,7 +236,7 @@ void HTTPServerTest::testIdentityRequestKeepAlive()
 	HTTPServer srv(new RequestHandlerFactory, 8008);
 	srv.start();
 	
-	HTTPClientSession cs("localhost", srv.socket().address().port());
+	HTTPClientSession cs("127.0.0.1", srv.socket().address().port());
 	cs.setKeepAlive(true);
 	std::string body(5000, 'x');
 	HTTPRequest request("POST", "/echoBody", HTTPMessage::HTTP_1_1);
@@ -267,7 +267,7 @@ void HTTPServerTest::testChunkedRequestKeepAlive()
 	HTTPServer srv(new RequestHandlerFactory, 8009);
 	srv.start();
 	
-	HTTPClientSession cs("localhost", srv.socket().address().port());
+	HTTPClientSession cs("127.0.0.1", srv.socket().address().port());
 	cs.setKeepAlive(true);
 	std::string body(5000, 'x');
 	HTTPRequest request("POST", "/echoBody", HTTPMessage::HTTP_1_1);
@@ -299,7 +299,7 @@ void HTTPServerTest::testClosedRequestKeepAlive()
 	HTTPServer srv(new RequestHandlerFactory, 8010);
 	srv.start();
 	
-	HTTPClientSession cs("localhost", srv.socket().address().port());
+	HTTPClientSession cs("127.0.0.1", srv.socket().address().port());
 	std::string body(5000, 'x');
 	HTTPRequest request("POST", "/echoBody");
 	request.setContentType("text/plain");
@@ -324,7 +324,7 @@ void HTTPServerTest::testMaxKeepAlive()
 	HTTPServer srv(new RequestHandlerFactory, svs, pParams);
 	srv.start();
 	
-	HTTPClientSession cs("localhost", svs.address().port());
+	HTTPClientSession cs("127.0.0.1", svs.address().port());
 	cs.setKeepAlive(true);
 	HTTPRequest request("POST", "/echoBody", HTTPMessage::HTTP_1_1);
 	request.setContentType("text/plain");
@@ -380,7 +380,7 @@ void HTTPServerTest::testKeepAliveTimeout()
 	HTTPServer srv(new RequestHandlerFactory, svs, pParams);
 	srv.start();
 	
-	HTTPClientSession cs("localhost", svs.address().port());
+	HTTPClientSession cs("127.0.0.1", svs.address().port());
 	cs.setKeepAlive(true);
 	cs.setKeepAliveTimeout(Poco::Timespan(2, 0));
 	HTTPRequest request("POST", "/echoBody", HTTPMessage::HTTP_1_1);
@@ -424,7 +424,7 @@ void HTTPServerTest::test100Continue()
 	HTTPServer srv(new RequestHandlerFactory, svs, pParams);
 	srv.start();
 	
-	HTTPClientSession cs("localhost", svs.address().port());
+	HTTPClientSession cs("127.0.0.1", svs.address().port());
 	std::string body(5000, 'x');
 	HTTPRequest request("POST", "/echoBody");
 	request.setContentLength((int) body.length());
@@ -448,7 +448,7 @@ void HTTPServerTest::testRedirect()
 	HTTPServer srv(new RequestHandlerFactory, svs, pParams);
 	srv.start();
 	
-	HTTPClientSession cs("localhost", svs.address().port());
+	HTTPClientSession cs("127.0.0.1", svs.address().port());
 	HTTPRequest request("GET", "/redirect");
 	cs.sendRequest(request);
 	HTTPResponse response;
@@ -468,7 +468,7 @@ void HTTPServerTest::testAuth()
 	HTTPServer srv(new RequestHandlerFactory, svs, pParams);
 	srv.start();
 	
-	HTTPClientSession cs("localhost", svs.address().port());
+	HTTPClientSession cs("127.0.0.1", svs.address().port());
 	HTTPRequest request("GET", "/auth");
 	cs.sendRequest(request);
 	HTTPResponse response;
@@ -488,7 +488,7 @@ void HTTPServerTest::testNotImpl()
 	HTTPServer srv(new RequestHandlerFactory, svs, pParams);
 	srv.start();
 	
-	HTTPClientSession cs("localhost", svs.address().port());
+	HTTPClientSession cs("127.0.0.1", svs.address().port());
 	HTTPRequest request("GET", "/notImpl");
 	cs.sendRequest(request);
 	HTTPResponse response;
@@ -507,7 +507,7 @@ void HTTPServerTest::testBuffer()
 	HTTPServer srv(new RequestHandlerFactory, svs, pParams);
 	srv.start();
 	
-	HTTPClientSession cs("localhost", svs.address().port());
+	HTTPClientSession cs("127.0.0.1", svs.address().port());
 	HTTPRequest request("GET", "/buffer");
 	cs.sendRequest(request);
 	HTTPResponse response;

Net/testsuite/src/HTTPStreamFactoryTest.cpp

@@ -44,7 +44,7 @@ void HTTPStreamFactoryTest::testNoRedirect()
 {
 	HTTPTestServer server;
 	HTTPStreamFactory factory;
-	URI uri("http://localhost/large");
+	URI uri("http://127.0.0.1/large");
 	uri.setPort(server.port());
 	std::auto_ptr<std::istream> pStr(factory.open(uri));
 	std::ostringstream ostr;
@@ -57,7 +57,7 @@ void HTTPStreamFactoryTest::testEmptyPath()
 {
 	HTTPTestServer server;
 	HTTPStreamFactory factory;
-	URI uri("http://localhost");
+	URI uri("http://127.0.0.1");
 	uri.setPort(server.port());
 	std::auto_ptr<std::istream> pStr(factory.open(uri));
 	std::ostringstream ostr;
@@ -71,7 +71,7 @@ void HTTPStreamFactoryTest::testRedirect()
 	HTTPTestServer server;
 	Poco::URIStreamOpener opener;
 	opener.registerStreamFactory("http", new HTTPStreamFactory);
-	URI uri("http://localhost/redirect");
+	URI uri("http://127.0.0.1/redirect");
 	uri.setPort(server.port());
 	std::auto_ptr<std::istream> pStr(opener.open(uri));
 	std::ostringstream ostr;
@@ -83,7 +83,7 @@ void HTTPStreamFactoryTest::testRedirect()
 void HTTPStreamFactoryTest::testProxy()
 {
 	HTTPTestServer server;
-	HTTPStreamFactory factory("localhost", server.port());
+	HTTPStreamFactory factory("127.0.0.1", server.port());
 	URI uri("http://www.somehost.com/large");
 	std::auto_ptr<std::istream> pStr(factory.open(uri));
 	std::ostringstream ostr;
@@ -96,7 +96,7 @@ void HTTPStreamFactoryTest::testError()
 {
 	HTTPTestServer server;
 	HTTPStreamFactory factory;
-	URI uri("http://localhost/notfound");
+	URI uri("http://127.0.0.1/notfound");
 	uri.setPort(server.port());
 	try
 	{

Net/testsuite/src/ICMPClientTest.cpp

@@ -48,9 +48,9 @@ ICMPClientTest::~ICMPClientTest()
 
 void ICMPClientTest::testPing()
 {
-	assert(ICMPClient::pingIPv4("localhost") > 0);
+	assert(ICMPClient::pingIPv4("127.0.0.1") > 0);
 
-	assert(_icmpClient.ping("localhost") > 0);
+	assert(_icmpClient.ping("127.0.0.1") > 0);
 	assert(_icmpClient.ping("www.appinf.com", 4) > 0);
 
 	// warning: may fail depending on the existence of the addresses at test site

Net/testsuite/src/POP3ClientSessionTest.cpp

@@ -42,7 +42,7 @@ void POP3ClientSessionTest::testLogin()
 	server.addResponse("+OK USER");
 	server.addResponse("+OK PASS");
 	server.addResponse("+OK QUIT");
-	POP3ClientSession session("localhost", server.port());
+	POP3ClientSession session("127.0.0.1", server.port());
 	session.login("user", "secret");
 	std::string cmd = server.popCommand();
 	assert (cmd == "USER user");
@@ -61,7 +61,7 @@ void POP3ClientSessionTest::testLoginFail()
 	server.addResponse("+OK USER");
 	server.addResponse("-ERR PASS");
 	server.addResponse("+OK QUIT");
-	POP3ClientSession session("localhost", server.port());
+	POP3ClientSession session("127.0.0.1", server.port());
 	try
 	{
 		session.login("user", "secret");
@@ -82,7 +82,7 @@ void POP3ClientSessionTest::testMessageCount()
 	server.addResponse("+OK PASS");
 	server.addResponse("+OK 42 12345");
 	server.addResponse("+OK QUIT");
-	POP3ClientSession session("localhost", server.port());
+	POP3ClientSession session("127.0.0.1", server.port());
 	session.login("user", "secret");
 	server.clearCommands();
 	int n = session.messageCount();
@@ -107,7 +107,7 @@ void POP3ClientSessionTest::testList()
 		".\r\n"
 	);
 	server.addResponse("+OK QUIT");
-	POP3ClientSession session("localhost", server.port());
+	POP3ClientSession session("127.0.0.1", server.port());
 	session.login("user", "secret");
 	server.clearCommands();
 	std::vector<POP3ClientSession::MessageInfo> infos;
@@ -146,7 +146,7 @@ void POP3ClientSessionTest::testRetrieveMessage()
 		".\r\n"
 	);
 	server.addResponse("+OK QUIT");
-	POP3ClientSession session("localhost", server.port());
+	POP3ClientSession session("127.0.0.1", server.port());
 	session.login("user", "secret");
 	server.clearCommands();
 	MailMessage message;
@@ -182,7 +182,7 @@ void POP3ClientSessionTest::testRetrieveHeader()
 		"."
 	);
 	server.addResponse("+OK QUIT");
-	POP3ClientSession session("localhost", server.port());
+	POP3ClientSession session("127.0.0.1", server.port());
 	session.login("user", "secret");
 	server.clearCommands();
 	MessageHeader header;
@@ -225,7 +225,7 @@ void POP3ClientSessionTest::testRetrieveMessages()
 		"."
 	);
 	server.addResponse("+OK QUIT");
-	POP3ClientSession session("localhost", server.port());
+	POP3ClientSession session("127.0.0.1", server.port());
 	session.login("user", "secret");
 	server.clearCommands();
 	MessageHeader header;
@@ -261,7 +261,7 @@ void POP3ClientSessionTest::testDeleteMessage()
 	server.addResponse("+OK PASS");
 	server.addResponse("+OK DELETED");
 	server.addResponse("+OK QUIT");
-	POP3ClientSession session("localhost", server.port());
+	POP3ClientSession session("127.0.0.1", server.port());
 	session.login("user", "secret");
 	server.clearCommands();
 	session.deleteMessage(42);

Net/testsuite/src/RawSocketTest.cpp

@@ -45,7 +45,7 @@ RawSocketTest::~RawSocketTest()
 
 void RawSocketTest::testEchoIPv4()
 {
-	SocketAddress sa("localhost", 0);
+	SocketAddress sa("127.0.0.1", 0);
 	RawSocket rs(IPAddress::IPv4);
 	rs.connect(sa);
 
@@ -70,7 +70,7 @@ void RawSocketTest::testSendToReceiveFromIPv4()
 {
 	RawSocket rs(IPAddress::IPv4);
 	
-	int n = rs.sendTo("hello", 5, SocketAddress("localhost", 0));
+	int n = rs.sendTo("hello", 5, SocketAddress("127.0.0.1", 0));
 	assert (n == 5);
 
 	char buffer[256] = "";

Net/testsuite/src/SMTPClientSessionTest.cpp

@@ -42,7 +42,7 @@ void SMTPClientSessionTest::testLoginEHLO()
 	server.addResponse("220 localhost SMTP ready");
 	server.addResponse("250 Hello localhost");
 	server.addResponse("221 Bye");
-	SMTPClientSession session("localhost", server.port());
+	SMTPClientSession session("127.0.0.1", server.port());
 	session.login("localhost");
 	std::string cmd = server.popCommand();
 	assert (cmd == "EHLO localhost");
@@ -59,7 +59,7 @@ void SMTPClientSessionTest::testLoginHELO()
 	server.addResponse("500 EHLO not understood");
 	server.addResponse("250 Hello localhost");
 	server.addResponse("221 Bye");
-	SMTPClientSession session("localhost", server.port());
+	SMTPClientSession session("127.0.0.1", server.port());
 	session.login("localhost");
 	std::string cmd = server.popCommand();
 	assert (cmd == "EHLO localhost");
@@ -76,7 +76,7 @@ void SMTPClientSessionTest::testLoginFailed()
 	DialogServer server;
 	server.addResponse("500 No SMTP service here");
 	server.addResponse("221 Bye");
-	SMTPClientSession session("localhost", server.port());
+	SMTPClientSession session("127.0.0.1", server.port());
 	try
 	{
 		session.login("localhost");
@@ -99,7 +99,7 @@ void SMTPClientSessionTest::testSend()
 	server.addResponse("354 Send data");
 	server.addResponse("250 OK");
 	server.addResponse("221 Bye");
-	SMTPClientSession session("localhost", server.port());
+	SMTPClientSession session("127.0.0.1", server.port());
 	session.login("localhost");
 
 	MailMessage message;
@@ -153,7 +153,7 @@ void SMTPClientSessionTest::testSendMultiRecipient()
 	server.addResponse("250 OK");
 	server.addResponse("250 OK");
 	server.addResponse("221 Bye");
-	SMTPClientSession session("localhost", server.port());
+	SMTPClientSession session("127.0.0.1", server.port());
 	session.login("localhost");
 
 	MailMessage message;
@@ -218,7 +218,7 @@ void SMTPClientSessionTest::testMultiSeparateRecipient()
 	server.addResponse("250 OK");
 	server.addResponse("250 OK");
 	server.addResponse("221 Bye");
-	SMTPClientSession session("localhost", server.port());
+	SMTPClientSession session("127.0.0.1", server.port());
 	session.login("localhost");
 
 	MailMessage message;
@@ -285,7 +285,7 @@ void SMTPClientSessionTest::testSendFailed()
 	server.addResponse("354 Send data");
 	server.addResponse("500 Error");
 	server.addResponse("221 Bye");
-	SMTPClientSession session("localhost", server.port());
+	SMTPClientSession session("127.0.0.1", server.port());
 	session.login("localhost");
 
 	MailMessage message;

Net/testsuite/src/SocketAddressTest.cpp

@@ -23,6 +23,7 @@ using Poco::Net::InvalidAddressException;
 using Poco::Net::HostNotFoundException;
 using Poco::Net::ServiceNotFoundException;
 using Poco::Net::NoAddressFoundException;
+using Poco::Net::AddressFamilyMismatchException;
 using Poco::InvalidArgumentException;
 
 
@@ -68,10 +69,10 @@ void SocketAddressTest::testSocketAddress()
 	{
 	}
 
-	SocketAddress sa4("www.appinf.com", 80);
+	SocketAddress sa4("pocoproject.org", 80);
 	assert (sa4.host().toString() == "162.209.7.4");
 	assert (sa4.port() == 80);
-
+	
 	try
 	{
 		SocketAddress sa5("192.168.2.260", 80);
@@ -118,6 +119,24 @@ void SocketAddressTest::testSocketAddress()
 	catch (InvalidArgumentException&)
 	{
 	}
+	
+	SocketAddress sa10("www6.pocoproject.org", 80);
+	assert (sa10.host().toString() == "162.209.7.4" || sa10.host().toString() == "[2001:4801:7819:74:be76:4eff:fe10:6b73]");
+	
+	SocketAddress sa11(SocketAddress::IPv4, "www6.pocoproject.org", 80);
+	assert (sa11.host().toString() == "162.209.7.4");
+
+#ifdef POCO_HAVE_IPv6
+	try
+	{
+		SocketAddress sa12(SocketAddress::IPv6, "www6.pocoproject.org", 80);
+		assert (sa12.host().toString() == "2001:4801:7819:74:be76:4eff:fe10:6b73");
+	}
+	catch (AddressFamilyMismatchException&)
+	{
+		// may happen if no IPv6 address is configured on the system
+	}
+#endif
 }
 
 

Net/testsuite/src/SocketReactorTest.cpp

@@ -314,7 +314,7 @@ void SocketReactorTest::testSocketReactor()
 	ServerSocket ss(ssa);
 	SocketReactor reactor;
 	SocketAcceptor<EchoServiceHandler> acceptor(ss, reactor);
-	SocketAddress sa("localhost", ss.address().port());
+	SocketAddress sa("127.0.0.1", ss.address().port());
 	SocketConnector<ClientServiceHandler> connector(sa, reactor);
 	ClientServiceHandler::setOnce(true);
 	ClientServiceHandler::resetData();
@@ -334,7 +334,7 @@ void SocketReactorTest::testSetSocketReactor()
 	SocketReactor reactor;
 	SocketAcceptor<EchoServiceHandler> acceptor(ss);
 	acceptor.setReactor(reactor);
-	SocketAddress sa("localhost", ss.address().port());
+	SocketAddress sa("127.0.0.1", ss.address().port());
 	SocketConnector<ClientServiceHandler> connector(sa, reactor);
 	ClientServiceHandler::setOnce(true);
 	ClientServiceHandler::resetData();
@@ -353,7 +353,7 @@ void SocketReactorTest::testParallelSocketReactor()
 	ServerSocket ss(ssa);
 	SocketReactor reactor;
 	ParallelSocketAcceptor<EchoServiceHandler, SocketReactor> acceptor(ss, reactor);
-	SocketAddress sa("localhost", ss.address().port());
+	SocketAddress sa("127.0.0.1", ss.address().port());
 	SocketConnector<ClientServiceHandler> connector1(sa, reactor);
 	SocketConnector<ClientServiceHandler> connector2(sa, reactor);
 	SocketConnector<ClientServiceHandler> connector3(sa, reactor);
@@ -390,7 +390,7 @@ void SocketReactorTest::testSocketConnectorTimeout()
 	SocketAddress ssa;
 	ServerSocket ss(ssa);
 	SocketReactor reactor;
-	SocketAddress sa("localhost", ss.address().port());
+	SocketAddress sa("127.0.0.1", ss.address().port());
 	SocketConnector<ClientServiceHandler> connector(sa, reactor);
 	reactor.run();
 	assert (ClientServiceHandler::timeout());

Net/testsuite/src/SocketStreamTest.cpp

@@ -49,7 +49,7 @@ void SocketStreamTest::testStreamEcho()
 {
 	EchoServer echoServer;
 	StreamSocket ss;
-	ss.connect(SocketAddress("localhost", echoServer.port()));
+	ss.connect(SocketAddress("127.0.0.1", echoServer.port()));
 	SocketStream str(ss);
 	str << "hello";
 	assert (str.good());
@@ -72,7 +72,7 @@ void SocketStreamTest::testLargeStreamEcho()
 	const int msgSize = 64000;
 	EchoServer echoServer;
 	StreamSocket ss;
-	ss.connect(SocketAddress("localhost", echoServer.port()));
+	ss.connect(SocketAddress("127.0.0.1", echoServer.port()));
 	SocketStream str(ss);
 	ss.setSendBufferSize(msgSize);
 	ss.setReceiveBufferSize(msgSize);
@@ -100,7 +100,7 @@ void SocketStreamTest::testEOF()
 	{
 		EchoServer echoServer;
 
-		ss.connect(SocketAddress("localhost", echoServer.port()));
+		ss.connect(SocketAddress("127.0.0.1", echoServer.port()));
 		str << "hello";
 		assert (str.good());
 		str.flush();

Net/testsuite/src/SocketTest.cpp

@@ -55,7 +55,7 @@ void SocketTest::testEcho()
 {
 	EchoServer echoServer;
 	StreamSocket ss;
-	ss.connect(SocketAddress("localhost", echoServer.port()));
+	ss.connect(SocketAddress("127.0.0.1", echoServer.port()));
 	int n = ss.sendBytes("hello", 5);
 	assert (n == 5);
 	char buffer[256];
@@ -70,7 +70,7 @@ void SocketTest::testPoll()
 {
 	EchoServer echoServer;
 	StreamSocket ss;
-	ss.connect(SocketAddress("localhost", echoServer.port()));
+	ss.connect(SocketAddress("127.0.0.1", echoServer.port()));
 	Stopwatch sw;
 	sw.start();
 	Timespan timeout(1000000);
@@ -95,7 +95,7 @@ void SocketTest::testAvailable()
 {
 	EchoServer echoServer;
 	StreamSocket ss;
-	ss.connect(SocketAddress("localhost", echoServer.port()));
+	ss.connect(SocketAddress("127.0.0.1", echoServer.port()));
 	Timespan timeout(1000000);
 	ss.sendBytes("hello", 5);
 	char buffer[256];
@@ -135,7 +135,7 @@ void SocketTest::testFIFOBuffer()
 
 	EchoServer echoServer;
 	StreamSocket ss;
-	ss.connect(SocketAddress("localhost", echoServer.port()));
+	ss.connect(SocketAddress("127.0.0.1", echoServer.port()));
 	int n = ss.sendBytes(f);
 	assert (n == 5);
 	assert(1 == _notToReadable);
@@ -172,7 +172,7 @@ void SocketTest::testConnect()
 	serv.listen();
 	StreamSocket ss;
 	Timespan timeout(250000);
-	ss.connect(SocketAddress("localhost", serv.address().port()), timeout);
+	ss.connect(SocketAddress("127.0.0.1", serv.address().port()), timeout);
 }
 
 
@@ -187,7 +187,7 @@ void SocketTest::testConnectRefused()
 	Timespan timeout(250000);
 	try
 	{
-		ss.connect(SocketAddress("localhost", port));
+		ss.connect(SocketAddress("127.0.0.1", port));
 		fail("connection refused - must throw");
 	}
 	catch (ConnectionRefusedException&)
@@ -207,7 +207,7 @@ void SocketTest::testConnectRefusedNB()
 	Timespan timeout(2, 0);
 	try
 	{
-		ss.connect(SocketAddress("localhost", port), timeout);
+		ss.connect(SocketAddress("127.0.0.1", port), timeout);
 		fail("connection refused - must throw");
 	}
 	catch (TimeoutException&)
@@ -223,7 +223,7 @@ void SocketTest::testNonBlocking()
 {
 	EchoServer echoServer;
 	StreamSocket ss;
-	ss.connect(SocketAddress("localhost", echoServer.port()));
+	ss.connect(SocketAddress("127.0.0.1", echoServer.port()));
 	ss.setBlocking(false);
 
 	Timespan timeout(1000000);
@@ -247,7 +247,7 @@ void SocketTest::testAddress()
 	serv.bind(SocketAddress());
 	serv.listen();
 	StreamSocket ss;
-	ss.connect(SocketAddress("localhost", serv.address().port()));
+	ss.connect(SocketAddress("127.0.0.1", serv.address().port()));
 	StreamSocket css = serv.acceptConnection();
 	assert (css.peerAddress().host() == ss.address().host());
 	assert (css.peerAddress().port() == ss.address().port());
@@ -309,7 +309,7 @@ void SocketTest::testTimeout()
 {
 	EchoServer echoServer;
 	StreamSocket ss;
-	ss.connect(SocketAddress("localhost", echoServer.port()));
+	ss.connect(SocketAddress("127.0.0.1", echoServer.port()));
 	
 	Timespan timeout0 = ss.getReceiveTimeout();
 	Timespan timeout(250000);
@@ -347,7 +347,7 @@ void SocketTest::testTimeout()
 void SocketTest::testBufferSize()
 {
 	EchoServer echoServer;
-	SocketAddress sa("localhost", 1234);
+	SocketAddress sa("127.0.0.1", 1234);
 	StreamSocket ss(sa.family());
 	
 	int osz = ss.getSendBufferSize();
@@ -371,7 +371,7 @@ void SocketTest::testOptions()
 {
 	EchoServer echoServer;
 	StreamSocket ss;
-	ss.connect(SocketAddress("localhost", echoServer.port()));
+	ss.connect(SocketAddress("127.0.0.1", echoServer.port()));
 
 	ss.setLinger(true, 20);
 	bool f;
@@ -405,7 +405,7 @@ void SocketTest::testSelect()
 
 	EchoServer echoServer;
 	StreamSocket ss;
-	ss.connect(SocketAddress("localhost", echoServer.port()));
+	ss.connect(SocketAddress("127.0.0.1", echoServer.port()));
 
 	Socket::SocketList readList;
 	Socket::SocketList writeList;
@@ -442,8 +442,8 @@ void SocketTest::testSelect2()
 
 	EchoServer echoServer1;
 	EchoServer echoServer2;
-	StreamSocket ss1(SocketAddress("localhost", echoServer1.port()));
+	StreamSocket ss1(SocketAddress("127.0.0.1", echoServer1.port()));
-	StreamSocket ss2(SocketAddress("localhost", echoServer2.port()));
+	StreamSocket ss2(SocketAddress("127.0.0.1", echoServer2.port()));
 	
 	Socket::SocketList readList;
 	Socket::SocketList writeList;

Net/testsuite/src/SyslogTest.cpp

@@ -125,7 +125,7 @@ SyslogTest::~SyslogTest()
 void SyslogTest::testListener()
 {
 	Poco::AutoPtr<RemoteSyslogChannel> channel = new RemoteSyslogChannel();
-	channel->setProperty("loghost", "localhost:51400");
+	channel->setProperty("loghost", "127.0.0.1:51400");
 	channel->open();
 	Poco::AutoPtr<RemoteSyslogListener> listener = new RemoteSyslogListener(51400);
 	listener->open();
@@ -150,7 +150,7 @@ void SyslogTest::testListener()
 void SyslogTest::testChannelOpenClose()
 {
 	Poco::AutoPtr<RemoteSyslogChannel> channel = new RemoteSyslogChannel();
-	channel->setProperty("loghost", "localhost:51400");
+	channel->setProperty("loghost", "127.0.0.1:51400");
 	channel->open();
 	Poco::AutoPtr<RemoteSyslogListener> listener = new RemoteSyslogListener(51400);
 	listener->open();
@@ -189,7 +189,7 @@ void SyslogTest::testChannelOpenClose()
 void SyslogTest::testOldBSD()
 {
 	Poco::AutoPtr<RemoteSyslogChannel> channel = new RemoteSyslogChannel();
-	channel->setProperty("loghost", "localhost:51400");
+	channel->setProperty("loghost", "127.0.0.1:51400");
 	channel->setProperty("format", "bsd");
 	channel->open();
 	Poco::AutoPtr<RemoteSyslogListener> listener = new RemoteSyslogListener(51400);

Net/testsuite/src/TCPServerTest.cpp

@@ -24,6 +24,7 @@
 
 
 using Poco::Net::TCPServer;
+using Poco::Net::TCPServerConnectionFilter;
 using Poco::Net::TCPServerConnection;
 using Poco::Net::TCPServerConnectionFactory;
 using Poco::Net::TCPServerConnectionFactoryImpl;
@@ -62,6 +63,15 @@ namespace
 			}
 		}
 	};
+	
+	class RejectFilter: public TCPServerConnectionFilter
+	{
+	public:
+		bool accept(const StreamSocket&)
+		{
+			return false;
+		}
+	};
 }
 
 
@@ -84,7 +94,7 @@ void TCPServerTest::testOneConnection()
 	assert (srv.queuedConnections() == 0);
 	assert (srv.totalConnections() == 0);
 	
-	SocketAddress sa("localhost", srv.socket().address().port());
+	SocketAddress sa("127.0.0.1", srv.socket().address().port());
 	StreamSocket ss1(sa);
 	std::string data("hello, world");
 	ss1.sendBytes(data.data(), (int) data.size());
@@ -111,7 +121,7 @@ void TCPServerTest::testTwoConnections()
 	assert (srv.queuedConnections() == 0);
 	assert (srv.totalConnections() == 0);
 	
-	SocketAddress sa("localhost", srv.socket().address().port());
+	SocketAddress sa("127.0.0.1", srv.socket().address().port());
 	StreamSocket ss1(sa);
 	StreamSocket ss2(sa);
 	std::string data("hello, world");
@@ -159,7 +169,7 @@ void TCPServerTest::testMultiConnections()
 	assert (srv.queuedConnections() == 0);
 	assert (srv.totalConnections() == 0);
 	
-	SocketAddress sa("localhost", svs.address().port());
+	SocketAddress sa("127.0.0.1", svs.address().port());
 	StreamSocket ss1(sa);
 	StreamSocket ss2(sa);
 	StreamSocket ss3(sa);
@@ -233,7 +243,9 @@ void TCPServerTest::testMultiConnections()
 	assert (srv.currentConnections() == 0);
 }
 
-void TCPServerTest::testThreadCapacity(){
+
+void TCPServerTest::testThreadCapacity()
+{
 	ServerSocket svs(0);
 	TCPServerParams* pParams = new TCPServerParams;
 	pParams->setMaxThreads(64);
@@ -243,6 +255,29 @@ void TCPServerTest::testThreadCapacity(){
 }
 
 
+void TCPServerTest::testFilter()
+{
+	TCPServer srv(new TCPServerConnectionFactoryImpl<EchoConnection>());
+	srv.setConnectionFilter(new RejectFilter);
+	srv.start();
+	assert (srv.currentConnections() == 0);
+	assert (srv.currentThreads() == 0);
+	assert (srv.queuedConnections() == 0);
+	assert (srv.totalConnections() == 0);
+	
+	SocketAddress sa("127.0.0.1", srv.socket().address().port());
+	StreamSocket ss(sa);
+
+	char buffer[256];
+	int n = ss.receiveBytes(buffer, sizeof(buffer));
+
+	assert (n == 0);
+	assert (srv.currentConnections() == 0);
+	assert (srv.currentThreads() == 0);
+	assert (srv.queuedConnections() == 0);
+	assert (srv.totalConnections() == 0);
+}
+
 
 void TCPServerTest::setUp()
 {
@@ -262,6 +297,7 @@ CppUnit::Test* TCPServerTest::suite()
 	CppUnit_addTest(pSuite, TCPServerTest, testTwoConnections);
 	CppUnit_addTest(pSuite, TCPServerTest, testMultiConnections);
 	CppUnit_addTest(pSuite, TCPServerTest, testThreadCapacity);
+	CppUnit_addTest(pSuite, TCPServerTest, testFilter);
 
 	return pSuite;
 }

Net/testsuite/src/TCPServerTest.h

@@ -30,6 +30,7 @@ public:
 	void testTwoConnections();
 	void testMultiConnections();
 	void testThreadCapacity();
+	void testFilter();
 
 	void setUp();
 	void tearDown();

Net/testsuite/src/WebSocketTest.cpp

@@ -119,7 +119,7 @@ void WebSocketTest::testWebSocket()
 	
 	Poco::Thread::sleep(200);
 	
-	HTTPClientSession cs("localhost", ss.address().port());
+	HTTPClientSession cs("127.0.0.1", ss.address().port());
 	HTTPRequest request(HTTPRequest::HTTP_GET, "/ws", HTTPRequest::HTTP_1_1);
 	HTTPResponse response;
 	WebSocket ws(cs, request, response);
@@ -200,7 +200,7 @@ void WebSocketTest::testWebSocketLarge()
 	
 	Poco::Thread::sleep(200);
 	
-	HTTPClientSession cs("localhost", ss.address().port());
+	HTTPClientSession cs("127.0.0.1", ss.address().port());
 	HTTPRequest request(HTTPRequest::HTTP_GET, "/ws", HTTPRequest::HTTP_1_1);
 	HTTPResponse response;
 	WebSocket ws(cs, request, response);
@@ -232,7 +232,7 @@ void WebSocketTest::testOneLargeFrame(int msgSize)
 
 	Poco::Thread::sleep(200);
 
-	HTTPClientSession cs("localhost", ss.address().port());
+	HTTPClientSession cs("127.0.0.1", ss.address().port());
 	HTTPRequest request(HTTPRequest::HTTP_GET, "/ws", HTTPRequest::HTTP_1_1);
 	HTTPResponse response;
 	WebSocket ws(cs, request, response);

NetSSL_OpenSSL/src/Context.cpp

@@ -494,6 +494,17 @@ void Context::initDH(const std::string& dhParamsFile)
 			std::string msg = Utility::getLastError();
 			throw SSLContextException("Error creating Diffie-Hellman parameters", msg);
 		}
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+		BIGNUM* p = BN_bin2bn(dh1024_p, sizeof(dh1024_p), 0);
+		BIGNUM* g = BN_bin2bn(dh1024_g, sizeof(dh1024_g), 0);
+		DH_set0_pqg(dh, p, 0, g);
+		DH_set_length(dh, 160);
+		if (!p || !g)
+		{
+			DH_free(dh);
+			throw SSLContextException("Error creating Diffie-Hellman parameters");
+		}
+#else
 		dh->p = BN_bin2bn(dh1024_p, sizeof(dh1024_p), 0);
 		dh->g = BN_bin2bn(dh1024_g, sizeof(dh1024_g), 0);
 		dh->length = 160;
@@ -502,6 +513,7 @@ void Context::initDH(const std::string& dhParamsFile)
 			DH_free(dh);
 			throw SSLContextException("Error creating Diffie-Hellman parameters");
 		}
+#endif
 	}
 	SSL_CTX_set_tmp_dh(_pSSLContext, dh);
 	SSL_CTX_set_options(_pSSLContext, SSL_OP_SINGLE_DH_USE);

NetSSL_OpenSSL/src/HTTPSStreamFactory.cpp

@@ -26,6 +26,8 @@
 #include "Poco/UnbufferedStreamBuf.h"
 #include "Poco/NullStream.h"
 #include "Poco/StreamCopier.h"
+#include "Poco/Format.h"
+#include "Poco/Version.h"
 
 
 using Poco::URIStreamFactory;
@@ -118,6 +120,12 @@ std::istream* HTTPSStreamFactory::open(const URI& uri)
 				cred.authenticate(req, res);
 			}
 
+			req.set("User-Agent", Poco::format("poco/%d.%d.%d", 
+				(POCO_VERSION >> 24) & 0xFF,
+				(POCO_VERSION >> 16) & 0xFF,
+				(POCO_VERSION >> 8) & 0xFF));
+			req.set("Accept", "*/*");
+
 			pSession->sendRequest(req);
 			std::istream& rs = pSession->receiveResponse(res);
 			bool moved = (res.getStatus() == HTTPResponse::HTTP_MOVED_PERMANENTLY || 

NetSSL_OpenSSL/testsuite/src/HTTPSClientSessionTest.cpp

@@ -93,7 +93,7 @@ HTTPSClientSessionTest::~HTTPSClientSessionTest()
 void HTTPSClientSessionTest::testGetSmall()
 {
 	HTTPSTestServer srv;
-	HTTPSClientSession s("localhost", srv.port());
+	HTTPSClientSession s("127.0.0.1", srv.port());
 	HTTPRequest request(HTTPRequest::HTTP_GET, "/small");
 	s.sendRequest(request);
 	HTTPResponse response;
@@ -109,7 +109,7 @@ void HTTPSClientSessionTest::testGetSmall()
 void HTTPSClientSessionTest::testGetLarge()
 {
 	HTTPSTestServer srv;
-	HTTPSClientSession s("localhost", srv.port());
+	HTTPSClientSession s("127.0.0.1", srv.port());
 	HTTPRequest request(HTTPRequest::HTTP_GET, "/large");
 	s.sendRequest(request);
 	HTTPResponse response;
@@ -125,7 +125,7 @@ void HTTPSClientSessionTest::testGetLarge()
 void HTTPSClientSessionTest::testHead()
 {
 	HTTPSTestServer srv;
-	HTTPSClientSession s("localhost", srv.port());
+	HTTPSClientSession s("127.0.0.1", srv.port());
 	HTTPRequest request(HTTPRequest::HTTP_HEAD, "/large");
 	s.sendRequest(request);
 	HTTPResponse response;
@@ -140,7 +140,7 @@ void HTTPSClientSessionTest::testHead()
 void HTTPSClientSessionTest::testPostSmallIdentity()
 {
 	HTTPSTestServer srv;
-	HTTPSClientSession s("localhost", srv.port());
+	HTTPSClientSession s("127.0.0.1", srv.port());
 	HTTPRequest request(HTTPRequest::HTTP_POST, "/echo");
 	std::string body("this is a random request body\r\n0\r\n");
 	request.setContentLength((int) body.length());
@@ -157,7 +157,7 @@ void HTTPSClientSessionTest::testPostSmallIdentity()
 void HTTPSClientSessionTest::testPostLargeIdentity()
 {
 	HTTPSTestServer srv;
-	HTTPSClientSession s("localhost", srv.port());
+	HTTPSClientSession s("127.0.0.1", srv.port());
 	HTTPRequest request(HTTPRequest::HTTP_POST, "/echo");
 	std::string body(8000, 'x');
 	body.append("\r\n0\r\n");
@@ -175,7 +175,7 @@ void HTTPSClientSessionTest::testPostLargeIdentity()
 void HTTPSClientSessionTest::testPostSmallChunked()
 {
 	HTTPSTestServer srv;
-	HTTPSClientSession s("localhost", srv.port());
+	HTTPSClientSession s("127.0.0.1", srv.port());
 	HTTPRequest request(HTTPRequest::HTTP_POST, "/echo");
 	std::string body("this is a random request body");
 	request.setChunkedTransferEncoding(true);
@@ -193,7 +193,7 @@ void HTTPSClientSessionTest::testPostSmallChunked()
 void HTTPSClientSessionTest::testPostLargeChunked()
 {
 	HTTPSTestServer srv;
-	HTTPSClientSession s("localhost", srv.port());
+	HTTPSClientSession s("127.0.0.1", srv.port());
 	HTTPRequest request(HTTPRequest::HTTP_POST, "/echo");
 	std::string body(16000, 'x');
 	request.setChunkedTransferEncoding(true);
@@ -215,7 +215,7 @@ void HTTPSClientSessionTest::testPostLargeChunkedKeepAlive()
 	srv.start();
 	try
 	{
-		HTTPSClientSession s("localhost", srv.port());
+		HTTPSClientSession s("127.0.0.1", srv.port());
 		s.setKeepAlive(true);
 		for (int i = 0; i < 10; ++i)
 		{
@@ -244,7 +244,7 @@ void HTTPSClientSessionTest::testPostLargeChunkedKeepAlive()
 void HTTPSClientSessionTest::testKeepAlive()
 {
 	HTTPSTestServer srv;
-	HTTPSClientSession s("localhost", srv.port());
+	HTTPSClientSession s("127.0.0.1", srv.port());
 	s.setKeepAlive(true);
 	HTTPRequest request(HTTPRequest::HTTP_HEAD, "/keepAlive", HTTPMessage::HTTP_1_1);
 	s.sendRequest(request);
@@ -359,7 +359,7 @@ void HTTPSClientSessionTest::testCachedSession()
 		"ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
 	pClientContext->enableSessionCache(true);
 
-	HTTPSClientSession s1("localhost", srv.port(), pClientContext);
+	HTTPSClientSession s1("127.0.0.1", srv.port(), pClientContext);
 	HTTPRequest request1(HTTPRequest::HTTP_GET, "/small");
 	s1.sendRequest(request1);
 	Session::Ptr pSession1 = s1.sslSession();
@@ -371,7 +371,7 @@ void HTTPSClientSessionTest::testCachedSession()
 	StreamCopier::copyStream(rs1, ostr1);
 	assert (ostr1.str() == HTTPSTestServer::SMALL_BODY);
 
-	HTTPSClientSession s2("localhost", srv.port(), pClientContext, pSession1);
+	HTTPSClientSession s2("127.0.0.1", srv.port(), pClientContext, pSession1);
 	HTTPRequest request2(HTTPRequest::HTTP_GET, "/small");
 	s2.sendRequest(request2);
 	Session::Ptr pSession2 = s2.sslSession();
@@ -419,7 +419,7 @@ void HTTPSClientSessionTest::testCachedSession()
 void HTTPSClientSessionTest::testUnknownContentLength()
 {
 	HTTPSTestServer srv;
-	HTTPSClientSession s("localhost", srv.port());
+	HTTPSClientSession s("127.0.0.1", srv.port());
 	HTTPRequest request(HTTPRequest::HTTP_GET, "/nolength");
 	s.sendRequest(request);
 	HTTPResponse response;
@@ -435,7 +435,7 @@ void HTTPSClientSessionTest::testUnknownContentLength()
 void HTTPSClientSessionTest::testServerAbort()
 {
 	HTTPSTestServer srv;
-	HTTPSClientSession s("localhost", srv.port());
+	HTTPSClientSession s("127.0.0.1", srv.port());
 	HTTPRequest request(HTTPRequest::HTTP_GET, "/nolength/connection/abort");
 	s.sendRequest(request);
 	HTTPResponse response;

NetSSL_OpenSSL/testsuite/src/HTTPSServerTest.cpp

@@ -133,7 +133,7 @@ void HTTPSServerTest::testIdentityRequest()
 	HTTPServer srv(new RequestHandlerFactory, svs, pParams);
 	srv.start();
 	
-	HTTPSClientSession cs("localhost", svs.address().port());
+	HTTPSClientSession cs("127.0.0.1", svs.address().port());
 	std::string body(5000, 'x');
 	HTTPRequest request("POST", "/echoBody");
 	request.setContentLength((int) body.length());
@@ -156,7 +156,7 @@ void HTTPSServerTest::testChunkedRequest()
 	HTTPServer srv(new RequestHandlerFactory, svs, pParams);
 	srv.start();
 	
-	HTTPSClientSession cs("localhost", svs.address().port());
+	HTTPSClientSession cs("127.0.0.1", svs.address().port());
 	std::string body(5000, 'x');
 	HTTPRequest request("POST", "/echoBody");
 	request.setContentType("text/plain");
@@ -180,7 +180,7 @@ void HTTPSServerTest::testIdentityRequestKeepAlive()
 	HTTPServer srv(new RequestHandlerFactory, svs, pParams);
 	srv.start();
 	
-	HTTPSClientSession cs("localhost", svs.address().port());
+	HTTPSClientSession cs("127.0.0.1", svs.address().port());
 	cs.setKeepAlive(true);
 	std::string body(5000, 'x');
 	HTTPRequest request("POST", "/echoBody", HTTPMessage::HTTP_1_1);
@@ -214,7 +214,7 @@ void HTTPSServerTest::testChunkedRequestKeepAlive()
 	HTTPServer srv(new RequestHandlerFactory, svs, pParams);
 	srv.start();
 	
-	HTTPSClientSession cs("localhost", svs.address().port());
+	HTTPSClientSession cs("127.0.0.1", svs.address().port());
 	cs.setKeepAlive(true);
 	std::string body(5000, 'x');
 	HTTPRequest request("POST", "/echoBody", HTTPMessage::HTTP_1_1);
@@ -249,7 +249,7 @@ void HTTPSServerTest::test100Continue()
 	HTTPServer srv(new RequestHandlerFactory, svs, pParams);
 	srv.start();
 	
-	HTTPSClientSession cs("localhost", svs.address().port());
+	HTTPSClientSession cs("127.0.0.1", svs.address().port());
 	std::string body(5000, 'x');
 	HTTPRequest request("POST", "/echoBody");
 	request.setContentLength((int) body.length());
@@ -273,7 +273,7 @@ void HTTPSServerTest::testRedirect()
 	HTTPServer srv(new RequestHandlerFactory, svs, pParams);
 	srv.start();
 	
-	HTTPSClientSession cs("localhost", svs.address().port());
+	HTTPSClientSession cs("127.0.0.1", svs.address().port());
 	HTTPRequest request("GET", "/redirect");
 	cs.sendRequest(request);
 	HTTPResponse response;
@@ -293,7 +293,7 @@ void HTTPSServerTest::testAuth()
 	HTTPServer srv(new RequestHandlerFactory, svs, pParams);
 	srv.start();
 	
-	HTTPSClientSession cs("localhost", svs.address().port());
+	HTTPSClientSession cs("127.0.0.1", svs.address().port());
 	HTTPRequest request("GET", "/auth");
 	cs.sendRequest(request);
 	HTTPResponse response;
@@ -313,7 +313,7 @@ void HTTPSServerTest::testNotImpl()
 	HTTPServer srv(new RequestHandlerFactory, svs, pParams);
 	srv.start();
 	
-	HTTPSClientSession cs("localhost", svs.address().port());
+	HTTPSClientSession cs("127.0.0.1", svs.address().port());
 	HTTPRequest request("GET", "/notImpl");
 	cs.sendRequest(request);
 	HTTPResponse response;

NetSSL_OpenSSL/testsuite/src/HTTPSStreamFactoryTest.cpp

@@ -48,7 +48,7 @@ void HTTPSStreamFactoryTest::testNoRedirect()
 {
 	HTTPSTestServer server;
 	HTTPSStreamFactory factory;
-	URI uri("https://localhost/large");
+	URI uri("https://127.0.0.1/large");
 	uri.setPort(server.port());
 	std::auto_ptr<std::istream> pStr(factory.open(uri));
 	std::ostringstream ostr;
@@ -61,7 +61,7 @@ void HTTPSStreamFactoryTest::testEmptyPath()
 {
 	HTTPSTestServer server;
 	HTTPSStreamFactory factory;
-	URI uri("https://localhost");
+	URI uri("https://127.0.0.1");
 	uri.setPort(server.port());
 	std::auto_ptr<std::istream> pStr(factory.open(uri));
 	std::ostringstream ostr;
@@ -74,7 +74,7 @@ void HTTPSStreamFactoryTest::testRedirect()
 {
 	HTTPSTestServer server;
 	HTTPSStreamFactory factory;
-	URI uri("https://localhost/redirect");
+	URI uri("https://127.0.0.1/redirect");
 	uri.setPort(server.port());
 	std::auto_ptr<std::istream> pStr(factory.open(uri));
 	std::ostringstream ostr;
@@ -103,7 +103,7 @@ void HTTPSStreamFactoryTest::testError()
 {
 	HTTPSTestServer server;
 	HTTPSStreamFactory factory;
-	URI uri("https://localhost/notfound");
+	URI uri("https://127.0.0.1/notfound");
 	uri.setPort(server.port());
 	try
 	{

NetSSL_OpenSSL/testsuite/src/TCPServerTest.cpp

@@ -95,7 +95,7 @@ void TCPServerTest::testOneConnection()
 	assert (srv.queuedConnections() == 0);
 	assert (srv.totalConnections() == 0);
 	
-	SocketAddress sa("localhost", svs.address().port());
+	SocketAddress sa("127.0.0.1", svs.address().port());
 	SecureStreamSocket ss1(sa);
 	std::string data("hello, world");
 	ss1.sendBytes(data.data(), (int) data.size());
@@ -123,7 +123,7 @@ void TCPServerTest::testTwoConnections()
 	assert (srv.queuedConnections() == 0);
 	assert (srv.totalConnections() == 0);
 	
-	SocketAddress sa("localhost", svs.address().port());
+	SocketAddress sa("127.0.0.1", svs.address().port());
 	SecureStreamSocket ss1(sa);
 	SecureStreamSocket ss2(sa);
 	std::string data("hello, world");
@@ -170,7 +170,7 @@ void TCPServerTest::testMultiConnections()
 	assert (srv.queuedConnections() == 0);
 	assert (srv.totalConnections() == 0);
 	
-	SocketAddress sa("localhost", svs.address().port());
+	SocketAddress sa("127.0.0.1", svs.address().port());
 	SecureStreamSocket ss1(sa);
 	SecureStreamSocket ss2(sa);
 	SecureStreamSocket ss3(sa);
@@ -259,7 +259,7 @@ void TCPServerTest::testReuseSocket()
 	assert (srv.queuedConnections() == 0);
 	assert (srv.totalConnections() == 0);
 	
-	SocketAddress sa("localhost", svs.address().port());
+	SocketAddress sa("127.0.0.1", svs.address().port());
 	SecureStreamSocket ss1(sa);
 	std::string data("hello, world");
 	ss1.sendBytes(data.data(), (int) data.size());
@@ -328,7 +328,7 @@ void TCPServerTest::testReuseSession()
 		"ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
 	pClientContext->enableSessionCache(true);
 	
-	SocketAddress sa("localhost", svs.address().port());
+	SocketAddress sa("127.0.0.1", svs.address().port());
 	SecureStreamSocket ss1(sa, pClientContext);
 	assert (!ss1.sessionWasReused());
 	std::string data("hello, world");

NetSSL_OpenSSL/testsuite/src/WebSocketTest.cpp

@@ -119,7 +119,7 @@ void WebSocketTest::testWebSocket()
 	
 	Poco::Thread::sleep(200);
 	
-	HTTPSClientSession cs("localhost", ss.address().port());
+	HTTPSClientSession cs("127.0.0.1", ss.address().port());
 	HTTPRequest request(HTTPRequest::HTTP_GET, "/ws");
 	HTTPResponse response;
 	WebSocket ws(cs, request, response);
@@ -186,7 +186,7 @@ void WebSocketTest::testWebSocketLarge()
 	
 	Poco::Thread::sleep(200);
 	
-	HTTPSClientSession cs("localhost", ss.address().port());
+	HTTPSClientSession cs("127.0.0.1", ss.address().port());
 	HTTPRequest request(HTTPRequest::HTTP_GET, "/ws");
 	HTTPResponse response;
 	WebSocket ws(cs, request, response);

NetSSL_Win/testsuite/src/HTTPSClientSessionTest.cpp

@@ -92,7 +92,7 @@ HTTPSClientSessionTest::~HTTPSClientSessionTest()
 void HTTPSClientSessionTest::testGetSmall()
 {
 	HTTPSTestServer srv;
-	HTTPSClientSession s("localhost", srv.port());
+	HTTPSClientSession s("127.0.0.1", srv.port());
 	HTTPRequest request(HTTPRequest::HTTP_GET, "/small");
 	s.sendRequest(request);
 	HTTPResponse response;
@@ -108,7 +108,7 @@ void HTTPSClientSessionTest::testGetSmall()
 void HTTPSClientSessionTest::testGetLarge()
 {
 	HTTPSTestServer srv;
-	HTTPSClientSession s("localhost", srv.port());
+	HTTPSClientSession s("127.0.0.1", srv.port());
 	HTTPRequest request(HTTPRequest::HTTP_GET, "/large");
 	s.sendRequest(request);
 	HTTPResponse response;
@@ -124,7 +124,7 @@ void HTTPSClientSessionTest::testGetLarge()
 void HTTPSClientSessionTest::testHead()
 {
 	HTTPSTestServer srv;
-	HTTPSClientSession s("localhost", srv.port());
+	HTTPSClientSession s("127.0.0.1", srv.port());
 	HTTPRequest request(HTTPRequest::HTTP_HEAD, "/large");
 	s.sendRequest(request);
 	HTTPResponse response;
@@ -139,7 +139,7 @@ void HTTPSClientSessionTest::testHead()
 void HTTPSClientSessionTest::testPostSmallIdentity()
 {
 	HTTPSTestServer srv;
-	HTTPSClientSession s("localhost", srv.port());
+	HTTPSClientSession s("127.0.0.1", srv.port());
 	HTTPRequest request(HTTPRequest::HTTP_POST, "/echo");
 	std::string body("this is a random request body\r\n0\r\n");
 	request.setContentLength((int) body.length());
@@ -156,7 +156,7 @@ void HTTPSClientSessionTest::testPostSmallIdentity()
 void HTTPSClientSessionTest::testPostLargeIdentity()
 {
 	HTTPSTestServer srv;
-	HTTPSClientSession s("localhost", srv.port());
+	HTTPSClientSession s("127.0.0.1", srv.port());
 	HTTPRequest request(HTTPRequest::HTTP_POST, "/echo");
 	std::string body(8000, 'x');
 	body.append("\r\n0\r\n");
@@ -174,7 +174,7 @@ void HTTPSClientSessionTest::testPostLargeIdentity()
 void HTTPSClientSessionTest::testPostSmallChunked()
 {
 	HTTPSTestServer srv;
-	HTTPSClientSession s("localhost", srv.port());
+	HTTPSClientSession s("127.0.0.1", srv.port());
 	HTTPRequest request(HTTPRequest::HTTP_POST, "/echo");
 	std::string body("this is a random request body");
 	request.setChunkedTransferEncoding(true);
@@ -192,7 +192,7 @@ void HTTPSClientSessionTest::testPostSmallChunked()
 void HTTPSClientSessionTest::testPostLargeChunked()
 {
 	HTTPSTestServer srv;
-	HTTPSClientSession s("localhost", srv.port());
+	HTTPSClientSession s("127.0.0.1", srv.port());
 	HTTPRequest request(HTTPRequest::HTTP_POST, "/echo");
 	std::string body(16000, 'x');
 	request.setChunkedTransferEncoding(true);
@@ -214,7 +214,7 @@ void HTTPSClientSessionTest::testPostLargeChunkedKeepAlive()
 	srv.start();
 	try
 	{
-		HTTPSClientSession s("localhost", srv.port());
+		HTTPSClientSession s("127.0.0.1", srv.port());
 		s.setKeepAlive(true);
 		for (int i = 0; i < 10; ++i)
 		{
@@ -243,7 +243,7 @@ void HTTPSClientSessionTest::testPostLargeChunkedKeepAlive()
 void HTTPSClientSessionTest::testKeepAlive()
 {
 	HTTPSTestServer srv;
-	HTTPSClientSession s("localhost", srv.port());
+	HTTPSClientSession s("127.0.0.1", srv.port());
 	s.setKeepAlive(true);
 	HTTPRequest request(HTTPRequest::HTTP_HEAD, "/keepAlive", HTTPMessage::HTTP_1_1);
 	s.sendRequest(request);
@@ -359,7 +359,7 @@ void HTTPSClientSessionTest::testCachedSession()
 		"");
 	//pClientContext->enableSessionCache(true);
 
-	HTTPSClientSession s1("localhost", srv.port(), pClientContext);
+	HTTPSClientSession s1("127.0.0.1", srv.port(), pClientContext);
 	HTTPRequest request1(HTTPRequest::HTTP_GET, "/small");
 	s1.sendRequest(request1);
 	Session::Ptr pSession1 = s1.sslSession();
@@ -371,7 +371,7 @@ void HTTPSClientSessionTest::testCachedSession()
 	StreamCopier::copyStream(rs1, ostr1);
 	assert (ostr1.str() == HTTPSTestServer::SMALL_BODY);
 
-	HTTPSClientSession s2("localhost", srv.port(), pClientContext, pSession1);
+	HTTPSClientSession s2("127.0.0.1", srv.port(), pClientContext, pSession1);
 	HTTPRequest request2(HTTPRequest::HTTP_GET, "/small");
 	s2.sendRequest(request2);
 	Session::Ptr pSession2 = s2.sslSession();

NetSSL_Win/testsuite/src/HTTPSServerTest.cpp

@@ -134,7 +134,7 @@ void HTTPSServerTest::testIdentityRequest()
 	HTTPServer srv(new RequestHandlerFactory, svs, pParams);
 	srv.start();
 	
-	HTTPSClientSession cs("localhost", svs.address().port());
+	HTTPSClientSession cs("127.0.0.1", svs.address().port());
 	std::string body(5000, 'x');
 	HTTPRequest request("POST", "/echoBody");
 	request.setContentLength((int) body.length());
@@ -157,7 +157,7 @@ void HTTPSServerTest::testChunkedRequest()
 	HTTPServer srv(new RequestHandlerFactory, svs, pParams);
 	srv.start();
 	
-	HTTPSClientSession cs("localhost", svs.address().port());
+	HTTPSClientSession cs("127.0.0.1", svs.address().port());
 	std::string body(5000, 'x');
 	HTTPRequest request("POST", "/echoBody");
 	request.setContentType("text/plain");
@@ -181,7 +181,7 @@ void HTTPSServerTest::testIdentityRequestKeepAlive()
 	HTTPServer srv(new RequestHandlerFactory, svs, pParams);
 	srv.start();
 	
-	HTTPSClientSession cs("localhost", svs.address().port());
+	HTTPSClientSession cs("127.0.0.1", svs.address().port());
 	cs.setKeepAlive(true);
 	std::string body(5000, 'x');
 	HTTPRequest request("POST", "/echoBody", HTTPMessage::HTTP_1_1);
@@ -216,7 +216,7 @@ void HTTPSServerTest::testChunkedRequestKeepAlive()
 	HTTPServer srv(new RequestHandlerFactory, svs, pParams);
 	srv.start();
 	
-	HTTPSClientSession cs("localhost", svs.address().port());
+	HTTPSClientSession cs("127.0.0.1", svs.address().port());
 	cs.setKeepAlive(true);
 	std::string body(5000, 'x');
 	HTTPRequest request("POST", "/echoBody", HTTPMessage::HTTP_1_1);
@@ -251,7 +251,7 @@ void HTTPSServerTest::test100Continue()
 	HTTPServer srv(new RequestHandlerFactory, svs, pParams);
 	srv.start();
 	
-	HTTPSClientSession cs("localhost", svs.address().port());
+	HTTPSClientSession cs("127.0.0.1", svs.address().port());
 	std::string body(5000, 'x');
 	HTTPRequest request("POST", "/echoBody");
 	request.setContentLength((int) body.length());
@@ -275,7 +275,7 @@ void HTTPSServerTest::testRedirect()
 	HTTPServer srv(new RequestHandlerFactory, svs, pParams);
 	srv.start();
 	
-	HTTPSClientSession cs("localhost", svs.address().port());
+	HTTPSClientSession cs("127.0.0.1", svs.address().port());
 	HTTPRequest request("GET", "/redirect");
 	cs.sendRequest(request);
 	HTTPResponse response;
@@ -295,7 +295,7 @@ void HTTPSServerTest::testAuth()
 	HTTPServer srv(new RequestHandlerFactory, svs, pParams);
 	srv.start();
 	
-	HTTPSClientSession cs("localhost", svs.address().port());
+	HTTPSClientSession cs("127.0.0.1", svs.address().port());
 	HTTPRequest request("GET", "/auth");
 	cs.sendRequest(request);
 	HTTPResponse response;
@@ -315,7 +315,7 @@ void HTTPSServerTest::testNotImpl()
 	HTTPServer srv(new RequestHandlerFactory, svs, pParams);
 	srv.start();
 	
-	HTTPSClientSession cs("localhost", svs.address().port());
+	HTTPSClientSession cs("127.0.0.1", svs.address().port());
 	HTTPRequest request("GET", "/notImpl");
 	cs.sendRequest(request);
 	HTTPResponse response;

NetSSL_Win/testsuite/src/HTTPSStreamFactoryTest.cpp

@@ -48,7 +48,7 @@ void HTTPSStreamFactoryTest::testNoRedirect()
 {
 	HTTPSTestServer server;
 	HTTPSStreamFactory factory;
-	URI uri("https://localhost/large");
+	URI uri("https://127.0.0.1/large");
 	uri.setPort(server.port());
 	std::auto_ptr<std::istream> pStr(factory.open(uri));
 	std::ostringstream ostr;
@@ -61,7 +61,7 @@ void HTTPSStreamFactoryTest::testEmptyPath()
 {
 	HTTPSTestServer server;
 	HTTPSStreamFactory factory;
-	URI uri("https://localhost");
+	URI uri("https://127.0.0.1");
 	uri.setPort(server.port());
 	std::auto_ptr<std::istream> pStr(factory.open(uri));
 	std::ostringstream ostr;
@@ -74,7 +74,7 @@ void HTTPSStreamFactoryTest::testRedirect()
 {
 	HTTPSTestServer server;
 	HTTPSStreamFactory factory;
-	URI uri("https://localhost/redirect");
+	URI uri("https://127.0.0.1/redirect");
 	uri.setPort(server.port());
 	std::auto_ptr<std::istream> pStr(factory.open(uri));
 	std::ostringstream ostr;
@@ -107,7 +107,7 @@ void HTTPSStreamFactoryTest::testError()
 {
 	HTTPSTestServer server;
 	HTTPSStreamFactory factory;
-	URI uri("https://localhost/notfound");
+	URI uri("https://127.0.0.1/notfound");
 	uri.setPort(server.port());
 	try
 	{

NetSSL_Win/testsuite/src/TCPServerTest.cpp

@@ -95,7 +95,7 @@ void TCPServerTest::testOneConnection()
 	assert (srv.queuedConnections() == 0);
 	assert (srv.totalConnections() == 0);
 	
-	SocketAddress sa("localhost", svs.address().port());
+	SocketAddress sa("127.0.0.1", svs.address().port());
 	SecureStreamSocket ss1(sa);
 	std::string data("hello, world");
 	ss1.sendBytes(data.data(), (int) data.size());
@@ -123,7 +123,7 @@ void TCPServerTest::testTwoConnections()
 	assert (srv.queuedConnections() == 0);
 	assert (srv.totalConnections() == 0);
 	
-	SocketAddress sa("localhost", svs.address().port());
+	SocketAddress sa("127.0.0.1", svs.address().port());
 	SecureStreamSocket ss1(sa);
 	SecureStreamSocket ss2(sa);
 	std::string data("hello, world");
@@ -170,7 +170,7 @@ void TCPServerTest::testMultiConnections()
 	assert (srv.queuedConnections() == 0);
 	assert (srv.totalConnections() == 0);
 	
-	SocketAddress sa("localhost", svs.address().port());
+	SocketAddress sa("127.0.0.1", svs.address().port());
 	SecureStreamSocket ss1(sa);
 	SecureStreamSocket ss2(sa);
 	SecureStreamSocket ss3(sa);
@@ -259,7 +259,7 @@ void TCPServerTest::testReuseSocket()
 	assert (srv.queuedConnections() == 0);
 	assert (srv.totalConnections() == 0);
 	
-	SocketAddress sa("localhost", svs.address().port());
+	SocketAddress sa("127.0.0.1", svs.address().port());
 	SecureStreamSocket ss1(sa);
 	std::string data("hello, world");
 	ss1.sendBytes(data.data(), (int) data.size());
@@ -316,7 +316,7 @@ void TCPServerTest::testReuseSession()
 		"");
 	//pClientContext->enableSessionCache(true);
 	
-	SocketAddress sa("localhost", svs.address().port());
+	SocketAddress sa("127.0.0.1", svs.address().port());
 	SecureStreamSocket ss1(sa, pClientContext);
 	assert (!ss1.sessionWasReused());
 	std::string data("hello, world");

NetSSL_Win/testsuite/src/WebSocketTest.cpp

@@ -121,7 +121,7 @@ void WebSocketTest::testWebSocket()
 	
 	Poco::Thread::sleep(200);
 	
-	HTTPSClientSession cs("localhost", ss.address().port());
+	HTTPSClientSession cs("127.0.0.1", ss.address().port());
 	HTTPRequest request(HTTPRequest::HTTP_GET, "/ws");
 	HTTPResponse response;
 	WebSocket ws(cs, request, response);
@@ -188,7 +188,7 @@ void WebSocketTest::testWebSocketLarge()
 	
 	Poco::Thread::sleep(200);
 	
-	HTTPSClientSession cs("localhost", ss.address().port());
+	HTTPSClientSession cs("127.0.0.1", ss.address().port());
 	HTTPRequest request(HTTPRequest::HTTP_GET, "/ws");
 	HTTPResponse response;
 	WebSocket ws(cs, request, response);

PageCompiler/src/PageCompiler.cpp

@@ -285,7 +285,11 @@ protected:
 			p.setBaseName(clazz);
 		}
 
+#if __cplusplus < 201103L
 		std::auto_ptr<CodeWriter> pCodeWriter(createCodeWriter(page, clazz));
+#else
+		std::unique_ptr<CodeWriter> pCodeWriter(createCodeWriter(page, clazz));
+#endif
 
 		if (!_outputDir.empty())
 		{

Redis/testsuite/src/RedisTest.cpp

@@ -31,7 +31,7 @@ Poco::Redis::Client RedisTest::_redis;
 
 RedisTest::RedisTest(const std::string& name):
 	CppUnit::TestCase("Redis"),
-	_host("localhost"),
+	_host("127.0.0.1"),
 	_port(6379)
 {
 	if (!_connected)