Major plugin refactor and cleanup.

Switched to POCO library for unified platform/library interface.
Deprecated the external module API. It was creating more problems than solving.
Removed most built-in libraries in favor of system libraries for easier maintenance.
Cleaned and secured code with help from static analyzers.

vendor/POCO/ApacheConnector/src/ApacheApplication.cpp

@@ -0,0 +1,53 @@
+//
+// ApacheApplication.cpp
+//
+// Copyright (c) 2006-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "ApacheApplication.h"
+#include "ApacheChannel.h"
+#include "Poco/Logger.h"
+#include "Poco/SingletonHolder.h"
+#include <vector>
+
+
+using Poco::Logger;
+using Poco::FastMutex;
+
+
+ApacheApplication::ApacheApplication():
+	_ready(false)
+{
+	Logger::root().setChannel(new ApacheChannel);
+}
+
+
+ApacheApplication::~ApacheApplication()
+{
+	Logger::shutdown();
+}
+
+
+void ApacheApplication::setup()
+{
+	FastMutex::ScopedLock lock(_mutex);
+	
+	if (!_ready)
+	{
+		std::vector<std::string> cmdLine;
+		cmdLine.push_back("mod_poco");
+		init(cmdLine);
+		_ready = true;
+	}
+}
+
+
+ApacheApplication& ApacheApplication::instance()
+{
+	static Poco::SingletonHolder<ApacheApplication> sh;
+	return *sh.get();
+}

vendor/POCO/ApacheConnector/src/ApacheChannel.cpp

@@ -0,0 +1,29 @@
+//
+// ApacheApplication.cpp
+//
+// Copyright (c) 2006-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "ApacheChannel.h"
+#include "ApacheConnector.h"
+#include "Poco/Message.h"
+
+
+ApacheChannel::ApacheChannel()
+{
+}
+
+
+ApacheChannel::~ApacheChannel()
+{
+}
+
+
+void ApacheChannel::log(const Poco::Message& msg)
+{
+	ApacheConnector::log(msg.getSource().c_str(), 0, msg.getPriority(), 0, msg.getText().c_str());
+}

vendor/POCO/ApacheConnector/src/ApacheConnector.cpp

