/*
  Copyright (C) 2007 Klarälvdalens Datakonsult AB

  KDPipeIODevice is free software; you can redistribute it and/or
  modify it under the terms of the GNU Library General Public
  License as published by the Free Software Foundation; either
  version 2 of the License, or (at your option) any later version.

  KDPipeIODevice is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Library General Public License for more details.

  You should have received a copy of the GNU Library General Public License
  along with KDPipeIODevice; see the file COPYING.LIB.  If not, write to the
  Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  Boston, MA 02110-1301, USA.
*/

#include "kdpipeiodevice.h"

#include <QtCore>

#include <cassert>
#include <memory>
#include <algorithm>

#ifdef Q_OS_WIN32
# ifndef NOMINMAX
#  define NOMINMAX
# endif
# include <windows.h>
# include <io.h>
#else
# include <unistd.h>
# include <errno.h>
#endif

using namespace _gpgme_;

#ifndef KDAB_CHECK_THIS
# define KDAB_CHECK_CTOR (void)1
# define KDAB_CHECK_DTOR KDAB_CHECK_CTOR
# define KDAB_CHECK_THIS KDAB_CHECK_CTOR
#endif

#define LOCKED( d ) const QMutexLocker locker( &d->mutex )
#define synchronized( d ) if ( int i = 0 ) {} else for ( const QMutexLocker locker( &d->mutex ) ; !i ; ++i )

const unsigned int BUFFER_SIZE = 4096;
const bool ALLOW_QIODEVICE_BUFFERING = true;

// comment to get trace output:
//#define qDebug if(1){}else qDebug

namespace {
class Reader : public QThread {
    Q_OBJECT
public:
    Reader( int fd, Qt::HANDLE handle );
    ~Reader();

    qint64 readData( char * data, qint64 maxSize );

    unsigned int bytesInBuffer() const {
        return ( wptr + sizeof buffer - rptr ) % sizeof buffer ;
    }

    bool bufferFull() const {
        return bytesInBuffer() == sizeof buffer - 1;
    }

    bool bufferEmpty() const {
	return bytesInBuffer() == 0;
    }

    bool bufferContains( char ch ) {
	const unsigned int bib = bytesInBuffer();
	for ( unsigned int i = rptr ; i < rptr + bib ; ++i )
	    if ( buffer[i%sizeof buffer] == ch )
		return true;
	return false;
    }
        
    void notifyReadyRead();

Q_SIGNALS:
    void readyRead();

protected:
    /* reimp */ void run();

private:
    int fd;
    Qt::HANDLE handle;
public:
    QMutex mutex;
    QWaitCondition waitForCancelCondition;
    QWaitCondition bufferNotFullCondition;
    QWaitCondition bufferNotEmptyCondition;
    QWaitCondition hasStarted;
    QWaitCondition readyReadSentCondition;
    QWaitCondition blockedConsumerIsDoneCondition;
    bool cancel;
    bool eof;
    bool error;
    bool eofShortCut;
    int errorCode;
    bool isReading;
    bool consumerBlocksOnUs;
   
private:
    unsigned int rptr, wptr;
    char buffer[BUFFER_SIZE+1]; // need to keep one byte free to detect empty state
};


Reader::Reader( int fd_, Qt::HANDLE handle_ )
    : QThread(),
      fd( fd_ ),
      handle( handle_ ),
      mutex(),
      bufferNotFullCondition(),
      bufferNotEmptyCondition(),
      hasStarted(),
      cancel( false ),
      eof( false ),
      error( false ),
      eofShortCut( false ),
      errorCode( 0 ),
      isReading( false ),
      consumerBlocksOnUs( false ),
      rptr( 0 ), wptr( 0 )
{
    
}

Reader::~Reader() {}


class Writer : public QThread {
    Q_OBJECT
public:
    Writer( int fd, Qt::HANDLE handle );
    ~Writer();

    qint64 writeData( const char * data, qint64 size );

    unsigned int bytesInBuffer() const { return numBytesInBuffer; }

    bool bufferFull() const {
        return numBytesInBuffer == sizeof buffer;
    }

