filters.h

Cryptolib4.1.rar

// Used By ProxyFilter
class OutputProxy : public Sink
{
public:
	OutputProxy(BufferedTransformation &owner, bool passSignal) : m_owner(owner), m_passSignal(passSignal) {}

	bool GetPassSignal() const {return m_passSignal;}
	void SetPassSignal(bool passSignal) {m_passSignal = passSignal;}

	void Put(byte b) 
		{m_owner.AttachedTransformation()->Put(b);}
	void Put(const byte *string, unsigned int len) 
		{m_owner.AttachedTransformation()->Put(string, len);}
	void Flush(bool completeFlush, int propagation=-1) 
		{if (m_passSignal) m_owner.AttachedTransformation()->Flush(completeFlush, propagation);}
	void MessageEnd(int propagation=-1)
		{if (m_passSignal) m_owner.AttachedTransformation()->MessageEnd(propagation);}
	void MessageSeriesEnd(int propagation=-1) 
		{if (m_passSignal) m_owner.AttachedTransformation()->MessageSeriesEnd(propagation);}

	void ChannelPut(const std::string &channel, byte b) 
		{m_owner.AttachedTransformation()->ChannelPut(channel, b);}
	void ChannelPut(const std::string &channel, const byte *string, unsigned int len) 
		{m_owner.AttachedTransformation()->ChannelPut(channel, string, len);}
	void ChannelFlush(const std::string &channel, bool completeFlush, int propagation=-1) 
		{if (m_passSignal) m_owner.AttachedTransformation()->ChannelFlush(channel, completeFlush, propagation);}
	void ChannelMessageEnd(const std::string &channel, int propagation=-1)
		{if (m_passSignal) m_owner.AttachedTransformation()->ChannelMessageEnd(channel, propagation);}
	void ChannelMessageSeriesEnd(const std::string &channel, int propagation=-1) 
		{if (m_passSignal) m_owner.AttachedTransformation()->ChannelMessageSeriesEnd(channel, propagation);}

private:
	BufferedTransformation &m_owner;
	bool m_passSignal;
};

//! Base class for Filter classes that are proxies for a chain of other filters.
class ProxyFilter : public FilterWithBufferedInput
{
public:
	ProxyFilter(Filter *filter, unsigned int firstSize, unsigned int lastSize, BufferedTransformation *outQ);

	void Flush(bool completeFlush, int propagation=-1);

	void SetFilter(Filter *filter);
	void NextPut(const byte *s, unsigned int len);

protected:
	member_ptr<Filter> m_filter;
	OutputProxy *m_proxy;
};

//! Append input to a string object
template <class T>
class StringSinkTemplate : public Sink
{
public:
	// VC60 workaround: no T::char_type
	typedef typename T::traits_type::char_type char_type;

	StringSinkTemplate(T &output)
		: m_output(output) {assert(sizeof(output[0])==1);}
	void Put(byte b)
		{m_output += (char_type)b;}
	void Put(const byte *str, unsigned int bc)
		{m_output.append((const char_type *)str, bc);}

private:	
	T &m_output;
};

//! Append input to an std::string
typedef StringSinkTemplate<std::string> StringSink;

//! Copy input to a memory buffer
class ArraySink : public Sink
{
public:
	ArraySink(byte *buf, unsigned int size) : m_buf(buf), m_size(size), m_total(0) {}

	unsigned int AvailableSize() {return m_size - STDMIN(m_total, (unsigned long)m_size);}
	unsigned long TotalPutLength() {return m_total;}

	void Put(byte b)
	{
		if (m_total < m_size)
			m_buf[m_total] = b;
		m_total++;
	}

	void Put(const byte *str, unsigned int len)
	{
		if (m_total < m_size)
			memcpy(m_buf+m_total, str, STDMIN(len, (unsigned int)(m_size-m_total)));
		m_total += len;
	}

protected:
	byte *m_buf;
	unsigned int m_size;
	unsigned long m_total;
};

//! Xor input to a memory buffer
class ArrayXorSink : public ArraySink
{
public:
	ArrayXorSink(byte *buf, unsigned int size)
		: ArraySink(buf, size) {}

	void Put(byte b)
	{
		if (m_total < m_size)
			m_buf[m_total] ^= b;
		m_total++;
	}

	void Put(const byte *str, unsigned int len)
	{
		if (m_total < m_size)
			xorbuf(m_buf+m_total, str, STDMIN(len, (unsigned int)(m_size-m_total)));
		m_total += len;
	}
};

//! Provide implementation of SetAutoSignalPropagation and GetAutoSignalPropagation
class BufferedTransformationWithAutoSignal : virtual public BufferedTransformation
{
public:
	BufferedTransformationWithAutoSignal(int propagation=-1) : m_autoSignalPropagation(propagation) {}

	void SetAutoSignalPropagation(int propagation)
		{m_autoSignalPropagation = propagation;}
	int GetAutoSignalPropagation() const
		{return m_autoSignalPropagation;}

private:
	int m_autoSignalPropagation;
};

