Move poco to base/poco/ (#46075)

* Replicate poco into base/poco/

* De-register poco submodule

* Build poco from ClickHouse

* Exclude poco from stylecheck

* Exclude poco from whitespace check

* Exclude poco from typo check

* Remove x bit from sources/headers (the style check complained)

* Exclude poco from duplicate include check

* Fix fasttest

* Remove contrib/poco-cmake/*

* Simplify poco build descriptions

* Remove poco stuff not used by ClickHouse

* Glob poco sources

* Exclude poco from clang-tidy

.gitmodules

@@ -1,7 +1,3 @@
-[submodule "contrib/poco"]
-	path = contrib/poco
-	url = https://github.com/ClickHouse/poco
-	branch = clickhouse
 [submodule "contrib/zstd"]
 	path = contrib/zstd
 	url = https://github.com/facebook/zstd

base/CMakeLists.txt

@@ -1,8 +1,5 @@
-if (USE_CLANG_TIDY)
-    set (CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY_PATH}")
-endif ()
-
 add_subdirectory (base)
 add_subdirectory (pcg-random)
+add_subdirectory (poco)
 add_subdirectory (widechar_width)
 add_subdirectory (readpassphrase)

base/base/CMakeLists.txt

@@ -1,3 +1,7 @@
+if (USE_CLANG_TIDY)
+    set (CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY_PATH}")
+endif ()
+
 set (SRCS
     argsToConfig.cpp
     coverage.cpp

base/pcg-random/CMakeLists.txt

@@ -1,2 +1,6 @@
+if (USE_CLANG_TIDY)
+    set (CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY_PATH}")
+endif ()
+
 add_library(pcg_random INTERFACE)
 target_include_directories(pcg_random INTERFACE .)

base/poco/CMakeLists.txt

@@ -1,4 +1,5 @@
-set (LIBRARY_DIR "${ClickHouse_SOURCE_DIR}/contrib/poco")
+set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -w")
+set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -w")
 
 add_subdirectory (Crypto)
 add_subdirectory (Data)
@@ -7,7 +8,7 @@ add_subdirectory (Foundation)
 add_subdirectory (JSON)
 add_subdirectory (MongoDB)
 add_subdirectory (Net)
-add_subdirectory (Net/SSL)
+add_subdirectory (NetSSL_OpenSSL)
 add_subdirectory (Redis)
 add_subdirectory (Util)
 add_subdirectory (XML)

base/poco/CONTRIBUTORS

@@ -0,0 +1,52 @@
+Guenter Obiltschnig
+Alex Fabijanic
+Peter Schojer
+Ferdinand Beyer
+Krzysztof Burghardt
+Claus Dabringer
+Caleb Epstein
+Eran Hammer-Lahav
+Chris Johnson
+Sergey Kholodilov
+Ryan Kraay
+Larry Lewis
+Andrew J. P. Maclean
+Andrew Marlow
+Paschal Mushubi
+Jiang Shan
+David Shawley
+Sergey Skorokhodov
+Tom Tan
+Sergey N. Yatskevich
+Marc Chevrier
+Philippe Cuvillier
+Marian Krivos
+Franky Braem
+Philip Prindeville
+Anton Yabchinskiy
+Rangel Reale
+Fabrizio Duhem
+Patrick White
+Mike Naquin
+Roger Meier
+Mathaus Mendel
+Arturo Castro
+Adrian Imboden
+Matej Knopp
+Patrice Tarabbia
+Lucas Clemente
+Karl Reid
+Pascal Bach
+Cristian Thiago Moecke
+Sergei Nikulov
+Aaron Kaluszka
+Iyed Bennour
+Scott Davis
+Kristin Cowalcijk
+Yuval Kashtan
+Christopher Baker
+Scott Davis
+Jeff Adams
+Martin Osborne
+Björn Schramke
+Francis Andre

base/poco/Crypto/CMakeLists.txt

@@ -0,0 +1,17 @@
+if (ENABLE_SSL)
+    file (GLOB SRCS src/*.cpp)
+
+    add_library (_poco_crypto ${SRCS})
+    add_library (Poco::Crypto ALIAS _poco_crypto)
+
+    target_compile_options (_poco_crypto PRIVATE -Wno-newline-eof)
+    target_include_directories (_poco_crypto SYSTEM PUBLIC "include")
+    target_link_libraries (_poco_crypto PUBLIC Poco::Foundation OpenSSL::SSL OpenSSL::Crypto)
+
+    message (STATUS "Using Poco::Crypto")
+else ()
+    add_library (_poco_crypto INTERFACE)
+    add_library (Poco::Crypto ALIAS _poco_crypto)
+
+    message (STATUS "Not using Poco::Crypto")
+endif ()

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

@@ -0,0 +1,138 @@
+//
+// Cipher.h
+//
+// Library: Crypto
+// Package: Cipher
+// Module:  Cipher
+//
+// Definition of the Cipher class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_Cipher_INCLUDED
+#define Crypto_Cipher_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/AutoPtr.h"
+#include <istream>
+#include <ostream>
+#include <vector>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+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
+
+
+#endif // Crypto_Cipher_INCLUDED

base/poco/Crypto/include/Poco/Crypto/CipherFactory.h

@@ -0,0 +1,75 @@
+//
+// CipherFactory.h
+//
+// Library: Crypto
+// Package: Cipher
+// Module:  CipherFactory
+//
+// Definition of the CipherFactory class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_CipherFactory_INCLUDED
+#define Crypto_CipherFactory_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class Cipher;
+class CipherKey;
+class RSAKey;
+
+
+class Crypto_API CipherFactory
+	/// A factory for Cipher objects. See the Cipher class for examples on how to
+	/// use the CipherFactory.
+{
+public:
+	CipherFactory();
+		/// Creates a new CipherFactory object.
+
+	virtual ~CipherFactory();
+		/// Destroys the CipherFactory.
+
+	Cipher* createCipher(const CipherKey& key);
+		/// Creates a Cipher object for the given Cipher name. Valid cipher 
+		/// names depend on the OpenSSL version the library is linked with;  
+		/// see the output of
+		///
+		///     openssl enc --help
+		///
+		/// for a list of supported block and stream ciphers.
+		///
+		/// Common examples are:
+		///
+		///   * AES: "aes-128", "aes-256"
+		///   * DES: "des", "des3"
+		///   * Blowfish: "bf"
+
+	Cipher* createCipher(const RSAKey& key, RSAPaddingMode paddingMode = RSA_PADDING_PKCS1);
+		/// Creates a RSACipher using the given RSA key and padding mode
+		/// for public key encryption/private key decryption.
+	
+	static CipherFactory& defaultFactory();
+		/// Returns the default CipherFactory.
+
+private:
+	CipherFactory(const CipherFactory&);
+	CipherFactory& operator = (const CipherFactory&);
+};
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_CipherFactory_INCLUDED

base/poco/Crypto/include/Poco/Crypto/CipherImpl.h

@@ -0,0 +1,69 @@
+//
+// CipherImpl.h
+//
+// Library: Crypto
+// Package: Cipher
+// Module:  CipherImpl
+//
+// Definition of the CipherImpl class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_CipherImpl_INCLUDED
+#define Crypto_CipherImpl_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/Crypto/Cipher.h"
+#include "Poco/Crypto/CipherKey.h"
+#include "Poco/Crypto/OpenSSLInitializer.h"
+#include <openssl/evp.h>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class CipherImpl: public Cipher
+	/// An implementation of the Cipher class for OpenSSL's crypto library.
+{
+public:
+	CipherImpl(const CipherKey& key);
+		/// Creates a new CipherImpl object for the given CipherKey.
+
+	virtual ~CipherImpl();
+		/// Destroys the CipherImpl.
+
+	const std::string& name() const;
+		/// Returns the name of the cipher.
+
+	CryptoTransform* createEncryptor();
+		/// Creates an encryptor object.
+
+	CryptoTransform* createDecryptor();
+		/// Creates a decryptor object.
+
+private:
+	CipherKey _key;
+	OpenSSLInitializer _openSSLInitializer;
+};
+
+
+//
+// Inlines
+//
+inline const std::string& CipherImpl::name() const
+{
+	return _key.name();
+}
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_CipherImpl_INCLUDED

base/poco/Crypto/include/Poco/Crypto/CipherKey.h

@@ -0,0 +1,201 @@
+//
+// CipherKey.h
+//
+// Library: Crypto
+// Package: Cipher
+// Module:  CipherKey
+//
+// Definition of the CipherKey class.
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_CipherKey_INCLUDED
+#define Crypto_CipherKey_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/Crypto/CipherKeyImpl.h"
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class Crypto_API CipherKey
+	/// CipherKey stores the key information for decryption/encryption of data.
+	/// To create a random key, using the following code:
+	///
+	///     CipherKey key("aes-256");
+	///
+	/// 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.
+	///
+	/// To create a key using a human-readable password
+	/// string, use the following code. We create a AES Cipher and 
+	/// use a salt value to make the key more robust:
+	///
+	///     std::string password = "secret";
+	///     std::string salt("asdff8723lasdf(**923412");
+	///     CipherKey key("aes-256", password, salt);
+	///
+	/// You may also control the digest and the number of iterations used to generate the key
+	/// by specifying the specific values. Here we create a key with the same data as before,
+	/// except that we use 100 iterations instead of DEFAULT_ITERATION_COUNT, and sha1 instead of
+	/// the default md5:
+	///
+	///     std::string password = "secret";
+	///     std::string salt("asdff8723lasdf(**923412");
+	///     std::string digest ("sha1");
+	///     CipherKey key("aes-256", password, salt, 100, digest);
+	///
+{
+public:
+	typedef CipherKeyImpl::Mode Mode;
+	typedef CipherKeyImpl::ByteVec ByteVec;
+
+	enum
+	{
+		DEFAULT_ITERATION_COUNT = 2000
+			/// Default iteration count to use with
+			/// generateKey(). RSA security recommends
+			/// an iteration count of at least 1000.
+	};
+
+	CipherKey(const std::string& name, 
+		const std::string& passphrase, 
+		const std::string& salt = "",
+		int iterationCount = DEFAULT_ITERATION_COUNT,
+		const std::string& digest = "md5");
+		/// Creates a new CipherKeyImpl object using the given
+		/// cipher name, passphrase, salt value, iteration count and digest.
+
+	CipherKey(const std::string& name, 
+		const ByteVec& key, 
+		const ByteVec& iv);
+		/// Creates a new CipherKeyImpl object using the given cipher
+		/// name, key and initialization vector (IV).
+		///
+		/// The size of the IV must match the cipher's expected
+		/// IV size (see ivSize()), except for GCM mode, which allows
+		/// a custom IV size.
+
+	CipherKey(const std::string& name);
+		/// Creates a new CipherKeyImpl object. Autoinitializes key and 
+		/// initialization vector.
+
+	~CipherKey();
+		/// Destroys the CipherKeyImpl.
+
+	const std::string& name() const;
+		/// Returns the name of the Cipher.
+
+	int keySize() const;
+		/// Returns the key size of the Cipher.
+
+	int blockSize() const;
+		/// Returns the block size of the Cipher.
+
+	int ivSize() const;
+		/// Returns the IV size of the Cipher.
+
+	Mode mode() const;
+		/// Returns the Cipher's mode of operation.
+	
+	const ByteVec& getKey() const;
+		/// Returns the key for the Cipher.
+
+	void setKey(const ByteVec& key);
+		/// Sets the key for the Cipher.
+
+	const ByteVec& getIV() const;
+		/// Returns the initialization vector (IV) for the Cipher.
+
+	void setIV(const ByteVec& iv);
+		/// Sets the initialization vector (IV) for the Cipher.
+		///
+		/// The size of the vector must match the cipher's expected
+		/// IV size (see ivSize()), except for GCM mode, which allows
+		/// a custom IV size.
+
+	CipherKeyImpl::Ptr impl();
+		/// Returns the impl object
+
+private:
+	CipherKeyImpl::Ptr _pImpl;
+};
+
+
+//
+// inlines
+//
+inline const std::string& CipherKey::name() const
+{
+	return _pImpl->name();
+}
+
+
+inline int CipherKey::keySize() const
+{
+	return _pImpl->keySize();
+}
+
+
+inline int CipherKey::blockSize() const
+{
+	return _pImpl->blockSize();
+}
+
+
+inline int CipherKey::ivSize() const
+{
+	return _pImpl->ivSize();
+}
+
+
+inline CipherKey::Mode CipherKey::mode() const
+{
+	return _pImpl->mode();
+}
+
+
+inline const CipherKey::ByteVec& CipherKey::getKey() const
+{
+	return _pImpl->getKey();
+}
+
+
+inline void CipherKey::setKey(const CipherKey::ByteVec& key)
+{
+	_pImpl->setKey(key);
+}
+
+
+inline const CipherKey::ByteVec& CipherKey::getIV() const
+{
+	return _pImpl->getIV();
+}
+
+
+inline void CipherKey::setIV(const CipherKey::ByteVec& iv)
+{
+	_pImpl->setIV(iv);
+}
+
+
+inline CipherKeyImpl::Ptr CipherKey::impl()
+{
+	return _pImpl;
+}
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_CipherKey_INCLUDED

base/poco/Crypto/include/Poco/Crypto/CipherKeyImpl.h

@@ -0,0 +1,168 @@
+//
+// CipherKeyImpl.h
+//
+// Library: Crypto
+// Package: Cipher
+// Module:  CipherKeyImpl
+//
+// Definition of the CipherKeyImpl class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_CipherKeyImpl_INCLUDED
+#define Crypto_CipherKeyImpl_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/Crypto/OpenSSLInitializer.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/AutoPtr.h"
+#include <vector>
+
+
+struct evp_cipher_st;
+typedef struct evp_cipher_st EVP_CIPHER;
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class CipherKeyImpl: public RefCountedObject
+	/// An implementation of the CipherKey class for OpenSSL's crypto library.
+{
+public:
+	typedef std::vector<unsigned char> ByteVec;
+	typedef Poco::AutoPtr<CipherKeyImpl> Ptr;
+
+	enum Mode
+		/// Cipher mode of operation. This mode determines how multiple blocks
+		/// are connected; this is essential to improve security.
+	{
+		MODE_STREAM_CIPHER,	/// Stream cipher
+		MODE_ECB,			/// Electronic codebook (plain concatenation)
+		MODE_CBC,			/// Cipher block chaining (default)
+		MODE_CFB,			/// Cipher feedback
+		MODE_OFB,			/// Output feedback
+		MODE_CTR,           /// Counter mode
+		MODE_GCM,           /// Galois/Counter mode
+		MODE_CCM            /// Counter with CBC-MAC
+	};
+
+	CipherKeyImpl(const std::string& name,
+		const std::string& passphrase,
+		const std::string& salt,
+		int iterationCount,
+		const std::string& digest);
+		/// Creates a new CipherKeyImpl object, using
+		/// the given cipher name, passphrase, salt value
+		/// and iteration count.
+
+	CipherKeyImpl(const std::string& name,
+		const ByteVec& key,
+		const ByteVec& iv);
+		/// Creates a new CipherKeyImpl object, using the
+		/// given cipher name, key and initialization vector.
+
+	CipherKeyImpl(const std::string& name);
+		/// Creates a new CipherKeyImpl object. Autoinitializes key
+		/// and initialization vector.
+
+	virtual ~CipherKeyImpl();
+		/// Destroys the CipherKeyImpl.
+
+	const std::string& name() const;
+		/// Returns the name of the Cipher.
+
+	int keySize() const;
+		/// Returns the key size of the Cipher.
+
+	int blockSize() const;
+		/// Returns the block size of the Cipher.
+
+	int ivSize() const;
+		/// Returns the IV size of the Cipher.
+
+	Mode mode() const;
+		/// Returns the Cipher's mode of operation.
+
+	const ByteVec& getKey() const;
+		/// Returns the key for the Cipher.
+
+	void setKey(const ByteVec& key);
+		/// Sets the key for the Cipher.
+
+	const ByteVec& getIV() const;
+		/// Returns the initialization vector (IV) for the Cipher.
+
+	void setIV(const ByteVec& iv);
+		/// Sets the initialization vector (IV) for the Cipher.
+
+	const EVP_CIPHER* cipher();
+		/// Returns the cipher object
+
+private:
+	void generateKey(const std::string& passphrase,
+		const std::string& salt,
+		int iterationCount);
+	 	/// Generates key and IV from a password and optional salt string.
+
+	void generateKey();
+		/// Generates key and IV from random data.
+
+	void getRandomBytes(ByteVec& vec, std::size_t count);
+		/// Stores random bytes in vec.
+
+private:
+	const EVP_CIPHER*  _pCipher;
+	const EVP_MD*      _pDigest;
+	std::string	       _name;
+	ByteVec		       _key;
+	ByteVec		       _iv;
+	OpenSSLInitializer _openSSLInitializer;
+};
+
+
+//
+// Inlines
+//
+inline const std::string& CipherKeyImpl::name() const
+{
+	return _name;
+}
+
+
+inline const CipherKeyImpl::ByteVec& CipherKeyImpl::getKey() const
+{
+	return _key;
+}
+
+
+inline void CipherKeyImpl::setKey(const ByteVec& key)
+{
+	poco_assert(key.size() == static_cast<ByteVec::size_type>(keySize()));
+	_key = key;
+}
+
+
+inline const CipherKeyImpl::ByteVec& CipherKeyImpl::getIV() const
+{
+	return _iv;
+}
+
+
+inline const EVP_CIPHER* CipherKeyImpl::cipher()
+{
+	return _pCipher;
+}
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_CipherKeyImpl_INCLUDED

base/poco/Crypto/include/Poco/Crypto/Crypto.h

@@ -0,0 +1,195 @@
+//
+// Crypto.h
+//
+// Library: Crypto
+// Package: CryptoCore
+// Module:  Crypto
+//
+// Basic definitions for the Poco Crypto library.
+// This file must be the first file included by every other Crypto
+// header file.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_Crypto_INCLUDED
+#define Crypto_Crypto_INCLUDED
+
+
+#define POCO_EXTERNAL_OPENSSL_DEFAULT 1
+#define POCO_EXTERNAL_OPENSSL_SLPRO 2
+
+
+#include "Poco/Foundation.h"
+#include <openssl/opensslv.h>
+
+
+#ifndef OPENSSL_VERSION_PREREQ
+	#if defined(OPENSSL_VERSION_MAJOR) && defined(OPENSSL_VERSION_MINOR)
+		#define OPENSSL_VERSION_PREREQ(maj, min) \
+			((OPENSSL_VERSION_MAJOR << 16) + OPENSSL_VERSION_MINOR >= ((maj) << 16) + (min))
+	#else
+		#define OPENSSL_VERSION_PREREQ(maj, min) \
+			(OPENSSL_VERSION_NUMBER >= (((maj) << 28) | ((min) << 20)))
+	#endif
+#endif
+
+
+enum RSAPaddingMode
+	/// The padding mode used for RSA public key encryption.
+{
+	RSA_PADDING_PKCS1,
+		/// PKCS #1 v1.5 padding. This currently is the most widely used mode. 
+		
+	RSA_PADDING_PKCS1_OAEP,
+		/// EME-OAEP as defined in PKCS #1 v2.0 with SHA-1, MGF1 and an empty 
+		/// encoding parameter. This mode is recommended for all new applications.
+		
+	RSA_PADDING_SSLV23,
+		/// PKCS #1 v1.5 padding with an SSL-specific modification that denotes 
+		/// that the server is SSL3 capable. 
+		
+	RSA_PADDING_NONE
+		/// Raw RSA encryption. This mode should only be used to implement cryptographically 
+		/// sound padding modes in the application code. Encrypting user data directly with RSA 
+		/// is insecure. 
+};
+
+
+//
+// The following block is the standard way of creating macros which make exporting
+// from a DLL simpler. All files within this DLL are compiled with the Crypto_EXPORTS
+// symbol defined on the command line. this symbol should not be defined on any project
+// that uses this DLL. This way any other project whose source files include this file see
+// Crypto_API functions as being imported from a DLL, whereas this DLL sees symbols
+// defined with this macro as being exported.
+//
+#if defined(_WIN32)
+	#if defined(POCO_DLL)
+		#if defined(Crypto_EXPORTS)
+			#define Crypto_API __declspec(dllexport)
+		#else
+			#define Crypto_API __declspec(dllimport)
+		#endif
+	#endif
+#endif
+
+
+#if !defined(Crypto_API)
+	#if !defined(POCO_NO_GCC_API_ATTRIBUTE) && defined (__GNUC__) && (__GNUC__ >= 4)
+		#define Crypto_API __attribute__ ((visibility ("default")))
+	#else
+		#define Crypto_API
+	#endif
+#endif
+
+
+//
+// Automatically link Crypto and OpenSSL libraries.
+//
+#if defined(_MSC_VER)
+	#if !defined(POCO_NO_AUTOMATIC_LIBS)
+		#if defined(POCO_INTERNAL_OPENSSL_MSVC_VER)
+			#if defined(POCO_EXTERNAL_OPENSSL)
+				#pragma message("External OpenSSL defined but internal headers used - possible mismatch!")
+			#endif // POCO_EXTERNAL_OPENSSL
+			#if !defined(_DEBUG)
+				#define POCO_DEBUG_SUFFIX ""
+				#if !defined (_DLL)
+					#define POCO_STATIC_SUFFIX "mt"
+				#else // _DLL
+					#define POCO_STATIC_SUFFIX ""
+				#endif
+			#else // _DEBUG
+				#define POCO_DEBUG_SUFFIX "d"
+				#if !defined (_DLL)
+					#define POCO_STATIC_SUFFIX "mt"
+				#else // _DLL
+					#define POCO_STATIC_SUFFIX ""
+				#endif
+			#endif
+			#pragma comment(lib, "libcrypto" POCO_STATIC_SUFFIX POCO_DEBUG_SUFFIX ".lib")
+			#pragma comment(lib, "libssl" POCO_STATIC_SUFFIX POCO_DEBUG_SUFFIX ".lib")
+			#if !defined(_WIN64) && !defined (_DLL) && \
+						(POCO_INTERNAL_OPENSSL_MSVC_VER == 120) && \
+						(POCO_MSVC_VERSION < POCO_INTERNAL_OPENSSL_MSVC_VER)
+				#pragma comment(lib, "libPreVS2013CRT" POCO_STATIC_SUFFIX POCO_DEBUG_SUFFIX ".lib")
+			#endif
+			#if !defined (_DLL) && (POCO_MSVS_VERSION >= 2015)
+				#pragma comment(lib, "legacy_stdio_definitions.lib")
+				#pragma comment(lib, "legacy_stdio_wide_specifiers.lib")
+			#endif
+		#elif defined(POCO_EXTERNAL_OPENSSL)
+			#if POCO_EXTERNAL_OPENSSL == POCO_EXTERNAL_OPENSSL_SLPRO
+				#if defined(POCO_DLL)
+					#if OPENSSL_VERSION_PREREQ(1,1)
+						#pragma comment(lib, "libcrypto.lib")
+						#pragma comment(lib, "libssl.lib")
+					#else
+						#pragma comment(lib, "libeay32.lib")
+						#pragma comment(lib, "ssleay32.lib")
+					#endif
+			  	#else
+					#if OPENSSL_VERSION_PREREQ(1,1)
+						#if defined(_WIN64)
+							#pragma comment(lib, "libcrypto64" POCO_LIB_SUFFIX)
+							#pragma comment(lib, "libssl64" POCO_LIB_SUFFIX)
+						#else
+							#pragma comment(lib, "libcrypto32" POCO_LIB_SUFFIX)
+							#pragma comment(lib, "libssl32" POCO_LIB_SUFFIX)
+						#endif
+					#else
+						#pragma comment(lib, "libeay32" POCO_LIB_SUFFIX)
+						#pragma comment(lib, "ssleay32" POCO_LIB_SUFFIX)
+					#endif
+				#endif
+			#elif POCO_EXTERNAL_OPENSSL == POCO_EXTERNAL_OPENSSL_DEFAULT
+				#if OPENSSL_VERSION_PREREQ(1,1)
+					#pragma comment(lib, "libcrypto.lib")
+					#pragma comment(lib, "libssl.lib")
+				#else
+					#pragma comment(lib, "libeay32.lib")
+					#pragma comment(lib, "ssleay32.lib")
+				#endif
+			#endif
+		#endif // POCO_INTERNAL_OPENSSL_MSVC_VER
+		#if !defined(Crypto_EXPORTS)
+			#pragma comment(lib, "PocoCrypto" POCO_LIB_SUFFIX)
+		#endif
+	#endif // POCO_NO_AUTOMATIC_LIBS
+#endif
+
+
+namespace Poco {
+namespace Crypto {
+
+
+void Crypto_API initializeCrypto();
+	/// Initialize the Crypto library, as well as the underlying OpenSSL
+	/// libraries, by calling OpenSSLInitializer::initialize().
+	///
+	/// Should be called before using any class from the Crypto library.
+	/// The Crypto library will be initialized automatically, through
+	/// OpenSSLInitializer instances held by various Crypto classes
+	/// (Cipher, CipherKey, RSAKey, X509Certificate).
+	/// However, it is recommended to call initializeCrypto()
+	/// in any case at application startup.
+	///
+	/// Can be called multiple times; however, for every call to
+	/// initializeCrypto(), a matching call to uninitializeCrypto()
+	/// must be performed.
+
+
+void Crypto_API uninitializeCrypto();
+	/// Uninitializes the Crypto library by calling
+	/// OpenSSLInitializer::uninitialize().
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_Crypto_INCLUDED

base/poco/Crypto/include/Poco/Crypto/CryptoException.h

@@ -0,0 +1,56 @@
+//
+// CryptoException.h
+//
+//
+// Library: Crypto
+// Package: Crypto
+// Module:  CryptoException
+//
+// Definition of the CryptoException class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_CryptoException_INCLUDED
+#define Crypto_CryptoException_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/Exception.h"
+
+
+namespace Poco {
+namespace Crypto {
+
+
+POCO_DECLARE_EXCEPTION(Crypto_API, CryptoException, Poco::Exception)
+
+
+class Crypto_API OpenSSLException : public CryptoException
+{
+public:
+	OpenSSLException(int code = 0);
+	OpenSSLException(const std::string& msg, int code = 0);
+	OpenSSLException(const std::string& msg, const std::string& arg, int code = 0);
+	OpenSSLException(const std::string& msg, const Poco::Exception& exc, int code = 0);
+	OpenSSLException(const OpenSSLException& exc);
+	~OpenSSLException() throw();
+	OpenSSLException& operator = (const OpenSSLException& exc);
+	const char* name() const throw();
+	const char* className() const throw();
+	Poco::Exception* clone() const;
+	void rethrow() const;
+
+private:
+	void setExtMessage();
+};
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_CryptoException_INCLUDED

base/poco/Crypto/include/Poco/Crypto/CryptoStream.h

@@ -0,0 +1,192 @@
+//
+// CryptoStream.h
+//
+// Library: Crypto
+// Package: Cipher
+// Module:  CryptoStream
+//
+// Definition of the CryptoStreamBuf, CryptoInputStream and CryptoOutputStream
+// classes.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_CryptoStream_INCLUDED
+#define Crypto_CryptoStream_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/BufferedStreamBuf.h"
+#include "Poco/Buffer.h"
+#include <iostream>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class CryptoTransform;
+class Cipher;
+
+
+class Crypto_API CryptoStreamBuf: public Poco::BufferedStreamBuf
+	/// This stream buffer performs cryptographic transformation on the data
+	/// going through it.
+{
+public:
+	CryptoStreamBuf(std::istream& istr, CryptoTransform* pTransform, std::streamsize bufferSize = 8192);
+	CryptoStreamBuf(std::ostream& ostr, CryptoTransform* pTransform, std::streamsize bufferSize = 8192);
+
+	virtual ~CryptoStreamBuf();
+
+	void close();
+		/// Flushes all buffers and finishes the encryption.
+
+protected:
+	int readFromDevice(char* buffer, std::streamsize length);
+	int writeToDevice(const char* buffer, std::streamsize length);
+
+private:
+	CryptoTransform* _pTransform;
+	std::istream*	 _pIstr;
+	std::ostream*	 _pOstr;
+	bool			 _eof;
+
+	Poco::Buffer<unsigned char> _buffer;
+
+	CryptoStreamBuf(const CryptoStreamBuf&);
+	CryptoStreamBuf& operator = (const CryptoStreamBuf&);
+};
+
+
+class Crypto_API CryptoIOS: public virtual std::ios
+	/// The base class for CryptoInputStream and CryptoOutputStream.
+	///
+	/// This class is needed to ensure correct initialization order of the
+	/// stream buffer and base classes.
+{
+public:
+	CryptoIOS(std::istream& istr, CryptoTransform* pTransform, std::streamsize bufferSize = 8192);
+	CryptoIOS(std::ostream& ostr, CryptoTransform* pTransform, std::streamsize bufferSize = 8192);
+	~CryptoIOS();
+	CryptoStreamBuf* rdbuf();
+
+protected:
+	CryptoStreamBuf _buf;
+};
+
+
+class Crypto_API CryptoInputStream: public CryptoIOS, public std::istream
+	/// This stream transforms all data passing through it using the given
+	/// CryptoTransform.
+	///
+	/// Use a CryptoTransform object provided by Cipher::createEncrytor() or
+	/// Cipher::createDecryptor() to create an encrypting or decrypting stream,
+	/// respectively.
+{
+public:
+	CryptoInputStream(std::istream& istr, CryptoTransform* pTransform, std::streamsize bufferSize = 8192);
+		/// Create a new CryptoInputStream object. The CryptoInputStream takes the
+		/// ownership of the given CryptoTransform object.
+
+	CryptoInputStream(std::istream& istr, Cipher& cipher, std::streamsize bufferSize = 8192);
+		/// Create a new encrypting CryptoInputStream object using the given cipher.
+
+	~CryptoInputStream();
+		/// Destroys the CryptoInputStream.
+};
+
+
+class Crypto_API CryptoOutputStream: public CryptoIOS, public std::ostream
+	/// This stream transforms all data passing through it using the given
+	/// CryptoTransform.
+	///
+	/// Use a CryptoTransform object provided by Cipher::createEncrytor() or
+	/// Cipher::createDecryptor() to create an encrypting or decrypting stream,
+	/// respectively.
+	///
+	/// After all data has been passed through the stream, close() must be called
+	/// to ensure completion of cryptographic transformation.
+{
+public:
+	CryptoOutputStream(std::ostream& ostr, CryptoTransform* pTransform, std::streamsize bufferSize = 8192);
+		/// Create a new CryptoOutputStream object. The CryptoOutputStream takes the
+		/// ownership of the given CryptoTransform object.
+
+	CryptoOutputStream(std::ostream& ostr, Cipher& cipher, std::streamsize bufferSize = 8192);
+		/// Create a new decrypting CryptoOutputStream object using the given cipher.
+
+	~CryptoOutputStream();
+		/// Destroys the CryptoOutputStream.
+
+	void close();
+		/// Flushes all buffers and finishes the encryption.
+};
+
+
+class Crypto_API DecryptingInputStream: public CryptoIOS, public std::istream
+	/// This stream decrypts all data passing through it using the given
+	/// Cipher.
+{
+public:
+	DecryptingInputStream(std::istream& istr, Cipher& cipher, std::streamsize bufferSize = 8192);
+		/// Create a new DecryptingInputStream object using the given cipher.
+
+	~DecryptingInputStream();
+		/// Destroys the DecryptingInputStream.
+};
+
+
+class Crypto_API DecryptingOutputStream: public CryptoIOS, public std::ostream
+	/// This stream decrypts all data passing through it using the given
+	/// Cipher.
+{
+public:
+	DecryptingOutputStream(std::ostream& ostr, Cipher& cipher, std::streamsize bufferSize = 8192);
+		/// Create a new DecryptingOutputStream object using the given cipher.
+
+	~DecryptingOutputStream();
+		/// Destroys the DecryptingOutputStream.
+
+	void close();
+		/// Flushes all buffers and finishes the decryption.
+};
+
+
+class Crypto_API EncryptingInputStream: public CryptoIOS, public std::istream
+	/// This stream encrypts all data passing through it using the given
+	/// Cipher.
+{
+public:
+	EncryptingInputStream(std::istream& istr, Cipher& cipher, std::streamsize bufferSize = 8192);
+		/// Create a new EncryptingInputStream object using the given cipher.
+
+	~EncryptingInputStream();
+		/// Destroys the EncryptingInputStream.
+};
+
+
+class Crypto_API EncryptingOutputStream: public CryptoIOS, public std::ostream
+	/// This stream encrypts all data passing through it using the given
+	/// Cipher.
+{
+public:
+	EncryptingOutputStream(std::ostream& ostr, Cipher& cipher, std::streamsize bufferSize = 8192);
+		/// Create a new EncryptingOutputStream object using the given cipher.
+
+	~EncryptingOutputStream();
+		/// Destroys the EncryptingOutputStream.
+
+	void close();
+		/// Flushes all buffers and finishes the encryption.
+};
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_CryptoStream_INCLUDED

base/poco/Crypto/include/Poco/Crypto/CryptoTransform.h

@@ -0,0 +1,87 @@
+//
+// CryptoTransform.h
+//
+// Library: Crypto
+// Package: Cipher
+// Module:  CryptoTransform
+//
+// Definition of the CryptoTransform class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_CryptoTransform_INCLUDED
+#define Crypto_CryptoTransform_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include <ios>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class Crypto_API CryptoTransform
+	/// This interface represents the basic operations for cryptographic
+	/// transformations to be used with a CryptoInputStream or a
+	/// CryptoOutputStream.
+	///
+	/// Implementations of this class are returned by the Cipher class to
+	/// perform encryption or decryption of data.
+{
+public:
+	CryptoTransform();
+		/// Creates a new CryptoTransform object.
+
+	virtual ~CryptoTransform();
+		/// Destroys the CryptoTransform.
+
+	virtual std::size_t blockSize() const = 0;
+		/// Returns the block size for this CryptoTransform.
+
+	virtual int setPadding(int padding);
+		/// Enables or disables padding. By default encryption operations are padded using standard block
+		/// padding and the padding is checked and removed when decrypting. If the padding parameter is zero then
+		/// no padding is performed, the total amount of data encrypted or decrypted must then be a multiple of
+		/// the block size or an error will occur.
+
+	virtual std::string getTag(std::size_t tagSize = 16) = 0;
+		/// Returns the GCM tag after encrypting using GCM mode.
+		///
+		/// Must be called after finalize().
+
+	virtual void setTag(const std::string& tag) = 0;
+		/// Sets the GCM tag for authenticated decryption using GCM mode.
+		///
+		/// Must be set before finalize() is called, otherwise
+		/// decryption will fail.
+
+	virtual std::streamsize transform(
+		const unsigned char* input,
+		std::streamsize		 inputLength,
+		unsigned char*		 output,
+		std::streamsize		 outputLength) = 0;
+		/// Transforms a chunk of data. The inputLength is arbitrary and does not
+		/// need to be a multiple of the block size. The output buffer has a maximum
+		/// capacity of the given outputLength that must be at least
+		///   inputLength + blockSize() - 1
+		/// Returns the number of bytes written to the output buffer.
+
+	virtual std::streamsize finalize(unsigned char* output, std::streamsize length) = 0;
+		/// Finalizes the transformation. The output buffer must contain enough
+		/// space for at least two blocks, ie.
+		///   length >= 2*blockSize()
+		/// must be true.  Returns the number of bytes written to the output
+		/// buffer.
+};
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_CryptoTransform_INCLUDED

base/poco/Crypto/include/Poco/Crypto/DigestEngine.h

@@ -0,0 +1,80 @@
+//
+// DigestEngine.h
+//
+// Library: Crypto
+// Package: Digest
+// Module:  DigestEngine
+//
+// Definition of the DigestEngine class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_DigestEngine_INCLUDED
+#define Crypto_DigestEngine_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/Crypto/OpenSSLInitializer.h"
+#include "Poco/DigestEngine.h"
+#include <openssl/evp.h>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class Crypto_API DigestEngine: public Poco::DigestEngine
+	/// This class implements a Poco::DigestEngine for all
+	/// digest algorithms supported by OpenSSL.
+{
+public:
+	DigestEngine(const std::string& name);
+		/// Creates a DigestEngine using the digest with the given name
+		/// (e.g., "MD5", "SHA1", "SHA256", "SHA512", etc.).
+		/// See the OpenSSL documentation for a list of supported digest algorithms.
+		///
+		/// Throws a Poco::NotFoundException if no algorithm with the given name exists.
+
+	~DigestEngine();
+		/// Destroys the DigestEngine.
+
+	const std::string& algorithm() const;
+		/// Returns the name of the digest algorithm.
+
+	int nid() const;
+		/// Returns the NID (OpenSSL object identifier) of the digest algorithm.
+
+	// DigestEngine
+	std::size_t digestLength() const;
+	void reset();
+	const Poco::DigestEngine::Digest& digest();
+
+protected:
+	void updateImpl(const void* data, std::size_t length);
+
+private:
+	std::string _name;
+	EVP_MD_CTX* _pContext;
+	Poco::DigestEngine::Digest _digest;
+	OpenSSLInitializer _openSSLInitializer;
+};
+
+
+//
+// inlines
+//
+inline const std::string& DigestEngine::algorithm() const
+{
+	return _name;
+}
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_DigestEngine_INCLUDED

base/poco/Crypto/include/Poco/Crypto/ECDSADigestEngine.h

@@ -0,0 +1,101 @@
+//
+// ECDSADigestEngine.h
+//
+//
+// Library: Crypto
+// Package: ECDSA
+// Module:  ECDSADigestEngine
+//
+// Definition of the ECDSADigestEngine class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_ECDSADigestEngine_INCLUDED
+#define Crypto_ECDSADigestEngine_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/Crypto/ECKey.h"
+#include "Poco/DigestEngine.h"
+#include "Poco/Crypto/DigestEngine.h"
+#include <istream>
+#include <ostream>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class Crypto_API ECDSADigestEngine: public Poco::DigestEngine
+	/// This class implements a Poco::DigestEngine that can be
+	/// used to compute a secure digital signature.
+	///
+	/// First another Poco::Crypto::DigestEngine is created and
+	/// used to compute a cryptographic hash of the data to be
+	/// signed. Then, the hash value is encrypted, using
+	/// the ECDSA private key.
+	///
+	/// To verify a signature, pass it to the verify() 
+	/// member function. It will decrypt the signature
+	/// using the ECDSA public key and compare the resulting
+	/// hash with the actual hash of the data.
+{
+public:
+
+	ECDSADigestEngine(const ECKey& key, const std::string &name);
+		/// Creates the ECDSADigestEngine with the given ECDSA key,
+		/// using the hash algorithm with the given name
+		/// (e.g., "SHA1", "SHA256", "SHA512", etc.).
+		/// See the OpenSSL documentation for a list of supported digest algorithms.
+		///
+		/// Throws a Poco::NotFoundException if no algorithm with the given name exists.
+
+	~ECDSADigestEngine();
+		/// Destroys the ECDSADigestEngine.
+
+	std::size_t digestLength() const;
+		/// Returns the length of the digest in bytes.
+
+	void reset();
+		/// Resets the engine so that a new
+		/// digest can be computed.
+		
+	const DigestEngine::Digest& digest();
+		/// Finishes the computation of the digest 
+		/// (the first time it's called) and
+		/// returns the message digest. 
+		///
+		/// Can be called multiple times.
+
+	const DigestEngine::Digest& signature();
+		/// Signs the digest using the ECDSADSA algorithm
+		/// and the private key (the first time it's
+		/// called) and returns the result.
+		///
+		/// Can be called multiple times.
+
+	bool verify(const DigestEngine::Digest& signature);
+		/// Verifies the data against the signature.
+		///
+		/// Returns true if the signature can be verified, false otherwise.
+
+protected:
+	void updateImpl(const void* data, std::size_t length);
+
+private:
+	ECKey _key;
+	Poco::Crypto::DigestEngine _engine;
+	Poco::DigestEngine::Digest _digest;
+	Poco::DigestEngine::Digest _signature;
+};
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_ECDSADigestEngine_INCLUDED

base/poco/Crypto/include/Poco/Crypto/ECKey.h

@@ -0,0 +1,136 @@
+//
+// ECKey.h
+//
+//
+// Library: Crypto
+// Package: EC
+// Module:  ECKey
+//
+// Definition of the ECKey class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_ECKey_INCLUDED
+#define Crypto_ECKey_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/Crypto/KeyPair.h"
+#include "Poco/Crypto/ECKeyImpl.h"
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class X509Certificate;
+class PKCS12Container;
+
+
+class Crypto_API ECKey : public KeyPair
+	/// This class stores an EC key pair, consisting
+	/// of private and public key. Storage of the private
+	/// key is optional.
+	///
+	/// If a private key is available, the ECKey can be
+	/// used for decrypting data (encrypted with the public key)
+	/// or computing secure digital signatures.
+{
+public:
+	ECKey(const EVPPKey& key);
+		/// Constructs ECKeyImpl by extracting the EC key.
+
+	ECKey(const X509Certificate& cert);
+		/// Extracts the EC public key from the given certificate.
+
+	ECKey(const PKCS12Container& cert);
+		/// Extracts the EC private key from the given certificate.
+
+	ECKey(const std::string& eccGroup);
+		/// Creates the ECKey. Creates a new public/private keypair using the given parameters.
+		/// Can be used to sign data and verify signatures.
+
+	ECKey(const std::string& publicKeyFile, const std::string& privateKeyFile, const std::string& privateKeyPassphrase = "");
+		/// Creates the ECKey, by reading public and private key from the given files and
+		/// using the given passphrase for the private key.
+		///
+		/// Cannot be used for signing or decryption unless a private key is available.
+		///
+		/// If a private key is specified, you don't need to specify a public key file.
+		/// OpenSSL will auto-create the public key from the private key.
+
+	ECKey(std::istream* pPublicKeyStream, std::istream* pPrivateKeyStream = 0, const std::string& privateKeyPassphrase = "");
+		/// Creates the ECKey, by reading public and private key from the given streams and
+		/// using the given passphrase for the private key.
+		///
+		/// Cannot be used for signing or decryption unless a private key is available.
+		///
+		/// If a private key is specified, you don't need to specify a public key file.
+		/// OpenSSL will auto-create the public key from the private key.
+
+	~ECKey();
+		/// Destroys the ECKey.
+
+	ECKeyImpl::Ptr impl() const;
+		/// Returns the impl object.
+
+	static std::string getCurveName(int nid = -1);
+		/// Returns elliptical curve name corresponding to
+		/// the given nid; if nid is not found, returns
+		/// empty string.
+		///
+		/// If nid is -1, returns first curve name.
+		///
+		/// If no curves are found, returns empty string;
+
+	static int getCurveNID(std::string& name);
+		/// Returns the NID of the specified curve.
+		///
+		/// If name is empty, returns the first curve NID
+		/// and updates the name accordingly.
+
+	static bool hasCurve(const std::string& name);
+		/// Returns true if the named curve is found,
+		/// false otherwise.
+
+private:
+	ECKeyImpl::Ptr _pImpl;
+};
+
+
+//
+// inlines
+//
+inline ECKeyImpl::Ptr ECKey::impl() const
+{
+	return _pImpl;
+}
+
+
+inline std::string ECKey::getCurveName(int nid)
+{
+	return ECKeyImpl::getCurveName(nid);
+}
+
+
+inline int ECKey::getCurveNID(std::string& name)
+{
+	return ECKeyImpl::getCurveNID(name);
+}
+
+
+inline bool ECKey::hasCurve(const std::string& name)
+{
+	return ECKeyImpl::hasCurve(name);
+}
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_ECKey_INCLUDED

base/poco/Crypto/include/Poco/Crypto/ECKeyImpl.h

@@ -0,0 +1,174 @@
+//
+// ECKeyImpl.h
+//
+//
+// Library: Crypto
+// Package: EC
+// Module:  ECKeyImpl
+//
+// Definition of the ECKeyImpl class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_ECKeyImplImpl_INCLUDED
+#define Crypto_ECKeyImplImpl_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/Crypto/EVPPKey.h"
+#include "Poco/Crypto/KeyPairImpl.h"
+#include "Poco/Crypto/OpenSSLInitializer.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/AutoPtr.h"
+#include <istream>
+#include <ostream>
+#include <vector>
+#include <openssl/objects.h>
+#include <openssl/ec.h>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class X509Certificate;
+class PKCS12Container;
+
+
+class ECKeyImpl: public KeyPairImpl
+	/// Elliptic Curve key clas implementation.
+{
+public:
+	typedef Poco::AutoPtr<ECKeyImpl> Ptr;
+	typedef std::vector<unsigned char> ByteVec;
+
+	ECKeyImpl(const EVPPKey& key);
+		/// Constructs ECKeyImpl by extracting the EC key.
+
+	ECKeyImpl(const X509Certificate& cert);
+		/// Constructs ECKeyImpl by extracting the EC public key from the given certificate.
+
+	ECKeyImpl(const PKCS12Container& cert);
+		/// Constructs ECKeyImpl by extracting the EC private key from the given certificate.
+
+	ECKeyImpl(int eccGroup);
+		/// Creates the ECKey of the specified group. Creates a new public/private keypair using the given parameters.
+		/// Can be used to sign data and verify signatures.
+
+	ECKeyImpl(const std::string& publicKeyFile, const std::string& privateKeyFile, const std::string& privateKeyPassphrase);
+		/// Creates the ECKey, by reading public and private key from the given files and
+		/// using the given passphrase for the private key. Can only by used for signing if 
+		/// a private key is available. 
+
+	ECKeyImpl(std::istream* pPublicKeyStream, std::istream* pPrivateKeyStream, const std::string& privateKeyPassphrase);
+		/// Creates the ECKey. Can only by used for signing if pPrivKey
+		/// is not null. If a private key file is specified, you don't need to
+		/// specify a public key file. OpenSSL will auto-create it from the private key.
+
+	~ECKeyImpl();
+		/// Destroys the ECKeyImpl.
+
+	EC_KEY* getECKey();
+		/// Returns the OpenSSL EC key.
+
+	const EC_KEY* getECKey() const;
+		/// Returns the OpenSSL EC key.
+
+	int size() const;
+		/// Returns the EC key length in bits.
+
+	int groupId() const;
+		/// Returns the EC key group integer Id.
+
+	std::string groupName() const;
+		/// Returns the EC key group name.
+
+	void save(const std::string& publicKeyFile,
+		const std::string& privateKeyFile = "",
+		const std::string& privateKeyPassphrase = "") const;
+		/// Exports the public and private keys to the given files. 
+		///
+		/// If an empty filename is specified, the corresponding key
+		/// is not exported.
+
+	void save(std::ostream* pPublicKeyStream,
+		std::ostream* pPrivateKeyStream = 0,
+		const std::string& privateKeyPassphrase = "") const;
+		/// Exports the public and private key to the given streams.
+		///
+		/// If a null pointer is passed for a stream, the corresponding
+		/// key is not exported.
+
+	static std::string getCurveName(int nid = -1);
+		/// Returns elliptical curve name corresponding to
+		/// the given nid; if nid is not found, returns
+		/// empty string.
+		///
+		/// If nid is -1, returns first curve name.
+		///
+		/// If no curves are found, returns empty string;
+
+	static int getCurveNID(std::string& name);
+		/// Returns the NID of the specified curve.
+		///
+		/// If name is empty, returns the first curve NID
+		/// and updates the name accordingly.
+
+	static bool hasCurve(const std::string& name);
+		/// Returns true if the named curve is found,
+		/// false otherwise.
+
+private:
+	void checkEC(const std::string& method, const std::string& func) const;
+	void freeEC();
+
+	EC_KEY* _pEC;
+};
+
+
+//
+// inlines
+//
+inline EC_KEY* ECKeyImpl::getECKey()
+{
+	return _pEC;
+}
+
+
+inline const EC_KEY* ECKeyImpl::getECKey() const
+{
+	return _pEC;
+}
+
+
+inline std::string ECKeyImpl::groupName() const
+{
+	return OBJ_nid2sn(groupId());
+}
+
+
+inline void ECKeyImpl::save(const std::string& publicKeyFile,
+	const std::string& privateKeyFile,
+	const std::string& privateKeyPassphrase) const
+{
+	EVPPKey(_pEC).save(publicKeyFile, privateKeyFile, privateKeyPassphrase);
+}
+
+
+inline void ECKeyImpl::save(std::ostream* pPublicKeyStream,
+	std::ostream* pPrivateKeyStream,
+	const std::string& privateKeyPassphrase) const
+{
+	EVPPKey(_pEC).save(pPublicKeyStream, pPrivateKeyStream, privateKeyPassphrase);
+}
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_ECKeyImplImpl_INCLUDED

base/poco/Crypto/include/Poco/Crypto/EVPPKey.h

@@ -0,0 +1,354 @@
+//
+// EVPPKey.h
+//
+//
+// Library: Crypto
+// Package: CryptoCore
+// Module:  EVPPKey
+//
+// Definition of the EVPPKey class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_EVPPKeyImpl_INCLUDED
+#define Crypto_EVPPKeyImpl_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/Crypto/CryptoException.h"
+#include "Poco/StreamCopier.h"
+#include <openssl/ec.h>
+#include <openssl/rsa.h>
+#include <openssl/evp.h>
+#include <openssl/pem.h>
+#include <sstream>
+#include <typeinfo>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class ECKey;
+class RSAKey;
+
+
+class Crypto_API EVPPKey
+	/// Utility class for conversion of native keys to EVP.
+	/// Currently, only RSA and EC keys are supported.
+{
+public:
+	explicit EVPPKey(const std::string& ecCurveName);
+		/// Constructs EVPPKey from ECC curve name.
+		///
+		/// Only EC keys can be wrapped by an EVPPKey
+		/// created using this constructor.
+
+	explicit EVPPKey(const char* ecCurveName);
+		/// Constructs EVPPKey from ECC curve name.
+		///
+		/// Only EC keys can be wrapped by an EVPPKey
+		/// created using this constructor.
+
+	explicit EVPPKey(EVP_PKEY* pEVPPKey);
+		/// Constructs EVPPKey from EVP_PKEY pointer.
+		/// The content behind the supplied pointer is internally duplicated.
+
+	template<typename K>
+	explicit EVPPKey(K* pKey): _pEVPPKey(EVP_PKEY_new())
+		/// Constructs EVPPKey from a "native" OpenSSL (RSA or EC_KEY),
+		/// or a Poco wrapper (RSAKey, ECKey) key pointer.
+	{
+		if (!_pEVPPKey) throw OpenSSLException();
+		setKey(pKey);
+	}
+
+	EVPPKey(const std::string& publicKeyFile, const std::string& privateKeyFile, const std::string& privateKeyPassphrase = "");
+		/// Creates the EVPPKey, by reading public and private key from the given files and
+		/// using the given passphrase for the private key. Can only by used for signing if
+		/// a private key is available.
+
+	EVPPKey(std::istream* pPublicKeyStream, std::istream* pPrivateKeyStream, const std::string& privateKeyPassphrase = "");
+		/// Creates the EVPPKey. Can only by used for signing if pPrivKey
+		/// is not null. If a private key file is specified, you don't need to
+		/// specify a public key file. OpenSSL will auto-create it from the private key.
+
+	EVPPKey(const EVPPKey& other);
+		/// Copy constructor.
+
+	EVPPKey& operator=(const EVPPKey& other);
+		/// Assignment operator.
+
+#ifdef POCO_ENABLE_CPP11
+
+	EVPPKey(EVPPKey&& other);
+		/// Move constructor.
+
+	EVPPKey& operator=(EVPPKey&& other);
+		/// Assignment move operator.
+
+#endif // POCO_ENABLE_CPP11
+
+	~EVPPKey();
+		/// Destroys the EVPPKey.
+
+	bool operator == (const EVPPKey& other) const;
+		/// Comparison operator.
+		/// Returns true if public key components and parameters
+		/// of the other key are equal to this key.
+		///
+		/// Works as expected when one key contains only public key,
+		/// while the other one contains private (thus also public) key.
+
+	bool operator != (const EVPPKey& other) const;
+		/// Comparison operator.
+		/// Returns true if public key components and parameters
+		/// of the other key are different from this key.
+		///
+		/// Works as expected when one key contains only public key,
+		/// while the other one contains private (thus also public) key.
+
+	void save(const std::string& publicKeyFile, const std::string& privateKeyFile = "", const std::string& privateKeyPassphrase = "") const;
+		/// Exports the public and/or private keys to the given files.
+		///
+		/// If an empty filename is specified, the corresponding key
+		/// is not exported.
+
+	void save(std::ostream* pPublicKeyStream, std::ostream* pPrivateKeyStream = 0, const std::string& privateKeyPassphrase = "") const;
+		/// Exports the public and/or private key to the given streams.
+		///
+		/// If a null pointer is passed for a stream, the corresponding
+		/// key is not exported.
+
+	int type() const;
+		/// Retuns the EVPPKey type NID.
+
+	bool isSupported(int type) const;
+		/// Returns true if OpenSSL type is supported
+
+	operator const EVP_PKEY*() const;
+		/// Returns const pointer to the OpenSSL EVP_PKEY structure.
+
+	operator EVP_PKEY*();
+		/// Returns pointer to the OpenSSL EVP_PKEY structure.
+
+	static EVP_PKEY* duplicate(const EVP_PKEY* pFromKey, EVP_PKEY** pToKey);
+		/// Duplicates pFromKey into *pToKey and returns
+		// the pointer to duplicated EVP_PKEY.
+
+private:
+	EVPPKey();
+
+	static int type(const EVP_PKEY* pEVPPKey);
+	void newECKey(const char* group);
+	void duplicate(EVP_PKEY* pEVPPKey);
+
+	void setKey(ECKey* pKey);
+	void setKey(RSAKey* pKey);
+	void setKey(EC_KEY* pKey);
+	void setKey(RSA* pKey);
+	static int passCB(char* buf, int size, int, void* pass);
+
+	typedef EVP_PKEY* (*PEM_read_FILE_Key_fn)(FILE*, EVP_PKEY**, pem_password_cb*, void*);
+	typedef EVP_PKEY* (*PEM_read_BIO_Key_fn)(BIO*, EVP_PKEY**, pem_password_cb*, void*);
+	typedef void* (*EVP_PKEY_get_Key_fn)(EVP_PKEY*);
+
+	// The following load*() functions are used by both native and EVP_PKEY type key
+	// loading from BIO/FILE.
+	// When used for EVP key loading, getFunc is null (ie. native key is not extracted
+	// from the loaded EVP_PKEY).
+	template <typename K, typename F>
+	static bool loadKey(K** ppKey,
+		PEM_read_FILE_Key_fn readFunc,
+		F getFunc,
+		const std::string& keyFile,
+		const std::string& pass = "")
+	{
+		poco_assert_dbg (((typeid(K*) == typeid(RSA*) || typeid(K*) == typeid(EC_KEY*)) && getFunc) ||
+						((typeid(K*) == typeid(EVP_PKEY*)) && !getFunc));
+		poco_check_ptr (ppKey);
+		poco_assert_dbg (!*ppKey);
+
+		FILE* pFile = 0;
+		if (!keyFile.empty())
+		{
+			if (!getFunc) *ppKey = (K*)EVP_PKEY_new();
+			EVP_PKEY* pKey = getFunc ? EVP_PKEY_new() : (EVP_PKEY*)*ppKey;
+			if (pKey)
+			{
+				pFile = fopen(keyFile.c_str(), "r");
+				if (pFile)
+				{
+					pem_password_cb* pCB = pass.empty() ? (pem_password_cb*)0 : &passCB;
+					void* pPassword = pass.empty() ? (void*)0 : (void*)pass.c_str();
+					if (readFunc(pFile, &pKey, pCB, pPassword))
+					{
+						fclose(pFile); pFile = 0;
+						if(getFunc)
+						{
+							*ppKey = (K*)getFunc(pKey);
+							EVP_PKEY_free(pKey);
+						}
+						else
+						{
+							poco_assert_dbg (typeid(K*) == typeid(EVP_PKEY*));
+							*ppKey = (K*)pKey;
+						}
+						if(!*ppKey) goto error;
+						return true;
+					}
+					goto error;
+				}
+				else
+				{
+					if (getFunc) EVP_PKEY_free(pKey);
+					throw IOException("ECKeyImpl, cannot open file", keyFile);
+				}
+			}
+			else goto error;
+		}
+		return false;
+
+	error:
+		if (pFile) fclose(pFile);
+		throw OpenSSLException("EVPKey::loadKey(string)");
+	}
+
+	template <typename K, typename F>
+	static bool loadKey(K** ppKey,
+		PEM_read_BIO_Key_fn readFunc,
+		F getFunc,
+		std::istream* pIstr,
+		const std::string& pass = "")
+	{
+		poco_assert_dbg (((typeid(K*) == typeid(RSA*) || typeid(K*) == typeid(EC_KEY*)) && getFunc) ||
+						((typeid(K*) == typeid(EVP_PKEY*)) && !getFunc));
+		poco_check_ptr(ppKey);
+		poco_assert_dbg(!*ppKey);
+
+		BIO* pBIO = 0;
+		if (pIstr)
+		{
+			std::ostringstream ostr;
+			Poco::StreamCopier::copyStream(*pIstr, ostr);
+			std::string key = ostr.str();
+			pBIO = BIO_new_mem_buf(const_cast<char*>(key.data()), static_cast<int>(key.size()));
+			if (pBIO)
+			{
+				if (!getFunc) *ppKey = (K*)EVP_PKEY_new();
+				EVP_PKEY* pKey = getFunc ? EVP_PKEY_new() : (EVP_PKEY*)*ppKey;
+				if (pKey)
+				{
+					pem_password_cb* pCB = pass.empty() ? (pem_password_cb*)0 : &passCB;
+					void* pPassword = pass.empty() ? (void*)0 : (void*)pass.c_str();
+					if (readFunc(pBIO, &pKey, pCB, pPassword))
+					{
+						BIO_free(pBIO); pBIO = 0;
+						if (getFunc)
+						{
+							*ppKey = (K*)getFunc(pKey);
+							EVP_PKEY_free(pKey);
+						}
+						else
+						{
+							poco_assert_dbg (typeid(K*) == typeid(EVP_PKEY*));
+							*ppKey = (K*)pKey;
+						}
+						if (!*ppKey) goto error;
+						return true;
+					}
+					if (getFunc) EVP_PKEY_free(pKey);
+					goto error;
+				}
+				else goto error;
+			}
+			else goto error;
+		}
+		return false;
+
+	error:
+		if (pBIO) BIO_free(pBIO);
+		throw OpenSSLException("EVPKey::loadKey(stream)");
+	}
+
+	EVP_PKEY* _pEVPPKey;
+
+	friend class ECKeyImpl;
+	friend class RSAKeyImpl;
+};
+
+
+//
+// inlines
+//
+
+
+inline bool EVPPKey::operator == (const EVPPKey& other) const
+{
+	poco_check_ptr (other._pEVPPKey);
+	poco_check_ptr (_pEVPPKey);
+	return (1 == EVP_PKEY_cmp(_pEVPPKey, other._pEVPPKey));
+}
+
+
+inline bool EVPPKey::operator != (const EVPPKey& other) const
+{
+	return !(other == *this);
+}
+
+
+inline int EVPPKey::type(const EVP_PKEY* pEVPPKey)
+{
+	if (!pEVPPKey) return NID_undef;
+
+	return EVP_PKEY_type(EVP_PKEY_id(pEVPPKey));
+}
+
+
+inline int EVPPKey::type() const
+{
+	return type(_pEVPPKey);
+}
+
+
+inline bool EVPPKey::isSupported(int type) const
+{
+	return type == EVP_PKEY_EC || type == EVP_PKEY_RSA;
+}
+
+
+inline EVPPKey::operator const EVP_PKEY*() const
+{
+	return _pEVPPKey;
+}
+
+
+inline EVPPKey::operator EVP_PKEY*()
+{
+	return _pEVPPKey;
+}
+
+
+inline void EVPPKey::setKey(EC_KEY* pKey)
+{
+	if (!EVP_PKEY_set1_EC_KEY(_pEVPPKey, pKey))
+		throw OpenSSLException();
+}
+
+
+inline void EVPPKey::setKey(RSA* pKey)
+{
+	if (!EVP_PKEY_set1_RSA(_pEVPPKey, pKey))
+		throw OpenSSLException();
+}
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_EVPPKeyImpl_INCLUDED

base/poco/Crypto/include/Poco/Crypto/KeyPair.h

@@ -0,0 +1,133 @@
+//
+// KeyPair.h
+//
+//
+// Library: Crypto
+// Package: CryptoCore
+// Module:  KeyPair
+//
+// Definition of the KeyPair class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_KeyPair_INCLUDED
+#define Crypto_KeyPair_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/Crypto/KeyPairImpl.h"
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class X509Certificate;
+
+
+class Crypto_API KeyPair
+	/// This is a parent class for classes storing a key pair, consisting
+	/// of private and public key. Storage of the private key is optional.
+	///
+	/// If a private key is available, the KeyPair can be
+	/// used for decrypting data (encrypted with the public key)
+	/// or computing secure digital signatures.
+{
+public:
+	enum Type
+	{
+		KT_RSA = KeyPairImpl::KT_RSA_IMPL,
+		KT_EC = KeyPairImpl::KT_EC_IMPL
+	};
+
+	explicit KeyPair(KeyPairImpl::Ptr pKeyPairImpl = 0);
+		/// Extracts the RSA public key from the given certificate.
+
+	virtual ~KeyPair();
+		/// Destroys the KeyPair.
+
+	virtual int size() const;
+		/// Returns the RSA modulus size.
+
+	virtual void save(const std::string& publicKeyPairFile,
+		const std::string& privateKeyPairFile = "",
+		const std::string& privateKeyPairPassphrase = "") const;
+		/// Exports the public and private keys to the given files. 
+		///
+		/// If an empty filename is specified, the corresponding key
+		/// is not exported.
+
+	virtual void save(std::ostream* pPublicKeyPairStream,
+		std::ostream* pPrivateKeyPairStream = 0,
+		const std::string& privateKeyPairPassphrase = "") const;
+		/// Exports the public and private key to the given streams.
+		///
+		/// If a null pointer is passed for a stream, the corresponding
+		/// key is not exported.
+
+	KeyPairImpl::Ptr impl() const;
+		/// Returns the impl object.
+
+	const std::string& name() const;
+		/// Returns key pair name
+
+	Type type() const;
+		/// Returns key pair type
+	
+private:
+	KeyPairImpl::Ptr _pImpl;
+};
+
+
+//
+// inlines
+//
+
+inline int KeyPair::size() const
+{
+	return _pImpl->size();
+}
+
+
+inline void KeyPair::save(const std::string& publicKeyFile,
+	const std::string& privateKeyFile,
+	const std::string& privateKeyPassphrase) const
+{
+	_pImpl->save(publicKeyFile, privateKeyFile, privateKeyPassphrase);
+}
+
+
+inline void KeyPair::save(std::ostream* pPublicKeyStream,
+	std::ostream* pPrivateKeyStream,
+	const std::string& privateKeyPassphrase) const
+{
+	_pImpl->save(pPublicKeyStream, pPrivateKeyStream, privateKeyPassphrase);
+}
+
+
+inline const std::string& KeyPair::name() const
+{
+	return _pImpl->name();
+}
+
+inline KeyPairImpl::Ptr KeyPair::impl() const
+{
+	return _pImpl;
+}
+
+
+inline KeyPair::Type KeyPair::type() const
+{
+	return (KeyPair::Type)impl()->type();
+}
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_KeyPair_INCLUDED

base/poco/Crypto/include/Poco/Crypto/KeyPairImpl.h

@@ -0,0 +1,107 @@
+//
+// KeyPairImpl.h
+//
+//
+// Library: Crypto
+// Package: CryptoCore
+// Module:  KeyPairImpl
+//
+// Definition of the KeyPairImpl class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_KeyPairImplImpl_INCLUDED
+#define Crypto_KeyPairImplImpl_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/Crypto/OpenSSLInitializer.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/AutoPtr.h"
+#include <string>
+#include <vector>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class KeyPairImpl: public Poco::RefCountedObject
+	/// Class KeyPairImpl
+{
+public:
+	enum Type
+	{
+		KT_RSA_IMPL = 0,
+		KT_EC_IMPL
+	};
+
+	typedef Poco::AutoPtr<KeyPairImpl> Ptr;
+	typedef std::vector<unsigned char> ByteVec;
+
+	KeyPairImpl(const std::string& name, Type type);
+		/// Create KeyPairImpl with specified type and name.
+
+	virtual ~KeyPairImpl();
+		/// Destroys the KeyPairImpl.
+
+	virtual int size() const = 0;
+		/// Returns the key size.
+
+	virtual void save(const std::string& publicKeyFile,
+		const std::string& privateKeyFile = "",
+		const std::string& privateKeyPassphrase = "") const = 0;
+		/// Exports the public and private keys to the given files. 
+		///
+		/// If an empty filename is specified, the corresponding key
+		/// is not exported.
+
+	virtual void save(std::ostream* pPublicKeyStream,
+		std::ostream* pPrivateKeyStream = 0,
+		const std::string& privateKeyPassphrase = "") const = 0;
+		/// Exports the public and private key to the given streams.
+		///
+		/// If a null pointer is passed for a stream, the corresponding
+		/// key is not exported.
+
+	const std::string& name() const;
+		/// Returns key pair name
+
+	Type type() const;
+		/// Returns key pair type
+
+private:
+	KeyPairImpl();
+
+	std::string _name;
+	Type        _type;
+	OpenSSLInitializer _openSSLInitializer;
+};
+
+
+//
+// inlines
+//
+
+
+inline const std::string& KeyPairImpl::name() const
+{
+	return _name;
+}
+
+
+inline KeyPairImpl::Type KeyPairImpl::type() const
+{
+	return _type;
+}
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_KeyPairImplImpl_INCLUDED

base/poco/Crypto/include/Poco/Crypto/OpenSSLInitializer.h

@@ -0,0 +1,115 @@
+//
+// OpenSSLInitializer.h
+//
+// Library: Crypto
+// Package: CryptoCore
+// Module:  OpenSSLInitializer
+//
+// Definition of the OpenSSLInitializer class.
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_OpenSSLInitializer_INCLUDED
+#define Crypto_OpenSSLInitializer_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/Mutex.h"
+#include "Poco/AtomicCounter.h"
+#include <openssl/crypto.h>
+
+#if defined(OPENSSL_FIPS) && OPENSSL_VERSION_NUMBER < 0x010001000L
+#include <openssl/fips.h>
+#endif
+
+
+extern "C"
+{
+	struct CRYPTO_dynlock_value
+	{
+		Poco::FastMutex _mutex;
+	};
+}
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class Crypto_API OpenSSLInitializer
+	/// Initalizes the OpenSSL library.
+	///
+	/// The class ensures the earliest initialization and the
+	/// latest shutdown of the OpenSSL library.
+{
+public:
+	OpenSSLInitializer();
+		/// Automatically initialize OpenSSL on startup.
+		
+	~OpenSSLInitializer();
+		/// Automatically shut down OpenSSL on exit.
+	
+	static void initialize();
+		/// Initializes the OpenSSL machinery.
+
+	static void uninitialize();
+		/// Shuts down the OpenSSL machinery.
+
+	static bool isFIPSEnabled();
+		// Returns true if FIPS mode is enabled, false otherwise.
+
+	static void enableFIPSMode(bool enabled);
+		// Enable or disable FIPS mode. If FIPS is not available, this method doesn't do anything.
+
+protected:
+	enum
+	{
+		SEEDSIZE = 256
+	};
+	
+	// OpenSSL multithreading support
+	static void lock(int mode, int n, const char* file, int line);
+	static unsigned long id();
+	static struct CRYPTO_dynlock_value* dynlockCreate(const char* file, int line);
+	static void dynlock(int mode, struct CRYPTO_dynlock_value* lock, const char* file, int line);
+	static void dynlockDestroy(struct CRYPTO_dynlock_value* lock, const char* file, int line);
+
+private:
+	static Poco::FastMutex* _mutexes;
+	static Poco::AtomicCounter _rc;
+};
+
+
+//
+// inlines
+//
+inline bool OpenSSLInitializer::isFIPSEnabled()
+{
+#ifdef OPENSSL_FIPS
+	return FIPS_mode() ? true : false;
+#else
+	return false;
+#endif
+}
+
+#ifdef OPENSSL_FIPS
+inline void OpenSSLInitializer::enableFIPSMode(bool enabled)
+{
+	FIPS_mode_set(enabled);
+}
+#else
+inline void OpenSSLInitializer::enableFIPSMode(bool /*enabled*/)
+{
+}
+#endif
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_OpenSSLInitializer_INCLUDED

base/poco/Crypto/include/Poco/Crypto/PKCS12Container.h

@@ -0,0 +1,159 @@
+//
+// PKCS12Container.h
+//
+// Library: Crypto
+// Package: Certificate
+// Module:  PKCS12Container
+//
+// Definition of the PKCS12Container class.
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_PKCS12Container_INCLUDED
+#define Crypto_PKCS12Container_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/Crypto/OpenSSLInitializer.h"
+#include "Poco/Crypto/X509Certificate.h"
+#include "Poco/Crypto/EVPPKey.h"
+#include "Poco/Path.h"
+#include <memory>
+#include <istream>
+#include <openssl/pkcs12.h>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class Crypto_API PKCS12Container
+	/// This class implements PKCS#12 container functionality.
+{
+public:
+	typedef X509Certificate::List CAList;
+	typedef std::vector<std::string> CANameList;
+
+	explicit PKCS12Container(std::istream& istr, const std::string& password = "");
+		/// Creates the PKCS12Container object from a stream.
+
+	explicit PKCS12Container(const std::string& path, const std::string& password = "");
+		/// Creates the PKCS12Container object from a file.
+
+	PKCS12Container(const PKCS12Container& cont);
+		/// Copy constructor.
+
+	PKCS12Container& operator = (const PKCS12Container& cont);
+		/// Assignment operator.
+
+#ifdef POCO_ENABLE_CPP11
+
+	PKCS12Container(PKCS12Container&& cont);
+		/// Move constructor.
+
+	PKCS12Container& operator = (PKCS12Container&& cont);
+		/// Move assignment operator.
+
+#endif // POCO_ENABLE_CPP11
+
+	~PKCS12Container();
+		/// Destroys the PKCS12Container.
+
+	bool hasKey() const;
+		/// Returns true if container contains the key.
+
+	EVPPKey getKey() const;
+		/// Return key as openssl EVP_PKEY wrapper object.
+
+	bool hasX509Certificate() const;
+		/// Returns true if container has X509 certificate.
+
+	const X509Certificate& getX509Certificate() const;
+		/// Returns the X509 certificate.
+		/// Throws NotFoundException if there is no certificate.
+
+	const CAList& getCACerts() const;
+		/// Returns the list of CA certificates in this container.
+
+	const std::string& getFriendlyName() const;
+		/// Returns the friendly name of the certificate bag.
+
+	const CANameList& getFriendlyNamesCA() const;
+		/// Returns a list of CA certificates friendly names.
+
+private:
+	void load(PKCS12* pPKCS12, const std::string& password = "");
+	std::string extractFriendlyName(X509* pCert);
+
+#ifdef POCO_ENABLE_CPP11
+	typedef std::unique_ptr<X509Certificate> CertPtr;
+#else
+	typedef std::auto_ptr<X509Certificate> CertPtr;
+#endif // #ifdef POCO_ENABLE_CPP11
+
+	OpenSSLInitializer _openSSLInitializer;
+	EVP_PKEY*          _pKey;
+	CertPtr            _pX509Cert;
+	CAList             _caCertList;
+	CANameList         _caCertNames;
+	std::string        _pkcsFriendlyName;
+};
+
+
+//
+// inlines
+//
+
+inline bool PKCS12Container::hasX509Certificate() const
+{
+	return _pX509Cert.get() != 0;
+}
+
+
+inline const X509Certificate& PKCS12Container::getX509Certificate() const
+{
+	if (!hasX509Certificate())
+		throw NotFoundException("PKCS12Container X509 certificate");
+	return *_pX509Cert;
+}
+
+
+inline const std::string& PKCS12Container::getFriendlyName() const
+{
+	return _pkcsFriendlyName;
+}
+
+
+inline const PKCS12Container::CAList& PKCS12Container::getCACerts() const
+{
+	return _caCertList;
+}
+
+
+inline const PKCS12Container::CANameList& PKCS12Container::getFriendlyNamesCA() const
+{
+	return _caCertNames;
+}
+
+
+inline bool PKCS12Container::hasKey() const
+{
+	return _pKey != 0;
+}
+
+
+inline EVPPKey PKCS12Container::getKey() const
+{
+	return EVPPKey(_pKey);
+}
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_PKCS12Container_INCLUDED

base/poco/Crypto/include/Poco/Crypto/RSACipherImpl.h

@@ -0,0 +1,77 @@
+//
+// RSACipherImpl.h
+//
+// Library: Crypto
+// Package: RSA
+// Module:  RSACipherImpl
+//
+// Definition of the RSACipherImpl class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_RSACipherImpl_INCLUDED
+#define Crypto_RSACipherImpl_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/Crypto/Cipher.h"
+#include "Poco/Crypto/RSAKey.h"
+#include "Poco/Crypto/OpenSSLInitializer.h"
+#include <openssl/evp.h>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class RSACipherImpl: public Cipher
+	/// An implementation of the Cipher class for 
+	/// asymmetric (public-private key) encryption
+	/// based on the the RSA algorithm in OpenSSL's 
+	/// crypto library.
+	///
+	/// Encryption is using the public key, decryption
+	/// requires the private key.
+{
+public:
+	RSACipherImpl(const RSAKey& key, RSAPaddingMode paddingMode);
+		/// Creates a new RSACipherImpl object for the given RSAKey
+		/// and using the given padding mode.
+
+	virtual ~RSACipherImpl();
+		/// Destroys the RSACipherImpl.
+
+	const std::string& name() const;
+		/// Returns the name of the Cipher.
+	
+	CryptoTransform* createEncryptor();
+		/// Creates an encryptor object.
+
+	CryptoTransform* createDecryptor();
+		/// Creates a decryptor object.
+
+private:
+	RSAKey _key;
+	RSAPaddingMode _paddingMode;
+	OpenSSLInitializer _openSSLInitializer;
+};
+
+
+//
+// Inlines
+//
+inline const std::string& RSACipherImpl::name() const
+{
+	return _key.name();
+}
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_RSACipherImpl_INCLUDED

base/poco/Crypto/include/Poco/Crypto/RSADigestEngine.h

@@ -0,0 +1,111 @@
+//
+// RSADigestEngine.h
+//
+// Library: Crypto
+// Package: RSA
+// Module:  RSADigestEngine
+//
+// Definition of the RSADigestEngine class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_RSADigestEngine_INCLUDED
+#define Crypto_RSADigestEngine_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/Crypto/RSAKey.h"
+#include "Poco/DigestEngine.h"
+#include "Poco/Crypto/DigestEngine.h"
+#include <istream>
+#include <ostream>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class Crypto_API RSADigestEngine: public Poco::DigestEngine
+	/// This class implements a Poco::DigestEngine that can be
+	/// used to compute a secure digital signature.
+	///
+	/// First another Poco::Crypto::DigestEngine is created and
+	/// used to compute a cryptographic hash of the data to be
+	/// signed. Then, the hash value is encrypted, using
+	/// the RSA private key.
+	///
+	/// To verify a signature, pass it to the verify() 
+	/// member function. It will decrypt the signature
+	/// using the RSA public key and compare the resulting
+	/// hash with the actual hash of the data.
+{
+public:
+	enum DigestType
+	{
+		DIGEST_MD5,
+		DIGEST_SHA1
+	};
+	
+	//@ deprecated
+	RSADigestEngine(const RSAKey& key, DigestType digestType = DIGEST_SHA1);
+		/// Creates the RSADigestEngine with the given RSA key,
+		/// using the MD5 or SHA-1 hash algorithm.
+		/// Kept for backward compatibility
+
+	RSADigestEngine(const RSAKey& key, const std::string &name);
+		/// Creates the RSADigestEngine with the given RSA key,
+		/// using the hash algorithm with the given name
+		/// (e.g., "MD5", "SHA1", "SHA256", "SHA512", etc.).
+		/// See the OpenSSL documentation for a list of supported digest algorithms.
+		///
+		/// Throws a Poco::NotFoundException if no algorithm with the given name exists.
+
+	~RSADigestEngine();
+		/// Destroys the RSADigestEngine.
+
+	std::size_t digestLength() const;
+		/// Returns the length of the digest in bytes.
+
+	void reset();
+		/// Resets the engine so that a new
+		/// digest can be computed.
+		
+	const DigestEngine::Digest& digest();
+		/// Finishes the computation of the digest 
+		/// (the first time it's called) and
+		/// returns the message digest. 
+		///
+		/// Can be called multiple times.
+
+	const DigestEngine::Digest& signature();
+		/// Signs the digest using the RSA algorithm
+		/// and the private key (the first time it's
+		/// called) and returns the result.
+		///
+		/// Can be called multiple times.
+
+	bool verify(const DigestEngine::Digest& signature);
+		/// Verifies the data against the signature.
+		///
+		/// Returns true if the signature can be verified, false otherwise.
+
+protected:
+	void updateImpl(const void* data, std::size_t length);
+
+private:
+	RSAKey _key;
+	Poco::Crypto::DigestEngine _engine;
+	Poco::DigestEngine::Digest _digest;
+	Poco::DigestEngine::Digest _signature;
+};
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_RSADigestEngine_INCLUDED

base/poco/Crypto/include/Poco/Crypto/RSAKey.h

@@ -0,0 +1,125 @@
+//
+// RSAKey.h
+//
+// Library: Crypto
+// Package: RSA
+// Module:  RSAKey
+//
+// Definition of the RSAKey class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_RSAKey_INCLUDED
+#define Crypto_RSAKey_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/Crypto/KeyPair.h"
+#include "Poco/Crypto/RSAKeyImpl.h"
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class X509Certificate;
+class PKCS12Container;
+
+
+class Crypto_API RSAKey : public KeyPair
+	/// This class stores an RSA key pair, consisting
+	/// of private and public key. Storage of the private
+	/// key is optional.
+	///
+	/// If a private key is available, the RSAKey can be
+	/// used for decrypting data (encrypted with the public key)
+	/// or computing secure digital signatures.
+{
+public:
+	enum KeyLength
+	{
+		KL_512  = 512,
+		KL_1024 = 1024,
+		KL_2048 = 2048,
+		KL_4096 = 4096
+	};
+
+	enum Exponent
+	{
+		EXP_SMALL = 0,
+		EXP_LARGE
+	};
+
+	RSAKey(const EVPPKey& key);
+		/// Constructs ECKeyImpl by extracting the EC key.
+
+	RSAKey(const X509Certificate& cert);
+		/// Extracts the RSA public key from the given certificate.
+
+	RSAKey(const PKCS12Container& cert);
+		/// Extracts the RSA private key from the given certificate.
+
+	RSAKey(KeyLength keyLength, Exponent exp);
+		/// Creates the RSAKey. Creates a new public/private keypair using the given parameters.
+		/// Can be used to sign data and verify signatures.
+
+	RSAKey(const std::string& publicKeyFile,
+		const std::string& privateKeyFile = "",
+		const std::string& privateKeyPassphrase = "");
+		/// Creates the RSAKey, by reading public and private key from the given files and
+		/// using the given passphrase for the private key.
+		///
+		/// Cannot be used for signing or decryption unless a private key is available.
+		///
+		/// If a private key is specified, you don't need to specify a public key file.
+		/// OpenSSL will auto-create the public key from the private key.
+
+	RSAKey(std::istream* pPublicKeyStream,
+		std::istream* pPrivateKeyStream = 0,
+		const std::string& privateKeyPassphrase = "");
+		/// Creates the RSAKey, by reading public and private key from the given streams and
+		/// using the given passphrase for the private key.
+		///
+		/// Cannot be used for signing or decryption unless a private key is available.
+		///
+		/// If a private key is specified, you don't need to specify a public key file.
+		/// OpenSSL will auto-create the public key from the private key.
+
+	~RSAKey();
+		/// Destroys the RSAKey.
+
+	RSAKeyImpl::ByteVec modulus() const;
+		/// Returns the RSA modulus.
+
+	RSAKeyImpl::ByteVec encryptionExponent() const;
+		/// Returns the RSA encryption exponent.
+
+	RSAKeyImpl::ByteVec decryptionExponent() const;
+		/// Returns the RSA decryption exponent.
+
+	RSAKeyImpl::Ptr impl() const;
+		/// Returns the impl object.
+	
+private:
+	RSAKeyImpl::Ptr _pImpl;
+};
+
+
+//
+// inlines
+//
+inline RSAKeyImpl::Ptr RSAKey::impl() const
+{
+	return _pImpl;
+}
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_RSAKey_INCLUDED

base/poco/Crypto/include/Poco/Crypto/RSAKeyImpl.h

@@ -0,0 +1,141 @@
+//
+// RSAKeyImpl.h
+//
+// Library: Crypto
+// Package: RSA
+// Module:  RSAKeyImpl
+//
+// Definition of the RSAKeyImpl class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_RSAKeyImplImpl_INCLUDED
+#define Crypto_RSAKeyImplImpl_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/Crypto/EVPPKey.h"
+#include "Poco/Crypto/KeyPairImpl.h"
+#include "Poco/Crypto/OpenSSLInitializer.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/AutoPtr.h"
+#include <istream>
+#include <ostream>
+#include <vector>
+
+
+struct bignum_st;
+struct rsa_st;
+typedef struct bignum_st BIGNUM;
+typedef struct rsa_st RSA;
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class X509Certificate;
+class PKCS12Container;
+
+
+class RSAKeyImpl: public KeyPairImpl
+	/// class RSAKeyImpl
+{
+public:
+	typedef Poco::AutoPtr<RSAKeyImpl> Ptr;
+	typedef std::vector<unsigned char> ByteVec;
+
+	RSAKeyImpl(const EVPPKey& key);
+		/// Constructs ECKeyImpl by extracting the EC key.
+
+	RSAKeyImpl(const X509Certificate& cert);
+		/// Extracts the RSA public key from the given certificate.
+
+	RSAKeyImpl(const PKCS12Container& cert);
+		/// Extracts the EC private key from the given certificate.
+
+	RSAKeyImpl(int keyLength, unsigned long exponent);
+		/// Creates the RSAKey. Creates a new public/private keypair using the given parameters.
+		/// Can be used to sign data and verify signatures.
+
+	RSAKeyImpl(const std::string& publicKeyFile, const std::string& privateKeyFile, const std::string& privateKeyPassphrase);
+		/// Creates the RSAKey, by reading public and private key from the given files and
+		/// using the given passphrase for the private key. Can only by used for signing if 
+		/// a private key is available. 
+
+	RSAKeyImpl(std::istream* pPublicKeyStream, std::istream* pPrivateKeyStream, const std::string& privateKeyPassphrase);
+		/// Creates the RSAKey. Can only by used for signing if pPrivKey
+		/// is not null. If a private key file is specified, you don't need to
+		/// specify a public key file. OpenSSL will auto-create it from the private key.
+
+	~RSAKeyImpl();
+		/// Destroys the RSAKeyImpl.
+
+	RSA* getRSA();
+		/// Returns the OpenSSL RSA object.
+
+	const RSA* getRSA() const;
+		/// Returns the OpenSSL RSA object.
+
+	int size() const;
+		/// Returns the RSA modulus size.
+
+	ByteVec modulus() const;
+		/// Returns the RSA modulus.
+
+	ByteVec encryptionExponent() const;
+		/// Returns the RSA encryption exponent.
+
+	ByteVec decryptionExponent() const;
+		/// Returns the RSA decryption exponent.
+
+	void save(const std::string& publicKeyFile,
+		const std::string& privateKeyFile = "",
+		const std::string& privateKeyPassphrase = "") const;
+		/// Exports the public and private keys to the given files. 
+		///
+		/// If an empty filename is specified, the corresponding key
+		/// is not exported.
+
+	void save(std::ostream* pPublicKeyStream,
+		std::ostream* pPrivateKeyStream = 0,
+		const std::string& privateKeyPassphrase = "") const;
+		/// Exports the public and private key to the given streams.
+		///
+		/// If a null pointer is passed for a stream, the corresponding
+		/// key is not exported.
+
+private:
+	RSAKeyImpl();
+
+	void freeRSA();
+	static ByteVec convertToByteVec(const BIGNUM* bn);
+
+	RSA* _pRSA;
+};
+
+
+//
+// inlines
+//
+inline RSA* RSAKeyImpl::getRSA()
+{
+	return _pRSA;
+}
+
+
+inline const RSA* RSAKeyImpl::getRSA() const
+{
+	return _pRSA;
+}
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_RSAKeyImplImpl_INCLUDED

base/poco/Crypto/include/Poco/Crypto/X509Certificate.h

@@ -0,0 +1,245 @@
+//
+// X509Certificate.h
+//
+// Library: Crypto
+// Package: Certificate
+// Module:  X509Certificate
+//
+// Definition of the X509Certificate class.
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_X509Certificate_INCLUDED
+#define Crypto_X509Certificate_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/Crypto/OpenSSLInitializer.h"
+#include "Poco/DateTime.h"
+#include "Poco/SharedPtr.h"
+#include <vector>
+#include <set>
+#include <istream>
+#include <openssl/ssl.h>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class Crypto_API X509Certificate
+	/// This class represents a X509 Certificate.
+{
+public:
+	typedef std::vector<X509Certificate> List;
+
+	enum NID
+		/// Name identifier for extracting information from
+		/// a certificate subject's or issuer's distinguished name.
+	{
+		NID_COMMON_NAME = 13,
+		NID_COUNTRY = 14,
+		NID_LOCALITY_NAME = 15,
+		NID_STATE_OR_PROVINCE = 16,
+		NID_ORGANIZATION_NAME = 17,
+		NID_ORGANIZATION_UNIT_NAME = 18,
+		NID_PKCS9_EMAIL_ADDRESS = 48,
+		NID_SERIAL_NUMBER = 105
+	};
+
+	explicit X509Certificate(std::istream& istr);
+		/// Creates the X509Certificate object by reading
+		/// a certificate in PEM format from a stream.
+
+	explicit X509Certificate(const std::string& path);
+		/// Creates the X509Certificate object by reading
+		/// a certificate in PEM format from a file.
+
+	explicit X509Certificate(X509* pCert);
+		/// Creates the X509Certificate from an existing
+		/// OpenSSL certificate. Ownership is taken of
+		/// the certificate.
+
+	X509Certificate(X509* pCert, bool shared);
+		/// Creates the X509Certificate from an existing
+		/// OpenSSL certificate. Ownership is taken of
+		/// the certificate. If shared is true, the
+		/// certificate's reference count is incremented.
+
+	X509Certificate(const X509Certificate& cert);
+		/// Creates the certificate by copying another one.
+
+	X509Certificate& operator = (const X509Certificate& cert);
+		/// Assigns a certificate.
+
+	void swap(X509Certificate& cert);
+		/// Exchanges the certificate with another one.
+
+	~X509Certificate();
+		/// Destroys the X509Certificate.
+
+	long version() const;
+		/// Returns the version of the certificate.
+
+	const std::string& serialNumber() const;
+		/// Returns the certificate serial number as a
+		/// string in decimal encoding.
+
+	const std::string& issuerName() const;
+		/// Returns the certificate issuer's distinguished name.
+
+	std::string issuerName(NID nid) const;
+		/// Extracts the information specified by the given
+		/// NID (name identifier) from the certificate issuer's
+		/// distinguished name.
+
+	const std::string& subjectName() const;
+		/// Returns the certificate subject's distinguished name.
+
+	std::string subjectName(NID nid) const;
+		/// Extracts the information specified by the given
+		/// NID (name identifier) from the certificate subject's
+		/// distinguished name.
+
+	std::string commonName() const;
+		/// Returns the common name stored in the certificate
+		/// subject's distinguished name.
+
+	void extractNames(std::string& commonName, std::set<std::string>& domainNames) const;
+		/// Extracts the common name and the alias domain names from the
+		/// certificate.
+
+	Poco::DateTime validFrom() const;
+		/// Returns the date and time the certificate is valid from.
+
+	Poco::DateTime expiresOn() const;
+		/// Returns the date and time the certificate expires.
+
+	void save(std::ostream& stream) const;
+		/// Writes the certificate to the given stream.
+		/// The certificate is written in PEM format.
+
+	void save(const std::string& path) const;
+		/// Writes the certificate to the file given by path.
+		/// The certificate is written in PEM format.
+
+	bool issuedBy(const X509Certificate& issuerCertificate) const;
+		/// Checks whether the certificate has been issued by
+		/// the issuer given by issuerCertificate. This can be
+		/// used to validate a certificate chain.
+		///
+		/// Verifies if the certificate has been signed with the
+		/// issuer's private key, using the public key from the issuer
+		/// certificate.
+		///
+		/// Returns true if verification against the issuer certificate
+		/// was successful, false otherwise.
+
+	bool equals(const X509Certificate& otherCertificate) const;
+		/// Checks whether the certificate is equal to
+		/// the other certificate, by comparing the hashes
+		/// of both certificates.
+		///
+		/// Returns true if both certificates are identical,
+		/// otherwise false.
+
+	const X509* certificate() const;
+		/// Returns the underlying OpenSSL certificate.
+
+	X509* dup() const;
+		/// Duplicates and returns the underlying OpenSSL certificate. Note that
+		/// the caller assumes responsibility for the lifecycle of the created
+		/// certificate.
+
+	std::string signatureAlgorithm() const;
+		/// Returns the certificate signature algorithm long name.
+
+	void print(std::ostream& out) const;
+		/// Prints the certificate information to ostream.
+
+	static List readPEM(const std::string& pemFileName);
+		/// Reads and returns a list of certificates from
+		/// the specified PEM file.
+
+	static void writePEM(const std::string& pemFileName, const List& list);
+		/// Writes the list of certificates to the specified PEM file.
+
+protected:
+	void load(std::istream& stream);
+		/// Loads the certificate from the given stream. The
+		/// certificate must be in PEM format.
+
+	void load(const std::string& path);
+		/// Loads the certificate from the given file. The
+		/// certificate must be in PEM format.
+
+	void init();
+		/// Extracts issuer and subject name from the certificate.
+
+private:
+	enum
+	{
+		NAME_BUFFER_SIZE = 256
+	};
+
+	std::string _issuerName;
+	std::string _subjectName;
+	std::string _serialNumber;
+	X509*       _pCert;
+	OpenSSLInitializer _openSSLInitializer;
+};
+
+
+//
+// inlines
+//
+
+
+inline long X509Certificate::version() const
+{
+	// This is defined by standards (X.509 et al) to be
+	// one less than the certificate version.
+	// So, eg. a version 3 certificate will return 2.
+	return X509_get_version(_pCert) + 1;
+}
+
+
+inline const std::string& X509Certificate::serialNumber() const
+{
+	return _serialNumber;
+}
+
+
+inline const std::string& X509Certificate::issuerName() const
+{
+	return _issuerName;
+}
+
+
+inline const std::string& X509Certificate::subjectName() const
+{
+	return _subjectName;
+}
+
+
+inline const X509* X509Certificate::certificate() const
+{
+	return _pCert;
+}
+
+
+inline X509* X509Certificate::dup() const
+{
+	return X509_dup(_pCert);
+}
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_X509Certificate_INCLUDED

base/poco/Crypto/src/Cipher.cpp

@@ -0,0 +1,140 @@
+//
+// Cipher.cpp
+//
+// Library: Crypto
+// Package: Cipher
+// Module:  Cipher
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/Cipher.h"
+#include "Poco/Crypto/CryptoStream.h"
+#include "Poco/Crypto/CryptoTransform.h"
+#include "Poco/Base64Encoder.h"
+#include "Poco/Base64Decoder.h"
+#include "Poco/HexBinaryEncoder.h"
+#include "Poco/HexBinaryDecoder.h"
+#include "Poco/StreamCopier.h"
+#include "Poco/Exception.h"
+#include <sstream>
+#include <memory>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+Cipher::Cipher()
+{
+}
+
+
+Cipher::~Cipher()
+{
+}
+
+
+std::string Cipher::encryptString(const std::string& str, Encoding encoding)
+{
+	std::istringstream source(str);
+	std::ostringstream sink;
+
+	encrypt(source, sink, encoding);
+
+	return sink.str();
+}
+
+
+std::string Cipher::decryptString(const std::string& str, Encoding encoding)
+{
+	std::istringstream source(str);
+	std::ostringstream sink;
+
+	decrypt(source, sink, encoding);
+	return sink.str();
+}
+
+
+void Cipher::encrypt(std::istream& source, std::ostream& sink, Encoding encoding)
+{
+	CryptoInputStream encryptor(source, createEncryptor());
+
+	switch (encoding)
+	{
+	case ENC_NONE:
+		StreamCopier::copyStream(encryptor, sink);
+		break;
+
+	case ENC_BASE64:
+	case ENC_BASE64_NO_LF:
+		{
+			Poco::Base64Encoder encoder(sink);
+			if (encoding == ENC_BASE64_NO_LF)
+			{
+				encoder.rdbuf()->setLineLength(0);
+			}
+			StreamCopier::copyStream(encryptor, encoder);
+			encoder.close();
+		}
+		break;
+
+	case ENC_BINHEX:
+	case ENC_BINHEX_NO_LF:
+		{
+			Poco::HexBinaryEncoder encoder(sink);
+			if (encoding == ENC_BINHEX_NO_LF)
+			{
+				encoder.rdbuf()->setLineLength(0);
+			}
+			StreamCopier::copyStream(encryptor, encoder);
+			encoder.close();
+		}
+		break;
+
+	default:
+		throw Poco::InvalidArgumentException("Invalid argument", "encoding");
+	}
+}
+
+
+void Cipher::decrypt(std::istream& source, std::ostream& sink, Encoding encoding)
+{
+	CryptoOutputStream decryptor(sink, createDecryptor());
+
+	switch (encoding)
+	{
+	case ENC_NONE:
+		StreamCopier::copyStream(source, decryptor);
+		decryptor.close();
+		break;
+
+	case ENC_BASE64:
+	case ENC_BASE64_NO_LF:
+		{
+			Poco::Base64Decoder decoder(source);
+			StreamCopier::copyStream(decoder, decryptor);
+			decryptor.close();
+		}
+		break;
+
+	case ENC_BINHEX:
+	case ENC_BINHEX_NO_LF:
+		{
+			Poco::HexBinaryDecoder decoder(source);
+			StreamCopier::copyStream(decoder, decryptor);
+			decryptor.close();
+		}
+		break;
+
+	default:
+		throw Poco::InvalidArgumentException("Invalid argument", "encoding");
+	}
+}
+
+
+} } // namespace Poco::Crypto

base/poco/Crypto/src/CipherFactory.cpp

@@ -0,0 +1,65 @@
+//
+// CipherFactory.cpp
+//
+// Library: Crypto
+// Package: Cipher
+// Module:  CipherFactory
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/CipherFactory.h"
+#include "Poco/Crypto/Cipher.h"
+#include "Poco/Crypto/CipherKey.h"
+#include "Poco/Crypto/RSAKey.h"
+#include "Poco/Crypto/CipherImpl.h"
+#include "Poco/Crypto/RSACipherImpl.h"
+#include "Poco/Exception.h"
+#include "Poco/SingletonHolder.h"
+#include <openssl/evp.h>
+#include <openssl/err.h>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+CipherFactory::CipherFactory()
+{
+}
+
+
+CipherFactory::~CipherFactory()
+{
+}
+
+
+namespace
+{
+	static Poco::SingletonHolder<CipherFactory> holder;
+}
+
+
+CipherFactory& CipherFactory::defaultFactory()
+{
+	return *holder.get();
+}
+
+
+Cipher* CipherFactory::createCipher(const CipherKey& key)
+{
+	return new CipherImpl(key);
+}
+
+
+Cipher* CipherFactory::createCipher(const RSAKey& key, RSAPaddingMode paddingMode)
+{
+	return new RSACipherImpl(key, paddingMode);
+}
+
+
+} } // namespace Poco::Crypto

base/poco/Crypto/src/CipherImpl.cpp

@@ -0,0 +1,272 @@
+//
+// CipherImpl.cpp
+//
+// Library: Crypto
+// Package: Cipher
+// Module:  CipherImpl
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/CipherImpl.h"
+#include "Poco/Crypto/CryptoTransform.h"
+#include "Poco/Exception.h"
+#include "Poco/Buffer.h"
+#include <openssl/err.h>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+namespace
+{
+	void throwError()
+	{
+		unsigned long err;
+		std::string msg;
+
+		while ((err = ERR_get_error()))
+		{
+			if (!msg.empty())
+				msg.append("; ");
+			msg.append(ERR_error_string(err, 0));
+		}
+
+		throw Poco::IOException(msg);
+	}
+
+
+	class CryptoTransformImpl: public CryptoTransform
+	{
+	public:
+		typedef Cipher::ByteVec ByteVec;
+
+		enum Direction
+		{
+			DIR_ENCRYPT,
+			DIR_DECRYPT
+		};
+
+		CryptoTransformImpl(
+			const EVP_CIPHER* pCipher,
+			const ByteVec&    key,
+			const ByteVec&    iv,
+			Direction         dir);
+
+		~CryptoTransformImpl();
+
+		std::size_t blockSize() const;
+		int setPadding(int padding);
+		std::string getTag(std::size_t tagSize);
+		void setTag(const std::string& tag);
+
+		std::streamsize transform(
+			const unsigned char* input,
+			std::streamsize      inputLength,
+			unsigned char*       output,
+			std::streamsize      outputLength);
+
+		std::streamsize finalize(
+			unsigned char*  output,
+			std::streamsize length);
+
+	private:
+		const EVP_CIPHER* _pCipher;
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+		EVP_CIPHER_CTX*   _pContext;
+#else
+		EVP_CIPHER_CTX    _context;
+#endif
+		ByteVec           _key;
+		ByteVec           _iv;
+	};
+
+
+	CryptoTransformImpl::CryptoTransformImpl(
+		const EVP_CIPHER* pCipher,
+		const ByteVec&    key,
+		const ByteVec&    iv,
+		Direction         dir):
+		_pCipher(pCipher),
+		_key(key),
+		_iv(iv)
+	{
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+		_pContext = EVP_CIPHER_CTX_new();
+		EVP_CipherInit(
+			_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
+
+#if OPENSSL_VERSION_NUMBER >= 0x10001000L
+		if (_iv.size() != EVP_CIPHER_iv_length(_pCipher) && EVP_CIPHER_mode(_pCipher) == EVP_CIPH_GCM_MODE)
+		{
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+			int rc = EVP_CIPHER_CTX_ctrl(_pContext, EVP_CTRL_GCM_SET_IVLEN, _iv.size(), NULL);
+#else
+			int rc = EVP_CIPHER_CTX_ctrl(&_context, EVP_CTRL_GCM_SET_IVLEN, _iv.size(), NULL);
+#endif
+			if (rc == 0) throwError();
+		}
+#endif
+	}
+
+
+	CryptoTransformImpl::~CryptoTransformImpl()
+	{
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+		EVP_CIPHER_CTX_cleanup(_pContext);
+		EVP_CIPHER_CTX_free(_pContext);
+#else
+		EVP_CIPHER_CTX_cleanup(&_context);
+#endif
+	}
+
+
+	std::size_t CryptoTransformImpl::blockSize() const
+	{
+#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)
+	{
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+		return EVP_CIPHER_CTX_block_size(_pContext);
+#else
+		return EVP_CIPHER_CTX_set_padding(&_context, padding);
+#endif
+	}
+
+
+	std::string CryptoTransformImpl::getTag(std::size_t tagSize)
+	{
+		std::string tag;
+#if OPENSSL_VERSION_NUMBER >= 0x10001000L
+		Poco::Buffer<char> buffer(tagSize);
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+		int rc = EVP_CIPHER_CTX_ctrl(_pContext, EVP_CTRL_GCM_GET_TAG, tagSize, buffer.begin());
+#else
+		int rc = EVP_CIPHER_CTX_ctrl(&_context, EVP_CTRL_GCM_GET_TAG, tagSize, buffer.begin());
+#endif
+		if (rc == 0) throwError();
+		tag.assign(buffer.begin(), tagSize);
+#endif
+		return tag;
+	}
+
+
+	void CryptoTransformImpl::setTag(const std::string& tag)
+	{
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+		int rc = EVP_CIPHER_CTX_ctrl(_pContext, EVP_CTRL_GCM_SET_TAG, tag.size(), const_cast<char*>(tag.data()));
+#elif OPENSSL_VERSION_NUMBER >= 0x10001000L
+		int rc = EVP_CIPHER_CTX_ctrl(&_context, EVP_CTRL_GCM_SET_TAG, tag.size(), const_cast<char*>(tag.data()));
+#else
+		int rc = 0;
+#endif
+		if (rc == 0) throwError();
+	}
+
+
+	std::streamsize CryptoTransformImpl::transform(
+		const unsigned char* input,
+		std::streamsize      inputLength,
+		unsigned char*       output,
+		std::streamsize      outputLength)
+	{
+		poco_assert (outputLength >= (inputLength + blockSize() - 1));
+
+		int outLen = static_cast<int>(outputLength);
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+		int rc = EVP_CipherUpdate(
+			_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();
+
+		return static_cast<std::streamsize>(outLen);
+	}
+
+
+	std::streamsize CryptoTransformImpl::finalize(
+		unsigned char*	output,
+		std::streamsize length)
+	{
+		poco_assert (length >= blockSize());
+
+		int len = static_cast<int>(length);
+
+		// 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.
+#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();
+
+		return static_cast<std::streamsize>(len);
+	}
+}
+
+
+CipherImpl::CipherImpl(const CipherKey& key):
+	_key(key)
+{
+}
+
+
+CipherImpl::~CipherImpl()
+{
+}
+
+
+CryptoTransform* CipherImpl::createEncryptor()
+{
+	CipherKeyImpl::Ptr p = _key.impl();
+	return new CryptoTransformImpl(p->cipher(), p->getKey(), p->getIV(), CryptoTransformImpl::DIR_ENCRYPT);
+}
+
+
+CryptoTransform* CipherImpl::createDecryptor()
+{
+	CipherKeyImpl::Ptr p = _key.impl();
+	return new CryptoTransformImpl(p->cipher(), p->getKey(), p->getIV(), CryptoTransformImpl::DIR_DECRYPT);
+}
+
+
+} } // namespace Poco::Crypto

base/poco/Crypto/src/CipherKey.cpp

@@ -0,0 +1,49 @@
+//
+// CipherKey.cpp
+//
+// Library: Crypto
+// Package: Cipher
+// Module:  CipherKey
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/CipherKey.h"
+
+
+namespace Poco {
+namespace Crypto {
+
+
+CipherKey::CipherKey(const std::string& name,
+	const std::string& passphrase,
+	const std::string& salt,
+	int iterationCount,
+	const std::string &digest):
+		_pImpl(new CipherKeyImpl(name, passphrase, salt, iterationCount, digest))
+{
+}
+
+
+CipherKey::CipherKey(const std::string& name, const ByteVec& key, const ByteVec& iv):
+	_pImpl(new CipherKeyImpl(name, key, iv))
+{
+}
+
+
+CipherKey::CipherKey(const std::string& name):
+	_pImpl(new CipherKeyImpl(name))
+{
+}
+
+
+CipherKey::~CipherKey()
+{
+}
+
+
+} } // namespace Poco::Crypto

base/poco/Crypto/src/CipherKeyImpl.cpp

@@ -0,0 +1,222 @@
+//
+// CipherKeyImpl.cpp
+//
+// Library: Crypto
+// Package: Cipher
+// Module:  CipherKeyImpl
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/CipherKeyImpl.h"
+#include "Poco/Crypto/CryptoTransform.h"
+#include "Poco/Crypto/CipherFactory.h"
+#include "Poco/Exception.h"
+#include "Poco/RandomStream.h"
+#include <openssl/err.h>
+#include <openssl/evp.h>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+CipherKeyImpl::CipherKeyImpl(const std::string& name,
+	const std::string& passphrase,
+	const std::string& salt,
+	int iterationCount,
+	const std::string& digest):
+	_pCipher(0),
+	_pDigest(0),
+	_name(name),
+	_key(),
+	_iv()
+{
+	// dummy access to Cipherfactory so that the EVP lib is initilaized
+	CipherFactory::defaultFactory();
+	_pCipher = EVP_get_cipherbyname(name.c_str());
+
+	if (!_pCipher)
+		throw Poco::NotFoundException("Cipher " + name + " was not found");
+
+	_pDigest = EVP_get_digestbyname(digest.c_str());
+
+	if (!_pDigest)
+		throw Poco::NotFoundException("Digest " + name + " was not found");
+
+	_key = ByteVec(keySize());
+	_iv = ByteVec(ivSize());
+	generateKey(passphrase, salt, iterationCount);
+}
+
+
+CipherKeyImpl::CipherKeyImpl(const std::string& name,
+	const ByteVec& key,
+	const ByteVec& iv):
+	_pCipher(0),
+	_pDigest(0),
+	_name(name),
+	_key(key),
+	_iv(iv)
+{
+	// dummy access to Cipherfactory so that the EVP lib is initialized
+	CipherFactory::defaultFactory();
+	_pCipher = EVP_get_cipherbyname(name.c_str());
+
+	if (!_pCipher)
+		throw Poco::NotFoundException("Cipher " + name + " was not found");
+}
+
+
+CipherKeyImpl::CipherKeyImpl(const std::string& name):
+	_pCipher(0),
+	_pDigest(0),
+	_name(name),
+	_key(),
+	_iv()
+{
+	// dummy access to Cipherfactory so that the EVP lib is initilaized
+	CipherFactory::defaultFactory();
+	_pCipher = EVP_get_cipherbyname(name.c_str());
+
+	if (!_pCipher)
+		throw Poco::NotFoundException("Cipher " + name + " was not found");
+	_key = ByteVec(keySize());
+	_iv = ByteVec(ivSize());
+	generateKey();
+}
+
+
+CipherKeyImpl::~CipherKeyImpl()
+{
+}
+
+
+CipherKeyImpl::Mode CipherKeyImpl::mode() const
+{
+	switch (EVP_CIPHER_mode(_pCipher))
+	{
+	case EVP_CIPH_STREAM_CIPHER:
+		return MODE_STREAM_CIPHER;
+
+	case EVP_CIPH_ECB_MODE:
+		return MODE_ECB;
+
+	case EVP_CIPH_CBC_MODE:
+		return MODE_CBC;
+
+	case EVP_CIPH_CFB_MODE:
+		return MODE_CFB;
+
+	case EVP_CIPH_OFB_MODE:
+		return MODE_OFB;
+
+#if OPENSSL_VERSION_NUMBER >= 0x10001000L
+	case EVP_CIPH_CTR_MODE:
+		return MODE_CTR;
+
+	case EVP_CIPH_GCM_MODE:
+		return MODE_GCM;
+
+#endif
+	}
+	throw Poco::IllegalStateException("Unexpected value of EVP_CIPHER_mode()");
+}
+
+
+void CipherKeyImpl::generateKey()
+{
+	ByteVec vec;
+
+	getRandomBytes(vec, keySize());
+	setKey(vec);
+
+	getRandomBytes(vec, ivSize());
+	setIV(vec);
+}
+
+
+void CipherKeyImpl::getRandomBytes(ByteVec& vec, std::size_t count)
+{
+	Poco::RandomInputStream random;
+
+	vec.clear();
+	vec.reserve(count);
+
+	for (int i = 0; i < count; ++i)
+		vec.push_back(static_cast<unsigned char>(random.get()));
+}
+
+
+void CipherKeyImpl::generateKey(
+	const std::string& password,
+	const std::string& salt,
+	int iterationCount)
+{
+	unsigned char keyBytes[EVP_MAX_KEY_LENGTH];
+	unsigned char ivBytes[EVP_MAX_IV_LENGTH];
+
+	// OpenSSL documentation specifies that the salt must be an 8-byte array.
+	unsigned char saltBytes[8];
+
+	if (!salt.empty())
+	{
+		int len = static_cast<int>(salt.size());
+		// Create the salt array from the salt string
+		for (int i = 0; i < 8; ++i)
+			saltBytes[i] = salt.at(i % len);
+		for (int i = 8; i < len; ++i)
+			saltBytes[i % 8] ^= salt.at(i);
+	}
+
+	// Now create the key and IV, using the MD5 digest algorithm.
+	int keySize = EVP_BytesToKey(
+		_pCipher,
+		_pDigest ? _pDigest : EVP_md5(),
+		(salt.empty() ? 0 : saltBytes),
+		reinterpret_cast<const unsigned char*>(password.data()),
+		static_cast<int>(password.size()),
+		iterationCount,
+		keyBytes,
+		ivBytes);
+
+	// Copy the buffers to our member byte vectors.
+	_key.assign(keyBytes, keyBytes + keySize);
+
+	if (ivSize() == 0)
+		_iv.clear();
+	else
+		_iv.assign(ivBytes, ivBytes + ivSize());
+}
+
+
+int CipherKeyImpl::keySize() const
+{
+	return EVP_CIPHER_key_length(_pCipher);
+}
+
+
+int CipherKeyImpl::blockSize() const
+{
+	return EVP_CIPHER_block_size(_pCipher);
+}
+
+
+int CipherKeyImpl::ivSize() const
+{
+	return EVP_CIPHER_iv_length(_pCipher);
+}
+
+
+void CipherKeyImpl::setIV(const ByteVec& iv)
+{
+	poco_assert(mode() == MODE_GCM || iv.size() == static_cast<ByteVec::size_type>(ivSize()));
+	_iv = iv;
+}
+
+
+} } // namespace Poco::Crypto

base/poco/Crypto/src/CryptoException.cpp

@@ -0,0 +1,108 @@
+//
+// CryptoException.cpp
+//
+//
+// Library: Crypto
+// Package: Crypto
+// Module:  CryptoException
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/CryptoException.h"
+#include "Poco/NumberFormatter.h"
+#include <typeinfo>
+#include <openssl/err.h>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+POCO_IMPLEMENT_EXCEPTION(CryptoException, Exception, "Crypto Exception")
+
+
+OpenSSLException::OpenSSLException(int otherCode): CryptoException(otherCode)
+{
+	setExtMessage();
+}
+
+
+OpenSSLException::OpenSSLException(const std::string& msg, int otherCode): CryptoException(msg, otherCode)
+{
+	setExtMessage();
+}
+
+
+OpenSSLException::OpenSSLException(const std::string& msg, const std::string& arg, int otherCode): CryptoException(msg, arg, otherCode)
+{
+	setExtMessage();
+}
+
+
+OpenSSLException::OpenSSLException(const std::string& msg, const Poco::Exception& exc, int otherCode): CryptoException(msg, exc, otherCode)
+{
+	setExtMessage();
+}
+
+
+OpenSSLException::OpenSSLException(const OpenSSLException& exc): CryptoException(exc)
+{
+	setExtMessage();
+}
+
+
+OpenSSLException::~OpenSSLException() throw()
+{
+}
+
+
+OpenSSLException& OpenSSLException::operator = (const OpenSSLException& exc)
+{
+	CryptoException::operator = (exc);
+	return *this;
+}
+
+
+const char* OpenSSLException::name() const throw()
+{
+	return "OpenSSLException";
+}
+
+
+const char* OpenSSLException::className() const throw()
+{
+	return typeid(*this).name();
+}
+
+
+Poco::Exception* OpenSSLException::clone() const
+{
+	return new OpenSSLException(*this);
+}
+
+
+void OpenSSLException::setExtMessage()
+{
+	Poco::UInt64 e = static_cast<Poco::UInt64>(ERR_get_error());
+	char buf[128] = { 0 };
+	char* pErr = ERR_error_string(static_cast<unsigned long>(e), buf);
+	std::string err;
+	if (pErr) err = pErr;
+	else err = NumberFormatter::format(e);
+
+	extendedMessage(err);
+}
+
+
+void OpenSSLException::rethrow() const
+{
+	throw *this;
+}
+
+
+} } // namespace Poco::Crypto

base/poco/Crypto/src/CryptoStream.cpp

@@ -0,0 +1,355 @@
+//
+// CryptoStream.cpp
+//
+// Library: Crypto
+// Package: Cipher
+// Module:  CryptoStream
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/CryptoStream.h"
+#include "Poco/Crypto/CryptoTransform.h"
+#include "Poco/Crypto/Cipher.h"
+#include "Poco/Exception.h"
+#include <algorithm>
+
+
+#undef min
+#undef max
+
+
+namespace Poco {
+namespace Crypto {
+
+
+//
+// CryptoStreamBuf
+//
+
+
+CryptoStreamBuf::CryptoStreamBuf(std::istream& istr, CryptoTransform* pTransform, std::streamsize bufferSize):
+	Poco::BufferedStreamBuf(bufferSize, std::ios::in),
+	_pTransform(pTransform),
+	_pIstr(&istr),
+	_pOstr(0),
+	_eof(false),
+	_buffer(static_cast<std::size_t>(bufferSize))
+{
+	poco_check_ptr (pTransform);
+	poco_assert (bufferSize > 2 * pTransform->blockSize());
+}
+
+
+CryptoStreamBuf::CryptoStreamBuf(std::ostream& ostr, CryptoTransform* pTransform, std::streamsize bufferSize):
+	Poco::BufferedStreamBuf(bufferSize, std::ios::out),
+	_pTransform(pTransform),
+	_pIstr(0),
+	_pOstr(&ostr),
+	_eof(false),
+	_buffer(static_cast<std::size_t>(bufferSize))
+{
+	poco_check_ptr (pTransform);
+	poco_assert (bufferSize > 2 * pTransform->blockSize());
+}
+
+
+CryptoStreamBuf::~CryptoStreamBuf()
+{
+	try
+	{
+		close();
+	}
+	catch (...)
+	{
+	}
+	delete _pTransform;
+}
+
+
+void CryptoStreamBuf::close()
+{
+	sync();
+
+	if (_pIstr)
+	{
+		_pIstr = 0;
+	}
+	else if (_pOstr)
+	{
+		// Close can be called multiple times. By zeroing the pointer we make
+		// sure that we call finalize() only once, even if an exception is
+		// thrown.
+		std::ostream* pOstr = _pOstr;
+		_pOstr = 0;
+		
+		// Finalize transformation.
+		std::streamsize n = _pTransform->finalize(_buffer.begin(), static_cast<std::streamsize>(_buffer.size()));
+		
+		if (n > 0)
+		{
+			pOstr->write(reinterpret_cast<char*>(_buffer.begin()), n);
+			if (!pOstr->good())
+				throw Poco::IOException("Output stream failure");
+		}
+	}
+}
+
+
+int CryptoStreamBuf::readFromDevice(char* buffer, std::streamsize length)
+{
+	if (!_pIstr)
+		return 0;
+
+	int count = 0;
+
+	while (!_eof)
+	{
+		int m = (static_cast<int>(length) - count)/2 - static_cast<int>(_pTransform->blockSize());
+
+		// Make sure we can read at least one more block. Explicitely check
+		// for m < 0 since blockSize() returns an unsigned int and the
+		// comparison might give false results for m < 0.
+		if (m <= 0)
+			break;
+
+		int n = 0;
+
+		if (_pIstr->good())
+		{
+			_pIstr->read(reinterpret_cast<char*>(_buffer.begin()), m);
+			n = static_cast<int>(_pIstr->gcount());
+		}
+
+		if (n == 0)
+		{
+			_eof = true;
+
+			// No more data, finalize transformation
+			count += static_cast<int>(_pTransform->finalize(
+				reinterpret_cast<unsigned char*>(buffer + count),
+				static_cast<int>(length) - count));
+		}
+		else
+		{
+			// Transform next chunk of data
+			count += static_cast<int>(_pTransform->transform(
+				_buffer.begin(),
+				n,
+				reinterpret_cast<unsigned char*>(buffer + count),
+				static_cast<int>(length) - count));
+		}
+	}
+
+	return count;
+}
+
+
+int CryptoStreamBuf::writeToDevice(const char* buffer, std::streamsize length)
+{
+	if (!_pOstr)
+		return 0;
+
+	std::size_t maxChunkSize = _buffer.size()/2;
+	std::size_t count = 0;
+
+	while (count < length)
+	{
+		// Truncate chunk size so that the maximum output fits into _buffer.
+		std::size_t n = static_cast<std::size_t>(length) - count;
+		if (n > maxChunkSize)
+			n = maxChunkSize;
+
+		// Transform next chunk of data
+		std::streamsize k = _pTransform->transform(
+			reinterpret_cast<const unsigned char*>(buffer + count),
+			static_cast<std::streamsize>(n),
+			_buffer.begin(),
+			static_cast<std::streamsize>(_buffer.size()));
+
+		// Attention: (n != k) might be true. In count, we have to track how
+		// many bytes from buffer have been consumed, not how many bytes have
+		// been written to _pOstr!
+		count += n;
+
+		if (k > 0)
+		{
+			_pOstr->write(reinterpret_cast<const char*>(_buffer.begin()), k);
+			if (!_pOstr->good())
+				throw Poco::IOException("Output stream failure");
+		}
+	}
+
+	return static_cast<int>(count);
+}
+
+
+//
+// CryptoIOS
+//
+
+
+CryptoIOS::CryptoIOS(std::istream& istr, CryptoTransform* pTransform, std::streamsize bufferSize):
+	_buf(istr, pTransform, bufferSize)
+{
+	poco_ios_init(&_buf);
+}
+
+
+CryptoIOS::CryptoIOS(std::ostream& ostr, CryptoTransform* pTransform, std::streamsize bufferSize):
+	_buf(ostr, pTransform, bufferSize)
+{
+	poco_ios_init(&_buf);
+}
+
+
+CryptoIOS::~CryptoIOS()
+{
+}
+
+
+CryptoStreamBuf* CryptoIOS::rdbuf()
+{
+	return &_buf;
+}
+
+
+//
+// CryptoInputStream
+//
+
+
+CryptoInputStream::CryptoInputStream(std::istream& istr, CryptoTransform* pTransform, std::streamsize bufferSize):
+	CryptoIOS(istr, pTransform, bufferSize),
+	std::istream(&_buf)
+{
+}
+
+
+CryptoInputStream::CryptoInputStream(std::istream& istr, Cipher& cipher, std::streamsize bufferSize):
+	CryptoIOS(istr, cipher.createEncryptor(), bufferSize),
+	std::istream(&_buf)
+{
+}
+
+
+CryptoInputStream::~CryptoInputStream()
+{
+}
+
+
+//
+// CryptoOutputStream
+//
+
+
+CryptoOutputStream::CryptoOutputStream(std::ostream& ostr, CryptoTransform* pTransform, std::streamsize bufferSize):
+	CryptoIOS(ostr, pTransform, bufferSize),
+	std::ostream(&_buf)
+{
+}
+
+
+CryptoOutputStream::CryptoOutputStream(std::ostream& ostr, Cipher& cipher, std::streamsize bufferSize):
+	CryptoIOS(ostr, cipher.createDecryptor(), bufferSize),
+	std::ostream(&_buf)
+{
+}
+
+
+CryptoOutputStream::~CryptoOutputStream()
+{
+}
+
+
+void CryptoOutputStream::close()
+{
+	_buf.close();
+}
+
+
+//
+// EncryptingInputStream
+//
+
+
+EncryptingInputStream::EncryptingInputStream(std::istream& istr, Cipher& cipher, std::streamsize bufferSize):
+	CryptoIOS(istr, cipher.createEncryptor(), bufferSize),
+	std::istream(&_buf)
+{
+}
+
+
+EncryptingInputStream::~EncryptingInputStream()
+{
+}
+
+
+//
+// EncryptingOuputStream
+//
+
+
+EncryptingOutputStream::EncryptingOutputStream(std::ostream& ostr, Cipher& cipher, std::streamsize bufferSize):
+	CryptoIOS(ostr, cipher.createEncryptor(), bufferSize),
+	std::ostream(&_buf)
+{
+}
+
+
+EncryptingOutputStream::~EncryptingOutputStream()
+{
+}
+
+
+void EncryptingOutputStream::close()
+{
+	_buf.close();
+}
+
+
+//
+// DecryptingInputStream
+//
+
+
+DecryptingInputStream::DecryptingInputStream(std::istream& istr, Cipher& cipher, std::streamsize bufferSize):
+	CryptoIOS(istr, cipher.createDecryptor(), bufferSize),
+	std::istream(&_buf)
+{
+}
+
+
+DecryptingInputStream::~DecryptingInputStream()
+{
+}
+
+
+//
+// DecryptingOuputStream
+//
+
+
+DecryptingOutputStream::DecryptingOutputStream(std::ostream& ostr, Cipher& cipher, std::streamsize bufferSize):
+	CryptoIOS(ostr, cipher.createDecryptor(), bufferSize),
+	std::ostream(&_buf)
+{
+}
+
+
+DecryptingOutputStream::~DecryptingOutputStream()
+{
+}
+
+
+void DecryptingOutputStream::close()
+{
+	_buf.close();
+}
+
+
+} } // namespace Poco::Crypto

base/poco/Crypto/src/CryptoTransform.cpp

@@ -0,0 +1,38 @@
+//
+// CryptoTransform.cpp
+//
+// Library: Crypto
+// Package: Cipher
+// Module:  CryptoTransform
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/CryptoTransform.h"
+
+
+namespace Poco {
+namespace Crypto {
+
+
+CryptoTransform::CryptoTransform()
+{
+}
+
+
+CryptoTransform::~CryptoTransform()
+{
+}
+
+  
+int CryptoTransform::setPadding(int padding)
+{
+	return 1;
+}
+
+
+} } // namespace Poco::Crypto

base/poco/Crypto/src/DigestEngine.cpp

@@ -0,0 +1,80 @@
+//
+// DigestEngine.cpp
+//
+// Library: Crypto
+// Package: Digest
+// Module:  DigestEngine
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/DigestEngine.h"
+#include "Poco/Exception.h"
+
+
+namespace Poco {
+namespace Crypto {
+
+
+DigestEngine::DigestEngine(const std::string& name):
+	_name(name),
+	_pContext(EVP_MD_CTX_create())
+{
+	const EVP_MD* md = EVP_get_digestbyname(_name.c_str());
+	if (!md) throw Poco::NotFoundException(_name);
+	EVP_DigestInit_ex(_pContext, md, NULL);
+}
+
+
+DigestEngine::~DigestEngine()
+{
+	EVP_MD_CTX_destroy(_pContext);
+}
+
+int DigestEngine::nid() const
+{
+	return EVP_MD_type(EVP_MD_CTX_md(_pContext));
+}
+
+std::size_t DigestEngine::digestLength() const
+{
+	return EVP_MD_CTX_size(_pContext);
+}
+
+
+void DigestEngine::reset()
+{
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L && !defined(LIBRESSL_VERSION_NUMBER)
+	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(_pContext, md, NULL);
+}
+
+
+const Poco::DigestEngine::Digest& DigestEngine::digest()
+{
+	_digest.clear();
+	unsigned len = EVP_MD_CTX_size(_pContext);
+	_digest.resize(len);
+	EVP_DigestFinal_ex(_pContext, &_digest[0], &len);
+	reset();
+	return _digest;
+}
+
+
+void DigestEngine::updateImpl(const void* data, std::size_t length)
+{
+	EVP_DigestUpdate(_pContext, data, length);
+}
+
+
+} } // namespace Poco::Crypto

base/poco/Crypto/src/ECDSADigestEngine.cpp

@@ -0,0 +1,100 @@
+//
+// ECDSADigestEngine.cpp
+//
+//
+// Library: Crypto
+// Package: ECDSA
+// Module:  ECDSADigestEngine
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/ECDSADigestEngine.h"
+#include <openssl/ecdsa.h>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+ECDSADigestEngine::ECDSADigestEngine(const ECKey& key, const std::string &name):
+	_key(key),
+	_engine(name)
+{
+}
+
+
+ECDSADigestEngine::~ECDSADigestEngine()
+{
+}
+
+
+std::size_t ECDSADigestEngine::digestLength() const
+{
+	return _engine.digestLength();
+}
+
+
+void ECDSADigestEngine::reset()
+{
+	_engine.reset();
+	_digest.clear();
+	_signature.clear();
+}
+
+	
+const DigestEngine::Digest& ECDSADigestEngine::digest()
+{
+	if (_digest.empty())
+	{
+		_digest = _engine.digest();
+	}
+	return _digest;
+}
+
+
+const DigestEngine::Digest& ECDSADigestEngine::signature()
+{
+	if (_signature.empty())
+	{
+		digest();
+		_signature.resize(_key.size());
+		unsigned sigLen = static_cast<unsigned>(_signature.size());
+		if (!ECDSA_sign(0, &_digest[0], static_cast<unsigned>(_digest.size()),
+			&_signature[0], &sigLen, _key.impl()->getECKey()))
+		{
+			throw OpenSSLException();
+		}
+		if (sigLen < _signature.size()) _signature.resize(sigLen);
+	}
+	return _signature;
+}
+
+
+bool ECDSADigestEngine::verify(const DigestEngine::Digest& sig)
+{
+	digest();
+	EC_KEY* pKey = _key.impl()->getECKey();
+	if (pKey)
+	{
+		int ret = ECDSA_verify(0, &_digest[0], static_cast<unsigned>(_digest.size()),
+			&sig[0], static_cast<unsigned>(sig.size()),
+			pKey);
+		if (1 == ret) return true;
+		else if (0 == ret) return false;
+	}
+	throw OpenSSLException();
+}
+
+
+void ECDSADigestEngine::updateImpl(const void* data, std::size_t length)
+{
+	_engine.update(data, length);
+}
+
+
+} } // namespace Poco::Crypto

base/poco/Crypto/src/ECKey.cpp

@@ -0,0 +1,75 @@
+//
+// ECKey.cpp
+//
+//
+// Library: Crypto
+// Package: EC
+// Module:  ECKey
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/ECKey.h"
+#include <openssl/rsa.h>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+ECKey::ECKey(const EVPPKey& key):
+	KeyPair(new ECKeyImpl(key)),
+	_pImpl(KeyPair::impl().cast<ECKeyImpl>())
+{
+}
+
+
+ECKey::ECKey(const X509Certificate& cert):
+	KeyPair(new ECKeyImpl(cert)),
+	_pImpl(KeyPair::impl().cast<ECKeyImpl>())
+{
+}
+
+
+ECKey::ECKey(const PKCS12Container& cont):
+	KeyPair(new ECKeyImpl(cont)),
+	_pImpl(KeyPair::impl().cast<ECKeyImpl>())
+{
+}
+
+
+ECKey::ECKey(const std::string& eccGroup):
+	KeyPair(new ECKeyImpl(OBJ_txt2nid(eccGroup.c_str()))),
+	_pImpl(KeyPair::impl().cast<ECKeyImpl>())
+{
+}
+
+
+ECKey::ECKey(const std::string& publicKeyFile,
+	const std::string& privateKeyFile,
+	const std::string& privateKeyPassphrase):
+		KeyPair(new ECKeyImpl(publicKeyFile, privateKeyFile, privateKeyPassphrase)),
+		_pImpl(KeyPair::impl().cast<ECKeyImpl>())
+{
+}
+
+
+ECKey::ECKey(std::istream* pPublicKeyStream,
+	std::istream* pPrivateKeyStream,
+	const std::string& privateKeyPassphrase):
+		KeyPair(new ECKeyImpl(pPublicKeyStream, pPrivateKeyStream, privateKeyPassphrase)),
+		_pImpl(KeyPair::impl().cast<ECKeyImpl>())
+{
+}
+
+
+ECKey::~ECKey()
+{
+}
+
+
+} } // namespace Poco::Crypto

base/poco/Crypto/src/ECKeyImpl.cpp

@@ -0,0 +1,258 @@
+//
+// ECKeyImpl.cpp
+//
+//
+// Library: Crypto
+// Package: EC
+// Module:  ECKeyImpl
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/ECKeyImpl.h"
+#include "Poco/Crypto/X509Certificate.h"
+#include "Poco/Crypto/PKCS12Container.h"
+#include "Poco/FileStream.h"
+#include "Poco/Format.h"
+#include "Poco/StreamCopier.h"
+#include <sstream>
+#include <openssl/evp.h>
+#if OPENSSL_VERSION_NUMBER >= 0x00908000L
+#include <openssl/bn.h>
+#endif
+
+
+namespace Poco {
+namespace Crypto {
+
+
+ECKeyImpl::ECKeyImpl(const EVPPKey& key):
+	KeyPairImpl("ec", KT_EC_IMPL),
+	_pEC(EVP_PKEY_get1_EC_KEY(const_cast<EVP_PKEY*>((const EVP_PKEY*)key)))
+{
+	checkEC("ECKeyImpl(const EVPPKey&)", "EVP_PKEY_get1_EC_KEY()");
+}
+
+
+ECKeyImpl::ECKeyImpl(const X509Certificate& cert):
+	KeyPairImpl("ec", KT_EC_IMPL),
+	_pEC(0)
+{
+	const X509* pCert = cert.certificate();
+	if (pCert)
+	{
+		EVP_PKEY* pKey = X509_get_pubkey(const_cast<X509*>(pCert));
+		if (pKey)
+		{
+			_pEC = EVP_PKEY_get1_EC_KEY(pKey);
+			EVP_PKEY_free(pKey);
+			checkEC("ECKeyImpl(const const X509Certificate&)", "EVP_PKEY_get1_EC_KEY()");
+			return;
+		}
+	}
+	throw OpenSSLException("ECKeyImpl(const X509Certificate&)");
+}
+
+
+ECKeyImpl::ECKeyImpl(const PKCS12Container& cont):
+	KeyPairImpl("ec", KT_EC_IMPL),
+	_pEC(EVP_PKEY_get1_EC_KEY(cont.getKey()))
+{
+	checkEC("ECKeyImpl(const PKCS12Container&)", "EVP_PKEY_get1_EC_KEY()");
+}
+
+
+ECKeyImpl::ECKeyImpl(int curve):
+	KeyPairImpl("ec", KT_EC_IMPL),
+	_pEC(EC_KEY_new_by_curve_name(curve))
+{
+	poco_check_ptr(_pEC);
+	EC_KEY_set_asn1_flag(_pEC, OPENSSL_EC_NAMED_CURVE);
+	if (!(EC_KEY_generate_key(_pEC)))
+		throw OpenSSLException("ECKeyImpl(int curve): EC_KEY_generate_key()");
+	checkEC("ECKeyImpl(int curve)", "EC_KEY_generate_key()");
+}
+
+
+ECKeyImpl::ECKeyImpl(const std::string& publicKeyFile, 
+	const std::string& privateKeyFile, 
+	const std::string& privateKeyPassphrase): KeyPairImpl("ec", KT_EC_IMPL), _pEC(0)
+{
+	if (EVPPKey::loadKey(&_pEC, PEM_read_PrivateKey, EVP_PKEY_get1_EC_KEY, privateKeyFile, privateKeyPassphrase))
+	{
+		checkEC(Poco::format("ECKeyImpl(%s, %s, %s)",
+			publicKeyFile, privateKeyFile, privateKeyPassphrase.empty() ? privateKeyPassphrase : std::string("***")),
+			"PEM_read_PrivateKey() or EVP_PKEY_get1_EC_KEY()");
+		return; // private key is enough
+	}
+
+	// no private key, this must be public key only, otherwise throw
+	if (!EVPPKey::loadKey(&_pEC, PEM_read_PUBKEY, EVP_PKEY_get1_EC_KEY, publicKeyFile))
+	{
+		throw OpenSSLException("ECKeyImpl(const string&, const string&, const string&");
+	}
+	checkEC(Poco::format("ECKeyImpl(%s, %s, %s)",
+		publicKeyFile, privateKeyFile, privateKeyPassphrase.empty() ? privateKeyPassphrase : std::string("***")),
+		"PEM_read_PUBKEY() or EVP_PKEY_get1_EC_KEY()");
+}
+
+
+ECKeyImpl::ECKeyImpl(std::istream* pPublicKeyStream,
+	std::istream* pPrivateKeyStream,
+	const std::string& privateKeyPassphrase): KeyPairImpl("ec", KT_EC_IMPL), _pEC(0)
+{
+	if (EVPPKey::loadKey(&_pEC, PEM_read_bio_PrivateKey, EVP_PKEY_get1_EC_KEY, pPrivateKeyStream, privateKeyPassphrase))
+	{
+		checkEC(Poco::format("ECKeyImpl(stream, stream, %s)",
+			privateKeyPassphrase.empty() ? privateKeyPassphrase : std::string("***")),
+			"PEM_read_bio_PrivateKey() or EVP_PKEY_get1_EC_KEY()");
+		return; // private key is enough
+	}
+
+	// no private key, this must be public key only, otherwise throw
+	if (!EVPPKey::loadKey(&_pEC, PEM_read_bio_PUBKEY, EVP_PKEY_get1_EC_KEY, pPublicKeyStream))
+	{
+		throw OpenSSLException("ECKeyImpl(istream*, istream*, const string&");
+	}
+	checkEC(Poco::format("ECKeyImpl(stream, stream, %s)",
+		privateKeyPassphrase.empty() ? privateKeyPassphrase : std::string("***")),
+		"PEM_read_bio_PUBKEY() or EVP_PKEY_get1_EC_KEY()");
+}
+
+
+ECKeyImpl::~ECKeyImpl()
+{
+	freeEC();
+}
+
+
+void ECKeyImpl::checkEC(const std::string& method, const std::string& func) const
+{
+	if (!_pEC) throw OpenSSLException(Poco::format("%s: %s", method, func));
+	if (!EC_KEY_check_key(_pEC))
+		throw OpenSSLException(Poco::format("%s: EC_KEY_check_key()", method));
+}
+
+
+void ECKeyImpl::freeEC()
+{
+	if (_pEC)
+	{
+		EC_KEY_free(_pEC);
+		_pEC = 0;
+	}
+}
+
+
+int ECKeyImpl::size() const
+{
+	int sz = -1;
+	EVP_PKEY* pKey = EVP_PKEY_new();
+	if (pKey && EVP_PKEY_set1_EC_KEY(pKey, _pEC))
+	{
+		sz = EVP_PKEY_bits(pKey);
+		EVP_PKEY_free(pKey);
+		return sz;
+	}
+	throw OpenSSLException("ECKeyImpl::size()");
+}
+
+
+int ECKeyImpl::groupId() const
+{
+	if (_pEC)
+	{
+		const EC_GROUP* ecGroup = EC_KEY_get0_group(_pEC);
+		if (ecGroup)
+		{
+			return EC_GROUP_get_curve_name(ecGroup);
+		}
+		else
+		{
+			throw OpenSSLException("ECKeyImpl::groupName()");
+		}
+	}
+	throw NullPointerException("ECKeyImpl::groupName() => _pEC");
+}
+
+
+std::string ECKeyImpl::getCurveName(int nid)
+{
+	std::string curveName;
+	size_t len = EC_get_builtin_curves(NULL, 0);
+	EC_builtin_curve* pCurves =
+			(EC_builtin_curve*) OPENSSL_malloc(sizeof(EC_builtin_curve) * len);
+	if (!pCurves) return curveName;
+
+	if (!EC_get_builtin_curves(pCurves, len))
+	{
+		OPENSSL_free(pCurves);
+		return curveName;
+	}
+
+	if (-1 == nid) nid = pCurves[0].nid;
+	const int bufLen = 128;
+	char buf[bufLen];
+	std::memset(buf, 0, bufLen);
+	OBJ_obj2txt(buf, bufLen, OBJ_nid2obj(nid), 0);
+	curveName = buf;
+	OPENSSL_free(pCurves);
+	return curveName;
+}
+
+
+int ECKeyImpl::getCurveNID(std::string& name)
+{
+	std::string curveName;
+	size_t len = EC_get_builtin_curves(NULL, 0);
+	EC_builtin_curve* pCurves =
+		(EC_builtin_curve*)OPENSSL_malloc(static_cast<int>(sizeof(EC_builtin_curve) * len));
+	if (!pCurves) return -1;
+
+	if (!EC_get_builtin_curves(pCurves, len))
+	{
+		OPENSSL_free(pCurves);
+		return -1;
+	}
+
+	int nid = -1;
+	const int bufLen = 128;
+	char buf[bufLen];
+	if (name.empty())
+	{
+		std::memset(buf, 0, bufLen);
+		OBJ_obj2txt(buf, bufLen, OBJ_nid2obj(nid), 0);
+		name = buf;
+		nid = pCurves[0].nid;
+	}
+	else
+	{
+		for (int i = 0; i < len; ++i)
+		{
+			std::memset(buf, 0, bufLen);
+			OBJ_obj2txt(buf, bufLen, OBJ_nid2obj(pCurves[i].nid), 0);
+			if (strncmp(name.c_str(), buf, name.size() > bufLen ? bufLen : name.size()) == 0)
+			{
+				nid = pCurves[i].nid;
+				break;
+			}
+		}
+	}
+
+	OPENSSL_free(pCurves);
+	return nid;
+}
+
+
+bool ECKeyImpl::hasCurve(const std::string& name)
+{
+	std::string tmp(name);
+	return (-1 != getCurveNID(tmp));
+}
+
+
+} } // namespace Poco::Crypto

base/poco/Crypto/src/EVPPKey.cpp

@@ -0,0 +1,321 @@
+//
+// EVPPKey.cpp
+//
+//
+// Library: Crypto
+// Package: CryptoCore
+// Module:  EVPPKey
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/EVPPKey.h"
+#include "Poco/Crypto/ECKey.h"
+#include "Poco/Crypto/RSAKey.h"
+#include "Poco/NumberFormatter.h"
+
+
+namespace Poco {
+namespace Crypto {
+
+
+EVPPKey::EVPPKey(const std::string& ecCurveName): _pEVPPKey(0)
+{
+	newECKey(ecCurveName.c_str());
+	poco_check_ptr(_pEVPPKey);
+}
+
+
+EVPPKey::EVPPKey(const char* ecCurveName): _pEVPPKey(0)
+{
+	newECKey(ecCurveName);
+	poco_check_ptr(_pEVPPKey);
+}
+
+
+EVPPKey::EVPPKey(EVP_PKEY* pEVPPKey): _pEVPPKey(0)
+{
+	duplicate(pEVPPKey, &_pEVPPKey);
+	poco_check_ptr(_pEVPPKey);
+}
+
+
+EVPPKey::EVPPKey(const std::string& publicKeyFile,
+	const std::string& privateKeyFile,
+	const std::string& privateKeyPassphrase): _pEVPPKey(0)
+{
+	if (loadKey(&_pEVPPKey, PEM_read_PrivateKey, (EVP_PKEY_get_Key_fn)0, privateKeyFile, privateKeyPassphrase))
+	{
+		poco_check_ptr(_pEVPPKey);
+		return; // private key is enough
+	}
+
+	// no private key, this must be public key only, otherwise throw
+	if (!loadKey(&_pEVPPKey, PEM_read_PUBKEY, (EVP_PKEY_get_Key_fn)0, publicKeyFile))
+	{
+		throw OpenSSLException("ECKeyImpl(const string&, const string&, const string&");
+	}
+	poco_check_ptr(_pEVPPKey);
+}
+
+
+EVPPKey::EVPPKey(std::istream* pPublicKeyStream,
+	std::istream* pPrivateKeyStream,
+	const std::string& privateKeyPassphrase): _pEVPPKey(0)
+{
+	if (loadKey(&_pEVPPKey, PEM_read_bio_PrivateKey, (EVP_PKEY_get_Key_fn)0, pPrivateKeyStream, privateKeyPassphrase))
+	{
+		poco_check_ptr(_pEVPPKey);
+		return; // private key is enough
+	}
+
+	// no private key, this must be public key only, otherwise throw
+	if (!loadKey(&_pEVPPKey, PEM_read_bio_PUBKEY, (EVP_PKEY_get_Key_fn)0, pPublicKeyStream))
+	{
+		throw OpenSSLException("ECKeyImpl(istream*, istream*, const string&");
+	}
+	poco_check_ptr(_pEVPPKey);
+}
+
+
+EVPPKey::EVPPKey(const EVPPKey& other)
+{
+	duplicate(other._pEVPPKey, &_pEVPPKey);
+	poco_check_ptr(_pEVPPKey);
+}
+
+
+EVPPKey& EVPPKey::operator=(const EVPPKey& other)
+{
+	duplicate(other._pEVPPKey, &_pEVPPKey);
+	poco_check_ptr(_pEVPPKey);
+	return *this;
+}
+
+
+#ifdef POCO_ENABLE_CPP11
+
+EVPPKey::EVPPKey(EVPPKey&& other): _pEVPPKey(other._pEVPPKey)
+{
+	other._pEVPPKey = nullptr;
+	poco_check_ptr(_pEVPPKey);
+}
+
+
+EVPPKey& EVPPKey::operator=(EVPPKey&& other)
+{
+	_pEVPPKey = other._pEVPPKey;
+	other._pEVPPKey = nullptr;
+	poco_check_ptr(_pEVPPKey);
+	return *this;
+}
+
+#endif // POCO_ENABLE_CPP11
+
+EVPPKey::~EVPPKey()
+{
+	if (_pEVPPKey) EVP_PKEY_free(_pEVPPKey);
+}
+
+
+void EVPPKey::save(const std::string& publicKeyFile, const std::string& privateKeyFile, const std::string& privateKeyPassphrase) const
+{
+	if (!publicKeyFile.empty() && (publicKeyFile != privateKeyFile))
+	{
+		BIO* bio = BIO_new(BIO_s_file());
+		if (!bio) throw Poco::IOException("Cannot create BIO for writing public key file", publicKeyFile);
+		try
+		{
+			if (BIO_write_filename(bio, const_cast<char*>(publicKeyFile.c_str())))
+			{
+				if (!PEM_write_bio_PUBKEY(bio, _pEVPPKey))
+				{
+					throw Poco::WriteFileException("Failed to write public key to file", publicKeyFile);
+				}
+			}
+			else throw Poco::CreateFileException("Cannot create public key file");
+		}
+		catch (...)
+		{
+			BIO_free(bio);
+			throw;
+		}
+		BIO_free(bio);
+	}
+
+	if (!privateKeyFile.empty())
+	{
+		BIO* bio = BIO_new(BIO_s_file());
+		if (!bio) throw Poco::IOException("Cannot create BIO for writing private key file", privateKeyFile);
+		try
+		{
+			if (BIO_write_filename(bio, const_cast<char*>(privateKeyFile.c_str())))
+			{
+				int rc = 0;
+				if (privateKeyPassphrase.empty())
+				{
+					rc = PEM_write_bio_PrivateKey(bio, _pEVPPKey, 0, 0, 0, 0, 0);
+				}
+				else
+				{
+					rc = PEM_write_bio_PrivateKey(bio, _pEVPPKey, EVP_des_ede3_cbc(),
+						reinterpret_cast<unsigned char*>(const_cast<char*>(privateKeyPassphrase.c_str())),
+						static_cast<int>(privateKeyPassphrase.length()), 0, 0);
+				}
+				if (!rc)
+					throw Poco::FileException("Failed to write private key to file", privateKeyFile);
+			}
+			else throw Poco::CreateFileException("Cannot create private key file", privateKeyFile);
+		}
+		catch (...)
+		{
+			BIO_free(bio);
+			throw;
+		}
+		BIO_free(bio);
+	}
+}
+
+
+void EVPPKey::save(std::ostream* pPublicKeyStream, std::ostream* pPrivateKeyStream, const std::string& privateKeyPassphrase) const
+{
+	if (pPublicKeyStream && (pPublicKeyStream != pPrivateKeyStream))
+	{
+		BIO* bio = BIO_new(BIO_s_mem());
+		if (!bio) throw Poco::IOException("Cannot create BIO for writing public key");
+		if (!PEM_write_bio_PUBKEY(bio, _pEVPPKey))
+		{
+			BIO_free(bio);
+			throw Poco::WriteFileException("Failed to write public key to stream");
+		}
+		char* pData;
+		long size = BIO_get_mem_data(bio, &pData);
+		pPublicKeyStream->write(pData, static_cast<std::streamsize>(size));
+		BIO_free(bio);
+	}
+
+	if (pPrivateKeyStream)
+	{
+		BIO* bio = BIO_new(BIO_s_mem());
+		if (!bio) throw Poco::IOException("Cannot create BIO for writing public key");
+		int rc = 0;
+		if (privateKeyPassphrase.empty())
+			rc = PEM_write_bio_PrivateKey(bio, _pEVPPKey, 0, 0, 0, 0, 0);
+		else
+			rc = PEM_write_bio_PrivateKey(bio, _pEVPPKey, EVP_des_ede3_cbc(),
+				reinterpret_cast<unsigned char*>(const_cast<char*>(privateKeyPassphrase.c_str())),
+				static_cast<int>(privateKeyPassphrase.length()), 0, 0);
+		if (!rc)
+		{
+			BIO_free(bio);
+			throw Poco::FileException("Failed to write private key to stream");
+		}
+		char* pData;
+		long size = BIO_get_mem_data(bio, &pData);
+		pPrivateKeyStream->write(pData, static_cast<std::streamsize>(size));
+		BIO_free(bio);
+	}
+}
+
+
+EVP_PKEY* EVPPKey::duplicate(const EVP_PKEY* pFromKey, EVP_PKEY** pToKey)
+{
+	if (!pFromKey) throw NullPointerException("EVPPKey::duplicate(): "
+		"provided key pointer is null.");
+
+	*pToKey = EVP_PKEY_new();
+	if (!*pToKey) throw NullPointerException("EVPPKey::duplicate(): "
+		"EVP_PKEY_new() returned null.");
+
+	int keyType = type(pFromKey);
+	switch (keyType)
+	{
+		case EVP_PKEY_RSA:
+		{
+			RSA* pRSA = EVP_PKEY_get1_RSA(const_cast<EVP_PKEY*>(pFromKey));
+			if (pRSA)
+			{
+				EVP_PKEY_set1_RSA(*pToKey, pRSA);
+				RSA_free(pRSA);
+			}
+			else throw OpenSSLException("EVPPKey::duplicate(): EVP_PKEY_get1_RSA()");
+			break;
+		}
+		case EVP_PKEY_EC:
+		{
+			EC_KEY* pEC = EVP_PKEY_get1_EC_KEY(const_cast<EVP_PKEY*>(pFromKey));
+			if (pEC)
+			{
+				EVP_PKEY_set1_EC_KEY(*pToKey, pEC);
+				EC_KEY_free(pEC);
+				int cmp = EVP_PKEY_cmp_parameters(*pToKey, pFromKey);
+				if (cmp < 0)
+					throw OpenSSLException("EVPPKey::duplicate(): EVP_PKEY_cmp_parameters()");
+				if (0 == cmp)
+				{
+					if(!EVP_PKEY_copy_parameters(*pToKey, pFromKey))
+						throw OpenSSLException("EVPPKey::duplicate(): EVP_PKEY_copy_parameters()");
+				}
+			}
+			else throw OpenSSLException();
+			break;
+		}
+		default:
+			throw NotImplementedException("EVPPKey:duplicate(); Key type: " +
+				NumberFormatter::format(keyType));
+	}
+
+	return *pToKey;
+}
+
+
+void EVPPKey::newECKey(const char* ecCurveName)
+{
+	int curveID = OBJ_txt2nid(ecCurveName);
+	EC_KEY* pEC = EC_KEY_new_by_curve_name(curveID);
+	if (!pEC) goto err;
+	if (!EC_KEY_generate_key(pEC)) goto err;
+	_pEVPPKey = EVP_PKEY_new();
+	if (!_pEVPPKey) goto err;
+	if (!EVP_PKEY_set1_EC_KEY(_pEVPPKey, pEC)) goto err;
+	EC_KEY_free(pEC);
+	return;
+err:
+	throw OpenSSLException("EVPPKey:newECKey()");
+}
+
+
+void EVPPKey::setKey(ECKey* pKey)
+{
+	poco_check_ptr(pKey);
+	poco_check_ptr(pKey->impl());
+	setKey(pKey->impl()->getECKey());
+}
+
+
+void EVPPKey::setKey(RSAKey* pKey)
+{
+	poco_check_ptr(pKey);
+	poco_check_ptr(pKey->impl());
+	setKey(pKey->impl()->getRSA());
+}
+
+
+int EVPPKey::passCB(char* buf, int size, int, void* pass)
+{
+	if (pass)
+	{
+		int len = (int)std::strlen((char*)pass);
+		if(len > size) len = size;
+		std::memcpy(buf, pass, len);
+		return len;
+	}
+	return 0;
+}
+
+
+} } // namespace Poco::Crypto

base/poco/Crypto/src/KeyPair.cpp

@@ -0,0 +1,34 @@
+//
+// KeyPair.cpp
+//
+//
+// Library: Crypto
+// Package: CryptoCore
+// Module:  KeyPair
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/KeyPair.h"
+#include <openssl/rsa.h>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+KeyPair::KeyPair(KeyPairImpl::Ptr pKeyPairImpl): _pImpl(pKeyPairImpl)
+{
+}
+
+
+KeyPair::~KeyPair()
+{
+}
+
+
+} } // namespace Poco::Crypto

base/poco/Crypto/src/KeyPairImpl.cpp

@@ -0,0 +1,35 @@
+//
+// KeyPairImpl.cpp
+//
+//
+// Library: Crypto
+// Package: CryptoCore
+// Module:  KeyPairImpl
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/KeyPairImpl.h"
+
+
+namespace Poco {
+namespace Crypto {
+
+
+KeyPairImpl::KeyPairImpl(const std::string& name, Type type):
+	_name(name),
+	_type(type)
+{
+}
+
+
+KeyPairImpl::~KeyPairImpl()
+{
+}
+
+
+} } // namespace Poco::Crypto

base/poco/Crypto/src/OpenSSLInitializer.cpp

@@ -0,0 +1,190 @@
+//
+// OpenSSLInitializer.cpp
+//
+// Library: Crypto
+// Package: CryptoCore
+// Module:  OpenSSLInitializer
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/OpenSSLInitializer.h"
+#include "Poco/RandomStream.h"
+#include "Poco/Thread.h"
+#include <openssl/ssl.h>
+#include <openssl/rand.h>
+#include <openssl/crypto.h>
+#include <openssl/err.h>
+#if OPENSSL_VERSION_NUMBER >= 0x0907000L
+#include <openssl/conf.h>
+#endif
+#if defined(POCO_OS_FAMILY_WINDOWS)
+	#define POCO_STR_HELPER(x) #x
+	#define POCO_STR(x) POCO_STR_HELPER(x)
+	#if defined POCO_INTERNAL_OPENSSL_MSVC_VER
+		#define POCO_INTERNAL_OPENSSL_BUILD          \
+				" (POCO internal build, MSVC version " \
+				POCO_STR(POCO_INTERNAL_OPENSSL_MSVC_VER) ")"
+	#else
+		#define POCO_INTERNAL_OPENSSL_BUILD ""
+	#endif
+	#pragma message (OPENSSL_VERSION_TEXT POCO_INTERNAL_OPENSSL_BUILD)
+#endif
+
+
+using Poco::RandomInputStream;
+using Poco::Thread;
+
+
+#if defined(_MSC_VER) && !defined(_DLL) && defined(POCO_INTERNAL_OPENSSL_MSVC_VER)
+
+	#if (POCO_MSVS_VERSION >= 2015)
+		FILE _iob[] = { *stdin, *stdout, *stderr };
+		extern "C" FILE * __cdecl __iob_func(void) { return _iob; }
+	#endif // (POCO_MSVS_VERSION >= 2015)
+
+	#if (POCO_MSVS_VERSION < 2012)
+		extern "C" __declspec(noreturn) void __cdecl __report_rangecheckfailure(void) { ::ExitProcess(1); }
+	#endif // (POCO_MSVS_VERSION < 2012)
+
+#endif // _MSC_VER && _MT && !POCO_EXTERNAL_OPENSSL && (POCO_MSVS_VERSION < 2013)
+
+
+namespace Poco {
+namespace Crypto {
+
+
+Poco::FastMutex* OpenSSLInitializer::_mutexes(0);
+Poco::AtomicCounter OpenSSLInitializer::_rc;
+
+
+OpenSSLInitializer::OpenSSLInitializer()
+{
+	initialize();
+}
+
+
+OpenSSLInitializer::~OpenSSLInitializer()
+{
+	try
+	{
+		uninitialize();
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+void OpenSSLInitializer::initialize()
+{
+	if (++_rc == 1)
+	{
+#if OPENSSL_VERSION_NUMBER >= 0x0907000L
+		OPENSSL_config(NULL);
+#endif
+		SSL_library_init();
+		SSL_load_error_strings();
+		OpenSSL_add_all_algorithms();
+		
+		char seed[SEEDSIZE];
+		RandomInputStream rnd;
+		rnd.read(seed, sizeof(seed));
+		RAND_seed(seed, SEEDSIZE);
+		
+		int nMutexes = CRYPTO_num_locks();
+		_mutexes = new Poco::FastMutex[nMutexes];
+		CRYPTO_set_locking_callback(&OpenSSLInitializer::lock);
+#ifndef POCO_OS_FAMILY_WINDOWS
+// Not needed on Windows (see SF #110: random unhandled exceptions when linking with ssl).
+// https://sourceforge.net/p/poco/bugs/110/
+//
+// From http://www.openssl.org/docs/crypto/threads.html :
+// "If the application does not register such a callback using CRYPTO_THREADID_set_callback(), 
+//  then a default implementation is used - on Windows and BeOS this uses the system's 
+//  default thread identifying APIs"
+		CRYPTO_set_id_callback(&OpenSSLInitializer::id);
+#endif
+		CRYPTO_set_dynlock_create_callback(&OpenSSLInitializer::dynlockCreate);
+		CRYPTO_set_dynlock_lock_callback(&OpenSSLInitializer::dynlock);
+		CRYPTO_set_dynlock_destroy_callback(&OpenSSLInitializer::dynlockDestroy);
+	}
+}
+
+
+void OpenSSLInitializer::uninitialize()
+{
+	if (--_rc == 0)
+	{
+		EVP_cleanup();
+		ERR_free_strings();
+		CRYPTO_set_locking_callback(0);
+#ifndef POCO_OS_FAMILY_WINDOWS
+		CRYPTO_set_id_callback(0);
+#endif
+		delete [] _mutexes;
+		
+		CONF_modules_free();
+	}
+}
+
+
+void OpenSSLInitializer::lock(int mode, int n, const char* file, int line)
+{
+	if (mode & CRYPTO_LOCK)
+		_mutexes[n].lock();
+	else
+		_mutexes[n].unlock();
+}
+
+
+unsigned long OpenSSLInitializer::id()
+{
+	// Note: we use an old-style C cast here because
+	// neither static_cast<> nor reinterpret_cast<>
+	// work uniformly across all platforms.
+	return (unsigned long) Poco::Thread::currentTid();
+}
+
+
+struct CRYPTO_dynlock_value* OpenSSLInitializer::dynlockCreate(const char* file, int line)
+{
+	return new CRYPTO_dynlock_value;
+}
+
+
+void OpenSSLInitializer::dynlock(int mode, struct CRYPTO_dynlock_value* lock, const char* file, int line)
+{
+	poco_check_ptr (lock);
+
+	if (mode & CRYPTO_LOCK)
+		lock->_mutex.lock();
+	else
+		lock->_mutex.unlock();
+}
+
+
+void OpenSSLInitializer::dynlockDestroy(struct CRYPTO_dynlock_value* lock, const char* file, int line)
+{
+	delete lock;
+}
+
+
+void initializeCrypto()
+{
+	OpenSSLInitializer::initialize();
+}
+
+
+void uninitializeCrypto()
+{
+	OpenSSLInitializer::uninitialize();
+}
+
+
+} } // namespace Poco::Crypto

base/poco/Crypto/src/PKCS12Container.cpp

@@ -0,0 +1,191 @@
+//
+// PKCS12Container.cpp
+//
+//
+// Library: Crypto
+// Package: Certificate
+// Module:  PKCS12Container
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/PKCS12Container.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/StreamCopier.h"
+#include <sstream>
+#include <openssl/err.h>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+PKCS12Container::PKCS12Container(std::istream& istr, const std::string& password): _pKey(0)
+{
+	std::ostringstream ostr;
+	Poco::StreamCopier::copyStream(istr, ostr);
+	const std::string& cont = ostr.str();
+
+	BIO *pBIO = BIO_new_mem_buf(const_cast<char*>(cont.data()), static_cast<int>(cont.size()));
+	if (pBIO)
+	{
+		PKCS12* pPKCS12 = 0;
+		d2i_PKCS12_bio(pBIO, &pPKCS12);
+		BIO_free(pBIO);
+		if (!pPKCS12) throw OpenSSLException("PKCS12Container(istream&, const string&)");
+		load(pPKCS12, password);
+	}
+	else
+	{
+		throw Poco::NullPointerException("PKCS12Container(istream&, const string&)");
+	}
+}
+
+
+PKCS12Container::PKCS12Container(const std::string& path, const std::string& password): _pKey(0)
+{
+	FILE* pFile = fopen(path.c_str(), "rb");
+	if (pFile)
+	{
+		PKCS12* pPKCS12 = d2i_PKCS12_fp(pFile, NULL);
+		fclose (pFile);
+		if (!pPKCS12) throw OpenSSLException("PKCS12Container(const string&, const string&)");
+		load(pPKCS12, password);
+	}
+	else
+	{
+		throw Poco::OpenFileException("PKCS12Container: " + path);
+	}
+}
+
+
+PKCS12Container::PKCS12Container(const PKCS12Container& other):
+	_pKey(EVPPKey::duplicate(other._pKey, &_pKey)),
+	_pX509Cert(new X509Certificate(*other._pX509Cert)),
+	_caCertList(other._caCertList),
+	_caCertNames(other._caCertNames),
+	_pkcsFriendlyName(other._pkcsFriendlyName)
+{
+}
+
+
+PKCS12Container& PKCS12Container::operator = (const PKCS12Container& other)
+{
+	if (&other != this)
+	{
+		if (_pKey) EVP_PKEY_free(_pKey);
+		_pKey = EVPPKey::duplicate(other._pKey, &_pKey);
+		_pX509Cert.reset(new X509Certificate(*other._pX509Cert));
+		_caCertList = other._caCertList;
+		_caCertNames = other._caCertNames;
+		_pkcsFriendlyName = other._pkcsFriendlyName;
+	}
+	return *this;
+}
+
+
+#ifdef POCO_ENABLE_CPP11
+
+
+PKCS12Container::PKCS12Container(PKCS12Container&& other):
+	_pKey(other._pKey),
+	_pX509Cert(std::move(other._pX509Cert)),
+	_caCertList(std::move(other._caCertList)),
+	_caCertNames(std::move(other._caCertNames)),
+	_pkcsFriendlyName(std::move(other._pkcsFriendlyName))
+{
+	other._pKey = 0;
+}
+
+
+PKCS12Container& PKCS12Container::operator = (PKCS12Container&& other)
+{
+	if (&other != this)
+	{
+		if (_pKey) EVP_PKEY_free(_pKey);
+		_pKey = other._pKey; other._pKey = 0;
+		_pX509Cert = std::move(other._pX509Cert);
+		_caCertList = std::move(other._caCertList);
+		_caCertNames = std::move(other._caCertNames);
+		_pkcsFriendlyName = std::move(other._pkcsFriendlyName);
+	}
+	return *this;
+}
+
+
+#endif // POCO_ENABLE_CPP11
+
+
+PKCS12Container::~PKCS12Container()
+{
+	if (_pKey) EVP_PKEY_free(_pKey);
+}
+
+
+std::string PKCS12Container::extractFriendlyName(X509* pCert)
+{
+	std::string friendlyName;
+	if(!pCert) throw NullPointerException("PKCS12Container::extractFriendlyName(X509)");
+
+	// This is how PKCS12_add_cert() sets friendlyName (via PKCS12_add_friendlyname())
+	int namelen = 0;
+	char *name = (char *)X509_alias_get0(pCert, &namelen);
+
+	friendlyName = std::string(name, namelen);
+	return friendlyName;
+}
+
+
+void PKCS12Container::load(PKCS12* pPKCS12, const std::string& password)
+{
+	if (pPKCS12)
+	{
+		X509* pCert = 0;
+		STACK_OF(X509)* pCA = 0;
+		if (PKCS12_parse(pPKCS12, password.c_str(), &_pKey, &pCert, &pCA))
+		{
+			if (pCert)
+			{
+				_pX509Cert.reset(new X509Certificate(pCert, true));
+				_pkcsFriendlyName = extractFriendlyName(pCert);
+			}
+			else _pX509Cert.reset();
+
+			_caCertList.clear();
+			_caCertNames.clear();
+			if (pCA)
+			{
+				int certCount = sk_X509_num(pCA);
+				for (int i = 0; i < certCount; ++i)
+				{
+					X509* pX509 = sk_X509_value(pCA, i);
+					if (pX509)
+					{
+						_caCertList.push_back(X509Certificate(pX509, true));
+						_caCertNames.push_back(extractFriendlyName(pX509));
+					}
+					else throw OpenSSLException("PKCS12Container::load()");
+				}
+			}
+		}
+		else
+		{
+			throw OpenSSLException();
+		}
+		PKCS12_free(pPKCS12);
+		sk_X509_pop_free(pCA, X509_free);
+		if (pCert) X509_free(pCert);
+		poco_assert_dbg (_caCertList.size() == _caCertNames.size());
+	}
+	else
+	{
+		throw NullPointerException("PKCS12Container: struct PKCS12");
+	}
+}
+
+
+} } // namespace Poco::Crypto

base/poco/Crypto/src/RSACipherImpl.cpp

@@ -0,0 +1,342 @@
+//
+// RSACipherImpl.cpp
+//
+// Library: Crypto
+// Package: RSA
+// Module:  RSACipherImpl
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/RSACipherImpl.h"
+#include "Poco/Crypto/CryptoTransform.h"
+#include "Poco/Exception.h"
+#include <openssl/err.h>
+#include <openssl/rsa.h>
+#include <cstring>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+namespace
+{
+	void throwError()
+	{
+		unsigned long err;
+		std::string msg;
+
+		while ((err = ERR_get_error()))
+		{
+			if (!msg.empty())
+				msg.append("; ");
+			msg.append(ERR_error_string(err, 0));
+		}
+
+		throw Poco::IOException(msg);
+	}
+
+
+	int mapPaddingMode(RSAPaddingMode paddingMode)
+	{
+		switch (paddingMode)
+		{
+		case RSA_PADDING_PKCS1:
+			return RSA_PKCS1_PADDING;
+		case RSA_PADDING_PKCS1_OAEP:
+			return RSA_PKCS1_OAEP_PADDING;
+		case RSA_PADDING_NONE:
+			return RSA_NO_PADDING;
+		default:
+			poco_bugcheck();
+			return RSA_NO_PADDING;
+		}
+	}
+
+
+	class RSAEncryptImpl: public CryptoTransform
+	{
+	public:
+		RSAEncryptImpl(const RSA* pRSA, RSAPaddingMode paddingMode);
+		~RSAEncryptImpl();
+
+		std::size_t blockSize() const;
+		std::size_t maxDataSize() const;
+		std::string getTag(std::size_t);
+		void setTag(const std::string&);
+
+		std::streamsize transform(
+			const unsigned char* input,
+			std::streamsize		 inputLength,
+			unsigned char*		 output,
+			std::streamsize		 outputLength);
+
+		std::streamsize finalize(unsigned char*	output, std::streamsize length);
+
+	private:
+		const RSA*      _pRSA;
+		RSAPaddingMode  _paddingMode;
+		std::streamsize _pos;
+		unsigned char*  _pBuf;
+	};
+
+
+	RSAEncryptImpl::RSAEncryptImpl(const RSA* pRSA, RSAPaddingMode paddingMode):
+			_pRSA(pRSA),
+			_paddingMode(paddingMode),
+			_pos(0),
+			_pBuf(0)
+	{
+		_pBuf = new unsigned char[blockSize()];
+	}
+
+
+	RSAEncryptImpl::~RSAEncryptImpl()
+	{
+		delete [] _pBuf;
+	}
+
+
+	std::size_t RSAEncryptImpl::blockSize() const
+	{
+		return RSA_size(_pRSA);
+	}
+
+
+	std::size_t RSAEncryptImpl::maxDataSize() const
+	{
+		std::size_t size = blockSize();
+		switch (_paddingMode)
+		{
+		case RSA_PADDING_PKCS1:
+		case RSA_PADDING_SSLV23:
+			size -= 11;
+			break;
+		case RSA_PADDING_PKCS1_OAEP:
+			size -= 41;
+			break;
+		default:
+			break;
+		}
+		return size;
+	}
+
+
+	std::string RSAEncryptImpl::getTag(std::size_t)
+	{
+		return std::string();
+	}
+
+
+	void RSAEncryptImpl::setTag(const std::string&)
+	{
+	}
+
+
+	std::streamsize RSAEncryptImpl::transform(
+		const unsigned char* input,
+		std::streamsize		 inputLength,
+		unsigned char*		 output,
+		std::streamsize		 outputLength)
+	{
+		// always fill up the buffer before writing!
+		std::streamsize maxSize = static_cast<std::streamsize>(maxDataSize());
+		std::streamsize rsaSize = static_cast<std::streamsize>(blockSize());
+		poco_assert_dbg(_pos <= maxSize);
+		poco_assert (outputLength >= rsaSize);
+		int rc = 0;
+		while (inputLength > 0)
+		{
+			// check how many data bytes we are missing to get the buffer full
+			poco_assert_dbg (maxSize >= _pos);
+			std::streamsize missing = maxSize - _pos;
+			if (missing == 0)
+			{
+				poco_assert (outputLength >= rsaSize);
+				int n = RSA_public_encrypt(static_cast<int>(maxSize), _pBuf, output, const_cast<RSA*>(_pRSA), mapPaddingMode(_paddingMode));
+				if (n == -1)
+					throwError();
+				rc += n;
+				output += n;
+				outputLength -= n;
+				_pos = 0;
+
+			}
+			else
+			{
+				if (missing > inputLength)
+					missing = inputLength;
+
+				std::memcpy(_pBuf + _pos, input, static_cast<std::size_t>(missing));
+				input += missing;
+				_pos += missing;
+				inputLength -= missing;
+			}
+		}
+		return rc;
+	}
+
+
+	std::streamsize RSAEncryptImpl::finalize(unsigned char*	output, std::streamsize length)
+	{
+		poco_assert (length >= blockSize());
+		poco_assert (_pos <= maxDataSize());
+		int rc = 0;
+		if (_pos > 0)
+		{
+			rc = RSA_public_encrypt(static_cast<int>(_pos), _pBuf, output, const_cast<RSA*>(_pRSA), mapPaddingMode(_paddingMode));
+			if (rc == -1) throwError();
+		}
+		return rc;
+	}
+
+
+	class RSADecryptImpl: public CryptoTransform
+	{
+	public:
+		RSADecryptImpl(const RSA* pRSA, RSAPaddingMode paddingMode);
+		~RSADecryptImpl();
+
+		std::size_t blockSize() const;
+		std::string getTag(std::size_t);
+		void setTag(const std::string&);
+
+		std::streamsize transform(
+			const unsigned char* input,
+			std::streamsize		 inputLength,
+			unsigned char*		 output,
+			std::streamsize		 outputLength);
+
+		std::streamsize finalize(
+			unsigned char*	output,
+			std::streamsize length);
+
+	private:
+		const RSA*      _pRSA;
+		RSAPaddingMode  _paddingMode;
+		std::streamsize _pos;
+		unsigned char*  _pBuf;
+	};
+
+
+	RSADecryptImpl::RSADecryptImpl(const RSA* pRSA, RSAPaddingMode paddingMode):
+			_pRSA(pRSA),
+			_paddingMode(paddingMode),
+			_pos(0),
+			_pBuf(0)
+	{
+		_pBuf = new unsigned char[blockSize()];
+	}
+
+
+	RSADecryptImpl::~RSADecryptImpl()
+	{
+		delete [] _pBuf;
+	}
+
+
+	std::size_t RSADecryptImpl::blockSize() const
+	{
+		return RSA_size(_pRSA);
+	}
+
+
+	std::string RSADecryptImpl::getTag(std::size_t)
+	{
+		return std::string();
+	}
+
+
+	void RSADecryptImpl::setTag(const std::string&)
+	{
+	}
+
+
+	std::streamsize RSADecryptImpl::transform(
+		const unsigned char* input,
+		std::streamsize		 inputLength,
+		unsigned char*		 output,
+		std::streamsize		 outputLength)
+	{
+
+		// always fill up the buffer before decrypting!
+		std::streamsize rsaSize = static_cast<std::streamsize>(blockSize());
+		poco_assert_dbg(_pos <= rsaSize);
+		poco_assert (outputLength >= rsaSize);
+		int rc = 0;
+		while (inputLength > 0)
+		{
+			// check how many data bytes we are missing to get the buffer full
+			poco_assert_dbg (rsaSize >= _pos);
+			std::streamsize missing = rsaSize - _pos;
+			if (missing == 0)
+			{
+				int tmp = RSA_private_decrypt(static_cast<int>(rsaSize), _pBuf, output, const_cast<RSA*>(_pRSA), mapPaddingMode(_paddingMode));
+				if (tmp == -1)
+					throwError();
+				rc += tmp;
+				output += tmp;
+				outputLength -= tmp;
+				_pos = 0;
+
+			}
+			else
+			{
+				if (missing > inputLength)
+					missing = inputLength;
+
+				std::memcpy(_pBuf + _pos, input, static_cast<std::size_t>(missing));
+				input += missing;
+				_pos += missing;
+				inputLength -= missing;
+			}
+		}
+		return rc;
+	}
+
+
+	std::streamsize RSADecryptImpl::finalize(unsigned char*	output, std::streamsize length)
+	{
+		poco_assert (length >= blockSize());
+		int rc = 0;
+		if (_pos > 0)
+		{
+			rc = RSA_private_decrypt(static_cast<int>(_pos), _pBuf, output, const_cast<RSA*>(_pRSA), mapPaddingMode(_paddingMode));
+			if (rc == -1)
+				throwError();
+		}
+		return rc;
+	}
+}
+
+
+RSACipherImpl::RSACipherImpl(const RSAKey& key, RSAPaddingMode paddingMode):
+	_key(key),
+	_paddingMode(paddingMode)
+{
+}
+
+
+RSACipherImpl::~RSACipherImpl()
+{
+}
+
+
+CryptoTransform* RSACipherImpl::createEncryptor()
+{
+	return new RSAEncryptImpl(_key.impl()->getRSA(), _paddingMode);
+}
+
+
+CryptoTransform* RSACipherImpl::createDecryptor()
+{
+	return new RSADecryptImpl(_key.impl()->getRSA(), _paddingMode);
+}
+
+
+} } // namespace Poco::Crypto

base/poco/Crypto/src/RSADigestEngine.cpp

@@ -0,0 +1,96 @@
+//
+// RSADigestEngine.cpp
+//
+// Library: Crypto
+// Package: RSA
+// Module:  RSADigestEngine
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/RSADigestEngine.h"
+#include <openssl/rsa.h>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+RSADigestEngine::RSADigestEngine(const RSAKey& key, DigestType digestType):
+	_key(key),
+	_engine(digestType == DIGEST_MD5 ? "MD5" : "SHA1")
+{
+}
+
+RSADigestEngine::RSADigestEngine(const RSAKey& key, const std::string &name):
+	_key(key),
+	_engine(name)
+{
+}
+
+
+RSADigestEngine::~RSADigestEngine()
+{
+}
+
+
+std::size_t RSADigestEngine::digestLength() const
+{
+	return _engine.digestLength();
+}
+
+
+void RSADigestEngine::reset()
+{
+	_engine.reset();
+	_digest.clear();
+	_signature.clear();
+}
+
+	
+const DigestEngine::Digest& RSADigestEngine::digest()
+{
+	if (_digest.empty())
+	{
+		_digest = _engine.digest();
+	}
+	return _digest;
+}
+
+
+const DigestEngine::Digest& RSADigestEngine::signature()
+{
+	if (_signature.empty())
+	{
+		digest();
+		_signature.resize(_key.size());
+		unsigned sigLen = static_cast<unsigned>(_signature.size());
+		RSA_sign(_engine.nid(), &_digest[0], static_cast<unsigned>(_digest.size()), &_signature[0], &sigLen, _key.impl()->getRSA());
+		// truncate _sig to sigLen
+		if (sigLen < _signature.size())
+			_signature.resize(sigLen);
+	}
+    return _signature;
+}
+
+	
+bool RSADigestEngine::verify(const DigestEngine::Digest& sig)
+{
+	digest();
+	DigestEngine::Digest sigCpy = sig; // copy becausse RSA_verify can modify sigCpy
+	int ret = RSA_verify(_engine.nid(), &_digest[0], static_cast<unsigned>(_digest.size()), &sigCpy[0], static_cast<unsigned>(sigCpy.size()), _key.impl()->getRSA());
+	return ret != 0;
+}
+
+
+void RSADigestEngine::updateImpl(const void* data, std::size_t length)
+{
+	_engine.update(data, length);
+}
+
+
+} } // namespace Poco::Crypto

base/poco/Crypto/src/RSAKey.cpp

@@ -0,0 +1,87 @@
+//
+// RSAKey.cpp
+//
+// Library: Crypto
+// Package: RSA
+// Module:  RSAKey
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/RSAKey.h"
+#include <openssl/rsa.h>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+RSAKey::RSAKey(const EVPPKey& key):
+	KeyPair(new RSAKeyImpl(key)),
+	_pImpl(KeyPair::impl().cast<RSAKeyImpl>())
+{
+}
+
+
+RSAKey::RSAKey(const X509Certificate& cert):
+	KeyPair(new RSAKeyImpl(cert)),
+	_pImpl(KeyPair::impl().cast<RSAKeyImpl>())
+{
+}
+
+
+RSAKey::RSAKey(const PKCS12Container& cont):
+	KeyPair(new RSAKeyImpl(cont)),
+	_pImpl(KeyPair::impl().cast<RSAKeyImpl>())
+{
+}
+
+
+RSAKey::RSAKey(KeyLength keyLength, Exponent exp):
+	KeyPair(new RSAKeyImpl(keyLength, (exp == EXP_LARGE) ? RSA_F4 : RSA_3)),
+	_pImpl(KeyPair::impl().cast<RSAKeyImpl>())
+{
+}
+
+
+RSAKey::RSAKey(const std::string& publicKeyFile, const std::string& privateKeyFile, const std::string& privateKeyPassphrase):
+	KeyPair(new RSAKeyImpl(publicKeyFile, privateKeyFile, privateKeyPassphrase)),
+	_pImpl(KeyPair::impl().cast<RSAKeyImpl>())
+{
+}
+
+
+RSAKey::RSAKey(std::istream* pPublicKeyStream, std::istream* pPrivateKeyStream, const std::string& privateKeyPassphrase):
+	KeyPair(new RSAKeyImpl(pPublicKeyStream, pPrivateKeyStream, privateKeyPassphrase)),
+	_pImpl(KeyPair::impl().cast<RSAKeyImpl>())
+{
+}
+
+
+RSAKey::~RSAKey()
+{
+}
+
+RSAKeyImpl::ByteVec RSAKey::modulus() const
+{
+	return _pImpl->modulus();
+}
+
+
+RSAKeyImpl::ByteVec RSAKey::encryptionExponent() const
+{
+	return _pImpl->encryptionExponent();
+}
+
+
+RSAKeyImpl::ByteVec RSAKey::decryptionExponent() const
+{
+	return _pImpl->decryptionExponent();
+}
+
+
+} } // namespace Poco::Crypto

base/poco/Crypto/src/RSAKeyImpl.cpp

@@ -0,0 +1,386 @@
+//
+// RSAKeyImpl.cpp
+//
+// Library: Crypto
+// Package: RSA
+// Module:  RSAKeyImpl
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/RSAKeyImpl.h"
+#include "Poco/Crypto/X509Certificate.h"
+#include "Poco/Crypto/PKCS12Container.h"
+#include "Poco/FileStream.h"
+#include "Poco/StreamCopier.h"
+#include <sstream>
+#include <openssl/pem.h>
+#include <openssl/rsa.h>
+#include <openssl/evp.h>
+#if OPENSSL_VERSION_NUMBER >= 0x00908000L
+#include <openssl/bn.h>
+#endif
+
+
+namespace Poco {
+namespace Crypto {
+
+
+RSAKeyImpl::RSAKeyImpl(const EVPPKey& key):
+	KeyPairImpl("rsa", KT_RSA_IMPL),
+	_pRSA(EVP_PKEY_get1_RSA(const_cast<EVP_PKEY*>((const EVP_PKEY*)key)))
+{
+	if (!_pRSA) throw OpenSSLException();
+}
+
+
+RSAKeyImpl::RSAKeyImpl(const X509Certificate& cert):
+	KeyPairImpl("rsa", KT_RSA_IMPL),
+	_pRSA(0)
+{
+	const X509* pCert = cert.certificate();
+	EVP_PKEY* pKey = X509_get_pubkey(const_cast<X509*>(pCert));
+	if (pKey)
+	{
+		_pRSA = EVP_PKEY_get1_RSA(pKey);
+		EVP_PKEY_free(pKey);
+	}
+	else
+		throw OpenSSLException("RSAKeyImpl(const X509Certificate&)");
+}
+
+
+RSAKeyImpl::RSAKeyImpl(const PKCS12Container& cont):
+	KeyPairImpl("rsa", KT_RSA_IMPL),
+	_pRSA(0)
+{
+	EVPPKey key = cont.getKey();
+	_pRSA = EVP_PKEY_get1_RSA(key);
+}
+
+
+RSAKeyImpl::RSAKeyImpl(int keyLength, unsigned long exponent): KeyPairImpl("rsa", KT_RSA_IMPL),
+	_pRSA(0)
+{
+#if OPENSSL_VERSION_NUMBER >= 0x00908000L
+	_pRSA = RSA_new();
+	int ret = 0;
+	BIGNUM* bn = 0;
+	try
+	{
+		bn = BN_new();
+		BN_set_word(bn, exponent);
+		ret = RSA_generate_key_ex(_pRSA, keyLength, bn, 0);
+		BN_free(bn);
+	}
+	catch (...)
+	{
+		BN_free(bn);
+		throw;
+	}
+	if (!ret) throw Poco::InvalidArgumentException("Failed to create RSA context");
+#else
+	_pRSA = RSA_generate_key(keyLength, exponent, 0, 0);
+	if (!_pRSA) throw Poco::InvalidArgumentException("Failed to create RSA context");
+#endif
+}
+
+
+RSAKeyImpl::RSAKeyImpl(const std::string& publicKeyFile, 
+	const std::string& privateKeyFile, 
+	const std::string& privateKeyPassphrase): KeyPairImpl("rsa", KT_RSA_IMPL),
+		_pRSA(0)
+{
+	poco_assert_dbg(_pRSA == 0);
+
+	_pRSA = RSA_new();
+	if (!publicKeyFile.empty())
+	{
+		BIO* bio = BIO_new(BIO_s_file());
+		if (!bio) throw Poco::IOException("Cannot create BIO for reading public key", publicKeyFile);
+		int rc = BIO_read_filename(bio, publicKeyFile.c_str());
+		if (rc)
+		{
+			RSA* pubKey = PEM_read_bio_RSAPublicKey(bio, &_pRSA, 0, 0);
+			if (!pubKey)
+			{
+				int rc = BIO_reset(bio);
+				// BIO_reset() normally returns 1 for success and 0 or -1 for failure. 
+				// File BIOs are an exception, they return 0 for success and -1 for failure.
+				if (rc != 0) throw Poco::FileException("Failed to load public key", publicKeyFile);
+				pubKey = PEM_read_bio_RSA_PUBKEY(bio, &_pRSA, 0, 0);
+			}
+			BIO_free(bio);
+			if (!pubKey)
+			{
+				freeRSA();
+				throw Poco::FileException("Failed to load public key", publicKeyFile);
+			}
+		}
+		else
+		{
+			freeRSA();
+			throw Poco::FileNotFoundException("Public key file", publicKeyFile);
+		}
+	}
+
+	if (!privateKeyFile.empty())
+	{
+		BIO* bio = BIO_new(BIO_s_file());
+		if (!bio) throw Poco::IOException("Cannot create BIO for reading private key", privateKeyFile);
+		int rc = BIO_read_filename(bio, privateKeyFile.c_str());
+		if (rc)
+		{
+			RSA* privKey = 0;
+			if (privateKeyPassphrase.empty())
+				privKey = PEM_read_bio_RSAPrivateKey(bio, &_pRSA, 0, 0);
+			else
+				privKey = PEM_read_bio_RSAPrivateKey(bio, &_pRSA, 0, const_cast<char*>(privateKeyPassphrase.c_str()));
+			BIO_free(bio);
+			if (!privKey)
+			{
+				freeRSA();
+				throw Poco::FileException("Failed to load private key", privateKeyFile);
+			}
+		}
+		else
+		{
+			freeRSA();
+			throw Poco::FileNotFoundException("Private key file", privateKeyFile);
+		}
+	}
+}
+
+
+RSAKeyImpl::RSAKeyImpl(std::istream* pPublicKeyStream,
+	std::istream* pPrivateKeyStream,
+	const std::string& privateKeyPassphrase): KeyPairImpl("rsa", KT_RSA_IMPL),
+		_pRSA(0)
+{
+	poco_assert_dbg(_pRSA == 0);
+
+	_pRSA = RSA_new();
+	if (pPublicKeyStream)
+	{
+		std::string publicKeyData;
+		Poco::StreamCopier::copyToString(*pPublicKeyStream, publicKeyData);
+		BIO* bio = BIO_new_mem_buf(const_cast<char*>(publicKeyData.data()), static_cast<int>(publicKeyData.size()));
+		if (!bio) throw Poco::IOException("Cannot create BIO for reading public key");
+		RSA* publicKey = PEM_read_bio_RSAPublicKey(bio, &_pRSA, 0, 0);
+		if (!publicKey)
+		{
+			int rc = BIO_reset(bio);
+			// BIO_reset() normally returns 1 for success and 0 or -1 for failure. 
+			// File BIOs are an exception, they return 0 for success and -1 for failure.
+			if (rc != 1) throw Poco::FileException("Failed to load public key");
+			publicKey = PEM_read_bio_RSA_PUBKEY(bio, &_pRSA, 0, 0);
+		}
+		BIO_free(bio);
+		if (!publicKey)
+		{
+			freeRSA();
+			throw Poco::FileException("Failed to load public key");
+		}
+	}
+
+	if (pPrivateKeyStream)
+	{
+		std::string privateKeyData;
+		Poco::StreamCopier::copyToString(*pPrivateKeyStream, privateKeyData);
+		BIO* bio = BIO_new_mem_buf(const_cast<char*>(privateKeyData.data()), static_cast<int>(privateKeyData.size()));
+		if (!bio) throw Poco::IOException("Cannot create BIO for reading private key");
+		RSA* privateKey = 0;
+		if (privateKeyPassphrase.empty())
+			privateKey = PEM_read_bio_RSAPrivateKey(bio, &_pRSA, 0, 0);
+		else
+			privateKey = PEM_read_bio_RSAPrivateKey(bio, &_pRSA, 0, const_cast<char*>(privateKeyPassphrase.c_str()));
+		BIO_free(bio);
+		if (!privateKey)
+		{
+			freeRSA();
+			throw Poco::FileException("Failed to load private key");
+		}
+	}
+}
+
+
+RSAKeyImpl::~RSAKeyImpl()
+{
+	freeRSA();
+}
+
+
+void RSAKeyImpl::freeRSA()
+{
+	if (_pRSA) RSA_free(_pRSA);
+	_pRSA = 0;
+}
+
+
+int RSAKeyImpl::size() const
+{
+	return RSA_size(_pRSA);
+}
+
+
+RSAKeyImpl::ByteVec RSAKeyImpl::modulus() const
+{
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L && !defined(LIBRESSL_VERSION_NUMBER)
+	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 && !defined(LIBRESSL_VERSION_NUMBER)
+	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 && !defined(LIBRESSL_VERSION_NUMBER)
+	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
+}
+
+
+void RSAKeyImpl::save(const std::string& publicKeyFile,
+	const std::string& privateKeyFile,
+	const std::string& privateKeyPassphrase) const
+{
+	if (!publicKeyFile.empty())
+	{
+		BIO* bio = BIO_new(BIO_s_file());
+		if (!bio) throw Poco::IOException("Cannot create BIO for writing public key file", publicKeyFile);
+		try
+		{
+			if (BIO_write_filename(bio, const_cast<char*>(publicKeyFile.c_str())))
+			{
+				if (!PEM_write_bio_RSAPublicKey(bio, _pRSA))
+					throw Poco::WriteFileException("Failed to write public key to file", publicKeyFile);
+			}
+			else throw Poco::CreateFileException("Cannot create public key file");
+		}
+		catch (...)
+		{
+			BIO_free(bio);
+			throw;
+		}
+		BIO_free(bio);
+	}
+	
+	if (!privateKeyFile.empty())
+	{
+		BIO* bio = BIO_new(BIO_s_file());
+		if (!bio) throw Poco::IOException("Cannot create BIO for writing private key file", privateKeyFile);
+		try
+		{
+			if (BIO_write_filename(bio, const_cast<char*>(privateKeyFile.c_str())))
+			{
+				int rc = 0;
+				if (privateKeyPassphrase.empty())
+					rc = PEM_write_bio_RSAPrivateKey(bio, _pRSA, 0, 0, 0, 0, 0);
+				else
+					rc = PEM_write_bio_RSAPrivateKey(bio, _pRSA, EVP_des_ede3_cbc(), 
+						reinterpret_cast<unsigned char*>(const_cast<char*>(privateKeyPassphrase.c_str())), 
+						static_cast<int>(privateKeyPassphrase.length()), 0, 0);
+				if (!rc) throw Poco::FileException("Failed to write private key to file", privateKeyFile);
+			}
+			else throw Poco::CreateFileException("Cannot create private key file", privateKeyFile);
+		}
+		catch (...)
+		{
+			BIO_free(bio);
+			throw;
+		}
+		BIO_free(bio);
+	}
+}
+
+
+void RSAKeyImpl::save(std::ostream* pPublicKeyStream,
+	std::ostream* pPrivateKeyStream,
+	const std::string& privateKeyPassphrase) const
+{
+	if (pPublicKeyStream)
+	{
+		BIO* bio = BIO_new(BIO_s_mem());
+		if (!bio) throw Poco::IOException("Cannot create BIO for writing public key");
+		if (!PEM_write_bio_RSAPublicKey(bio, _pRSA))
+		{
+			BIO_free(bio);
+			throw Poco::WriteFileException("Failed to write public key to stream");
+		}
+		char* pData;
+		long size = BIO_get_mem_data(bio, &pData);
+		pPublicKeyStream->write(pData, static_cast<std::streamsize>(size));
+		BIO_free(bio);
+	}
+
+	if (pPrivateKeyStream)
+	{
+		BIO* bio = BIO_new(BIO_s_mem());
+		if (!bio) throw Poco::IOException("Cannot create BIO for writing public key");
+		int rc = 0;
+		if (privateKeyPassphrase.empty())
+			rc = PEM_write_bio_RSAPrivateKey(bio, _pRSA, 0, 0, 0, 0, 0);
+		else
+			rc = PEM_write_bio_RSAPrivateKey(bio, _pRSA, EVP_des_ede3_cbc(), 
+				reinterpret_cast<unsigned char*>(const_cast<char*>(privateKeyPassphrase.c_str())), 
+				static_cast<int>(privateKeyPassphrase.length()), 0, 0);
+		if (!rc) 
+		{
+			BIO_free(bio);
+			throw Poco::FileException("Failed to write private key to stream");
+		}
+		char* pData;
+		long size = BIO_get_mem_data(bio, &pData);
+		pPrivateKeyStream->write(pData, static_cast<std::streamsize>(size));
+		BIO_free(bio);
+	}
+}
+
+
+RSAKeyImpl::ByteVec RSAKeyImpl::convertToByteVec(const BIGNUM* bn)
+{
+	int numBytes = BN_num_bytes(bn);
+	ByteVec byteVector(numBytes);
+
+	ByteVec::value_type* buffer = new ByteVec::value_type[numBytes];
+	BN_bn2bin(bn, buffer);
+
+	for (int i = 0; i < numBytes; ++i)
+		byteVector[i] = buffer[i];
+
+	delete [] buffer;
+
+	return byteVector;
+}
+
+
+} } // namespace Poco::Crypto

base/poco/Crypto/src/X509Certificate.cpp

@@ -0,0 +1,386 @@
+//
+// X509Certificate.cpp
+//
+// Library: Crypto
+// Package: Certificate
+// Module:  X509Certificate
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/X509Certificate.h"
+#include "Poco/Crypto/CryptoException.h"
+#include "Poco/StreamCopier.h"
+#include "Poco/String.h"
+#include "Poco/DateTimeParser.h"
+#include "Poco/Format.h"
+#include <sstream>
+#include <openssl/pem.h>
+#ifdef _WIN32
+// fix for WIN32 header conflict
+#undef X509_NAME 
+#endif
+#include <openssl/x509v3.h>
+#include <openssl/err.h>
+#include <openssl/evp.h>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+X509Certificate::X509Certificate(std::istream& istr):
+	_pCert(0)
+{
+	load(istr);
+}
+
+
+X509Certificate::X509Certificate(const std::string& path):
+	_pCert(0)
+{
+	load(path);
+}
+
+
+X509Certificate::X509Certificate(X509* pCert):
+	_pCert(pCert)
+{
+	poco_check_ptr(_pCert);
+
+	init();
+}
+
+
+X509Certificate::X509Certificate(X509* pCert, bool shared):
+	_pCert(pCert)
+{
+	poco_check_ptr(_pCert);
+	
+	if (shared)
+	{
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+		X509_up_ref(_pCert);
+#else
+		_pCert->references++;
+#endif
+	}
+
+	init();
+}
+
+
+X509Certificate::X509Certificate(const X509Certificate& cert):
+	_issuerName(cert._issuerName),
+	_subjectName(cert._subjectName),
+	_serialNumber(cert._serialNumber),
+	_pCert(cert._pCert)
+{
+	_pCert = X509_dup(_pCert);
+}
+
+
+X509Certificate& X509Certificate::operator = (const X509Certificate& cert)
+{
+	X509Certificate tmp(cert);
+	swap(tmp);
+	return *this;
+}
+
+
+void X509Certificate::swap(X509Certificate& cert)
+{
+	using std::swap;
+	swap(cert._issuerName, _issuerName);
+	swap(cert._subjectName, _subjectName);
+	swap(cert._serialNumber, _serialNumber);
+	swap(cert._pCert, _pCert);
+}
+
+
+X509Certificate::~X509Certificate()
+{
+	X509_free(_pCert);
+}
+
+
+void X509Certificate::load(std::istream& istr)
+{
+	poco_assert (!_pCert);
+
+	std::stringstream certStream;
+	Poco::StreamCopier::copyStream(istr, certStream);
+	std::string cert = certStream.str();
+
+	BIO *pBIO = BIO_new_mem_buf(const_cast<char*>(cert.data()), static_cast<int>(cert.size()));
+	if (!pBIO) throw Poco::IOException("Cannot create BIO for reading certificate");
+	_pCert = PEM_read_bio_X509(pBIO, 0, 0, 0);
+	BIO_free(pBIO);
+
+	if (!_pCert) throw Poco::IOException("Failed to load certificate from stream");
+
+	init();
+}
+
+
+void X509Certificate::load(const std::string& path)
+{
+	poco_assert (!_pCert);
+
+	BIO *pBIO = BIO_new(BIO_s_file());
+	if (!pBIO) throw Poco::IOException("Cannot create BIO for reading certificate file", path);
+	if (!BIO_read_filename(pBIO, path.c_str()))
+	{
+		BIO_free(pBIO);
+		throw Poco::OpenFileException("Cannot open certificate file for reading", path);
+	}
+
+	_pCert = PEM_read_bio_X509(pBIO, 0, 0, 0);
+	BIO_free(pBIO);
+
+	if (!_pCert) throw Poco::ReadFileException("Faild to load certificate from", path);
+
+	init();
+}
+
+
+void X509Certificate::save(std::ostream& stream) const
+{
+	BIO *pBIO = BIO_new(BIO_s_mem());
+	if (!pBIO) throw Poco::IOException("Cannot create BIO for writing certificate");
+	try
+	{
+		if (!PEM_write_bio_X509(pBIO, _pCert)) 
+			throw Poco::IOException("Failed to write certificate to stream");
+
+		char *pData;
+		long size;
+		size = BIO_get_mem_data(pBIO, &pData);
+		stream.write(pData, size);
+	}
+	catch (...)
+	{
+		BIO_free(pBIO);
+		throw;
+	}
+	BIO_free(pBIO);
+}
+
+
+void X509Certificate::save(const std::string& path) const
+{
+	BIO *pBIO = BIO_new(BIO_s_file());
+	if (!pBIO) throw Poco::IOException("Cannot create BIO for reading certificate file", path);
+	if (!BIO_write_filename(pBIO, const_cast<char*>(path.c_str())))
+	{
+		BIO_free(pBIO);
+		throw Poco::CreateFileException("Cannot create certificate file", path);
+	}
+	try
+	{
+		if (!PEM_write_bio_X509(pBIO, _pCert)) 
+			throw Poco::WriteFileException("Failed to write certificate to file", path);
+	}
+	catch (...)
+	{
+		BIO_free(pBIO);
+		throw;
+	}
+	BIO_free(pBIO);
+}
+
+
+void X509Certificate::init()
+{
+	char buffer[NAME_BUFFER_SIZE];
+	X509_NAME_oneline(X509_get_issuer_name(_pCert), buffer, sizeof(buffer));
+	_issuerName = buffer;
+	X509_NAME_oneline(X509_get_subject_name(_pCert), buffer, sizeof(buffer));
+	_subjectName = buffer;
+	BIGNUM* pBN = ASN1_INTEGER_to_BN(X509_get_serialNumber(const_cast<X509*>(_pCert)), 0);
+	if (pBN)
+	{
+		char* pSN = BN_bn2hex(pBN);
+		if (pSN)
+		{
+			_serialNumber = pSN;
+			OPENSSL_free(pSN);
+		}
+		BN_free(pBN);
+	}
+}
+
+
+std::string X509Certificate::commonName() const
+{
+	return subjectName(NID_COMMON_NAME);
+}
+
+
+std::string X509Certificate::issuerName(NID nid) const
+{
+	if (X509_NAME* issuer = X509_get_issuer_name(_pCert))
+	{
+		char buffer[NAME_BUFFER_SIZE];
+		if (X509_NAME_get_text_by_NID(issuer, nid, buffer, sizeof(buffer)) >= 0)
+			return std::string(buffer);
+	}
+	return std::string();
+}
+
+
+std::string X509Certificate::subjectName(NID nid) const
+{
+	if (X509_NAME* subj = X509_get_subject_name(_pCert))
+	{
+		char buffer[NAME_BUFFER_SIZE];
+		if (X509_NAME_get_text_by_NID(subj, nid, buffer, sizeof(buffer)) >= 0)
+			return std::string(buffer);
+	}
+	return std::string();
+}
+
+
+void X509Certificate::extractNames(std::string& cmnName, std::set<std::string>& domainNames) const
+{
+	domainNames.clear(); 
+	if (STACK_OF(GENERAL_NAME)* names = static_cast<STACK_OF(GENERAL_NAME)*>(X509_get_ext_d2i(_pCert, NID_subject_alt_name, 0, 0)))
+	{
+		for (int i = 0; i < sk_GENERAL_NAME_num(names); ++i)
+		{
+			const GENERAL_NAME* name = sk_GENERAL_NAME_value(names, i);
+			if (name->type == GEN_DNS)
+			{
+				const char* data = reinterpret_cast<char*>(ASN1_STRING_data(name->d.ia5));
+				std::size_t len = ASN1_STRING_length(name->d.ia5);
+				domainNames.insert(std::string(data, len));
+			}
+		}
+		GENERAL_NAMES_free(names);
+	}
+ 
+	cmnName = commonName();
+	if (!cmnName.empty() && domainNames.empty())
+	{
+		domainNames.insert(cmnName);
+	}
+}
+
+
+Poco::DateTime X509Certificate::validFrom() const
+{
+	ASN1_TIME* certTime = X509_get_notBefore(_pCert);
+	std::string dateTime(reinterpret_cast<char*>(certTime->data));
+	int tzd;
+	return DateTimeParser::parse("%y%m%d%H%M%S", dateTime, tzd);
+}
+
+	
+Poco::DateTime X509Certificate::expiresOn() const
+{
+	ASN1_TIME* certTime = X509_get_notAfter(_pCert);
+	std::string dateTime(reinterpret_cast<char*>(certTime->data));
+	int tzd;
+	return DateTimeParser::parse("%y%m%d%H%M%S", dateTime, tzd);
+}
+
+
+bool X509Certificate::issuedBy(const X509Certificate& issuerCertificate) const
+{
+	X509* pCert = const_cast<X509*>(_pCert);
+	X509* pIssuerCert = const_cast<X509*>(issuerCertificate.certificate());
+	EVP_PKEY* pIssuerPublicKey = X509_get_pubkey(pIssuerCert);
+	if (!pIssuerPublicKey) throw Poco::InvalidArgumentException("Issuer certificate has no public key");
+	int rc = X509_verify(pCert, pIssuerPublicKey);
+	EVP_PKEY_free(pIssuerPublicKey);
+	return rc == 1;
+}
+
+
+bool X509Certificate::equals(const X509Certificate& otherCertificate) const
+{
+	X509* pCert = const_cast<X509*>(_pCert);
+	X509* pOtherCert = const_cast<X509*>(otherCertificate.certificate());
+	return X509_cmp(pCert, pOtherCert) == 0;
+}
+
+
+std::string X509Certificate::signatureAlgorithm() const
+{
+	int sigNID = NID_undef;
+
+#if (OPENSSL_VERSION_NUMBER >=  0x1010000fL) && !defined(LIBRESSL_VERSION_NUMBER)
+	sigNID = X509_get_signature_nid(_pCert);
+#else
+	poco_check_ptr(_pCert->sig_alg);
+	sigNID = OBJ_obj2nid(_pCert->sig_alg->algorithm);
+#endif
+
+	if (sigNID != NID_undef)
+	{
+		const char* pAlgName = OBJ_nid2ln(sigNID);
+		if (pAlgName) return std::string(pAlgName);
+		else throw OpenSSLException(Poco::format("X509Certificate::"
+				"signatureAlgorithm(): OBJ_nid2ln(%d)", sigNID));
+	}
+	else
+		throw NotFoundException("X509Certificate::signatureAlgorithm()");
+
+	return "";
+}
+
+
+X509Certificate::List X509Certificate::readPEM(const std::string& pemFileName)
+{
+	List caCertList;
+	BIO* pBIO = BIO_new_file(pemFileName.c_str(), "r");
+	if (pBIO == NULL) throw OpenFileException("X509Certificate::readPEM()");
+	X509* x = PEM_read_bio_X509(pBIO, NULL, 0, NULL);
+	if (!x) throw OpenSSLException(Poco::format("X509Certificate::readPEM(%s)", pemFileName));
+	while(x)
+	{
+		caCertList.push_back(X509Certificate(x));
+		x = PEM_read_bio_X509(pBIO, NULL, 0, NULL);
+	}
+	BIO_free(pBIO);
+	return caCertList;
+}
+
+
+void X509Certificate::writePEM(const std::string& pemFileName, const List& list)
+{
+	BIO* pBIO = BIO_new_file(pemFileName.c_str(), "a");
+	if (pBIO == NULL) throw OpenFileException("X509Certificate::writePEM()");
+	List::const_iterator it = list.begin();
+	List::const_iterator end = list.end();
+	for (; it != end; ++it)
+	{
+		if (!PEM_write_bio_X509(pBIO, const_cast<X509*>(it->certificate())))
+		{
+			throw OpenSSLException("X509Certificate::writePEM()");
+		}
+	}
+	BIO_free(pBIO);
+}
+
+
+void X509Certificate::print(std::ostream& out) const
+{
+	out << "subjectName: " << subjectName() << std::endl;
+	out << "issuerName: " << issuerName() << std::endl;
+	out << "commonName: " << commonName() << std::endl;
+	out << "country: " << subjectName(X509Certificate::NID_COUNTRY) << std::endl;
+	out << "localityName: " << subjectName(X509Certificate::NID_LOCALITY_NAME) << std::endl;
+	out << "stateOrProvince: " << subjectName(X509Certificate::NID_STATE_OR_PROVINCE) << std::endl;
+	out << "organizationName: " << subjectName(X509Certificate::NID_ORGANIZATION_NAME) << std::endl;
+	out << "organizationUnitName: " << subjectName(X509Certificate::NID_ORGANIZATION_UNIT_NAME) << std::endl;
+	out << "emailAddress: " << subjectName(X509Certificate::NID_PKCS9_EMAIL_ADDRESS) << std::endl;
+	out << "serialNumber: " << subjectName(X509Certificate::NID_SERIAL_NUMBER) << std::endl;
+}
+
+
+} } // namespace Poco::Crypto

base/poco/Data/CMakeLists.txt

@@ -0,0 +1,7 @@
+file (GLOB SRCS src/*.cpp)
+
+add_library (_poco_data ${SRCS})
+add_library (Poco::Data ALIAS _poco_data)
+
+target_include_directories (_poco_data SYSTEM PUBLIC "include")
+target_link_libraries (_poco_data PUBLIC Poco::Foundation)

base/poco/Data/ODBC/CMakeLists.txt

@@ -0,0 +1,39 @@
+if (ENABLE_ODBC)
+    if (NOT TARGET ch_contrib::unixodbc)
+        message(FATAL_ERROR "Configuration error: unixodbc is not a target")
+    endif()
+
+    set (SRCS
+        src/Binder.cpp
+        src/ConnectionHandle.cpp
+        src/Connector.cpp
+        src/EnvironmentHandle.cpp
+        src/Extractor.cpp
+        src/ODBCException.cpp
+        src/ODBCMetaColumn.cpp
+        src/ODBCStatementImpl.cpp
+        src/Parameter.cpp
+        src/Preparator.cpp
+        src/SessionImpl.cpp
+        src/TypeInfo.cpp
+        src/Unicode.cpp
+        src/Utility.cpp
+    )
+
+    add_library (_poco_data_odbc ${SRCS})
+    add_library (Poco::Data::ODBC ALIAS _poco_data_odbc)
+
+    target_compile_options (_poco_data_odbc PRIVATE -Wno-unused-variable)
+    target_include_directories (_poco_data_odbc SYSTEM PUBLIC "include")
+    target_link_libraries (_poco_data_odbc PUBLIC Poco::Data ch_contrib::unixodbc)
+
+    message (STATUS "Using Poco::Data::ODBC")
+else ()
+    add_library (_poco_data_odbc INTERFACE)
+    add_library (Poco::Data::ODBC ALIAS _poco_data_odbc)
+    if (TARGET ch_contrib::unixodbc)
+        target_link_libraries (_poco_data_odbc INTERFACE ch_contrib::unixodbc)
+    endif()
+
+    message (STATUS "Not using Poco::Data::ODBC")
+endif ()

base/poco/Data/ODBC/include/Poco/Data/ODBC/ConnectionHandle.h

@@ -0,0 +1,96 @@
+//
+// ConnectionHandle.h
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  ConnectionHandle
+//
+// Definition of ConnectionHandle.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ODBC_ConnectionHandle_INCLUDED
+#define Data_ODBC_ConnectionHandle_INCLUDED
+
+
+#include "Poco/Data/ODBC/ODBC.h"
+#include "Poco/Data/ODBC/EnvironmentHandle.h"
+#ifdef POCO_OS_FAMILY_WINDOWS
+#include <windows.h>
+#endif
+#include <sqltypes.h>
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+class ODBC_API ConnectionHandle
+/// ODBC connection handle class
+{
+public:
+	ConnectionHandle(EnvironmentHandle* pEnvironment = 0);
+		/// Creates the ConnectionHandle.
+
+	~ConnectionHandle();
+		/// Creates the ConnectionHandle.
+
+	operator const SQLHDBC& () const;
+		/// Const conversion operator into reference to native type.
+
+	const SQLHDBC& handle() const;
+		/// Returns const reference to handle;
+
+private:
+	operator SQLHDBC& ();
+		/// Conversion operator into reference to native type.
+
+	SQLHDBC& handle();
+		/// Returns reference to handle;
+
+	ConnectionHandle(const ConnectionHandle&);
+	const ConnectionHandle& operator=(const ConnectionHandle&);
+
+	const EnvironmentHandle* _pEnvironment;
+	SQLHDBC                  _hdbc;
+	bool                     _ownsEnvironment;
+};
+
+
+//
+// inlines
+//
+inline ConnectionHandle::operator const SQLHDBC& () const
+{
+	return handle();
+}
+
+
+inline const SQLHDBC& ConnectionHandle::handle() const
+{
+	return _hdbc;
+}
+
+
+inline ConnectionHandle::operator SQLHDBC& ()
+{
+	return handle();
+}
+
+
+inline SQLHDBC& ConnectionHandle::handle()
+{
+	return _hdbc;
+}
+
+
+} } } // namespace Poco::Data::ODBC
+
+
+#endif

base/poco/Data/ODBC/include/Poco/Data/ODBC/Connector.h

@@ -0,0 +1,96 @@
+//
+// Connector.h
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Connector
+//
+// Definition of the Connector class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ODBC_Connector_INCLUDED
+#define Data_ODBC_Connector_INCLUDED
+
+
+#include "Poco/Data/ODBC/ODBC.h"
+#include "Poco/Data/Connector.h"
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+class ODBC_API Connector: public Poco::Data::Connector
+	/// Connector instantiates SqLite SessionImpl objects.
+{
+public:
+	static const std::string KEY;
+		/// Keyword for creating ODBC sessions.
+
+	Connector();
+		/// Creates the Connector.
+
+	~Connector();
+		/// Destroys the Connector.
+
+	const std::string& name() const;
+		/// Returns the name associated with this connector.
+
+	Poco::AutoPtr<Poco::Data::SessionImpl> createSession(const std::string& connectionString,
+		std::size_t timeout = Poco::Data::SessionImpl::LOGIN_TIMEOUT_DEFAULT);
+		/// Creates a ODBC SessionImpl object and initializes it with the given connectionString.
+
+	static void registerConnector();
+		/// Registers the Connector under the Keyword Connector::KEY at the Poco::Data::SessionFactory
+
+	static void unregisterConnector();
+		/// Unregisters the Connector under the Keyword Connector::KEY at the Poco::Data::SessionFactory
+
+	static void bindStringToLongVarChar(bool flag = true);
+		/// If set to true (default), std::string is bound to SQL_LONGVARCHAR.
+		///
+		/// This can cause issues with SQL Server, resulting in an error
+		/// ("The data types varchar and text are incompatible in the equal to operator")
+		/// when comparing against a VARCHAR. 
+		///
+		/// Set this to false to bind std::string to SQL_VARCHAR.
+		///
+		/// NOTE: This is a global setting, affecting all sessions.
+		/// This setting should not be changed after the first Session has
+		/// been created.
+
+	static bool stringBoundToLongVarChar();
+		/// Returns true if std::string is bound to SQL_LONGVARCHAR,
+		/// otherwise false (bound to SQL_VARCHAR).
+
+private:
+	static bool _bindStringToLongVarChar;
+};
+
+
+///
+/// inlines
+///
+inline const std::string& Connector::name() const
+{
+	return KEY;
+}
+
+
+inline bool Connector::stringBoundToLongVarChar()
+{
+	return _bindStringToLongVarChar;
+}
+
+
+} } } // namespace Poco::Data::ODBC
+
+
+#endif // Data_ODBC_Connector_INCLUDED

base/poco/Data/ODBC/include/Poco/Data/ODBC/Diagnostics.h

@@ -0,0 +1,239 @@
+//
+// Diagnostics.h
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Diagnostics
+//
+// Definition of Diagnostics.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ODBC_Diagnostics_INCLUDED
+#define Data_ODBC_Diagnostics_INCLUDED
+
+
+#include "Poco/Data/ODBC/ODBC.h"
+#include <vector>
+#include <cstring>
+#ifdef POCO_OS_FAMILY_WINDOWS
+#include <windows.h>
+#endif
+#include <sqlext.h>
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+template <typename H, SQLSMALLINT handleType>
+class Diagnostics
+	/// Utility class providing functionality for retrieving ODBC diagnostic
+	/// records. Diagnostics object must be created with corresponding handle
+	/// as constructor argument. During construction, diagnostic records fields 
+	/// are populated and the object is ready for querying.
+{
+public:
+
+	static const unsigned int SQL_STATE_SIZE = SQL_SQLSTATE_SIZE + 1;
+	static const unsigned int SQL_MESSAGE_LENGTH = SQL_MAX_MESSAGE_LENGTH + 1;
+	static const unsigned int SQL_NAME_LENGTH = 128;
+	static const std::string  DATA_TRUNCATED;
+
+	struct DiagnosticFields
+	{
+		/// SQLGetDiagRec fields
+		SQLCHAR    _sqlState[SQL_STATE_SIZE];
+		SQLCHAR    _message[SQL_MESSAGE_LENGTH];
+		SQLINTEGER _nativeError;
+	};
+
+	typedef std::vector<DiagnosticFields> FieldVec;
+	typedef typename FieldVec::const_iterator Iterator;
+
+	explicit Diagnostics(const H& handle): _handle(handle)
+		/// Creates and initializes the Diagnostics.
+	{
+		std::memset(_connectionName, 0, sizeof(_connectionName));
+		std::memset(_serverName, 0, sizeof(_serverName));
+		diagnostics();
+	}
+
+	~Diagnostics()
+		/// Destroys the Diagnostics.
+	{
+	}
+
+	std::string sqlState(int index) const
+		/// Returns SQL state.
+	{
+		poco_assert (index < count());
+		return std::string((char*) _fields[index]._sqlState);
+	}
+
+	std::string message(int index) const
+		/// Returns error message.
+	{
+		poco_assert (index < count());
+		return std::string((char*) _fields[index]._message);
+	}
+
+	long nativeError(int index) const
+		/// Returns native error code.
+	{
+		poco_assert (index < count());
+		return _fields[index]._nativeError;
+	}
+
+	std::string connectionName() const
+		/// Returns the connection name. 
+		/// If there is no active connection, connection name defaults to NONE.
+		/// If connection name is not applicable for query context (such as when querying environment handle),
+		/// connection name defaults to NOT_APPLICABLE.
+	{
+		return std::string((char*) _connectionName);
+	}
+
+	std::string serverName() const
+		/// Returns the server name.
+		/// If the connection has not been established, server name defaults to NONE.
+		/// If server name is not applicable for query context (such as when querying environment handle),
+		/// connection name defaults to NOT_APPLICABLE.
+	{
+		return std::string((char*) _serverName);
+	}
+
+	int count() const
+		/// Returns the number of contained diagnostic records.
+	{
+		return (int) _fields.size();
+	}
+
+	void reset()
+		/// Resets the diagnostic fields container.
+	{
+		_fields.clear();
+	}
+
+	const FieldVec& fields() const
+	{
+		return _fields;
+	}
+
+	Iterator begin() const
+	{
+		return _fields.begin();
+	}
+
+	Iterator end() const
+	{
+		return _fields.end();
+	}
+
+	const Diagnostics& diagnostics()
+	{
+		DiagnosticFields df;
+		SQLSMALLINT count = 1;
+		SQLSMALLINT messageLength = 0;
+		static const std::string none = "None";
+		static const std::string na = "Not applicable";
+
+		reset();
+
+		while (!Utility::isError(SQLGetDiagRec(handleType, 
+			_handle, 
+			count, 
+			df._sqlState, 
+			&df._nativeError, 
+			df._message, 
+			SQL_MESSAGE_LENGTH, 
+			&messageLength))) 
+		{
+			if (1 == count)
+			{
+				// success of the following two calls is optional
+				// (they fail if connection has not been established yet
+				//  or return empty string if not applicable for the context)
+				if (Utility::isError(SQLGetDiagField(handleType, 
+					_handle, 
+					count, 
+					SQL_DIAG_CONNECTION_NAME, 
+					_connectionName, 
+					sizeof(_connectionName), 
+					&messageLength)))
+				{
+					std::size_t len = sizeof(_connectionName) > none.length() ? 
+						none.length() : sizeof(_connectionName) - 1;
+					std::memcpy(_connectionName, none.c_str(), len);
+				}
+				else if (0 == _connectionName[0]) 
+				{
+					std::size_t len = sizeof(_connectionName) > na.length() ? 
+						na.length() : sizeof(_connectionName) - 1;
+					std::memcpy(_connectionName, na.c_str(), len);
+				}
+				
+				if (Utility::isError(SQLGetDiagField(handleType, 
+					_handle, 
+					count, 
+					SQL_DIAG_SERVER_NAME, 
+					_serverName, 
+					sizeof(_serverName), 
+					&messageLength)))
+				{
+					std::size_t len = sizeof(_serverName) > none.length() ? 
+						none.length() : sizeof(_serverName) - 1;
+					std::memcpy(_serverName, none.c_str(), len);
+				}
+				else if (0 == _serverName[0]) 
+				{
+					std::size_t len = sizeof(_serverName) > na.length() ? 
+						na.length() : sizeof(_serverName) - 1;
+					std::memcpy(_serverName, na.c_str(), len);
+				}
+			}
+
+			_fields.push_back(df);
+
+			std::memset(df._sqlState, 0, SQL_STATE_SIZE);
+			std::memset(df._message, 0, SQL_MESSAGE_LENGTH);
+			df._nativeError = 0;
+
+			++count;
+		}
+
+		return *this;
+	}
+
+private:
+
+	Diagnostics();
+
+	/// SQLGetDiagField fields
+	SQLCHAR _connectionName[SQL_NAME_LENGTH];
+	SQLCHAR _serverName[SQL_NAME_LENGTH];
+
+	/// Diagnostics container
+	FieldVec _fields;
+
+	/// Context handle
+	const H& _handle;
+};
+
+
+typedef Diagnostics<SQLHENV, SQL_HANDLE_ENV> EnvironmentDiagnostics;
+typedef Diagnostics<SQLHDBC, SQL_HANDLE_DBC> ConnectionDiagnostics;
+typedef Diagnostics<SQLHSTMT, SQL_HANDLE_STMT> StatementDiagnostics;
+typedef Diagnostics<SQLHDESC, SQL_HANDLE_DESC> DescriptorDiagnostics;
+
+
+} } } // namespace Poco::Data::ODBC
+
+
+#endif

base/poco/Data/ODBC/include/Poco/Data/ODBC/EnvironmentHandle.h

@@ -0,0 +1,94 @@
+//
+// EnvironmentHandle.h
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  EnvironmentHandle
+//
+// Definition of EnvironmentHandle.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ODBC_EnvironmentHandle_INCLUDED
+#define Data_ODBC_EnvironmentHandle_INCLUDED
+
+
+#include "Poco/Data/ODBC/ODBC.h"
+#ifdef POCO_OS_FAMILY_WINDOWS
+#include <windows.h>
+#endif
+#include <sqltypes.h>
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+class ODBC_API EnvironmentHandle
+/// ODBC environment handle class
+{
+public:
+	EnvironmentHandle();
+		/// Creates the EnvironmentHandle.
+
+	~EnvironmentHandle();
+		/// Destroys the EnvironmentHandle.
+
+	operator const SQLHENV& () const;
+		/// Const conversion operator into reference to native type.
+
+	const SQLHENV& handle() const;
+		/// Returns const reference to handle.
+
+private:
+	operator SQLHENV& ();
+		/// Conversion operator into reference to native type.
+
+	SQLHENV& handle();
+		/// Returns reference to handle.
+
+	EnvironmentHandle(const EnvironmentHandle&);
+	const EnvironmentHandle& operator=(const EnvironmentHandle&);
+
+	SQLHENV _henv;
+	bool    _isOwner;
+};
+
+
+///
+/// inlines
+///
+inline EnvironmentHandle::operator const SQLHENV& () const
+{
+	return handle();
+}
+
+
+inline const SQLHENV& EnvironmentHandle::handle() const
+{
+	return _henv;
+}
+
+
+inline EnvironmentHandle::operator SQLHENV& ()
+{
+	return handle();
+}
+
+
+inline SQLHENV& EnvironmentHandle::handle()
+{
+	return _henv;
+}
+
+
+} } } // namespace Poco::Data::ODBC
+
+
+#endif

base/poco/Data/ODBC/include/Poco/Data/ODBC/Error.h

@@ -0,0 +1,124 @@
+//
+// Error.h
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Error
+//
+// Definition of Error.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ODBC_Error_INCLUDED
+#define Data_ODBC_Error_INCLUDED
+
+
+#include "Poco/Data/ODBC/ODBC.h"
+#include "Poco/Data/ODBC/Utility.h"
+#include "Poco/Data/ODBC/Diagnostics.h"
+#include "Poco/Format.h"
+#include <vector>
+#ifdef POCO_OS_FAMILY_WINDOWS
+#include <windows.h>
+#endif
+#include <sqlext.h>
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+template <typename H, SQLSMALLINT handleType>
+class Error
+	/// Class encapsulating ODBC diagnostic record collection. Collection is generated
+	/// during construction. Class provides access and string generation for the collection
+	/// as well as individual diagnostic records.
+{
+public:
+	explicit Error(const H& handle) : _diagnostics(handle)
+		/// Creates the Error.
+	{
+	}
+
+	~Error()
+		/// Destroys the Error.
+	{
+	}
+
+	const Diagnostics<H, handleType>& diagnostics() const
+		/// Returns the associated diagnostics.
+	{
+		return _diagnostics;
+	}
+
+	int count() const
+		/// Returns the count of diagnostic records.
+	{
+		return (int) _diagnostics.count();
+	}
+
+	std::string& toString(int index, std::string& str) const
+		/// Generates the string for the diagnostic record.
+	{
+		if ((index < 0) || (index > (count() - 1))) 
+			return str;
+
+		std::string s;
+		Poco::format(s, 
+			"===========================\n"
+			"ODBC Diagnostic record #%d:\n"
+			"===========================\n"
+			"SQLSTATE = %s\nNative Error Code = %ld\n%s\n\n",
+			index + 1,
+			_diagnostics.sqlState(index),
+			_diagnostics.nativeError(index),
+			_diagnostics.message(index));
+
+		str.append(s);
+
+		return str;
+	}
+
+	std::string toString() const
+		/// Generates the string for the diagnostic record collection.
+	{
+		std::string str;
+
+		Poco::format(str, 
+			"Connection:%s\nServer:%s\n",
+			_diagnostics.connectionName(),
+			_diagnostics.serverName());
+
+		std::string s;
+		for (int i = 0; i < count(); ++i)
+		{
+			s.clear();
+			str.append(toString(i, s));
+		}
+
+		return str;
+	}
+
+private:
+	Error();
+
+	Diagnostics<H, handleType> _diagnostics;
+};
+
+
+typedef Error<SQLHENV, SQL_HANDLE_ENV> EnvironmentError;
+typedef Error<SQLHDBC, SQL_HANDLE_DBC> ConnectionError;
+typedef Error<SQLHSTMT, SQL_HANDLE_STMT> StatementError;
+typedef Error<SQLHSTMT, SQL_HANDLE_DESC> DescriptorError;
+
+
+} } } // namespace Poco::Data::ODBC
+
+
+#endif

base/poco/Data/ODBC/include/Poco/Data/ODBC/Extractor.h

@@ -0,0 +1,728 @@
+//
+// Extractor.h
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Extractor
+//
+// Definition of the Extractor class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ODBC_Extractor_INCLUDED
+#define Data_ODBC_Extractor_INCLUDED
+
+
+#include "Poco/Data/Constants.h"
+#include "Poco/Data/ODBC/ODBC.h"
+#include "Poco/Data/AbstractExtractor.h"
+#include "Poco/Data/ODBC/Preparator.h"
+#include "Poco/Data/ODBC/ODBCMetaColumn.h"
+#include "Poco/Data/ODBC/Error.h"
+#include "Poco/Data/ODBC/Utility.h"
+#include "Poco/Data/Date.h"
+#include "Poco/Data/Time.h"
+#include "Poco/DateTime.h"
+#include "Poco/Any.h"
+#include "Poco/Dynamic/Var.h"
+#include "Poco/Nullable.h"
+#include "Poco/UTFString.h"
+#include "Poco/Exception.h"
+#include <map>
+#ifdef POCO_OS_FAMILY_WINDOWS
+	#include <windows.h>
+#endif
+#include <sqltypes.h>
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+class ODBC_API Extractor: public Poco::Data::AbstractExtractor
+	/// Extracts and converts data values from the result row returned by ODBC.
+	/// If NULL is received, the incoming val value is not changed and false is returned
+{
+public:
+	typedef Preparator::Ptr PreparatorPtr;
+
+	Extractor(const StatementHandle& rStmt, 
+		Preparator::Ptr pPreparator);
+		/// Creates the Extractor.
+
+	~Extractor();
+		/// Destroys the Extractor.
+
+	bool extract(std::size_t pos, Poco::Int8& val);
+		/// Extracts an Int8.
+
+	bool extract(std::size_t pos, std::vector<Poco::Int8>& val);
+		/// Extracts an Int8 vector.
+
+	bool extract(std::size_t pos, std::deque<Poco::Int8>& val);
+		/// Extracts an Int8 deque.
+
+	bool extract(std::size_t pos, std::list<Poco::Int8>& val);
+		/// Extracts an Int8 list.
+
+	bool extract(std::size_t pos, Poco::UInt8& val);
+		/// Extracts an UInt8.
+
+	bool extract(std::size_t pos, std::vector<Poco::UInt8>& val);
+		/// Extracts an UInt8 vector.
+
+	bool extract(std::size_t pos, std::deque<Poco::UInt8>& val);
+		/// Extracts an UInt8 deque.
+
+	bool extract(std::size_t pos, std::list<Poco::UInt8>& val);
+		/// Extracts an UInt8 list.
+
+	bool extract(std::size_t pos, Poco::Int16& val);
+		/// Extracts an Int16.
+
+	bool extract(std::size_t pos, std::vector<Poco::Int16>& val);
+		/// Extracts an Int16 vector.
+
+	bool extract(std::size_t pos, std::deque<Poco::Int16>& val);
+		/// Extracts an Int16 deque.
+
+	bool extract(std::size_t pos, std::list<Poco::Int16>& val);
+		/// Extracts an Int16 list.
+
+	bool extract(std::size_t pos, Poco::UInt16& val);
+		/// Extracts an UInt16.
+
+	bool extract(std::size_t pos, std::vector<Poco::UInt16>& val);
+		/// Extracts an UInt16 vector.
+
+	bool extract(std::size_t pos, std::deque<Poco::UInt16>& val);
+		/// Extracts an UInt16 deque.
+
+	bool extract(std::size_t pos, std::list<Poco::UInt16>& val);
+		/// Extracts an UInt16 list.
+
+	bool extract(std::size_t pos, Poco::Int32& val);
+		/// Extracts an Int32.
+
+	bool extract(std::size_t pos, std::vector<Poco::Int32>& val);
+		/// Extracts an Int32 vector.
+
+	bool extract(std::size_t pos, std::deque<Poco::Int32>& val);
+		/// Extracts an Int32 deque.
+
+	bool extract(std::size_t pos, std::list<Poco::Int32>& val);
+		/// Extracts an Int32 list.
+
+	bool extract(std::size_t pos, Poco::UInt32& val);
+		/// Extracts an UInt32.
+
+	bool extract(std::size_t pos, std::vector<Poco::UInt32>& val);
+		/// Extracts an UInt32 vector.
+
+	bool extract(std::size_t pos, std::deque<Poco::UInt32>& val);
+		/// Extracts an UInt32 deque.
+
+	bool extract(std::size_t pos, std::list<Poco::UInt32>& val);
+		/// Extracts an UInt32 list.
+
+	bool extract(std::size_t pos, Poco::Int64& val);
+		/// Extracts an Int64.
+
+	bool extract(std::size_t pos, std::vector<Poco::Int64>& val);
+		/// Extracts an Int64 vector.
+
+	bool extract(std::size_t pos, std::deque<Poco::Int64>& val);
+		/// Extracts an Int64 deque.
+
+	bool extract(std::size_t pos, std::list<Poco::Int64>& val);
+		/// Extracts an Int64 list.
+
+	bool extract(std::size_t pos, Poco::UInt64& val);
+		/// Extracts an UInt64.
+
+	bool extract(std::size_t pos, std::vector<Poco::UInt64>& val);
+		/// Extracts an UInt64 vector.
+
+	bool extract(std::size_t pos, std::deque<Poco::UInt64>& val);
+		/// Extracts an UInt64 deque.
+
+	bool extract(std::size_t pos, std::list<Poco::UInt64>& val);
+		/// Extracts an UInt64 list.
+
+#ifndef POCO_LONG_IS_64_BIT
+	bool extract(std::size_t pos, long& val);
+		/// Extracts a long.
+
+	bool extract(std::size_t pos, unsigned long& val);
+		/// Extracts an unsigned long.
+
+	bool extract(std::size_t pos, std::vector<long>& val);
+		/// Extracts a long vector.
+
+	bool extract(std::size_t pos, std::deque<long>& val);
+		/// Extracts a long deque.
+
+	bool extract(std::size_t pos, std::list<long>& val);
+		/// Extracts a long list.
+#endif
+
+	bool extract(std::size_t pos, bool& val);
+		/// Extracts a boolean.
+
+	bool extract(std::size_t pos, std::vector<bool>& val);
+		/// Extracts a boolean vector.
+
+	bool extract(std::size_t pos, std::deque<bool>& val);
+		/// Extracts a boolean deque.
+
+	bool extract(std::size_t pos, std::list<bool>& val);
+		/// Extracts a boolean list.
+
+	bool extract(std::size_t pos, float& val);
+		/// Extracts a float.
+
+	bool extract(std::size_t pos, std::vector<float>& val);
+		/// Extracts a float vector.
+
+	bool extract(std::size_t pos, std::deque<float>& val);
+		/// Extracts a float deque.
+
+	bool extract(std::size_t pos, std::list<float>& val);
+		/// Extracts a float list.
+
+	bool extract(std::size_t pos, double& val);
+		/// Extracts a double.
+
+	bool extract(std::size_t pos, std::vector<double>& val);
+		/// Extracts a double vector.
+
+	bool extract(std::size_t pos, std::deque<double>& val);
+		/// Extracts a double deque.
+
+	bool extract(std::size_t pos, std::list<double>& val);
+		/// Extracts a double list.
+
+	bool extract(std::size_t pos, char& val);
+		/// Extracts a single character.
+
+	bool extract(std::size_t pos, std::vector<char>& val);
+		/// Extracts a single character vector.
+
+	bool extract(std::size_t pos, std::deque<char>& val);
+		/// Extracts a single character deque.
+
+	bool extract(std::size_t pos, std::list<char>& val);
+		/// Extracts a single character list.
+
+	bool extract(std::size_t pos, std::string& val);
+		/// Extracts a string.
+
+	bool extract(std::size_t pos, std::vector<std::string>& val);
+		/// Extracts a string vector.
+
+	bool extract(std::size_t pos, std::deque<std::string>& val);
+		/// Extracts a string deque.
+
+	bool extract(std::size_t pos, std::list<std::string>& val);
+		/// Extracts a string list.
+		/// Extracts a single character list.
+
+	bool extract(std::size_t pos, UTF16String& val);
+	/// Extracts a string.
+
+	bool extract(std::size_t pos, std::vector<UTF16String>& val);
+	/// Extracts a string vector.
+
+	bool extract(std::size_t pos, std::deque<UTF16String>& val);
+	/// Extracts a string deque.
+
+	bool extract(std::size_t pos, std::list<UTF16String>& val);
+	/// Extracts a string list.
+
+	bool extract(std::size_t pos, Poco::Data::BLOB& val);
+		/// Extracts a BLOB.
+
+	bool extract(std::size_t pos, Poco::Data::CLOB& val);
+		/// Extracts a CLOB.
+
+	bool extract(std::size_t pos, std::vector<Poco::Data::BLOB>& val);
+		/// Extracts a BLOB vector.
+
+	bool extract(std::size_t pos, std::deque<Poco::Data::BLOB>& val);
+		/// Extracts a BLOB deque.
+
+	bool extract(std::size_t pos, std::list<Poco::Data::BLOB>& val);
+		/// Extracts a BLOB list.
+
+	bool extract(std::size_t pos, std::vector<Poco::Data::CLOB>& val);
+		/// Extracts a CLOB vector.
+
+	bool extract(std::size_t pos, std::deque<Poco::Data::CLOB>& val);
+		/// Extracts a CLOB deque.
+
+	bool extract(std::size_t pos, std::list<Poco::Data::CLOB>& val);
+		/// Extracts a CLOB list.
+
+	bool extract(std::size_t pos, Poco::Data::Date& val);
+		/// Extracts a Date.
+
+	bool extract(std::size_t pos, std::vector<Poco::Data::Date>& val);
+		/// Extracts a Date vector.
+
+	bool extract(std::size_t pos, std::deque<Poco::Data::Date>& val);
+		/// Extracts a Date deque.
+
+	bool extract(std::size_t pos, std::list<Poco::Data::Date>& val);
+		/// Extracts a Date list.
+
+	bool extract(std::size_t pos, Poco::Data::Time& val);
+		/// Extracts a Time.
+
+	bool extract(std::size_t pos, std::vector<Poco::Data::Time>& val);
+		/// Extracts a Time vector.
+
+	bool extract(std::size_t pos, std::deque<Poco::Data::Time>& val);
+		/// Extracts a Time deque.
+
+	bool extract(std::size_t pos, std::list<Poco::Data::Time>& val);
+		/// Extracts a Time list.
+
+	bool extract(std::size_t pos, Poco::DateTime& val);
+		/// Extracts a DateTime.
+
+	bool extract(std::size_t pos, std::vector<Poco::DateTime>& val);
+		/// Extracts a DateTime vector.
+
+	bool extract(std::size_t pos, std::deque<Poco::DateTime>& val);
+		/// Extracts a DateTime deque.
+
+	bool extract(std::size_t pos, std::list<Poco::DateTime>& val);
+		/// Extracts a DateTime list.
+	
+	bool extract(std::size_t pos, Poco::Any& val);
+		/// Extracts an Any.
+
+	bool extract(std::size_t pos, std::vector<Poco::Any>& val);
+		/// Extracts an Any vector.
+
+	bool extract(std::size_t pos, std::deque<Poco::Any>& val);
+		/// Extracts an Any deque.
+
+	bool extract(std::size_t pos, std::list<Poco::Any>& val);
+		/// Extracts an Any list.
+
+	bool extract(std::size_t pos, Poco::DynamicAny& val);
+		/// Extracts a DynamicAny.
+
+	bool extract(std::size_t pos, std::vector<Poco::DynamicAny>& val);
+		/// Extracts a DynamicAny vector.
+
+	bool extract(std::size_t pos, std::deque<Poco::DynamicAny>& val);
+		/// Extracts a DynamicAny deque.
+
+	bool extract(std::size_t pos, std::list<Poco::DynamicAny>& val);
+		/// Extracts a DynamicAny list.
+
+	void setDataExtraction(Preparator::DataExtraction ext);
+		/// Set data extraction mode.
+
+	Preparator::DataExtraction getDataExtraction() const;
+		/// Returns data extraction mode.
+
+	bool isNull(std::size_t col, std::size_t row = POCO_DATA_INVALID_ROW);
+		/// Returns true if the value at [col,row] is null.
+
+	void reset();
+		/// Resets the internally cached length indicators. 
+
+private:
+	static const int CHUNK_SIZE = 1024;
+		/// Amount of data retrieved in one SQLGetData() request when doing manual extract.
+
+	static const std::string FLD_SIZE_EXCEEDED_FMT;
+		/// String format for the exception message when the field size is exceeded.
+
+	void checkDataSize(std::size_t size);
+		/// This check is only performed for bound data
+		/// retrieval from variable length columns.
+		/// The reason for this check is to ensure we can
+		/// accept the value ODBC driver is supplying
+		/// (i.e. the bound buffer is large enough to receive
+		/// the returned value)
+
+	void resizeLengths(std::size_t pos);
+		/// Resizes the vector holding extracted data lengths to the
+		/// appropriate size.
+
+	template<typename T>
+	bool extractBoundImpl(std::size_t pos, T& val)
+	{
+		if (isNull(pos)) return false;
+		poco_assert_dbg (typeid(T) == _pPreparator->at(pos).type());
+		val = *AnyCast<T>(&_pPreparator->at(pos)); 
+		return true;
+	}
+
+	bool extractBoundImpl(std::size_t pos, Poco::Data::BLOB& val);
+	bool extractBoundImpl(std::size_t pos, Poco::Data::CLOB& val);
+
+	template <typename C>
+	bool extractBoundImplContainer(std::size_t pos, C& val)
+	{
+		typedef typename C::value_type Type;
+		poco_assert_dbg (typeid(std::vector<Type>) == _pPreparator->at(pos).type());
+		std::vector<Type>& v = RefAnyCast<std::vector<Type> >(_pPreparator->at(pos));
+		val.assign(v.begin(), v.end());
+		return true;
+	}
+
+	bool extractBoundImplContainer(std::size_t pos, std::vector<std::string>& values);
+	bool extractBoundImplContainer(std::size_t pos, std::deque<std::string>& values);
+	bool extractBoundImplContainer(std::size_t pos, std::list<std::string>& values); 
+	bool extractBoundImplContainer(std::size_t pos, std::vector<Poco::UTF16String>& values);
+	bool extractBoundImplContainer(std::size_t pos, std::deque<Poco::UTF16String>& values);
+	bool extractBoundImplContainer(std::size_t pos, std::list<Poco::UTF16String>& values);
+	bool extractBoundImplContainer(std::size_t pos, std::vector<Poco::Data::CLOB>& values);
+	bool extractBoundImplContainer(std::size_t pos, std::deque<Poco::Data::CLOB>& values);
+	bool extractBoundImplContainer(std::size_t pos, std::list<Poco::Data::CLOB>& values);
+	bool extractBoundImplContainer(std::size_t pos, std::vector<Poco::Data::BLOB>& values);
+	bool extractBoundImplContainer(std::size_t pos, std::deque<Poco::Data::BLOB>& values);
+	bool extractBoundImplContainer(std::size_t pos, std::list<Poco::Data::BLOB>& values);
+
+	template <typename C>
+	bool extractBoundImplContainerString(std::size_t pos, C& values)
+	{
+		typedef typename C::value_type StringType;
+		typedef typename C::iterator ItType;
+		typedef typename StringType::value_type CharType;
+
+		CharType** pc = AnyCast<CharType*>(&(_pPreparator->at(pos)));
+		poco_assert_dbg (pc);
+		poco_assert_dbg (_pPreparator->bulkSize() == values.size());
+		std::size_t colWidth = columnSize(pos);
+		ItType it = values.begin();
+		ItType end = values.end();
+		for (int row = 0; it != end; ++it, ++row)
+		{
+			it->assign(*pc + row * colWidth / sizeof(CharType), _pPreparator->actualDataSize(pos, row));
+			// clean up superfluous null chars returned by some drivers
+			typename StringType::size_type trimLen = 0;
+			typename StringType::reverse_iterator sIt = it->rbegin();
+			typename StringType::reverse_iterator sEnd = it->rend();
+			for (; sIt != sEnd; ++sIt)
+			{
+				if (*sIt == '\0') ++trimLen;
+				else break;
+			}
+			if (trimLen) it->assign(it->begin(), it->begin() + it->length() - trimLen);
+		}
+
+		return true;
+	}
+
+	template <typename C>
+	bool extractBoundImplContainerLOB(std::size_t pos, C& values)
+	{
+		typedef typename C::value_type LOBType;
+		typedef typename LOBType::ValueType CharType;
+		typedef typename C::iterator ItType;
+
+		CharType** pc = AnyCast<CharType*>(&(_pPreparator->at(pos)));
+		poco_assert_dbg (pc);
+		poco_assert_dbg (_pPreparator->bulkSize() == values.size());
+		std::size_t colWidth = _pPreparator->maxDataSize(pos);
+		ItType it = values.begin();
+		ItType end = values.end();
+		for (int row = 0; it != end; ++it, ++row)
+			it->assignRaw(*pc + row * colWidth, _pPreparator->actualDataSize(pos, row));
+
+		return true;
+	}
+
+	template<typename T>
+	bool extractBoundImplLOB(std::size_t pos, Poco::Data::LOB<T>& val)
+	{
+		if (isNull(pos)) return false;
+
+		std::size_t dataSize = _pPreparator->actualDataSize(pos);
+		checkDataSize(dataSize);
+		T* sp = AnyCast<T*>(_pPreparator->at(pos));
+		val.assignRaw(sp, dataSize);
+
+		return true;
+	}
+
+	template<typename T>
+	bool extractManualImpl(std::size_t pos, T& val, SQLSMALLINT cType)
+	{
+		SQLRETURN rc = 0;
+		T value = (T) 0;
+
+		resizeLengths(pos);
+
+		rc = SQLGetData(_rStmt, 
+			(SQLUSMALLINT) pos + 1, 
+			cType,  //C data type
+			&value, //returned value
+			0,      //buffer length (ignored)
+			&_lengths[pos]);  //length indicator
+
+		if (Utility::isError(rc))
+			throw StatementException(_rStmt, "SQLGetData()");
+		
+		if (isNullLengthIndicator(_lengths[pos])) 
+			return false;
+		else 
+		{
+			//for fixed-length data, buffer must be large enough
+			//otherwise, driver may write past the end
+			poco_assert_dbg (_lengths[pos] <= sizeof(T));
+			val = value;
+		}
+
+		return true;
+	}
+
+	template <typename T, typename NT>
+	bool extAny(std::size_t pos, T& val)
+	{
+		NT i;
+		if (extract(pos, i))
+		{
+			val = i;
+			return true;
+		}
+		else
+		{
+			val = Nullable<NT>();
+			return false;
+		}
+	}
+
+	template <typename T>
+	bool extractImpl(std::size_t pos, T& val)
+		/// Utility function for extraction of Any and DynamicAny.
+	{
+		ODBCMetaColumn column(_rStmt, pos);
+
+		switch (column.type())
+		{
+			case MetaColumn::FDT_INT8:
+			{ return extAny<T, Poco::Int8>(pos, val); }
+
+			case MetaColumn::FDT_UINT8:
+			{ return extAny<T, Poco::UInt8>(pos, val); }
+
+			case MetaColumn::FDT_INT16:
+			{ return extAny<T, Poco::Int16>(pos, val); }
+
+			case MetaColumn::FDT_UINT16:
+			{ return extAny<T, Poco::UInt16>(pos, val); }
+
+			case MetaColumn::FDT_INT32:
+			{ return extAny<T, Poco::Int32>(pos, val);	}
+
+			case MetaColumn::FDT_UINT32:
+			{ return extAny<T, Poco::UInt32>(pos, val); }
+
+			case MetaColumn::FDT_INT64:
+			{ return extAny<T, Poco::Int64>(pos, val); }
+
+			case MetaColumn::FDT_UINT64:
+			{ return extAny<T, Poco::UInt64>(pos, val); }
+
+			case MetaColumn::FDT_BOOL:
+			{ return extAny<T, bool>(pos, val); }
+
+			case MetaColumn::FDT_FLOAT:
+			{ return extAny<T, float>(pos, val); }
+
+			case MetaColumn::FDT_DOUBLE:
+			{ return extAny<T, double>(pos, val); }
+
+			case MetaColumn::FDT_STRING:
+			{ return extAny<T, std::string>(pos, val); }
+
+			case MetaColumn::FDT_WSTRING:
+			{ return extAny<T, Poco::UTF16String>(pos, val); }
+
+			case MetaColumn::FDT_BLOB:
+			{ return extAny<T, Poco::Data::BLOB>(pos, val); }
+
+			case MetaColumn::FDT_CLOB:
+			{ return extAny<T, Poco::Data::CLOB>(pos, val); }
+
+			case MetaColumn::FDT_DATE:
+			{ return extAny<T, Poco::Data::Date>(pos, val); }
+
+			case MetaColumn::FDT_TIME:
+			{ return extAny<T, Poco::Data::Time>(pos, val); }
+
+			case MetaColumn::FDT_TIMESTAMP:
+			{ return extAny<T, Poco::DateTime>(pos, val); }
+
+			default: 
+				throw DataFormatException("Unsupported data type.");
+		}
+
+		return false;
+	}
+
+	bool isNullLengthIndicator(SQLLEN val) const;
+		/// The reason for this utility wrapper are platforms where 
+		/// SQLLEN macro (a.k.a. SQLINTEGER) yields 64-bit value, 
+		/// while SQL_NULL_DATA (#define'd as -1 literal) remains 32-bit.
+
+	SQLINTEGER columnSize(std::size_t pos) const;
+
+	const StatementHandle&     _rStmt;
+	PreparatorPtr              _pPreparator;
+	Preparator::DataExtraction _dataExtraction;
+	std::vector<SQLLEN>        _lengths;
+};
+
+
+///
+/// inlines
+///
+
+inline bool Extractor::extractBoundImpl(std::size_t pos, Poco::Data::BLOB& val)
+{
+	return extractBoundImplLOB<BLOB::ValueType>(pos, val);
+}
+
+
+inline bool Extractor::extractBoundImpl(std::size_t pos, Poco::Data::CLOB& val)
+{
+	return extractBoundImplLOB<CLOB::ValueType>(pos, val);
+}
+
+
+inline bool Extractor::extractBoundImplContainer(std::size_t pos, std::vector<std::string>& values)
+{
+	return extractBoundImplContainerString(pos, values);
+}
+
+
+inline bool Extractor::extractBoundImplContainer(std::size_t pos, std::deque<std::string>& values)
+{
+	return extractBoundImplContainerString(pos, values);
+}
+
+
+inline bool Extractor::extractBoundImplContainer(std::size_t pos, std::list<std::string>& values)
+{
+	return extractBoundImplContainerString(pos, values);
+}
+
+
+inline bool Extractor::extractBoundImplContainer(std::size_t pos, std::vector<Poco::UTF16String>& values)
+{
+	return extractBoundImplContainerString(pos, values);
+}
+
+
+inline bool Extractor::extractBoundImplContainer(std::size_t pos, std::deque<Poco::UTF16String>& values)
+{
+	return extractBoundImplContainerString(pos, values);
+}
+
+
+inline bool Extractor::extractBoundImplContainer(std::size_t pos, std::list<Poco::UTF16String>& values)
+{
+	return extractBoundImplContainerString(pos, values);
+}
+
+
+inline bool Extractor::extractBoundImplContainer(std::size_t pos, 
+	std::vector<Poco::Data::CLOB>& values)
+{
+	return extractBoundImplContainerLOB(pos, values);
+}
+
+
+inline bool Extractor::extractBoundImplContainer(std::size_t pos, 
+	std::deque<Poco::Data::CLOB>& values)
+{
+	return extractBoundImplContainerLOB(pos, values);
+}
+
+
+inline bool Extractor::extractBoundImplContainer(std::size_t pos, 
+	std::list<Poco::Data::CLOB>& values)
+{
+	return extractBoundImplContainerLOB(pos, values);
+}
+
+
+inline bool Extractor::extractBoundImplContainer(std::size_t pos, 
+	std::vector<Poco::Data::BLOB>& values)
+{
+	return extractBoundImplContainerLOB(pos, values);
+}
+
+
+inline bool Extractor::extractBoundImplContainer(std::size_t pos, 
+	std::deque<Poco::Data::BLOB>& values)
+{
+	return extractBoundImplContainerLOB(pos, values);
+}
+
+
+inline bool Extractor::extractBoundImplContainer(std::size_t pos, 
+	std::list<Poco::Data::BLOB>& values)
+{
+	return extractBoundImplContainerLOB(pos, values);
+}
+
+
+inline void Extractor::setDataExtraction(Preparator::DataExtraction ext)
+{
+	_pPreparator->setDataExtraction(_dataExtraction = ext);
+}
+
+
+inline Preparator::DataExtraction Extractor::getDataExtraction() const
+{
+	return _dataExtraction;
+}
+
+
+inline void Extractor::reset()
+{
+	_lengths.clear();
+}
+
+
+inline void Extractor::resizeLengths(std::size_t pos)
+{
+	if (pos >= _lengths.size()) 
+		_lengths.resize(pos + 1, (SQLLEN) 0);
+}
+
+
+inline bool Extractor::isNullLengthIndicator(SQLLEN val) const
+{
+	return SQL_NULL_DATA == (int) val;
+}
+
+
+inline SQLINTEGER Extractor::columnSize(std::size_t pos) const
+{
+	std::size_t size = ODBCMetaColumn(_rStmt, pos).length();
+	std::size_t maxSize = _pPreparator->maxDataSize(pos);
+	if (size > maxSize) size = maxSize;
+	return (SQLINTEGER) size;
+}
+
+
+} } } // namespace Poco::Data::ODBC
+
+
+#endif // Data_ODBC_Extractor_INCLUDED

base/poco/Data/ODBC/include/Poco/Data/ODBC/Handle.h

@@ -0,0 +1,113 @@
+//
+// Handle.h
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Handle
+//
+// Definition of Handle.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ODBC_Handle_INCLUDED
+#define Data_ODBC_Handle_INCLUDED
+
+
+#include "Poco/Data/ODBC/ODBC.h"
+#include "Poco/Data/ODBC/EnvironmentHandle.h"
+#include "Poco/Data/ODBC/ConnectionHandle.h"
+#include "Poco/Data/ODBC/ODBCException.h"
+#include "Poco/Data/ODBC/Utility.h"
+#ifdef POCO_OS_FAMILY_WINDOWS
+#include <windows.h>
+#endif
+#include <sqltypes.h>
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+template <typename H, SQLSMALLINT handleType>
+class Handle
+/// ODBC handle class template
+{
+public:
+	Handle(const ConnectionHandle& rConnection): 
+		_rConnection(rConnection),
+		_handle(0)
+			/// Creates the Handle.
+	{
+		if (Utility::isError(SQLAllocHandle(handleType, 
+			_rConnection, 
+			&_handle))) 
+		{
+			throw ODBCException("Could not allocate statement handle.");
+		}
+	}
+
+	~Handle()
+		/// Destroys the Handle.
+	{
+		try
+		{
+			SQLRETURN rc = SQLFreeHandle(handleType, _handle);
+			// N.B. Destructors should not throw, but neither do we want to
+			// leak resources. So, we throw here in debug mode if things go bad.
+			poco_assert_dbg (!Utility::isError(rc));
+		}
+		catch (...)
+		{
+			poco_unexpected();
+		}
+	}
+
+	operator const H& () const
+		/// Const conversion operator into reference to native type.
+	{
+		return handle();
+	}
+
+	const H& handle() const
+		/// Returns const reference to native type.
+	{
+		return _handle;
+	}
+
+private:
+	Handle(const Handle&);
+	const Handle& operator=(const Handle&);
+
+	operator H& ()
+		/// Conversion operator into reference to native type.
+	{
+		return handle();
+	}
+
+	H& handle()
+		/// Returns reference to native type.
+	{
+		return _handle;
+	}
+
+	const ConnectionHandle& _rConnection;
+	H _handle;
+
+	friend class ODBCStatementImpl;
+};
+
+
+typedef Handle<SQLHSTMT, SQL_HANDLE_STMT> StatementHandle;
+typedef Handle<SQLHDESC, SQL_HANDLE_DESC> DescriptorHandle;
+
+
+} } } // namespace Poco::Data::ODBC
+
+
+#endif

base/poco/Data/ODBC/include/Poco/Data/ODBC/ODBC.h

@@ -0,0 +1,69 @@
+//
+// ODBC.h
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  ODBC
+//
+// Basic definitions for the Poco ODBC library.
+// This file must be the first file included by every other ODBC
+// header file.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ODBC_ODBC_INCLUDED
+#define Data_ODBC_ODBC_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#ifdef POCO_OS_FAMILY_WINDOWS
+#include <windows.h>
+#endif
+
+
+//
+// The following block is the standard way of creating macros which make exporting
+// from a DLL simpler. All files within this DLL are compiled with the ODBC_EXPORTS
+// symbol defined on the command line. this symbol should not be defined on any project
+// that uses this DLL. This way any other project whose source files include this file see
+// ODBC_API functions as being imported from a DLL, wheras this DLL sees symbols
+// defined with this macro as being exported.
+//
+#if defined(_WIN32) && defined(POCO_DLL)
+	#if defined(ODBC_EXPORTS)
+		#define ODBC_API __declspec(dllexport)
+	#else
+		#define ODBC_API __declspec(dllimport)
+	#endif
+#endif
+
+
+#if !defined(ODBC_API)
+	#if !defined(POCO_NO_GCC_API_ATTRIBUTE) && defined (__GNUC__) && (__GNUC__ >= 4)
+		#define ODBC_API __attribute__ ((visibility ("default")))
+	#else
+		#define ODBC_API
+	#endif
+#endif
+
+
+
+#include "Poco/Data/ODBC/Unicode.h"
+
+
+//
+// Automatically link Data library.
+//
+#if defined(_MSC_VER)
+	#if !defined(POCO_NO_AUTOMATIC_LIBS) && !defined(ODBC_EXPORTS)
+		#pragma comment(lib, "PocoDataODBC" POCO_LIB_SUFFIX)
+	#endif
+#endif
+
+
+#endif // ODBC_ODBC_INCLUDED

base/poco/Data/ODBC/include/Poco/Data/ODBC/ODBCException.h

@@ -0,0 +1,150 @@
+//
+// ODBCException.h
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  ODBCException
+//
+// Definition of ODBCException.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ODBC_ODBCException_INCLUDED
+#define Data_ODBC_ODBCException_INCLUDED
+
+
+#include "Poco/Data/ODBC/ODBC.h"
+#include "Poco/Data/ODBC/Utility.h"
+#include "Poco/Data/ODBC/Diagnostics.h"
+#include "Poco/Data/ODBC/Error.h"
+#include "Poco/Data/DataException.h"
+#include "Poco/Format.h"
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+POCO_DECLARE_EXCEPTION(ODBC_API, ODBCException, Poco::Data::DataException)
+POCO_DECLARE_EXCEPTION(ODBC_API, InsufficientStorageException, ODBCException)
+POCO_DECLARE_EXCEPTION(ODBC_API, UnknownDataLengthException, ODBCException)
+POCO_DECLARE_EXCEPTION(ODBC_API, DataTruncatedException, ODBCException)
+
+
+template <class H, SQLSMALLINT handleType>
+class HandleException: public ODBCException
+{
+public:
+	HandleException(const H& handle): _error(handle)
+		/// Creates HandleException
+	{
+		message(_error.toString());
+	}
+
+	HandleException(const H& handle, const std::string& msg): 
+		ODBCException(msg), 
+		_error(handle)
+		/// Creates HandleException
+	{
+		extendedMessage(_error.toString());
+	}							
+
+	HandleException(const H& handle, const std::string& msg, const std::string& arg): 
+		ODBCException(msg, arg), 
+		_error(handle)
+		/// Creates HandleException
+	{
+	}
+
+	HandleException(const H& handle, const std::string& msg, const Poco::Exception& exc): 
+		ODBCException(msg, exc),
+		_error(handle)
+		/// Creates HandleException
+	{
+	}
+
+	HandleException(const HandleException& exc): 
+		ODBCException(exc),
+		_error(exc._error)
+		/// Creates HandleException
+	{
+	}
+
+	~HandleException() throw()
+		/// Destroys HandleException
+	{
+	}
+
+	HandleException& operator = (const HandleException& exc)
+		/// Assignment operator
+	{
+		if (&exc != this) _error = exc._error;
+
+		return *this;
+	}
+
+	const char* name() const throw()
+		/// Returns the name of the exception
+	{
+		return "ODBC handle exception";
+	}
+
+	const char* className() const throw()
+		/// Returns the HandleException class name.
+	{
+		return typeid(*this).name();
+	}
+
+	Poco::Exception* clone() const
+		/// Clones the HandleException
+	{
+		return new HandleException(*this);
+	}
+
+	void rethrow() const
+		/// Re-throws the HandleException.
+	{
+		throw *this;
+	}
+
+	const Diagnostics<H, handleType>& diagnostics() const
+		/// Returns error diagnostics.
+	{
+		return _error.diagnostics();
+	}
+
+	std::string toString() const
+		/// Returns the formatted error diagnostics for the handle.
+	{
+		return Poco::format("ODBC Error: %s\n===================\n%s\n",
+			std::string(what()),
+			_error.toString());
+	}
+
+	static std::string errorString(const H& handle)
+		/// Returns the error diagnostics string for the handle.
+	{
+		return Error<H, handleType>(handle).toString();
+	}
+
+private:
+	Error<H, handleType> _error;
+};
+
+
+typedef HandleException<SQLHENV, SQL_HANDLE_ENV>   EnvironmentException;
+typedef HandleException<SQLHDBC, SQL_HANDLE_DBC>   ConnectionException;
+typedef HandleException<SQLHSTMT, SQL_HANDLE_STMT> StatementException;
+typedef HandleException<SQLHDESC, SQL_HANDLE_DESC> DescriptorException;
+
+
+} } } // namespace Poco::Data::ODBC
+
+
+#endif

base/poco/Data/ODBC/include/Poco/Data/ODBC/ODBCMetaColumn.h

@@ -0,0 +1,92 @@
+//
+// ODBCMetaColumn.h
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  ODBCMetaColumn
+//
+// Definition of ODBCMetaColumn.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ODBC_ODBCColumn_INCLUDED
+#define Data_ODBC_ODBCColumn_INCLUDED
+
+
+#include "Poco/Data/ODBC/ODBC.h"
+#include "Poco/Data/ODBC/Error.h"
+#include "Poco/Data/ODBC/Handle.h"
+#include "Poco/Data/ODBC/ODBCException.h"
+#include "Poco/Data/MetaColumn.h"
+#ifdef POCO_OS_FAMILY_WINDOWS
+#include <windows.h>
+#endif
+#include <sqlext.h>
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+class ODBC_API ODBCMetaColumn: public MetaColumn
+{
+public:
+	explicit ODBCMetaColumn(const StatementHandle& rStmt, std::size_t position);
+		/// Creates the ODBCMetaColumn.
+		
+	~ODBCMetaColumn();
+		/// Destroys the ODBCMetaColumn.
+
+	std::size_t dataLength() const;
+		/// A numeric value that is either the maximum or actual character length of a character 
+		/// string or binary data type. It is the maximum character length for a fixed-length data type, 
+		/// or the actual character length for a variable-length data type. Its value always excludes the 
+		/// null-termination byte that ends the character string. 
+		/// This information is returned from the SQL_DESC_LENGTH record field of the IRD.
+
+	bool isUnsigned() const;
+		/// Returns true if column is unsigned or a non-numeric data type.
+
+private:
+	ODBCMetaColumn();
+
+	static const int NAME_BUFFER_LENGTH = 2048;
+
+	struct ColumnDescription
+	{
+		SQLCHAR name[NAME_BUFFER_LENGTH];
+		SQLSMALLINT  nameBufferLength;
+		SQLSMALLINT  dataType;
+		SQLULEN      size;
+		SQLSMALLINT  decimalDigits;
+		SQLSMALLINT  isNullable;
+	};
+
+	void init();
+	void getDescription();
+
+	SQLLEN                 _dataLength;
+	const StatementHandle& _rStmt;
+	ColumnDescription      _columnDesc;
+};
+
+
+///
+/// inlines
+///
+inline std::size_t ODBCMetaColumn::dataLength() const
+{
+	return _dataLength;
+}
+
+
+} } } // namespace Poco::Data::ODBC
+
+
+#endif

base/poco/Data/ODBC/include/Poco/Data/ODBC/ODBCStatementImpl.h

@@ -0,0 +1,206 @@
+//
+// ODBCStatementImpl.h
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  ODBCStatementImpl
+//
+// Definition of the ODBCStatementImpl class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ODBC_ODBCStatementImpl_INCLUDED
+#define Data_ODBC_ODBCStatementImpl_INCLUDED
+
+
+#include "Poco/Data/ODBC/ODBC.h"
+#include "Poco/Data/ODBC/SessionImpl.h"
+#include "Poco/Data/ODBC/Binder.h"
+#include "Poco/Data/ODBC/Extractor.h"
+#include "Poco/Data/ODBC/Preparator.h"
+#include "Poco/Data/ODBC/ODBCMetaColumn.h"
+#include "Poco/Data/StatementImpl.h"
+#include "Poco/Data/Column.h"
+#include "Poco/SharedPtr.h"
+#include "Poco/Format.h"
+#include <sstream>
+#ifdef POCO_OS_FAMILY_WINDOWS
+#include <windows.h>
+#endif
+#include <sqltypes.h>
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+class ODBC_API ODBCStatementImpl: public Poco::Data::StatementImpl
+	/// Implements statement functionality needed for ODBC
+{
+public:
+	ODBCStatementImpl(SessionImpl& rSession);
+		/// Creates the ODBCStatementImpl.
+
+	~ODBCStatementImpl();
+		/// Destroys the ODBCStatementImpl.
+
+protected:
+	std::size_t columnsReturned() const;
+		/// Returns number of columns returned by query.
+
+	int affectedRowCount() const;
+		/// Returns the number of affected rows.
+		/// Used to find out the number of rows affected by insert or update.
+
+	const MetaColumn& metaColumn(std::size_t pos) const;
+		/// Returns column meta data.
+
+	bool hasNext();
+		/// Returns true if a call to next() will return data.
+
+	std::size_t next();
+		/// Retrieves the next row or set of rows from the resultset.
+		/// Returns the number of rows retrieved.
+		/// Will throw, if the resultset is empty.
+
+	bool canBind() const;
+		/// Returns true if a valid statement is set and we can bind.
+
+	bool canCompile() const;
+		/// Returns true if another compile is possible.
+
+	void compileImpl();
+		/// Compiles the statement, doesn't bind yet. 
+		/// Does nothing if the statement has already been compiled.
+
+	void bindImpl();
+		/// Binds all parameters and executes the statement.
+
+	AbstractExtraction::ExtractorPtr extractor();
+		/// Returns the concrete extractor used by the statement.
+
+	AbstractBinding::BinderPtr binder();
+		/// Returns the concrete binder used by the statement.
+
+	std::string nativeSQL();
+		/// Returns the SQL string as modified by the driver.
+
+private:
+	typedef Poco::Data::AbstractBindingVec    Bindings;
+	typedef Poco::SharedPtr<Binder>           BinderPtr;
+	typedef Poco::Data::AbstractExtractionVec Extractions;
+	typedef Poco::SharedPtr<Preparator>       PreparatorPtr;
+	typedef std::vector<PreparatorPtr>        PreparatorVec;
+	typedef Poco::SharedPtr<Extractor>        ExtractorPtr;
+	typedef std::vector<ExtractorPtr>         ExtractorVec;
+	typedef std::vector<ODBCMetaColumn*>      ColumnPtrVec;
+	typedef std::vector<ColumnPtrVec>         ColumnPtrVecVec;
+	
+	static const std::string INVALID_CURSOR_STATE;
+
+	void clear();
+		/// Closes the cursor and resets indicator variables.
+	
+	void doBind();
+		/// Binds parameters.
+
+	void makeInternalExtractors();
+		/// Creates internal extractors if none were supplied from the user.
+
+	bool isStoredProcedure() const;
+		/// Returns true if SQL is a stored procedure call.
+
+	void doPrepare();
+		/// Prepares placeholders for data returned by statement.
+		/// It is called during statement compilation for SQL statements
+		/// returning data. For stored procedures returning datasets, 
+		/// it is called upon the first check for data availability 
+		/// (see hasNext() function).
+
+	bool hasData() const;
+		/// Returns true if statement returns data.
+
+	void makeStep();
+		/// Fetches the next row of data.
+
+	bool nextRowReady() const;
+		/// Returns true if there is a row fetched but not yet extracted.
+
+	void putData();
+		/// Called whenever SQLExecute returns SQL_NEED_DATA. This is expected 
+		/// behavior for PB_AT_EXEC binding mode. 
+
+	void getData();
+
+	void addPreparator();
+	void fillColumns();
+	void checkError(SQLRETURN rc, const std::string& msg="");
+
+	const SQLHDBC&        _rConnection;
+	const StatementHandle _stmt;
+	PreparatorVec         _preparations;
+	BinderPtr             _pBinder;
+	ExtractorVec          _extractors;
+	bool                  _stepCalled;
+	int                   _nextResponse;
+	ColumnPtrVecVec       _columnPtrs;
+	bool                  _prepared;
+	mutable std::size_t   _affectedRowCount;
+	bool                  _canCompile;
+};
+
+
+//
+// inlines
+//
+inline AbstractExtraction::ExtractorPtr ODBCStatementImpl::extractor()
+{
+	poco_assert_dbg (currentDataSet() < _extractors.size());
+	poco_assert_dbg (_extractors[currentDataSet()]);
+	return _extractors[currentDataSet()];
+}
+
+
+inline AbstractBinding::BinderPtr ODBCStatementImpl::binder()
+{
+	poco_assert_dbg (!_pBinder.isNull());
+	return _pBinder;
+}
+
+
+inline std::size_t ODBCStatementImpl::columnsReturned() const
+{
+	poco_assert_dbg (currentDataSet() < _preparations.size());
+	poco_assert_dbg (_preparations[currentDataSet()]);
+	return static_cast<std::size_t>(_preparations[currentDataSet()]->columns());
+}
+
+
+inline bool ODBCStatementImpl::hasData() const
+{
+	return (columnsReturned() > 0);
+}
+
+
+inline bool ODBCStatementImpl::nextRowReady() const
+{
+	return (!Utility::isError(_nextResponse));
+}
+
+
+inline bool ODBCStatementImpl::canCompile() const
+{
+	return _canCompile;
+}
+
+
+} } } // namespace Poco::Data::ODBC
+
+
+#endif // Data_ODBC_ODBCStatementImpl_INCLUDED

base/poco/Data/ODBC/include/Poco/Data/ODBC/Parameter.h

@@ -0,0 +1,111 @@
+//
+// Parameter.h
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Parameter
+//
+// Definition of Parameter.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ODBC_Parameter_INCLUDED
+#define Data_ODBC_Parameter_INCLUDED
+
+
+#include "Poco/Data/ODBC/ODBC.h"
+#include "Poco/Data/ODBC/Handle.h"
+#ifdef POCO_OS_FAMILY_WINDOWS
+#include <windows.h>
+#endif
+#include <sqlext.h>
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+class ODBC_API Parameter
+{
+public:
+	explicit Parameter(const StatementHandle& rStmt, std::size_t colNum);
+		/// Creates the Parameter.
+		
+	~Parameter();
+		/// Destroys the Parameter.
+
+	std::size_t number() const;
+		/// Returns the column number.
+
+	std::size_t dataType() const;
+		/// Returns the SQL data type.
+
+	std::size_t columnSize() const;
+		/// Returns the the size of the column or expression of the corresponding 
+		/// parameter marker as defined by the data source.
+
+	std::size_t decimalDigits() const;
+		/// Returns the number of decimal digits of the column or expression 
+		/// of the corresponding parameter as defined by the data source.
+
+	bool isNullable() const;
+		/// Returns true if column allows null values, false otherwise.
+
+private:
+	Parameter();
+
+	void init();
+
+	SQLSMALLINT _dataType;
+    SQLULEN     _columnSize;
+    SQLSMALLINT _decimalDigits;
+    SQLSMALLINT _isNullable;
+
+	const StatementHandle& _rStmt;
+	std::size_t _number;
+};
+
+
+///
+/// inlines
+///
+inline std::size_t Parameter::number() const
+{
+	return _number;
+}
+
+
+inline std::size_t Parameter::dataType() const
+{
+	return _dataType;
+}
+
+
+inline std::size_t Parameter::columnSize() const
+{
+	return _columnSize;
+}
+
+
+inline std::size_t Parameter::decimalDigits() const
+{
+	return _decimalDigits;
+}
+
+
+inline bool Parameter::isNullable() const
+{
+	return SQL_NULLABLE == _isNullable;
+}
+
+
+} } } // namespace Poco::Data::ODBC
+
+
+#endif

base/poco/Data/ODBC/include/Poco/Data/ODBC/SessionImpl.h

@@ -0,0 +1,290 @@
+//
+// SessionImpl.h
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  SessionImpl
+//
+// Definition of the SessionImpl class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ODBC_SessionImpl_INCLUDED
+#define Data_ODBC_SessionImpl_INCLUDED
+
+
+#include "Poco/Data/ODBC/ODBC.h"
+#include "Poco/Data/ODBC/Connector.h"
+#include "Poco/Data/ODBC/TypeInfo.h"
+#include "Poco/Data/ODBC/Binder.h"
+#include "Poco/Data/ODBC/Handle.h"
+#include "Poco/Data/ODBC/ODBCException.h"
+#include "Poco/Data/AbstractSessionImpl.h"
+#include "Poco/SharedPtr.h"
+#include "Poco/Mutex.h"
+#ifdef POCO_OS_FAMILY_WINDOWS
+#include <windows.h>
+#endif
+#include <sqltypes.h>
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+class ODBC_API SessionImpl: public Poco::Data::AbstractSessionImpl<SessionImpl>
+	/// Implements SessionImpl interface
+{
+public:
+	static const std::size_t ODBC_MAX_FIELD_SIZE = 1024u;
+
+	enum TransactionCapability
+	{
+		ODBC_TXN_CAPABILITY_UNKNOWN = -1,
+		ODBC_TXN_CAPABILITY_FALSE = 0,
+		ODBC_TXN_CAPABILITY_TRUE = 1
+	};
+
+	SessionImpl(const std::string& connect,
+		std::size_t loginTimeout,
+		std::size_t maxFieldSize = ODBC_MAX_FIELD_SIZE, 
+		bool autoBind = true,
+		bool autoExtract = true);
+		/// Creates the SessionImpl. Opens a connection to the database.
+		/// Throws NotConnectedException if connection was not succesful.
+
+	//@ deprecated
+	SessionImpl(const std::string& connect, 
+		Poco::Any maxFieldSize = ODBC_MAX_FIELD_SIZE, 
+		bool enforceCapability=false,
+		bool autoBind = true,
+		bool autoExtract = true);
+		/// Creates the SessionImpl. Opens a connection to the database.
+
+	~SessionImpl();
+		/// Destroys the SessionImpl.
+
+	Poco::Data::StatementImpl* createStatementImpl();
+		/// Returns an ODBC StatementImpl
+
+	void open(const std::string& connect = "");
+		/// Opens a connection to the Database
+
+	void close();
+		/// Closes the connection
+
+	bool isConnected();
+		/// Returns true if session is connected
+
+	void setConnectionTimeout(std::size_t timeout);
+		/// Sets the session connection timeout value.
+
+	std::size_t getConnectionTimeout();
+		/// Returns the session connection timeout value.
+
+	void begin();
+		/// Starts a transaction
+
+	void commit();
+		/// Commits and ends a transaction
+
+	void rollback();
+		/// Aborts a transaction
+
+	bool isTransaction();
+		/// Returns true iff a transaction is in progress.
+
+	const std::string& connectorName() const;
+		/// Returns the name of the connector.
+
+	bool canTransact();
+		/// Returns true if connection is transaction-capable.
+
+	void setTransactionIsolation(Poco::UInt32 ti);
+		/// Sets the transaction isolation level.
+
+	Poco::UInt32 getTransactionIsolation();
+		/// Returns the transaction isolation level.
+
+	bool hasTransactionIsolation(Poco::UInt32);
+		/// Returns true iff the transaction isolation level corresponding
+		/// to the supplied bitmask is supported.
+
+	bool isTransactionIsolation(Poco::UInt32);
+		/// Returns true iff the transaction isolation level corresponds
+		/// to the supplied bitmask.
+
+	void autoCommit(const std::string&, bool val);
+		/// Sets autocommit property for the session.
+
+	bool isAutoCommit(const std::string& name="");
+		/// Returns autocommit property value.
+
+	void autoBind(const std::string&, bool val);
+		/// Sets automatic binding for the session.
+
+	bool isAutoBind(const std::string& name="");
+		/// Returns true if binding is automatic for this session.
+
+	void autoExtract(const std::string&, bool val);
+		/// Sets automatic extraction for the session.
+
+	bool isAutoExtract(const std::string& name="");
+		/// Returns true if extraction is automatic for this session.
+
+	void setMaxFieldSize(const std::string& rName, const Poco::Any& rValue);
+		/// Sets the max field size (the default used when column size is unknown).
+		
+	Poco::Any getMaxFieldSize(const std::string& rName="");
+		/// Returns the max field size (the default used when column size is unknown).
+
+	int maxStatementLength();
+		/// Returns maximum length of SQL statement allowed by driver.
+
+	void setQueryTimeout(const std::string&, const Poco::Any& value);
+		/// Sets the timeout (in seconds) for queries.
+		/// Value must be of type int.
+		
+	Poco::Any getQueryTimeout(const std::string&);
+		/// Returns the timeout (in seconds) for queries,
+		/// or -1 if no timeout has been set.
+		
+	int queryTimeout() const;
+		/// Returns the timeout (in seconds) for queries,
+		/// or -1 if no timeout has been set.
+
+	const ConnectionHandle& dbc() const;
+		/// Returns the connection handle.
+
+	Poco::Any dataTypeInfo(const std::string& rName="");
+		/// Returns the data types information.
+
+private:
+	void setDataTypeInfo(const std::string& rName, const Poco::Any& rValue);
+		/// No-op. Throws InvalidAccessException.
+
+	static const int FUNCTIONS = SQL_API_ODBC3_ALL_FUNCTIONS_SIZE;
+
+	void checkError(SQLRETURN rc, const std::string& msg="");
+
+	Poco::UInt32 getDefaultTransactionIsolation();
+
+	Poco::UInt32 transactionIsolation(SQLULEN isolation);
+
+	std::string            _connector;
+	const ConnectionHandle _db;
+	Poco::Any              _maxFieldSize;
+	bool                   _autoBind;
+	bool                   _autoExtract;
+	TypeInfo               _dataTypes;
+	char                   _canTransact;
+	bool                   _inTransaction;
+	int                    _queryTimeout;
+	Poco::FastMutex        _mutex;
+};
+
+
+///
+/// inlines
+///
+inline void SessionImpl::checkError(SQLRETURN rc, const std::string& msg)
+{
+	if (Utility::isError(rc))
+		throw ConnectionException(_db, msg);
+}
+
+
+inline const ConnectionHandle& SessionImpl::dbc() const
+{
+	return _db;
+}
+
+
+inline void SessionImpl::setMaxFieldSize(const std::string& rName, const Poco::Any& rValue)
+{
+	_maxFieldSize = rValue;
+}
+
+		
+inline Poco::Any SessionImpl::getMaxFieldSize(const std::string& rName)
+{
+	return _maxFieldSize;
+}
+
+
+inline void SessionImpl::setDataTypeInfo(const std::string& rName, const Poco::Any& rValue)
+{
+	throw InvalidAccessException();
+}
+
+		
+inline Poco::Any SessionImpl::dataTypeInfo(const std::string& rName)
+{
+	return &_dataTypes;
+}
+
+
+inline void SessionImpl::autoBind(const std::string&, bool val)
+{
+	_autoBind = val;
+}
+
+
+inline bool SessionImpl::isAutoBind(const std::string& name)
+{
+	return _autoBind;
+}
+
+
+inline void SessionImpl::autoExtract(const std::string&, bool val)
+{
+	_autoExtract = val;
+}
+
+
+inline bool SessionImpl::isAutoExtract(const std::string& name)
+{
+	return _autoExtract;
+}
+
+
+inline const std::string& SessionImpl::connectorName() const
+{
+	return _connector;
+}
+
+
+inline bool SessionImpl::isTransactionIsolation(Poco::UInt32 ti)
+{
+	return 0 != (ti & getTransactionIsolation());
+}
+
+
+inline void SessionImpl::setQueryTimeout(const std::string&, const Poco::Any& value)
+{
+	_queryTimeout = Poco::AnyCast<int>(value);
+}
+
+
+inline Poco::Any SessionImpl::getQueryTimeout(const std::string&)
+{
+	return _queryTimeout;
+}
+
+
+inline int SessionImpl::queryTimeout() const
+{
+	return _queryTimeout;
+}
+
+
+} } } // namespace Poco::Data::ODBC
+
+
+#endif // Data_ODBC_SessionImpl_INCLUDED

base/poco/Data/ODBC/include/Poco/Data/ODBC/TypeInfo.h

@@ -0,0 +1,117 @@
+//
+// TypeInfo.h
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  TypeInfo
+//
+// Definition of TypeInfo.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ODBC_DataTypes_INCLUDED
+#define Data_ODBC_DataTypes_INCLUDED
+
+
+#include "Poco/Data/ODBC/ODBC.h"
+#include "Poco/NamedTuple.h"
+#include "Poco/DynamicAny.h"
+#include <vector>
+#include <map>
+#ifdef POCO_OS_FAMILY_WINDOWS
+#include <windows.h>
+#endif
+#include <sqlext.h>
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+class ODBC_API TypeInfo
+	/// Datatypes mapping utility class.
+	///
+	/// This class provides mapping between C and SQL datatypes as well
+	/// as datatypes supported by the underlying database. In order for database
+	/// types to be available, a valid conection handle must be supplied at either
+	/// object construction time, or at a later point in time, through call to
+	/// fillTypeInfo member function.
+	///
+	/// Class also provides a convenient debugging function that prints
+	/// tabulated data to an output stream.
+{
+public:
+	typedef std::map<int, int> DataTypeMap;
+	typedef DataTypeMap::value_type ValueType;
+	typedef Poco::NamedTuple<std::string,
+		SQLSMALLINT,
+		SQLINTEGER,
+		std::string,
+		std::string,
+		std::string,
+		SQLSMALLINT,
+		SQLSMALLINT,
+		SQLSMALLINT,
+		SQLSMALLINT,
+		SQLSMALLINT,
+		SQLSMALLINT,
+		std::string,
+		SQLSMALLINT,
+		SQLSMALLINT,
+		SQLSMALLINT,
+		SQLSMALLINT,
+		SQLINTEGER,
+		SQLSMALLINT> TypeInfoTup;
+	typedef std::vector<TypeInfoTup> TypeInfoVec;
+
+	explicit TypeInfo(SQLHDBC* pHDBC=0);
+		/// Creates the TypeInfo.
+
+	~TypeInfo();
+		/// Destroys the TypeInfo.
+
+	int cDataType(int sqlDataType) const;
+		/// Returns C data type corresponding to supplied SQL data type.
+
+	int sqlDataType(int cDataType) const;
+		/// Returns SQL data type corresponding to supplied C data type.
+
+	void fillTypeInfo(SQLHDBC pHDBC);
+		/// Fills the data type info structure for the database.
+
+	DynamicAny getInfo(SQLSMALLINT type, const std::string& param) const;
+		/// Returns information about specified data type as specified by parameter 'type'.
+		/// The requested information is specified by parameter 'param'.
+		/// Will fail with a Poco::NotFoundException thrown if the param is not found
+		
+	bool tryGetInfo(SQLSMALLINT type, const std::string& param, DynamicAny& result) const;
+		/// Returns information about specified data type as specified by parameter 'type' in param result.
+		/// The requested information is specified by parameter 'param'.
+		/// Will return false if the param is not found. The value of result will be not changed in this case.
+			
+
+	void print(std::ostream& ostr);
+		/// Prints all the types (as reported by the underlying database)
+		/// to the supplied output stream.
+
+private:
+	void fillCTypes();
+	void fillSQLTypes();
+
+	DataTypeMap _cDataTypes; 
+	DataTypeMap _sqlDataTypes; 
+	TypeInfoVec _typeInfo;
+	SQLHDBC*    _pHDBC;
+};
+
+
+} } } // namespace Poco::Data::ODBC
+
+
+#endif

base/poco/Data/ODBC/include/Poco/Data/ODBC/Unicode.h

@@ -0,0 +1,985 @@
+//
+// Unicode.h
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Unicode
+//
+// Definition of Unicode.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ODBC_Unicode_INCLUDED
+#define Data_ODBC_Unicode_INCLUDED
+
+
+#include "Poco/UnicodeConverter.h"
+#include "Poco/Buffer.h"
+#include "Poco/Exception.h"
+#include <cstring>
+#ifdef POCO_OS_FAMILY_WINDOWS
+	#include <windows.h>
+#endif
+#ifndef SQL_NOUNICODEMAP
+	#define SQL_NOUNICODEMAP
+#endif
+#include <sqlext.h>
+#include <sqltypes.h>
+#include <sqlucode.h>
+
+
+#if defined(POCO_OS_FAMILY_WINDOWS) && defined(POCO_WIN32_UTF8)
+	#define POCO_ODBC_UNICODE
+	#define POCO_ODBC_UNICODE_WINDOWS
+#elif defined(POCO_OS_FAMILY_UNIX) && defined(UNICODE)
+	#define POCO_ODBC_UNICODE
+	#ifdef POCO_UNIXODBC
+		#define POCO_ODBC_UNICODE_UNIXODBC
+	#elif defined(POCO_IODBC)
+		#error "iODBC Unicode not supported"
+	#endif
+#endif
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+#if defined(POCO_PTR_IS_64_BIT) || defined(POCO_OS_FAMILY_UNIX) // mkrivos - POCO_OS_FAMILY_UNIX doesn't compile with SQLPOINTER & SQLColAttribute()
+	typedef SQLLEN* NumAttrPtrType;
+#else
+	typedef SQLPOINTER NumAttrPtrType;
+#endif
+
+
+SQLRETURN ODBC_API SQLColAttribute(SQLHSTMT hstmt,
+	SQLUSMALLINT   iCol,
+	SQLUSMALLINT   iField,
+	SQLPOINTER	   pCharAttr,
+	SQLSMALLINT	   cbCharAttrMax,
+	SQLSMALLINT*   pcbCharAttr,
+	NumAttrPtrType pNumAttr);
+
+
+SQLRETURN ODBC_API SQLColAttributes(SQLHSTMT hstmt,
+	SQLUSMALLINT icol,
+	SQLUSMALLINT fDescType,
+	SQLPOINTER   rgbDesc,
+	SQLSMALLINT  cbDescMax,
+	SQLSMALLINT* pcbDesc,
+	SQLLEN*      pfDesc);
+
+SQLRETURN ODBC_API SQLConnect(SQLHDBC hdbc,
+	SQLCHAR*    szDSN,
+	SQLSMALLINT cbDSN,
+	SQLCHAR*    szUID,
+	SQLSMALLINT cbUID,
+	SQLCHAR*    szAuthStr,
+	SQLSMALLINT cbAuthStr);
+
+SQLRETURN ODBC_API SQLDescribeCol(SQLHSTMT hstmt,
+	SQLUSMALLINT icol,
+	SQLCHAR*     szColName,
+	SQLSMALLINT  cbColNameMax,
+	SQLSMALLINT* pcbColName,
+	SQLSMALLINT* pfSqlType,
+	SQLULEN*     pcbColDef,
+	SQLSMALLINT* pibScale,
+	SQLSMALLINT* pfNullable);
+
+SQLRETURN ODBC_API SQLError(SQLHENV henv,
+	SQLHDBC      hdbc,
+	SQLHSTMT     hstmt,
+	SQLCHAR*     szSqlState,
+	SQLINTEGER*  pfNativeError,
+	SQLCHAR*     szErrorMsg,
+	SQLSMALLINT  cbErrorMsgMax,
+	SQLSMALLINT* pcbErrorMsg);
+
+SQLRETURN ODBC_API SQLExecDirect(SQLHSTMT hstmt,
+	SQLCHAR*   szSqlStr,
+	SQLINTEGER cbSqlStr);
+
+SQLRETURN ODBC_API SQLGetConnectAttr(SQLHDBC hdbc,
+	SQLINTEGER  fAttribute,
+	SQLPOINTER  rgbValue,
+	SQLINTEGER  cbValueMax,
+	SQLINTEGER* pcbValue);
+
+SQLRETURN ODBC_API SQLGetCursorName(SQLHSTMT hstmt,
+	SQLCHAR*     szCursor,
+	SQLSMALLINT  cbCursorMax,
+	SQLSMALLINT* pcbCursor);
+
+SQLRETURN ODBC_API SQLSetDescField(SQLHDESC DescriptorHandle,
+	SQLSMALLINT RecNumber,
+	SQLSMALLINT FieldIdentifier,
+	SQLPOINTER  Value,
+	SQLINTEGER  BufferLength);
+
+SQLRETURN ODBC_API SQLGetDescField(SQLHDESC hdesc,
+	SQLSMALLINT iRecord,
+	SQLSMALLINT iField,
+	SQLPOINTER  rgbValue,
+	SQLINTEGER	cbValueMax,
+	SQLINTEGER* pcbValue);
+
+SQLRETURN ODBC_API SQLGetDescRec(SQLHDESC hdesc,
+	SQLSMALLINT  iRecord,
+	SQLCHAR*     szName,
+	SQLSMALLINT  cbNameMax,
+	SQLSMALLINT* pcbName,
+	SQLSMALLINT* pfType,
+	SQLSMALLINT* pfSubType,
+	SQLLEN*      pLength,
+	SQLSMALLINT* pPrecision,
+	SQLSMALLINT* pScale,
+	SQLSMALLINT* pNullable);
+
+SQLRETURN ODBC_API SQLGetDiagField(SQLSMALLINT fHandleType,
+	SQLHANDLE    handle,
+	SQLSMALLINT  iRecord,
+	SQLSMALLINT  fDiagField,
+	SQLPOINTER   rgbDiagInfo,
+	SQLSMALLINT  cbDiagInfoMax,
+	SQLSMALLINT* pcbDiagInfo);
+
+SQLRETURN ODBC_API SQLGetDiagRec(SQLSMALLINT fHandleType,
+	SQLHANDLE    handle,
+	SQLSMALLINT  iRecord,
+	SQLCHAR*     szSqlState,
+	SQLINTEGER*  pfNativeError,
+	SQLCHAR*     szErrorMsg,
+	SQLSMALLINT  cbErrorMsgMax,
+	SQLSMALLINT* pcbErrorMsg);
+
+SQLRETURN ODBC_API SQLPrepare(SQLHSTMT hstmt,
+	SQLCHAR*   szSqlStr,
+	SQLINTEGER cbSqlStr);
+
+SQLRETURN ODBC_API SQLSetConnectAttr(SQLHDBC hdbc,
+	SQLINTEGER fAttribute,
+	SQLPOINTER rgbValue,
+	SQLINTEGER cbValue);
+
+SQLRETURN ODBC_API SQLSetCursorName(SQLHSTMT hstmt,
+	SQLCHAR*    szCursor,
+	SQLSMALLINT cbCursor);
+
+SQLRETURN ODBC_API SQLSetStmtAttr(SQLHSTMT hstmt,
+	SQLINTEGER fAttribute,
+	SQLPOINTER rgbValue,
+	SQLINTEGER cbValueMax);
+
+SQLRETURN ODBC_API SQLGetStmtAttr(SQLHSTMT hstmt,
+	SQLINTEGER  fAttribute,
+	SQLPOINTER  rgbValue,
+	SQLINTEGER  cbValueMax,
+	SQLINTEGER* pcbValue);
+
+SQLRETURN ODBC_API SQLColumns(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName,
+	SQLCHAR*    szColumnName,
+	SQLSMALLINT cbColumnName);
+
+SQLRETURN ODBC_API SQLGetConnectOption(SQLHDBC hdbc,
+	SQLUSMALLINT fOption,
+	SQLPOINTER   pvParam);
+
+SQLRETURN ODBC_API SQLGetInfo(SQLHDBC hdbc,
+	SQLUSMALLINT fInfoType,
+	SQLPOINTER   rgbInfoValue,
+	SQLSMALLINT  cbInfoValueMax,
+	SQLSMALLINT* pcbInfoValue);
+
+SQLRETURN ODBC_API SQLGetTypeInfo(SQLHSTMT StatementHandle,
+	SQLSMALLINT	DataType);
+
+SQLRETURN ODBC_API SQLSetConnectOption(SQLHDBC hdbc,
+	SQLUSMALLINT fOption,
+	SQLULEN      vParam);
+
+SQLRETURN ODBC_API SQLSpecialColumns(SQLHSTMT hstmt,
+	SQLUSMALLINT fColType,
+	SQLCHAR*     szCatalogName,
+	SQLSMALLINT  cbCatalogName,
+	SQLCHAR*     szSchemaName,
+	SQLSMALLINT  cbSchemaName,
+	SQLCHAR*     szTableName,
+	SQLSMALLINT  cbTableName,
+	SQLUSMALLINT fScope,
+	SQLUSMALLINT fNullable);
+
+SQLRETURN ODBC_API SQLStatistics(SQLHSTMT hstmt,
+	SQLCHAR*     szCatalogName,
+	SQLSMALLINT  cbCatalogName,
+	SQLCHAR*     szSchemaName,
+	SQLSMALLINT  cbSchemaName,
+	SQLCHAR*     szTableName,
+	SQLSMALLINT  cbTableName,
+	SQLUSMALLINT fUnique,
+	SQLUSMALLINT fAccuracy);
+
+SQLRETURN ODBC_API SQLTables(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName,
+	SQLCHAR*    szTableType,
+	SQLSMALLINT cbTableType);
+
+SQLRETURN ODBC_API SQLDataSources(SQLHENV henv,
+	SQLUSMALLINT fDirection,
+	SQLCHAR*     szDSN,
+	SQLSMALLINT  cbDSNMax,
+	SQLSMALLINT* pcbDSN,
+	SQLCHAR*     szDescription,
+	SQLSMALLINT  cbDescriptionMax,
+	SQLSMALLINT* pcbDescription);
+
+SQLRETURN ODBC_API SQLDriverConnect(SQLHDBC hdbc,
+	SQLHWND      hwnd,
+	SQLCHAR*     szConnStrIn,
+	SQLSMALLINT  cbConnStrIn,
+	SQLCHAR*     szConnStrOut,
+	SQLSMALLINT  cbConnStrOutMax,
+	SQLSMALLINT* pcbConnStrOut,
+	SQLUSMALLINT fDriverCompletion);
+
+SQLRETURN ODBC_API SQLBrowseConnect(SQLHDBC hdbc,
+	SQLCHAR*     szConnStrIn,
+	SQLSMALLINT  cbConnStrIn,
+	SQLCHAR*     szConnStrOut,
+	SQLSMALLINT  cbConnStrOutMax,
+	SQLSMALLINT* pcbConnStrOut);
+
+SQLRETURN ODBC_API SQLColumnPrivileges(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName,
+	SQLCHAR*    szColumnName,
+	SQLSMALLINT cbColumnName);
+
+SQLRETURN ODBC_API SQLForeignKeys(SQLHSTMT hstmt,
+	SQLCHAR*    szPkCatalogName,
+	SQLSMALLINT cbPkCatalogName,
+	SQLCHAR*    szPkSchemaName,
+	SQLSMALLINT cbPkSchemaName,
+	SQLCHAR*    szPkTableName,
+	SQLSMALLINT cbPkTableName,
+	SQLCHAR*    szFkCatalogName,
+	SQLSMALLINT cbFkCatalogName,
+	SQLCHAR*    szFkSchemaName,
+	SQLSMALLINT cbFkSchemaName,
+	SQLCHAR*    szFkTableName,
+	SQLSMALLINT cbFkTableName);
+
+SQLRETURN ODBC_API SQLNativeSql(SQLHDBC hdbc,
+	SQLCHAR*    szSqlStrIn,
+	SQLINTEGER  cbSqlStrIn,
+	SQLCHAR*    szSqlStr,
+	SQLINTEGER  cbSqlStrMax,
+	SQLINTEGER* pcbSqlStr);
+
+SQLRETURN ODBC_API SQLPrimaryKeys(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName);
+
+SQLRETURN ODBC_API SQLProcedureColumns(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szProcName,
+	SQLSMALLINT cbProcName,
+	SQLCHAR*    szColumnName,
+	SQLSMALLINT cbColumnName);
+
+SQLRETURN ODBC_API SQLProcedures(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szProcName,
+	SQLSMALLINT cbProcName);
+
+SQLRETURN ODBC_API SQLTablePrivileges(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName);
+
+SQLRETURN ODBC_API SQLDrivers(SQLHENV henv,
+	SQLUSMALLINT fDirection,
+	SQLCHAR*     szDriverDesc,
+	SQLSMALLINT  cbDriverDescMax,
+	SQLSMALLINT* pcbDriverDesc,
+	SQLCHAR*     szDriverAttributes,
+	SQLSMALLINT  cbDrvrAttrMax,
+	SQLSMALLINT* pcbDrvrAttr);
+
+
+///
+/// inlines
+///
+
+inline bool isString(SQLPOINTER pValue, SQLINTEGER length)
+{
+	return (SQL_NTS == length || length > 0) && pValue;
+}
+
+
+inline SQLINTEGER stringLength(SQLPOINTER pValue, SQLINTEGER length)
+{
+	if (SQL_NTS != length) return length;
+
+	return (SQLINTEGER) std::strlen((const char*) pValue);
+}
+
+
+#if !defined(POCO_ODBC_UNICODE)
+
+
+///
+/// inlines
+///
+
+inline SQLRETURN SQLColAttribute(SQLHSTMT hstmt,
+	SQLUSMALLINT   iCol,
+	SQLUSMALLINT   iField,
+	SQLPOINTER     pCharAttr,
+	SQLSMALLINT    cbCharAttrMax,
+	SQLSMALLINT*   pcbCharAttr,
+	NumAttrPtrType pNumAttr)
+{
+	return ::SQLColAttributeA(hstmt,
+		iCol,
+		iField,
+		pCharAttr,
+		cbCharAttrMax,
+		pcbCharAttr,
+		pNumAttr);
+}
+
+
+inline SQLRETURN SQLColAttributes(SQLHSTMT hstmt,
+	SQLUSMALLINT icol,
+	SQLUSMALLINT fDescType,
+	SQLPOINTER   rgbDesc,
+	SQLSMALLINT  cbDescMax,
+	SQLSMALLINT* pcbDesc,
+	SQLLEN*      pfDesc)
+{
+	return ::SQLColAttributesA(hstmt,
+		icol,
+		fDescType,
+		rgbDesc,
+		cbDescMax,
+		pcbDesc,
+		pfDesc);
+}
+
+
+inline SQLRETURN SQLConnect(SQLHDBC hdbc,
+	SQLCHAR*    szDSN,
+	SQLSMALLINT cbDSN,
+	SQLCHAR*    szUID,
+	SQLSMALLINT cbUID,
+	SQLCHAR*    szAuthStr,
+	SQLSMALLINT cbAuthStr)
+{
+	return ::SQLConnectA(hdbc,
+		szDSN,
+		cbDSN,
+		szUID,
+		cbUID,
+		szAuthStr,
+		cbAuthStr);
+}
+
+
+inline SQLRETURN SQLDescribeCol(SQLHSTMT hstmt,
+	SQLUSMALLINT icol,
+	SQLCHAR*     szColName,
+	SQLSMALLINT  cbColNameMax,
+	SQLSMALLINT* pcbColName,
+	SQLSMALLINT* pfSqlType,
+	SQLULEN*     pcbColDef,
+	SQLSMALLINT* pibScale,
+	SQLSMALLINT* pfNullable)
+{
+	return ::SQLDescribeColA(hstmt,
+		icol,
+		szColName,
+		cbColNameMax,
+		pcbColName,
+		pfSqlType,
+		pcbColDef,
+		pibScale,
+		pfNullable);
+}
+
+
+inline SQLRETURN SQLError(SQLHENV henv,
+	SQLHDBC      hdbc,
+	SQLHSTMT     hstmt,
+	SQLCHAR*     szSqlState,
+	SQLINTEGER*  pfNativeError,
+	SQLCHAR*     szErrorMsg,
+	SQLSMALLINT  cbErrorMsgMax,
+	SQLSMALLINT* pcbErrorMsg)
+{
+	throw Poco::NotImplementedException("SQLError is obsolete. "
+		"Use SQLGetDiagRec instead.");
+}
+
+
+inline SQLRETURN SQLExecDirect(SQLHSTMT hstmt,
+	SQLCHAR*   szSqlStr,
+	SQLINTEGER cbSqlStr)
+{
+	return ::SQLExecDirectA(hstmt, szSqlStr, cbSqlStr);
+}
+
+
+inline SQLRETURN SQLGetConnectAttr(SQLHDBC hdbc,
+	SQLINTEGER  fAttribute,
+	SQLPOINTER  rgbValue,
+	SQLINTEGER  cbValueMax,
+	SQLINTEGER* pcbValue)
+{
+	return ::SQLGetConnectAttrA(hdbc,
+		fAttribute,
+		rgbValue,
+		cbValueMax,
+		pcbValue);
+}
+
+
+inline SQLRETURN SQLGetCursorName(SQLHSTMT hstmt,
+	SQLCHAR*     szCursor,
+	SQLSMALLINT  cbCursorMax,
+	SQLSMALLINT* pcbCursor)
+{
+	throw Poco::NotImplementedException("Not implemented");
+}
+
+
+inline SQLRETURN SQLSetDescField(SQLHDESC DescriptorHandle,
+	SQLSMALLINT RecNumber,
+	SQLSMALLINT FieldIdentifier,
+	SQLPOINTER  Value,
+	SQLINTEGER  BufferLength)
+{
+	return ::SQLSetDescField(DescriptorHandle,
+		RecNumber,
+		FieldIdentifier,
+		Value,
+		BufferLength);
+}
+
+
+inline SQLRETURN SQLGetDescField(SQLHDESC hdesc,
+	SQLSMALLINT iRecord,
+	SQLSMALLINT iField,
+	SQLPOINTER  rgbValue,
+	SQLINTEGER	cbValueMax,
+	SQLINTEGER* pcbValue)
+{
+	return ::SQLGetDescFieldA(hdesc,
+		iRecord,
+		iField,
+		rgbValue,
+		cbValueMax,
+		pcbValue);
+}
+
+
+inline SQLRETURN SQLGetDescRec(SQLHDESC hdesc,
+	SQLSMALLINT  iRecord,
+	SQLCHAR*     szName,
+	SQLSMALLINT  cbNameMax,
+	SQLSMALLINT* pcbName,
+	SQLSMALLINT* pfType,
+	SQLSMALLINT* pfSubType,
+	SQLLEN*      pLength,
+	SQLSMALLINT* pPrecision,
+	SQLSMALLINT* pScale,
+	SQLSMALLINT* pNullable)
+{
+	return ::SQLGetDescRecA(hdesc,
+		iRecord,
+		szName,
+		cbNameMax,
+		pcbName,
+		pfType,
+		pfSubType,
+		pLength,
+		pPrecision,
+		pScale,
+		pNullable);
+}
+
+
+inline SQLRETURN SQLGetDiagField(SQLSMALLINT fHandleType,
+	SQLHANDLE    handle,
+	SQLSMALLINT  iRecord,
+	SQLSMALLINT  fDiagField,
+	SQLPOINTER   rgbDiagInfo,
+	SQLSMALLINT  cbDiagInfoMax,
+	SQLSMALLINT* pcbDiagInfo)
+{
+	return ::SQLGetDiagFieldA(fHandleType,
+		handle,
+		iRecord,
+		fDiagField,
+		rgbDiagInfo,
+		cbDiagInfoMax,
+		pcbDiagInfo);
+}
+
+
+inline SQLRETURN SQLGetDiagRec(SQLSMALLINT fHandleType,
+	SQLHANDLE    handle,
+	SQLSMALLINT  iRecord,
+	SQLCHAR*     szSqlState,
+	SQLINTEGER*  pfNativeError,
+	SQLCHAR*     szErrorMsg,
+	SQLSMALLINT  cbErrorMsgMax,
+	SQLSMALLINT* pcbErrorMsg)
+{
+	return ::SQLGetDiagRecA(fHandleType,
+		handle,
+		iRecord,
+		szSqlState,
+		pfNativeError,
+		szErrorMsg,
+		cbErrorMsgMax,
+		pcbErrorMsg);
+}
+
+
+inline SQLRETURN SQLPrepare(SQLHSTMT hstmt,
+	SQLCHAR*   szSqlStr,
+	SQLINTEGER cbSqlStr)
+{
+	return ::SQLPrepareA(hstmt,	szSqlStr, cbSqlStr);
+}
+
+
+inline SQLRETURN SQLSetConnectAttr(SQLHDBC hdbc,
+	SQLINTEGER fAttribute,
+	SQLPOINTER rgbValue,
+	SQLINTEGER cbValue)
+{
+	return ::SQLSetConnectAttrA(hdbc,	fAttribute,	rgbValue, cbValue);
+}
+
+
+inline SQLRETURN SQLSetCursorName(SQLHSTMT hstmt,
+	SQLCHAR*    szCursor,
+	SQLSMALLINT cbCursor)
+{
+	throw Poco::NotImplementedException("Not implemented");
+}
+
+
+inline SQLRETURN SQLSetStmtAttr(SQLHSTMT hstmt,
+	SQLINTEGER fAttribute,
+	SQLPOINTER rgbValue,
+	SQLINTEGER cbValueMax)
+{
+	return ::SQLSetStmtAttr(hstmt, fAttribute, rgbValue, cbValueMax);
+}
+
+
+inline SQLRETURN SQLGetStmtAttr(SQLHSTMT hstmt,
+	SQLINTEGER  fAttribute,
+	SQLPOINTER  rgbValue,
+	SQLINTEGER  cbValueMax,
+	SQLINTEGER* pcbValue)
+{
+	return ::SQLGetStmtAttrA(hstmt,
+		fAttribute,
+		rgbValue,
+		cbValueMax,
+		pcbValue);
+}
+
+
+inline SQLRETURN SQLColumns(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName,
+	SQLCHAR*    szColumnName,
+	SQLSMALLINT cbColumnName)
+{
+	return ::SQLColumnsA(hstmt,
+		szCatalogName,
+		cbCatalogName,
+		szSchemaName,
+		cbSchemaName,
+		szTableName,
+		cbTableName,
+		szColumnName,
+		cbColumnName);
+}
+
+
+inline SQLRETURN SQLGetConnectOption(SQLHDBC hdbc,
+	SQLUSMALLINT fOption,
+	SQLPOINTER   pvParam)
+{
+	return ::SQLGetConnectOptionA(hdbc, fOption, pvParam);
+}
+
+
+inline SQLRETURN SQLGetInfo(SQLHDBC hdbc,
+	SQLUSMALLINT fInfoType,
+	SQLPOINTER   rgbInfoValue,
+	SQLSMALLINT  cbInfoValueMax,
+	SQLSMALLINT* pcbInfoValue)
+{
+	return ::SQLGetInfoA(hdbc,
+		fInfoType,
+		rgbInfoValue,
+		cbInfoValueMax,
+		pcbInfoValue);
+}
+
+
+inline SQLRETURN SQLGetTypeInfo(SQLHSTMT StatementHandle,
+	SQLSMALLINT	DataType)
+{
+	return ::SQLGetTypeInfoA(StatementHandle, DataType);
+}
+
+
+inline SQLRETURN SQLSetConnectOption(SQLHDBC hdbc,
+	SQLUSMALLINT fOption,
+	SQLULEN      vParam)
+{
+	return ::SQLSetConnectOptionA(hdbc, fOption, vParam);
+}
+
+
+inline SQLRETURN SQLSpecialColumns(SQLHSTMT hstmt,
+	SQLUSMALLINT fColType,
+	SQLCHAR*     szCatalogName,
+	SQLSMALLINT  cbCatalogName,
+	SQLCHAR*     szSchemaName,
+	SQLSMALLINT  cbSchemaName,
+	SQLCHAR*     szTableName,
+	SQLSMALLINT  cbTableName,
+	SQLUSMALLINT fScope,
+	SQLUSMALLINT fNullable)
+{
+	return ::SQLSpecialColumnsA(hstmt,
+		fColType,
+		szCatalogName,
+		cbCatalogName,
+		szSchemaName,
+		cbSchemaName,
+		szTableName,
+		cbTableName,
+		fScope,
+		fNullable);
+}
+
+
+inline SQLRETURN SQLStatistics(SQLHSTMT hstmt,
+	SQLCHAR*     szCatalogName,
+	SQLSMALLINT  cbCatalogName,
+	SQLCHAR*     szSchemaName,
+	SQLSMALLINT  cbSchemaName,
+	SQLCHAR*     szTableName,
+	SQLSMALLINT  cbTableName,
+	SQLUSMALLINT fUnique,
+	SQLUSMALLINT fAccuracy)
+{
+	return ::SQLStatisticsA(hstmt,
+		szCatalogName,
+		cbCatalogName,
+		szSchemaName,
+		cbSchemaName,
+		szTableName,
+		cbTableName,
+		fUnique,
+		fAccuracy);
+}
+
+
+inline SQLRETURN SQLTables(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName,
+	SQLCHAR*    szTableType,
+	SQLSMALLINT cbTableType)
+{
+	return ::SQLTablesA(hstmt,
+		szCatalogName,
+		cbCatalogName,
+		szSchemaName,
+		cbSchemaName,
+		szTableName,
+		cbTableName,
+		szTableType,
+		cbTableType);
+}
+
+
+inline SQLRETURN SQLDataSources(SQLHENV henv,
+	SQLUSMALLINT fDirection,
+	SQLCHAR*     szDSN,
+	SQLSMALLINT  cbDSNMax,
+	SQLSMALLINT* pcbDSN,
+	SQLCHAR*     szDescription,
+	SQLSMALLINT  cbDescriptionMax,
+	SQLSMALLINT* pcbDescription)
+{
+	return ::SQLDataSourcesA(henv,
+		fDirection,
+		szDSN,
+		cbDSNMax,
+		pcbDSN,
+		szDescription,
+		cbDescriptionMax,
+		pcbDescription);
+}
+
+
+inline SQLRETURN SQLDriverConnect(SQLHDBC hdbc,
+	SQLHWND      hwnd,
+	SQLCHAR*     szConnStrIn,
+	SQLSMALLINT  cbConnStrIn,
+	SQLCHAR*     szConnStrOut,
+	SQLSMALLINT  cbConnStrOutMax,
+	SQLSMALLINT* pcbConnStrOut,
+	SQLUSMALLINT fDriverCompletion)
+{
+	return ::SQLDriverConnectA(hdbc,
+		hwnd,
+		szConnStrIn,
+		cbConnStrIn,
+		szConnStrOut,
+		cbConnStrOutMax,
+		pcbConnStrOut,
+		fDriverCompletion);
+}
+
+
+inline SQLRETURN SQLBrowseConnect(SQLHDBC hdbc,
+	SQLCHAR*     szConnStrIn,
+	SQLSMALLINT  cbConnStrIn,
+	SQLCHAR*     szConnStrOut,
+	SQLSMALLINT  cbConnStrOutMax,
+	SQLSMALLINT* pcbConnStrOut)
+{
+	return ::SQLBrowseConnectA(hdbc,
+		szConnStrIn,
+		cbConnStrIn,
+		szConnStrOut,
+		cbConnStrOutMax,
+		pcbConnStrOut);
+}
+
+
+inline SQLRETURN SQLColumnPrivileges(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName,
+	SQLCHAR*    szColumnName,
+	SQLSMALLINT cbColumnName)
+{
+	return ::SQLColumnPrivilegesA(hstmt,
+		szCatalogName,
+		cbCatalogName,
+		szSchemaName,
+		cbSchemaName,
+		szTableName,
+		cbTableName,
+		szColumnName,
+		cbColumnName);
+}
+
+
+inline SQLRETURN SQLForeignKeys(SQLHSTMT hstmt,
+	SQLCHAR*    szPkCatalogName,
+	SQLSMALLINT cbPkCatalogName,
+	SQLCHAR*    szPkSchemaName,
+	SQLSMALLINT cbPkSchemaName,
+	SQLCHAR*    szPkTableName,
+	SQLSMALLINT cbPkTableName,
+	SQLCHAR*    szFkCatalogName,
+	SQLSMALLINT cbFkCatalogName,
+	SQLCHAR*    szFkSchemaName,
+	SQLSMALLINT cbFkSchemaName,
+	SQLCHAR*    szFkTableName,
+	SQLSMALLINT cbFkTableName)
+{
+	return ::SQLForeignKeysA(hstmt,
+		szPkCatalogName,
+		cbPkCatalogName,
+		szPkSchemaName,
+		cbPkSchemaName,
+		szPkTableName,
+		cbPkTableName,
+		szFkCatalogName,
+		cbFkCatalogName,
+		szFkSchemaName,
+		cbFkSchemaName,
+		szFkTableName,
+		cbFkTableName);
+}
+
+
+inline SQLRETURN SQLNativeSql(SQLHDBC hdbc,
+	SQLCHAR*    szSqlStrIn,
+	SQLINTEGER  cbSqlStrIn,
+	SQLCHAR*    szSqlStr,
+	SQLINTEGER  cbSqlStrMax,
+	SQLINTEGER* pcbSqlStr)
+{
+	return ::SQLNativeSqlA(hdbc,
+		szSqlStrIn,
+		cbSqlStrIn,
+		szSqlStr,
+		cbSqlStrMax,
+		pcbSqlStr);
+}
+
+
+inline SQLRETURN SQLPrimaryKeys(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName)
+{
+	return ::SQLPrimaryKeysA(hstmt,
+		szCatalogName,
+		cbCatalogName,
+		szSchemaName,
+		cbSchemaName,
+		szTableName,
+		cbTableName);
+}
+
+
+inline SQLRETURN SQLProcedureColumns(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szProcName,
+	SQLSMALLINT cbProcName,
+	SQLCHAR*    szColumnName,
+	SQLSMALLINT cbColumnName)
+{
+	return ::SQLProcedureColumnsA(hstmt,
+		szCatalogName,
+		cbCatalogName,
+		szSchemaName,
+		cbSchemaName,
+		szProcName,
+		cbProcName,
+		szColumnName,
+		cbColumnName);
+}
+
+
+inline SQLRETURN SQLProcedures(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szProcName,
+	SQLSMALLINT cbProcName)
+{
+	return ::SQLProceduresA(hstmt,
+		szCatalogName,
+		cbCatalogName,
+		szSchemaName,
+		cbSchemaName,
+		szProcName,
+		cbProcName);
+}
+
+
+inline SQLRETURN SQLTablePrivileges(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName)
+{
+	return ::SQLTablePrivilegesA(hstmt,
+		szCatalogName,
+		cbCatalogName,
+		szSchemaName,
+		cbSchemaName,
+		szTableName,
+		cbTableName);
+}
+
+
+inline SQLRETURN SQLDrivers(SQLHENV henv,
+	SQLUSMALLINT fDirection,
+	SQLCHAR*     szDriverDesc,
+	SQLSMALLINT  cbDriverDescMax,
+	SQLSMALLINT* pcbDriverDesc,
+	SQLCHAR*     szDriverAttributes,
+	SQLSMALLINT  cbDrvrAttrMax,
+	SQLSMALLINT* pcbDrvrAttr)
+{
+	return ::SQLDriversA(henv,
+		fDirection,
+		szDriverDesc,
+		cbDriverDescMax,
+		pcbDriverDesc,
+		szDriverAttributes,
+		cbDrvrAttrMax,
+		pcbDrvrAttr);
+}
+
+
+#endif // POCO_ODBC_UNICODE
+
+
+} } } // namespace Poco::Data::ODBC
+
+
+#endif // ODBC_Unicode_INCLUDED

base/poco/Data/ODBC/include/Poco/Data/ODBC/Unicode_UNIXODBC.h

@@ -0,0 +1,51 @@
+//
+// Unicode.h
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Unicode
+//
+// Definition of Unicode_UNIX.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ODBC_Unicode_UNIX_INCLUDED
+#define Data_ODBC_Unicode_UNIX_INCLUDED
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+void makeUTF16(SQLCHAR* pSQLChar, SQLINTEGER length, std::string& target);
+	/// Utility function for conversion from UTF-8 to UTF-16
+
+
+inline void makeUTF16(SQLCHAR* pSQLChar, SQLSMALLINT length, std::string& target)
+	/// Utility function for conversion from UTF-8 to UTF-16.
+{
+	makeUTF16(pSQLChar, (SQLINTEGER) length, target);
+}
+
+
+void makeUTF8(Poco::Buffer<SQLWCHAR>& buffer, SQLINTEGER length, SQLPOINTER pTarget, SQLINTEGER targetLength);
+	/// Utility function for conversion from UTF-16 to UTF-8.
+
+
+inline void makeUTF8(Poco::Buffer<SQLWCHAR>& buffer, int length, SQLPOINTER pTarget, SQLSMALLINT targetLength)
+	/// Utility function for conversion from UTF-16 to UTF-8.
+{
+	makeUTF8(buffer, length, pTarget, (SQLINTEGER) targetLength);
+}
+
+
+} } } // namespace Poco::Data::ODBC
+
+
+#endif // Data_ODBC_Unicode_UNIX_INCLUDED

base/poco/Data/ODBC/include/Poco/Data/ODBC/Unicode_WIN32.h

@@ -0,0 +1,57 @@
+//
+// Unicode.h
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Unicode
+//
+// Definition of Unicode_WIN32.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ODBC_Unicode_WIN32_INCLUDED
+#define Data_ODBC_Unicode_WIN32_INCLUDED
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+inline void makeUTF16(SQLCHAR* pSQLChar, SQLINTEGER length, std::wstring& target)
+	/// Utility function for conversion from UTF-8 to UTF-16
+{
+	int len = length;
+	if (SQL_NTS == len) 
+		len = (int) std::strlen((const char *) pSQLChar);
+
+	UnicodeConverter::toUTF16((const char *) pSQLChar, len, target);
+}
+
+
+inline void makeUTF8(Poco::Buffer<wchar_t>& buffer, SQLINTEGER length, SQLPOINTER pTarget, SQLINTEGER targetLength)
+	/// Utility function for conversion from UTF-16 to UTF-8. Length is in bytes.
+{
+	if (buffer.sizeBytes() < length)
+		throw InvalidArgumentException("Specified length exceeds available length.");
+	else if ((length % 2) != 0)
+		throw InvalidArgumentException("Length must be an even number.");
+
+	length /= sizeof(wchar_t);
+	std::string result;
+	UnicodeConverter::toUTF8(buffer.begin(), length, result);
+	
+	std::memset(pTarget, 0, targetLength);
+	std::strncpy((char*) pTarget, result.c_str(), result.size() < targetLength ? result.size() : targetLength);
+}
+
+
+} } } // namespace Poco::Data::ODBC
+
+
+#endif // Data_ODBC_Unicode_WIN32_INCLUDED

base/poco/Data/ODBC/include/Poco/Data/ODBC/Utility.h

@@ -0,0 +1,207 @@
+//
+// Utility.h
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Utility
+//
+// Definition of Utility.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ODBC_Utility_INCLUDED
+#define Data_ODBC_Utility_INCLUDED
+
+
+#include "Poco/Data/ODBC/ODBC.h"
+#include "Poco/Data/ODBC/TypeInfo.h"
+#include "Poco/Data/Date.h"
+#include "Poco/Data/Time.h"
+#include "Poco/DateTime.h"
+#include <sstream>
+#include <map>
+#include <sqltypes.h>
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+class ODBC_API Utility
+	/// Various utility functions
+{
+public:
+	typedef std::map<std::string, std::string> DSNMap;
+	typedef DSNMap DriverMap;
+
+	static bool isError(SQLRETURN rc);
+		/// Returns true if return code is error
+
+	static DriverMap& drivers(DriverMap& driverMap);
+		/// Returns driver-attributes map of available ODBC drivers.
+
+	static DSNMap& dataSources(DSNMap& dsnMap);
+		/// Returns DSN-description map of available ODBC data sources.
+
+	template<typename MapType, typename KeyArgType, typename ValueArgType>
+	static typename MapType::iterator mapInsert(MapType& m, const KeyArgType& k, const ValueArgType& v)
+		/// Utility map "insert or replace" function (from S. Meyers: Effective STL, Item 24)
+	{
+		typename MapType::iterator lb = m.lower_bound(k);
+		if (lb != m.end() && !(m.key_comp()(k, lb->first)))
+		{
+			lb->second = v;
+			return lb;
+		}
+		else
+		{
+			typedef typename MapType::value_type MVT;
+			return m.insert(lb, MVT(k,v));
+		}
+	}
+
+	static int cDataType(int sqlDataType);
+		/// Returns C data type corresponding to supplied SQL data type.
+
+	static int sqlDataType(int cDataType);
+		/// Returns SQL data type corresponding to supplied C data type.
+
+	static void dateSync(Date& dt, const SQL_DATE_STRUCT& ts);
+		/// Transfers data from ODBC SQL_DATE_STRUCT to Poco::DateTime.
+
+	template <typename T, typename F>
+	static void dateSync(T& d, const F& ds)
+		/// Transfers data from ODBC SQL_DATE_STRUCT container to Poco::DateTime container.
+	{
+		std::size_t size = ds.size();
+		if (d.size() != size) d.resize(size);
+		typename T::iterator dIt = d.begin();
+		typename F::const_iterator it = ds.begin();
+		typename F::const_iterator end = ds.end();
+		for (; it != end; ++it, ++dIt) dateSync(*dIt, *it);
+	}
+
+	static void timeSync(Time& dt, const SQL_TIME_STRUCT& ts);
+		/// Transfers data from ODBC SQL_TIME_STRUCT to Poco::DateTime.
+
+	template <typename T, typename F>
+	static void timeSync(T& t, const F& ts)
+		/// Transfers data from ODBC SQL_TIME_STRUCT container to Poco::DateTime container.
+	{
+		std::size_t size = ts.size();
+		if (t.size() != size) t.resize(size);
+		typename T::iterator dIt = t.begin();
+		typename F::const_iterator it = ts.begin();
+		typename F::const_iterator end = ts.end();
+		for (; it != end; ++it, ++dIt) timeSync(*dIt, *it);
+	}
+
+	static void dateTimeSync(Poco::DateTime& dt, const SQL_TIMESTAMP_STRUCT& ts);
+		/// Transfers data from ODBC SQL_TIMESTAMP_STRUCT to Poco::DateTime.
+
+	template <typename T, typename F>
+	static void dateTimeSync(T& dt, const F& ts)
+		/// Transfers data from ODBC SQL_TIMESTAMP_STRUCT container to Poco::DateTime container.
+	{
+		std::size_t size = ts.size();
+		if (dt.size() != size) dt.resize(size);
+		typename T::iterator dIt = dt.begin();
+		typename F::const_iterator it = ts.begin();
+		typename F::const_iterator end = ts.end();
+		for (; it != end; ++it, ++dIt) dateTimeSync(*dIt, *it);
+	}
+
+	static void dateSync(SQL_DATE_STRUCT& ts, const Date& dt);
+		/// Transfers data from Poco::Data::Date to ODBC SQL_DATE_STRUCT.
+
+	template <typename C>
+	static void dateSync(std::vector<SQL_DATE_STRUCT>& ds, const C& d)
+		/// Transfers data from Poco::Data::Date vector to ODBC SQL_DATE_STRUCT container.
+	{
+		std::size_t size = d.size();
+		if (ds.size() != size) ds.resize(size);
+		std::vector<SQL_DATE_STRUCT>::iterator dIt = ds.begin();
+		typename C::const_iterator it = d.begin();
+		typename C::const_iterator end = d.end();
+		for (; it != end; ++it, ++dIt) dateSync(*dIt, *it);
+	}
+
+	static void timeSync(SQL_TIME_STRUCT& ts, const Time& dt);
+		/// Transfers data from Poco::Data::Time to ODBC SQL_TIME_STRUCT.
+
+	template <typename C>
+	static void timeSync(std::vector<SQL_TIME_STRUCT>& ts, const C& t)
+		/// Transfers data from Poco::Data::Time container to ODBC SQL_TIME_STRUCT vector.
+	{
+		std::size_t size = t.size();
+		if (ts.size() != size) ts.resize(size);
+		std::vector<SQL_TIME_STRUCT>::iterator tIt = ts.begin();
+		typename C::const_iterator it = t.begin();
+		typename C::const_iterator end = t.end();
+		for (; it != end; ++it, ++tIt) timeSync(*tIt, *it);
+	}
+
+	static void dateTimeSync(SQL_TIMESTAMP_STRUCT& ts, const Poco::DateTime& dt);
+		/// Transfers data from Poco::DateTime to ODBC SQL_TIMESTAMP_STRUCT.
+
+	template <typename C>
+	static void dateTimeSync(std::vector<SQL_TIMESTAMP_STRUCT>& ts, const C& dt)
+		/// Transfers data from Poco::DateTime to ODBC SQL_TIMESTAMP_STRUCT.
+	{
+		std::size_t size = dt.size();
+		if (ts.size() != size) ts.resize(size);
+		std::vector<SQL_TIMESTAMP_STRUCT>::iterator tIt = ts.begin();
+		typename C::const_iterator it = dt.begin();
+		typename C::const_iterator end = dt.end();
+		for (; it != end; ++it, ++tIt) dateTimeSync(*tIt, *it);
+	}
+
+private:
+	static const TypeInfo _dataTypes;
+		/// C <==> SQL data type mapping
+};
+
+
+///
+/// inlines
+///
+inline bool Utility::isError(SQLRETURN rc)
+{
+	return (0 != (rc & (~1)));
+}
+
+
+inline int Utility::cDataType(int sqlDataType)
+{
+	return _dataTypes.cDataType(sqlDataType);
+}
+
+
+inline int Utility::sqlDataType(int cDataType)
+{
+	return _dataTypes.sqlDataType(cDataType);
+}
+
+
+inline void Utility::dateSync(Date& d, const SQL_DATE_STRUCT& ts)
+{
+	d.assign(ts.year, ts.month, ts.day);
+}
+
+
+inline void Utility::timeSync(Time& t, const SQL_TIME_STRUCT& ts)
+{
+	t.assign(ts.hour, ts.minute, ts.second);
+}
+
+
+} } } // namespace Poco::Data::ODBC
+
+
+#endif

base/poco/Data/ODBC/src/Binder.cpp

@@ -0,0 +1,541 @@
+//
+// Binder.cpp
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Binder
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/ODBC/Binder.h"
+#include "Poco/Data/ODBC/Utility.h"
+#include "Poco/Data/ODBC/Connector.h"
+#include "Poco/Data/LOB.h"
+#include "Poco/Data/ODBC/ODBCException.h"
+#include "Poco/DateTime.h"
+#include "Poco/Exception.h"
+#include <sql.h>
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+Binder::Binder(const StatementHandle& rStmt,
+	std::size_t maxFieldSize,
+	Binder::ParameterBinding dataBinding,
+	TypeInfo* pDataTypes):
+	_rStmt(rStmt),
+	_paramBinding(dataBinding),
+	_pTypeInfo(pDataTypes),
+	_paramSetSize(0),
+	_maxFieldSize(maxFieldSize)
+{
+}
+
+
+Binder::~Binder()
+{
+	freeMemory();
+}
+
+
+void Binder::freeMemory()
+{
+	LengthPtrVec::iterator itLen = _lengthIndicator.begin();
+	LengthPtrVec::iterator itLenEnd = _lengthIndicator.end();
+	for(; itLen != itLenEnd; ++itLen) delete *itLen;
+
+	LengthVecVec::iterator itVecLen = _vecLengthIndicator.begin();
+	LengthVecVec::iterator itVecLenEnd = _vecLengthIndicator.end();
+	for (; itVecLen != itVecLenEnd; ++itVecLen) delete *itVecLen;
+
+	TimeMap::iterator itT = _times.begin();
+	TimeMap::iterator itTEnd = _times.end();
+	for(; itT != itTEnd; ++itT) delete itT->first;
+
+	DateMap::iterator itD = _dates.begin();
+	DateMap::iterator itDEnd = _dates.end();
+	for(; itD != itDEnd; ++itD) delete itD->first;
+
+	TimestampMap::iterator itTS = _timestamps.begin();
+	TimestampMap::iterator itTSEnd = _timestamps.end();
+	for(; itTS != itTSEnd; ++itTS) delete itTS->first;
+
+	StringMap::iterator itStr = _strings.begin();
+	StringMap::iterator itStrEnd = _strings.end();
+	for(; itStr != itStrEnd; ++itStr) std::free(itStr->first);
+
+	CharPtrVec::iterator itChr = _charPtrs.begin();
+	CharPtrVec::iterator endChr = _charPtrs.end();
+	for (; itChr != endChr; ++itChr) std::free(*itChr);
+
+	UTF16CharPtrVec::iterator itUTF16Chr = _utf16CharPtrs.begin();
+	UTF16CharPtrVec::iterator endUTF16Chr = _utf16CharPtrs.end();
+	for (; itUTF16Chr != endUTF16Chr; ++itUTF16Chr) std::free(*itUTF16Chr);
+
+	BoolPtrVec::iterator itBool = _boolPtrs.begin();
+	BoolPtrVec::iterator endBool = _boolPtrs.end();
+	for (; itBool != endBool; ++itBool) delete [] *itBool;
+
+	DateVecVec::iterator itDateVec = _dateVecVec.begin();
+	DateVecVec::iterator itDateVecEnd = _dateVecVec.end();
+	for (; itDateVec != itDateVecEnd; ++itDateVec) delete *itDateVec;
+
+	TimeVecVec::iterator itTimeVec = _timeVecVec.begin();
+	TimeVecVec::iterator itTimeVecEnd = _timeVecVec.end();
+	for (; itTimeVec != itTimeVecEnd; ++itTimeVec) delete *itTimeVec;
+
+	DateTimeVecVec::iterator itDateTimeVec = _dateTimeVecVec.begin();
+	DateTimeVecVec::iterator itDateTimeVecEnd = _dateTimeVecVec.end();
+	for (; itDateTimeVec != itDateTimeVecEnd; ++itDateTimeVec) delete *itDateTimeVec;
+}
+
+
+void Binder::bind(std::size_t pos, const std::string& val, Direction dir)
+{
+	SQLPOINTER pVal = 0;
+	SQLINTEGER size = (SQLINTEGER) val.size();
+	SQLINTEGER colSize = 0;
+	SQLSMALLINT decDigits = 0;
+	getColSizeAndPrecision(pos, SQL_C_CHAR, colSize, decDigits, val.size());
+
+	if (isOutBound(dir))
+	{
+		getColumnOrParameterSize(pos, size);
+		char* pChar = (char*) std::calloc(size, sizeof(char));
+		pVal = (SQLPOINTER) pChar;
+		_outParams.insert(ParamMap::value_type(pVal, size));
+		_strings.insert(StringMap::value_type(pChar, const_cast<std::string*>(&val)));
+	}
+	else if (isInBound(dir))
+	{
+		pVal = (SQLPOINTER) val.c_str();
+		_inParams.insert(ParamMap::value_type(pVal, size));
+	}
+	else
+		throw InvalidArgumentException("Parameter must be [in] OR [out] bound.");
+
+	SQLLEN* pLenIn = new SQLLEN(SQL_NTS);
+
+	if (PB_AT_EXEC == _paramBinding)
+		*pLenIn = SQL_LEN_DATA_AT_EXEC(size);
+
+	_lengthIndicator.push_back(pLenIn);
+
+	if (Utility::isError(SQLBindParameter(_rStmt, 
+		(SQLUSMALLINT) pos + 1, 
+		toODBCDirection(dir), 
+		SQL_C_CHAR, 
+		Connector::stringBoundToLongVarChar() ? SQL_LONGVARCHAR : SQL_VARCHAR, 
+		(SQLUINTEGER) colSize,
+		0,
+		pVal, 
+		(SQLINTEGER) size, 
+		_lengthIndicator.back())))
+	{
+		throw StatementException(_rStmt, "SQLBindParameter(std::string)");
+	}
+}
+
+
+void Binder::bind(std::size_t pos, const UTF16String& val, Direction dir)
+{
+	typedef UTF16String::value_type CharT;
+
+	SQLPOINTER pVal = 0;
+	SQLINTEGER size = (SQLINTEGER)(val.size() * sizeof(CharT));
+	SQLINTEGER colSize = 0;
+	SQLSMALLINT decDigits = 0;
+	getColSizeAndPrecision(pos, SQL_C_WCHAR, colSize, decDigits);
+
+	if (isOutBound(dir))
+	{
+		getColumnOrParameterSize(pos, size);
+		CharT* pChar = (CharT*)std::calloc(size, 1);
+		pVal = (SQLPOINTER)pChar;
+		_outParams.insert(ParamMap::value_type(pVal, size));
+		_utf16Strings.insert(UTF16StringMap::value_type(pChar, const_cast<UTF16String*>(&val)));
+	}
+	else if (isInBound(dir))
+	{
+		pVal = (SQLPOINTER)val.c_str();
+		_inParams.insert(ParamMap::value_type(pVal, size));
+	}
+	else
+		throw InvalidArgumentException("Parameter must be [in] OR [out] bound.");
+
+	SQLLEN* pLenIn = new SQLLEN(SQL_NTS);
+
+	if (PB_AT_EXEC == _paramBinding)
+	{
+		*pLenIn = SQL_LEN_DATA_AT_EXEC(size);
+	}
+
+	_lengthIndicator.push_back(pLenIn);
+
+	if (Utility::isError(SQLBindParameter(_rStmt,
+		(SQLUSMALLINT)pos + 1,
+		toODBCDirection(dir),
+		SQL_C_WCHAR,
+		SQL_WLONGVARCHAR,
+		(SQLUINTEGER)colSize,
+		0,
+		pVal,
+		(SQLINTEGER)size,
+		_lengthIndicator.back())))
+	{
+		throw StatementException(_rStmt, "SQLBindParameter(std::string)");
+	}
+}
+
+
+void Binder::bind(std::size_t pos, const Date& val, Direction dir)
+{
+	SQLINTEGER size = (SQLINTEGER) sizeof(SQL_DATE_STRUCT);
+	SQLLEN* pLenIn = new SQLLEN;
+	*pLenIn  = size;
+
+	_lengthIndicator.push_back(pLenIn);
+
+	SQL_DATE_STRUCT* pDS = new SQL_DATE_STRUCT;
+	Utility::dateSync(*pDS, val);
+	
+	_dates.insert(DateMap::value_type(pDS, const_cast<Date*>(&val)));
+
+	SQLINTEGER colSize = 0;
+	SQLSMALLINT decDigits = 0;
+	getColSizeAndPrecision(pos, SQL_TYPE_DATE, colSize, decDigits);
+
+	if (Utility::isError(SQLBindParameter(_rStmt, 
+		(SQLUSMALLINT) pos + 1, 
+		toODBCDirection(dir), 
+		SQL_C_TYPE_DATE, 
+		SQL_TYPE_DATE, 
+		colSize,
+		decDigits,
+		(SQLPOINTER) pDS, 
+		0, 
+		_lengthIndicator.back())))
+	{
+		throw StatementException(_rStmt, "SQLBindParameter(Date)");
+	}
+}
+
+
+void Binder::bind(std::size_t pos, const Time& val, Direction dir)
+{
+	SQLINTEGER size = (SQLINTEGER) sizeof(SQL_TIME_STRUCT);
+	SQLLEN* pLenIn = new SQLLEN;
+	*pLenIn  = size;
+
+	_lengthIndicator.push_back(pLenIn);
+
+	SQL_TIME_STRUCT* pTS = new SQL_TIME_STRUCT;
+	Utility::timeSync(*pTS, val);
+	
+	_times.insert(TimeMap::value_type(pTS, const_cast<Time*>(&val)));
+
+	SQLINTEGER colSize = 0;
+	SQLSMALLINT decDigits = 0;
+	getColSizeAndPrecision(pos, SQL_TYPE_TIME, colSize, decDigits);
+
+	if (Utility::isError(SQLBindParameter(_rStmt, 
+		(SQLUSMALLINT) pos + 1, 
+		toODBCDirection(dir), 
+		SQL_C_TYPE_TIME, 
+		SQL_TYPE_TIME, 
+		colSize,
+		decDigits,
+		(SQLPOINTER) pTS, 
+		0, 
+		_lengthIndicator.back())))
+	{
+		throw StatementException(_rStmt, "SQLBindParameter(Time)");
+	}
+}
+
+
+void Binder::bind(std::size_t pos, const Poco::DateTime& val, Direction dir)
+{
+	SQLINTEGER size = (SQLINTEGER) sizeof(SQL_TIMESTAMP_STRUCT);
+	SQLLEN* pLenIn = new SQLLEN;
+	*pLenIn  = size;
+
+	_lengthIndicator.push_back(pLenIn);
+
+	SQL_TIMESTAMP_STRUCT* pTS = new SQL_TIMESTAMP_STRUCT;
+	Utility::dateTimeSync(*pTS, val);
+
+	_timestamps.insert(TimestampMap::value_type(pTS, const_cast<DateTime*>(&val)));
+
+	SQLINTEGER colSize = 0;
+	SQLSMALLINT decDigits = 0;
+	getColSizeAndPrecision(pos, SQL_TYPE_TIMESTAMP, colSize, decDigits);
+
+	if (Utility::isError(SQLBindParameter(_rStmt, 
+		(SQLUSMALLINT) pos + 1, 
+		toODBCDirection(dir), 
+		SQL_C_TYPE_TIMESTAMP, 
+		SQL_TYPE_TIMESTAMP, 
+		colSize,
+		decDigits,
+		(SQLPOINTER) pTS, 
+		0, 
+		_lengthIndicator.back())))
+	{
+		throw StatementException(_rStmt, "SQLBindParameter(DateTime)");
+	}
+}
+
+
+void Binder::bind(std::size_t pos, const NullData& val, Direction dir)
+{
+	if (isOutBound(dir) || !isInBound(dir))
+		throw NotImplementedException("NULL parameter type can only be inbound.");
+
+	_inParams.insert(ParamMap::value_type(SQLPOINTER(0), SQLINTEGER(0)));
+
+	SQLLEN* pLenIn = new SQLLEN;
+	*pLenIn  = SQL_NULL_DATA;
+
+	_lengthIndicator.push_back(pLenIn);
+
+	SQLINTEGER colSize = 0;
+	SQLSMALLINT decDigits = 0;
+	getColSizeAndPrecision(pos, SQL_C_STINYINT, colSize, decDigits);
+
+	if (Utility::isError(SQLBindParameter(_rStmt, 
+		(SQLUSMALLINT) pos + 1, 
+		SQL_PARAM_INPUT, 
+		SQL_C_STINYINT, 
+		Utility::sqlDataType(SQL_C_STINYINT), 
+		colSize,
+		decDigits,
+		0, 
+		0, 
+		_lengthIndicator.back())))
+	{
+		throw StatementException(_rStmt, "SQLBindParameter()");
+	}
+}
+
+
+std::size_t Binder::parameterSize(SQLPOINTER pAddr) const
+{
+	ParamMap::const_iterator it = _inParams.find(pAddr);
+	if (it != _inParams.end()) return it->second;
+
+	it = _outParams.find(pAddr);
+	if (it != _outParams.end()) return it->second;
+	
+	throw NotFoundException("Requested data size not found.");
+}
+
+
+void Binder::bind(std::size_t pos, const char* const &pVal, Direction dir)
+{
+	throw NotImplementedException("char* binding not implemented, Use std::string instead.");
+}
+
+
+SQLSMALLINT Binder::toODBCDirection(Direction dir) const
+{
+	bool in = isInBound(dir);
+	bool out = isOutBound(dir);
+	SQLSMALLINT ioType = SQL_PARAM_TYPE_UNKNOWN;
+	if (in && out) ioType = SQL_PARAM_INPUT_OUTPUT; 
+	else if(in)    ioType = SQL_PARAM_INPUT;
+	else if(out)   ioType = SQL_PARAM_OUTPUT;
+	else throw Poco::IllegalStateException("Binder not bound (must be [in] OR [out]).");
+
+	return ioType;
+}
+
+
+void Binder::synchronize()
+{
+	if (_dates.size())
+	{
+		DateMap::iterator it = _dates.begin();
+		DateMap::iterator end = _dates.end();
+		for(; it != end; ++it) 
+			Utility::dateSync(*it->second, *it->first);
+	}
+
+	if (_times.size())
+	{
+		TimeMap::iterator it = _times.begin();
+		TimeMap::iterator end = _times.end();
+		for(; it != end; ++it) 
+			Utility::timeSync(*it->second, *it->first);
+	}
+
+	if (_timestamps.size())
+	{
+		TimestampMap::iterator it = _timestamps.begin();
+		TimestampMap::iterator end = _timestamps.end();
+		for(; it != end; ++it) 
+			Utility::dateTimeSync(*it->second, *it->first);
+	}
+
+	if (_strings.size())
+	{
+		StringMap::iterator it = _strings.begin();
+		StringMap::iterator end = _strings.end();
+		for(; it != end; ++it)
+			it->second->assign(it->first, std::strlen(it->first));
+	}
+}
+
+
+void Binder::reset()
+{
+	freeMemory();
+	LengthPtrVec().swap(_lengthIndicator);
+	_inParams.clear();
+	_outParams.clear();
+	_dates.clear();
+	_times.clear();
+	_timestamps.clear();
+	_strings.clear();
+	_dateVecVec.clear();
+	_timeVecVec.clear();
+	_dateTimeVecVec.clear();
+	_charPtrs.clear();
+	_boolPtrs.clear();
+	_containers.clear();
+	_paramSetSize = 0;
+}
+
+
+void Binder::getColSizeAndPrecision(std::size_t pos, 
+	SQLSMALLINT cDataType, 
+	SQLINTEGER& colSize, 
+	SQLSMALLINT& decDigits,
+	std::size_t actualSize)
+{
+	// Not all drivers are equally willing to cooperate in this matter.
+	// Hence the funky flow control.
+	DynamicAny tmp;
+	bool found(false);
+	if (_pTypeInfo)
+	{
+		found = _pTypeInfo->tryGetInfo(cDataType, "COLUMN_SIZE", tmp);
+		if (found) colSize = tmp;
+		if (actualSize > colSize)
+		{
+			throw LengthExceededException(Poco::format("Error binding column %z size=%z, max size=%ld)",
+					pos, actualSize, static_cast<long>(colSize)));
+		}
+		found = _pTypeInfo->tryGetInfo(cDataType, "MINIMUM_SCALE", tmp);
+		if (found)
+		{
+			decDigits = tmp;
+			return;
+		}
+	}
+
+	try
+	{
+		Parameter p(_rStmt, pos);
+		colSize = (SQLINTEGER) p.columnSize();
+		decDigits = (SQLSMALLINT) p.decimalDigits();
+		return;
+	} 
+	catch (StatementException&)
+	{ 
+	}
+
+	try
+	{
+		ODBCMetaColumn c(_rStmt, pos);
+		colSize = (SQLINTEGER) c.length();
+		decDigits = (SQLSMALLINT) c.precision();
+		return;
+	} 
+	catch (StatementException&) 
+	{ 
+	}
+
+	// last check, just in case
+	if ((0 != colSize) && (actualSize > colSize))
+	{
+		throw LengthExceededException(Poco::format("Error binding column %z size=%z, max size=%ld)",
+				pos, actualSize, static_cast<long>(colSize)));
+	}
+
+	// no success, set to zero and hope for the best
+	// (most drivers do not require these most of the times anyway)
+	colSize = 0;
+	decDigits = 0;
+	return;
+}
+
+
+void Binder::getColumnOrParameterSize(std::size_t pos, SQLINTEGER& size)
+{
+	std::size_t colSize = 0;
+	std::size_t paramSize = 0;
+
+	try
+	{
+		ODBCMetaColumn col(_rStmt, pos);
+		colSize = col.length();
+	}
+	catch (StatementException&) { }
+
+	try
+	{
+		Parameter p(_rStmt, pos);
+		paramSize = p.columnSize();
+	}
+	catch (StatementException&)
+	{
+		size = DEFAULT_PARAM_SIZE;
+//On Linux, PostgreSQL driver segfaults on SQLGetDescField, so this is disabled for now
+#ifdef POCO_OS_FAMILY_WINDOWS
+		SQLHDESC hIPD = 0;
+		if (!Utility::isError(SQLGetStmtAttr(_rStmt, SQL_ATTR_IMP_PARAM_DESC, &hIPD, SQL_IS_POINTER, 0)))
+		{
+			SQLUINTEGER sz = 0;
+			if (!Utility::isError(SQLGetDescField(hIPD, (SQLSMALLINT) pos + 1, SQL_DESC_LENGTH, &sz, SQL_IS_UINTEGER, 0)) && 
+				sz > 0)
+			{
+				size = sz;
+			}
+		}
+#endif
+	}
+
+	if (colSize > 0 && paramSize > 0)
+		size = colSize < paramSize ? static_cast<SQLINTEGER>(colSize) : static_cast<SQLINTEGER>(paramSize);
+	else if (colSize > 0)
+		size = static_cast<SQLINTEGER>(colSize);
+	else if (paramSize > 0)
+		size = static_cast<SQLINTEGER>(paramSize);
+
+	if (size > _maxFieldSize) size = static_cast<SQLINTEGER>(_maxFieldSize);
+}
+
+
+void Binder::setParamSetSize(std::size_t length)
+{
+	if (0 == _paramSetSize)
+	{
+		if (Utility::isError(Poco::Data::ODBC::SQLSetStmtAttr(_rStmt, SQL_ATTR_PARAM_BIND_TYPE, SQL_PARAM_BIND_BY_COLUMN, SQL_IS_UINTEGER)) ||  
+			Utility::isError(Poco::Data::ODBC::SQLSetStmtAttr(_rStmt, SQL_ATTR_PARAMSET_SIZE, (SQLPOINTER) length, SQL_IS_UINTEGER)))
+				throw StatementException(_rStmt, "SQLSetStmtAttr()");
+
+		_paramSetSize = static_cast<SQLINTEGER>(length);
+	}
+}
+
+
+} } } // namespace Poco::Data::ODBC

base/poco/Data/ODBC/src/ConnectionHandle.cpp

@@ -0,0 +1,57 @@
+//
+// ConnectionHandle.cpp
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  ConnectionHandle
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/ODBC/ConnectionHandle.h"
+#include "Poco/Data/ODBC/Utility.h"
+#include "Poco/Data/ODBC/ODBCException.h"
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+ConnectionHandle::ConnectionHandle(EnvironmentHandle* pEnvironment): 
+	_pEnvironment(pEnvironment ? pEnvironment : new EnvironmentHandle),
+	_hdbc(SQL_NULL_HDBC), 
+	_ownsEnvironment(pEnvironment ? false : true)
+{
+	if (Utility::isError(SQLAllocHandle(SQL_HANDLE_DBC, 
+		_pEnvironment->handle(), 
+		&_hdbc))) 
+	{
+		throw ODBCException("Could not allocate connection handle.");
+	}
+}
+
+
+ConnectionHandle::~ConnectionHandle()
+{
+	try
+	{
+		SQLDisconnect(_hdbc);
+		SQLRETURN rc = SQLFreeHandle(SQL_HANDLE_DBC, _hdbc);
+
+		if (_ownsEnvironment) delete _pEnvironment;
+
+		poco_assert (!Utility::isError(rc));
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+} } } // namespace Poco::Data::ODBC

base/poco/Data/ODBC/src/Connector.cpp

@@ -0,0 +1,64 @@
+//
+// Connector.cpp
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Connector
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/ODBC/Connector.h"
+#include "Poco/Data/ODBC/SessionImpl.h"
+#include "Poco/Data/SessionFactory.h"
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+const std::string Connector::KEY("ODBC");
+bool Connector::_bindStringToLongVarChar(true);
+
+
+Connector::Connector()
+{
+}
+
+
+Connector::~Connector()
+{
+}
+
+
+Poco::AutoPtr<Poco::Data::SessionImpl> Connector::createSession(const std::string& connectionString,
+	std::size_t timeout)
+{
+	return Poco::AutoPtr<Poco::Data::SessionImpl>(new SessionImpl(connectionString, timeout));
+}
+
+
+void Connector::registerConnector()
+{
+	Poco::Data::SessionFactory::instance().add(new Connector());
+}
+
+
+void Connector::unregisterConnector()
+{
+	Poco::Data::SessionFactory::instance().remove(KEY);
+}
+
+
+void Connector::bindStringToLongVarChar(bool flag)
+{
+	_bindStringToLongVarChar = flag;
+}
+
+
+} } } // namespace Poco::Data::ODBC

base/poco/Data/ODBC/src/EnvironmentHandle.cpp

@@ -0,0 +1,54 @@
+//
+// EnvironmentHandle.cpp
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  EnvironmentHandle
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/ODBC/EnvironmentHandle.h"
+#include "Poco/Data/ODBC/Utility.h"
+#include "Poco/Data/ODBC/ODBCException.h"
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+EnvironmentHandle::EnvironmentHandle(): _henv(SQL_NULL_HENV)
+{
+	if (Utility::isError(SQLAllocHandle(SQL_HANDLE_ENV, 
+			SQL_NULL_HANDLE, 
+			&_henv)) ||
+		Utility::isError(SQLSetEnvAttr(_henv, 
+			SQL_ATTR_ODBC_VERSION, 
+			(SQLPOINTER) SQL_OV_ODBC3, 
+			0)))
+	{
+		throw ODBCException("Could not initialize environment.");
+	}
+}
+
+
+EnvironmentHandle::~EnvironmentHandle()
+{
+	try
+	{
+		SQLRETURN rc = SQLFreeHandle(SQL_HANDLE_ENV, _henv);
+		poco_assert (!Utility::isError(rc));
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+} } } // namespace Poco::Data::ODBC

base/poco/Data/ODBC/src/ODBCException.cpp

@@ -0,0 +1,30 @@
+//
+// ODBCException.cpp
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  ODBCException
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/ODBC/ODBCException.h"
+#include <typeinfo>
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+POCO_IMPLEMENT_EXCEPTION(ODBCException, Poco::Data::DataException, "Generic ODBC error")
+POCO_IMPLEMENT_EXCEPTION(InsufficientStorageException, ODBCException, "Insufficient storage error")
+POCO_IMPLEMENT_EXCEPTION(UnknownDataLengthException, ODBCException, "Unknown length of remaining data")
+POCO_IMPLEMENT_EXCEPTION(DataTruncatedException, ODBCException, "Variable length character or binary data truncated")
+
+
+} } } // namespace Poco::Data::ODBC

base/poco/Data/ODBC/src/ODBCMetaColumn.cpp

@@ -0,0 +1,168 @@
+//
+// ODBCMetaColumn.cpp
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  ODBCMetaColumn
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/ODBC/ODBCMetaColumn.h"
+#include "Poco/Data/ODBC/Utility.h"
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+ODBCMetaColumn::ODBCMetaColumn(const StatementHandle& rStmt, std::size_t position) : 
+	MetaColumn(position),
+	_rStmt(rStmt)
+{
+	init();
+}
+
+	
+ODBCMetaColumn::~ODBCMetaColumn()
+{
+}
+
+
+void ODBCMetaColumn::getDescription()
+{
+	std::memset(_columnDesc.name, 0, NAME_BUFFER_LENGTH);
+	_columnDesc.nameBufferLength = 0;
+	_columnDesc.dataType = 0;
+	_columnDesc.size = 0;
+	_columnDesc.decimalDigits = 0;
+	_columnDesc.isNullable = 0;
+
+	if (Utility::isError(Poco::Data::ODBC::SQLDescribeCol(_rStmt, 
+		(SQLUSMALLINT) position() + 1, // ODBC columns are 1-based
+		_columnDesc.name, 
+		NAME_BUFFER_LENGTH,
+		&_columnDesc.nameBufferLength, 
+		&_columnDesc.dataType,
+		&_columnDesc.size, 
+		&_columnDesc.decimalDigits, 
+		&_columnDesc.isNullable)))
+	{
+		throw StatementException(_rStmt);
+	}
+}
+
+
+bool ODBCMetaColumn::isUnsigned() const
+{
+	SQLLEN val = 0;
+	if (Utility::isError(Poco::Data::ODBC::SQLColAttribute(_rStmt,
+		(SQLUSMALLINT)position() + 1, // ODBC columns are 1-based
+		SQL_DESC_UNSIGNED,
+		0,
+		0,
+		0,
+		&val)))
+	{
+		throw StatementException(_rStmt);
+	}
+	return (val == SQL_TRUE);
+}
+
+
+void ODBCMetaColumn::init()
+{
+	getDescription();
+
+	if (Utility::isError(Poco::Data::ODBC::SQLColAttribute(_rStmt,
+			(SQLUSMALLINT) position() + 1, // ODBC columns are 1-based
+			SQL_DESC_LENGTH,
+			0,
+			0,
+			0,
+			&_dataLength)))
+	{
+		throw StatementException(_rStmt);
+	}
+
+	setName(std::string((char*) _columnDesc.name));
+	setLength(_columnDesc.size);
+	setPrecision(_columnDesc.decimalDigits);
+	setNullable(SQL_NULLABLE == _columnDesc.isNullable);
+	switch(_columnDesc.dataType)
+	{
+	case SQL_BIT:
+		setType(MetaColumn::FDT_BOOL); break;
+
+	case SQL_CHAR:
+	case SQL_VARCHAR:
+	case SQL_LONGVARCHAR:
+#ifdef SQL_GUID
+	case SQL_GUID:
+#endif
+		setType(MetaColumn::FDT_STRING); break;
+
+	case SQL_WCHAR:
+	case SQL_WVARCHAR:
+	case SQL_WLONGVARCHAR:
+		setType(MetaColumn::FDT_WSTRING); break;
+
+	case SQL_TINYINT:
+		setType(isUnsigned() ? MetaColumn::FDT_UINT8 : MetaColumn::FDT_INT8);
+		break;
+
+	case SQL_SMALLINT:
+		setType(isUnsigned() ? MetaColumn::FDT_UINT16 : MetaColumn::FDT_INT16);
+		break;
+
+	case SQL_INTEGER:
+		setType(isUnsigned() ? MetaColumn::FDT_UINT32 : MetaColumn::FDT_INT32);
+		break;
+
+	case SQL_BIGINT:
+		setType(isUnsigned() ? MetaColumn::FDT_UINT64 : MetaColumn::FDT_INT64);
+		break;
+
+	case SQL_DOUBLE:
+	case SQL_FLOAT:
+		setType(MetaColumn::FDT_DOUBLE); break;
+
+	case SQL_NUMERIC:
+	case SQL_DECIMAL:
+		// Oracle has no INTEGER type - it's essentially NUMBER with 38 whole and
+		// 0 fractional digits. It also does not recognize SQL_BIGINT type,
+		// so the workaround here is to hardcode it to 32 bit integer
+		if (0 == _columnDesc.decimalDigits) setType(MetaColumn::FDT_INT32);
+		else setType(MetaColumn::FDT_DOUBLE);
+		break;
+
+	case SQL_REAL:
+		setType(MetaColumn::FDT_FLOAT); break;
+	
+	case SQL_BINARY:
+	case SQL_VARBINARY:
+	case SQL_LONGVARBINARY:
+	case -98:// IBM DB2 non-standard type
+		setType(MetaColumn::FDT_BLOB); break;
+	
+	case SQL_TYPE_DATE:
+		setType(MetaColumn::FDT_DATE); break;
+	
+	case SQL_TYPE_TIME:
+		setType(MetaColumn::FDT_TIME); break;
+	
+	case SQL_TYPE_TIMESTAMP:
+		setType(MetaColumn::FDT_TIMESTAMP); break;
+	
+	default:
+		throw DataFormatException("Unsupported data type.");
+	}
+}
+
+
+} } } // namespace Poco::Data::ODBC

base/poco/Data/ODBC/src/ODBCStatementImpl.cpp

@@ -0,0 +1,458 @@
+//
+// ODBCStatementImpl.cpp
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  ODBCStatementImpl
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/ODBC/ODBCStatementImpl.h"
+#include "Poco/Data/ODBC/ConnectionHandle.h"
+#include "Poco/Data/ODBC/Utility.h"
+#include "Poco/Data/ODBC/ODBCException.h"
+#include "Poco/Data/AbstractPreparation.h"
+#include "Poco/Exception.h"
+
+
+#ifdef POCO_OS_FAMILY_WINDOWS
+	#pragma warning(disable:4312)// 'type cast' : conversion from 'std::size_t' to 'SQLPOINTER' of greater size
+#endif
+
+
+using Poco::DataFormatException;
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+const std::string ODBCStatementImpl::INVALID_CURSOR_STATE = "24000";
+
+
+ODBCStatementImpl::ODBCStatementImpl(SessionImpl& rSession):
+	Poco::Data::StatementImpl(rSession),
+	_rConnection(rSession.dbc()),
+	_stmt(rSession.dbc()),
+	_stepCalled(false),
+	_nextResponse(0),
+	_prepared(false),
+	_affectedRowCount(0),
+	_canCompile(true)
+{
+	int queryTimeout = rSession.queryTimeout();
+	if (queryTimeout >= 0)
+	{
+		SQLULEN uqt = static_cast<SQLULEN>(queryTimeout);
+		SQLSetStmtAttr(_stmt,
+			SQL_ATTR_QUERY_TIMEOUT,
+			(SQLPOINTER) uqt,
+			0);
+	}
+}
+
+
+ODBCStatementImpl::~ODBCStatementImpl()
+{
+	ColumnPtrVecVec::iterator it = _columnPtrs.begin();
+	ColumnPtrVecVec::iterator end = _columnPtrs.end();
+	for (; it != end; ++it)
+	{
+		ColumnPtrVec::iterator itC = it->begin();
+		ColumnPtrVec::iterator endC = it->end();
+		for (; itC != endC; ++itC) delete *itC;
+	}
+}
+
+
+void ODBCStatementImpl::compileImpl()
+{
+	if (!_canCompile) return;
+
+	_stepCalled = false;
+	_nextResponse = 0;
+
+	if (_preparations.size())
+		PreparatorVec().swap(_preparations);
+
+	addPreparator();
+
+	Binder::ParameterBinding bind = session().getFeature("autoBind") ? 
+		Binder::PB_IMMEDIATE : Binder::PB_AT_EXEC;
+
+	TypeInfo* pDT = 0;
+	try
+	{
+		Poco::Any dti = session().getProperty("dataTypeInfo");
+		pDT = AnyCast<TypeInfo*>(dti);
+	}
+	catch (NotSupportedException&) 
+	{
+	}
+
+	std::size_t maxFieldSize = AnyCast<std::size_t>(session().getProperty("maxFieldSize"));
+	
+	_pBinder = new Binder(_stmt, maxFieldSize, bind, pDT);
+	
+	makeInternalExtractors();
+	doPrepare();
+
+	 _canCompile = false;
+}
+
+
+void ODBCStatementImpl::makeInternalExtractors()
+{
+	if (hasData() && !extractions().size()) 
+	{
+		try
+		{
+			fillColumns();
+		} 
+		catch (DataFormatException&)
+		{
+			if (isStoredProcedure()) return;
+			throw;
+		}
+
+		makeExtractors(columnsReturned());
+		fixupExtraction();
+	}
+}
+
+
+void ODBCStatementImpl::addPreparator()
+{
+	if (0 == _preparations.size())
+	{
+		std::string statement(toString());
+		if (statement.empty())
+			throw ODBCException("Empty statements are illegal");
+
+		Preparator::DataExtraction ext = session().getFeature("autoExtract") ? 
+			Preparator::DE_BOUND : Preparator::DE_MANUAL;
+
+		std::size_t maxFieldSize = AnyCast<std::size_t>(session().getProperty("maxFieldSize"));
+
+		_preparations.push_back(new Preparator(_stmt, statement, maxFieldSize, ext));
+	}
+	else
+		_preparations.push_back(new Preparator(*_preparations[0]));
+
+	_extractors.push_back(new Extractor(_stmt, _preparations.back()));
+}
+
+
+void ODBCStatementImpl::doPrepare()
+{
+	if (session().getFeature("autoExtract") && hasData())
+	{
+		std::size_t curDataSet = currentDataSet();
+		poco_check_ptr (_preparations[curDataSet]);
+
+		Extractions& extracts = extractions();
+		Extractions::iterator it    = extracts.begin();
+		Extractions::iterator itEnd = extracts.end();
+
+		if (it != itEnd && (*it)->isBulk())
+		{
+			std::size_t limit = getExtractionLimit();
+			if (limit == Limit::LIMIT_UNLIMITED) 
+				throw InvalidArgumentException("Bulk operation not allowed without limit.");
+			checkError(Poco::Data::ODBC::SQLSetStmtAttr(_stmt, SQL_ATTR_ROW_ARRAY_SIZE, (SQLPOINTER) limit, 0),
+					"SQLSetStmtAttr(SQL_ATTR_ROW_ARRAY_SIZE)");
+		}
+
+		AbstractPreparation::Ptr pAP = 0;
+		Poco::Data::AbstractPreparator::Ptr pP = _preparations[curDataSet];
+		for (std::size_t pos = 0; it != itEnd; ++it)
+		{
+			pAP = (*it)->createPreparation(pP, pos);
+			pAP->prepare();
+			pos += (*it)->numOfColumnsHandled();
+		}
+
+		_prepared = true;
+	}
+}
+
+
+bool ODBCStatementImpl::canBind() const
+{
+	if (!bindings().empty())
+		return (*bindings().begin())->canBind();
+
+	return false;
+}
+
+
+void ODBCStatementImpl::doBind()
+{
+	this->clear();
+	Bindings& binds = bindings();
+	if (!binds.empty())
+	{
+		Bindings::iterator it    = binds.begin();
+		Bindings::iterator itEnd = binds.end();
+
+		if (it != itEnd && 0 == _affectedRowCount)
+			_affectedRowCount = static_cast<std::size_t>((*it)->numOfRowsHandled());
+
+		for (std::size_t pos = 0; it != itEnd && (*it)->canBind(); ++it)
+		{
+			(*it)->bind(pos);
+			pos += (*it)->numOfColumnsHandled();
+		}
+	}
+}
+
+
+void ODBCStatementImpl::bindImpl()
+{
+	doBind();
+
+	SQLRETURN rc = SQLExecute(_stmt);
+
+	if (SQL_NEED_DATA == rc) putData();
+	else checkError(rc, "SQLExecute()");
+
+	_pBinder->synchronize();
+}
+
+
+void ODBCStatementImpl::putData()
+{
+	SQLPOINTER pParam = 0;
+	SQLINTEGER dataSize = 0;
+	SQLRETURN rc;
+
+	while (SQL_NEED_DATA == (rc = SQLParamData(_stmt, &pParam)))
+	{
+		if (pParam)
+		{
+			dataSize = (SQLINTEGER) _pBinder->parameterSize(pParam);
+
+			if (Utility::isError(SQLPutData(_stmt, pParam, dataSize))) 
+				throw StatementException(_stmt, "SQLPutData()");
+		}
+		else // if pParam is null pointer, do a dummy call
+		{
+			char dummy = 0;
+			if (Utility::isError(SQLPutData(_stmt, &dummy, 0))) 
+				throw StatementException(_stmt, "SQLPutData()");
+		}
+	}
+
+	checkError(rc, "SQLParamData()");
+}
+
+
+void ODBCStatementImpl::clear()
+{
+	SQLRETURN rc = SQLCloseCursor(_stmt);
+	_stepCalled = false;
+	_affectedRowCount = 0;
+
+	if (Utility::isError(rc))
+	{
+		StatementError err(_stmt);
+		bool ignoreError = false;
+
+		const StatementDiagnostics& diagnostics = err.diagnostics();
+		//ignore "Invalid cursor state" error
+		//(returned by 3.x drivers when cursor is not opened)
+		for (int i = 0; i < diagnostics.count(); ++i)
+		{
+			if ((ignoreError =
+				(INVALID_CURSOR_STATE == std::string(diagnostics.sqlState(i)))))
+			{
+				break;
+			}
+		}
+
+		if (!ignoreError)
+			throw StatementException(_stmt, "SQLCloseCursor()");
+	}
+}
+
+
+bool ODBCStatementImpl::hasNext()
+{
+	if (hasData())
+	{
+		if (!extractions().size())
+			makeInternalExtractors();
+
+		if (!_prepared) doPrepare();
+
+		if (_stepCalled)
+			return _stepCalled = nextRowReady();
+
+		makeStep();
+
+		if (!nextRowReady())
+		{
+			if (hasMoreDataSets()) activateNextDataSet();
+			else return false;
+
+			if (SQL_NO_DATA == SQLMoreResults(_stmt))
+				return false;
+
+			addPreparator();
+			doPrepare();
+			fixupExtraction();
+			makeStep();
+		}
+		else if (Utility::isError(_nextResponse))
+			checkError(_nextResponse, "SQLFetch()");
+
+		return true;
+	}
+
+	return false;
+}
+
+
+void ODBCStatementImpl::makeStep()
+{
+	_extractors[currentDataSet()]->reset();
+	_nextResponse = SQLFetch(_stmt);
+	checkError(_nextResponse);
+	_stepCalled = true;
+}
+
+
+std::size_t ODBCStatementImpl::next()
+{
+	std::size_t count = 0;
+
+	if (nextRowReady())
+	{
+		Extractions& extracts = extractions();
+		Extractions::iterator it    = extracts.begin();
+		Extractions::iterator itEnd = extracts.end();
+		std::size_t prevCount = 0;
+		for (std::size_t pos = 0; it != itEnd; ++it)
+		{
+			count = (*it)->extract(pos);
+			if (prevCount && count != prevCount)
+				throw IllegalStateException("Different extraction counts");
+			prevCount = count;
+			pos += (*it)->numOfColumnsHandled();
+		}
+		_stepCalled = false;
+	}
+	else
+	{
+		throw StatementException(_stmt,
+			std::string("Next row not available."));
+	}
+
+	return count;
+}
+
+
+std::string ODBCStatementImpl::nativeSQL()
+{
+	std::string statement = toString();
+
+	SQLINTEGER length = (SQLINTEGER) statement.size() * 2;
+
+	char* pNative = 0;
+	SQLINTEGER retlen = length;
+	do
+	{
+		delete [] pNative;
+		pNative = new char[retlen];
+		std::memset(pNative, 0, retlen);
+		length = retlen;
+		if (Utility::isError(SQLNativeSql(_rConnection,
+			(SQLCHAR*) statement.c_str(),
+			(SQLINTEGER) statement.size(),
+			(SQLCHAR*) pNative,
+			length,
+			&retlen)))
+		{
+			delete [] pNative;
+			throw ConnectionException(_rConnection, "SQLNativeSql()");
+		}
+		++retlen;//accomodate for terminating '\0'
+	}while (retlen > length);
+
+	std::string sql(pNative);
+	delete [] pNative;
+	return sql;
+}
+
+
+void ODBCStatementImpl::checkError(SQLRETURN rc, const std::string& msg)
+{
+	if (SQL_NO_DATA == rc) return;
+
+	if (Utility::isError(rc))
+	{
+		std::ostringstream os;
+		os << std::endl << "Requested SQL statement: " << toString() << std::endl; 	 
+		os << "Native SQL statement: " << nativeSQL() << std::endl; 	 
+		std::string str(msg); str += os.str();
+		
+		throw StatementException(_stmt, str);
+	}
+}
+
+
+void ODBCStatementImpl::fillColumns()
+{
+	std::size_t colCount = columnsReturned();
+	std::size_t curDataSet = currentDataSet();
+	if (curDataSet >= _columnPtrs.size())
+		_columnPtrs.resize(curDataSet + 1);
+
+	for (int i = 0; i < colCount; ++i)
+		_columnPtrs[curDataSet].push_back(new ODBCMetaColumn(_stmt, i));
+}
+
+
+bool ODBCStatementImpl::isStoredProcedure() const 	 
+{ 	 
+	std::string str = toString(); 	 
+	if (trimInPlace(str).size() < 2) return false; 	 
+
+	return ('{' == str[0] && '}' == str[str.size()-1]); 	 
+}
+
+
+const MetaColumn& ODBCStatementImpl::metaColumn(std::size_t pos) const
+{
+	std::size_t curDataSet = currentDataSet();
+	poco_assert_dbg (curDataSet < _columnPtrs.size());
+
+	std::size_t sz = _columnPtrs[curDataSet].size();
+
+	if (0 == sz || pos > sz - 1)
+		throw InvalidAccessException(format("Invalid column number: %u", pos));
+
+	return *_columnPtrs[curDataSet][pos];
+}
+
+
+int ODBCStatementImpl::affectedRowCount() const
+{
+	if (0 == _affectedRowCount)
+	{
+		SQLLEN rows = 0;
+		if (!Utility::isError(SQLRowCount(_stmt, &rows)))
+			_affectedRowCount = static_cast<std::size_t>(rows);
+	}
+
+	return static_cast<int>(_affectedRowCount);
+}
+
+
+} } } // namespace Poco::Data::ODBC

base/poco/Data/ODBC/src/Parameter.cpp

@@ -0,0 +1,53 @@
+//
+// Parameter.cpp
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Parameter
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/ODBC/Parameter.h"
+#include "Poco/Data/ODBC/Utility.h"
+#include "Poco/Data/ODBC/Error.h"
+#include "Poco/Data/ODBC/ODBCException.h"
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+Parameter::Parameter(const StatementHandle& rStmt, std::size_t colNum) : 
+	_rStmt(rStmt), 
+	_number(colNum)
+{
+	init();
+}
+
+	
+Parameter::~Parameter()
+{
+}
+
+
+void Parameter::init()
+{
+	if (Utility::isError(SQLDescribeParam(_rStmt, 
+		(SQLUSMALLINT) _number + 1, 
+		&_dataType,
+		&_columnSize,
+		&_decimalDigits,
+		&_isNullable)))
+	{
+		throw StatementException(_rStmt);
+	}
+}
+
+
+} } } // namespace Poco::Data::ODBC

base/poco/Data/ODBC/src/Preparator.cpp

@@ -0,0 +1,209 @@
+//
+// Preparator.cpp
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Preparator
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/ODBC/Preparator.h"
+#include "Poco/Data/ODBC/ODBCMetaColumn.h"
+#include "Poco/Exception.h"
+
+
+using Poco::InvalidArgumentException;
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+Preparator::Preparator(const StatementHandle& rStmt, 
+	const std::string& statement, 
+	std::size_t maxFieldSize,
+	DataExtraction dataExtraction): 
+	_rStmt(rStmt),
+	_maxFieldSize(maxFieldSize),
+	_dataExtraction(dataExtraction)
+{
+	SQLCHAR* pStr = (SQLCHAR*) statement.c_str();
+	if (Utility::isError(Poco::Data::ODBC::SQLPrepare(_rStmt, pStr, (SQLINTEGER) statement.length())))
+		throw StatementException(_rStmt);
+}
+
+
+Preparator::Preparator(const Preparator& other): 
+	_rStmt(other._rStmt),
+	_maxFieldSize(other._maxFieldSize),
+	_dataExtraction(other._dataExtraction)
+{
+	resize();
+}
+
+
+Preparator::~Preparator()
+{
+	try
+	{
+		freeMemory();
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+void Preparator::freeMemory() const
+{
+	IndexMap::iterator it = _varLengthArrays.begin();
+	IndexMap::iterator end = _varLengthArrays.end();
+	for (; it != end; ++it)
+	{
+		switch (it->second)
+		{
+			case DT_BOOL:
+				deleteCachedArray<bool>(it->first);
+				break;
+
+			case DT_CHAR:
+				deleteCachedArray<char>(it->first);
+				break;
+
+			case DT_WCHAR:
+				deleteCachedArray<UTF16String::value_type>(it->first);
+				break;
+
+			case DT_UCHAR:
+				deleteCachedArray<unsigned char>(it->first);
+				break;
+
+			case DT_CHAR_ARRAY:
+			{
+				char** pc = AnyCast<char*>(&_values[it->first]);
+				if (pc) std::free(*pc);
+				break;
+			}
+
+			case DT_WCHAR_ARRAY:
+			{
+				UTF16String::value_type** pc = AnyCast<UTF16String::value_type*>(&_values[it->first]);
+				if (pc) std::free(*pc);
+				break;
+			}
+
+			case DT_UCHAR_ARRAY:
+			{
+				unsigned char** pc = AnyCast<unsigned char*>(&_values[it->first]);
+				if (pc) std::free(*pc);
+				break;
+			}
+
+			case DT_BOOL_ARRAY:
+			{
+				bool** pb = AnyCast<bool*>(&_values[it->first]);
+				if (pb) std::free(*pb);
+				break;
+			}
+
+			default:
+				throw InvalidArgumentException("Unknown data type.");
+		}
+	}
+}
+
+
+std::size_t Preparator::columns() const
+{
+	if (_values.empty()) resize();
+	return _values.size();
+}
+
+
+void Preparator::resize() const
+{
+	SQLSMALLINT nCol = 0;
+	if (!Utility::isError(SQLNumResultCols(_rStmt, &nCol)) && 0 != nCol)
+	{
+		_values.resize(nCol, 0);
+		_lengths.resize(nCol, 0);
+		_lenLengths.resize(nCol);
+		if(_varLengthArrays.size())
+		{
+			freeMemory();
+			_varLengthArrays.clear();
+		}
+	}
+}
+
+
+std::size_t Preparator::maxDataSize(std::size_t pos) const
+{
+	poco_assert_dbg (pos < _values.size());
+
+	std::size_t sz = 0;
+	std::size_t maxsz = getMaxFieldSize();
+
+	try 
+	{
+		ODBCMetaColumn mc(_rStmt, pos);
+		sz = mc.length();
+
+		// accomodate for terminating zero (non-bulk only!)
+		MetaColumn::ColumnDataType type = mc.type();
+		if (!isBulk() && ((ODBCMetaColumn::FDT_WSTRING == type) || (ODBCMetaColumn::FDT_STRING == type))) ++sz;
+	}
+	catch (StatementException&) { }
+
+	if (!sz || sz > maxsz) sz = maxsz;
+
+	return sz;
+}
+
+
+std::size_t Preparator::actualDataSize(std::size_t col, std::size_t row) const
+{
+	SQLLEN size = (POCO_DATA_INVALID_ROW == row) ? _lengths.at(col) :
+		_lenLengths.at(col).at(row);
+
+	// workaround for drivers returning negative length
+	if (size < 0 && SQL_NULL_DATA != size) size *= -1;
+
+	return size;
+}
+
+
+void Preparator::prepareBoolArray(std::size_t pos, SQLSMALLINT valueType, std::size_t length)
+{
+	poco_assert_dbg (DE_BOUND == _dataExtraction);
+	poco_assert_dbg (pos < _values.size());
+	poco_assert_dbg (pos < _lengths.size());
+	poco_assert_dbg (pos < _lenLengths.size());
+
+	bool* pArray = (bool*) std::calloc(length, sizeof(bool));
+
+	_values[pos] = Any(pArray);
+	_lengths[pos] = 0;
+	_lenLengths[pos].resize(length);
+	_varLengthArrays.insert(IndexMap::value_type(pos, DT_BOOL_ARRAY));
+
+	if (Utility::isError(SQLBindCol(_rStmt, 
+		(SQLUSMALLINT) pos + 1, 
+		valueType, 
+		(SQLPOINTER) pArray, 
+		(SQLINTEGER) sizeof(bool), 
+		&_lenLengths[pos][0])))
+	{
+		throw StatementException(_rStmt, "SQLBindCol()");
+	}
+}
+
+
+} } } // namespace Poco::Data::ODBC

base/poco/Data/ODBC/src/SessionImpl.cpp

@@ -0,0 +1,418 @@
+//
+// SessionImpl.cpp
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  SessionImpl
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/ODBC/SessionImpl.h"
+#include "Poco/Data/ODBC/Utility.h"
+#include "Poco/Data/ODBC/ODBCStatementImpl.h"
+#include "Poco/Data/ODBC/Error.h"
+#include "Poco/Data/ODBC/ODBCException.h"
+#include "Poco/Data/Session.h"
+#include "Poco/String.h"
+#include <sqlext.h>
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+SessionImpl::SessionImpl(const std::string& connect,
+	std::size_t loginTimeout,
+	std::size_t maxFieldSize,
+	bool autoBind,
+	bool autoExtract): 
+	Poco::Data::AbstractSessionImpl<SessionImpl>(connect, loginTimeout),
+		_connector(Connector::KEY),
+		_maxFieldSize(maxFieldSize),
+		_autoBind(autoBind),
+		_autoExtract(autoExtract),
+		_canTransact(ODBC_TXN_CAPABILITY_UNKNOWN),
+		_inTransaction(false),
+		_queryTimeout(-1)
+{
+	setFeature("bulk", true);
+	open();
+	setProperty("handle", _db.handle());
+}
+
+
+SessionImpl::SessionImpl(const std::string& connect,
+	Poco::Any maxFieldSize, 
+	bool enforceCapability,
+	bool autoBind,
+	bool autoExtract): Poco::Data::AbstractSessionImpl<SessionImpl>(connect),
+		_connector(Connector::KEY),
+		_maxFieldSize(maxFieldSize),
+		_autoBind(autoBind),
+		_autoExtract(autoExtract),
+		_canTransact(ODBC_TXN_CAPABILITY_UNKNOWN),
+		_inTransaction(false),
+		_queryTimeout(-1)
+{
+	setFeature("bulk", true);
+	open();
+	setProperty("handle", _db.handle());
+}
+
+
+SessionImpl::~SessionImpl()
+{
+	try
+	{
+		if (isTransaction() && !getFeature("autoCommit"))
+		{
+			try { rollback(); }
+			catch (...) { }
+		}
+
+		close();
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+Poco::Data::StatementImpl* SessionImpl::createStatementImpl()
+{
+	return new ODBCStatementImpl(*this);
+}
+
+
+void SessionImpl::open(const std::string& connect)
+{
+	if (connect != connectionString())
+	{
+		if (isConnected())
+			throw InvalidAccessException("Session already connected");
+
+		if (!connect.empty())
+			setConnectionString(connect);
+	}
+
+	poco_assert_dbg (!connectionString().empty());
+
+	SQLULEN tout = static_cast<SQLULEN>(getLoginTimeout());
+	if (Utility::isError(SQLSetConnectAttr(_db, SQL_ATTR_LOGIN_TIMEOUT, (SQLPOINTER) tout, 0)))
+	{
+		if (Utility::isError(SQLGetConnectAttr(_db, SQL_ATTR_LOGIN_TIMEOUT, &tout, 0, 0)) ||
+				getLoginTimeout() != tout)
+		{
+			ConnectionError e(_db);
+			throw ConnectionFailedException(e.toString());
+		}
+	}
+
+	SQLCHAR connectOutput[512] = {0};
+	SQLSMALLINT result;
+
+	if (Utility::isError(Poco::Data::ODBC::SQLDriverConnect(_db
+		, NULL
+		,(SQLCHAR*) connectionString().c_str()
+		,(SQLSMALLINT) SQL_NTS
+		, connectOutput
+		, sizeof(connectOutput)
+		, &result
+		, SQL_DRIVER_NOPROMPT)))
+	{
+		ConnectionError err(_db);
+		std::string errStr = err.toString();
+		close();
+		throw ConnectionFailedException(errStr);
+	}
+
+	_dataTypes.fillTypeInfo(_db);
+		addProperty("dataTypeInfo", 
+		&SessionImpl::setDataTypeInfo, 
+		&SessionImpl::dataTypeInfo);
+
+	addFeature("autoCommit", 
+		&SessionImpl::autoCommit, 
+		&SessionImpl::isAutoCommit);
+
+	addFeature("autoBind", 
+		&SessionImpl::autoBind, 
+		&SessionImpl::isAutoBind);
+
+	addFeature("autoExtract", 
+		&SessionImpl::autoExtract, 
+		&SessionImpl::isAutoExtract);
+
+	addProperty("maxFieldSize",
+		&SessionImpl::setMaxFieldSize,
+		&SessionImpl::getMaxFieldSize);
+
+	addProperty("queryTimeout",
+		&SessionImpl::setQueryTimeout,
+		&SessionImpl::getQueryTimeout);
+
+	Poco::Data::ODBC::SQLSetConnectAttr(_db, SQL_ATTR_QUIET_MODE, 0, 0);
+
+	if (!canTransact()) autoCommit("", true);
+}
+
+
+bool SessionImpl::isConnected()
+{
+	SQLULEN value = 0;
+
+	if (Utility::isError(Poco::Data::ODBC::SQLGetConnectAttr(_db,
+		SQL_ATTR_CONNECTION_DEAD,
+		&value,
+		0,
+		0))) return false;
+
+	return (SQL_CD_FALSE == value);
+}
+
+
+void SessionImpl::setConnectionTimeout(std::size_t timeout)
+{
+	SQLUINTEGER value = static_cast<SQLUINTEGER>(timeout);
+
+	checkError(Poco::Data::ODBC::SQLSetConnectAttr(_db,
+		SQL_ATTR_CONNECTION_TIMEOUT,
+		&value,
+		SQL_IS_UINTEGER), "Failed to set connection timeout.");
+}
+
+
+std::size_t SessionImpl::getConnectionTimeout()
+{
+	SQLULEN value = 0;
+
+	checkError(Poco::Data::ODBC::SQLGetConnectAttr(_db,
+		SQL_ATTR_CONNECTION_TIMEOUT,
+		&value,
+		0,
+		0), "Failed to get connection timeout.");
+
+	return value;
+}
+
+
+bool SessionImpl::canTransact()
+{
+	if (ODBC_TXN_CAPABILITY_UNKNOWN == _canTransact)
+	{
+		SQLUSMALLINT ret;
+		checkError(Poco::Data::ODBC::SQLGetInfo(_db, SQL_TXN_CAPABLE, &ret, 0, 0), 
+			"Failed to obtain transaction capability info.");
+
+		_canTransact = (SQL_TC_NONE != ret) ? 
+			ODBC_TXN_CAPABILITY_TRUE : 
+			ODBC_TXN_CAPABILITY_FALSE;
+	}
+
+	return ODBC_TXN_CAPABILITY_TRUE == _canTransact;
+}
+
+
+void SessionImpl::setTransactionIsolation(Poco::UInt32 ti)
+{
+#if POCO_PTR_IS_64_BIT
+	Poco::UInt64 isolation = 0;
+#else
+	Poco::UInt32 isolation = 0;
+#endif
+
+	if (ti & Session::TRANSACTION_READ_UNCOMMITTED)
+		isolation |= SQL_TXN_READ_UNCOMMITTED;
+
+	if (ti & Session::TRANSACTION_READ_COMMITTED)
+		isolation |= SQL_TXN_READ_COMMITTED;
+
+	if (ti & Session::TRANSACTION_REPEATABLE_READ)
+		isolation |= SQL_TXN_REPEATABLE_READ;
+
+	if (ti & Session::TRANSACTION_SERIALIZABLE)
+		isolation |= SQL_TXN_SERIALIZABLE;
+
+	checkError(SQLSetConnectAttr(_db, SQL_ATTR_TXN_ISOLATION, (SQLPOINTER) isolation, 0));
+}
+
+
+Poco::UInt32 SessionImpl::getTransactionIsolation()
+{
+	SQLULEN isolation = 0;
+	checkError(SQLGetConnectAttr(_db, SQL_ATTR_TXN_ISOLATION,
+		&isolation,
+		0,
+		0));
+
+	return transactionIsolation(isolation);
+}
+
+
+bool SessionImpl::hasTransactionIsolation(Poco::UInt32 ti)
+{
+	if (isTransaction()) throw InvalidAccessException();
+
+	bool retval = true;
+	Poco::UInt32 old = getTransactionIsolation();
+	try { setTransactionIsolation(ti); }
+	catch (Poco::Exception&) { retval = false; }
+	setTransactionIsolation(old);
+	return retval;
+}
+
+
+Poco::UInt32 SessionImpl::getDefaultTransactionIsolation()
+{
+	SQLUINTEGER isolation = 0;
+	checkError(SQLGetInfo(_db, SQL_DEFAULT_TXN_ISOLATION,
+		&isolation,
+		0,
+		0));
+
+	return transactionIsolation(isolation);
+}
+
+
+Poco::UInt32 SessionImpl::transactionIsolation(SQLULEN isolation)
+{
+	if (0 == isolation)
+		throw InvalidArgumentException("transactionIsolation(SQLUINTEGER)");
+
+	Poco::UInt32 ret = 0;
+
+	if (isolation & SQL_TXN_READ_UNCOMMITTED)
+		ret |= Session::TRANSACTION_READ_UNCOMMITTED;
+
+	if (isolation & SQL_TXN_READ_COMMITTED)
+		ret |= Session::TRANSACTION_READ_COMMITTED;
+
+	if (isolation & SQL_TXN_REPEATABLE_READ)
+		ret |= Session::TRANSACTION_REPEATABLE_READ;
+
+	if (isolation & SQL_TXN_SERIALIZABLE)
+		ret |= Session::TRANSACTION_SERIALIZABLE;
+
+	if (0 == ret)
+		throw InvalidArgumentException("transactionIsolation(SQLUINTEGER)");
+
+	return ret;
+}
+
+
+void SessionImpl::autoCommit(const std::string&, bool val)
+{
+	checkError(Poco::Data::ODBC::SQLSetConnectAttr(_db, 
+		SQL_ATTR_AUTOCOMMIT, 
+		val ? (SQLPOINTER) SQL_AUTOCOMMIT_ON : 
+			(SQLPOINTER) SQL_AUTOCOMMIT_OFF, 
+		SQL_IS_UINTEGER), "Failed to set automatic commit.");
+}
+
+
+bool SessionImpl::isAutoCommit(const std::string&)
+{
+	SQLULEN value = 0;
+
+	checkError(Poco::Data::ODBC::SQLGetConnectAttr(_db,
+		SQL_ATTR_AUTOCOMMIT,
+		&value,
+		0,
+		0));
+
+	return (0 != value);
+}
+
+
+bool SessionImpl::isTransaction()
+{
+	if (!canTransact()) return false;
+
+	SQLULEN value = 0;
+	checkError(Poco::Data::ODBC::SQLGetConnectAttr(_db,
+		SQL_ATTR_AUTOCOMMIT,
+		&value,
+		0,
+		0));
+
+	if (0 == value) return _inTransaction;
+	else return false;
+}
+
+
+void SessionImpl::begin()
+{
+	if (isAutoCommit())
+		throw InvalidAccessException("Session in auto commit mode.");
+
+	{
+		Poco::FastMutex::ScopedLock l(_mutex);
+
+		if (_inTransaction)
+			throw InvalidAccessException("Transaction in progress.");
+
+		_inTransaction = true;
+	}
+}
+
+
+void SessionImpl::commit()
+{
+	if (!isAutoCommit())
+		checkError(SQLEndTran(SQL_HANDLE_DBC, _db, SQL_COMMIT));
+
+	_inTransaction = false;
+}
+
+
+void SessionImpl::rollback()
+{
+	if (!isAutoCommit())
+		checkError(SQLEndTran(SQL_HANDLE_DBC, _db, SQL_ROLLBACK));
+
+	_inTransaction = false;
+}
+
+
+void SessionImpl::close()
+{
+	if (!isConnected()) return;
+
+	try
+	{
+		commit();
+	}
+	catch (ConnectionException&) 
+	{
+	}
+
+	SQLDisconnect(_db);
+}
+
+
+int SessionImpl::maxStatementLength()
+{
+	SQLUINTEGER info;
+	SQLRETURN rc = 0;
+	if (Utility::isError(rc = Poco::Data::ODBC::SQLGetInfo(_db,
+		SQL_MAXIMUM_STATEMENT_LENGTH,
+		(SQLPOINTER) &info,
+		0,
+		0)))
+	{
+		throw ConnectionException(_db, 
+			"SQLGetInfo(SQL_MAXIMUM_STATEMENT_LENGTH)");
+	}
+
+	return info;
+}
+
+
+} } } // namespace Poco::Data::ODBC

base/poco/Data/ODBC/src/TypeInfo.cpp

@@ -0,0 +1,265 @@
+//
+// TypeInfo.cpp
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  TypeInfo
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/ODBC/TypeInfo.h"
+#include "Poco/Data/ODBC/ODBCException.h"
+#include "Poco/Format.h"
+#include "Poco/Exception.h"
+#include <iostream>
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+TypeInfo::TypeInfo(SQLHDBC* pHDBC): _pHDBC(pHDBC)
+{
+	fillCTypes();
+	fillSQLTypes();
+	if (_pHDBC) fillTypeInfo(*_pHDBC);
+}
+
+
+TypeInfo::~TypeInfo()
+{
+}
+
+
+void TypeInfo::fillCTypes()
+{
+	_cDataTypes.insert(ValueType(SQL_CHAR, SQL_C_CHAR));
+	_cDataTypes.insert(ValueType(SQL_VARCHAR, SQL_C_CHAR));
+	_cDataTypes.insert(ValueType(SQL_LONGVARCHAR, SQL_C_CHAR));
+	_cDataTypes.insert(ValueType(SQL_DECIMAL, SQL_C_DOUBLE));
+	_cDataTypes.insert(ValueType(SQL_NUMERIC, SQL_C_DOUBLE));
+	_cDataTypes.insert(ValueType(SQL_BIT, SQL_C_BIT));
+	_cDataTypes.insert(ValueType(SQL_TINYINT, SQL_C_STINYINT));
+	_cDataTypes.insert(ValueType(SQL_SMALLINT, SQL_C_SSHORT));
+	_cDataTypes.insert(ValueType(SQL_INTEGER, SQL_C_SLONG));
+	_cDataTypes.insert(ValueType(SQL_BIGINT, SQL_C_SBIGINT));
+	_cDataTypes.insert(ValueType(SQL_REAL, SQL_C_FLOAT));
+	_cDataTypes.insert(ValueType(SQL_FLOAT, SQL_C_DOUBLE));
+	_cDataTypes.insert(ValueType(SQL_DOUBLE, SQL_C_DOUBLE));
+	_cDataTypes.insert(ValueType(SQL_BINARY, SQL_C_BINARY));
+	_cDataTypes.insert(ValueType(SQL_VARBINARY, SQL_C_BINARY));
+	_cDataTypes.insert(ValueType(SQL_LONGVARBINARY, SQL_C_BINARY));
+	_cDataTypes.insert(ValueType(SQL_TYPE_DATE, SQL_C_TYPE_DATE));
+	_cDataTypes.insert(ValueType(SQL_TYPE_TIME, SQL_C_TYPE_TIME));
+	_cDataTypes.insert(ValueType(SQL_TYPE_TIMESTAMP, SQL_C_TYPE_TIMESTAMP));
+}
+
+
+void TypeInfo::fillSQLTypes()
+{
+	_sqlDataTypes.insert(ValueType(SQL_C_CHAR, SQL_LONGVARCHAR));
+	_sqlDataTypes.insert(ValueType(SQL_C_BIT, SQL_BIT));
+	_sqlDataTypes.insert(ValueType(SQL_C_TINYINT, SQL_TINYINT));
+	_sqlDataTypes.insert(ValueType(SQL_C_STINYINT, SQL_TINYINT));
+	_sqlDataTypes.insert(ValueType(SQL_C_UTINYINT, SQL_TINYINT));
+	_sqlDataTypes.insert(ValueType(SQL_C_SHORT, SQL_SMALLINT));
+	_sqlDataTypes.insert(ValueType(SQL_C_SSHORT, SQL_SMALLINT));
+	_sqlDataTypes.insert(ValueType(SQL_C_USHORT, SQL_SMALLINT));
+	_sqlDataTypes.insert(ValueType(SQL_C_LONG, SQL_INTEGER));
+	_sqlDataTypes.insert(ValueType(SQL_C_SLONG, SQL_INTEGER));
+	_sqlDataTypes.insert(ValueType(SQL_C_ULONG, SQL_INTEGER));
+	_sqlDataTypes.insert(ValueType(SQL_C_SBIGINT, SQL_BIGINT));
+	_sqlDataTypes.insert(ValueType(SQL_C_UBIGINT, SQL_BIGINT));
+	_sqlDataTypes.insert(ValueType(SQL_C_FLOAT, SQL_REAL));
+	_sqlDataTypes.insert(ValueType(SQL_C_DOUBLE, SQL_DOUBLE));
+	_sqlDataTypes.insert(ValueType(SQL_C_BINARY, SQL_LONGVARBINARY));
+	_sqlDataTypes.insert(ValueType(SQL_C_TYPE_DATE, SQL_TYPE_DATE));
+	_sqlDataTypes.insert(ValueType(SQL_C_TYPE_TIME, SQL_TYPE_TIME));
+	_sqlDataTypes.insert(ValueType(SQL_C_TYPE_TIMESTAMP, SQL_TYPE_TIMESTAMP));
+}
+
+
+void TypeInfo::fillTypeInfo(SQLHDBC pHDBC)
+{
+	_pHDBC = &pHDBC;
+
+	if (_typeInfo.empty() && _pHDBC)
+	{
+		const static int stringSize = 512;
+		TypeInfoVec().swap(_typeInfo);
+
+		SQLRETURN rc;
+		SQLHSTMT hstmt = SQL_NULL_HSTMT;
+
+		rc = SQLAllocHandle(SQL_HANDLE_STMT, *_pHDBC, &hstmt);
+		if (!SQL_SUCCEEDED(rc))
+			throw StatementException(hstmt, "SQLGetData()");
+
+		rc = SQLGetTypeInfo(hstmt, SQL_ALL_TYPES);
+		if (SQL_SUCCEEDED(rc))
+		{
+			while (SQLFetch(hstmt) != SQL_NO_DATA_FOUND)
+			{
+				char typeName[stringSize] = { 0 };
+				char literalPrefix[stringSize] = { 0 };
+				char literalSuffix[stringSize] = { 0 };
+				char createParams[stringSize] = { 0 };
+				char localTypeName[stringSize] = { 0 };
+				
+				TypeInfoTup ti("TYPE_NAME", "",
+					"DATA_TYPE", 0,
+					"COLUMN_SIZE", 0,
+					"LITERAL_PREFIX", "",
+					"LITERAL_SUFFIX", "",
+					"CREATE_PARAMS", "",
+					"NULLABLE", 0,
+					"CASE_SENSITIVE", 0,
+					"SEARCHABLE", 0,
+					"UNSIGNED_ATTRIBUTE", 0,
+					"FIXED_PREC_SCALE", 0,
+					"AUTO_UNIQUE_VALUE", 0,
+					"LOCAL_TYPE_NAME", "",
+					"MINIMUM_SCALE", 0,
+					"MAXIMUM_SCALE", 0,
+					"SQL_DATA_TYPE", 0,
+					"SQL_DATETIME_SUB", 0,
+					"NUM_PREC_RADIX", 0,
+					"INTERVAL_PRECISION", 0);
+
+				SQLLEN ind = 0;
+				rc = SQLGetData(hstmt, 1, SQL_C_CHAR, typeName, sizeof(typeName), &ind);
+				ti.set<0>(typeName);
+				rc = SQLGetData(hstmt, 2, SQL_C_SSHORT, &ti.get<1>(), sizeof(SQLSMALLINT), &ind);
+				rc = SQLGetData(hstmt, 3, SQL_C_SLONG, &ti.get<2>(), sizeof(SQLINTEGER), &ind);
+				rc = SQLGetData(hstmt, 4, SQL_C_CHAR, literalPrefix, sizeof(literalPrefix), &ind);
+				ti.set<3>(literalPrefix);
+				rc = SQLGetData(hstmt, 5, SQL_C_CHAR, literalSuffix, sizeof(literalSuffix), &ind);
+				ti.set<4>(literalSuffix);
+				rc = SQLGetData(hstmt, 6, SQL_C_CHAR, createParams, sizeof(createParams), &ind);
+				ti.set<5>(createParams);
+				rc = SQLGetData(hstmt, 7, SQL_C_SSHORT, &ti.get<6>(), sizeof(SQLSMALLINT), &ind); 
+				rc = SQLGetData(hstmt, 8, SQL_C_SSHORT, &ti.get<7>(), sizeof(SQLSMALLINT), &ind); 
+				rc = SQLGetData(hstmt, 9, SQL_C_SSHORT, &ti.get<8>(), sizeof(SQLSMALLINT), &ind); 
+				rc = SQLGetData(hstmt, 10, SQL_C_SSHORT, &ti.get<9>(), sizeof(SQLSMALLINT), &ind); 
+				rc = SQLGetData(hstmt, 11, SQL_C_SSHORT, &ti.get<10>(), sizeof(SQLSMALLINT), &ind);
+				rc = SQLGetData(hstmt, 12, SQL_C_SSHORT, &ti.get<11>(), sizeof(SQLSMALLINT), &ind);
+				rc = SQLGetData(hstmt, 13, SQL_C_CHAR, localTypeName, sizeof(localTypeName), &ind);
+				ti.set<12>(localTypeName);
+				rc = SQLGetData(hstmt, 14, SQL_C_SSHORT, &ti.get<13>(), sizeof(SQLSMALLINT), &ind);
+				rc = SQLGetData(hstmt, 15, SQL_C_SSHORT, &ti.get<14>(), sizeof(SQLSMALLINT), &ind);
+				rc = SQLGetData(hstmt, 16, SQL_C_SSHORT, &ti.get<15>(), sizeof(SQLSMALLINT), &ind);
+				rc = SQLGetData(hstmt, 17, SQL_C_SSHORT, &ti.get<16>(), sizeof(SQLSMALLINT), &ind);
+				rc = SQLGetData(hstmt, 18, SQL_C_SLONG, &ti.get<17>(), sizeof(SQLINTEGER), &ind);
+				rc = SQLGetData(hstmt, 19, SQL_C_SSHORT, &ti.get<18>(), sizeof(SQLSMALLINT), &ind);
+
+				_typeInfo.push_back(ti);
+			}
+		}
+
+		SQLFreeHandle(SQL_HANDLE_STMT, hstmt);
+	}
+}
+
+
+DynamicAny TypeInfo::getInfo(SQLSMALLINT type, const std::string& param) const
+{
+	TypeInfoVec::const_iterator it = _typeInfo.begin();
+	TypeInfoVec::const_iterator end = _typeInfo.end();
+	for (; it != end; ++it)
+	{
+		if (type == it->get<1>())
+			return (*it)[param];
+	}
+
+	throw NotFoundException(param);
+}
+
+
+bool TypeInfo::tryGetInfo(SQLSMALLINT type, const std::string& param, DynamicAny& result) const
+{
+	TypeInfoVec::const_iterator it = _typeInfo.begin();
+	TypeInfoVec::const_iterator end = _typeInfo.end();
+	for (; it != end; ++it)
+	{
+		if (type == it->get<1>())
+		{
+			result = (*it)[param];
+			return true;
+		}
+	}
+	
+	return false;
+}
+
+
+int TypeInfo::cDataType(int sqlDataType) const
+{
+	DataTypeMap::const_iterator it = _cDataTypes.find(sqlDataType);
+
+	if (_cDataTypes.end() == it)
+		throw NotFoundException(format("C data type not found for SQL data type: %d", sqlDataType));
+
+	return it->second;
+}
+
+
+int TypeInfo::sqlDataType(int cDataType) const
+{
+	DataTypeMap::const_iterator it = _sqlDataTypes.find(cDataType);
+
+	if (_sqlDataTypes.end() == it)
+		throw NotFoundException(format("SQL data type not found for C data type: %d", cDataType));
+
+	return it->second;
+}
+
+
+void TypeInfo::print(std::ostream& ostr)
+{
+	if (_typeInfo.empty())
+	{
+		ostr << "No data found.";
+		return;
+	}
+
+	TypeInfoTup::NameVec::const_iterator nIt = (*_typeInfo[0].names()).begin();
+	TypeInfoTup::NameVec::const_iterator nItEnd = (*_typeInfo[0].names()).end();
+	for (; nIt != nItEnd; ++nIt)
+		ostr << *nIt << "\t";
+
+	ostr << std::endl;
+
+	TypeInfoVec::const_iterator it = _typeInfo.begin();
+	TypeInfoVec::const_iterator end = _typeInfo.end();
+
+	for (; it != end; ++it)
+	{
+		ostr << it->get<0>() << "\t" 
+			<< it->get<1>() << "\t" 
+			<< it->get<2>() << "\t" 
+			<< it->get<3>() << "\t" 
+			<< it->get<4>() << "\t" 
+			<< it->get<5>() << "\t" 
+			<< it->get<6>() << "\t" 
+			<< it->get<7>() << "\t" 
+			<< it->get<8>() << "\t" 
+			<< it->get<9>() << "\t" 
+			<< it->get<10>() << "\t" 
+			<< it->get<11>() << "\t" 
+			<< it->get<12>() << "\t" 
+			<< it->get<13>() << "\t" 
+			<< it->get<14>() << "\t"
+			<< it->get<15>() << "\t" 
+			<< it->get<16>() << "\t" 
+			<< it->get<17>() << "\t" 
+			<< it->get<18>() << std::endl;
+	}
+}
+
+
+} } } // namespace Poco::Data::ODBC

base/poco/Data/ODBC/src/Unicode.cpp

@@ -0,0 +1,22 @@
+//
+// Unicode.cpp
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Unicode
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/ODBC/ODBC.h"
+
+
+#if defined(POCO_ODBC_UNICODE_WINDOWS)
+#include "Unicode_WIN32.cpp"
+#elif defined(POCO_ODBC_UNICODE_UNIXODBC)
+#include "Unicode_UNIXODBC.cpp"
+#endif

base/poco/Data/ODBC/src/Unicode_UNIXODBC.cpp

@@ -0,0 +1,775 @@
+//
+// Unicode.cpp
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Unicode
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/ODBC/ODBC.h"
+#include "Poco/Data/ODBC/Unicode_UNIXODBC.h"
+#include "Poco/TextConverter.h"
+#include "Poco/UTF8Encoding.h"
+#include "Poco/UTF16Encoding.h"
+#include "Poco/Buffer.h"
+#include "Poco/Exception.h"
+#include <iostream>
+
+
+using Poco::Buffer;
+using Poco::UTF8Encoding;
+using Poco::UTF16Encoding;
+using Poco::TextConverter;
+using Poco::InvalidArgumentException;
+using Poco::NotImplementedException;
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+void makeUTF16(SQLCHAR* pSQLChar, SQLINTEGER length, std::string& target)
+{
+	int len = length;
+	if (SQL_NTS == len) 
+		len = (int) std::strlen((const char *) pSQLChar);
+
+	UTF8Encoding utf8Encoding;
+	UTF16Encoding utf16Encoding;
+	TextConverter converter(utf8Encoding, utf16Encoding);
+
+	if (0 != converter.convert(pSQLChar, len, target))
+		throw DataFormatException("Error converting UTF-8 to UTF-16");
+}
+
+
+void makeUTF8(Poco::Buffer<SQLWCHAR>& buffer, SQLINTEGER length, SQLPOINTER pTarget, SQLINTEGER targetLength)
+{
+	UTF8Encoding utf8Encoding;
+	UTF16Encoding utf16Encoding;
+	TextConverter converter(utf16Encoding, utf8Encoding);
+
+	std::string result;
+	if (0 != converter.convert(buffer.begin(), length, result))
+		throw DataFormatException("Error converting UTF-16 to UTF-8");
+	
+	std::memset(pTarget, 0, targetLength);
+	std::strncpy((char*) pTarget, result.c_str(), result.size() < targetLength ? result.size() : targetLength);
+}
+
+
+SQLRETURN SQLColAttribute(SQLHSTMT hstmt,
+	SQLUSMALLINT   iCol,
+	SQLUSMALLINT   iField,
+	SQLPOINTER	   pCharAttr,
+	SQLSMALLINT	   cbCharAttrMax,	
+	SQLSMALLINT*   pcbCharAttr,
+	NumAttrPtrType pNumAttr)
+{
+	if (isString(pCharAttr, cbCharAttrMax))
+	{
+		Buffer<SQLWCHAR> buffer(stringLength(pCharAttr, cbCharAttrMax));
+
+		SQLRETURN rc = SQLColAttributeW(hstmt,
+			iCol,
+			iField,
+			buffer.begin(),
+			(SQLSMALLINT) buffer.sizeBytes(),
+			pcbCharAttr,
+			pNumAttr);
+
+		makeUTF8(buffer, *pcbCharAttr, pCharAttr, cbCharAttrMax);
+		return rc;
+	}
+
+	return SQLColAttributeW(hstmt,
+		iCol,
+		iField,
+		pCharAttr,
+		cbCharAttrMax,	
+		pcbCharAttr,
+		pNumAttr);
+}
+
+
+SQLRETURN SQLColAttributes(SQLHSTMT hstmt,
+	SQLUSMALLINT icol,
+	SQLUSMALLINT fDescType,
+	SQLPOINTER   rgbDesc,
+	SQLSMALLINT  cbDescMax,
+	SQLSMALLINT* pcbDesc,
+	SQLLEN*      pfDesc)
+{
+	return SQLColAttribute(hstmt,
+		icol,
+		fDescType,
+		rgbDesc,
+		cbDescMax,
+		pcbDesc,
+		pfDesc);
+}
+
+
+SQLRETURN SQLConnect(SQLHDBC hdbc,
+	SQLCHAR*    szDSN,
+	SQLSMALLINT cbDSN,
+	SQLCHAR*    szUID,
+	SQLSMALLINT cbUID,
+	SQLCHAR*    szAuthStr,
+	SQLSMALLINT cbAuthStr)
+{
+	std::string sqlDSN;
+	makeUTF16(szDSN, cbDSN, sqlDSN);
+
+	std::string sqlUID;
+	makeUTF16(szUID, cbUID, sqlUID);
+
+	std::string sqlPWD;
+	makeUTF16(szAuthStr, cbAuthStr, sqlPWD);
+	
+	return SQLConnectW(hdbc, 
+		(SQLWCHAR*) sqlDSN.c_str(), cbDSN,
+		(SQLWCHAR*) sqlUID.c_str(), cbUID,
+		(SQLWCHAR*) sqlPWD.c_str(), cbAuthStr);
+}
+
+
+SQLRETURN SQLDescribeCol(SQLHSTMT hstmt,
+	SQLUSMALLINT icol,
+	SQLCHAR*     szColName,
+	SQLSMALLINT  cbColNameMax,
+	SQLSMALLINT* pcbColName,
+	SQLSMALLINT* pfSqlType,
+	SQLULEN*     pcbColDef,
+	SQLSMALLINT* pibScale,
+	SQLSMALLINT* pfNullable)
+{
+	Buffer<SQLWCHAR> buffer(cbColNameMax);
+	SQLRETURN rc = SQLDescribeColW(hstmt,
+		icol,
+		(SQLWCHAR*) buffer.begin(),
+		(SQLSMALLINT) buffer.size(),
+		pcbColName,
+		pfSqlType,
+		pcbColDef,
+		pibScale,
+		pfNullable);
+
+	makeUTF8(buffer, *pcbColName * sizeof(SQLWCHAR), szColName, cbColNameMax);
+	return rc;
+}
+
+
+SQLRETURN SQLError(SQLHENV henv,
+	SQLHDBC      hdbc,
+	SQLHSTMT     hstmt,
+	SQLCHAR*     szSqlState,
+	SQLINTEGER*  pfNativeError,
+	SQLCHAR*     szErrorMsg,
+	SQLSMALLINT  cbErrorMsgMax,
+	SQLSMALLINT* pcbErrorMsg)
+{
+	throw NotImplementedException("SQLError is obsolete. "
+		"Use SQLGetDiagRec instead.");
+}
+
+
+SQLRETURN SQLExecDirect(SQLHSTMT hstmt,
+	SQLCHAR*   szSqlStr,
+	SQLINTEGER cbSqlStr)
+{
+	std::string sqlStr;
+	makeUTF16(szSqlStr, cbSqlStr, sqlStr);
+
+	return SQLExecDirectW(hstmt, (SQLWCHAR*) sqlStr.c_str(), cbSqlStr);
+}
+
+
+SQLRETURN SQLGetConnectAttr(SQLHDBC hdbc,
+	SQLINTEGER  fAttribute,
+	SQLPOINTER  rgbValue,
+	SQLINTEGER  cbValueMax,
+	SQLINTEGER* pcbValue)
+{
+	if (isString(rgbValue, cbValueMax))
+	{
+		Buffer<SQLWCHAR> buffer(stringLength(rgbValue, cbValueMax));
+
+		SQLRETURN rc = SQLGetConnectAttrW(hdbc,
+				fAttribute,
+				buffer.begin(),
+				(SQLINTEGER) buffer.sizeBytes(),
+				pcbValue);
+
+		makeUTF8(buffer, *pcbValue, rgbValue, cbValueMax);
+		return rc;
+	}
+	
+
+	return SQLGetConnectAttrW(hdbc,
+		fAttribute,
+		rgbValue,
+		cbValueMax,
+		pcbValue);
+}
+
+
+SQLRETURN SQLGetCursorName(SQLHSTMT hstmt,
+	SQLCHAR*     szCursor,
+	SQLSMALLINT  cbCursorMax,
+	SQLSMALLINT* pcbCursor)
+{
+	throw NotImplementedException("Not implemented");
+}
+
+
+SQLRETURN SQLSetDescField(SQLHDESC hdesc,
+	SQLSMALLINT iRecord, 
+	SQLSMALLINT iField,
+	SQLPOINTER  rgbValue, 
+	SQLINTEGER  cbValueMax)
+{
+	if (isString(rgbValue, cbValueMax))
+	{
+		std::string str;
+		makeUTF16((SQLCHAR*) rgbValue, cbValueMax, str);
+
+		return SQLSetDescFieldW(hdesc,
+			iRecord, 
+			iField,
+			(SQLPOINTER) str.c_str(), 
+			(SQLINTEGER) str.size() * sizeof(SQLWCHAR));
+	}
+
+	return SQLSetDescFieldW(hdesc,
+		iRecord, 
+		iField,
+		rgbValue, 
+		cbValueMax);
+}
+
+
+SQLRETURN SQLGetDescField(SQLHDESC hdesc,
+	SQLSMALLINT iRecord,
+	SQLSMALLINT iField,
+	SQLPOINTER  rgbValue,
+	SQLINTEGER	cbValueMax,
+	SQLINTEGER* pcbValue)
+{
+	if (isString(rgbValue, cbValueMax))
+	{
+		Buffer<SQLWCHAR> buffer(stringLength(rgbValue, cbValueMax));
+
+		SQLRETURN rc = SQLGetDescFieldW(hdesc,
+			iRecord,
+			iField,
+			buffer.begin(),
+			(SQLINTEGER) buffer.sizeBytes(),
+			pcbValue);
+
+		makeUTF8(buffer, *pcbValue, rgbValue, cbValueMax);
+
+		return rc;
+	}
+
+	return SQLGetDescFieldW(hdesc,
+		iRecord,
+		iField,
+		rgbValue,
+		cbValueMax,
+		pcbValue);
+}
+
+
+SQLRETURN SQLGetDescRec(SQLHDESC hdesc,
+	SQLSMALLINT  iRecord,
+	SQLCHAR*     szName,
+	SQLSMALLINT  cbNameMax,
+	SQLSMALLINT* pcbName,
+	SQLSMALLINT* pfType,
+	SQLSMALLINT* pfSubType,
+	SQLLEN*      pLength,
+	SQLSMALLINT* pPrecision, 
+	SQLSMALLINT* pScale,
+	SQLSMALLINT* pNullable)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLGetDiagField(SQLSMALLINT fHandleType,
+	SQLHANDLE    handle,
+	SQLSMALLINT  iRecord,
+	SQLSMALLINT  fDiagField,
+	SQLPOINTER   rgbDiagInfo,
+	SQLSMALLINT  cbDiagInfoMax,
+	SQLSMALLINT* pcbDiagInfo)
+{
+	if (isString(rgbDiagInfo, cbDiagInfoMax))
+	{
+		Buffer<SQLWCHAR> buffer(stringLength(rgbDiagInfo, cbDiagInfoMax));
+
+		SQLRETURN rc = SQLGetDiagFieldW(fHandleType,
+			handle,
+			iRecord,
+			fDiagField,
+			buffer.begin(),
+			(SQLSMALLINT) buffer.sizeBytes(),
+			pcbDiagInfo);
+
+		makeUTF8(buffer, *pcbDiagInfo, rgbDiagInfo, cbDiagInfoMax);
+
+		return rc;
+	}
+
+	return SQLGetDiagFieldW(fHandleType,
+		handle,
+		iRecord,
+		fDiagField,
+		rgbDiagInfo,
+		cbDiagInfoMax,
+		pcbDiagInfo);
+}
+
+
+SQLRETURN SQLGetDiagRec(SQLSMALLINT fHandleType,
+	SQLHANDLE    handle,
+	SQLSMALLINT  iRecord,
+	SQLCHAR*     szSqlState,
+	SQLINTEGER*  pfNativeError,
+	SQLCHAR*     szErrorMsg,
+	SQLSMALLINT  cbErrorMsgMax,
+	SQLSMALLINT* pcbErrorMsg)
+{
+	const SQLINTEGER stateLen = SQL_SQLSTATE_SIZE + 1;
+	Buffer<SQLWCHAR> bufState(stateLen);
+	Buffer<SQLWCHAR> bufErr(cbErrorMsgMax);
+
+	SQLRETURN rc = SQLGetDiagRecW(fHandleType,
+		handle,
+		iRecord,
+		bufState.begin(),
+		pfNativeError,
+		bufErr.begin(),
+		(SQLSMALLINT) bufErr.size(),
+		pcbErrorMsg);
+
+	makeUTF8(bufState, stateLen * sizeof(SQLWCHAR), szSqlState, stateLen);
+	makeUTF8(bufErr, *pcbErrorMsg * sizeof(SQLWCHAR), szErrorMsg, cbErrorMsgMax);
+
+	return rc;
+}
+
+
+SQLRETURN SQLPrepare(SQLHSTMT hstmt,
+	SQLCHAR*   szSqlStr,
+	SQLINTEGER cbSqlStr)
+{
+	std::string sqlStr;
+	makeUTF16(szSqlStr, cbSqlStr, sqlStr);
+
+	return SQLPrepareW(hstmt, (SQLWCHAR*) sqlStr.c_str(), (SQLINTEGER) sqlStr.size());
+}
+
+
+SQLRETURN SQLSetConnectAttr(SQLHDBC hdbc,
+	SQLINTEGER fAttribute,
+	SQLPOINTER rgbValue,
+	SQLINTEGER cbValue)
+{
+	if (isString(rgbValue, cbValue))
+	{
+		std::string str;
+		makeUTF16((SQLCHAR*) rgbValue, cbValue, str);
+
+		return SQLSetConnectAttrW(hdbc,
+			fAttribute,
+			(SQLWCHAR*) str.c_str(), 
+			(SQLINTEGER) str.size() * sizeof(SQLWCHAR));
+	}
+
+	return SQLSetConnectAttrW(hdbc,	fAttribute,	rgbValue, cbValue);
+}
+
+
+SQLRETURN SQLSetCursorName(SQLHSTMT hstmt,
+	SQLCHAR*    szCursor,
+	SQLSMALLINT cbCursor)
+{
+	throw NotImplementedException("Not implemented");
+}
+
+
+SQLRETURN SQLSetStmtAttr(SQLHSTMT hstmt,
+	SQLINTEGER fAttribute,
+	SQLPOINTER rgbValue,
+	SQLINTEGER cbValueMax)
+{
+	if (isString(rgbValue, cbValueMax))
+	{
+		std::string str;
+		makeUTF16((SQLCHAR*) rgbValue, cbValueMax, str);
+
+		return SQLSetStmtAttrW(hstmt,
+			fAttribute,
+			(SQLWCHAR*) str.c_str(),
+			(SQLINTEGER) str.size());
+	}
+
+	return SQLSetStmtAttrW(hstmt, fAttribute, rgbValue,	cbValueMax);
+}
+
+
+SQLRETURN SQLGetStmtAttr(SQLHSTMT hstmt,
+	SQLINTEGER  fAttribute,
+	SQLPOINTER  rgbValue,
+	SQLINTEGER  cbValueMax,
+	SQLINTEGER* pcbValue)
+{
+	if (isString(rgbValue, cbValueMax))
+	{
+		Buffer<SQLWCHAR> buffer(stringLength(rgbValue, cbValueMax));
+
+		return SQLGetStmtAttrW(hstmt,
+			fAttribute,
+			(SQLPOINTER) buffer.begin(),
+			(SQLINTEGER) buffer.sizeBytes(),
+			pcbValue);
+	}
+
+	return SQLGetStmtAttrW(hstmt, fAttribute, rgbValue, cbValueMax, pcbValue);
+}
+
+
+SQLRETURN SQLColumns(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName,
+	SQLCHAR*    szColumnName,
+	SQLSMALLINT cbColumnName)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLGetConnectOption(SQLHDBC hdbc,
+	SQLUSMALLINT fOption,
+	SQLPOINTER   pvParam)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLGetInfo(SQLHDBC hdbc,
+	SQLUSMALLINT fInfoType,
+	SQLPOINTER   rgbInfoValue,
+	SQLSMALLINT  cbInfoValueMax,
+	SQLSMALLINT* pcbInfoValue)
+{
+	if (cbInfoValueMax)
+	{
+		Buffer<SQLWCHAR> buffer(cbInfoValueMax);
+
+		SQLRETURN rc = SQLGetInfoW(hdbc,
+			fInfoType,
+			(SQLPOINTER) buffer.begin(),
+			(SQLSMALLINT) buffer.sizeBytes(),
+			pcbInfoValue);
+
+		makeUTF8(buffer, *pcbInfoValue, rgbInfoValue, cbInfoValueMax);
+		
+		return rc;
+	}
+
+	return SQLGetInfoW(hdbc, fInfoType, rgbInfoValue, cbInfoValueMax, pcbInfoValue);
+}
+
+
+SQLRETURN SQLGetTypeInfo(SQLHSTMT StatementHandle, SQLSMALLINT DataType)
+{
+	return SQLGetTypeInfoW(StatementHandle, DataType);
+}
+
+
+SQLRETURN SQLSetConnectOption(SQLHDBC hdbc,
+	SQLUSMALLINT fOption,
+	SQLULEN      vParam)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLSpecialColumns(SQLHSTMT hstmt,
+	SQLUSMALLINT fColType,
+	SQLCHAR*     szCatalogName,
+	SQLSMALLINT  cbCatalogName,
+	SQLCHAR*     szSchemaName,
+	SQLSMALLINT  cbSchemaName,
+	SQLCHAR*     szTableName,
+	SQLSMALLINT  cbTableName,
+	SQLUSMALLINT fScope,
+	SQLUSMALLINT fNullable)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLStatistics(SQLHSTMT hstmt,
+	SQLCHAR*     szCatalogName,
+	SQLSMALLINT  cbCatalogName,
+	SQLCHAR*     szSchemaName,
+	SQLSMALLINT  cbSchemaName,
+	SQLCHAR*     szTableName,
+	SQLSMALLINT  cbTableName,
+	SQLUSMALLINT fUnique,
+	SQLUSMALLINT fAccuracy)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLTables(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName,
+	SQLCHAR*    szTableType,
+	SQLSMALLINT cbTableType)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLDataSources(SQLHENV henv,
+	SQLUSMALLINT fDirection,
+	SQLCHAR*     szDSN,
+	SQLSMALLINT  cbDSNMax,
+	SQLSMALLINT* pcbDSN,
+	SQLCHAR*     szDesc,
+	SQLSMALLINT  cbDescMax,
+	SQLSMALLINT* pcbDesc)
+{
+	Buffer<SQLWCHAR> bufDSN(cbDSNMax);
+	Buffer<SQLWCHAR> bufDesc(cbDescMax);
+
+	SQLRETURN rc = SQLDataSourcesW(henv,
+		fDirection,
+		bufDSN.begin(),
+		(SQLSMALLINT) bufDSN.size(),
+		pcbDSN,
+		bufDesc.begin(),
+		(SQLSMALLINT) bufDesc.size(),
+		pcbDesc);
+
+	makeUTF8(bufDSN, *pcbDSN * sizeof(SQLWCHAR), szDSN, cbDSNMax);
+	makeUTF8(bufDesc, *pcbDesc * sizeof(SQLWCHAR), szDesc, cbDescMax);
+
+	return rc;
+}
+
+
+SQLRETURN SQLDriverConnect(SQLHDBC hdbc,
+	SQLHWND      hwnd,
+	SQLCHAR*     szConnStrIn,
+	SQLSMALLINT  cbConnStrIn,
+	SQLCHAR*     szConnStrOut,
+	SQLSMALLINT  cbConnStrOutMax,
+	SQLSMALLINT* pcbConnStrOut,
+	SQLUSMALLINT fDriverCompletion)
+{
+	SQLSMALLINT len = cbConnStrIn;
+	if (SQL_NTS == len) 
+		len = (SQLSMALLINT) std::strlen((const char*) szConnStrIn) + 1;
+
+	std::string connStrIn;
+	makeUTF16(szConnStrIn, len, connStrIn);
+	
+	Buffer<SQLWCHAR> out(cbConnStrOutMax);
+	SQLRETURN rc = SQLDriverConnectW(hdbc,
+		hwnd,
+		(SQLWCHAR*) connStrIn.c_str(),
+		(SQLSMALLINT) connStrIn.size(),
+		out.begin(),
+		cbConnStrOutMax,
+		pcbConnStrOut,
+		fDriverCompletion);
+
+	makeUTF8(out, *pcbConnStrOut * sizeof(SQLWCHAR), pcbConnStrOut, cbConnStrOutMax);
+
+	return rc;
+}
+
+
+SQLRETURN SQLBrowseConnect(SQLHDBC hdbc,
+	SQLCHAR*     szConnStrIn,
+	SQLSMALLINT  cbConnStrIn,
+	SQLCHAR*     szConnStrOut,
+	SQLSMALLINT  cbConnStrOutMax,
+	SQLSMALLINT* pcbConnStrOut)
+{
+	std::string str;
+	makeUTF16(szConnStrIn, cbConnStrIn, str);
+
+	Buffer<SQLWCHAR> bufConnStrOut(cbConnStrOutMax);
+
+	SQLRETURN rc = SQLBrowseConnectW(hdbc,
+		(SQLWCHAR*) str.c_str(),
+		(SQLSMALLINT) str.size(),
+		bufConnStrOut.begin(),
+		(SQLSMALLINT) bufConnStrOut.size(),
+		pcbConnStrOut);
+
+	makeUTF8(bufConnStrOut, *pcbConnStrOut * sizeof(SQLWCHAR), szConnStrOut, cbConnStrOutMax);
+
+	return rc;
+}
+
+
+SQLRETURN SQLColumnPrivileges(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName,
+	SQLCHAR*    szColumnName,
+	SQLSMALLINT cbColumnName)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLForeignKeys(SQLHSTMT hstmt,
+	SQLCHAR*    szPkCatalogName,
+	SQLSMALLINT cbPkCatalogName,
+	SQLCHAR*    szPkSchemaName,
+	SQLSMALLINT cbPkSchemaName,
+	SQLCHAR*    szPkTableName,
+	SQLSMALLINT cbPkTableName,
+	SQLCHAR*    szFkCatalogName,
+	SQLSMALLINT cbFkCatalogName,
+	SQLCHAR*    szFkSchemaName,
+	SQLSMALLINT cbFkSchemaName,
+	SQLCHAR*    szFkTableName,
+	SQLSMALLINT cbFkTableName)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLNativeSql(SQLHDBC hdbc,
+	SQLCHAR*    szSqlStrIn,
+	SQLINTEGER  cbSqlStrIn,
+	SQLCHAR*    szSqlStr,
+	SQLINTEGER  cbSqlStrMax,
+	SQLINTEGER* pcbSqlStr)
+{
+	std::string str;
+	makeUTF16(szSqlStrIn, cbSqlStrIn, str);
+
+	Buffer<SQLWCHAR> bufSQLOut(cbSqlStrMax);
+
+	SQLRETURN rc = SQLNativeSqlW(hdbc,
+		(SQLWCHAR*) str.c_str(),
+		(SQLINTEGER) str.size(),
+		bufSQLOut.begin(),
+		(SQLINTEGER) bufSQLOut.size(),
+		pcbSqlStr);
+
+	makeUTF8(bufSQLOut, *pcbSqlStr * sizeof(SQLWCHAR), szSqlStr, cbSqlStrMax);
+
+	return rc;
+}
+
+
+SQLRETURN SQLPrimaryKeys(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLProcedureColumns(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szProcName,
+	SQLSMALLINT cbProcName,
+	SQLCHAR*    szColumnName,
+	SQLSMALLINT cbColumnName)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLProcedures(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szProcName,
+	SQLSMALLINT cbProcName)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLTablePrivileges(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLDrivers(SQLHENV henv,
+	SQLUSMALLINT fDirection,
+	SQLCHAR*     szDriverDesc,
+	SQLSMALLINT  cbDriverDescMax,
+	SQLSMALLINT* pcbDriverDesc,
+	SQLCHAR*     szDriverAttributes,
+	SQLSMALLINT  cbDrvrAttrMax,
+	SQLSMALLINT* pcbDrvrAttr)
+{
+	Buffer<SQLWCHAR> bufDriverDesc(cbDriverDescMax);
+	Buffer<SQLWCHAR> bufDriverAttr(cbDrvrAttrMax);
+
+	SQLRETURN rc = SQLDriversW(henv,
+		fDirection,
+		bufDriverDesc.begin(),
+		(SQLSMALLINT) bufDriverDesc.size(),
+		pcbDriverDesc,
+		bufDriverAttr.begin(),
+		(SQLSMALLINT) bufDriverAttr.size(),
+		pcbDrvrAttr);
+
+	makeUTF8(bufDriverDesc, *pcbDriverDesc * sizeof(SQLWCHAR), szDriverDesc, cbDriverDescMax);
+	makeUTF8(bufDriverAttr, *pcbDrvrAttr * sizeof(SQLWCHAR), szDriverAttributes, cbDrvrAttrMax);
+
+	return rc;
+}
+
+
+} } } // namespace Poco::Data::ODBC

base/poco/Data/ODBC/src/Unicode_WIN32.cpp

@@ -0,0 +1,761 @@
+//
+// Unicode.cpp
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Unicode
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/ODBC/ODBC.h"
+#include "Poco/Data/ODBC/Utility.h"
+#include "Poco/Data/ODBC/Unicode_WIN32.h"
+#include "Poco/Buffer.h"
+#include "Poco/Exception.h"
+
+
+using Poco::Buffer;
+using Poco::InvalidArgumentException;
+using Poco::NotImplementedException;
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+SQLRETURN SQLColAttribute(SQLHSTMT hstmt,
+	SQLUSMALLINT   iCol,
+	SQLUSMALLINT   iField,
+	SQLPOINTER	   pCharAttr,
+	SQLSMALLINT	   cbCharAttrMax,
+	SQLSMALLINT*   pcbCharAttr,
+	NumAttrPtrType pNumAttr)
+{
+	if (isString(pCharAttr, cbCharAttrMax))
+	{
+		Buffer<wchar_t> buffer(stringLength(pCharAttr, cbCharAttrMax));
+
+		SQLRETURN rc = SQLColAttributeW(hstmt,
+			iCol,
+			iField,
+			buffer.begin(),
+			(SQLSMALLINT) buffer.sizeBytes(),
+			pcbCharAttr,
+			pNumAttr);
+
+		makeUTF8(buffer, *pcbCharAttr, pCharAttr, cbCharAttrMax);
+		return rc;
+	}
+
+	return SQLColAttributeW(hstmt,
+		iCol,
+		iField,
+		pCharAttr,
+		cbCharAttrMax,
+		pcbCharAttr,
+		pNumAttr);
+}
+
+
+SQLRETURN SQLColAttributes(SQLHSTMT hstmt,
+	SQLUSMALLINT icol,
+	SQLUSMALLINT fDescType,
+	SQLPOINTER   rgbDesc,
+	SQLSMALLINT  cbDescMax,
+	SQLSMALLINT* pcbDesc,
+	SQLLEN*      pfDesc)
+{
+	return SQLColAttribute(hstmt,
+		icol,
+		fDescType,
+		rgbDesc,
+		cbDescMax,
+		pcbDesc,
+		pfDesc);
+}
+
+
+SQLRETURN SQLConnect(SQLHDBC hdbc,
+	SQLCHAR*    szDSN,
+	SQLSMALLINT cbDSN,
+	SQLCHAR*    szUID,
+	SQLSMALLINT cbUID,
+	SQLCHAR*    szAuthStr,
+	SQLSMALLINT cbAuthStr)
+{
+	std::wstring sqlDSN;
+	makeUTF16(szDSN, cbDSN, sqlDSN);
+
+	std::wstring sqlUID;
+	makeUTF16(szUID, cbUID, sqlUID);
+
+	std::wstring sqlPWD;
+	makeUTF16(szAuthStr, cbAuthStr, sqlPWD);
+	
+	return SQLConnectW(hdbc,
+		(SQLWCHAR*) sqlDSN.c_str(),
+		(SQLSMALLINT) sqlDSN.size(),
+		(SQLWCHAR*) sqlUID.c_str(),
+		(SQLSMALLINT) sqlUID.size(),
+		(SQLWCHAR*) sqlPWD.c_str(),
+		(SQLSMALLINT) sqlPWD.size());
+}
+
+
+SQLRETURN SQLDescribeCol(SQLHSTMT hstmt,
+	SQLUSMALLINT icol,
+	SQLCHAR*     szColName,
+	SQLSMALLINT  cbColNameMax,
+	SQLSMALLINT* pcbColName,
+	SQLSMALLINT* pfSqlType,
+	SQLULEN*     pcbColDef,
+	SQLSMALLINT* pibScale,
+	SQLSMALLINT* pfNullable)
+{
+	Buffer<wchar_t> buffer(cbColNameMax);
+	SQLRETURN rc = SQLDescribeColW(hstmt,
+		icol,
+		(SQLWCHAR*) buffer.begin(),
+		(SQLSMALLINT) buffer.size(),
+		pcbColName,
+		pfSqlType,
+		pcbColDef,
+		pibScale,
+		pfNullable);
+
+	makeUTF8(buffer, *pcbColName * sizeof(wchar_t), szColName, cbColNameMax);
+	return rc;
+}
+
+
+SQLRETURN SQLError(SQLHENV henv,
+	SQLHDBC      hdbc,
+	SQLHSTMT     hstmt,
+	SQLCHAR*     szSqlState,
+	SQLINTEGER*  pfNativeError,
+	SQLCHAR*     szErrorMsg,
+	SQLSMALLINT  cbErrorMsgMax,
+	SQLSMALLINT* pcbErrorMsg)
+{
+	throw NotImplementedException("SQLError is obsolete. "
+		"Use SQLGetDiagRec instead.");
+}
+
+
+SQLRETURN SQLExecDirect(SQLHSTMT hstmt,
+	SQLCHAR*   szSqlStr,
+	SQLINTEGER cbSqlStr)
+{
+	std::wstring sqlStr;
+	makeUTF16(szSqlStr, cbSqlStr, sqlStr);
+
+	return SQLExecDirectW(hstmt, 
+		(SQLWCHAR*) sqlStr.c_str(), 
+		(SQLINTEGER) sqlStr.size());
+}
+
+
+SQLRETURN SQLGetConnectAttr(SQLHDBC hdbc,
+	SQLINTEGER  fAttribute,
+	SQLPOINTER  rgbValue,
+	SQLINTEGER  cbValueMax,
+	SQLINTEGER* pcbValue)
+{
+	if (isString(rgbValue, cbValueMax))
+	{
+		Buffer<wchar_t> buffer(stringLength(rgbValue, cbValueMax));
+
+		SQLRETURN rc = SQLGetConnectAttrW(hdbc,
+				fAttribute,
+				buffer.begin(),
+				(SQLINTEGER) buffer.sizeBytes(),
+				pcbValue);
+
+		makeUTF8(buffer, *pcbValue, rgbValue, cbValueMax);
+		return rc;
+	}
+	
+
+	return SQLGetConnectAttrW(hdbc,
+		fAttribute,
+		rgbValue,
+		cbValueMax,
+		pcbValue);
+}
+
+
+SQLRETURN SQLGetCursorName(SQLHSTMT hstmt,
+	SQLCHAR*     szCursor,
+	SQLSMALLINT  cbCursorMax,
+	SQLSMALLINT* pcbCursor)
+{
+	throw NotImplementedException("Not implemented");
+}
+
+
+SQLRETURN SQLSetDescField(SQLHDESC hdesc,
+	SQLSMALLINT iRecord, 
+	SQLSMALLINT iField,
+	SQLPOINTER  rgbValue, 
+	SQLINTEGER  cbValueMax)
+{
+	if (isString(rgbValue, cbValueMax))
+	{
+		std::wstring str;
+		makeUTF16((SQLCHAR*) rgbValue, cbValueMax, str);
+
+		SQLRETURN rc = SQLSetDescFieldW(hdesc,
+			iRecord, 
+			iField,
+			(SQLPOINTER) str.c_str(), 
+			(SQLINTEGER) str.size() * sizeof(std::wstring::value_type));
+
+		return rc;
+	}
+
+	return SQLSetDescFieldW(hdesc,
+		iRecord, 
+		iField,
+		rgbValue, 
+		cbValueMax);
+}
+
+
+SQLRETURN SQLGetDescField(SQLHDESC hdesc,
+	SQLSMALLINT iRecord,
+	SQLSMALLINT iField,
+	SQLPOINTER  rgbValue,
+	SQLINTEGER	cbValueMax,
+	SQLINTEGER* pcbValue)
+{
+	if (isString(rgbValue, cbValueMax))
+	{
+		Buffer<wchar_t> buffer(stringLength(rgbValue, cbValueMax));
+
+		SQLRETURN rc = SQLGetDescFieldW(hdesc,
+			iRecord,
+			iField,
+			buffer.begin(),
+			(SQLINTEGER) buffer.sizeBytes(),
+			pcbValue);
+
+		makeUTF8(buffer, *pcbValue, rgbValue, cbValueMax);
+		return rc;
+	}
+
+	return SQLGetDescFieldW(hdesc,
+		iRecord,
+		iField,
+		rgbValue,
+		cbValueMax,
+		pcbValue);
+}
+
+
+SQLRETURN SQLGetDescRec(SQLHDESC hdesc,
+	SQLSMALLINT  iRecord,
+	SQLCHAR*     szName,
+	SQLSMALLINT  cbNameMax,
+	SQLSMALLINT* pcbName,
+	SQLSMALLINT* pfType,
+	SQLSMALLINT* pfSubType,
+	SQLLEN*      pLength,
+	SQLSMALLINT* pPrecision, 
+	SQLSMALLINT* pScale,
+	SQLSMALLINT* pNullable)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLGetDiagField(SQLSMALLINT fHandleType,
+	SQLHANDLE    handle,
+	SQLSMALLINT  iRecord,
+	SQLSMALLINT  fDiagField,
+	SQLPOINTER   rgbDiagInfo,
+	SQLSMALLINT  cbDiagInfoMax,
+	SQLSMALLINT* pcbDiagInfo)
+{
+	if (isString(rgbDiagInfo, cbDiagInfoMax))
+	{
+		Buffer<wchar_t> buffer(stringLength(rgbDiagInfo, cbDiagInfoMax));
+
+		SQLRETURN rc = SQLGetDiagFieldW(fHandleType,
+			handle,
+			iRecord,
+			fDiagField,
+			buffer.begin(),
+			(SQLSMALLINT) buffer.sizeBytes(),
+			pcbDiagInfo);
+
+		makeUTF8(buffer, *pcbDiagInfo, rgbDiagInfo, cbDiagInfoMax);
+		return rc;
+	}
+
+	return SQLGetDiagFieldW(fHandleType,
+		handle,
+		iRecord,
+		fDiagField,
+		rgbDiagInfo,
+		cbDiagInfoMax,
+		pcbDiagInfo);
+}
+
+
+SQLRETURN SQLGetDiagRec(SQLSMALLINT fHandleType,
+	SQLHANDLE    handle,
+	SQLSMALLINT  iRecord,
+	SQLCHAR*     szSqlState,
+	SQLINTEGER*  pfNativeError,
+	SQLCHAR*     szErrorMsg,
+	SQLSMALLINT  cbErrorMsgMax,
+	SQLSMALLINT* pcbErrorMsg)
+{
+	const SQLINTEGER stateLen = SQL_SQLSTATE_SIZE + 1;
+	Buffer<wchar_t> bufState(stateLen);
+	Buffer<wchar_t> bufErr(cbErrorMsgMax);
+
+	SQLRETURN rc = SQLGetDiagRecW(fHandleType,
+		handle,
+		iRecord,
+		bufState.begin(),
+		pfNativeError,
+		bufErr.begin(),
+		(SQLSMALLINT) bufErr.size(),
+		pcbErrorMsg);
+
+	makeUTF8(bufState, stateLen * sizeof(wchar_t), szSqlState, stateLen);
+	makeUTF8(bufErr, *pcbErrorMsg * sizeof(wchar_t), szErrorMsg, cbErrorMsgMax);
+
+	return rc;
+}
+
+
+SQLRETURN SQLPrepare(SQLHSTMT hstmt,
+	SQLCHAR*   szSqlStr,
+	SQLINTEGER cbSqlStr)
+{
+	std::wstring sqlStr;
+	makeUTF16(szSqlStr, cbSqlStr, sqlStr);
+
+	return SQLPrepareW(hstmt, 
+		(SQLWCHAR*) sqlStr.c_str(), 
+		(SQLINTEGER) sqlStr.size());
+}
+
+
+SQLRETURN SQLSetConnectAttr(SQLHDBC hdbc,
+	SQLINTEGER fAttribute,
+	SQLPOINTER rgbValue,
+	SQLINTEGER cbValue)
+{
+	if (isString(rgbValue, cbValue))
+	{
+		std::wstring str;
+		makeUTF16((SQLCHAR*) rgbValue, cbValue, str);
+
+		return SQLSetConnectAttrW(hdbc,
+			fAttribute,
+			(SQLWCHAR*) str.c_str(), 
+			(SQLINTEGER) str.size() * sizeof(std::wstring::value_type));
+	}
+
+	return SQLSetConnectAttrW(hdbc,
+		fAttribute,
+		rgbValue, 
+		cbValue);
+}
+
+
+SQLRETURN SQLSetCursorName(SQLHSTMT hstmt,
+	SQLCHAR*    szCursor,
+	SQLSMALLINT cbCursor)
+{
+	throw NotImplementedException("Not implemented");
+}
+
+
+SQLRETURN SQLSetStmtAttr(SQLHSTMT hstmt,
+	SQLINTEGER fAttribute,
+	SQLPOINTER rgbValue,
+	SQLINTEGER cbValueMax)
+{
+	if (isString(rgbValue, cbValueMax))
+	{
+		std::wstring str;
+		makeUTF16((SQLCHAR*) rgbValue, cbValueMax, str);
+
+		return SQLSetStmtAttrW(hstmt,
+			fAttribute,
+			(SQLPOINTER) str.c_str(),
+			(SQLINTEGER) str.size());
+	}
+
+	return SQLSetStmtAttrW(hstmt,
+		fAttribute,
+		rgbValue,
+		cbValueMax);
+}
+
+
+SQLRETURN SQLGetStmtAttr(SQLHSTMT hstmt,
+	SQLINTEGER  fAttribute,
+	SQLPOINTER  rgbValue,
+	SQLINTEGER  cbValueMax,
+	SQLINTEGER* pcbValue)
+{
+	if (isString(rgbValue, cbValueMax))
+	{
+		Buffer<wchar_t> buffer(stringLength(rgbValue, cbValueMax));
+
+		return SQLGetStmtAttrW(hstmt,
+			fAttribute,
+			(SQLPOINTER) buffer.begin(),
+			(SQLINTEGER) buffer.sizeBytes(),
+			pcbValue);
+	}
+
+	return SQLGetStmtAttrW(hstmt,
+			fAttribute,
+			rgbValue,
+			cbValueMax,
+			pcbValue);
+}
+
+
+SQLRETURN SQLColumns(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName,
+	SQLCHAR*    szColumnName,
+	SQLSMALLINT cbColumnName)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLGetConnectOption(SQLHDBC hdbc,
+	SQLUSMALLINT fOption,
+	SQLPOINTER   pvParam)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLGetInfo(SQLHDBC hdbc,
+	SQLUSMALLINT fInfoType,
+	SQLPOINTER   rgbInfoValue,
+	SQLSMALLINT  cbInfoValueMax,
+	SQLSMALLINT* pcbInfoValue)
+{
+	if (cbInfoValueMax)
+	{
+		Buffer<wchar_t> buffer(cbInfoValueMax);
+
+		SQLRETURN rc = SQLGetInfoW(hdbc,
+			fInfoType,
+			(SQLPOINTER) buffer.begin(),
+			(SQLSMALLINT) buffer.sizeBytes(),
+			pcbInfoValue);
+
+		makeUTF8(buffer, *pcbInfoValue, rgbInfoValue, cbInfoValueMax);
+
+		return rc;
+	}
+
+	return SQLGetInfoW(hdbc,
+		fInfoType,
+		rgbInfoValue,
+		cbInfoValueMax,
+		pcbInfoValue);
+}
+
+
+SQLRETURN SQLGetTypeInfo(SQLHSTMT StatementHandle, SQLSMALLINT DataType)
+{
+	return SQLGetTypeInfoW(StatementHandle, DataType);
+}
+
+
+SQLRETURN SQLSetConnectOption(SQLHDBC hdbc,
+	SQLUSMALLINT fOption,
+	SQLULEN      vParam)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLSpecialColumns(SQLHSTMT hstmt,
+	SQLUSMALLINT fColType,
+	SQLCHAR*     szCatalogName,
+	SQLSMALLINT  cbCatalogName,
+	SQLCHAR*     szSchemaName,
+	SQLSMALLINT  cbSchemaName,
+	SQLCHAR*     szTableName,
+	SQLSMALLINT  cbTableName,
+	SQLUSMALLINT fScope,
+	SQLUSMALLINT fNullable)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLStatistics(SQLHSTMT hstmt,
+	SQLCHAR*     szCatalogName,
+	SQLSMALLINT  cbCatalogName,
+	SQLCHAR*     szSchemaName,
+	SQLSMALLINT  cbSchemaName,
+	SQLCHAR*     szTableName,
+	SQLSMALLINT  cbTableName,
+	SQLUSMALLINT fUnique,
+	SQLUSMALLINT fAccuracy)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLTables(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName,
+	SQLCHAR*    szTableType,
+	SQLSMALLINT cbTableType)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLDataSources(SQLHENV henv,
+	SQLUSMALLINT fDirection,
+	SQLCHAR*     szDSN,
+	SQLSMALLINT  cbDSNMax,
+	SQLSMALLINT* pcbDSN,
+	SQLCHAR*     szDesc,
+	SQLSMALLINT  cbDescMax,
+	SQLSMALLINT* pcbDesc)
+{
+	Buffer<wchar_t> bufDSN(cbDSNMax);
+	Buffer<wchar_t> bufDesc(cbDescMax);
+
+	SQLRETURN rc = SQLDataSourcesW(henv,
+		fDirection,
+		bufDSN.begin(),
+		(SQLSMALLINT) bufDSN.size(),
+		pcbDSN,
+		bufDesc.begin(),
+		(SQLSMALLINT) bufDesc.size(),
+		pcbDesc);
+
+	makeUTF8(bufDSN, *pcbDSN * sizeof(wchar_t), szDSN, cbDSNMax);
+	makeUTF8(bufDesc, *pcbDesc * sizeof(wchar_t), szDesc, cbDescMax);
+
+	return rc;
+}
+
+
+SQLRETURN SQLDriverConnect(SQLHDBC hdbc,
+	SQLHWND      hwnd,
+	SQLCHAR*     szConnStrIn,
+	SQLSMALLINT  cbConnStrIn,
+	SQLCHAR*     szConnStrOut,
+	SQLSMALLINT  cbConnStrOutMax,
+	SQLSMALLINT* pcbConnStrOut,
+	SQLUSMALLINT fDriverCompletion)
+{
+	std::wstring connStrIn;
+	int len = cbConnStrIn;
+	if (SQL_NTS == len) 
+		len = (int) std::strlen((const char*) szConnStrIn);
+
+	Poco::UnicodeConverter::toUTF16((const char *) szConnStrIn, len, connStrIn);
+
+	Buffer<wchar_t> bufOut(cbConnStrOutMax);
+	SQLRETURN rc = SQLDriverConnectW(hdbc,
+		hwnd,
+		(SQLWCHAR*) connStrIn.c_str(),
+		(SQLSMALLINT) connStrIn.size(),
+		bufOut.begin(),
+		(SQLSMALLINT) bufOut.size(),
+		pcbConnStrOut,
+		fDriverCompletion);
+
+	if (!Utility::isError(rc))
+		makeUTF8(bufOut, *pcbConnStrOut * sizeof(wchar_t), szConnStrOut, cbConnStrOutMax);
+
+	return rc;
+}
+
+
+SQLRETURN SQLBrowseConnect(SQLHDBC hdbc,
+	SQLCHAR*     szConnStrIn,
+	SQLSMALLINT  cbConnStrIn,
+	SQLCHAR*     szConnStrOut,
+	SQLSMALLINT  cbConnStrOutMax,
+	SQLSMALLINT* pcbConnStrOut)
+{
+	std::wstring str;
+	makeUTF16(szConnStrIn, cbConnStrIn, str);
+
+	Buffer<wchar_t> bufConnStrOut(cbConnStrOutMax);
+
+	SQLRETURN rc = SQLBrowseConnectW(hdbc,
+		(SQLWCHAR*) str.c_str(),
+		(SQLSMALLINT) str.size(),
+		bufConnStrOut.begin(),
+		(SQLSMALLINT) bufConnStrOut.size(),
+		pcbConnStrOut);
+
+	makeUTF8(bufConnStrOut, *pcbConnStrOut * sizeof(wchar_t), szConnStrOut, cbConnStrOutMax);
+
+	return rc;
+}
+
+
+SQLRETURN SQLColumnPrivileges(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName,
+	SQLCHAR*    szColumnName,
+	SQLSMALLINT cbColumnName)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLForeignKeys(SQLHSTMT hstmt,
+	SQLCHAR*    szPkCatalogName,
+	SQLSMALLINT cbPkCatalogName,
+	SQLCHAR*    szPkSchemaName,
+	SQLSMALLINT cbPkSchemaName,
+	SQLCHAR*    szPkTableName,
+	SQLSMALLINT cbPkTableName,
+	SQLCHAR*    szFkCatalogName,
+	SQLSMALLINT cbFkCatalogName,
+	SQLCHAR*    szFkSchemaName,
+	SQLSMALLINT cbFkSchemaName,
+	SQLCHAR*    szFkTableName,
+	SQLSMALLINT cbFkTableName)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLNativeSql(SQLHDBC hdbc,
+	SQLCHAR*    szSqlStrIn,
+	SQLINTEGER  cbSqlStrIn,
+	SQLCHAR*    szSqlStr,
+	SQLINTEGER  cbSqlStrMax,
+	SQLINTEGER* pcbSqlStr)
+{
+	std::wstring str;
+	makeUTF16(szSqlStrIn, cbSqlStrIn, str);
+
+	Buffer<wchar_t> bufSQLOut(cbSqlStrMax);
+
+	SQLRETURN rc = SQLNativeSqlW(hdbc,
+		(SQLWCHAR*) str.c_str(),
+		(SQLINTEGER) str.size(),
+		bufSQLOut.begin(),
+		(SQLINTEGER) bufSQLOut.size(),
+		pcbSqlStr);
+
+	makeUTF8(bufSQLOut, *pcbSqlStr * sizeof(wchar_t), szSqlStr, cbSqlStrMax);
+
+	return rc;
+}
+
+
+SQLRETURN SQLPrimaryKeys(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLProcedureColumns(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szProcName,
+	SQLSMALLINT cbProcName,
+	SQLCHAR*    szColumnName,
+	SQLSMALLINT cbColumnName)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLProcedures(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szProcName,
+	SQLSMALLINT cbProcName)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLTablePrivileges(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLDrivers(SQLHENV henv,
+	SQLUSMALLINT fDirection,
+	SQLCHAR*     szDriverDesc,
+	SQLSMALLINT  cbDriverDescMax,
+	SQLSMALLINT* pcbDriverDesc,
+	SQLCHAR*     szDriverAttributes,
+	SQLSMALLINT  cbDrvrAttrMax,
+	SQLSMALLINT* pcbDrvrAttr)
+{
+	Buffer<wchar_t> bufDriverDesc(cbDriverDescMax);
+	Buffer<wchar_t> bufDriverAttr(cbDrvrAttrMax);
+
+	SQLRETURN rc = SQLDriversW(henv,
+		fDirection,
+		bufDriverDesc.begin(),
+		(SQLSMALLINT) bufDriverDesc.size(),
+		pcbDriverDesc,
+		bufDriverAttr.begin(),
+		(SQLSMALLINT) bufDriverAttr.size(),
+		pcbDrvrAttr);
+
+	makeUTF8(bufDriverDesc, *pcbDriverDesc * sizeof(wchar_t), szDriverDesc, cbDriverDescMax);
+	makeUTF8(bufDriverAttr, *pcbDrvrAttr * sizeof(wchar_t), szDriverAttributes, cbDrvrAttrMax);
+
+	return rc;
+}
+
+
+} } } // namespace Poco::Data::ODBC

base/poco/Data/ODBC/src/Utility.cpp

@@ -0,0 +1,159 @@
+//
+// Utility.cpp
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Utility
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/ODBC/Utility.h"
+#include "Poco/Data/ODBC/Handle.h"
+#include "Poco/Data/ODBC/ODBCException.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/DateTime.h"
+#include <cmath>
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+const TypeInfo Utility::_dataTypes;
+
+
+Utility::DriverMap& Utility::drivers(Utility::DriverMap& driverMap)
+{
+	static const EnvironmentHandle henv;
+	const int length = sizeof(SQLCHAR) * 512;
+
+	SQLCHAR desc[length];
+	std::memset(desc, 0, length);
+	SQLSMALLINT len1 = length;
+	SQLCHAR attr[length];
+	std::memset(attr, 0, length);
+	SQLSMALLINT len2 = length;
+	RETCODE rc = 0;
+
+	if (!Utility::isError(rc = SQLDrivers(henv, 
+		SQL_FETCH_FIRST,
+		desc,
+		length,
+		&len1,
+		attr,
+		len2,
+		&len2)))
+	{
+		do
+		{
+			driverMap.insert(DSNMap::value_type(std::string((char *) desc), 
+				std::string((char *) attr)));
+			std::memset(desc, 0, length);
+			std::memset(attr, 0, length);
+			len2 = length;
+		}while (!Utility::isError(rc = SQLDrivers(henv, 
+			SQL_FETCH_NEXT,
+			desc,
+			length,
+			&len1,
+			attr,
+			len2,
+			&len2)));
+	}
+
+	if (SQL_NO_DATA != rc) 
+		throw EnvironmentException(henv);
+
+	return driverMap;
+}
+
+
+Utility::DSNMap& Utility::dataSources(Utility::DSNMap& dsnMap)
+{
+	static const EnvironmentHandle henv;
+	const int length = sizeof(SQLCHAR) * 512;
+	const int dsnLength = sizeof(SQLCHAR) * (SQL_MAX_DSN_LENGTH + 1);
+
+	SQLCHAR dsn[dsnLength];
+	std::memset(dsn, 0, dsnLength);
+	SQLSMALLINT len1 = sizeof(SQLCHAR) * SQL_MAX_DSN_LENGTH;
+	SQLCHAR desc[length];
+	std::memset(desc, 0, length);
+	SQLSMALLINT len2 = length;
+	RETCODE rc = 0;
+
+	while (!Utility::isError(rc = Poco::Data::ODBC::SQLDataSources(henv, 
+		SQL_FETCH_NEXT,
+		dsn,
+		SQL_MAX_DSN_LENGTH,
+		&len1,
+		desc,
+		len2,
+		&len2)))
+	{
+		dsnMap.insert(DSNMap::value_type(std::string((char *) dsn), std::string((char *) desc)));
+		std::memset(dsn, 0, dsnLength);
+		std::memset(desc, 0, length);
+		len2 = length;
+	}
+
+	if (SQL_NO_DATA != rc) 
+		throw EnvironmentException(henv);
+
+	return dsnMap;
+}
+
+
+void Utility::dateTimeSync(Poco::DateTime& dt, const SQL_TIMESTAMP_STRUCT& ts)
+{
+	double msec = ts.fraction/1000000;
+	double usec = 1000 * (msec - std::floor(msec));
+
+	dt.assign(ts.year,
+		ts.month,
+		ts.day,
+		ts.hour,
+		ts.minute,
+		ts.second,
+		(int) std::floor(msec),
+		(int) std::floor(usec));
+}
+
+
+void Utility::dateSync(SQL_DATE_STRUCT& ds, const Date& d)
+{
+	ds.year = d.year();
+	ds.month = d.month();
+	ds.day = d.day();
+}
+
+
+void Utility::timeSync(SQL_TIME_STRUCT& ts, const Time& t)
+{
+	ts.hour = t.hour();
+	ts.minute = t.minute();
+	ts.second = t.second();
+}
+
+
+void Utility::dateTimeSync(SQL_TIMESTAMP_STRUCT& ts, const Poco::DateTime& dt)
+{
+	ts.year = dt.year();
+	ts.month = dt.month();
+	ts.day = dt.day();
+	ts.hour = dt.hour();
+	ts.minute = dt.minute();
+	ts.second = dt.second();
+	// Fraction support is limited to milliseconds due to MS SQL Server limitation
+	// see http://support.microsoft.com/kb/263872
+	ts.fraction = (dt.millisecond() * 1000000);// + (dt.microsecond() * 1000);
+}
+
+
+} } } // namespace Poco::Data::ODBC

base/poco/Data/include/Poco/Data/AbstractBinder.h

@@ -0,0 +1,373 @@
+//
+// AbstractBinder.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  AbstractBinder
+//
+// Definition of the AbstractBinder class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_AbstractBinder_INCLUDED
+#define Data_AbstractBinder_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/Date.h"
+#include "Poco/Data/Time.h"
+#include "Poco/Data/LOB.h"
+#include "Poco/DateTime.h"
+#include "Poco/Nullable.h"
+#include "Poco/Any.h"
+#include "Poco/Dynamic/Var.h"
+#include "Poco/UTFString.h"
+#include <vector>
+#include <deque>
+#include <list>
+#include <cstddef>
+
+
+namespace Poco {
+namespace Data {
+
+
+typedef NullType NullData;
+
+
+namespace Keywords {
+
+
+static const NullData null = NULL_GENERIC;
+
+
+} // namespace Keywords
+
+
+class Data_API AbstractBinder
+	/// Interface for Binding data types to placeholders.
+{
+public:
+	typedef SharedPtr<AbstractBinder> Ptr;
+
+	enum Direction
+		/// Binding direction for a parameter.
+	{
+		PD_IN,
+		PD_OUT,
+		PD_IN_OUT
+	};
+
+	AbstractBinder();
+		/// Creates the AbstractBinder.
+
+	virtual ~AbstractBinder();
+		/// Destroys the AbstractBinder.
+
+	virtual void bind(std::size_t pos, const Poco::Int8& val, Direction dir = PD_IN) = 0;
+		/// Binds an Int8.
+
+	virtual void bind(std::size_t pos, const std::vector<Poco::Int8>& val, Direction dir = PD_IN);
+		/// Binds an Int8 vector.
+
+	virtual void bind(std::size_t pos, const std::deque<Poco::Int8>& val, Direction dir = PD_IN);
+		/// Binds an Int8 deque.
+
+	virtual void bind(std::size_t pos, const std::list<Poco::Int8>& val, Direction dir = PD_IN);
+		/// Binds an Int8 list.
+
+	virtual void bind(std::size_t pos, const Poco::UInt8& val, Direction dir = PD_IN) = 0;
+		/// Binds an UInt8.
+
+	virtual void bind(std::size_t pos, const std::vector<Poco::UInt8>& val, Direction dir = PD_IN);
+		/// Binds an UInt8 vector.
+
+	virtual void bind(std::size_t pos, const std::deque<Poco::UInt8>& val, Direction dir = PD_IN);
+		/// Binds an UInt8 deque.
+
+	virtual void bind(std::size_t pos, const std::list<Poco::UInt8>& val, Direction dir = PD_IN);
+		/// Binds an UInt8 list.
+
+	virtual void bind(std::size_t pos, const Poco::Int16& val, Direction dir = PD_IN) = 0;
+		/// Binds an Int16.
+
+	virtual void bind(std::size_t pos, const std::vector<Poco::Int16>& val, Direction dir = PD_IN);
+		/// Binds an Int16 vector.
+
+	virtual void bind(std::size_t pos, const std::deque<Poco::Int16>& val, Direction dir = PD_IN);
+		/// Binds an Int16 deque.
+
+	virtual void bind(std::size_t pos, const std::list<Poco::Int16>& val, Direction dir = PD_IN);
+		/// Binds an Int16 list.
+
+	virtual void bind(std::size_t pos, const Poco::UInt16& val, Direction dir = PD_IN) = 0;
+		/// Binds an UInt16.
+
+	virtual void bind(std::size_t pos, const std::vector<Poco::UInt16>& val, Direction dir = PD_IN);
+		/// Binds an UInt16 vector.
+
+	virtual void bind(std::size_t pos, const std::deque<Poco::UInt16>& val, Direction dir = PD_IN);
+		/// Binds an UInt16 deque.
+
+	virtual void bind(std::size_t pos, const std::list<Poco::UInt16>& val, Direction dir = PD_IN);
+		/// Binds an UInt16 list.
+
+	virtual void bind(std::size_t pos, const Poco::Int32& val, Direction dir = PD_IN) = 0;
+		/// Binds an Int32.
+
+	virtual void bind(std::size_t pos, const std::vector<Poco::Int32>& val, Direction dir = PD_IN);
+		/// Binds an Int32 vector.
+
+	virtual void bind(std::size_t pos, const std::deque<Poco::Int32>& val, Direction dir = PD_IN);
+		/// Binds an Int32 deque.
+
+	virtual void bind(std::size_t pos, const std::list<Poco::Int32>& val, Direction dir = PD_IN);
+		/// Binds an Int32 list.
+
+	virtual void bind(std::size_t pos, const Poco::UInt32& val, Direction dir = PD_IN) = 0;
+		/// Binds an UInt32.
+
+	virtual void bind(std::size_t pos, const std::vector<Poco::UInt32>& val, Direction dir = PD_IN);
+		/// Binds an UInt32 vector.
+
+	virtual void bind(std::size_t pos, const std::deque<Poco::UInt32>& val, Direction dir = PD_IN);
+		/// Binds an UInt32 deque.
+
+	virtual void bind(std::size_t pos, const std::list<Poco::UInt32>& val, Direction dir = PD_IN);
+		/// Binds an UInt32 list.
+		
+	virtual void bind(std::size_t pos, const Poco::Int64& val, Direction dir = PD_IN) = 0;
+		/// Binds an Int64.
+
+	virtual void bind(std::size_t pos, const std::vector<Poco::Int64>& val, Direction dir = PD_IN);
+		/// Binds an Int64 vector.
+
+	virtual void bind(std::size_t pos, const std::deque<Poco::Int64>& val, Direction dir = PD_IN);
+		/// Binds an Int64 deque.
+
+	virtual void bind(std::size_t pos, const std::list<Poco::Int64>& val, Direction dir = PD_IN);
+		/// Binds an Int64 list.
+
+	virtual void bind(std::size_t pos, const Poco::UInt64& val, Direction dir = PD_IN) = 0;
+		/// Binds an UInt64.
+
+	virtual void bind(std::size_t pos, const std::vector<Poco::UInt64>& val, Direction dir = PD_IN);
+		/// Binds an UInt64 vector.
+
+	virtual void bind(std::size_t pos, const std::deque<Poco::UInt64>& val, Direction dir = PD_IN);
+		/// Binds an UInt64 deque.
+
+	virtual void bind(std::size_t pos, const std::list<Poco::UInt64>& val, Direction dir = PD_IN);
+		/// Binds an UInt64 list.
+
+#ifndef POCO_LONG_IS_64_BIT
+	virtual void bind(std::size_t pos, const long& val, Direction dir = PD_IN) = 0;
+		/// Binds a long.
+
+	virtual void bind(std::size_t pos, const unsigned long& val, Direction dir = PD_IN) = 0;
+		/// Binds an unsiged long.
+
+	virtual void bind(std::size_t pos, const std::vector<long>& val, Direction dir = PD_IN);
+		/// Binds a long vector.
+
+	virtual void bind(std::size_t pos, const std::deque<long>& val, Direction dir = PD_IN);
+		/// Binds a long deque.
+
+	virtual void bind(std::size_t pos, const std::list<long>& val, Direction dir = PD_IN);
+		/// Binds a long list.
+#endif
+
+	virtual void bind(std::size_t pos, const bool& val, Direction dir = PD_IN) = 0;
+		/// Binds a boolean.
+
+	virtual void bind(std::size_t pos, const std::vector<bool>& val, Direction dir = PD_IN);
+		/// Binds a boolean vector.
+
+	virtual void bind(std::size_t pos, const std::deque<bool>& val, Direction dir = PD_IN);
+		/// Binds a boolean deque.
+
+	virtual void bind(std::size_t pos, const std::list<bool>& val, Direction dir = PD_IN);
+		/// Binds a boolean list.
+
+	virtual void bind(std::size_t pos, const float& val, Direction dir = PD_IN) = 0;
+		/// Binds a float.
+
+	virtual void bind(std::size_t pos, const std::vector<float>& val, Direction dir = PD_IN);
+		/// Binds a float vector.
+
+	virtual void bind(std::size_t pos, const std::deque<float>& val, Direction dir = PD_IN);
+		/// Binds a float deque.
+
+	virtual void bind(std::size_t pos, const std::list<float>& val, Direction dir = PD_IN);
+		/// Binds a float list.
+
+	virtual void bind(std::size_t pos, const double& val, Direction dir = PD_IN) = 0;
+		/// Binds a double.
+
+	virtual void bind(std::size_t pos, const std::vector<double>& val, Direction dir = PD_IN);
+		/// Binds a double vector.
+
+	virtual void bind(std::size_t pos, const std::deque<double>& val, Direction dir = PD_IN);
+		/// Binds a double deque.
+
+	virtual void bind(std::size_t pos, const std::list<double>& val, Direction dir = PD_IN);
+		/// Binds a double list.
+
+	virtual void bind(std::size_t pos, const char& val, Direction dir = PD_IN) = 0;
+		/// Binds a single character.
+
+	virtual void bind(std::size_t pos, const std::vector<char>& val, Direction dir = PD_IN);
+		/// Binds a character vector.
+
+	virtual void bind(std::size_t pos, const std::deque<char>& val, Direction dir = PD_IN);
+		/// Binds a character deque.
+
+	virtual void bind(std::size_t pos, const std::list<char>& val, Direction dir = PD_IN);
+		/// Binds a character list.
+
+	virtual void bind(std::size_t pos, const char* const& pVal, Direction dir = PD_IN) = 0;
+		/// Binds a const char ptr.
+
+	virtual void bind(std::size_t pos, const std::string& val, Direction dir = PD_IN) = 0;
+		/// Binds a string.
+
+	virtual void bind(std::size_t pos, const std::vector<std::string>& val, Direction dir = PD_IN);
+		/// Binds a string vector.
+
+	virtual void bind(std::size_t pos, const std::deque<std::string>& val, Direction dir = PD_IN);
+		/// Binds a string deque.
+
+	virtual void bind(std::size_t pos, const std::list<std::string>& val, Direction dir = PD_IN);
+		/// Binds a string list.
+
+	virtual void bind(std::size_t pos, const UTF16String& val, Direction dir = PD_IN);
+		/// Binds a UTF-16 Unicode string.
+
+	virtual void bind(std::size_t pos, const std::vector<UTF16String>& val, Direction dir = PD_IN);
+		/// Binds a UTF-16 Unicode string vector.
+
+	virtual void bind(std::size_t pos, const std::deque<UTF16String>& val, Direction dir = PD_IN);
+		/// Binds a UTF-16 Unicode string deque.
+
+	virtual void bind(std::size_t pos, const std::list<UTF16String>& val, Direction dir = PD_IN);
+		/// Binds a UTF-16 Unicode string list.
+
+	virtual void bind(std::size_t pos, const BLOB& val, Direction dir = PD_IN) = 0;
+		/// Binds a BLOB.
+
+	virtual void bind(std::size_t pos, const CLOB& val, Direction dir = PD_IN) = 0;
+		/// Binds a CLOB.
+
+	virtual void bind(std::size_t pos, const std::vector<BLOB>& val, Direction dir = PD_IN);
+		/// Binds a BLOB vector.
+
+	virtual void bind(std::size_t pos, const std::deque<BLOB>& val, Direction dir = PD_IN);
+		/// Binds a BLOB deque.
+
+	virtual void bind(std::size_t pos, const std::list<BLOB>& val, Direction dir = PD_IN);
+		/// Binds a BLOB list.
+
+	virtual void bind(std::size_t pos, const std::vector<CLOB>& val, Direction dir = PD_IN);
+		/// Binds a CLOB vector.
+
+	virtual void bind(std::size_t pos, const std::deque<CLOB>& val, Direction dir = PD_IN);
+		/// Binds a CLOB deque.
+
+	virtual void bind(std::size_t pos, const std::list<CLOB>& val, Direction dir = PD_IN);
+		/// Binds a CLOB list.
+
+	virtual void bind(std::size_t pos, const DateTime& val, Direction dir = PD_IN) = 0;
+		/// Binds a DateTime.
+
+	virtual void bind(std::size_t pos, const std::vector<DateTime>& val, Direction dir = PD_IN);
+		/// Binds a DateTime vector.
+
+	virtual void bind(std::size_t pos, const std::deque<DateTime>& val, Direction dir = PD_IN);
+		/// Binds a DateTime deque.
+
+	virtual void bind(std::size_t pos, const std::list<DateTime>& val, Direction dir = PD_IN);
+		/// Binds a DateTime list.
+
+	virtual void bind(std::size_t pos, const Date& val, Direction dir = PD_IN) = 0;
+		/// Binds a Date.
+
+	virtual void bind(std::size_t pos, const std::vector<Date>& val, Direction dir = PD_IN);
+		/// Binds a Date vector.
+
+	virtual void bind(std::size_t pos, const std::deque<Date>& val, Direction dir = PD_IN);
+		/// Binds a Date deque.
+
+	virtual void bind(std::size_t pos, const std::list<Date>& val, Direction dir = PD_IN);
+		/// Binds a Date list.
+
+	virtual void bind(std::size_t pos, const Time& val, Direction dir = PD_IN) = 0;
+		/// Binds a Time.
+
+	virtual void bind(std::size_t pos, const std::vector<Time>& val, Direction dir = PD_IN);
+		/// Binds a Time vector.
+
+	virtual void bind(std::size_t pos, const std::deque<Time>& val, Direction dir = PD_IN);
+		/// Binds a Time deque.
+
+	virtual void bind(std::size_t pos, const std::list<Time>& val, Direction dir = PD_IN);
+		/// Binds a Time list.
+
+	virtual void bind(std::size_t pos, const NullData& val, Direction dir = PD_IN) = 0;
+		/// Binds a null.
+
+	virtual void bind(std::size_t pos, const std::vector<NullData>& val, Direction dir = PD_IN);
+		/// Binds a null vector.
+
+	virtual void bind(std::size_t pos, const std::deque<NullData>& val, Direction dir = PD_IN);
+		/// Binds a null deque.
+
+	virtual void bind(std::size_t pos, const std::list<NullData>& val, Direction dir = PD_IN);
+		/// Binds a null list.
+
+	void bind(std::size_t pos, const Any& val, Direction dir = PD_IN);
+		/// Binds an Any.
+	
+	void bind(std::size_t pos, const Poco::Dynamic::Var& val, Direction dir = PD_IN);
+	/// Binds a Var.
+
+	virtual void reset();
+		/// Resets a binder. No-op by default. Implement for binders that cache data.
+
+	static bool isOutBound(Direction dir);
+		/// Returns true if direction is out bound;
+
+	static bool isInBound(Direction dir);
+		/// Returns true if direction is in bound;
+};
+
+
+//
+// inlines
+//
+inline void AbstractBinder::reset()
+{
+	//no-op
+}
+
+
+inline bool AbstractBinder::isOutBound(Direction dir)
+{
+	return PD_OUT == dir || PD_IN_OUT == dir;
+}
+
+
+inline bool AbstractBinder::isInBound(Direction dir)
+{
+	return PD_IN == dir || PD_IN_OUT == dir;
+}
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_AbstractBinder_INCLUDED

base/poco/Data/include/Poco/Data/AbstractBinding.h

@@ -0,0 +1,144 @@
+//
+// AbstractBinding.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  AbstractBinding
+//
+// Definition of the AbstractBinding class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_AbstractBinding_INCLUDED
+#define Data_AbstractBinding_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/AbstractBinder.h"
+#include "Poco/Any.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/AutoPtr.h"
+#include <vector>
+#include <list>
+#include <deque>
+#include <cstddef>
+
+
+namespace Poco {
+namespace Data {
+
+
+class Data_API AbstractBinding
+	/// AbstractBinding connects a value with a placeholder via an AbstractBinder interface.
+{
+public:
+	typedef SharedPtr<AbstractBinding> Ptr;
+	typedef AbstractBinder::Ptr        BinderPtr;
+
+	enum Direction
+	{
+		PD_IN = AbstractBinder::PD_IN,
+		PD_OUT = AbstractBinder::PD_OUT,
+		PD_IN_OUT = AbstractBinder::PD_IN_OUT
+	};
+
+	AbstractBinding(const std::string& name = "", Direction direction = PD_IN, Poco::UInt32 bulkSize = 0);
+		/// Creates the AbstractBinding.
+
+	virtual ~AbstractBinding();
+		/// Destroys the AbstractBinding.
+
+	void setBinder(BinderPtr pBinder);
+		/// Sets the object used for binding; object does NOT take ownership of the pointer.
+
+	BinderPtr getBinder() const;
+		/// Returns the AbstractBinder used for binding data.
+
+	virtual std::size_t numOfColumnsHandled() const = 0;
+		/// Returns the number of columns that the binding handles.
+		///
+		/// The trivial case will be one single column but when
+		/// complex types are used this value can be larger than one.
+
+	virtual std::size_t numOfRowsHandled() const = 0;
+		/// Returns the number of rows that the binding handles.
+		///
+		/// The trivial case will be one single row but 
+		/// for collection data types it can be larger.
+
+	virtual bool canBind() const = 0;
+		/// Returns true if we have enough data to bind
+
+	virtual void bind(std::size_t pos) = 0;
+		/// Binds a value to the given column position
+
+	virtual void reset() = 0;
+		/// Allows a binding to be reused.
+
+	AbstractBinder::Direction getDirection() const;
+		/// Returns the binding direction.
+
+	const std::string& name() const;
+		/// Returns the name for this binding.
+
+	bool isBulk() const;
+		/// Returns true if extraction is bulk.
+
+	Poco::UInt32 bulkSize() const;
+		/// Returns the size of the bulk binding.
+
+private:
+	BinderPtr    _pBinder;
+	std::string  _name;
+	Direction    _direction;
+	Poco::UInt32 _bulkSize;
+};
+
+
+typedef std::vector<AbstractBinding::Ptr> AbstractBindingVec;
+typedef std::deque<AbstractBinding::Ptr>  AbstractBindingDeq;
+typedef std::list<AbstractBinding::Ptr>   AbstractBindingLst;
+
+
+//
+// inlines
+//
+inline AbstractBinder::Ptr AbstractBinding::getBinder() const
+{
+	return _pBinder;
+}
+
+
+inline const std::string& AbstractBinding::name() const
+{
+	return _name;
+}
+
+
+inline AbstractBinder::Direction AbstractBinding::getDirection() const
+{
+	return (AbstractBinder::Direction) _direction;
+}
+
+
+inline bool AbstractBinding::isBulk() const
+{
+	return _bulkSize > 0;
+}
+
+
+inline Poco::UInt32 AbstractBinding::bulkSize() const
+{
+	return _bulkSize;
+}
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_AbstractBinding_INCLUDED

base/poco/Data/include/Poco/Data/AbstractExtraction.h

@@ -0,0 +1,278 @@
+//
+// AbstractExtraction.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  AbstractExtraction
+//
+// Definition of the AbstractExtraction class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_AbstractExtraction_INCLUDED
+#define Data_AbstractExtraction_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/AbstractExtractor.h"
+#include "Poco/Data/AbstractPreparation.h"
+#include "Poco/Data/Limit.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/UTFString.h"
+#include "Poco/AutoPtr.h"
+#include <vector>
+#include <deque>
+#include <list>
+#include <cstddef>
+
+
+namespace Poco {
+namespace Data {
+
+
+class AbstractPreparator;
+
+
+class Data_API AbstractExtraction
+	/// AbstractExtraction is the interface class that connects output positions to concrete values
+	/// retrieved via an AbstractExtractor.
+{
+public:
+	typedef SharedPtr<AbstractExtraction> Ptr;
+	typedef SharedPtr<AbstractExtractor>  ExtractorPtr;
+	typedef SharedPtr<AbstractPreparator> PreparatorPtr;
+
+	AbstractExtraction(Poco::UInt32 limit = Limit::LIMIT_UNLIMITED,
+		Poco::UInt32 position = 0, bool bulk = false);
+		/// Creates the AbstractExtraction. A limit value equal to EXTRACT_UNLIMITED (0xffffffffu) 
+		/// means that we extract as much data as possible during one execute.
+		/// Otherwise the limit value is used to partition data extracting to a limited amount of rows.
+
+	virtual ~AbstractExtraction();
+		/// Destroys the AbstractExtraction.
+
+	void setExtractor(ExtractorPtr pExtractor);
+		/// Sets the class used for extracting the data. Does not take ownership of the pointer.
+
+	ExtractorPtr getExtractor() const;
+		/// Retrieves the extractor object
+
+	Poco::UInt32 position() const;
+		/// Returns the extraction position.
+
+	virtual std::size_t numOfColumnsHandled() const = 0;
+		/// Returns the number of columns that the extraction handles.
+		///
+		/// The trivial case will be one single column but when
+		/// complex types are used this value can be larger than one.
+
+	virtual std::size_t numOfRowsHandled() const = 0;
+		/// Returns the number of rows that the extraction handles.
+		///
+		/// The trivial case will be one single row but 
+		/// for collection data types (ie vector) it can be larger.
+
+	virtual std::size_t numOfRowsAllowed() const = 0;
+		/// Returns the upper limit on number of rows that the extraction will handle.
+
+	virtual std::size_t extract(std::size_t pos) = 0;
+		/// Extracts a value from the param, starting at the given column position.
+		/// Returns the number of rows extracted.
+
+	virtual void reset();
+		/// Resets the extractor so that it can be re-used.
+		/// Does nothing in this implementation.
+		/// Implementations should override it for different behavior.
+
+	virtual bool canExtract() const;
+		/// Returns true. Implementations should override it for different behavior.
+
+	virtual AbstractPreparation::Ptr createPreparation(PreparatorPtr& pPrep, std::size_t pos) = 0;
+		/// Creates and returns shared pointer to Preparation object for the extracting object.
+
+	void setLimit(Poco::UInt32 limit);
+		/// Sets the limit.
+
+	Poco::UInt32 getLimit() const;
+		/// Gets the limit.
+
+	virtual bool isNull(std::size_t row) const;
+		/// In implementations, this function returns true if value at row is null, 
+		/// false otherwise. 
+		/// Normal behavior is to replace nulls with default values.
+		/// However, extraction implementations may remember the underlying database
+		/// null values and be able to later provide information about them.
+		/// Here, this function throws NotImplementedException.
+
+	bool isBulk() const;
+		/// Returns true if this is bulk extraction.
+
+	void setEmptyStringIsNull(bool emptyStringIsNull);
+		/// Sets the empty string handling flag.
+
+	bool getEmptyStringIsNull() const;
+		/// Returns the empty string handling flag.
+
+	void setForceEmptyString(bool forceEmptyString);
+		/// Sets the force empty string flag.
+
+	bool getForceEmptyString() const;
+		/// Returns the force empty string flag.
+
+	template <typename T>
+	bool isValueNull(const T& str, bool deflt)
+		/// Utility function to determine the nullness of the value.
+		/// This generic version always returns default value
+		/// (i.e. does nothing). The std::string overload does
+		/// the actual work.
+		///
+	{
+		return deflt;
+	}
+
+	bool isValueNull(const std::string& str, bool deflt);
+		/// Overload for const reference to std::string.
+		///
+		/// Returns true when folowing conditions are met:
+		///
+		/// - string is empty 
+		/// - getEmptyStringIsNull() returns true
+
+	bool isValueNull(const Poco::UTF16String& str, bool deflt);
+		/// Overload for const reference to UTF16String.
+		///
+		/// Returns true when folowing conditions are met:
+		///
+		/// - string is empty 
+		/// - getEmptyStringIsNull() returns true
+
+private:
+	template <typename S>
+	bool isStringNull(const S& str, bool deflt)
+	{
+		if (getForceEmptyString()) return false;
+
+		if (getEmptyStringIsNull() && str.empty())
+			return true;
+
+		return deflt;
+	}
+
+	ExtractorPtr _pExtractor;
+	Poco::UInt32 _limit;
+	Poco::UInt32 _position;
+	bool         _bulk;
+	bool         _emptyStringIsNull;
+	bool         _forceEmptyString;
+};
+
+
+typedef std::vector<AbstractExtraction::Ptr> AbstractExtractionVec;
+typedef std::vector<AbstractExtractionVec>   AbstractExtractionVecVec;
+typedef std::deque<AbstractExtraction::Ptr>  AbstractExtractionDeq;
+typedef std::vector<AbstractExtractionDeq>   AbstractExtractionDeqVec;
+typedef std::list<AbstractExtraction::Ptr>   AbstractExtractionLst;
+typedef std::vector<AbstractExtractionLst>   AbstractExtractionLstVec;
+
+
+//
+// inlines
+//
+inline void AbstractExtraction::setExtractor(ExtractorPtr pExtractor)
+{
+	_pExtractor = pExtractor;
+}
+
+
+inline AbstractExtraction::ExtractorPtr AbstractExtraction::getExtractor() const
+{
+	return _pExtractor;
+}
+
+
+inline void AbstractExtraction::setLimit(Poco::UInt32 limit)
+{
+	_limit = limit;
+}
+
+
+inline Poco::UInt32 AbstractExtraction::getLimit() const
+{
+	return _limit;
+}
+
+
+inline bool AbstractExtraction::isNull(std::size_t row) const
+{
+	throw NotImplementedException("Check for null values not implemented.");
+}
+
+
+inline Poco::UInt32 AbstractExtraction::position() const
+{
+	return _position;
+}
+
+
+inline bool AbstractExtraction::isBulk() const
+{
+	return _bulk;
+}
+
+
+inline void AbstractExtraction::reset()
+{
+}
+
+
+inline bool AbstractExtraction::canExtract() const
+{
+	return true;
+}
+
+
+inline void AbstractExtraction::setEmptyStringIsNull(bool emptyStringIsNull)
+{
+	_emptyStringIsNull = emptyStringIsNull;
+}
+
+
+inline bool AbstractExtraction::getEmptyStringIsNull() const
+{
+	return _emptyStringIsNull;
+}
+
+
+inline void AbstractExtraction::setForceEmptyString(bool forceEmptyString)
+{
+	_forceEmptyString = forceEmptyString;
+}
+
+
+inline bool AbstractExtraction::getForceEmptyString() const
+{
+	return _forceEmptyString;
+}
+
+
+inline bool AbstractExtraction::isValueNull(const std::string& str, bool deflt)
+{
+	return isStringNull(str, deflt);
+}
+
+
+inline bool AbstractExtraction::isValueNull(const Poco::UTF16String& str, bool deflt)
+{
+	return isStringNull(str, deflt);
+}
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_AbstractExtraction_INCLUDED

base/poco/Data/include/Poco/Data/AbstractExtractor.h

@@ -0,0 +1,351 @@
+//
+// AbstractExtractor.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  AbstractExtractor
+//
+// Definition of the AbstractExtractor class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_AbstractExtractor_INCLUDED
+#define Data_AbstractExtractor_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/Constants.h"
+#include "Poco/Data/LOB.h"
+#include "Poco/UTFString.h"
+#include <vector>
+#include <deque>
+#include <list>
+#include <string>
+#include <cstddef>
+
+
+namespace Poco {
+
+
+class DateTime;
+class Any;
+
+namespace Dynamic {
+class Var;
+}
+
+namespace Data {
+
+
+class Date;
+class Time;
+
+
+class Data_API AbstractExtractor
+	/// Interface used to extract data from a single result row.
+	/// If an extractor receives null it is not allowed to change val!
+{
+public:
+	typedef SharedPtr<AbstractExtractor> Ptr;
+
+	AbstractExtractor();
+		/// Creates the AbstractExtractor.
+
+	virtual ~AbstractExtractor();
+		/// Destroys the AbstractExtractor.
+
+	virtual bool extract(std::size_t pos, Poco::Int8& val) = 0;
+		/// Extracts an Int8. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<Poco::Int8>& val);
+		/// Extracts an Int8 vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Poco::Int8>& val);
+		/// Extracts an Int8 deque.
+
+	virtual bool extract(std::size_t pos, std::list<Poco::Int8>& val);
+		/// Extracts an Int8 list.
+
+	virtual bool extract(std::size_t pos, Poco::UInt8& val) = 0;
+		/// Extracts an UInt8. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<Poco::UInt8>& val);
+		/// Extracts an UInt8 vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Poco::UInt8>& val);
+		/// Extracts an UInt8 deque.
+
+	virtual bool extract(std::size_t pos, std::list<Poco::UInt8>& val);
+		/// Extracts an UInt8 list.
+
+	virtual bool extract(std::size_t pos, Poco::Int16& val) = 0;
+		/// Extracts an Int16. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<Poco::Int16>& val);
+		/// Extracts an Int16 vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Poco::Int16>& val);
+		/// Extracts an Int16 deque.
+
+	virtual bool extract(std::size_t pos, std::list<Poco::Int16>& val);
+		/// Extracts an Int16 list.
+
+	virtual bool extract(std::size_t pos, Poco::UInt16& val) = 0;
+		/// Extracts an UInt16. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<Poco::UInt16>& val);
+		/// Extracts an UInt16 vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Poco::UInt16>& val);
+		/// Extracts an UInt16 deque.
+
+	virtual bool extract(std::size_t pos, std::list<Poco::UInt16>& val);
+		/// Extracts an UInt16 list.
+
+	virtual bool extract(std::size_t pos, Poco::Int32& val) = 0;
+		/// Extracts an Int32. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<Poco::Int32>& val);
+		/// Extracts an Int32 vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Poco::Int32>& val);
+		/// Extracts an Int32 deque.
+
+	virtual bool extract(std::size_t pos, std::list<Poco::Int32>& val);
+		/// Extracts an Int32 list.
+
+	virtual bool extract(std::size_t pos, Poco::UInt32& val) = 0;
+		/// Extracts an UInt32. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<Poco::UInt32>& val);
+		/// Extracts an UInt32 vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Poco::UInt32>& val);
+		/// Extracts an UInt32 deque.
+
+	virtual bool extract(std::size_t pos, std::list<Poco::UInt32>& val);
+		/// Extracts an UInt32 list.
+
+	virtual bool extract(std::size_t pos, Poco::Int64& val) = 0;
+		/// Extracts an Int64. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<Poco::Int64>& val);
+		/// Extracts an Int64 vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Poco::Int64>& val);
+		/// Extracts an Int64 deque.
+
+	virtual bool extract(std::size_t pos, std::list<Poco::Int64>& val);
+		/// Extracts an Int64 list.
+
+	virtual bool extract(std::size_t pos, Poco::UInt64& val) = 0;
+		/// Extracts an UInt64. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<Poco::UInt64>& val);
+		/// Extracts an UInt64 vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Poco::UInt64>& val);
+		/// Extracts an UInt64 deque.
+
+	virtual bool extract(std::size_t pos, std::list<Poco::UInt64>& val);
+		/// Extracts an UInt64 list.
+
+#ifndef POCO_LONG_IS_64_BIT
+	virtual bool extract(std::size_t pos, long& val) = 0;
+		/// Extracts a long. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, unsigned long& val) = 0;
+		/// Extracts an unsigned long. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<long>& val);
+		/// Extracts a long vector.
+
+	virtual bool extract(std::size_t pos, std::deque<long>& val);
+		/// Extracts a long deque.
+
+	virtual bool extract(std::size_t pos, std::list<long>& val);
+		/// Extracts a long list.
+#endif
+
+	virtual bool extract(std::size_t pos, bool& val) = 0;
+		/// Extracts a boolean. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<bool>& val);
+		/// Extracts a boolean vector.
+
+	virtual bool extract(std::size_t pos, std::deque<bool>& val);
+		/// Extracts a boolean deque.
+
+	virtual bool extract(std::size_t pos, std::list<bool>& val);
+		/// Extracts a boolean list.
+
+	virtual bool extract(std::size_t pos, float& val) = 0;
+		/// Extracts a float. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<float>& val);
+		/// Extracts a float vector.
+
+	virtual bool extract(std::size_t pos, std::deque<float>& val);
+		/// Extracts a float deque.
+
+	virtual bool extract(std::size_t pos, std::list<float>& val);
+		/// Extracts a float list.
+
+	virtual bool extract(std::size_t pos, double& val) = 0;
+		/// Extracts a double. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<double>& val);
+		/// Extracts a double vector.
+
+	virtual bool extract(std::size_t pos, std::deque<double>& val);
+		/// Extracts a double deque.
+
+	virtual bool extract(std::size_t pos, std::list<double>& val);
+		/// Extracts a double list.
+
+	virtual bool extract(std::size_t pos, char& val) = 0;
+		/// Extracts a single character. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<char>& val);
+		/// Extracts a character vector.
+
+	virtual bool extract(std::size_t pos, std::deque<char>& val);
+		/// Extracts a character deque.
+
+	virtual bool extract(std::size_t pos, std::list<char>& val);
+		/// Extracts a character list.
+
+	virtual bool extract(std::size_t pos, std::string& val) = 0;
+		/// Extracts a string. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<std::string>& val);
+		/// Extracts a string vector.
+
+	virtual bool extract(std::size_t pos, std::deque<std::string>& val);
+		/// Extracts a string deque.
+
+	virtual bool extract(std::size_t pos, std::list<std::string>& val);
+		/// Extracts a string list.
+
+	virtual bool extract(std::size_t pos, UTF16String& val);
+		/// Extracts a UTF16String. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<UTF16String>& val);
+		/// Extracts a UTF16String vector.
+
+	virtual bool extract(std::size_t pos, std::deque<UTF16String>& val);
+		/// Extracts a UTF16String deque.
+
+	virtual bool extract(std::size_t pos, std::list<UTF16String>& val);
+		/// Extracts a UTF16String list.
+
+	virtual bool extract(std::size_t pos, BLOB& val) = 0;
+		/// Extracts a BLOB. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, CLOB& val) = 0;
+		/// Extracts a CLOB. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<BLOB>& val);
+		/// Extracts a BLOB vector.
+
+	virtual bool extract(std::size_t pos, std::deque<BLOB>& val);
+		/// Extracts a BLOB deque.
+
+	virtual bool extract(std::size_t pos, std::list<BLOB>& val);
+		/// Extracts a BLOB list.
+
+	virtual bool extract(std::size_t pos, std::vector<CLOB>& val);
+		/// Extracts a CLOB vector.
+
+	virtual bool extract(std::size_t pos, std::deque<CLOB>& val);
+		/// Extracts a CLOB deque.
+
+	virtual bool extract(std::size_t pos, std::list<CLOB>& val);
+		/// Extracts a CLOB list.
+
+	virtual bool extract(std::size_t pos, DateTime& val) = 0;
+		/// Extracts a DateTime. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<DateTime>& val);
+		/// Extracts a DateTime vector.
+
+	virtual bool extract(std::size_t pos, std::deque<DateTime>& val);
+		/// Extracts a DateTime deque.
+
+	virtual bool extract(std::size_t pos, std::list<DateTime>& val);
+		/// Extracts a DateTime list.
+
+	virtual bool extract(std::size_t pos, Date& val) = 0;
+		/// Extracts a Date. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<Date>& val);
+		/// Extracts a Date vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Date>& val);
+		/// Extracts a Date deque.
+
+	virtual bool extract(std::size_t pos, std::list<Date>& val);
+		/// Extracts a Date list.
+
+	virtual bool extract(std::size_t pos, Time& val) = 0;
+		/// Extracts a Time. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<Time>& val);
+		/// Extracts a Time vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Time>& val);
+		/// Extracts a Time deque.
+
+	virtual bool extract(std::size_t pos, std::list<Time>& val);
+		/// Extracts a Time list.
+
+	virtual bool extract(std::size_t pos, Any& val) = 0;
+		/// Extracts an Any. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<Any>& val);
+		/// Extracts an Any vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Any>& val);
+		/// Extracts an Any deque.
+
+	virtual bool extract(std::size_t pos, std::list<Any>& val);
+		/// Extracts an Any list.
+
+	virtual bool extract(std::size_t pos, Poco::Dynamic::Var& val) = 0;
+		/// Extracts a Var. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<Poco::Dynamic::Var>& val);
+		/// Extracts a Var vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Poco::Dynamic::Var>& val);
+		/// Extracts a Var deque.
+
+	virtual bool extract(std::size_t pos, std::list<Poco::Dynamic::Var>& val);
+		/// Extracts a Var list.
+
+	virtual bool isNull(std::size_t col, std::size_t row = POCO_DATA_INVALID_ROW) = 0;
+		/// Returns true if the value at [col,row] position is null.
+
+	virtual void reset();
+		/// Resets any information internally cached by the extractor.
+};
+
+
+///
+/// inlines
+///
+inline void AbstractExtractor::reset()
+{
+	//default no-op
+}
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_AbstractExtractor_INCLUDED

base/poco/Data/include/Poco/Data/AbstractPreparation.h

@@ -0,0 +1,71 @@
+//
+// AbstractPreparation.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  AbstractPreparation
+//
+// Definition of the AbstractPreparation class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_AbstractPreparation_INCLUDED
+#define Data_AbstractPreparation_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/AbstractPreparator.h"
+#include "Poco/SharedPtr.h"
+#include <cstddef>
+
+
+namespace Poco {
+namespace Data {
+
+
+class Data_API AbstractPreparation
+	/// Interface for calling the appropriate AbstractPreparator method
+{
+public:
+	typedef SharedPtr<AbstractPreparation> Ptr;
+	typedef AbstractPreparator::Ptr PreparatorPtr;
+
+	AbstractPreparation(PreparatorPtr pPreparator);
+		/// Creates the AbstractPreparation.
+
+	virtual ~AbstractPreparation();
+		/// Destroys the AbstractPreparation.
+
+	virtual void prepare() = 0;
+		/// Prepares data.
+
+protected:
+	AbstractPreparation();
+	AbstractPreparation(const AbstractPreparation&);
+	AbstractPreparation& operator = (const AbstractPreparation&);
+
+	PreparatorPtr preparation();
+		/// Returns the preparation object
+
+	PreparatorPtr _pPreparator;
+};
+
+
+//
+// inlines
+//
+inline AbstractPreparation::PreparatorPtr AbstractPreparation::preparation()
+{
+	return _pPreparator;
+}
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_AbstractPreparation_INCLUDED

base/poco/Data/include/Poco/Data/AbstractPreparator.h

@@ -0,0 +1,388 @@
+//
+// AbstractPreparator.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  AbstractPreparator
+//
+// Definition of the AbstractPreparator class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_AbstractPreparator_INCLUDED
+#define Data_AbstractPreparator_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/Data/LOB.h"
+#include "Poco/UTFString.h"
+#include <vector>
+#include <deque>
+#include <list>
+#include <cstddef>
+
+
+namespace Poco {
+
+
+class DateTime;
+class Any;
+
+namespace Dynamic {
+class Var;
+}
+
+
+namespace Data {
+
+
+class Date;
+class Time;
+
+
+class Data_API AbstractPreparator
+	/// Interface used for database preparation where we first have to register all data types
+	/// (and memory output locations) before extracting data, e.g. ODBC.
+	/// Extract works as two-phase extract: first we call prepare once, then extract n-times.
+	/// There are cases (bulk operations using std::vector storage) when extract is called only once.
+	/// The value passed to a prepare() call is not used by the prepare, serving only as an indication 
+	/// of the data type being prepared, thus all values are passed as const references. 
+	/// Implementing this interface is not mandatory for a connector. Connectors that only extract data 
+	/// after SQL execution (e.g. SQLite) do not need this functionality at all.
+{
+public:
+	typedef SharedPtr<AbstractPreparator> Ptr;
+
+	AbstractPreparator(Poco::UInt32 length = 1u);
+		/// Creates the AbstractPreparator.
+
+	virtual ~AbstractPreparator();
+		/// Destroys the AbstractPreparator.
+
+	virtual void prepare(std::size_t pos, const Poco::Int8&) = 0;
+		/// Prepares an Int8.
+
+	virtual void prepare(std::size_t pos, const std::vector<Poco::Int8>& val);
+		/// Prepares an Int8 vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<Poco::Int8>& val);
+		/// Prepares an Int8 deque.
+
+	virtual void prepare(std::size_t pos, const std::list<Poco::Int8>& val);
+		/// Prepares an Int8 list.
+
+	virtual void prepare(std::size_t pos, const Poco::UInt8&) = 0;
+		/// Prepares an UInt8.
+
+	virtual void prepare(std::size_t pos, const std::vector<Poco::UInt8>& val);
+		/// Prepares an UInt8 vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<Poco::UInt8>& val);
+		/// Prepares an UInt8 deque.
+
+	virtual void prepare(std::size_t pos, const std::list<Poco::UInt8>& val);
+		/// Prepares an UInt8 list.
+
+	virtual void prepare(std::size_t pos, const Poco::Int16&) = 0;
+		/// Prepares an Int16.
+
+	virtual void prepare(std::size_t pos, const std::vector<Poco::Int16>& val);
+		/// Prepares an Int16 vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<Poco::Int16>& val);
+		/// Prepares an Int16 deque.
+
+	virtual void prepare(std::size_t pos, const std::list<Poco::Int16>& val);
+		/// Prepares an Int16 list.
+
+	virtual void prepare(std::size_t pos, const Poco::UInt16&) = 0;
+		/// Prepares an UInt16.
+
+	virtual void prepare(std::size_t pos, const std::vector<Poco::UInt16>& val);
+		/// Prepares an UInt16 vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<Poco::UInt16>& val);
+		/// Prepares an UInt16 deque.
+
+	virtual void prepare(std::size_t pos, const std::list<Poco::UInt16>& val);
+		/// Prepares an UInt16 list.
+
+	virtual void prepare(std::size_t pos, const Poco::Int32&) = 0;
+		/// Prepares an Int32.
+
+	virtual void prepare(std::size_t pos, const std::vector<Poco::Int32>& val);
+		/// Prepares an Int32 vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<Poco::Int32>& val);
+		/// Prepares an Int32 deque.
+
+	virtual void prepare(std::size_t pos, const std::list<Poco::Int32>& val);
+		/// Prepares an Int32 list.
+
+	virtual void prepare(std::size_t pos, const Poco::UInt32&) = 0;
+		/// Prepares an UInt32.
+
+	virtual void prepare(std::size_t pos, const std::vector<Poco::UInt32>& val);
+		/// Prepares an UInt32 vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<Poco::UInt32>& val);
+		/// Prepares an UInt32 deque.
+
+	virtual void prepare(std::size_t pos, const std::list<Poco::UInt32>& val);
+		/// Prepares an UInt32 list.
+
+	virtual void prepare(std::size_t pos, const Poco::Int64&) = 0;
+		/// Prepares an Int64.
+
+	virtual void prepare(std::size_t pos, const std::vector<Poco::Int64>& val);
+		/// Prepares an Int64 vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<Poco::Int64>& val);
+		/// Prepares an Int64 deque.
+
+	virtual void prepare(std::size_t pos, const std::list<Poco::Int64>& val);
+		/// Prepares an Int64 list.
+
+	virtual void prepare(std::size_t pos, const Poco::UInt64&) = 0;
+		/// Prepares an UInt64.
+
+	virtual void prepare(std::size_t pos, const std::vector<Poco::UInt64>& val);
+		/// Prepares an UInt64 vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<Poco::UInt64>& val);
+		/// Prepares an UInt64 deque.
+
+	virtual void prepare(std::size_t pos, const std::list<Poco::UInt64>& val);
+		/// Prepares an UInt64 list.
+
+#ifndef POCO_LONG_IS_64_BIT
+	virtual void prepare(std::size_t pos, const long&) = 0;
+		/// Prepares a long.
+
+	virtual void prepare(std::size_t pos, const unsigned long&) = 0;
+		/// Prepares an unsigned long.
+
+	virtual void prepare(std::size_t pos, const std::vector<long>& val);
+		/// Prepares a long vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<long>& val);
+		/// Prepares a long deque.
+
+	virtual void prepare(std::size_t pos, const std::list<long>& val);
+		/// Prepares a long list.
+#endif
+
+	virtual void prepare(std::size_t pos, const bool&) = 0;
+		/// Prepares a boolean.
+
+	virtual void prepare(std::size_t pos, const std::vector<bool>& val);
+		/// Prepares a boolean vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<bool>& val);
+		/// Prepares a boolean deque.
+
+	virtual void prepare(std::size_t pos, const std::list<bool>& val);
+		/// Prepares a boolean list.
+
+	virtual void prepare(std::size_t pos, const float&) = 0;
+		/// Prepares a float.
+
+	virtual void prepare(std::size_t pos, const std::vector<float>& val);
+		/// Prepares a float vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<float>& val);
+		/// Prepares a float deque.
+
+	virtual void prepare(std::size_t pos, const std::list<float>& val);
+		/// Prepares a float list.
+
+	virtual void prepare(std::size_t pos, const double&) = 0;
+		/// Prepares a double.
+
+	virtual void prepare(std::size_t pos, const std::vector<double>& val);
+		/// Prepares a double vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<double>& val);
+		/// Prepares a double deque.
+
+	virtual void prepare(std::size_t pos, const std::list<double>& val);
+		/// Prepares a double list.
+
+	virtual void prepare(std::size_t pos, const char&) = 0;
+		/// Prepares a single character.
+
+	virtual void prepare(std::size_t pos, const std::vector<char>& val);
+		/// Prepares a character vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<char>& val);
+		/// Prepares a character deque.
+
+	virtual void prepare(std::size_t pos, const std::list<char>& val);
+		/// Prepares a character list.
+
+	virtual void prepare(std::size_t pos, const std::string&) = 0;
+		/// Prepares a string.
+
+	virtual void prepare(std::size_t pos, const std::vector<std::string>& val);
+		/// Prepares a string vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<std::string>& val);
+		/// Prepares a string deque.
+
+	virtual void prepare(std::size_t pos, const std::list<std::string>& val);
+		/// Prepares a character list.
+
+	virtual void prepare(std::size_t pos, const UTF16String&);
+		/// Prepares a UTF16String.
+
+	virtual void prepare(std::size_t pos, const std::vector<UTF16String>& val);
+		/// Prepares a UTF16String vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<UTF16String>& val);
+		/// Prepares a UTF16String deque.
+
+	virtual void prepare(std::size_t pos, const std::list<UTF16String>& val);
+		/// Prepares a UTF16String list.
+
+	virtual void prepare(std::size_t pos, const BLOB&) = 0;
+		/// Prepares a BLOB.
+
+	virtual void prepare(std::size_t pos, const CLOB&) = 0;
+		/// Prepares a CLOB.
+
+	virtual void prepare(std::size_t pos, const std::vector<BLOB>& val);
+		/// Prepares a BLOB vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<BLOB>& val);
+		/// Prepares a BLOB deque.
+
+	virtual void prepare(std::size_t pos, const std::list<BLOB>& val);
+		/// Prepares a BLOB list.
+
+	virtual void prepare(std::size_t pos, const std::vector<CLOB>& val);
+		/// Prepares a CLOB vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<CLOB>& val);
+		/// Prepares a CLOB deque.
+
+	virtual void prepare(std::size_t pos, const std::list<CLOB>& val);
+		/// Prepares a CLOB list.
+
+	virtual void prepare(std::size_t pos, const DateTime&) = 0;
+		/// Prepares a DateTime.
+
+	virtual void prepare(std::size_t pos, const std::vector<DateTime>& val);
+		/// Prepares a DateTime vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<DateTime>& val);
+		/// Prepares a DateTime deque.
+
+	virtual void prepare(std::size_t pos, const std::list<DateTime>& val);
+		/// Prepares a DateTime list.
+
+	virtual void prepare(std::size_t pos, const Date&) = 0;
+		/// Prepares a Date.
+
+	virtual void prepare(std::size_t pos, const std::vector<Date>& val);
+		/// Prepares a Date vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<Date>& val);
+		/// Prepares a Date deque.
+
+	virtual void prepare(std::size_t pos, const std::list<Date>& val);
+		/// Prepares a Date list.
+
+	virtual void prepare(std::size_t pos, const Time&) = 0;
+		/// Prepares a Time.
+
+	virtual void prepare(std::size_t pos, const std::vector<Time>& val);
+		/// Prepares a Time vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<Time>& val);
+		/// Prepares a Time deque.
+	
+	virtual void prepare(std::size_t pos, const std::list<Time>& val);
+		/// Prepares a Time list.
+
+	virtual void prepare(std::size_t pos, const Any&) = 0;
+		/// Prepares an Any.
+
+	virtual void prepare(std::size_t pos, const std::vector<Any>& val);
+		/// Prepares an Any vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<Any>& val);
+		/// Prepares an Any deque.
+
+	virtual void prepare(std::size_t pos, const std::list<Any>& val);
+		/// Prepares an Any list.
+
+	virtual void prepare(std::size_t pos, const Poco::Dynamic::Var&) = 0;
+		/// Prepares a Var.
+
+	virtual void prepare(std::size_t pos, const std::vector<Poco::Dynamic::Var>& val);
+		/// Prepares a Var vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<Poco::Dynamic::Var>& val);
+		/// Prepares a Var deque.
+
+	virtual void prepare(std::size_t pos, const std::list<Poco::Dynamic::Var>& val);
+		/// Prepares a Var list.
+
+	void setLength(Poco::UInt32 length);
+		/// Sets the length of prepared data.
+		/// Needed only for data lengths greater than 1 (i.e. for
+		/// bulk operations).
+
+	Poco::UInt32 getLength() const;
+		/// Returns the length of prepared data. Defaults to 1.
+		/// The length is greater than one for bulk operations.
+
+	void setBulk(bool bulkPrep = true);
+		/// Sets bulk operation flag (always false at object creation time)
+
+	bool isBulk() const;
+		/// Returns bulk operation flag.
+
+private:
+	Poco::UInt32 _length;
+	bool         _bulk;
+};
+
+
+///
+/// inlines
+///
+inline void AbstractPreparator::setLength(Poco::UInt32 length)
+{
+	_length = length;
+}
+
+
+inline Poco::UInt32 AbstractPreparator::getLength() const
+{
+	return _length;
+}
+
+
+inline void AbstractPreparator::setBulk(bool bulkPrep)
+{
+	_bulk = bulkPrep;
+}
+
+
+inline bool AbstractPreparator::isBulk() const
+{
+	return _bulk;
+}
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_AbstractPreparator_INCLUDED

base/poco/Data/include/Poco/Data/AbstractSessionImpl.h

@@ -0,0 +1,315 @@
+//
+// AbstractSessionImpl.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  AbstractSessionImpl
+//
+// Definition of the AbstractSessionImpl class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_AbstractSessionImpl_INCLUDED
+#define Data_AbstractSessionImpl_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/SessionImpl.h"
+#include "Poco/Data/DataException.h"
+#include <map>
+
+
+namespace Poco {
+namespace Data {
+
+
+template <class C>
+class AbstractSessionImpl: public SessionImpl
+	/// A partial implementation of SessionImpl, providing
+	/// features and properties management.
+	///
+	/// To implement a certain feature or property, a subclass
+	/// must provide setter and getter methods and register
+	/// them with addFeature() or addProperty().
+{
+public:
+	typedef void (C::*FeatureSetter)(const std::string&, bool);
+		/// The setter method for a feature.
+		
+	typedef bool (C::*FeatureGetter)(const std::string&);
+		/// The getter method for a feature.
+		
+	typedef void (C::*PropertySetter)(const std::string&, const Poco::Any&);
+		/// The setter method for a property.
+		
+	typedef Poco::Any (C::*PropertyGetter)(const std::string&);
+		/// The getter method for a property.
+
+	AbstractSessionImpl(const std::string& connectionString,
+		std::size_t timeout = LOGIN_TIMEOUT_DEFAULT): SessionImpl(connectionString, timeout),
+			_storage(std::string("deque")),
+			_bulk(false),
+			_emptyStringIsNull(false),
+			_forceEmptyString(false)
+		/// Creates the AbstractSessionImpl.
+		/// 
+		/// Adds "storage" property and sets the default internal storage container 
+		/// type to std::deque.
+		/// The storage is created by statements automatically whenever a query 
+		/// returning results is executed but external storage is provided by the user.
+		/// Storage type can be reconfigured at runtime both globally (for the
+		/// duration of the session) and locally (for a single statement execution only). 
+		/// See StatementImpl for details on how this property is used at runtime.
+		/// 
+		/// Adds "handle" property which, if set by the back end, returns native handle
+		/// for the back end DB.
+		/// 
+		/// Adds "bulk" feature and sets it to false.
+		/// Bulk feature determines whether the session is capable of bulk operations.
+		/// Connectors that are capable of it must set this feature prior to attempting 
+		/// bulk operations.
+		///
+		/// Adds "emptyStringIsNull" feature and sets it to false. This feature should be
+		/// set to true in order to modify the behavior of the databases that distinguish
+		/// between zero-length character strings as nulls. Setting this feature to true 
+		/// shall disregard any difference between empty character strings and nulls,
+		/// causing the framework to treat them the same (i.e. behave like Oracle).		
+		///
+		/// Adds "forceEmptyString" feature and sets it to false. This feature should be set
+		/// to true in order to force the databases that do not distinguish empty strings from
+		/// nulls (e.g. Oracle) to always report empty string.
+		///
+		/// The "emptyStringIsNull" and "forceEmptyString" features are mutually exclusive.
+		/// While these features can not both be true at the same time, they can both be false,
+		/// resulting in default underlying database behavior.
+		///
+	{
+		addProperty("storage", 
+			&AbstractSessionImpl<C>::setStorage, 
+			&AbstractSessionImpl<C>::getStorage);
+
+		addProperty("handle", 
+			&AbstractSessionImpl<C>::setHandle,
+			&AbstractSessionImpl<C>::getHandle);
+
+		addFeature("bulk", 
+			&AbstractSessionImpl<C>::setBulk, 
+			&AbstractSessionImpl<C>::getBulk);
+
+		addFeature("emptyStringIsNull", 
+			&AbstractSessionImpl<C>::setEmptyStringIsNull,
+			&AbstractSessionImpl<C>::getEmptyStringIsNull);
+
+		addFeature("forceEmptyString", 
+			&AbstractSessionImpl<C>::setForceEmptyString,
+			&AbstractSessionImpl<C>::getForceEmptyString);
+	}
+
+	~AbstractSessionImpl()
+		/// Destroys the AbstractSessionImpl.
+	{
+	}
+
+	void setFeature(const std::string& name, bool state)
+		/// Looks a feature up in the features map
+		/// and calls the feature's setter, if there is one.
+	{
+		typename FeatureMap::const_iterator it = _features.find(name);
+		if (it != _features.end())
+		{
+			if (it->second.setter)
+				(static_cast<C*>(this)->*it->second.setter)(name, state);
+			else
+				throw NotImplementedException("set", name);
+		}
+		else throw NotSupportedException(name);
+	}
+	
+	bool getFeature(const std::string& name)
+		/// Looks a feature up in the features map
+		/// and calls the feature's getter, if there is one.
+	{
+		typename FeatureMap::const_iterator it = _features.find(name);
+		if (it != _features.end())
+		{
+			if (it->second.getter)
+				return (static_cast<C*>(this)->*it->second.getter)(name);
+			else
+				throw NotImplementedException("get", name);
+		}
+		else throw NotSupportedException(name);
+	}
+	
+	void setProperty(const std::string& name, const Poco::Any& value)
+		/// Looks a property up in the properties map
+		/// and calls the property's setter, if there is one.
+	{
+		typename PropertyMap::const_iterator it = _properties.find(name);
+		if (it != _properties.end())
+		{
+			if (it->second.setter)
+				(static_cast<C*>(this)->*it->second.setter)(name, value);
+			else
+				throw NotImplementedException("set", name);
+		}
+		else throw NotSupportedException(name);
+	}
+
+	Poco::Any getProperty(const std::string& name)
+		/// Looks a property up in the properties map
+		/// and calls the property's getter, if there is one.
+	{
+		typename PropertyMap::const_iterator it = _properties.find(name);
+		if (it != _properties.end())
+		{
+			if (it->second.getter)
+				return (static_cast<C*>(this)->*it->second.getter)(name);
+			else
+				throw NotImplementedException("set", name);
+		}
+		else throw NotSupportedException(name);
+	}
+	
+	void setStorage(const std::string& value)
+		/// Sets the storage type.
+	{
+		_storage = value;
+	}
+
+	void setStorage(const std::string& name, const Poco::Any& value)
+		/// Sets the storage type.
+	{
+		_storage = Poco::RefAnyCast<std::string>(value);
+	}
+		
+	Poco::Any getStorage(const std::string& name="")
+		/// Returns the storage type
+	{
+		return _storage;
+	}
+
+	void setHandle(const std::string& name, const Poco::Any& handle)
+		/// Sets the native session handle. 
+	{
+		_handle = handle;
+	}
+		
+	Poco::Any getHandle(const std::string& name="")
+		/// Returns the native session handle. 
+	{
+		return _handle;
+	}
+
+	void setBulk(const std::string& name, bool bulk)
+		/// Sets the execution type.
+	{
+		_bulk = bulk;
+	}
+		
+	bool getBulk(const std::string& name="")
+		/// Returns the execution type
+	{
+		return _bulk;
+	}
+
+	void setEmptyStringIsNull(const std::string& name, bool emptyStringIsNull)
+		/// Sets the behavior regarding empty variable length strings.
+		/// Those are treated as NULL by Oracle and as empty string by
+		/// most other databases.
+		/// When this feature is true, empty strings are treated as NULL.
+	{
+		if (emptyStringIsNull && _forceEmptyString)
+			throw InvalidAccessException("Features mutually exclusive");
+
+		_emptyStringIsNull = emptyStringIsNull;
+	}
+		
+	bool getEmptyStringIsNull(const std::string& name="")
+		/// Returns the setting for the behavior regarding empty variable
+		/// length strings. See setEmptyStringIsNull(const std::string&, bool)
+		/// and this class documentation for feature rationale and details.
+	{
+		return _emptyStringIsNull;
+	}
+
+	void setForceEmptyString(const std::string& name, bool forceEmptyString)
+		/// Sets the behavior regarding empty variable length strings.
+		/// Those are treated as NULL by Oracle and as empty string by
+		/// most other databases.
+		/// When this feature is true, both empty strings and NULL values
+		/// are reported as empty strings.
+	{
+		if (forceEmptyString && _emptyStringIsNull)
+			throw InvalidAccessException("Features mutually exclusive");
+
+		_forceEmptyString = forceEmptyString;
+	}
+		
+	bool getForceEmptyString(const std::string& name="")
+		/// Returns the setting for the behavior regarding empty variable
+		/// length strings. See setForceEmptyString(const std::string&, bool)
+		/// and this class documentation for feature rationale and details.
+	{
+		return _forceEmptyString;
+	}
+
+protected:
+	void addFeature(const std::string& name, FeatureSetter setter, FeatureGetter getter)
+		/// Adds a feature to the map of supported features.
+		///
+		/// The setter or getter can be null, in case setting or getting a feature
+		/// is not supported.
+	{
+		Feature feature;
+		feature.setter = setter;
+		feature.getter = getter;
+		_features[name] = feature;
+	}
+		
+	void addProperty(const std::string& name, PropertySetter setter, PropertyGetter getter)
+		/// Adds a property to the map of supported properties.
+		///
+		/// The setter or getter can be null, in case setting or getting a property
+		/// is not supported.
+	{
+		Property property;
+		property.setter = setter;
+		property.getter = getter;
+		_properties[name] = property;
+	}
+
+private:
+	struct Feature
+	{
+		FeatureSetter setter;
+		FeatureGetter getter;
+	};
+	
+	struct Property
+	{
+		PropertySetter setter;
+		PropertyGetter getter;
+	};
+	
+	typedef std::map<std::string, Feature>  FeatureMap;
+	typedef std::map<std::string, Property> PropertyMap;
+	
+	FeatureMap  _features;
+	PropertyMap _properties;
+	std::string _storage;
+	bool        _bulk;
+	bool        _emptyStringIsNull;
+	bool        _forceEmptyString;
+	Poco::Any   _handle;
+};
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_AbstractSessionImpl_INCLUDED

base/poco/Data/include/Poco/Data/ArchiveStrategy.h

@@ -0,0 +1,222 @@
+//
+// ArchiveStrategy.h
+//
+// Library: Data
+// Package: Logging
+// Module:  ArchiveStrategy
+//
+// Definition of the ArchiveStrategy class and subclasses.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ArchiveStrategy_INCLUDED
+#define Data_ArchiveStrategy_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/Session.h"
+#include "Poco/DateTime.h"
+#include "Poco/Timespan.h"
+#include "Poco/Dynamic/Var.h"
+#include "Poco/SharedPtr.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+class Data_API ArchiveStrategy
+	/// The ArchiveStrategy is used by SQLChannel to archive log rows.
+{
+public:
+	static const std::string DEFAULT_ARCHIVE_DESTINATION;
+
+	ArchiveStrategy(const std::string& connector, 
+		const std::string& connect, 
+		const std::string& source, 
+		const std::string& destination = DEFAULT_ARCHIVE_DESTINATION);
+		/// Creates archive strategy.
+
+	virtual ~ArchiveStrategy();
+		/// Destroys archive strategy.
+
+	void open();
+		/// Opens the session.
+
+	virtual void archive() = 0;
+		/// Archives the rows.
+
+	const std::string& getSource() const;
+		/// Returns the name of the source table containing rows to be archived.
+
+	void setSource(const std::string& source);
+		/// Sets the name of the source table.
+
+	const std::string& getDestination() const;
+		/// Returns the name of the destination table for rows to be archived.
+
+	void setDestination(const std::string& destination);
+		/// Sets the name of the destination table.
+
+	virtual const std::string& getThreshold() const = 0;
+		/// Returns the archive threshold.
+
+	virtual void setThreshold(const std::string& threshold) = 0;
+		/// Sets the archive threshold.
+
+protected:
+	typedef Poco::SharedPtr<Session>   SessionPtr;
+	typedef Poco::SharedPtr<Statement> StatementPtr;
+
+	Session& session();
+
+	void setCopyStatement();
+	void setDeleteStatement();
+	void setCountStatement();
+
+	Statement& getCopyStatement();
+	Statement& getDeleteStatement();
+	Statement& getCountStatement();
+private:
+	
+	ArchiveStrategy();
+	ArchiveStrategy(const ArchiveStrategy&);
+	ArchiveStrategy& operator = (const ArchiveStrategy&);
+
+	std::string  _connector;
+	std::string  _connect;
+	SessionPtr   _pSession;
+	StatementPtr _pCopyStatement;
+	StatementPtr _pDeleteStatement;
+	StatementPtr _pCountStatement;
+	std::string  _source;
+	std::string  _destination;
+};
+
+
+//
+// inlines
+//
+
+inline const std::string& ArchiveStrategy::getSource() const
+{
+	return _source;
+}
+
+
+inline void ArchiveStrategy::setSource(const std::string& source)
+{
+	_source = source;
+}
+
+
+inline void ArchiveStrategy::setDestination(const std::string& destination)
+{
+	_destination = destination;
+}
+
+
+inline const std::string& ArchiveStrategy::getDestination() const
+{
+	return _destination;
+}
+
+
+inline Session& ArchiveStrategy::session()
+{
+	return *_pSession;
+}
+
+
+inline void ArchiveStrategy::setCopyStatement()
+{
+	_pCopyStatement = new Statement(*_pSession);
+}
+
+
+inline void ArchiveStrategy::setDeleteStatement()
+{
+	_pDeleteStatement = new Statement(*_pSession);
+}
+
+
+inline void ArchiveStrategy::setCountStatement()
+{
+	_pCountStatement = new Statement(*_pSession);
+}
+
+
+inline Statement& ArchiveStrategy::getCopyStatement()
+{
+	return *_pCopyStatement;
+}
+
+
+inline Statement& ArchiveStrategy::getDeleteStatement()
+{
+	return *_pDeleteStatement;
+}
+
+
+inline Statement& ArchiveStrategy::getCountStatement()
+{
+	return *_pCountStatement;
+}
+
+
+
+//
+// ArchiveByAgeStrategy
+//
+class Data_API ArchiveByAgeStrategy: public ArchiveStrategy
+	/// Archives rows scheduled for archiving.
+{
+public:
+	ArchiveByAgeStrategy(const std::string& connector, 
+		const std::string& connect, 
+		const std::string& sourceTable, 
+		const std::string& destinationTable = DEFAULT_ARCHIVE_DESTINATION);
+	
+	~ArchiveByAgeStrategy();
+
+	void archive();
+
+	const std::string& getThreshold() const;
+		/// Returns the archive threshold.
+
+	void setThreshold(const std::string& threshold);
+		/// Sets the archive threshold.
+
+private:
+	ArchiveByAgeStrategy();
+	ArchiveByAgeStrategy(const ArchiveByAgeStrategy&);
+	ArchiveByAgeStrategy& operator = (const ArchiveByAgeStrategy&);
+
+	void initStatements();
+
+	Timespan     _maxAge;
+	std::string  _ageString;
+	DateTime     _archiveDateTime;
+	Poco::Dynamic::Var _archiveCount;
+};
+
+
+//
+// inlines
+//
+
+inline const std::string& ArchiveByAgeStrategy::getThreshold() const
+{
+	return _ageString;
+}
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_ArchiveStrategy_INCLUDED

base/poco/Data/include/Poco/Data/AutoTransaction.h

@@ -0,0 +1,35 @@
+//
+// AutoTransaction.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  AutoTransaction
+//
+// Forward header for the Transaction class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+
+#ifndef Data_AutoTransaction_INCLUDED
+#define Data_AutoTransaction_INCLUDED
+
+
+#include "Poco/Data/Transaction.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+typedef Transaction AutoTransaction;
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_AutoTransaction_INCLUDED