    bool bufferEmpty() const {
	return numBytesInBuffer == 0;
    }

Q_SIGNALS:
    void bytesWritten( qint64 );

protected:
    /* reimp */ void run();

private:
    int fd;
    Qt::HANDLE handle;
public:
    QMutex mutex;
    QWaitCondition bufferEmptyCondition;
    QWaitCondition bufferNotEmptyCondition;
    QWaitCondition hasStarted;
    bool cancel;
    bool error;
    int errorCode;
private:
    unsigned int numBytesInBuffer;
    char buffer[BUFFER_SIZE];
};
}

Writer::Writer( int fd_, Qt::HANDLE handle_ )
    : QThread(),
      fd( fd_ ),
      handle( handle_ ),
      mutex(),
      bufferEmptyCondition(),
      bufferNotEmptyCondition(),
      hasStarted(),
      cancel( false ),
      error( false ),
      errorCode( 0 ),
      numBytesInBuffer( 0 )
{

}

Writer::~Writer() {}


class KDPipeIODevice::Private : public QObject {
Q_OBJECT
    friend class ::KDPipeIODevice;
    KDPipeIODevice * const q;
public:
    explicit Private( KDPipeIODevice * qq );
    ~Private();

    bool doOpen( int, Qt::HANDLE, OpenMode );
    bool startReaderThread(); 
    bool startWriterThread(); 
    void stopThreads();

public Q_SLOTS:
    void emitReadyRead();
 
private:
    int fd;
    Qt::HANDLE handle;
    Reader * reader;
    Writer * writer;
    bool triedToStartReader;
    bool triedToStartWriter;
};

KDPipeIODevice::Private::Private( KDPipeIODevice * qq )
    : QObject( qq ), q( qq ),
      fd( -1 ),
      handle( 0 ),
      reader( 0 ),
      writer( 0 ),
      triedToStartReader( false ), triedToStartWriter( false ) 
{

}

KDPipeIODevice::Private::~Private() {
    qDebug( "KDPipeIODevice::~Private(): Destroying %p", q );
}

KDPipeIODevice::KDPipeIODevice( QObject * p )
    : QIODevice( p ), d( new Private( this ) )
{
    KDAB_CHECK_CTOR;
}

KDPipeIODevice::KDPipeIODevice( int fd, OpenMode mode, QObject * p )
    : QIODevice( p ), d( new Private( this ) )
{
    KDAB_CHECK_CTOR;
    open( fd, mode );
}

KDPipeIODevice::KDPipeIODevice( Qt::HANDLE handle, OpenMode mode, QObject * p )
    : QIODevice( p ), d( new Private( this ) )
{
    KDAB_CHECK_CTOR;
    open( handle, mode );
}

KDPipeIODevice::~KDPipeIODevice() { KDAB_CHECK_DTOR;
    if ( isOpen() )
	close();
    delete d; d = 0;
}


bool KDPipeIODevice::open( int fd, OpenMode mode ) { KDAB_CHECK_THIS;

#ifdef Q_OS_WIN32
    return d->doOpen( fd, (HANDLE)_get_osfhandle( fd ), mode );
#else
    return d->doOpen( fd, 0, mode );
#endif

}

bool KDPipeIODevice::open( Qt::HANDLE h, OpenMode mode ) { KDAB_CHECK_THIS;

#ifdef Q_OS_WIN32
    return d->doOpen( -1, h, mode );
#else
    Q_UNUSED( h );
    Q_UNUSED( mode );
    assert( !"KDPipeIODevice::open( Qt::HANDLE, OpenMode ) should never be called except on Windows." );
#endif

}

