qformdatabuilder.cpp

Go to the documentation of this file.

// Copyright (C) 2024 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qformdatabuilder.h"
 
#include <QtCore/private/qstringconverter_p.h>
#if QT_CONFIG(mimetype)
#include "QtCore/qmimedatabase.h"
#endif
 
#include <vector>
 
QT_BEGIN_NAMESPACE
 
static QByteArray nameToByteArray(QStringView view)
{
    return view.toUtf8();
}
 
static QByteArray nameToByteArray(QLatin1StringView view)
{
    if (!QtPrivate::isAscii(view))
        return view.toString().toUtf8(); // ### optimize
 
    return QByteArray::fromRawData(view.data(), view.size());
}
 
static QByteArray nameToByteArray(QUtf8StringView view)
{
    return QByteArray::fromRawData(view.data(), view.size());
}
 
static void escapeNameAndAppend(QByteArray &dst, QByteArrayView src)
{
    for (auto c : src) {
        if (c == '"' || c == '\\')
            dst += '\\';
        dst += c;
    }
}
 
QFormDataPartBuilder::QFormDataPartBuilder(QAnyStringView name, PrivateConstructor /*unused*/)
{
    static_assert(std::is_nothrow_move_constructible_v<decltype(m_body)>);
    static_assert(std::is_nothrow_move_assignable_v<decltype(m_body)>);
 
    const auto enc = name.visit([](auto name) { return nameToByteArray(name); });
 
    m_headerValue += "form-data; name=\"";
    escapeNameAndAppend(m_headerValue, enc);
    m_headerValue += "\"";
}
 
QFormDataPartBuilder::~QFormDataPartBuilder()
    = default;
 
static void convertInto_impl(QByteArray &dst, QUtf8StringView in)
{
    dst.clear();
    dst += QByteArrayView{in}; // it's ASCII, anyway
}
 
static void convertInto_impl(QByteArray &dst, QLatin1StringView in)
{
    dst.clear();
    dst += QByteArrayView{in}; // it's ASCII, anyway
}
 
static void convertInto_impl(QByteArray &dst, QStringView in)
{
    dst.resize(in.size());
    (void)QLatin1::convertFromUnicode(dst.data(), in);
}
 
static void convertInto(QByteArray &dst, QAnyStringView in)
{
    in.visit([&dst](auto in) { convertInto_impl(dst, in); });
}
 
QFormDataPartBuilder &QFormDataPartBuilder::setBodyHelper(const QByteArray &data,
                                                          QAnyStringView name,
                                                          QAnyStringView mimeType)
{
    m_originalBodyName = name.toString();
    convertInto(m_mimeType, mimeType);
    m_body = data;
    return *this;
}
 
QFormDataPartBuilder &QFormDataPartBuilder::setBody(QByteArrayView data,
                                                    QAnyStringView fileName,
                                                    QAnyStringView mimeType)
{
    return setBody(data.toByteArray(), fileName, mimeType);
}
 
QFormDataPartBuilder &QFormDataPartBuilder::setBodyDevice(QIODevice *body, QAnyStringView fileName,
                                                          QAnyStringView mimeType)
{
    m_originalBodyName = fileName.toString();
    convertInto(m_mimeType, mimeType);
    m_body = body;
    return *this;
}
 
QFormDataPartBuilder &QFormDataPartBuilder::setHeaders(const QHttpHeaders &headers)
{
    m_httpHeaders = headers;
    return *this;
}
 
QHttpPart QFormDataPartBuilder::build()
{
    QHttpPart httpPart;
 
    if (!m_originalBodyName.isNull()) {
        const bool utf8 = !QtPrivate::isAscii(m_originalBodyName);
        const auto enc = utf8 ? m_originalBodyName.toUtf8() : m_originalBodyName.toLatin1();
        m_headerValue += "; filename=\"";
        escapeNameAndAppend(m_headerValue, enc);
        m_headerValue += "\"";
        if (utf8) {
            // For 'filename*' production see
            // https://datatracker.ietf.org/doc/html/rfc5987#section-3.2.1
            // For providing both filename and filename* parameters see
            // https://datatracker.ietf.org/doc/html/rfc6266#section-4.3 and
            // https://datatracker.ietf.org/doc/html/rfc8187#section-4.2
            m_headerValue += "; filename*=UTF-8''" + enc.toPercentEncoding();
        }
    }
 
#if QT_CONFIG(mimetype)
    if (m_mimeType.isEmpty()) {
        // auto-detect
        QMimeDatabase db;
        convertInto(m_mimeType, std::visit([&](auto &arg) {
                return db.mimeTypeForFileNameAndData(m_originalBodyName, arg);
            }, m_body).name());
    }
#endif
 
    for (qsizetype i = 0; i < m_httpHeaders.size(); i++) {
        httpPart.setRawHeader(QByteArrayView(m_httpHeaders.nameAt(i)).toByteArray(),
                                             m_httpHeaders.valueAt(i).toByteArray());
    }
 
    if (!m_mimeType.isEmpty())
        httpPart.setHeader(QNetworkRequest::ContentTypeHeader, m_mimeType);
 
    httpPart.setHeader(QNetworkRequest::ContentDispositionHeader, m_headerValue);
 
    if (auto d = std::get_if<QIODevice*>(&m_body))
        httpPart.setBodyDevice(*d);
    else if (auto b = std::get_if<QByteArray>(&m_body))
        httpPart.setBody(*b);
    else
        Q_UNREACHABLE();
 
    return httpPart;
}
 
class QFormDataBuilderPrivate
{
public:
    std::vector<QFormDataPartBuilder> parts;
};
 
QFormDataBuilder::QFormDataBuilder()
    : d_ptr(new QFormDataBuilderPrivate())
{
 
}
 
QFormDataBuilder::~QFormDataBuilder()
{
    delete d_ptr;
}
 
QFormDataPartBuilder &QFormDataBuilder::part(QAnyStringView name)
{
    Q_D(QFormDataBuilder);
 
    return d->parts.emplace_back(name, QFormDataPartBuilder::PrivateConstructor());
}
 
std::unique_ptr<QHttpMultiPart> QFormDataBuilder::buildMultiPart()
{
    Q_D(QFormDataBuilder);
 
    auto multiPart = std::make_unique<QHttpMultiPart>(QHttpMultiPart::FormDataType);
 
    for (auto &part : d->parts)
        multiPart->append(part.build());
 
    return multiPart;
}
 
QT_END_NAMESPACE