Update Poco to version 1.14.2

contrib/poco/CMakeLists.txt

@@ -1,16 +1,13 @@
-add_subdirectory (Foundation)
-add_subdirectory (Net)
+include(cmake/PocoMacros.cmake)
+
+add_subdirectory(Foundation)
+add_subdirectory(Util)
+add_subdirectory(Net)
 if (OS_LINUX OR OS_DARWIN)
-    add_subdirectory (Crypto)
-    add_subdirectory (NetSSL_OpenSSL)
-elseif (OS_WINDOWS)
-    if (MSVC)
-        if (TARGET Foundation)
-            set_property(TARGET Foundation APPEND PROPERTY INTERFACE_LINK_LIBRARIES Iphlpapi)
-        elseif (TARGET Poco::Foundation)
-            set_property(TARGET _poco_foundation APPEND PROPERTY INTERFACE_LINK_LIBRARIES Iphlpapi)
-        endif ()
-    endif ()
-    add_subdirectory (NetSSL_Win)
+    add_subdirectory(Crypto)
+    add_subdirectory(NetSSL_OpenSSL)
+    add_library(Poco::Net::SSL ALIAS NetSSL)
+else()
+    add_subdirectory(NetSSL_Win)
+    add_library(Poco::Net::WinSSL ALIAS NetSSLWin)
 endif()
-add_subdirectory (Util)

contrib/poco/Crypto/CMakeLists.txt