bool KDPipeIODevice::Private::startReaderThread()
{
   if ( triedToStartReader )
       return true;
   triedToStartReader = true;    
   if ( reader && !reader->isRunning() && !reader->isFinished() ) {
       qDebug("KDPipeIODevice::Private::startReaderThread(): locking reader (CONSUMER THREAD)" );
       LOCKED( reader );
       qDebug("KDPipeIODevice::Private::startReaderThread(): locked reader (CONSUMER THREAD)" );
       reader->start( QThread::HighestPriority );
       qDebug("KDPipeIODevice::Private::startReaderThread(): waiting for hasStarted (CONSUMER THREAD)" );
       const bool hasStarted = reader->hasStarted.wait( &reader->mutex, 1000 );
       qDebug("KDPipeIODevice::Private::startReaderThread(): returned from hasStarted (CONSUMER THREAD)" );

       return hasStarted;
   }
   return true;
}

bool KDPipeIODevice::Private::startWriterThread()
{
   if ( triedToStartWriter )
       return true;
   triedToStartWriter = true;    
   if ( writer && !writer->isRunning() && !writer->isFinished() ) {
       LOCKED( writer );
       
       writer->start( QThread::HighestPriority );
       if ( !writer->hasStarted.wait( &writer->mutex, 1000 ) )
            return false;
   }
   return true;
}

void KDPipeIODevice::Private::emitReadyRead()
{
    QPointer<Private> thisPointer( this );
    qDebug( "KDPipeIODevice::Private::emitReadyRead %p", this );

    emit q->readyRead();

    if ( !thisPointer )
        return;

    bool mustNotify = false;

    if ( reader ) {
        qDebug( "KDPipeIODevice::Private::emitReadyRead %p: locking reader (CONSUMER THREAD)", this );
        synchronized( reader ) {
            qDebug( "KDPipeIODevice::Private::emitReadyRead %p: locked reader (CONSUMER THREAD)", this );
            reader->readyReadSentCondition.wakeAll();
            mustNotify = !reader->bufferEmpty() && reader->isReading;
            qDebug( "KDPipeIODevice::emitReadyRead %p: bufferEmpty: %d reader in ReadFile: %d", this, reader->bufferEmpty(), reader->isReading );
        }
    }
    if ( mustNotify )
        QTimer::singleShot( 100, this, SLOT( emitReadyRead() ) );  
    qDebug( "KDPipeIODevice::Private::emitReadyRead %p leaving", this );

}

bool KDPipeIODevice::Private::doOpen( int fd_, Qt::HANDLE handle_, OpenMode mode_ ) {

    if ( q->isOpen() )
	return false;

#ifdef Q_OS_WIN32
    if ( !handle_ )
	return false;
#else
    if ( fd_ < 0 )
	return false;
#endif

    if ( !(mode_ & ReadWrite) )
	return false; // need to have at least read -or- write


    std::auto_ptr<Reader> reader_;
    std::auto_ptr<Writer> writer_;

    if ( mode_ & ReadOnly ) {
	reader_.reset( new Reader( fd_, handle_ ) );
        qDebug( "KDPipeIODevice::doOpen (%p): created reader (%p) for fd %d", this, reader_.get(), fd_ ); 
	connect( reader_.get(), SIGNAL(readyRead()), this, SLOT(emitReadyRead()), 
Qt::QueuedConnection );
    }
    if ( mode_ & WriteOnly ) {
	writer_.reset( new Writer( fd_, handle_ ) );
        qDebug( "KDPipeIODevice::doOpen (%p): created writer (%p) for fd %d", this, writer_.get(), fd_ ); 
        connect( writer_.get(), SIGNAL(bytesWritten(qint64)), q, SIGNAL(bytesWritten(qint64)), 
Qt::QueuedConnection );
    }

    // commit to *this:
    fd = fd_;
    handle = handle_;
    reader = reader_.release();
    writer = writer_.release();

    q->setOpenMode( mode_|Unbuffered );
    return true;
}

int KDPipeIODevice::descriptor() const { KDAB_CHECK_THIS;
    return d->fd;
}


Qt::HANDLE KDPipeIODevice::handle() const { KDAB_CHECK_THIS;
    return d->handle;
}

qint64 KDPipeIODevice::bytesAvailable() const { KDAB_CHECK_THIS;
    const qint64 base = QIODevice::bytesAvailable();
    if ( !d->triedToStartReader ) {
         d->startReaderThread();
         return base;
    }
    if ( d->reader )
	synchronized( d->reader ) {
            const qint64 inBuffer = d->reader->bytesInBuffer();     
            return base + inBuffer;
       }
    return base;
}

