fix conflict

.github/workflows/backport_branches.yml

@@ -512,6 +512,75 @@ jobs:
           docker ps --quiet | xargs --no-run-if-empty docker kill ||:
           docker ps --all --quiet | xargs --no-run-if-empty docker rm -f ||:
           sudo rm -fr "$TEMP_PATH"
+############################################################################################
+#################################### INSTALL PACKAGES ######################################
+############################################################################################
+  InstallPackagesTestRelease:
+    needs: [BuilderDebRelease]
+    runs-on: [self-hosted, style-checker]
+    steps:
+      - name: Set envs
+        run: |
+          cat >> "$GITHUB_ENV" << 'EOF'
+          TEMP_PATH=${{runner.temp}}/test_install
+          REPORTS_PATH=${{runner.temp}}/reports_dir
+          CHECK_NAME=Install packages (amd64)
+          REPO_COPY=${{runner.temp}}/test_install/ClickHouse
+          EOF
+      - name: Download json reports
+        uses: actions/download-artifact@v3
+        with:
+          path: ${{ env.REPORTS_PATH }}
+      - name: Check out repository code
+        uses: ClickHouse/checkout@v1
+        with:
+          clear-repository: true
+      - name: Test packages installation
+        run: |
+          sudo rm -fr "$TEMP_PATH"
+          mkdir -p "$TEMP_PATH"
+          cp -r "$GITHUB_WORKSPACE" "$TEMP_PATH"
+          cd "$REPO_COPY/tests/ci"
+          python3 install_check.py "$CHECK_NAME"
+      - name: Cleanup
+        if: always()
+        run: |
+          docker ps --quiet | xargs --no-run-if-empty docker kill ||:
+          docker ps --all --quiet | xargs --no-run-if-empty docker rm -f ||:
+          sudo rm -fr "$TEMP_PATH"
+  InstallPackagesTestAarch64:
+    needs: [BuilderDebRelease]
+    runs-on: [self-hosted, style-checker-aarch64]
+    steps:
+      - name: Set envs
+        run: |
+          cat >> "$GITHUB_ENV" << 'EOF'
+          TEMP_PATH=${{runner.temp}}/test_install
+          REPORTS_PATH=${{runner.temp}}/reports_dir
+          CHECK_NAME=Install packages (arm64)
+          REPO_COPY=${{runner.temp}}/test_install/ClickHouse
+          EOF
+      - name: Download json reports
+        uses: actions/download-artifact@v3
+        with:
+          path: ${{ env.REPORTS_PATH }}
+      - name: Check out repository code
+        uses: ClickHouse/checkout@v1
+        with:
+          clear-repository: true
+      - name: Test packages installation
+        run: |
+          sudo rm -fr "$TEMP_PATH"
+          mkdir -p "$TEMP_PATH"
+          cp -r "$GITHUB_WORKSPACE" "$TEMP_PATH"
+          cd "$REPO_COPY/tests/ci"
+          python3 install_check.py "$CHECK_NAME"
+      - name: Cleanup
+        if: always()
+        run: |
+          docker ps --quiet | xargs --no-run-if-empty docker kill ||:
+          docker ps --all --quiet | xargs --no-run-if-empty docker rm -f ||:
+          sudo rm -fr "$TEMP_PATH"
 ##############################################################################################
 ########################### FUNCTIONAl STATELESS TESTS #######################################
 ##############################################################################################

.github/workflows/master.yml

@@ -946,6 +946,75 @@ jobs:
         run: |
           cd "$GITHUB_WORKSPACE/tests/ci"
           python3 mark_release_ready.py
+############################################################################################
+#################################### INSTALL PACKAGES ######################################
+############################################################################################
+  InstallPackagesTestRelease:
+    needs: [BuilderDebRelease]
+    runs-on: [self-hosted, style-checker]
+    steps:
+      - name: Set envs
+        run: |
+          cat >> "$GITHUB_ENV" << 'EOF'
+          TEMP_PATH=${{runner.temp}}/test_install
+          REPORTS_PATH=${{runner.temp}}/reports_dir
+          CHECK_NAME=Install packages (amd64)
+          REPO_COPY=${{runner.temp}}/test_install/ClickHouse
+          EOF
+      - name: Download json reports
+        uses: actions/download-artifact@v3
+        with:
+          path: ${{ env.REPORTS_PATH }}
+      - name: Check out repository code
+        uses: ClickHouse/checkout@v1
+        with:
+          clear-repository: true
+      - name: Test packages installation
+        run: |
+          sudo rm -fr "$TEMP_PATH"
+          mkdir -p "$TEMP_PATH"
+          cp -r "$GITHUB_WORKSPACE" "$TEMP_PATH"
+          cd "$REPO_COPY/tests/ci"
+          python3 install_check.py "$CHECK_NAME"
+      - name: Cleanup
+        if: always()
+        run: |
+          docker ps --quiet | xargs --no-run-if-empty docker kill ||:
+          docker ps --all --quiet | xargs --no-run-if-empty docker rm -f ||:
+          sudo rm -fr "$TEMP_PATH"
+  InstallPackagesTestAarch64:
+    needs: [BuilderDebRelease]
+    runs-on: [self-hosted, style-checker-aarch64]
+    steps:
+      - name: Set envs
+        run: |
+          cat >> "$GITHUB_ENV" << 'EOF'
+          TEMP_PATH=${{runner.temp}}/test_install
+          REPORTS_PATH=${{runner.temp}}/reports_dir
+          CHECK_NAME=Install packages (arm64)
+          REPO_COPY=${{runner.temp}}/test_install/ClickHouse
+          EOF
+      - name: Download json reports
+        uses: actions/download-artifact@v3
+        with:
+          path: ${{ env.REPORTS_PATH }}
+      - name: Check out repository code
+        uses: ClickHouse/checkout@v1
+        with:
+          clear-repository: true
+      - name: Test packages installation
+        run: |
+          sudo rm -fr "$TEMP_PATH"
+          mkdir -p "$TEMP_PATH"
+          cp -r "$GITHUB_WORKSPACE" "$TEMP_PATH"
+          cd "$REPO_COPY/tests/ci"
+          python3 install_check.py "$CHECK_NAME"
+      - name: Cleanup
+        if: always()
+        run: |
+          docker ps --quiet | xargs --no-run-if-empty docker kill ||:
+          docker ps --all --quiet | xargs --no-run-if-empty docker rm -f ||:
+          sudo rm -fr "$TEMP_PATH"
 ##############################################################################################
 ########################### FUNCTIONAl STATELESS TESTS #######################################
 ##############################################################################################