//! A BufferedTransformation that only contains pre-existing output
class Store : public BufferedTransformationWithAutoSignal
{
public:
	Store() : m_messageEnd(false) {}

	void Put(byte)
		{}
	void Put(const byte *, unsigned int length)
		{}

	virtual unsigned long TransferTo(BufferedTransformation &target, unsigned long transferMax=ULONG_MAX) =0;
	virtual unsigned long CopyTo(BufferedTransformation &target, unsigned long copyMax=ULONG_MAX) const =0;

	unsigned int NumberOfMessages() const {return m_messageEnd ? 0 : 1;}
	bool GetNextMessage();
	unsigned int CopyMessagesTo(BufferedTransformation &target, unsigned int count=UINT_MAX) const;

private:
	bool m_messageEnd;
};

//! .
class StringStore : public Store
{
public:
	StringStore(const char *string)
		: m_store((const byte *)string), m_length(strlen(string)), m_count(0) {}
	StringStore(const byte *string, unsigned int length)
		: m_store(string), m_length(length), m_count(0) {}
	template <class T> StringStore(const T &string)
		: m_store((const byte *)string.data()), m_length(string.length()), m_count(0) {assert(sizeof(string[0])==1);}

	unsigned long TransferTo(BufferedTransformation &target, unsigned long transferMax=ULONG_MAX);
	unsigned long CopyTo(BufferedTransformation &target, unsigned long copyMax=ULONG_MAX) const;

private:
	const byte *m_store;
	unsigned int m_length, m_count;
};

//! .
class RandomNumberStore : public Store
{
public:
	RandomNumberStore(RandomNumberGenerator &rng, unsigned long length)
		: m_rng(rng), m_length(length), m_count(0) {}

	unsigned long TransferTo(BufferedTransformation &target, unsigned long transferMax=ULONG_MAX);
	unsigned long CopyTo(BufferedTransformation &target, unsigned long copyMax=ULONG_MAX) const;

private:
	RandomNumberGenerator &m_rng;
	unsigned long m_length, m_count;
};

//! A Filter that pumps data into its attachment as input
class Source : public Filter
{
public:
	Source(BufferedTransformation *outQ)
		: Filter(outQ) {}

	virtual unsigned long Pump(unsigned long pumpMax=ULONG_MAX) =0;
	virtual unsigned int PumpMessages(unsigned int count=UINT_MAX) {return 0;}
	void PumpAll();

	void Put(byte)
		{Pump(1);}
	void Put(const byte *, unsigned int length)
		{Pump(length);}
	void MessageEnd(int propagation=-1)
		{PumpAll();}
};

//! Turn a Store into a Source
class GeneralSource : public Source
{
public:
	GeneralSource(BufferedTransformation &store, bool pumpAll, BufferedTransformation *outQueue = NULL)
		: Source(outQueue), m_store(store)
	{
		if (pumpAll) PumpAll();
	}

	unsigned long Pump(unsigned long pumpMax=ULONG_MAX)
		{return m_store.TransferTo(*AttachedTransformation(), pumpMax);}
	unsigned int PumpMessages(unsigned int count=UINT_MAX)
		{return m_store.TransferMessagesTo(*AttachedTransformation(), count);}

private:
	BufferedTransformation &m_store;
};

//! .
class StringSource : public Source
{
public:
	StringSource(const char *string, bool pumpAll, BufferedTransformation *outQueue = NULL);
	StringSource(const byte *string, unsigned int length, bool pumpAll, BufferedTransformation *outQueue = NULL);

#ifdef __MWERKS__	// CW60 workaround
	StringSource(const std::string &string, bool pumpAll, BufferedTransformation *outQueue = NULL)
#else
	template <class T> StringSource(const T &string, bool pumpAll, BufferedTransformation *outQueue = NULL)
#endif
		: Source(outQueue), m_store(string)
	{
		if (pumpAll)
			PumpAll();
	}

	unsigned long Pump(unsigned long pumpMax=ULONG_MAX)
		{return m_store.TransferTo(*AttachedTransformation(), pumpMax);}
	unsigned int PumpMessages(unsigned int count=UINT_MAX)
		{return m_store.TransferMessagesTo(*AttachedTransformation(), count);}

private:
	StringStore m_store;
};

//! .
class RandomNumberSource : public Source
{
public:
	RandomNumberSource(RandomNumberGenerator &rng, unsigned int length, bool pumpAll, BufferedTransformation *outQueue = NULL);

	unsigned long Pump(unsigned long pumpMax=ULONG_MAX)
		{return m_store.TransferTo(*AttachedTransformation(), pumpMax);}
	unsigned int PumpMessages(unsigned int count=UINT_MAX)
		{return m_store.TransferMessagesTo(*AttachedTransformation(), count);}

private:
	RandomNumberStore m_store;
};

NAMESPACE_END

#endif