qint64 KDPipeIODevice::bytesToWrite() const { KDAB_CHECK_THIS;
    d->startWriterThread();
    const qint64 base = QIODevice::bytesToWrite();
    if ( d->writer )
	synchronized( d->writer ) return base + d->writer->bytesInBuffer();
    return base;
}

bool KDPipeIODevice::canReadLine() const { KDAB_CHECK_THIS;
    d->startReaderThread();
   if ( QIODevice::canReadLine() )
	return true;
    if ( d->reader )
	synchronized( d->reader ) return d->reader->bufferContains( '\n' );
    return true;
}

bool KDPipeIODevice::isSequential() const {
    return true;
}

bool KDPipeIODevice::atEnd() const { KDAB_CHECK_THIS;
    d->startReaderThread();
    if ( !QIODevice::atEnd() ) {
	qDebug( "%p: KDPipeIODevice::atEnd returns false since QIODevice::atEnd does (with bytesAvailable=%ld)", this, static_cast<long>(bytesAvailable()) );
	return false;
    }
    if ( !isOpen() )
	return true;
    if ( d->reader->eofShortCut )
	return true;
    LOCKED( d->reader );
    const bool eof = ( d->reader->error || d->reader->eof ) && d->reader->bufferEmpty();
    if ( !eof ) {
	if ( !d->reader->error && !d->reader->eof )
	    qDebug( "%p: KDPipeIODevice::atEnd returns false since !reader->error && !reader->eof", this );
	if ( !d->reader->bufferEmpty() )
	    qDebug( "%p: KDPipeIODevice::atEnd returns false since !reader->bufferEmpty()", this );
    }
    return eof;
}

bool KDPipeIODevice::waitForBytesWritten( int msecs ) { KDAB_CHECK_THIS;
    d->startWriterThread();
    Writer * const w = d->writer;
    if ( !w )
	return true;
    LOCKED( w );
    qDebug( "KDPipeIODevice::waitForBytesWritten (%p,w=%p): entered locked area", this, w 
); 
    return w->bufferEmpty() || w->error || w->bufferEmptyCondition.wait( &w->mutex, msecs ) ;
}

bool KDPipeIODevice::waitForReadyRead( int msecs ) { KDAB_CHECK_THIS;
    qDebug( "KDPipeIODEvice::waitForReadyRead()(%p)", this);
    d->startReaderThread();
    if ( ALLOW_QIODEVICE_BUFFERING ) {
	if ( bytesAvailable() > 0 )
	    return true;
    }
    Reader * const r = d->reader;
    if ( !r || r->eofShortCut )
	return true;
    LOCKED( r );
    if ( r->bytesInBuffer() != 0 || r->eof || r->error )
        return true;

    return msecs >= 0 ? r->bufferNotEmptyCondition.wait( &r->mutex, msecs ) : r->bufferNotEmptyCondition.wait( &r->mutex );
}

template <typename T>
class TemporaryValue {
public:
   TemporaryValue( T& var_, const T& tv ) : var( var_ ), oldValue( var_ ) { var = tv; }
   ~TemporaryValue() { var = oldValue; }
private:   
   T& var;
   const T oldValue;
}; 


bool KDPipeIODevice::readWouldBlock() const
{
   d->startReaderThread();
   LOCKED( d->reader );
   return d->reader->bufferEmpty() && !d->reader->eof && !d->reader->error;
}  

bool KDPipeIODevice::writeWouldBlock() const
{
   d->startWriterThread();
   LOCKED( d->writer );
   return !d->writer->bufferEmpty() && !d->writer->error;
}  


