ksocketbuffer.cpp
/* -*- C++ -*-
* Copyright (C) 2003 Thiago Macieira <thiago.macieira@kdemail.net>
*
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
* LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include <config.h>
#include <assert.h>
#include <string.h>
#include "ksocketbase.h"
#include "ksocketbuffer_p.h"
using namespace KNetwork;
using namespace KNetwork::Internal;
KSocketBuffer::KSocketBuffer(Q_LONG size)
: m_mutex(true), m_offset(0), m_size(size), m_length(0)
{
}
KSocketBuffer::KSocketBuffer(const KSocketBuffer& other)
: KIOBufferBase(other), m_mutex(true)
{
*this = other;
}
KSocketBuffer::~KSocketBuffer()
{
// QValueList takes care of deallocating memory
}
KSocketBuffer& KSocketBuffer::operator=(const KSocketBuffer& other)
{
QMutexLocker locker1(&m_mutex);
QMutexLocker locker2(&other.m_mutex);
KIOBufferBase::operator=(other);
m_list = other.m_list; // copy-on-write
m_offset = other.m_offset;
m_size = other.m_size;
m_length = other.m_length;
return *this;
}
bool KSocketBuffer::canReadLine() const
{
QMutexLocker locker(&m_mutex);
QValueListConstIterator<QByteArray> it = m_list.constBegin(),
end = m_list.constEnd();
QIODevice::Offset offset = m_offset;
// walk the buffer
for ( ; it != end; ++it)
{
if ((*it).find('\n', offset) != -1)
return true;
if ((*it).find('\r', offset) != -1)
return true;
offset = 0;
}
return false; // not found
}
QCString KSocketBuffer::readLine()
{
if (!canReadLine())
return QCString(); // empty
QMutexLocker locker(&m_mutex);
// find the offset of the newline in the buffer
int newline = 0;
QValueListConstIterator<QByteArray> it = m_list.constBegin(),
end = m_list.constEnd();
QIODevice::Offset offset = m_offset;
// walk the buffer
for ( ; it != end; ++it)
{
int posnl = (*it).find('\n', offset);
if (posnl == -1)
{
// not found in this one
newline += (*it).size();
offset = 0;
continue;
}
// we found it
newline += posnl;
break;
}
QCString result(newline + 2 - m_offset);
consumeBuffer(result.data(), newline + 1 - m_offset);
return result;
}
Q_LONG KSocketBuffer::length() const
{
return m_length;
}
Q_LONG KSocketBuffer::size() const
{
return m_size;
}
bool KSocketBuffer::setSize(Q_LONG size)
{
m_size = size;
if (size == -1 || m_length < m_size)
return true;
// size is now smaller than length
QMutexLocker locker(&m_mutex);
// repeat the test
if (m_length < m_size)
return true;
// discard from the beginning
return (m_length - m_size) == consumeBuffer(0L, m_length - m_size, true);
}
Q_LONG KSocketBuffer::feedBuffer(const char *data, Q_LONG len)
{
if (data == 0L || len == 0)
return 0; // nothing to write
if (isFull())
return -1; // can't write
QMutexLocker locker(&m_mutex);
// verify if we can add len bytes
if (m_size != -1 && (m_size - m_length) < len)
len = m_size - m_length;
QByteArray a(len);
a.duplicate(data, len);
m_list.append(a);
m_length += len;
return len;
}
Q_LONG KSocketBuffer::consumeBuffer(char *destbuffer, Q_LONG maxlen, bool discard)
{
if (maxlen == 0 || isEmpty())
return 0;
QValueListIterator<QByteArray> it = m_list.begin(),
end = m_list.end();
QIODevice::Offset offset = m_offset;
Q_LONG copied = 0;
// walk the buffer
while (it != end && maxlen)
{
// calculate how much we'll copy
size_t to_copy = (*it).size() - offset;
if (to_copy > maxlen)
to_copy = maxlen;
// do the copying
if (destbuffer)
memcpy(destbuffer + copied, (*it).data() + offset, to_copy);
maxlen -= to_copy;
copied += to_copy;
if ((*it).size() - offset > to_copy)
{
// we did not copy everything
offset += to_copy;
break;
}
else
{
// we copied everything
// discard this element;
offset = 0;
if (discard)
it = m_list.remove(it);
else
++it;
}
}
if (discard)
{
m_offset = offset;
m_length -= copied;
assert(m_length >= 0);
}
return copied;
}
void KSocketBuffer::clear()
{
QMutexLocker locker(&m_mutex);
m_list.clear();
m_offset = 0;
m_length = 0;
}
Q_LONG KSocketBuffer::sendTo(KActiveSocketBase* dev, Q_LONG len)
{
if (len == 0 || isEmpty())
return 0;
QMutexLocker locker(&m_mutex);
QValueListIterator<QByteArray> it = m_list.begin(),
end = m_list.end();
QIODevice::Offset offset = m_offset;
Q_LONG written = 0;
// walk the buffer
while (it != end && (len || len == -1))
{
// we have to write each element up to len bytes
// but since we can have several very small buffers, we can make things
// better by concatenating a few of them into a big buffer
// question is: how big should that buffer be? 2 kB should be enough
Q_ULONG bufsize = 1460;
if (len != -1 && len < bufsize)
bufsize = len;
QByteArray buf(bufsize);
Q_LONG count = 0;
while (it != end && count + ((*it).size() - offset) <= bufsize)
{
memcpy(buf.data() + count, (*it).data() + offset, (*it).size() - offset);
count += (*it).size() - offset;
offset = 0;
++it;
}
// see if we can still fit more
if (count < bufsize && it != end)
{
// getting here means this buffer (*it) is larger than
// (bufsize - count) (even for count == 0).
memcpy(buf.data() + count, (*it).data() + offset, bufsize - count);
offset += bufsize - count;
count = bufsize;
}
// now try to write those bytes
Q_LONG wrote = dev->writeBlock(buf, count);
if (wrote == -1)
// error?
break;
written += wrote;
if (wrote != count)
// can't fit more?
break;
}
// discard data that has been written
// this updates m_length too
if (written)
consumeBuffer(0L, written);
return written;
}
Q_LONG KSocketBuffer::receiveFrom(KActiveSocketBase* dev, Q_LONG len)
{
if (len == 0 || isFull())
return 0;
QMutexLocker locker(&m_mutex);
if (len == -1)
len = dev->bytesAvailable();
if (len <= 0)
// error or closing socket
return len;
// see if we can read that much
if (m_size != -1 && len > (m_size - m_length))
len = m_size - m_length;
// here, len contains just as many bytes as we're supposed to read
// now do the reading
QByteArray a(len);
len = dev->readBlock(a.data(), len);
if (len == -1)
// error?
return -1;
// success
// resize the buffer and add it
a.truncate(len);
m_list.append(a);
m_length += len;
return len;
}
KNetwork::KActiveSocketBase::readBlock
virtual Q_LONG readBlock(char *data, Q_ULONG len)=0
Reads data from the socket.
KNetwork::KActiveSocketBase
Abstract class for active sockets.
Definition: ksocketbase.h:443
KNetwork::KActiveSocketBase::bytesAvailable
virtual Q_LONG bytesAvailable() const =0
Returns the number of bytes available for reading without blocking.
KNetwork::KActiveSocketBase::writeBlock
virtual Q_LONG writeBlock(const char *data, Q_ULONG len)=0
Writes the given data to the socket.
KIOBufferBase
base for I/O buffer implementation
Definition: kiobuffer.h:45
KShortcut::remove
void remove(const KKeySequence &keySeq)
Removes the given key sequence from this shortcut.
Definition: kshortcut.cpp:569
KIOBufferBase::operator=
KIOBufferBase & operator=(const KIOBufferBase &)
Assignment operator.
Definition: kiobuffer.h:69
KStdAccel::end
const KShortcut & end()
Goto end of the document.
Definition: kstdaccel.cpp:289

KDE Home | KDE Accessibility Home | Description of Access Keys