Remove Crypto++ library

The tracked version of Crypto++ is going on 10 years old and doesn't
always compile properly on modern tooling.

This removes the entire subdirectory as well as references to files in
the build script.  Due to the number of files touched by this commit, I
opt to add its replacement in the next commit.

Signed-off-by: Malfurious <m@lfurio.us>

1 files changed, 0 insertions, 397 deletions

diff --git a/cryptopp562/wait.cpp b/cryptopp562/wait.cpp
deleted file mode 100644
index 1987858..0000000
--- a/cryptopp562/wait.cpp
+++ /dev/null
@@ -1,397 +0,0 @@
-// wait.cpp - written and placed in the public domain by Wei Dai
-
-#include "pch.h"
-#include "wait.h"
-#include "misc.h"
-
-#ifdef SOCKETS_AVAILABLE
-
-#ifdef USE_BERKELEY_STYLE_SOCKETS
-#include <errno.h>
-#include <sys/types.h>
-#include <sys/time.h>
-#include <unistd.h>
-#endif
-
-NAMESPACE_BEGIN(CryptoPP)
-
-unsigned int WaitObjectContainer::MaxWaitObjects()
-{
-#ifdef USE_WINDOWS_STYLE_SOCKETS
-	return MAXIMUM_WAIT_OBJECTS * (MAXIMUM_WAIT_OBJECTS-1);
-#else
-	return FD_SETSIZE;
-#endif
-}
-
-WaitObjectContainer::WaitObjectContainer(WaitObjectsTracer* tracer)
-	: m_tracer(tracer), m_eventTimer(Timer::MILLISECONDS)
-	, m_sameResultCount(0), m_noWaitTimer(Timer::MILLISECONDS)
-{
-	Clear();
-	m_eventTimer.StartTimer();
-}
-
-void WaitObjectContainer::Clear()
-{
-#ifdef USE_WINDOWS_STYLE_SOCKETS
-	m_handles.clear();
-#else
-	m_maxFd = 0;
-	FD_ZERO(&m_readfds);
-	FD_ZERO(&m_writefds);
-#endif
-	m_noWait = false;
-	m_firstEventTime = 0;
-}
-
-inline void WaitObjectContainer::SetLastResult(LastResultType result)
-{
-	if (result == m_lastResult)
-		m_sameResultCount++;
-	else
-	{
-		m_lastResult = result;
-		m_sameResultCount = 0;
-	}
-}
-
-void WaitObjectContainer::DetectNoWait(LastResultType result, CallStack const& callStack)
-{
-	if (result == m_lastResult && m_noWaitTimer.ElapsedTime() > 1000)
-	{
-		if (m_sameResultCount > m_noWaitTimer.ElapsedTime())
-		{
-			if (m_tracer)
-			{
-				std::string desc = "No wait loop detected - m_lastResult: ";
-				desc.append(IntToString(m_lastResult)).append(", call stack:");
-				for (CallStack const* cs = &callStack; cs; cs = cs->Prev())
-					desc.append("\n- ").append(cs->Format());
-				m_tracer->TraceNoWaitLoop(desc);
-			}
-			try { throw 0; } catch (...) {}		// help debugger break
-		}
-
-		m_noWaitTimer.StartTimer();
-		m_sameResultCount = 0;
-	}
-}
-
-void WaitObjectContainer::SetNoWait(CallStack const& callStack)
-{
-	DetectNoWait(LASTRESULT_NOWAIT, CallStack("WaitObjectContainer::SetNoWait()", &callStack));
-	m_noWait = true;
-}
-
-void WaitObjectContainer::ScheduleEvent(double milliseconds, CallStack const& callStack)
-{
-	if (milliseconds <= 3)
-		DetectNoWait(LASTRESULT_SCHEDULED, CallStack("WaitObjectContainer::ScheduleEvent()", &callStack));
-	double thisEventTime = m_eventTimer.ElapsedTimeAsDouble() + milliseconds;
-	if (!m_firstEventTime || thisEventTime < m_firstEventTime)
-		m_firstEventTime = thisEventTime;
-}
-
-#ifdef USE_WINDOWS_STYLE_SOCKETS
-
-struct WaitingThreadData
-{
-	bool waitingToWait, terminate;
-	HANDLE startWaiting, stopWaiting;
-	const HANDLE *waitHandles;
-	unsigned int count;
-	HANDLE threadHandle;
-	DWORD threadId;
-	DWORD* error;
-};
-
-WaitObjectContainer::~WaitObjectContainer()
-{
-	try		// don't let exceptions escape destructor
-	{
-		if (!m_threads.empty())
-		{
-			HANDLE threadHandles[MAXIMUM_WAIT_OBJECTS];
-			unsigned int i;
-			for (i=0; i<m_threads.size(); i++)
-			{
-				WaitingThreadData &thread = *m_threads[i];
-				while (!thread.waitingToWait)	// spin until thread is in the initial "waiting to wait" state
-					Sleep(0);
-				thread.terminate = true;
-				threadHandles[i] = thread.threadHandle;
-			}
-			PulseEvent(m_startWaiting);
-			::WaitForMultipleObjects((DWORD)m_threads.size(), threadHandles, TRUE, INFINITE);
-			for (i=0; i<m_threads.size(); i++)
-				CloseHandle(threadHandles[i]);
-			CloseHandle(m_startWaiting);
-			CloseHandle(m_stopWaiting);
-		}
-	}
-	catch (...)
-	{
-	}
-}
-
-
-void WaitObjectContainer::AddHandle(HANDLE handle, CallStack const& callStack)
-{
-	DetectNoWait(m_handles.size(), CallStack("WaitObjectContainer::AddHandle()", &callStack));
-	m_handles.push_back(handle);
-}
-
-DWORD WINAPI WaitingThread(LPVOID lParam)
-{
-	std::auto_ptr<WaitingThreadData> pThread((WaitingThreadData *)lParam);
-	WaitingThreadData &thread = *pThread;
-	std::vector<HANDLE> handles;
-
-	while (true)
-	{
-		thread.waitingToWait = true;
-		::WaitForSingleObject(thread.startWaiting, INFINITE);
-		thread.waitingToWait = false;
-
-		if (thread.terminate)
-			break;
-		if (!thread.count)
-			continue;
-
-		handles.resize(thread.count + 1);
-		handles[0] = thread.stopWaiting;
-		std::copy(thread.waitHandles, thread.waitHandles+thread.count, handles.begin()+1);
-
-		DWORD result = ::WaitForMultipleObjects((DWORD)handles.size(), &handles[0], FALSE, INFINITE);
-
-		if (result == WAIT_OBJECT_0)
-			continue;	// another thread finished waiting first, so do nothing
-		SetEvent(thread.stopWaiting);
-		if (!(result > WAIT_OBJECT_0 && result < WAIT_OBJECT_0 + handles.size()))
-		{
-			assert(!"error in WaitingThread");	// break here so we can see which thread has an error
-			*thread.error = ::GetLastError();
-		}
-	}
-
-	return S_OK;	// return a value here to avoid compiler warning
-}
-
-void WaitObjectContainer::CreateThreads(unsigned int count)
-{
-	size_t currentCount = m_threads.size();
-	if (currentCount == 0)
-	{
-		m_startWaiting = ::CreateEvent(NULL, TRUE, FALSE, NULL);
-		m_stopWaiting = ::CreateEvent(NULL, TRUE, FALSE, NULL);
-	}
-
-	if (currentCount < count)
-	{
-		m_threads.resize(count);
-		for (size_t i=currentCount; i<count; i++)
-		{
-			m_threads[i] = new WaitingThreadData;
-			WaitingThreadData &thread = *m_threads[i];
-			thread.terminate = false;
-			thread.startWaiting = m_startWaiting;
-			thread.stopWaiting = m_stopWaiting;
-			thread.waitingToWait = false;
-			thread.threadHandle = CreateThread(NULL, 0, &WaitingThread, &thread, 0, &thread.threadId);
-		}
-	}
-}
-
-bool WaitObjectContainer::Wait(unsigned long milliseconds)
-{
-	if (m_noWait || (m_handles.empty() && !m_firstEventTime))
-	{
-		SetLastResult(LASTRESULT_NOWAIT);
-		return true;
-	}
-
-	bool timeoutIsScheduledEvent = false;
-
-	if (m_firstEventTime)
-	{
-		double timeToFirstEvent = SaturatingSubtract(m_firstEventTime, m_eventTimer.ElapsedTimeAsDouble());
-
-		if (timeToFirstEvent <= milliseconds)
-		{
-			milliseconds = (unsigned long)timeToFirstEvent;
-			timeoutIsScheduledEvent = true;
-		}
-
-		if (m_handles.empty() || !milliseconds)
-		{
-			if (milliseconds)
-				Sleep(milliseconds);
-			SetLastResult(timeoutIsScheduledEvent ? LASTRESULT_SCHEDULED : LASTRESULT_TIMEOUT);
-			return timeoutIsScheduledEvent;
-		}
-	}
-
-	if (m_handles.size() > MAXIMUM_WAIT_OBJECTS)
-	{
-		// too many wait objects for a single WaitForMultipleObjects call, so use multiple threads
-		static const unsigned int WAIT_OBJECTS_PER_THREAD = MAXIMUM_WAIT_OBJECTS-1;
-		unsigned int nThreads = (unsigned int)((m_handles.size() + WAIT_OBJECTS_PER_THREAD - 1) / WAIT_OBJECTS_PER_THREAD);
-		if (nThreads > MAXIMUM_WAIT_OBJECTS)	// still too many wait objects, maybe implement recursive threading later?
-			throw Err("WaitObjectContainer: number of wait objects exceeds limit");
-		CreateThreads(nThreads);
-		DWORD error = S_OK;
-		
-		for (unsigned int i=0; i<m_threads.size(); i++)
-		{
-			WaitingThreadData &thread = *m_threads[i];
-			while (!thread.waitingToWait)	// spin until thread is in the initial "waiting to wait" state
-				Sleep(0);
-			if (i<nThreads)
-			{
-				thread.waitHandles = &m_handles[i*WAIT_OBJECTS_PER_THREAD];
-				thread.count = UnsignedMin(WAIT_OBJECTS_PER_THREAD, m_handles.size() - i*WAIT_OBJECTS_PER_THREAD);
-				thread.error = &error;
-			}
-			else
-				thread.count = 0;
-		}
-
-		ResetEvent(m_stopWaiting);
-		PulseEvent(m_startWaiting);
-
-		DWORD result = ::WaitForSingleObject(m_stopWaiting, milliseconds);
-		if (result == WAIT_OBJECT_0)
-		{
-			if (error == S_OK)
-				return true;
-			else
-				throw Err("WaitObjectContainer: WaitForMultipleObjects in thread failed with error " + IntToString(error));
-		}
-		SetEvent(m_stopWaiting);
-		if (result == WAIT_TIMEOUT)
-		{
-			SetLastResult(timeoutIsScheduledEvent ? LASTRESULT_SCHEDULED : LASTRESULT_TIMEOUT);
-			return timeoutIsScheduledEvent;
-		}
-		else
-			throw Err("WaitObjectContainer: WaitForSingleObject failed with error " + IntToString(::GetLastError()));
-	}
-	else
-	{
-#if TRACE_WAIT
-		static Timer t(Timer::MICROSECONDS);
-		static unsigned long lastTime = 0;
-		unsigned long timeBeforeWait = t.ElapsedTime();
-#endif
-		DWORD result = ::WaitForMultipleObjects((DWORD)m_handles.size(), &m_handles[0], FALSE, milliseconds);
-#if TRACE_WAIT
-		if (milliseconds > 0)
-		{
-			unsigned long timeAfterWait = t.ElapsedTime();
-			OutputDebugString(("Handles " + IntToString(m_handles.size()) + ", Woke up by " + IntToString(result-WAIT_OBJECT_0) + ", Busied for " + IntToString(timeBeforeWait-lastTime) + " us, Waited for " + IntToString(timeAfterWait-timeBeforeWait) + " us, max " + IntToString(milliseconds) + "ms\n").c_str());
-			lastTime = timeAfterWait;
-		}
-#endif
-		if (result >= WAIT_OBJECT_0 && result < WAIT_OBJECT_0 + m_handles.size())
-		{
-			if (result == m_lastResult)
-				m_sameResultCount++;
-			else
-			{
-				m_lastResult = result;
-				m_sameResultCount = 0;
-			}
-			return true;
-		}
-		else if (result == WAIT_TIMEOUT)
-		{
-			SetLastResult(timeoutIsScheduledEvent ? LASTRESULT_SCHEDULED : LASTRESULT_TIMEOUT);
-			return timeoutIsScheduledEvent;
-		}
-		else
-			throw Err("WaitObjectContainer: WaitForMultipleObjects failed with error " + IntToString(::GetLastError()));
-	}
-}
-
-#else // #ifdef USE_WINDOWS_STYLE_SOCKETS
-
-void WaitObjectContainer::AddReadFd(int fd, CallStack const& callStack)	// TODO: do something with callStack
-{
-	FD_SET(fd, &m_readfds);
-	m_maxFd = STDMAX(m_maxFd, fd);
-}
-
-void WaitObjectContainer::AddWriteFd(int fd, CallStack const& callStack) // TODO: do something with callStack
-{
-	FD_SET(fd, &m_writefds);
-	m_maxFd = STDMAX(m_maxFd, fd);
-}
-
-bool WaitObjectContainer::Wait(unsigned long milliseconds)
-{
-	if (m_noWait || (!m_maxFd && !m_firstEventTime))
-		return true;
-
-	bool timeoutIsScheduledEvent = false;
-
-	if (m_firstEventTime)
-	{
-		double timeToFirstEvent = SaturatingSubtract(m_firstEventTime, m_eventTimer.ElapsedTimeAsDouble());
-		if (timeToFirstEvent <= milliseconds)
-		{
-			milliseconds = (unsigned long)timeToFirstEvent;
-			timeoutIsScheduledEvent = true;
-		}
-	}
-
-	timeval tv, *timeout;
-
-	if (milliseconds == INFINITE_TIME)
-		timeout = NULL;
-	else
-	{
-		tv.tv_sec = milliseconds / 1000;
-		tv.tv_usec = (milliseconds % 1000) * 1000;
-		timeout = &tv;
-	}
-
-	int result = select(m_maxFd+1, &m_readfds, &m_writefds, NULL, timeout);
-
-	if (result > 0)
-		return true;
-	else if (result == 0)
-		return timeoutIsScheduledEvent;
-	else
-		throw Err("WaitObjectContainer: select failed with error " + errno);
-}
-
-#endif
-
-// ********************************************************
-
-std::string CallStack::Format() const
-{
-	return m_info;
-}
-
-std::string CallStackWithNr::Format() const
-{
-	return std::string(m_info) + " / nr: " + IntToString(m_nr);
-}
-
-std::string CallStackWithStr::Format() const
-{
-	return std::string(m_info) + " / " + std::string(m_z);
-}
-
-bool Waitable::Wait(unsigned long milliseconds, CallStack const& callStack)
-{
-	WaitObjectContainer container;
-	GetWaitObjects(container, callStack);	// reduce clutter by not adding this func to stack
-	return container.Wait(milliseconds);
-}
-
-NAMESPACE_END
-
-#endif