qint64 KDPipeIODevice::readData( char * data, qint64 maxSize ) { KDAB_CHECK_THIS;
    qDebug( "%p: KDPipeIODevice::readData: data=%p, maxSize=%lld", this, data, maxSize );
    d->startReaderThread();
    Reader * const r = d->reader;

    assert( r );


    //assert( r->isRunning() ); // wrong (might be eof, error)
    assert( data || maxSize == 0 );
    assert( maxSize >= 0 );

    if ( r->eofShortCut ) {
	qDebug( "%p: KDPipeIODevice::readData: hit eofShortCut, returning 0", this );
	return 0;
    }

    if ( maxSize < 0 )
	maxSize = 0;

    if ( ALLOW_QIODEVICE_BUFFERING ) {
	if ( bytesAvailable() > 0 )
	    maxSize = std::min( maxSize, bytesAvailable() ); // don't block
    }
    qDebug( "%p: KDPipeIODevice::readData: try to lock reader (CONSUMER THREAD)", this );
    LOCKED( r );
    qDebug( "%p: KDPipeIODevice::readData: locked reader (CONSUMER THREAD)", this );

    r->readyReadSentCondition.wakeAll();
    if ( /* maxSize > 0 && */ r->bufferEmpty() &&  !r->error && !r->eof ) { // ### block on maxSize == 0?
	qDebug( "%p: KDPipeIODevice::readData: waiting for bufferNotEmptyCondition (CONSUMER THREAD)", this );
        const TemporaryValue<bool> tmp( d->reader->consumerBlocksOnUs, true );
	r->bufferNotEmptyCondition.wait( &r->mutex );
        r->blockedConsumerIsDoneCondition.wakeAll();
	qDebug( "%p: KDPipeIODevice::readData: woke up from bufferNotEmptyCondition (CONSUMER THREAD)", this ); 
    }

    if ( r->bufferEmpty() ) {
	qDebug( "%p: KDPipeIODevice::readData: got empty buffer, signal eof", this );
	// woken with an empty buffer must mean either EOF or error:
	assert( r->eof || r->error );
	r->eofShortCut = true;
	return r->eof ? 0 : -1 ;
    }

    qDebug( "%p: KDPipeIODevice::readData: got bufferNotEmptyCondition, trying to read %lld bytes", this, maxSize );
    const qint64 bytesRead = r->readData( data, maxSize );
    qDebug( "%p: KDPipeIODevice::readData: read %lld bytes", this, bytesRead );
    qDebug( "%p (fd=%d): KDPipeIODevice::readData: %s", this, d->fd, data );
 
    return bytesRead;
}

qint64 Reader::readData( char * data, qint64 maxSize ) {
    qint64 numRead = rptr < wptr ? wptr - rptr : sizeof buffer - rptr ;
    if ( numRead > maxSize )
	numRead = maxSize;

    qDebug( "%p: KDPipeIODevice::readData: data=%p, maxSize=%lld; rptr=%u, wptr=%u (bytesInBuffer=%u); -> numRead=%lld", this,
	    data, maxSize, rptr, wptr, bytesInBuffer(), numRead );

    std::memcpy( data, buffer + rptr, numRead );

    rptr = ( rptr + numRead ) % sizeof buffer ;

    if ( !bufferFull() ) {
	qDebug( "%p: KDPipeIODevice::readData: signal bufferNotFullCondition", this );
	bufferNotFullCondition.wakeAll();
    }

    return numRead;
}

qint64 KDPipeIODevice::writeData( const char * data, qint64 size ) { KDAB_CHECK_THIS;
    d->startWriterThread();
    Writer * const w = d->writer;

    assert( w );
    assert( w->error || w->isRunning() );
    assert( data || size == 0 );
    assert( size >= 0 );

    LOCKED( w );

    while ( !w->error && !w->bufferEmpty() ) { 
	qDebug( "%p: KDPipeIODevice::writeData: wait for empty buffer", this );
	w->bufferEmptyCondition.wait( &w->mutex );
	qDebug( "%p: KDPipeIODevice::writeData: empty buffer signaled", this );

    }
    if ( w->error )
	return -1;

    assert( w->bufferEmpty() );

    return w->writeData( data, size );
}

