1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
// 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
|