@@ -0,0 +1,315 @@
+//
+// ApacheConnector.cpp
+//
+// Copyright (c) 2006-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "ApacheConnector.h"
+#include "ApacheApplication.h"
+#include "ApacheServerRequest.h"
+#include "ApacheServerResponse.h"
+#include "ApacheRequestHandlerFactory.h"
+#include "Poco/Net/HTTPRequestHandler.h"
+#include <memory>
+#include "httpd.h"
+#include "http_connection.h"
+#include "http_config.h"
+#include "http_core.h"
+#include "http_protocol.h"
+#include "http_log.h"
+#include "apr.h"
+#include "apr_lib.h"
+#include "apr_strings.h"
+#include "apr_buckets.h"
+#include "apr_file_info.h"
+#include "apr_hash.h"
+#define APR_WANT_STRFUNC
+#include "apr_want.h"
+#include "http_request.h"
+#include "util_filter.h"
+
+
+using Poco::Net::HTTPServerRequest;
+using Poco::Net::HTTPServerResponse;
+using Poco::Net::HTTPRequestHandler;
+using Poco::Net::HTTPResponse;
+
+
+extern "C" module AP_MODULE_DECLARE_DATA poco_module;
+
+
+ApacheRequestRec::ApacheRequestRec(request_rec* pRec):
+	_pRec(pRec)
+{
+}
+
+
+bool ApacheRequestRec::haveRequestBody()
+{
+	return ap_should_client_block(_pRec) != 0;
+}
+
+
+int ApacheRequestRec::readRequest(char* buffer, int length)
+{
+	return ap_get_client_block(_pRec, buffer, length);
+}
+
+
+void ApacheRequestRec::writeResponse(const char* buffer, int length)
+{
+	ap_rwrite(buffer, length, _pRec);
+}
+
+
+void ApacheRequestRec::redirect(const std::string& uri, int status)
+{
+	apr_table_set(_pRec->headers_out, "Location", uri.c_str());
+	_pRec->connection->keepalive = AP_CONN_CLOSE;
+	_pRec->status = status;
+	ap_set_keepalive(_pRec);
+	ap_send_error_response(_pRec, 0);
+}
+
+
+void ApacheRequestRec::sendErrorResponse(int status)
+{
+	_pRec->connection->keepalive = AP_CONN_CLOSE;
+	_pRec->status = status;
+	ap_set_keepalive(_pRec);
+
+	ap_send_error_response(_pRec, 0);
+}
+
+
+void ApacheRequestRec::addHeader(const std::string& key, const std::string& value)
+{
+	const apr_array_header_t *arr = apr_table_elts(_pRec->headers_out);
+	apr_table_add(const_cast<apr_table_t*>(reinterpret_cast<const apr_table_t*>(arr)), key.c_str(), value.c_str());
+}
+
+
+void ApacheRequestRec::setContentType(const std::string& mediaType)
+{
+	ap_set_content_type(_pRec, mediaType.c_str());
+}
+
+
+int ApacheRequestRec::sendFile(const std::string& path, unsigned int fileSize, const std::string& mediaType)
+{
+	apr_file_t *thefile = 0;
+	apr_finfo_t finfo;
+	apr_size_t nBytes;
+
+	// setting content-type
+	ap_set_content_type(_pRec, mediaType.c_str());
+
+	// opening file
+	if (apr_file_open(&thefile, path.c_str(), APR_READ, APR_UREAD | APR_GREAD, _pRec->pool) == APR_SUCCESS)
+	{
+		// getting fileinfo
+		apr_file_info_get(&finfo, APR_FINFO_NORM, thefile);
+
+		// setting last-updated & co
+		ap_update_mtime(_pRec, finfo.mtime);
+		ap_set_last_modified(_pRec);
+		ap_set_content_length(_pRec, fileSize);
+
+		// sending file
+		ap_send_fd(thefile, _pRec, 0, fileSize, &nBytes);
+
+		// well done
+		return 0;
+	}
+
+	// file not opened successfully -> produce an exception in C++ code
+	return 1;
+}
+
+
+bool ApacheRequestRec::secure()
+{
+	return DEFAULT_HTTPS_PORT == ap_default_port(_pRec) && ap_http_scheme(_pRec) == "https";
+}
+
+
+void ApacheRequestRec::setStatus(int status)
+{
+	_pRec->status = status;
+}
+
+
+void ApacheRequestRec::copyHeaders(ApacheServerRequest& request)
+{
+	const apr_array_header_t* arr = apr_table_elts(_pRec->headers_in);
+	const apr_table_entry_t* elts = (const apr_table_entry_t *)arr->elts;
+
+	request.setMethod(_pRec->method);
+	request.setURI(_pRec->unparsed_uri);
+
+	// iterating over raw-headers and printing them
+	for (int i = 0; i < arr->nelts; i++)
+	{
+		request.add(elts[i].key, elts[i].val);
+	}
+}
+
+
+void ApacheConnector::log(const char* file, int line, int level, int status, const char *text)
+{
+	// ap_log_error() has undergone significant changes in Apache 2.4.
+	// Validate Apache version for using a proper ap_log_error() version.
+#if AP_SERVER_MAJORVERSION_NUMBER == 2 && AP_SERVER_MINORVERSION_NUMBER < 4
+		ap_log_error(file, line, level, 0, NULL, "%s", text);
+#else
+	ap_log_error(file, line, level, 0, 0, 0, text);
+#endif
+}
+
+
+extern "C" int ApacheConnector_handler(request_rec *r)
+{
+	ApacheRequestRec rec(r);
+	ApacheApplication& app(ApacheApplication::instance());
+
+	try
+	{
+		// ensure application is ready
+		app.setup();
+
+		// if the ApacheRequestHandler declines handling - we stop
+		// request handling here and let other modules do their job!
+		if (!app.factory().mustHandle(r->uri))
+			return DECLINED;
+
+	    apr_status_t rv;
+		if ((rv = ap_setup_client_block(r, REQUEST_CHUNKED_DECHUNK)))
+			return rv;
+
+                // The properties conn_rec->remote_ip and conn_rec->remote_addr have undergone significant changes in Apache 2.4.
+                // Validate Apache version for using conn_rec->remote_ip and conn_rec->remote_addr proper versions.
+#if AP_SERVER_MAJORVERSION_NUMBER == 2 && AP_SERVER_MINORVERSION_NUMBER < 4
+                const char* clientIp = r->connection->remote_ip;
+                apr_port_t clientPort = r->connection->remote_addr->port;
+#else
+                const char* clientIp = r->connection->client_ip;
+                apr_port_t clientPort = r->connection->client_addr->port;
+#endif
+                std::unique_ptr<ApacheServerRequest> pRequest(new ApacheServerRequest(
+                        &rec,
+                        r->connection->local_ip,
+                        r->connection->local_addr->port,
+                        clientIp,
+                        clientPort));
+
+                std::unique_ptr<ApacheServerResponse> pResponse(new ApacheServerResponse(pRequest.get()));
+
+		// add header information to request
+		rec.copyHeaders(*pRequest);
+
+		try
+		{
+
+			std::unique_ptr<HTTPRequestHandler> pHandler(app.factory().createRequestHandler(*pRequest));
+
+			if (pHandler.get())
+			{
+				pHandler->handleRequest(*pRequest, *pResponse);
+			}
+			else
+			{
+				pResponse->sendErrorResponse(HTTP_NOT_IMPLEMENTED);
+			}
+		}
+		catch (...)
+		{
+			pResponse->sendErrorResponse(HTTP_INTERNAL_SERVER_ERROR);
+			throw;
+		}
+	}
+	catch (Poco::Exception& exc)
+	{
+		ApacheConnector::log(__FILE__, __LINE__, ApacheConnector::PRIO_ERROR, 0, exc.displayText().c_str());
+	}
+	catch (...)
+	{
+		ApacheConnector::log(__FILE__, __LINE__, ApacheConnector::PRIO_ERROR, 0, "Unknown exception");
+	}
+	return OK;
+}
+
+
+extern "C" void ApacheConnector_register_hooks(apr_pool_t *p)
+{
+	ap_hook_handler(ApacheConnector_handler, NULL, NULL, APR_HOOK_MIDDLE);
+}
+
+
+extern "C" const char* ApacheConnector_uris(cmd_parms *cmd, void *in_dconf, const char *in_str)
+{
+	try
+	{
+		ApacheApplication::instance().factory().handleURIs(in_str);
+	}
+	catch (Poco::Exception& exc)
+	{
+		ApacheConnector::log(__FILE__, __LINE__, ApacheConnector::PRIO_ERROR, 0, exc.displayText().c_str());
+	}
+	catch (...)
+	{
+		ApacheConnector::log(__FILE__, __LINE__, ApacheConnector::PRIO_ERROR, 0, "Unknown exception");
+	}
+    return 0;
+}
+
+
+extern "C" const char* ApacheConnector_config(cmd_parms *cmd, void *in_dconf, const char *in_str)
+{
+	try
+	{
+		ApacheApplication::instance().loadConfiguration(in_str);
+	}
+	catch (Poco::Exception& exc)
+	{
+		ApacheConnector::log(__FILE__, __LINE__, ApacheConnector::PRIO_ERROR, 0, exc.displayText().c_str());
+	}
+	catch (...)
+	{
+		ApacheConnector::log(__FILE__, __LINE__, ApacheConnector::PRIO_ERROR, 0, "Unknown exception");
+	}
+    return 0;
+}
+
+
+extern "C" const command_rec ApacheConnector_cmds[] =
+{
+    AP_INIT_RAW_ARGS(
+		"AddPocoRequestHandler",
+		reinterpret_cast<cmd_func>(ApacheConnector_uris),
+		NULL,
+		RSRC_CONF,
+		"POCO RequestHandlerFactory class name followed by shared library path followed by a list of ' ' separated URIs that must be handled by this module."),
+    AP_INIT_RAW_ARGS(
+		"AddPocoConfig",
+		reinterpret_cast<cmd_func>(ApacheConnector_config),
+		NULL,
+		RSRC_CONF,
+		"Path of the POCO configuration file."),
+    { NULL }
+};
+
+
+module AP_MODULE_DECLARE_DATA poco_module =
+{
+	STANDARD20_MODULE_STUFF,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	ApacheConnector_cmds,
+	ApacheConnector_register_hooks
+};