qint64 Writer::writeData( const char * data, qint64 size ) {
    assert( bufferEmpty() );

    if ( size > static_cast<qint64>( sizeof buffer ) )
	size = sizeof buffer;

    std::memcpy( buffer, data, size );
    
    numBytesInBuffer = size;

    if ( !bufferEmpty() ) {
	bufferNotEmptyCondition.wakeAll();
    }
   return size;
}

void KDPipeIODevice::Private::stopThreads()
{
    if ( triedToStartWriter )
    {
        if ( writer && q->bytesToWrite() > 0 )
	    q->waitForBytesWritten( -1 );

        assert( q->bytesToWrite() == 0 );
    }
    if ( Reader * & r = reader ) {
        disconnect( r, SIGNAL( readyRead() ), this, SLOT( emitReadyRead() ) ); 
	synchronized( r ) {
	    // tell thread to cancel:
	    r->cancel = true;
	    // and wake it, so it can terminate:
            r->waitForCancelCondition.wakeAll();
	    r->bufferNotFullCondition.wakeAll();
            r->readyReadSentCondition.wakeAll();
      	}
    }
    if ( Writer * & w = writer ) {
	synchronized( w ) {
	    // tell thread to cancel:
	    w->cancel = true;
	    // and wake it, so it can terminate:
	    w->bufferNotEmptyCondition.wakeAll();
	}
    }
}

void KDPipeIODevice::close() { KDAB_CHECK_THIS;
    qDebug( "KDPipeIODevice::close(%p)", this );
    if ( !isOpen() )
	return;

    // tell clients we're about to close:
    emit aboutToClose();
    d->stopThreads();

#define waitAndDelete( t ) if ( t ) { t->wait(); QThread* const t2 = t; t = 0; delete t2; }
    qDebug( "KPipeIODevice::close(%p): wait and closing writer %p", this, d->writer );
    waitAndDelete( d->writer );
    qDebug( "KPipeIODevice::close(%p): wait and closing reader %p", this, d->reader );
    if ( d->reader ) {
        LOCKED( d->reader );
        d->reader->readyReadSentCondition.wakeAll();
    }
    waitAndDelete( d->reader );
#undef waitAndDelete
#ifdef Q_OS_WIN32
    if ( d->fd != -1 )
        _close( d->fd );
    else
        CloseHandle( d->handle );
#else
    ::close( d->fd );
#endif

    setOpenMode( NotOpen );
    d->fd = -1;
    d->handle = 0;
}

