upload.cpp

/*
 * SPDX-FileCopyrightText: (C) 2014-2022 Daniel Nicoletti <dantti12@gmail.com>
 * SPDX-License-Identifier: BSD-3-Clause
 */
#include "common.h"
#include "upload_p.h"

#include <QDir>
#include <QFile>
#include <QFileInfo>
#include <QTemporaryFile>

using namespace Cutelyst;
using namespace Qt::StringLiterals;

QString Upload::filename() const
{
    Q_D(const Upload);
    return d->filename;
}

QByteArray Upload::contentType() const
{
    Q_D(const Upload);
    return d->headers.contentType();
}

Headers Upload::headers() const
{
    Q_D(const Upload);
    return d->headers;
}

bool Upload::save(const QString &newName)
{
    Q_D(Upload);

    bool error           = false;
    QString fileTemplate = u"%1/qt_temp.XXXXXX"_s;
    QFile out(fileTemplate.arg(QFileInfo(newName).path()));
    if (!out.open(QIODevice::ReadWrite)) {
        error = true;
    }

    if (error) {
        out.close();
        setErrorString(u"Failed to open file for saving: " + out.errorString());
        qCWarning(CUTELYST_UPLOAD) << errorString();
    } else {
        qint64 posOrig = d->pos;
        seek(0);

        char block[4096];
        while (!atEnd()) {
            qint64 in = read(block, sizeof(block));
            if (in <= 0) {
                break;
            }
            if (in != out.write(block, in)) {
                setErrorString(u"Failure to write block"_s);
                qCWarning(CUTELYST_UPLOAD) << errorString();
                error = true;
                break;
            }
        }

        if (error) {
            out.remove();
        }

        if (!error && !out.rename(newName)) {
            error = true;
            setErrorString(u"Cannot create %1 for output"_s.arg(newName));
            qCWarning(CUTELYST_UPLOAD) << errorString();
        }
        if (error) {
            out.remove();
        }
        seek(posOrig);
    }

    return !error;
}

std::unique_ptr<QTemporaryFile> Upload::createTemporaryFile(const QString &templateName)
{
    std::unique_ptr<QTemporaryFile> ret;

#ifndef QT_NO_TEMPORARYFILE
    Q_D(Upload);
    if (templateName.isEmpty()) {
        ret = std::make_unique<QTemporaryFile>();
    } else {
        ret = std::make_unique<QTemporaryFile>(templateName);
    }

    if (ret->open()) {
        bool error     = false;
        qint64 posOrig = d->pos;
        seek(0);

        char block[4096];
        while (!atEnd()) {
            qint64 in = read(block, sizeof(block));
            if (in <= 0) {
                break;
            }

            if (in != ret->write(block, in)) {
                setErrorString(u"Failure to write block"_s);
                qCWarning(CUTELYST_UPLOAD) << errorString();
                error = true;
                break;
            }
        }

        if (error) {
            ret->remove();
        }
        ret->seek(0);
        seek(posOrig);

        return ret;
    } else {
        qCWarning(CUTELYST_UPLOAD) << "Failed to open temporary file.";
    }
    ret.reset();
#else
    Q_UNUSED(templateName);
#endif

    return ret;
}

qint64 Upload::pos() const
{
    Q_D(const Upload);
    return d->pos;
}

qint64 Upload::size() const
{
    Q_D(const Upload);
    return d->endOffset - d->startOffset;
}

bool Upload::seek(qint64 pos)
{
    Q_D(Upload);
    if (pos <= size()) {
        QIODevice::seek(pos);
        d->pos = pos;
        return true;
    }
    return false;
}

Upload::Upload(UploadPrivate *prv)
    : d_ptr(prv)
{
    Q_D(Upload);
    open(prv->device->openMode());
    const QByteArray disposition = prv->headers.contentDisposition();
    int start                    = disposition.indexOf("name=\"");
    if (start != -1) {
        start += 6;
        int end = disposition.indexOf(u'"', start);
        if (end != -1) {
            // TODO
            d->name = QString::fromLatin1(disposition.sliced(start, end - start));
        }
    }

    start = disposition.indexOf("filename=\"");
    if (start != -1) {
        start += 10;
        int end = disposition.indexOf('"', start);
        if (end != -1) {
            d->filename = QString::fromLatin1(disposition.sliced(start, end - start));
        }
    }
}

Upload::~Upload()
{
    delete d_ptr;
}

QString Upload::name() const
{
    Q_D(const Upload);
    return d->name;
}

qint64 Upload::readData(char *data, qint64 maxlen)
{
    Q_D(Upload);
    qint64 posOrig = d->device->pos();

    d->device->seek(d->startOffset + d->pos);
    qint64 len = d->device->read(data, qMin(size() - d->pos, maxlen));
    d->device->seek(posOrig);
    d->pos += len;
    return len;
}

qint64 Upload::readLineData(char *data, qint64 maxlen)
{
    Q_D(Upload);
    qint64 posOrig = d->device->pos();

    d->device->seek(d->startOffset + d->pos);
    qint64 len = d->device->readLine(data, qMin(size() - d->pos, maxlen));
    d->device->seek(posOrig);
    d->pos += len;
    return len;
}

qint64 Upload::writeData(const char *data, qint64 maxSize)
{
    Q_UNUSED(data);
    Q_UNUSED(maxSize);
    return -1;
}

#include "moc_upload.cpp"