/* dataprovider.cpp

   Copyright (C) 2004 Klarävdalens Datakonsult AB

    Copyright (c) 2016 by Bundesamt für Sicherheit in der Informationstechnik

    Software engineering by Intevation GmbH

   This file is part of QGPGME.

   QGPGME 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.

   QGPGME 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 QGPGME; see the file COPYING.LIB.  If not, write to the

   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

   Boston, MA 02110-1301, USA. */

// -*- c++ -*-

#ifdef HAVE_CONFIG_H

 #include "config.h"

#endif

#include <dataprovider.h>

#include <error.h>

#include <QIODevice>

#include <QProcess>

#include <cstdio>

#include <cstring>

#include <cassert>

using namespace QGpgME;

using namespace GpgME;

//

//

// QByteArrayDataProvider

//

//

static bool resizeAndInit(QByteArray &ba, size_t newSize)

{

    const size_t oldSize = ba.size();

    ba.resize(newSize);

    const bool ok = (newSize == static_cast<size_t>(ba.size()));

    if (ok) {

        memset(ba.data() + oldSize, 0, newSize - oldSize);

    }

    return ok;

}

QByteArrayDataProvider::QByteArrayDataProvider()

    : GpgME::DataProvider(), mOff(0) {}

QByteArrayDataProvider::QByteArrayDataProvider(const QByteArray &initialData)

    : GpgME::DataProvider(), mArray(initialData), mOff(0) {}

QByteArrayDataProvider::~QByteArrayDataProvider() {}

ssize_t QByteArrayDataProvider::read(void *buffer, size_t bufSize)

{

#ifndef NDEBUG

    //qDebug( "QByteArrayDataProvider::read( %p, %d )", buffer, bufSize );

#endif

    if (bufSize == 0) {

        return 0;

    }

    if (!buffer) {

        Error::setSystemError(GPG_ERR_EINVAL);

        return -1;

    }

    if (mOff >= mArray.size()) {

        return 0; // EOF

    }

    size_t amount = qMin(bufSize, static_cast<size_t>(mArray.size() - mOff));

    assert(amount > 0);

    memcpy(buffer, mArray.data() + mOff, amount);

    mOff += amount;

    return amount;

}

ssize_t QByteArrayDataProvider::write(const void *buffer, size_t bufSize)

{

#ifndef NDEBUG

    //qDebug( "QByteArrayDataProvider::write( %p, %lu )", buffer, static_cast<unsigned long>( bufSize ) );

#endif

    if (bufSize == 0) {

        return 0;

    }

    if (!buffer) {

        Error::setSystemError(GPG_ERR_EINVAL);

        return -1;

    }

    if (mOff >= mArray.size()) {

        resizeAndInit(mArray, mOff + bufSize);

    }

    if (mOff >= mArray.size()) {

        Error::setSystemError(GPG_ERR_EIO);

        return -1;

    }

    assert(bufSize <= static_cast<size_t>(mArray.size()) - mOff);

    memcpy(mArray.data() + mOff, buffer, bufSize);

    mOff += bufSize;

    return bufSize;

}

off_t QByteArrayDataProvider::seek(off_t offset, int whence)

{

#ifndef NDEBUG

    //qDebug( "QByteArrayDataProvider::seek( %d, %d )", int(offset), whence );

#endif

    int newOffset = mOff;

    switch (whence) {

    case SEEK_SET:

        newOffset = offset;

        break;

    case SEEK_CUR:

        newOffset += offset;

        break;

    case SEEK_END:

        newOffset = mArray.size() + offset;

        break;

    default:

        Error::setSystemError(GPG_ERR_EINVAL);

        return (off_t) - 1;

    }

    return mOff = newOffset;

}

void QByteArrayDataProvider::release()

{

#ifndef NDEBUG

    //qDebug( "QByteArrayDataProvider::release()" );

#endif

    mArray = QByteArray();

}

//

//

// QIODeviceDataProvider

//

//

QIODeviceDataProvider::QIODeviceDataProvider(const std::shared_ptr<QIODevice> &io)

    : GpgME::DataProvider(),

      mIO(io),

      mErrorOccurred(false),

      mHaveQProcess(qobject_cast<QProcess *>(io.get()))