void Reader::run() {

    LOCKED( this );

    // too bad QThread doesn't have that itself; a signal isn't enough
    hasStarted.wakeAll();

    qDebug( "%p: Reader::run: started", this );

    while ( true ) {
        if ( !cancel && ( eof || error ) ) {
            //notify the client until the buffer is empty and then once 
            //again so he receives eof/error. After that, wait for him 
            //to cancel 
            const bool wasEmpty = bufferEmpty();
	    qDebug( "%p: Reader::run: received eof(%d) or error(%d), waking everyone", this, eof, error );
            notifyReadyRead();
            if ( !cancel && wasEmpty ) 
                waitForCancelCondition.wait( &mutex );
        } else if ( !cancel && !bufferFull() && !bufferEmpty() ) {
	    qDebug( "%p: Reader::run: buffer no longer empty, waking everyone", this );
            notifyReadyRead();
        } 
 
        while ( !cancel && !error && bufferFull() ) {
            notifyReadyRead();
            if ( !cancel && bufferFull() ) {
                qDebug( "%p: Reader::run: buffer is full, going to sleep", this );
	        bufferNotFullCondition.wait( &mutex );
	    }
        }
        
	if ( cancel ) {
            qDebug( "%p: Reader::run: detected cancel", this );
	    goto leave;
	}

        if ( !eof && !error ) {
            if ( rptr == wptr ) // optimize for larger chunks in case the buffer is empty
	        rptr = wptr = 0;

            unsigned int numBytes = ( rptr + sizeof buffer - wptr - 1 ) % sizeof buffer;
	    if ( numBytes > sizeof buffer - wptr )
	        numBytes = sizeof buffer - wptr;

	    qDebug( "%p: Reader::run: rptr=%d, wptr=%d -> numBytes=%d", this, rptr, wptr, numBytes );

	    assert( numBytes > 0 );

	    qDebug( "%p: Reader::run: trying to read %d bytes", this, numBytes );
#ifdef Q_OS_WIN32
            isReading = true;
	    mutex.unlock();
            DWORD numRead;
	    const bool ok = ReadFile( handle, buffer + wptr, numBytes, &numRead, 0 );
	    mutex.lock();
            isReading = false;
	    if ( ok ) {
                if ( numRead == 0 ) {
                    qDebug( "%p: Reader::run: got eof (numRead==0)", this );
                    eof = true;
                } 
            } else { // !ok
	        errorCode = static_cast<int>( GetLastError() );
	        if ( errorCode == ERROR_BROKEN_PIPE ) {
                    assert( numRead == 0 );
                    qDebug( "%p: Reader::run: got eof (broken pipe)", this );
		    eof = true;
	        } else {
                    assert( numRead == 0 );
		    qDebug( "%p: Reader::run: got error: %s (%d)", this, strerror( errorCode ), errorCode );
		    error = true;
	        }
	    }
#else
	    qint64 numRead;
	    mutex.unlock();
	    do {
	        numRead = ::read( fd, buffer + wptr, numBytes );
	    } while ( numRead == -1 && errno == EINTR );
	    mutex.lock();

	    if ( numRead < 0 ) {
	        errorCode = errno;
	        error = true;
	        qDebug( "%p: Reader::run: got error: %d", this, errorCode );
            } else if ( numRead == 0 ) {
	        qDebug( "%p: Reader::run: eof detected", this );  
                eof = true;
            }
#endif
	    qDebug( "%p: Reader::run: read %ld bytes", this, static_cast<long>(numRead) );
	    qDebug( "%p: Reader::run(fd=%d): %s", this, fd, buffer );

	    if ( numRead > 0 ) {
	        qDebug( "%p: Reader::run: buffer before: rptr=%4d, wptr=%4d", this, rptr, wptr );
	        wptr = ( wptr + numRead ) % sizeof buffer;
	        qDebug( "%p: Reader::run: buffer after:  rptr=%4d, wptr=%4d", this, rptr, wptr );
            }
        }
    }
 leave:
    qDebug( "%p: Reader::run: terminated", this );
}

void Reader::notifyReadyRead()
{
    qDebug( "notifyReadyRead: %d bytes available", bytesInBuffer() );
    assert( !cancel );

    if ( consumerBlocksOnUs ) {
        bufferNotEmptyCondition.wakeAll();
        blockedConsumerIsDoneCondition.wait( &mutex );
        return;
    }
    qDebug( "notifyReadyRead: emit signal" );
    emit readyRead();
    readyReadSentCondition.wait( &mutex );
    qDebug( "notifyReadyRead: returning from waiting, leave" );
}