@@ -1,36 +1,17 @@
-if (ENABLE_SSL)
-    file (GLOB SRCS src/*.cpp)
+# Sources
+file(GLOB SRCS_G "src/*.cpp")
+POCO_SOURCES_AUTO(SRCS ${SRCS_G})
 
-    add_library (_poco_crypto ${SRCS})
-    add_library (Poco::Crypto ALIAS _poco_crypto)
-    if (NOT MSVC)
-        # TODO: remove these warning exclusions
-        target_compile_options (_poco_crypto
-            PRIVATE
-                -Wno-covered-switch-default
-                -Wno-deprecated-dynamic-exception-spec
-                -Wno-extra-semi-stmt
-                -Wno-missing-noreturn
-                -Wno-newline-eof
-                -Wno-old-style-cast
-                -Wno-shadow
-                -Wno-shorten-64-to-32
-                -Wno-sign-compare
-                -Wno-suggest-destructor-override
-                -Wno-suggest-override
-                -Wno-unreachable-code-return
-                -Wno-unused-parameter
-                -Wno-zero-as-null-pointer-constant
-                -Wno-used-but-marked-unused
-        )
-    endif()
-    target_include_directories (_poco_crypto SYSTEM PUBLIC "include")
-    target_link_libraries (_poco_crypto PUBLIC Poco::Foundation OpenSSL::SSL OpenSSL::Crypto)
+# Headers
+file(GLOB_RECURSE HDRS_G "include/*.h")
+POCO_HEADERS_AUTO(SRCS ${HDRS_G})
 
-    message (STATUS "Using Poco::Crypto")
-else ()
-    add_library (_poco_crypto INTERFACE)
-    add_library (Poco::Crypto ALIAS _poco_crypto)
+add_library(Crypto ${SRCS})
+set_target_properties(Crypto PROPERTIES CXX_STANDARD 17)
+add_library(Poco::Crypto ALIAS Crypto)
 
-    message (STATUS "Not using Poco::Crypto")
-endif ()
+target_link_libraries(Crypto PUBLIC Poco::Foundation OpenSSL::SSL OpenSSL::Crypto)
+target_include_directories(Crypto
+	PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include
+	PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
+)

contrib/poco/Crypto/include/Poco/Crypto/Cipher.h

@@ -18,124 +18,118 @@
 #define Crypto_Cipher_INCLUDED
 
 
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/Crypto/CryptoTransform.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/AutoPtr.h"
 #include <istream>
 #include <ostream>
 #include <vector>
-#include "Poco/AutoPtr.h"
-#include "Poco/Crypto/Crypto.h"
-#include "Poco/RefCountedObject.h"
 
 
-namespace Poco
-{
-namespace Crypto
+namespace Poco {
+namespace Crypto {
+
+
+class Crypto_API Cipher: public Poco::RefCountedObject
+	/// Represents the abstract base class from which all implementations of
+	/// symmetric/asymmetric encryption algorithms must inherit.  Use the CipherFactory
+	/// class to obtain an instance of this class:
+	///
+	///     CipherFactory& factory = CipherFactory::defaultFactory();
+	///     // Creates a 256-bit AES cipher
+	///     Cipher* pCipher = factory.createCipher(CipherKey("aes-256"));
+	///     Cipher* pRSACipher = factory.createCipher(RSAKey(RSAKey::KL_1024, RSAKey::EXP_SMALL));
+	///
+	/// Check the different Key constructors on how to initialize/create
+	/// a key. The above example auto-generates random keys.
+	///
+	/// Note that you won't be able to decrypt data encrypted with a random key
+	/// once the Cipher is destroyed unless you persist the generated key and IV.
+	/// An example usage for random keys is to encrypt data saved in a temporary
+	/// file.
+	///
+	/// Once your key is set up, you can use the Cipher object to encrypt or
+	/// decrypt strings or, in conjunction with a CryptoInputStream or a
+	/// CryptoOutputStream, to encrypt streams of data.
+	///
+	/// Since encrypted strings will contain arbitrary binary data that will cause
+	/// problems in applications that are not binary-safe (eg., when sending
+	/// encrypted data in e-mails), the encryptString() and decryptString() can
+	/// encode (or decode, respectively) encrypted data using a "transport encoding".
+	/// Supported encodings are Base64 and BinHex.
+	///
+	/// The following example encrypts and decrypts a string utilizing Base64
+	/// encoding:
+	///
+	///     std::string plainText = "This is my secret information";
+	///     std::string encrypted = pCipher->encryptString(plainText, Cipher::ENC_BASE64);
+	///     std::string decrypted = pCipher->decryptString(encrypted, Cipher::ENC_BASE64);
+	///
+	/// In order to encrypt a stream of data (eg. to encrypt files), you can use
+	/// a CryptoStream:
+	///
+	///     // Create an output stream that will encrypt all data going through it
+	///     // and write pass it to the underlying file stream.
+	///     Poco::FileOutputStream sink("encrypted.dat");
+	///     CryptoOutputStream encryptor(sink, pCipher->createEncryptor());
+	///
+	///     Poco::FileInputStream source("source.txt");
+	///     Poco::StreamCopier::copyStream(source, encryptor);
+	///
+	///     // Always close output streams to flush all internal buffers
+	///     encryptor.close();
+	///     sink.close();
 {
+public:
+	using Ptr = Poco::AutoPtr<Cipher>;
+	using ByteVec = std::vector<unsigned char>;
+
+	enum Encoding
+		/// Transport encoding to use for encryptString() and decryptString().
+	{
+		ENC_NONE         = 0x00, /// Plain binary output
+		ENC_BASE64       = 0x01, /// Base64-encoded output
+		ENC_BINHEX       = 0x02, /// BinHex-encoded output
+		ENC_BASE64_NO_LF = 0x81, /// Base64-encoded output, no linefeeds
+		ENC_BINHEX_NO_LF = 0x82  /// BinHex-encoded output, no linefeeds
+	};
+
+	virtual ~Cipher();
+		/// Destroys the Cipher.
+
+	virtual const std::string& name() const = 0;
+		/// Returns the name of the Cipher.
+
+	virtual CryptoTransform::Ptr createEncryptor() = 0;
+		/// Creates an encryptor object to be used with a CryptoStream.
+
+	virtual CryptoTransform::Ptr createDecryptor() = 0;
+		/// Creates a decryptor object to be used with a CryptoStream.
+
+	virtual std::string encryptString(const std::string& str, Encoding encoding = ENC_NONE, bool padding = true);
+		/// Directly encrypt a string and encode it using the given encoding.
+
+	virtual std::string decryptString(const std::string& str, Encoding encoding = ENC_NONE, bool padding = true);
+		/// Directly decrypt a string that is encoded with the given encoding.
+
+	virtual void encrypt(std::istream& source, std::ostream& sink, Encoding encoding = ENC_NONE, bool padding = true);
+		/// Directly encrypts an input stream and encodes it using the given encoding.
+
+	virtual void decrypt(std::istream& source, std::ostream& sink, Encoding encoding = ENC_NONE, bool padding = true);
+		/// Directly decrypt an input stream that is encoded with the given encoding.
+
+protected:
+	Cipher();
+		/// Creates a new Cipher object.
+
+private:
+	Cipher(const Cipher&);
+	Cipher& operator = (const Cipher&);
+};
 
 
-    class CryptoTransform;
-
-
-    class Crypto_API Cipher : public Poco::RefCountedObject
-    /// Represents the abstract base class from which all implementations of
-    /// symmetric/asymmetric encryption algorithms must inherit.  Use the CipherFactory
-    /// class to obtain an instance of this class:
-    ///
-    ///     CipherFactory& factory = CipherFactory::defaultFactory();
-    ///     // Creates a 256-bit AES cipher
-    ///     Cipher* pCipher = factory.createCipher(CipherKey("aes-256"));
-    ///     Cipher* pRSACipher = factory.createCipher(RSAKey(RSAKey::KL_1024, RSAKey::EXP_SMALL));
-    ///
-    /// Check the different Key constructors on how to initialize/create
-    /// a key. The above example auto-generates random keys.
-    ///
-    /// Note that you won't be able to decrypt data encrypted with a random key
-    /// once the Cipher is destroyed unless you persist the generated key and IV.
-    /// An example usage for random keys is to encrypt data saved in a temporary
-    /// file.
-    ///
-    /// Once your key is set up, you can use the Cipher object to encrypt or
-    /// decrypt strings or, in conjunction with a CryptoInputStream or a
-    /// CryptoOutputStream, to encrypt streams of data.
-    ///
-    /// Since encrypted strings will contain arbitrary binary data that will cause
-    /// problems in applications that are not binary-safe (eg., when sending
-    /// encrypted data in e-mails), the encryptString() and decryptString() can
-    /// encode (or decode, respectively) encrypted data using a "transport encoding".
-    /// Supported encodings are Base64 and BinHex.
-    ///
-    /// The following example encrypts and decrypts a string utilizing Base64
-    /// encoding:
-    ///
-    ///     std::string plainText = "This is my secret information";
-    ///     std::string encrypted = pCipher->encryptString(plainText, Cipher::ENC_BASE64);
-    ///     std::string decrypted = pCipher->decryptString(encrypted, Cipher::ENC_BASE64);
-    ///
-    /// In order to encrypt a stream of data (eg. to encrypt files), you can use
-    /// a CryptoStream:
-    ///
-    ///     // Create an output stream that will encrypt all data going through it
-    ///     // and write pass it to the underlying file stream.
-    ///     Poco::FileOutputStream sink("encrypted.dat");
-    ///     CryptoOutputStream encryptor(sink, pCipher->createEncryptor());
-    ///
-    ///     Poco::FileInputStream source("source.txt");
-    ///     Poco::StreamCopier::copyStream(source, encryptor);
-    ///
-    ///     // Always close output streams to flush all internal buffers
-    ///     encryptor.close();
-    ///     sink.close();
-    {
-    public:
-        typedef Poco::AutoPtr<Cipher> Ptr;
-        typedef std::vector<unsigned char> ByteVec;
-
-        enum Encoding
-        /// Transport encoding to use for encryptString() and decryptString().
-        {
-            ENC_NONE = 0x00, /// Plain binary output
-            ENC_BASE64 = 0x01, /// Base64-encoded output
-            ENC_BINHEX = 0x02, /// BinHex-encoded output
-            ENC_BASE64_NO_LF = 0x81, /// Base64-encoded output, no linefeeds
-            ENC_BINHEX_NO_LF = 0x82 /// BinHex-encoded output, no linefeeds
-
-        };
-
-        virtual ~Cipher();
-        /// Destroys the Cipher.
-
-        virtual const std::string & name() const = 0;
-        /// Returns the name of the Cipher.
-
-        virtual CryptoTransform * createEncryptor() = 0;
-        /// Creates an encryptor object to be used with a CryptoStream.
-
-        virtual CryptoTransform * createDecryptor() = 0;
-        /// Creates a decryptor object to be used with a CryptoStream.
-
-        virtual std::string encryptString(const std::string & str, Encoding encoding = ENC_NONE);
-        /// Directly encrypt a string and encode it using the given encoding.
-
-        virtual std::string decryptString(const std::string & str, Encoding encoding = ENC_NONE);
-        /// Directly decrypt a string that is encoded with the given encoding.
-
-        virtual void encrypt(std::istream & source, std::ostream & sink, Encoding encoding = ENC_NONE);
-        /// Directly encrypts an input stream and encodes it using the given encoding.
-
-        virtual void decrypt(std::istream & source, std::ostream & sink, Encoding encoding = ENC_NONE);
-        /// Directly decrypt an input stream that is encoded with the given encoding.
-
-    protected:
-        Cipher();
-        /// Creates a new Cipher object.
-
-    private:
-        Cipher(const Cipher &);
-        Cipher & operator=(const Cipher &);
-    };
-
-
-}
-} // namespace Poco::Crypto
+} } // namespace Poco::Crypto
 
 
 #endif // Crypto_Cipher_INCLUDED