vendor/POCO/ApacheConnector/src/ApacheRequestHandlerFactory.cpp

@@ -0,0 +1,114 @@
+//
+// ApacheRequestHandlerFactory.cpp
+//
+// Copyright (c) 2006-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "ApacheRequestHandlerFactory.h"
+#include "ApacheConnector.h"
+#include "Poco/Net/HTTPRequestHandler.h"
+#include "Poco/StringTokenizer.h"
+#include "Poco/Manifest.h"
+#include "Poco/File.h"
+#include <vector>
+
+
+using Poco::StringTokenizer;
+using Poco::FastMutex;
+
+
+ApacheRequestHandlerFactory::ApacheRequestHandlerFactory()
+{
+}
+
+
+ApacheRequestHandlerFactory::~ApacheRequestHandlerFactory()
+{
+}
+
+
+Poco::Net::HTTPRequestHandler* ApacheRequestHandlerFactory::createRequestHandler(const Poco::Net::HTTPServerRequest& request)
+{
+	FastMutex::ScopedLock lock(_mutex);
+	
+	// only if the given uri is found in _uris we are
+	// handling this request.
+	RequestHandlerFactories::iterator it = _requestHandlers.begin();
+	RequestHandlerFactories::iterator itEnd = _requestHandlers.end();
+	std::string uri = request.getURI();
+
+	// if any uri in our map is found at the beginning of the given
+	// uri -> then we handle it!!
+	for (; it != itEnd; it++)
+	{
+		if (uri.find(it->first) == 0 || it->first.find(uri) == 0)
+		{
+			return it->second->createRequestHandler(request);
+		}
+	}
+
+	return 0;
+}
+
+
+void ApacheRequestHandlerFactory::handleURIs(const std::string& uris)
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	StringTokenizer st(uris, " ", StringTokenizer::TOK_TRIM);
+	StringTokenizer::Iterator it = st.begin();
+	StringTokenizer::Iterator itEnd = st.end();
+	std::string factoryName = (*it);
+	it++;
+	std::string dllName = (*it);
+	it++;
+
+	for (; it != itEnd; it++)
+	{
+		addRequestHandlerFactory(dllName, factoryName, *it);
+	}
+}
+
+
+void ApacheRequestHandlerFactory::addRequestHandlerFactory(const std::string& dllPath, const std::string& factoryName, const std::string& uri)
+{	
+	try
+	{
+		_loader.loadLibrary(dllPath);
+		Poco::Net::HTTPRequestHandlerFactory* pFactory = _loader.classFor(factoryName).create();
+		_requestHandlers.insert(std::make_pair(uri, pFactory));
+	}
+	catch (Poco::Exception& exc)
+	{
+		ApacheConnector::log(__FILE__, __LINE__, ApacheConnector::PRIO_ERROR, 0, exc.displayText().c_str());
+	}
+}
+
+
+bool ApacheRequestHandlerFactory::mustHandle(const std::string& uri)
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	// only if the given uri is found in _uris we are
+	// handling this request.
+	RequestHandlerFactories::iterator it = _requestHandlers.begin();
+	RequestHandlerFactories::iterator itEnd = _requestHandlers.end();
+
+	// if any uri in our map is found at the beginning of the given
+	// uri -> then we handle it!!
+	for (; it != itEnd; it++)
+	{
+		// dealing with both cases:
+		// handler is registered with: /download
+		// uri: /download/xyz
+		// uri: /download
+		if (uri.find(it->first) == 0 || it->first.find(uri) == 0)
+			return true;
+	}
+
+	return false;
+}

