6#ifndef CRYPTOPP_SIMPLE_H
7#define CRYPTOPP_SIMPLE_H
11#if CRYPTOPP_MSC_VERSION
13# pragma warning(disable: 4127 4189)
24template <
class DERIVED,
class BASE>
28 Clonable * Clone()
const {
return new DERIVED(*
static_cast<const DERIVED *
>(
this));}
35template <
class BASE,
class ALGORITHM_INFO=BASE>
48 std::string
AlgorithmName()
const {
return ALGORITHM_INFO::StaticAlgorithmName();}
101 bool IsolatedFlush(
bool hardFlush,
bool blocking)
102 {CRYPTOPP_UNUSED(hardFlush); CRYPTOPP_UNUSED(blocking);
return false;}
111 bool Flush(
bool completeFlush,
int propagation=-1,
bool blocking=
true)
112 {
return ChannelFlush(DEFAULT_CHANNEL, completeFlush, propagation, blocking);}
113 bool IsolatedFlush(
bool hardFlush,
bool blocking)
114 {CRYPTOPP_UNUSED(hardFlush); CRYPTOPP_UNUSED(blocking);
CRYPTOPP_ASSERT(
false);
return false;}
115 bool ChannelFlush(
const std::string &channel,
bool hardFlush,
int propagation=-1,
bool blocking=
true)
117 if (hardFlush && !InputBufferIsEmpty())
118 throw CannotFlush(
"Unflushable<T>: this object has buffered input that cannot be flushed");
122 return attached && propagation ? attached->
ChannelFlush(channel, hardFlush, propagation-1, blocking) :
false;
127 virtual bool InputBufferIsEmpty()
const {
return false;}
151 size_t Put2(
const byte *inString,
size_t length,
int messageEnd,
bool blocking)
152 {CRYPTOPP_UNUSED(inString); CRYPTOPP_UNUSED(length); CRYPTOPP_UNUSED(messageEnd); CRYPTOPP_UNUSED(blocking);
throw InputRejected();}
157 bool IsolatedFlush(
bool hardFlush,
bool blocking)
158 {CRYPTOPP_UNUSED(hardFlush); CRYPTOPP_UNUSED(blocking);
return false;}
159 bool IsolatedMessageSeriesEnd(
bool blocking)
160 {CRYPTOPP_UNUSED(blocking);
throw InputRejected();}
161 size_t ChannelPut2(
const std::string &channel,
const byte *inString,
size_t length,
int messageEnd,
bool blocking)
162 {CRYPTOPP_UNUSED(channel); CRYPTOPP_UNUSED(inString); CRYPTOPP_UNUSED(length); CRYPTOPP_UNUSED(messageEnd); CRYPTOPP_UNUSED(blocking);
throw InputRejected();}
163 bool ChannelMessageSeriesEnd(
const std::string& channel,
int messageEnd,
bool blocking)
164 {CRYPTOPP_UNUSED(channel); CRYPTOPP_UNUSED(messageEnd); CRYPTOPP_UNUSED(blocking);
throw InputRejected();}
191 virtual bool Flush(
bool hardFlush,
int propagation=-1,
bool blocking=
true) =0;
196 bool IsolatedFlush(
bool hardFlush,
bool blocking)
197 {CRYPTOPP_UNUSED(hardFlush); CRYPTOPP_UNUSED(blocking);
CRYPTOPP_ASSERT(
false);
return false;}
228 bool Flush(
bool hardFlush,
int propagation=-1,
bool blocking=
true)
229 {
return this->ChannelFlush(DEFAULT_CHANNEL, hardFlush, propagation, blocking);}
240 {
return this->ChannelMessageSeriesEnd(DEFAULT_CHANNEL, propagation, blocking);}
252 {
return this->ChannelCreatePutSpace(DEFAULT_CHANNEL, size);}
260 size_t Put2(
const byte *inString,
size_t length,
int messageEnd,
bool blocking)
261 {
return this->ChannelPut2(DEFAULT_CHANNEL, inString, length, messageEnd, blocking);}
269 size_t PutModifiable2(
byte *inString,
size_t length,
int messageEnd,
bool blocking)
270 {
return this->ChannelPutModifiable2(DEFAULT_CHANNEL, inString, length, messageEnd, blocking);}
274 byte * ChannelCreatePutSpace(
const std::string &channel,
size_t &size)
275 {CRYPTOPP_UNUSED(channel); size = 0;
return NULLPTR;}
276 bool ChannelPutModifiable(
const std::string &channel,
byte *inString,
size_t length)
277 {this->ChannelPut(channel, inString, length);
return false;}
279 virtual size_t ChannelPut2(
const std::string &channel,
const byte *begin,
size_t length,
int messageEnd,
bool blocking) =0;
280 size_t ChannelPutModifiable2(
const std::string &channel,
byte *begin,
size_t length,
int messageEnd,
bool blocking)
281 {
return ChannelPut2(channel, begin, length, messageEnd, blocking);}
283 virtual bool ChannelFlush(
const std::string &channel,
bool hardFlush,
int propagation=-1,
bool blocking=
true) =0;
296 void SetAutoSignalPropagation(
int propagation)
297 {m_autoSignalPropagation = propagation;}
298 int GetAutoSignalPropagation()
const
299 {
return m_autoSignalPropagation;}
302 int m_autoSignalPropagation;
306class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE
Store :
public AutoSignaling<InputRejecting<BufferedTransformation> >
314 m_messageEnd =
false;
315 StoreInitialize(parameters);
319 bool GetNextMessage();
320 unsigned int CopyMessagesTo(
BufferedTransformation &target,
unsigned int count=UINT_MAX,
const std::string &channel=DEFAULT_CHANNEL)
const;
323 virtual void StoreInitialize(
const NameValuePairs ¶meters) =0;
341 {CRYPTOPP_UNUSED(target); CRYPTOPP_UNUSED(transferBytes); CRYPTOPP_UNUSED(channel); CRYPTOPP_UNUSED(blocking); transferBytes = 0;
return 0;}
343 {CRYPTOPP_UNUSED(target); CRYPTOPP_UNUSED(begin); CRYPTOPP_UNUSED(end); CRYPTOPP_UNUSED(channel); CRYPTOPP_UNUSED(blocking);
return 0;}
354 {CRYPTOPP_UNUSED(params);}
355 size_t Put2(
const byte *inString,
size_t length,
int messageEnd,
bool blocking)
356 {CRYPTOPP_UNUSED(inString); CRYPTOPP_UNUSED(length); CRYPTOPP_UNUSED(messageEnd); CRYPTOPP_UNUSED(blocking);
return 0;}
361#if CRYPTOPP_MSC_VERSION
static std::string StaticAlgorithmName()
The algorithm name.
std::string AlgorithmName() const
The algorithm name.
Provides auto signaling support.
AutoSignaling(int propagation=-1)
Construct an AutoSignaling.
Acts as an input discarding Filter or Sink.
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing.
void IsolatedInitialize(const NameValuePairs ¶ms)
Initialize or reinitialize this object, without signal propagation.
std::string AlgorithmName() const
Provides the name of this algorithm.
Base class for bufferless filters.
Flush(true) was called but it can't completely flush its buffers.
Interface for cloning objects.
Base class for identifying alogorithm.
Interface for custom flush signals propagation.
virtual bool Flush(bool hardFlush, int propagation=-1, bool blocking=true)=0
Flush buffered input and/or output, with signal propagation.
Interface for custom flush signals.
virtual void Initialize(const NameValuePairs ¶meters=g_nullNameValuePairs, int propagation=-1)=0
Initialize or reinitialize this object, with signal propagation.
An invalid argument was detected.
Exception thrown when an invalid block size is encountered.
Exception thrown when an invalid derived key length is encountered.
Exception thrown when an invalid key length is encountered.
Exception thrown when an invalid personalization string length is encountered.
Exception thrown when an invalid number of rounds is encountered.
Exception thrown when an invalid salt length is encountered.
Multiple channels support for custom signal processing.
byte * CreatePutSpace(size_t &size)
Request space which can be written into by the caller.
bool MessageSeriesEnd(int propagation=-1, bool blocking=true)
Marks the end of a series of messages, with signal propagation.
size_t Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes for processing.
bool Flush(bool hardFlush, int propagation=-1, bool blocking=true)
Flush buffered input and/or output, with signal propagation.
size_t PutModifiable2(byte *inString, size_t length, int messageEnd, bool blocking)
Input multiple bytes that may be modified by callee.
Interface for retrieving values given their names.
A method was called which was not implemented.
Implementation of BufferedTransformation's attachment interface.
size_t TransferTo2(BufferedTransformation &target, lword &transferBytes, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true)
Transfer bytes from this object to another BufferedTransformation.
size_t CopyRangeTo2(BufferedTransformation &target, lword &begin, lword end=LWORD_MAX, const std::string &channel=DEFAULT_CHANNEL, bool blocking=true) const
Copy bytes from this object to another BufferedTransformation.
Acts as a Source for pre-existing, static data.
void IsolatedInitialize(const NameValuePairs ¶meters)
Initialize or reinitialize this object, without signal propagation.
Store()
Construct a Store.
unsigned int NumberOfMessages() const
Provides the number of meesages processed by this object.
Base class for unflushable filters.
Library configuration file.
Abstract base classes that provide a uniform interface to this library.
Utility functions for the Crypto++ library.
std::string IntToString(T value, unsigned int base=10)
Converts a value to a string.
Crypto++ library namespace.
#define CRYPTOPP_ASSERT(exp)
Debugging and diagnostic assertion.