void Writer::run() {

    LOCKED( this );

    // too bad QThread doesn't have that itself; a signal isn't enough
    hasStarted.wakeAll();

    qDebug( "%p: Writer::run: started", this );

    while ( true ) {

	while ( !cancel && bufferEmpty() ) {
	    qDebug( "%p: Writer::run: buffer is empty, wake bufferEmptyCond listeners", this );
            bufferEmptyCondition.wakeAll();
            emit bytesWritten( 0 );
	    qDebug( "%p: Writer::run: buffer is empty, going to sleep", this );
            bufferNotEmptyCondition.wait( &mutex );
	    qDebug( "%p: Writer::run: woke up", this );
	}

	if ( cancel ) {
	    qDebug( "%p: Writer::run: detected cancel", this );
	    goto leave;
	}

	assert( numBytesInBuffer > 0 );

	qDebug( "%p: Writer::run: Trying to write %u bytes", this, numBytesInBuffer );
	qint64 totalWritten = 0;
	do {  
            mutex.unlock();
#ifdef Q_OS_WIN32
            DWORD numWritten;
            qDebug( "%p (fd=%d): Writer::run: buffer before WriteFile (numBytes=%lld): %s:", this, fd, numBytesInBuffer, buffer ); 
            qDebug( "%p (fd=%d): Writer::run: Going into WriteFile", this, fd );
	    if ( !WriteFile( handle, buffer + totalWritten, numBytesInBuffer - totalWritten, &numWritten, 0 ) ) {
		mutex.lock();
		errorCode = static_cast<int>( GetLastError() );
		qDebug( "%p: Writer::run: got error code: %d", this, errorCode );
		error = true;
                goto leave;
	    }
#else
	    qint64 numWritten;
	    do {
		numWritten = ::write( fd, buffer + totalWritten, numBytesInBuffer - totalWritten );
	    } while ( numWritten == -1 && errno == EINTR );

	    if ( numWritten < 0 ) {
	        mutex.lock();
		errorCode = errno;
		qDebug( "%p: Writer::run: got error code: %d", this, errorCode );
		error = true;
                goto leave;
	    }
#endif
            qDebug( "%p (fd=%d): Writer::run: buffer after WriteFile (numBytes=%u): %s:", this, fd, numBytesInBuffer, buffer );
	    totalWritten += numWritten;
            mutex.lock();
	} while ( totalWritten < numBytesInBuffer );

	qDebug( "%p: Writer::run: wrote %lld bytes", this, totalWritten );

	numBytesInBuffer = 0;

	qDebug( "%p: Writer::run: buffer is empty, wake bufferEmptyCond listeners", this );
	bufferEmptyCondition.wakeAll();
	emit bytesWritten( totalWritten );
    }
 leave:
    qDebug( "%p: Writer::run: terminating", this );
    numBytesInBuffer = 0;
    qDebug( "%p: Writer::run: buffer is empty, wake bufferEmptyCond listeners", this );
    bufferEmptyCondition.wakeAll();
    emit bytesWritten( 0 );
}

// static 
std::pair<KDPipeIODevice*,KDPipeIODevice*> KDPipeIODevice::makePairOfConnectedPipes() {
    KDPipeIODevice * read = 0;
    KDPipeIODevice * write = 0;
#ifdef Q_OS_WIN32
    HANDLE rh;
    HANDLE wh;
    SECURITY_ATTRIBUTES sa;
    memset( &sa, 0, sizeof(sa) );
    sa.nLength = sizeof(sa);
    sa.bInheritHandle = TRUE;
	if ( CreatePipe( &rh, &wh, &sa, BUFFER_SIZE ) ) {
	read = new KDPipeIODevice;
	read->open( rh, ReadOnly );
	write = new KDPipeIODevice;
	write->open( wh, WriteOnly );
    }
#else
    int fds[2];
    if ( pipe( fds ) == 0 ) {
	read = new KDPipeIODevice;
	read->open( fds[0], ReadOnly );
	write = new KDPipeIODevice;
	write->open( fds[1], WriteOnly );
    }
#endif
    return std::make_pair( read, write );
}

#ifdef KDAB_DEFINE_CHECKS
KDAB_DEFINE_CHECKS( KDPipeIODevice ) {
    if ( !isOpen() ) {
	assert( openMode() == NotOpen );
	assert( !d->reader );
	assert( !d->writer );
#ifdef Q_OS_WIN32
	assert( !d->handle );
#else
	assert( d->fd < 0 );
#endif
    } else {
	assert( openMode() != NotOpen );
	assert( openMode() & ReadWrite );
	if ( openMode() & ReadOnly ) {
	    assert( d->reader );
	    synchronized( d->reader )
		assert( d->reader->eof || d->reader->error || d->reader->isRunning() );
	}
	if ( openMode() & WriteOnly ) {
	    assert( d->writer );
	    synchronized( d->writer )
		assert( d->writer->error || d->writer->isRunning() );
	}
#ifdef Q_OS_WIN32
	assert( d->handle );
#else
	assert( d->fd >= 0 );
#endif
    }
}
#endif // KDAB_DEFINE_CHECKS

#include "moc_kdpipeiodevice.cpp"
#include "kdpipeiodevice.moc"