.github/workflows/release_branches.yml

@@ -604,6 +604,75 @@ jobs:
         run: |
           cd "$GITHUB_WORKSPACE/tests/ci"
           python3 mark_release_ready.py
+############################################################################################
+#################################### INSTALL PACKAGES ######################################
+############################################################################################
+  InstallPackagesTestRelease:
+    needs: [BuilderDebRelease]
+    runs-on: [self-hosted, style-checker]
+    steps:
+      - name: Set envs
+        run: |
+          cat >> "$GITHUB_ENV" << 'EOF'
+          TEMP_PATH=${{runner.temp}}/test_install
+          REPORTS_PATH=${{runner.temp}}/reports_dir
+          CHECK_NAME=Install packages (amd64)
+          REPO_COPY=${{runner.temp}}/test_install/ClickHouse
+          EOF
+      - name: Download json reports
+        uses: actions/download-artifact@v3
+        with:
+          path: ${{ env.REPORTS_PATH }}
+      - name: Check out repository code
+        uses: ClickHouse/checkout@v1
+        with:
+          clear-repository: true
+      - name: Test packages installation
+        run: |
+          sudo rm -fr "$TEMP_PATH"
+          mkdir -p "$TEMP_PATH"
+          cp -r "$GITHUB_WORKSPACE" "$TEMP_PATH"
+          cd "$REPO_COPY/tests/ci"
+          python3 install_check.py "$CHECK_NAME"
+      - name: Cleanup
+        if: always()
+        run: |
+          docker ps --quiet | xargs --no-run-if-empty docker kill ||:
+          docker ps --all --quiet | xargs --no-run-if-empty docker rm -f ||:
+          sudo rm -fr "$TEMP_PATH"
+  InstallPackagesTestAarch64:
+    needs: [BuilderDebRelease]
+    runs-on: [self-hosted, style-checker-aarch64]
+    steps:
+      - name: Set envs
+        run: |
+          cat >> "$GITHUB_ENV" << 'EOF'
+          TEMP_PATH=${{runner.temp}}/test_install
+          REPORTS_PATH=${{runner.temp}}/reports_dir
+          CHECK_NAME=Install packages (arm64)
+          REPO_COPY=${{runner.temp}}/test_install/ClickHouse
+          EOF
+      - name: Download json reports
+        uses: actions/download-artifact@v3
+        with:
+          path: ${{ env.REPORTS_PATH }}
+      - name: Check out repository code
+        uses: ClickHouse/checkout@v1
+        with:
+          clear-repository: true
+      - name: Test packages installation
+        run: |
+          sudo rm -fr "$TEMP_PATH"
+          mkdir -p "$TEMP_PATH"
+          cp -r "$GITHUB_WORKSPACE" "$TEMP_PATH"
+          cd "$REPO_COPY/tests/ci"
+          python3 install_check.py "$CHECK_NAME"
+      - name: Cleanup
+        if: always()
+        run: |
+          docker ps --quiet | xargs --no-run-if-empty docker kill ||:
+          docker ps --all --quiet | xargs --no-run-if-empty docker rm -f ||:
+          sudo rm -fr "$TEMP_PATH"
 ##############################################################################################
 ########################### FUNCTIONAl STATELESS TESTS #######################################
 ##############################################################################################

.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

README.md

@@ -15,6 +15,7 @@ ClickHouse® is an open-source column-oriented database management system that a
 * [Code Browser (github.dev)](https://github.dev/ClickHouse/ClickHouse) with syntax highlight, powered by github.dev.
 * [Contacts](https://clickhouse.com/company/contact) can help to get your questions answered if there are any.
 
-## Upcoming events
+## Events
+* **FOSDEM 2023**: In the "Fast and Streaming Data" room Alexey gave a talk entitled "Building Analytical Apps With ClickHouse" that looks at the landscape of data tools, an interesting data set, and how you can interact with data quickly. Check out the recording on **[YouTube](https://www.youtube.com/watch?v=JlcI2Vfz_uk)**.
 * **Recording available**: [**v23.1 Release Webinar**](https://www.youtube.com/watch?v=zYSZXBnTMSE) 23.1 is the ClickHouse New Year release. Original creator, co-founder, and CTO of ClickHouse Alexey Milovidov will walk us through the highlights of the release. Inverted indices, query cache, and so -- very -- much more.
 * **Recording available**: [**ClickHouse Meetup at the CHEQ office in Tel Aviv**](https://www.meetup.com/clickhouse-tel-aviv-user-group/events/289599423/) - We are very excited to be holding our next in-person ClickHouse meetup at the CHEQ office in Tel Aviv! Hear from CHEQ, ServiceNow and Contentsquare, as well as a deep dive presentation from ClickHouse CTO Alexey Milovidov. Join us for a fun evening of talks, food and discussion!

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