bool ScASCII85EncodeFilter::closeFilter()
{
bool success = true;
if (m_buffer_pending)
{
char* writeBuffer = m_buffer.data();
writeBuffer[m_buffer_pending] = 0;
success &= writeDataInternal((const char*) writeBuffer, m_buffer_pending);
}
if (m_four_tuple_pending)
{
quint32 value;
const char* ascii85;
unsigned char five_tuple[6];
bool allZero;
memset (m_four_tuple + m_four_tuple_pending, 0, 4 - m_four_tuple_pending);
value = m_four_tuple[0] << 24 | m_four_tuple[1] << 16 | m_four_tuple[2] << 8 | m_four_tuple[3];
ascii85 = toAscii85(value, allZero);
memcpy (five_tuple, ascii85, 5);
five_tuple[m_four_tuple_pending + 1] = 0;
int five_tuple_len = strlen((const char* ) five_tuple);
success &= writeDataInternal((const char* ) five_tuple, five_tuple_len);
}
success &= writeDataInternal("~>\n", 3);
success &= ScStreamFilter::closeFilter();
return success;
}
bool ScRC4EncodeFilter::writeData(const char* data, int dataLen)
{
bool rc4Success = true;
unsigned int count;
const unsigned char *p = (const unsigned char *) data;
if (!m_filterData)
return false;
while (dataLen) {
count = dataLen;
if (count > BUFFER_SIZE - m_filterData->available_in)
count = BUFFER_SIZE - m_filterData->available_in;
memcpy (m_filterData->input_buffer + m_filterData->available_in, p, count);
p += count;
m_filterData->available_in += count;
dataLen -= count;
if (m_filterData->available_in == BUFFER_SIZE)
{
rc4_encrypt(&m_filterData->rc4_context, m_filterData->input_buffer, m_filterData->output_buffer, m_filterData->available_in);
rc4Success &= writeDataInternal((const char*) m_filterData->output_buffer, m_filterData->available_in);
m_filterData->available_in = 0;
}
}
return rc4Success;
}
bool ScRC4EncodeFilter::closeFilter(void)
{
bool closeSucceed = true;
if (m_filterData->available_in > 0)
{
rc4_encrypt(&m_filterData->rc4_context, m_filterData->input_buffer, m_filterData->output_buffer, m_filterData->available_in);
closeSucceed &= writeDataInternal((const char*) m_filterData->output_buffer, m_filterData->available_in);
}
m_openedFilter = false;
closeSucceed &= ScStreamFilter::closeFilter();
return closeSucceed;
}
bool ScASCII85EncodeFilter::writeData(const char* data, int dataLen)
{
bool writeSuccess = true;
int lineLength = 0;
bool allZero = true;
const char* ascii85;
quint32 value;
int maxWrite = m_buffer.size() - (m_buffer.size() % 5) - 5;
if (maxWrite <= 5) return 0;
const unsigned char *ptr = (const unsigned char*) data;
unsigned char* writeBuffer = (unsigned char*) m_buffer.data();
unsigned char* ptrw = writeBuffer + m_buffer_pending;
while (dataLen)
{
m_four_tuple[m_four_tuple_pending++] = *ptr++;
dataLen--;
if (m_four_tuple_pending == 4)
{
value = m_four_tuple[0] << 24 | m_four_tuple[1] << 16 | m_four_tuple[2] << 8 | m_four_tuple[3];
ascii85 = toAscii85(value, allZero);
if (allZero)
*ptrw++ = 'z';
else
{
*ptrw++ = ascii85[0];
*ptrw++ = ascii85[1];
*ptrw++ = ascii85[2];
*ptrw++ = ascii85[3];
*ptrw++ = ascii85[4];
}
lineLength += ((allZero) ? 1 : 5);
m_buffer_pending += ((allZero) ? 1 : 5);
if (lineLength > 75)
{
*ptrw++ = '\n';
++m_buffer_pending;
lineLength = 0;
}
if (m_buffer_pending > maxWrite)
{
writeSuccess &= writeDataInternal((const char*) writeBuffer, m_buffer_pending);
ptrw = writeBuffer;
m_buffer_pending = 0;
}
m_four_tuple_pending = 0;
}
}
return writeSuccess;
}
void XMPPLayer::writeData(const std::string& data) {
writeDataInternal(createSafeByteArray(data));
}
void XMPPLayer::writeElement(boost::shared_ptr<Element> element) {
writeDataInternal(xmppSerializer_->serializeElement(element));
}
void XMPPLayer::writeFooter() {
writeDataInternal(createSafeByteArray(xmppSerializer_->serializeFooter()));
}
void XMPPLayer::writeHeader(const ProtocolHeader& header) {
writeDataInternal(createSafeByteArray(xmppSerializer_->serializeHeader(header)));
}
