size_t InformationDispersal::Put2(const byte *begin, size_t length, int messageEnd, bool blocking)
{
if (!blocking)
throw BlockingInputOnly("InformationDispersal");
while (length--)
{
m_ida.ChannelData(m_nextChannel, begin, 1, false);
begin++;
m_nextChannel++;
if (m_nextChannel == m_ida.GetThreshold())
m_nextChannel = 0;
}
if (messageEnd)
{
m_ida.SetAutoSignalPropagation(messageEnd-1);
if (m_pad)
InformationDispersal::Put(1);
for (word32 i=0; i<m_ida.GetThreshold(); i++)
m_ida.ChannelData(i, NULL, 0, true);
}
return 0;
}
bool FilterWithBufferedInput::IsolatedFlush(bool hardFlush, bool blocking)
{
if (!blocking)
throw BlockingInputOnly("FilterWithBufferedInput");
if (hardFlush)
ForceNextPut();
FlushDerived();
return false;
}
bool Inflator::IsolatedFlush(bool hardFlush, bool blocking)
{
if (!blocking)
throw BlockingInputOnly("Inflator");
if (hardFlush)
ProcessInput(true);
FlushOutput();
return false;
}
unsigned int EqualityComparisonFilter::ChannelPut2(const std::string &channel, const byte *inString, unsigned int length, int messageEnd, bool blocking)
{
if (!blocking)
throw BlockingInputOnly("EqualityComparisonFilter");
unsigned int i = MapChannel(channel);
if (i == 2)
return Output(3, inString, length, messageEnd, blocking, channel);
else if (m_mismatchDetected)
return 0;
else
{
MessageQueue &q1 = m_q[i], &q2 = m_q[1-i];
if (q2.AnyMessages() && q2.MaxRetrievable() < length)
goto mismatch;
while (length > 0 && q2.AnyRetrievable())
{
unsigned int len = length;
const byte *data = q2.Spy(len);
len = STDMIN(len, length);
if (memcmp(inString, data, len) != 0)
goto mismatch;
inString += len;
length -= len;
q2.Skip(len);
}
q1.Put(inString, length);
if (messageEnd)
{
if (q2.AnyRetrievable())
goto mismatch;
else if (q2.AnyMessages())
q2.GetNextMessage();
else if (q2.NumberOfMessageSeries() > 0)
goto mismatch;
else
q1.MessageEnd();
}
return 0;
mismatch:
return HandleMismatchDetected(blocking);
}
}
size_t Inflator::Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
{
if (!blocking)
throw BlockingInputOnly("Inflator");
LazyPutter lp(m_inQueue, inString, length);
ProcessInput(messageEnd != 0);
if (messageEnd)
if (!(m_state == PRE_STREAM || m_state == AFTER_END))
throw UnexpectedEndErr();
Output(0, NULL, 0, messageEnd, blocking);
return 0;
}
size_t PaddingRemover::Put2(const byte *begin, size_t length, int messageEnd, bool blocking)
{
if (!blocking)
throw BlockingInputOnly("PaddingRemover");
const byte *const end = begin + length;
if (m_possiblePadding)
{
size_t len = std::find_if(begin, end, std::bind2nd(std::not_equal_to<byte>(), byte(0))) - begin;
m_zeroCount += len;
begin += len;
if (begin == end)
return 0;
AttachedTransformation()->Put(1);
while (m_zeroCount--)
AttachedTransformation()->Put(0);
AttachedTransformation()->Put(*begin++);
m_possiblePadding = false;
}
#if defined(_MSC_VER) && (_MSC_VER <= 1300) && !defined(__MWERKS__)
// VC60 and VC7 workaround: built-in reverse_iterator has two template parameters, Dinkumware only has one
typedef std::reverse_bidirectional_iterator<const byte *, const byte> RevIt;
#elif defined(_RWSTD_NO_CLASS_PARTIAL_SPEC)
typedef std::reverse_iterator<const byte *, std::random_access_iterator_tag, const byte> RevIt;
#else
typedef std::reverse_iterator<const byte *> RevIt;
#endif
const byte *x = std::find_if(RevIt(end), RevIt(begin), std::bind2nd(std::not_equal_to<byte>(), byte(0))).base();
if (x != begin && *(x-1) == 1)
{
AttachedTransformation()->Put(begin, x-begin-1);
m_possiblePadding = true;
m_zeroCount = end - x;
}
else
AttachedTransformation()->Put(begin, end-begin);
if (messageEnd)
{
m_possiblePadding = false;
Output(0, begin, length, messageEnd, blocking);
}
return 0;
}
size_t PaddingRemover::Put2(const byte *begin, size_t length, int messageEnd, bool blocking)
{
if (!blocking)
throw BlockingInputOnly("PaddingRemover");
const byte *const end = begin + length;
if (m_possiblePadding)
{
size_t len = std::find_if(begin, end, std::bind2nd(std::not_equal_to<byte>(), byte(0))) - begin;
m_zeroCount += len;
begin += len;
if (begin == end)
return 0;
AttachedTransformation()->Put(1);
while (m_zeroCount--)
AttachedTransformation()->Put(0);
AttachedTransformation()->Put(*begin++);
m_possiblePadding = false;
}
const byte *x = std::find_if(RevIt(end), RevIt(begin), std::bind2nd(std::not_equal_to<byte>(), byte(0))).base();
if (x != begin && *(x-1) == 1)
{
AttachedTransformation()->Put(begin, x-begin-1);
m_possiblePadding = true;
m_zeroCount = end - x;
}
else
AttachedTransformation()->Put(begin, end-begin);
if (messageEnd)
{
m_possiblePadding = false;
Output(0, begin, length, messageEnd, blocking);
}
return 0;
}
size_t SecretSharing::Put2(const byte *begin, size_t length, int messageEnd, bool blocking)
{
if (!blocking)
throw BlockingInputOnly("SecretSharing");
SecByteBlock buf(UnsignedMin(256, length));
unsigned int threshold = m_ida.GetThreshold();
while (length > 0)
{
size_t len = STDMIN(length, buf.size());
m_ida.ChannelData(0xffffffff, begin, len, false);
for (unsigned int i=0; i<threshold-1; i++)
{
m_rng.GenerateBlock(buf, len);
m_ida.ChannelData(i, buf, len, false);
}
length -= len;
begin += len;
}
if (messageEnd)
{
m_ida.SetAutoSignalPropagation(messageEnd-1);
if (m_pad)
{
SecretSharing::Put(1);
while (m_ida.InputBuffered(0xffffffff) > 0)
SecretSharing::Put(0);
}
m_ida.ChannelData(0xffffffff, NULL, 0, true);
for (unsigned int i=0; i<m_ida.GetThreshold()-1; i++)
m_ida.ChannelData(i, NULL, 0, true);
}
return 0;
}
size_t FilterWithBufferedInput::PutMaybeModifiable(byte *inString, size_t length, int messageEnd, bool blocking, bool modifiable)
{
if (!blocking)
throw BlockingInputOnly("FilterWithBufferedInput");
if (length != 0)
{
size_t newLength = m_queue.CurrentSize() + length;
if (!m_firstInputDone && newLength >= m_firstSize)
{
size_t len = m_firstSize - m_queue.CurrentSize();
m_queue.Put(inString, len);
FirstPut(m_queue.GetContigousBlocks(m_firstSize));
assert(m_queue.CurrentSize() == 0);
m_queue.ResetQueue(m_blockSize, (2*m_blockSize+m_lastSize-2)/m_blockSize);
inString += len;
newLength -= m_firstSize;
m_firstInputDone = true;
}
if (m_firstInputDone)
{
if (m_blockSize == 1)
{
while (newLength > m_lastSize && m_queue.CurrentSize() > 0)
{
size_t len = newLength - m_lastSize;
byte *ptr = m_queue.GetContigousBlocks(len);
NextPutModifiable(ptr, len);
newLength -= len;
}
if (newLength > m_lastSize)
{
size_t len = newLength - m_lastSize;
NextPutMaybeModifiable(inString, len, modifiable);
inString += len;
newLength -= len;
}
}
else
{
while (newLength >= m_blockSize + m_lastSize && m_queue.CurrentSize() >= m_blockSize)
{
NextPutModifiable(m_queue.GetBlock(), m_blockSize);
newLength -= m_blockSize;
}
if (newLength >= m_blockSize + m_lastSize && m_queue.CurrentSize() > 0)
{
assert(m_queue.CurrentSize() < m_blockSize);
size_t len = m_blockSize - m_queue.CurrentSize();
m_queue.Put(inString, len);
inString += len;
NextPutModifiable(m_queue.GetBlock(), m_blockSize);
newLength -= m_blockSize;
}
if (newLength >= m_blockSize + m_lastSize)
{
size_t len = RoundDownToMultipleOf(newLength - m_lastSize, m_blockSize);
NextPutMaybeModifiable(inString, len, modifiable);
inString += len;
newLength -= len;
}
}
}
m_queue.Put(inString, newLength - m_queue.CurrentSize());
}
if (messageEnd)
{
if (!m_firstInputDone && m_firstSize==0)
FirstPut(NULL);
SecByteBlock temp(m_queue.CurrentSize());
m_queue.GetAll(temp);
LastPut(temp, temp.size());
m_firstInputDone = false;
m_queue.ResetQueue(1, m_firstSize);
// Cast to void to supress Coverity finding
(void)Output(1, NULL, 0, messageEnd, blocking);
}
return 0;
}