{

    assert(mIO);

}

QIODeviceDataProvider::~QIODeviceDataProvider() {}

bool QIODeviceDataProvider::isSupported(Operation op) const

{

    const QProcess *const proc = qobject_cast<QProcess *>(mIO.get());

    bool canRead = true;

    if (proc) {

        canRead = proc->readChannel() == QProcess::StandardOutput;

    }

    switch (op) {

    case Read:    return mIO->isReadable() && canRead;

    case Write:   return mIO->isWritable();

    case Seek:    return !mIO->isSequential();

    case Release: return true;

    default:      return false;

    }

}

static qint64 blocking_read(const std::shared_ptr<QIODevice> &io, char *buffer, qint64 maxSize)

{

    while (!io->bytesAvailable()) {

        if (!io->waitForReadyRead(-1)) {

            if (const QProcess *const p = qobject_cast<QProcess *>(io.get())) {

                if (p->error() == QProcess::UnknownError &&

                        p->exitStatus() == QProcess::NormalExit &&

                        p->exitCode() == 0) {

                    if (io->atEnd()) {

                        // EOF

                        return 0;

                    } // continue reading even if process ended to ensure

                      // everything is read.

                } else {

                    Error::setSystemError(GPG_ERR_EIO);

                    return -1;

                }

            } else {

                return 0; // assume EOF (loses error cases :/ )

            }

        }

    }

    return io->read(buffer, maxSize);

}

ssize_t QIODeviceDataProvider::read(void *buffer, size_t bufSize)

{

#ifndef NDEBUG

    //qDebug( "QIODeviceDataProvider::read( %p, %lu )", buffer, bufSize );

#endif

    if (bufSize == 0) {

        return 0;

    }

    if (!buffer) {

        Error::setSystemError(GPG_ERR_EINVAL);

        return -1;

    }

    const qint64 numRead = mHaveQProcess

                           ? blocking_read(mIO, static_cast<char *>(buffer), bufSize)

                           : mIO->read(static_cast<char *>(buffer), bufSize);

    //workaround: some QIODevices (known example: QProcess) might not return 0 (EOF), but immediately -1 when finished. If no

    //errno is set, gpgme doesn't detect the error and loops forever. So return 0 on the very first -1 in case errno is 0

    ssize_t rc = numRead;

    if (numRead < 0 && !Error::hasSystemError()) {

        if (mErrorOccurred) {

            Error::setSystemError(GPG_ERR_EIO);

        } else {

            rc = 0;

        }

    }

    if (numRead < 0) {

        mErrorOccurred = true;

    }

    return rc;

}

ssize_t QIODeviceDataProvider::write(const void *buffer, size_t bufSize)

{

#ifndef NDEBUG

    //qDebug( "QIODeviceDataProvider::write( %p, %lu )", buffer, static_cast<unsigned long>( bufSize ) );

#endif

    if (bufSize == 0) {

        return 0;

    }

    if (!buffer) {

        Error::setSystemError(GPG_ERR_EINVAL);

        return -1;

    }

    return mIO->write(static_cast<const char *>(buffer), bufSize);

}

off_t QIODeviceDataProvider::seek(off_t offset, int whence)

{

#ifndef NDEBUG

    //qDebug( "QIODeviceDataProvider::seek( %d, %d )", int(offset), whence );

#endif

    if (mIO->isSequential()) {

        Error::setSystemError(GPG_ERR_ESPIPE);

        return (off_t) - 1;

    }

    qint64 newOffset = mIO->pos();

    switch (whence) {

    case SEEK_SET:

        newOffset = offset;

        break;

    case SEEK_CUR:

        newOffset += offset;

        break;

    case SEEK_END:

        newOffset = mIO->size() + offset;

        break;

    default:

        Error::setSystemError(GPG_ERR_EINVAL);

        return (off_t) - 1;

    }

    if (!mIO->seek(newOffset)) {

        Error::setSystemError(GPG_ERR_EINVAL);

        return (off_t) - 1;

    }

    return newOffset;

}

void QIODeviceDataProvider::release()

{

#ifndef NDEBUG

    //qDebug( "QIODeviceDataProvider::release()" );

#endif

    mIO->close();

}