vendor/POCO/ApacheConnector/src/ApacheServerRequest.cpp

@@ -0,0 +1,66 @@
+//
+// ApacheServerRequest.cpp
+//
+// Copyright (c) 2006-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "ApacheServerRequest.h"
+#include "ApacheServerResponse.h"
+#include "ApacheRequestHandlerFactory.h"
+#include "Poco/Exception.h"
+#include <set>
+
+
+ApacheServerRequest::ApacheServerRequest(
+	ApacheRequestRec* pApacheRequest, 
+	const char* serverName, 
+	int serverPort, 
+	const char* clientName, 
+	int clientPort):
+	_pApacheRequest(pApacheRequest),
+    _pResponse(0),
+    _pStream(new ApacheInputStream(_pApacheRequest)),
+	_serverAddress(serverName, serverPort),
+	_clientAddress(clientName, clientPort)
+{
+}
+
+
+ApacheServerRequest::~ApacheServerRequest()
+{
+	delete _pStream;
+}
+
+
+const Poco::Net::HTTPServerParams& ApacheServerRequest::serverParams() const
+{
+	throw Poco::NotImplementedException("No HTTPServerParams available in Apache modules.");
+}
+
+
+Poco::Net::HTTPServerResponse& ApacheServerRequest::response() const
+{
+	return *_pResponse;
+}
+
+
+void ApacheServerRequest::setResponse(ApacheServerResponse* pResponse)
+{
+	_pResponse = pResponse;
+}
+
+
+bool ApacheServerRequest::expectContinue() const
+{
+	return false;
+}
+
+
+bool ApacheServerRequest::secure() const
+{
+	return _pApacheRequest->secure();
+}

