Revision control
Copy as Markdown
// Copyright (C) 2022 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
// Qt-Security score:significant reason:default
#include <QtHttpServer/qhttpserverresponder.h>
#include <QtHttpServer/qhttpserverrequest.h>
#include <QtHttpServer/qhttpserverresponse.h>
#include <private/qhttpserverresponder_p.h>
#include <private/qhttpserverliterals_p.h>
#include <private/qhttpserverrequest_p.h>
#include <private/qhttpserverresponse_p.h>
#include <private/qhttpserverstream_p.h>
#include <QtCore/qjsondocument.h>
#include <QtCore/qloggingcategory.h>
#include <memory>
QT_BEGIN_NAMESPACE
/*!
\class QHttpServerResponder
\since 6.4
\inmodule QtHttpServer
\brief API for sending replies from an HTTP server.
Provides functions for writing back to an HTTP client with overloads for
serializing JSON objects. It also has support for writing HTTP headers and
status code.
*/
/*!
\enum QHttpServerResponder::StatusCode
HTTP status codes
\value Continue
\value SwitchingProtocols
\value Processing
\value Ok
\value Created
\value Accepted
\value NonAuthoritativeInformation
\value NoContent
\value ResetContent
\value PartialContent
\value MultiStatus
\value AlreadyReported
\value IMUsed
\value MultipleChoices
\value MovedPermanently
\value Found
\value SeeOther
\value NotModified
\value UseProxy
\value TemporaryRedirect
\value PermanentRedirect
\value BadRequest
\value Unauthorized
\value PaymentRequired
\value Forbidden
\value NotFound
\value MethodNotAllowed
\value NotAcceptable
\value ProxyAuthenticationRequired
\value RequestTimeout
\value Conflict
\value Gone
\value LengthRequired
\value PreconditionFailed
\value PayloadTooLarge
\value UriTooLong
\value UnsupportedMediaType
\value RequestRangeNotSatisfiable
\value ExpectationFailed
\value ImATeapot
\value MisdirectedRequest
\value UnprocessableEntity
\value Locked
\value FailedDependency
\value UpgradeRequired
\value PreconditionRequired
\value TooManyRequests
\value RequestHeaderFieldsTooLarge
\value UnavailableForLegalReasons
\value InternalServerError
\value NotImplemented
\value BadGateway
\value ServiceUnavailable
\value GatewayTimeout
\value HttpVersionNotSupported
\value VariantAlsoNegotiates
\value InsufficientStorage
\value LoopDetected
\value NotExtended
\value NetworkAuthenticationRequired
\value NetworkConnectTimeoutError
*/
/*!
\internal
*/
QHttpServerResponderPrivate::QHttpServerResponderPrivate(QHttpServerStream *stream) : stream(stream)
{
Q_ASSERT(stream);
QMetaObject::invokeMethod(stream, &QHttpServerStream::startHandlingRequest);
}
/*!
\internal
*/
QHttpServerResponderPrivate::~QHttpServerResponderPrivate()
{
Q_ASSERT(stream);
QMetaObject::invokeMethod(stream, &QHttpServerStream::responderDestroyed, m_streamId);
}
/*!
\internal
*/
void QHttpServerResponderPrivate::cancel()
{
canceled = true;
}
/*!
\internal
*/
void QHttpServerResponderPrivate::write(QHttpServerResponder::StatusCode status)
{
if (canceled)
return;
Q_ASSERT(stream);
QMetaObject::invokeMethod(
stream, qOverload<QHttpServerResponder::StatusCode, quint32>(&QHttpServerStream::write),
status, m_streamId);
}
/*!
\internal
*/
void QHttpServerResponderPrivate::write(const QByteArray &body, const QHttpHeaders &headers,
QHttpServerResponder::StatusCode status)
{
if (canceled)
return;
Q_ASSERT(stream);
QMetaObject::invokeMethod(
stream,
qOverload<const QByteArray &, const QHttpHeaders &, QHttpServerResponder::StatusCode,
quint32>(&QHttpServerStream::write),
body, headers, status, m_streamId);
}
/*!
\internal
*/
void QHttpServerResponderPrivate::write(QIODevice *data, const QHttpHeaders &headers,
QHttpServerResponder::StatusCode status)
{
if (canceled)
return;
Q_ASSERT(stream);
Q_ASSERT(data);
data->setParent(nullptr);
data->moveToThread(stream->thread());
QMetaObject::invokeMethod(
stream,
qOverload<QIODevice *, const QHttpHeaders &, QHttpServerResponder::StatusCode, quint32>(
&QHttpServerStream::write),
data, headers, status, m_streamId);
}
/*!
\internal
*/
void QHttpServerResponderPrivate::writeBeginChunked(const QHttpHeaders &headers,
QHttpServerResponder::StatusCode status)
{
if (canceled)
return;
Q_ASSERT(stream);
QMetaObject::invokeMethod(stream, &QHttpServerStream::writeBeginChunked, headers, status,
m_streamId);
}
/*!
\internal
*/
void QHttpServerResponderPrivate::writeChunk(const QByteArray &data)
{
if (canceled)
return;
Q_ASSERT(stream);
QMetaObject::invokeMethod(stream, &QHttpServerStream::writeChunk, data, m_streamId);
}
/*!
\internal
*/
void QHttpServerResponderPrivate::writeEndChunked(const QByteArray &data,
const QHttpHeaders &trailers)
{
if (canceled)
return;
Q_ASSERT(stream);
QMetaObject::invokeMethod(stream, &QHttpServerStream::writeEndChunked, data, trailers,
m_streamId);
}
/*!
Constructs a QHttpServerResponder instance using a \a stream
to output the response to.
*/
QHttpServerResponder::QHttpServerResponder(QHttpServerStream *stream)
: d_ptr(new QHttpServerResponderPrivate(stream))
{
Q_ASSERT(stream);
}
/*!
\fn QHttpServerResponder::QHttpServerResponder(QHttpServerResponder &&other)
Move-constructs a QHttpServerResponder instance, making it point
at the same object that \a other was pointing to.
*/
/*!
Destroys a QHttpServerResponder.
*/
QHttpServerResponder::~QHttpServerResponder()
{
delete d_ptr;
};
/*!
\fn void QHttpServerResponder::swap(QHttpServerResponder &other) noexcept
Swaps QHttpServerResponder \a other with this QHttpServerResponder.
This operation is very fast and never fails.
\since 6.8
*/
/*!
Answers a request with an HTTP status code \a status and
HTTP headers \a headers. The I/O device \a data provides the body
of the response. If \a data is sequential, the body of the
message is sent in chunks: otherwise, the function assumes all
the content is available and sends it all at once but the read
is done in chunks.
\note This function takes the ownership of \a data.
*/
void QHttpServerResponder::write(QIODevice *data,
const QHttpHeaders &headers,
StatusCode status)
{
Q_D(QHttpServerResponder);
d->write(data, headers, status);
}
/*!
Answers a request with an HTTP status code \a status and a
MIME type \a mimeType. The I/O device \a data provides the body
of the response. If \a data is sequential, the body of the
message is sent in chunks: otherwise, the function assumes all
the content is available and sends it all at once but the read
is done in chunks.
\note This function takes the ownership of \a data.
*/
void QHttpServerResponder::write(QIODevice *data,
const QByteArray &mimeType,
StatusCode status)
{
QHttpHeaders headers;
headers.append(QHttpHeaders::WellKnownHeader::ContentType, mimeType);
write(data, headers, status);
}
/*!
Answers a request with an HTTP status code \a status, JSON
document \a document and HTTP headers \a headers.
Note: This function sets HTTP Content-Type header as
\c{"application/json"}.
*/
void QHttpServerResponder::write(const QJsonDocument &document,
const QHttpHeaders &headers,
StatusCode status)
{
Q_D(QHttpServerResponder);
const QByteArray &json = document.toJson();
QHttpHeaders allHeaders(headers);
allHeaders.append(QHttpHeaders::WellKnownHeader::ContentType,
QHttpServerLiterals::contentTypeJson());
allHeaders.append(QHttpHeaders::WellKnownHeader::ContentLength,
QByteArray::number(json.size()));
d->write(document.toJson(), allHeaders, status);
}
/*!
Answers a request with an HTTP status code \a status, and JSON
document \a document.
Note: This function sets HTTP Content-Type header as
\c{"application/json"}.
*/
void QHttpServerResponder::write(const QJsonDocument &document,
StatusCode status)
{
write(document, {}, status);
}
/*!
Answers a request with an HTTP status code \a status,
HTTP Headers \a headers and a body \a data.
Note: This function sets HTTP Content-Length header.
*/
void QHttpServerResponder::write(const QByteArray &data,
const QHttpHeaders &headers,
StatusCode status)
{
Q_D(QHttpServerResponder);
QHttpHeaders allHeaders(headers);
allHeaders.append(QHttpHeaders::WellKnownHeader::ContentLength,
QByteArray::number(data.size()));
d->write(data, allHeaders, status);
}
/*!
Answers a request with an HTTP status code \a status, a
MIME type \a mimeType and a body \a data.
*/
void QHttpServerResponder::write(const QByteArray &data,
const QByteArray &mimeType,
StatusCode status)
{
QHttpHeaders headers;
headers.append(QHttpHeaders::WellKnownHeader::ContentType, mimeType);
write(data, headers, status);
}
/*!
Answers a request with an HTTP status code \a status.
Note: This function sets HTTP Content-Type header as
\c{"application/x-empty"}.
*/
void QHttpServerResponder::write(StatusCode status)
{
write(QByteArray(), QHttpServerLiterals::contentTypeXEmpty(), status);
}
/*!
Answers a request with an HTTP status code \a status and
HTTP Headers \a headers.
*/
void QHttpServerResponder::write(const QHttpHeaders &headers, StatusCode status)
{
write(QByteArray(), headers, status);
}
/*!
Sends a HTTP \a response to the client.
\since 6.5
*/
void QHttpServerResponder::sendResponse(const QHttpServerResponse &response)
{
Q_D(QHttpServerResponder);
const auto &r = response.d_ptr;
QHttpHeaders allHeaders(r->headers);
allHeaders.append(QHttpHeaders::WellKnownHeader::ContentLength,
QByteArray::number(r->data.size()));
d->write(r->data, allHeaders, r->statusCode);
}
/*!
Start sending chunks of data with \a headers and and the status
code \a status. This call must be followed up with an arbitrary
number of repeated \c writeChunk calls and and a single call to
\c writeEndChunked.
\since 6.8
\sa writeChunk, writeEndChunked
*/
void QHttpServerResponder::writeBeginChunked(const QHttpHeaders &headers, StatusCode status)
{
Q_D(QHttpServerResponder);
d->writeBeginChunked(headers, status);
}
/*!
Start sending chunks of data with the mime type \a mimeType and
and the given status code \a status. This call must be followed
up with an arbitrary number of repeated \c writeChunk calls and
and a single call to \c writeEndChunked.
\since 6.8
\sa writeChunk, writeEndChunked
*/
void QHttpServerResponder::writeBeginChunked(const QByteArray &mimeType, StatusCode status)
{
QHttpHeaders headers;
headers.append(QHttpHeaders::WellKnownHeader::ContentType, mimeType);
writeBeginChunked(headers, status);
}
/*!
Start sending chunks of data with \a headers and and the given
status code \a status. This call must be followed up with an
arbitrary number of repeated \c writeChunk calls and and a single
call to \c writeEndChunked with the same trailers given in
\a trailers.
\since 6.8
\sa writeChunk, writeEndChunked
*/
void QHttpServerResponder::writeBeginChunked(const QHttpHeaders &headers,
QList<QHttpHeaders::WellKnownHeader> trailers,
StatusCode status)
{
QHttpHeaders allHeaders(headers);
QByteArray trailerList;
for (qsizetype i = 0; i < trailers.size(); ++i) {
if (i != 0)
trailerList.append(", ");
trailerList.append(QHttpHeaders::wellKnownHeaderName(trailers[i]).toByteArray());
}
allHeaders.append(QHttpHeaders::WellKnownHeader::Trailer, trailerList);
writeBeginChunked(allHeaders, status);
}
/*!
Write \a data back to the client. To be called when data is
available to write. This can be called multiple times, but before
calling this \c writeBeginChunked must called, and afterwards
\c writeEndChunked must be called.
\sa writeBeginChunked, writeEndChunked
\since 6.8
*/
void QHttpServerResponder::writeChunk(const QByteArray &data)
{
Q_D(QHttpServerResponder);
d->writeChunk(data);
}
/*!
Write \a data back to the client with the \a trailers
announced in \c writeBeginChunked.
\since 6.8
\sa writeBeginChunked, writeChunk
*/
void QHttpServerResponder::writeEndChunked(const QByteArray &data, const QHttpHeaders &trailers)
{
Q_D(QHttpServerResponder);
d->writeEndChunked(data, trailers);
}
/*!
Write \a data back to the client. Must be preceded
by a call to \c writeBeginChunked.
\since 6.8
\sa writeBeginChunked, writeChunk
*/
void QHttpServerResponder::writeEndChunked(const QByteArray &data)
{
writeEndChunked(data, {});
}
/*!
Returns true if the client has canceled the response.
Used to make it possible to exit early in handler
when the response is canceled.
\since 6.11
*/
bool QHttpServerResponder::isResponseCanceled() const
{
Q_D(const QHttpServerResponder);
return d->canceled;
}
QT_END_NAMESPACE