146 lines
5.3 KiB
C++
146 lines
5.3 KiB
C++
// mqueue.h - originally written and placed in the public domain by Wei Dai
|
|
|
|
/// \file
|
|
/// \brief Classes for an unlimited queue to store messages
|
|
|
|
#ifndef CRYPTOPP_MQUEUE_H
|
|
#define CRYPTOPP_MQUEUE_H
|
|
|
|
#include "cryptlib.h"
|
|
#include "queue.h"
|
|
#include "filters.h"
|
|
#include "misc.h"
|
|
|
|
#include <deque>
|
|
|
|
NAMESPACE_BEGIN(CryptoPP)
|
|
|
|
/// \brief Data structure used to store messages
|
|
/// \details The queue is implemented with a ByteQueue.
|
|
/// \sa <A HREF="https://www.cryptopp.com/wiki/MessageQueue">MessageQueue</A>
|
|
/// on the Crypto++ wiki.
|
|
/// \since Crypto++ 2.0
|
|
class CRYPTOPP_DLL MessageQueue : public AutoSignaling<BufferedTransformation>
|
|
{
|
|
public:
|
|
virtual ~MessageQueue() {}
|
|
|
|
/// \brief Construct a MessageQueue
|
|
/// \param nodeSize the initial node size
|
|
MessageQueue(unsigned int nodeSize=256);
|
|
|
|
// BufferedTransformation
|
|
void IsolatedInitialize(const NameValuePairs ¶meters)
|
|
{m_queue.IsolatedInitialize(parameters); m_lengths.assign(1, 0U); m_messageCounts.assign(1, 0U);}
|
|
size_t Put2(const byte *begin, size_t length, int messageEnd, bool blocking)
|
|
{
|
|
CRYPTOPP_UNUSED(blocking);
|
|
m_queue.Put(begin, length);
|
|
m_lengths.back() += length;
|
|
if (messageEnd)
|
|
{
|
|
m_lengths.push_back(0);
|
|
m_messageCounts.back()++;
|
|
}
|
|
return 0;
|
|
}
|
|
bool IsolatedFlush(bool hardFlush, bool blocking)
|
|
{CRYPTOPP_UNUSED(hardFlush), CRYPTOPP_UNUSED(blocking); return false;}
|
|
bool IsolatedMessageSeriesEnd(bool blocking)
|
|
{CRYPTOPP_UNUSED(blocking); m_messageCounts.push_back(0); return false;}
|
|
|
|
lword MaxRetrievable() const
|
|
{return m_lengths.front();}
|
|
bool AnyRetrievable() const
|
|
{return m_lengths.front() > 0;}
|
|
|
|
size_t TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true);
|
|
size_t CopyRangeTo2(BufferedTransformation &target, lword &begin, lword end=LWORD_MAX, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true) const;
|
|
|
|
lword TotalBytesRetrievable() const
|
|
{return m_queue.MaxRetrievable();}
|
|
unsigned int NumberOfMessages() const
|
|
{return (unsigned int)m_lengths.size()-1;}
|
|
bool GetNextMessage();
|
|
|
|
unsigned int NumberOfMessagesInThisSeries() const
|
|
{return m_messageCounts[0];}
|
|
unsigned int NumberOfMessageSeries() const
|
|
{return (unsigned int)m_messageCounts.size()-1;}
|
|
|
|
/// \brief Copy messages from this object to another BufferedTransformation.
|
|
/// \param target the destination BufferedTransformation
|
|
/// \param count the number of messages to copy
|
|
/// \param channel the channel on which the transfer should occur
|
|
/// \return the number of messages that remain in the copy (i.e., messages not copied)
|
|
unsigned int CopyMessagesTo(BufferedTransformation &target, unsigned int count=UINT_MAX, const std::string &channel=DEFAULT_CHANNEL) const;
|
|
|
|
/// \brief Peek data in the queue
|
|
/// \param contiguousSize the size of the data
|
|
/// \details Spy() peeks at data at the head of the queue. Spy() does
|
|
/// not remove data from the queue.
|
|
/// \details The data's size is returned in <tt>contiguousSize</tt>.
|
|
/// Spy() returns the size of the first message in the list.
|
|
const byte * Spy(size_t &contiguousSize) const;
|
|
|
|
/// \brief Swap contents with another MessageQueue
|
|
/// \param rhs the other MessageQueue
|
|
void swap(MessageQueue &rhs);
|
|
|
|
private:
|
|
ByteQueue m_queue;
|
|
std::deque<lword> m_lengths;
|
|
std::deque<unsigned int> m_messageCounts;
|
|
};
|
|
|
|
/// \brief Filter that checks messages on two channels for equality
|
|
class CRYPTOPP_DLL EqualityComparisonFilter : public Unflushable<Multichannel<Filter> >
|
|
{
|
|
public:
|
|
/// \brief Different messages were detected
|
|
struct MismatchDetected : public Exception
|
|
{
|
|
/// \brief Construct a MismatchDetected exception
|
|
MismatchDetected() : Exception(DATA_INTEGRITY_CHECK_FAILED, "EqualityComparisonFilter: did not receive the same data on two channels") {}
|
|
};
|
|
|
|
/// \brief Construct an EqualityComparisonFilter
|
|
/// \param attachment an attached transformation
|
|
/// \param throwIfNotEqual flag indicating whether the objects throws
|
|
/// \param firstChannel string naming the first channel
|
|
/// \param secondChannel string naming the second channel
|
|
/// \throw MismatchDetected if throwIfNotEqual is true and not equal
|
|
/// \details If throwIfNotEqual is false, this filter will output a '\\0'
|
|
/// byte when it detects a mismatch, '\\1' otherwise.
|
|
EqualityComparisonFilter(BufferedTransformation *attachment=NULLPTR, bool throwIfNotEqual=true, const std::string &firstChannel="0", const std::string &secondChannel="1")
|
|
: m_throwIfNotEqual(throwIfNotEqual), m_mismatchDetected(false)
|
|
, m_firstChannel(firstChannel), m_secondChannel(secondChannel)
|
|
{Detach(attachment);}
|
|
|
|
// BufferedTransformation
|
|
size_t ChannelPut2(const std::string &channel, const byte *begin, size_t length, int messageEnd, bool blocking);
|
|
bool ChannelMessageSeriesEnd(const std::string &channel, int propagation=-1, bool blocking=true);
|
|
|
|
protected:
|
|
unsigned int MapChannel(const std::string &channel) const;
|
|
bool HandleMismatchDetected(bool blocking);
|
|
|
|
private:
|
|
bool m_throwIfNotEqual, m_mismatchDetected;
|
|
std::string m_firstChannel, m_secondChannel;
|
|
MessageQueue m_q[2];
|
|
};
|
|
|
|
NAMESPACE_END
|
|
|
|
#ifndef __BORLANDC__
|
|
NAMESPACE_BEGIN(std)
|
|
template<> inline void swap(CryptoPP::MessageQueue &a, CryptoPP::MessageQueue &b)
|
|
{
|
|
a.swap(b);
|
|
}
|
|
NAMESPACE_END
|
|
#endif
|
|
|
|
#endif
|