vendor/POCO/ApacheConnector/src/ApacheServerResponse.cpp

@@ -0,0 +1,137 @@
+//
+// ApacheServerResponse.cpp
+//
+// Copyright (c) 2006-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "ApacheServerResponse.h"
+#include "ApacheServerRequest.h"
+#include "ApacheStream.h"
+#include "ApacheConnector.h"
+#include "Poco/Net/HTTPCookie.h"
+#include "Poco/File.h"
+#include "Poco/Exception.h"
+#include <fstream>
+#include <vector>
+
+
+using Poco::File;
+using Poco::OpenFileException;
+using Poco::Net::HTTPCookie;
+
+
+ApacheServerResponse::ApacheServerResponse(ApacheServerRequest* pRequest):
+	_pStream(0),
+	_pApacheRequest(pRequest->_pApacheRequest)
+{
+	setVersion(pRequest->getVersion());
+	setKeepAlive(pRequest->getKeepAlive());
+
+	pRequest->setResponse(this);
+}
+
+
+ApacheServerResponse::~ApacheServerResponse()
+{
+	delete _pStream;
+}
+
+
+void ApacheServerResponse::initApacheOutputStream()
+{
+	poco_assert (!_pStream);
+
+	_pApacheRequest->setContentType(getContentType());
+
+	int statusCode = static_cast<std::underlying_type<Poco::Net::HTTPResponse::HTTPStatus>::type>(getStatus());
+	_pApacheRequest->setStatus(statusCode);
+
+	std::vector<HTTPCookie> cookies;
+	getCookies(cookies);
+	
+	std::size_t cnt = cookies.size();
+	for (int c = 0; c < cnt; c++)
+	{
+		_pApacheRequest->addHeader("Set-Cookie", cookies[c].toString());
+	}
+
+	for (Poco::Net::NameValueCollection::ConstIterator it = begin(); it != end(); ++it)
+	{
+		_pApacheRequest->addHeader(it->first, it->second);
+	}
+
+	_pStream = new ApacheOutputStream(_pApacheRequest);
+}
+
+
+void ApacheServerResponse::sendContinue()
+{
+	// should be handled by Apache
+}
+
+
+std::ostream& ApacheServerResponse::send()
+{
+	poco_assert (!_pStream);
+		
+	initApacheOutputStream();
+
+	return *_pStream;
+}
+
+
+void ApacheServerResponse::sendFile(const std::string& path, const std::string& mediaType)
+{
+	poco_assert (!_pStream);
+
+	initApacheOutputStream();
+
+	File f(path);
+	if (_pApacheRequest->sendFile(path, static_cast<unsigned int>(f.getSize()), mediaType) != 0)
+		throw OpenFileException(path);
+}
+
+
+void ApacheServerResponse::sendBuffer(const void* pBuffer, std::size_t length)
+{
+	poco_assert (!_pStream);
+
+	initApacheOutputStream();
+
+	_pStream->write(static_cast<const char*>(pBuffer), static_cast<std::streamsize>(length));
+}
+
+
+void ApacheServerResponse::redirect(const std::string& uri, HTTPStatus status)
+{
+	poco_assert (!_pStream);
+
+	initApacheOutputStream();
+
+	try
+	{
+		_pApacheRequest->redirect(uri, status);
+	}
+	catch (Poco::Exception&)
+	{
+		ApacheConnector::log(__FILE__, __LINE__, 7 , 0, "caught exception in ApacheServerResponse::redirect - ignoring\n");
+	}
+}
+
+
+void ApacheServerResponse::sendErrorResponse(int status)
+{		
+	initApacheOutputStream();
+
+	_pApacheRequest->sendErrorResponse(status);
+}
+
+
+void ApacheServerResponse::requireAuthentication(const std::string& realm)
+{
+	// should be handled by Apache
+}

vendor/POCO/ApacheConnector/src/ApacheStream.cpp

@@ -0,0 +1,120 @@
+//
+// ApacheStream.h
+//
+// Copyright (c) 2006-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "ApacheStream.h"
+#include "ApacheConnector.h"
+#include "Poco/Exception.h"
+
+
+using Poco::BufferedStreamBuf;
+
+
+//
+// ApacheStreamBuf
+//
+
+
+ApacheStreamBuf::ApacheStreamBuf(ApacheRequestRec* pApacheRequest, bool haveData): 
+	BufferedStreamBuf(STREAM_BUFFER_SIZE, std::ios::in | std::ios::out),
+	_pApacheRequest(pApacheRequest),
+	_haveData(haveData)
+{
+}
+
+
+ApacheStreamBuf::~ApacheStreamBuf()
+{
+}
+
+
+int ApacheStreamBuf::readFromDevice(char* buffer, std::streamsize len)
+{
+	if (_haveData)
+		return _pApacheRequest->readRequest(buffer, static_cast<int>(len));
+	else
+		return 0;
+}
+
+
+int ApacheStreamBuf::writeToDevice(const char* buffer, std::streamsize length)
+{
+	_pApacheRequest->writeResponse(buffer, length);
+	return length;
+}
+
+
+//
+// ApacheIOS
+//
+
+
+ApacheIOS::ApacheIOS(ApacheRequestRec* pApacheRequest, bool haveData):
+	_buf(pApacheRequest, haveData)
+{
+	poco_ios_init(&_buf);
+}
+
+
+ApacheIOS::~ApacheIOS()
+{
+	try
+	{
+		_buf.sync();
+	}
+	catch (...)
+	{
+	}
+}
+
+
+ApacheStreamBuf* ApacheIOS::rdbuf()
+{
+	return &_buf;
+}
+
+
+void ApacheIOS::close()
+{
+	_buf.sync();
+}
+
+
+//
+// ApacheOutputStream
+//
+
+
+ApacheOutputStream::ApacheOutputStream(ApacheRequestRec* pApacheRequest):
+	ApacheIOS(pApacheRequest),
+	std::ostream(&_buf)
+{
+}
+
+
+ApacheOutputStream::~ApacheOutputStream()
+{
+}
+
+
+//
+// ApacheInputStream
+//
+
+
+ApacheInputStream::ApacheInputStream(ApacheRequestRec* pApacheRequest):
+	ApacheIOS(pApacheRequest, pApacheRequest->haveRequestBody()),
+	std::istream(&_buf)
+{
+}
+
+
+ApacheInputStream::~ApacheInputStream()
+{
+}