qt-everywhere-src-5.15.1/qtwebglplugin/src/plugins/platforms/webgl/qwebglhttpserver.cpp - orbit - Git at Google

 /****************************************************************************
 **
 ** Copyright (C) 2017 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the Qt WebGL module of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:GPL$
 ** Commercial License Usage
 ** Licensees holding valid commercial Qt licenses may use this file in
 ** accordance with the commercial license agreement provided with the
 ** Software or, alternatively, in accordance with the terms contained in
 ** a written agreement between you and The Qt Company. For licensing terms
 ** and conditions see https://www.qt.io/terms-conditions. For further
 ** information use the contact form at https://www.qt.io/contact-us.
 **
 ** GNU General Public License Usage
 ** Alternatively, this file may be used under the terms of the GNU
 ** General Public License version 3 or (at your option) any later version
 ** approved by the KDE Free Qt Foundation. The licenses are as published by
 ** the Free Software Foundation and appearing in the file LICENSE.GPL3
 ** included in the packaging of this file. Please review the following
 ** information to ensure the GNU General Public License requirements will
 ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
 **
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/

 #include "qwebglhttpserver.h"

 #include "qwebglintegration.h"
 #include "qwebglwebsocketserver.h"

 #include <QtCore/qbuffer.h>
 #include <QtCore/qbytearray.h>
 #include <QtCore/qfile.h>
 #include <QtCore/qpointer.h>
 #include <QtCore/qtimer.h>
 #include <QtCore/qurlquery.h>
 #include <QtGui/qclipboard.h>
 #include <QtGui/qicon.h>
 #include <QtGui/qguiapplication.h>
 #include <QtNetwork/qnetworkinterface.h>
 #include <QtNetwork/qtcpserver.h>
 #include <QtNetwork/qtcpsocket.h>

 #include <cctype>
 #include <cstdlib>

 QT_BEGIN_NAMESPACE

 static Q_LOGGING_CATEGORY(lc, "qt.qpa.webgl.httpserver")

 struct HttpRequest {
     quint16 port = 0;

     bool readMethod(QTcpSocket *socket);
     bool readUrl(QTcpSocket *socket);
     bool readStatus(QTcpSocket *socket);
     bool readHeader(QTcpSocket *socket);

     enum class State {
         ReadingMethod,
         ReadingUrl,
         ReadingStatus,
         ReadingHeader,
         ReadingBody,
         AllDone
     } state = State::ReadingMethod;
     QByteArray fragment;

     enum class Method {
         Unknown,
         Head,
         Get,
         Put,
         Post,
         Delete,
     } method = Method::Unknown;
     quint32 byteSize = 0;
     QUrl url;
     QPair<quint8, quint8> version;
     QMap<QByteArray, QByteArray> headers;
 };

 class QWebGLHttpServerPrivate
 {
 public:
     QMap<QTcpSocket *, HttpRequest> clients;
     QMap<QString, QPointer<QIODevice>> customRequestDevices;
     QTcpServer server;
     QPointer<QWebGLWebSocketServer> webSocketServer;
 };

 QWebGLHttpServer::QWebGLHttpServer(QWebGLWebSocketServer *webSocketServer, QObject *parent) :
     QObject(parent),
     d_ptr(new QWebGLHttpServerPrivate)
 {
     Q_D(QWebGLHttpServer);
     d->webSocketServer = webSocketServer;

     connect(&d->server, &QTcpServer::newConnection, this, &QWebGLHttpServer::clientConnected);
 }

 QWebGLHttpServer::~QWebGLHttpServer()
 {}

 bool QWebGLHttpServer::listen(const QHostAddress &address, quint16 port)
 {
     Q_D(QWebGLHttpServer);
     const auto ok = d->server.listen(address, port);
     qCDebug(lc, "Listening in port %d", port);
     return ok;
 }

 bool QWebGLHttpServer::isListening() const
 {
     Q_D(const QWebGLHttpServer);
     return d->server.isListening();
 }

 quint16 QWebGLHttpServer::serverPort() const
 {
     Q_D(const QWebGLHttpServer);
     return d->server.serverPort();
 }

 QIODevice *QWebGLHttpServer::customRequestDevice(const QString &name)
 {
     Q_D(const QWebGLHttpServer);
     return d->customRequestDevices.value(name, nullptr).data();
 }

 void QWebGLHttpServer::setCustomRequestDevice(const QString &name, QIODevice *device)
 {
     Q_D(QWebGLHttpServer);
     if (d->customRequestDevices.value(name))
         d->customRequestDevices[name]->deleteLater();
     d->customRequestDevices.insert(name, device);
 }

 QString QWebGLHttpServer::errorString() const
 {
     Q_D(const QWebGLHttpServer);
     return d->server.errorString();
 }

 void QWebGLHttpServer::clientConnected()
 {
     Q_D(QWebGLHttpServer);
     auto socket = d->server.nextPendingConnection();
     connect(socket, &QTcpSocket::disconnected, this, &QWebGLHttpServer::clientDisconnected);
     connect(socket, &QTcpSocket::readyRead, this, &QWebGLHttpServer::readData);
 }

 void QWebGLHttpServer::clientDisconnected()
 {
     Q_D(QWebGLHttpServer);
     auto socket = qobject_cast<QTcpSocket *>(sender());
     Q_ASSERT(socket);
     d->clients.remove(socket);
     socket->deleteLater();
 }

 void QWebGLHttpServer::readData()
 {
     Q_D(QWebGLHttpServer);
     auto socket = qobject_cast<QTcpSocket *>(sender());
     if (!d->clients.contains(socket))
         d->clients[socket].port = d->server.serverPort();

     auto request = &d->clients[socket];
     bool error = false;

     request->byteSize += socket->bytesAvailable();
     if (Q_UNLIKELY(request->byteSize > 2048)) {
         socket->write(QByteArrayLiteral("HTTP 413 – Request entity too large\r\n"));
         socket->disconnectFromHost();
         d->clients.remove(socket);
         return;
     }

     if (Q_LIKELY(request->state == HttpRequest::State::ReadingMethod))
         if (Q_UNLIKELY(error = !request->readMethod(socket)))
             qCWarning(lc, "QWebGLHttpServer::readData: Invalid Method");

     if (Q_LIKELY(!error && request->state == HttpRequest::State::ReadingUrl))
         if (Q_UNLIKELY(error = !request->readUrl(socket)))
             qCWarning(lc, "QWebGLHttpServer::readData: Invalid URL");

     if (Q_LIKELY(!error && request->state == HttpRequest::State::ReadingStatus))
         if (Q_UNLIKELY(error = !request->readStatus(socket)))
             qCWarning(lc, "QWebGLHttpServer::readData: Invalid Status");

     if (Q_LIKELY(!error && request->state == HttpRequest::State::ReadingHeader))
         if (Q_UNLIKELY(error = !request->readHeader(socket)))
             qCWarning(lc, "QWebGLHttpServer::readData: Invalid Header");

     if (error) {
         socket->disconnectFromHost();
         d->clients.remove(socket);
     } else if (!request->url.isEmpty()) {
         Q_ASSERT(request->state != HttpRequest::State::ReadingUrl);
         answerClient(socket, request->url);
         d->clients.remove(socket);
     }
 }

 void QWebGLHttpServer::answerClient(QTcpSocket *socket, const QUrl &url)
 {
     Q_D(QWebGLHttpServer);
     bool disconnect = true;
     const auto path = url.path();

     qCDebug(lc, "%s requested: %s",
            qPrintable(socket->localAddress().toString()), qPrintable(path));

     QByteArray answer = QByteArrayLiteral("HTTP/1.1 404 Not Found\r\n"
                                           "Content-Type: text/html\r\n"
                                           "Content-Length: 136\r\n\r\n"
                                           "<html>"
                                           "<head><title>404 Not Found</title></head>"
                                           "<body bgcolor=\"white\">"
                                           "<center><h1>404 Not Found</h1></center>"
                                           "</body>"
                                           "</html>");
     const auto addData = [&answer](const QByteArray &contentType, const QByteArray &data)
     {
         answer = QByteArrayLiteral("HTTP/1.0 200 OK \r\n");
         QByteArray ret;
         const auto dataSize = QString::number(data.size()).toUtf8();
         answer += QByteArrayLiteral("Content-Type: ") + contentType + QByteArrayLiteral("\r\n") +
                   QByteArrayLiteral("Content-Length: ") + dataSize + QByteArrayLiteral("\r\n\r\n") +
                   data;
     };

     if (path == QLatin1String("/")) {
         QFile file(QStringLiteral(":/webgl/index.html"));
         Q_ASSERT(file.exists());
         file.open(QIODevice::ReadOnly | QIODevice::Text);
         Q_ASSERT(file.isOpen());
         auto data = file.readAll();
         addData(QByteArrayLiteral("text/html; charset=\"utf-8\""), data);
     } else if (path == QStringLiteral("/clipboard")) {
 #ifndef QT_NO_CLIPBOARD
         auto data = qGuiApp->clipboard()->text().toUtf8();
         addData(QByteArrayLiteral("text/html; charset=\"utf-8\""), data);
 #else
         qCWarning(lc, "Qt was built without clipboard support");
 #endif
     } else if (path == QStringLiteral("/webqt.js")) {
         QFile file(QStringLiteral(":/webgl/webqt.jsx"));
         Q_ASSERT(file.exists());
         file.open(QIODevice::ReadOnly | QIODevice::Text);
         Q_ASSERT(file.isOpen());
         const auto host = url.host().toUtf8();
         const auto port = QString::number(d->webSocketServer->port()).toUtf8();
         QByteArray data = "var host = \"" + host + "\";\r\nvar port = " + port + ";\r\n";
         data += file.readAll();
         addData(QByteArrayLiteral("application/javascript"), data);
     } else if (path == QStringLiteral("/favicon.ico")) {
         QFile file(QStringLiteral(":/webgl/favicon.ico"));
         Q_ASSERT(file.exists());
         file.open(QIODevice::ReadOnly);
         Q_ASSERT(file.isOpen());
         auto data = file.readAll();
         addData(QByteArrayLiteral("image/x-icon"), data);
     } else if (path == QStringLiteral("/favicon.png")) {
         QBuffer buffer;
         qGuiApp->windowIcon().pixmap(16, 16).save(&buffer, "png");
         addData(QByteArrayLiteral("image/x-icon"), buffer.data());
     } else if (auto device = d->customRequestDevices.value(path)) {
         answer = QByteArrayLiteral("HTTP/1.0 200 OK \r\n"
                                    "Content-Type: text/plain; charset=\"utf-8\"\r\n"
                                    "Connection: Keep.Alive\r\n\r\n") +
                 device->readAll();
         auto timer = new QTimer(device);
         timer->setSingleShot(false);
         connect(timer, &QTimer::timeout, [device, socket]()
         {
             if (device->bytesAvailable())
                 socket->write(device->readAll());
         });
         timer->start(1000);
         disconnect = false;
     }
     socket->write(answer);
     if (disconnect)
         socket->disconnectFromHost();
 }

 bool HttpRequest::readMethod(QTcpSocket *socket)
 {
     bool finished = false;
     while (socket->bytesAvailable() && !finished) {
         const auto c = socket->read(1).at(0);
         if (std::isupper(c) && fragment.size() < 6)
             fragment += c;
         else
             finished = true;
     }
     if (finished) {
         if (fragment == "HEAD")
             method = Method::Head;
         else if (fragment == "GET")
             method = Method::Get;
         else if (fragment == "PUT")
             method = Method::Put;
         else if (fragment == "POST")
             method = Method::Post;
         else if (fragment == "DELETE")
             method = Method::Delete;
         else
             qCWarning(lc, "QWebGLHttpServer::HttpRequest::readMethod: Invalid operation %s",
                      fragment.data());

         state = State::ReadingUrl;
         fragment.clear();

         return method != Method::Unknown;
     }
     return true;
 }

 bool HttpRequest::readUrl(QTcpSocket *socket)
 {
     bool finished = false;
     while (socket->bytesAvailable() && !finished) {
         char c;
         if (!socket->getChar(&c))
             return false;
         if (std::isspace(c))
             finished = true;
         else
             fragment += c;
     }
     if (finished) {
         if (!fragment.startsWith("/")) {
             qCWarning(lc, "QWebGLHttpServer::HttpRequest::readUrl: Invalid URL path %s",
                      fragment.constData());
             return false;
         }
         url.setUrl(QStringLiteral("http://localhost:") + QString::number(port) +
                    QString::fromUtf8(fragment));
         state = State::ReadingStatus;
         if (!url.isValid()) {
             qCWarning(lc, "QWebGLHttpServer::HttpRequest::readUrl: Invalid URL %s",
                      fragment.constData());
             return false;
         }
         fragment.clear();
         return true;
     }
     return true;
 }

 bool HttpRequest::readStatus(QTcpSocket *socket)
 {
     bool finished = false;
     while (socket->bytesAvailable() && !finished) {
         fragment += socket->read(1);
         if (fragment.endsWith("\r\n")) {
             finished = true;
             fragment.chop(2);
         }
     }
     if (finished) {
         if (!std::isdigit(fragment.at(fragment.size() - 3)) ||
                 !std::isdigit(fragment.at(fragment.size() - 1))) {
             qCWarning(lc, "QWebGLHttpServer::HttpRequest::::readStatus: Invalid version");
             return false;
         }
         version = qMakePair(fragment.at(fragment.size() - 3) - '0',
                             fragment.at(fragment.size() - 1) - '0');
         state = State::ReadingHeader;
         fragment.clear();
     }
     return true;
 }

 bool HttpRequest::readHeader(QTcpSocket *socket)
 {
     while (socket->bytesAvailable()) {
         fragment += socket->read(1);
         if (fragment.endsWith("\r\n")) {
             if (fragment == "\r\n") {
                 state = State::ReadingBody;
                 fragment.clear();
                 return true;
             } else {
                 fragment.chop(2);
                 const int index = fragment.indexOf(':');
                 if (index == -1)
                     return false;

                 const QByteArray key = fragment.mid(0, index).trimmed();
                 const QByteArray value = fragment.mid(index + 1).trimmed();
                 headers.insert(key, value);
                 if (QStringLiteral("host").compare(key, Qt::CaseInsensitive) == 0) {
                     auto parts = value.split(':');
                     if (parts.size() == 1) {
                         url.setHost(parts.first());
                         url.setPort(80);
                     } else {
                         url.setHost(parts.first());
                         url.setPort(std::strtoul(parts.at(1).constData(), nullptr, 10));
                     }
                 }
                 fragment.clear();
             }
         }
     }
     return false;
 }

 QT_END_NAMESPACE
	/****************************************************************************
	**
	** Copyright (C) 2017 The Qt Company Ltd.
	** Contact: https://www.qt.io/licensing/
	**
	** This file is part of the Qt WebGL module of the Qt Toolkit.
	**
	** $QT_BEGIN_LICENSE:GPL$
	** Commercial License Usage
	** Licensees holding valid commercial Qt licenses may use this file in
	** accordance with the commercial license agreement provided with the
	** Software or, alternatively, in accordance with the terms contained in
	** a written agreement between you and The Qt Company. For licensing terms
	** and conditions see https://www.qt.io/terms-conditions. For further
	** information use the contact form at https://www.qt.io/contact-us.
	**
	** GNU General Public License Usage
	** Alternatively, this file may be used under the terms of the GNU
	** General Public License version 3 or (at your option) any later version
	** approved by the KDE Free Qt Foundation. The licenses are as published by
	** the Free Software Foundation and appearing in the file LICENSE.GPL3
	** included in the packaging of this file. Please review the following
	** information to ensure the GNU General Public License requirements will
	** be met: https://www.gnu.org/licenses/gpl-3.0.html.
	**
	** $QT_END_LICENSE$
	**
	****************************************************************************/

	#include "qwebglhttpserver.h"

	#include "qwebglintegration.h"
	#include "qwebglwebsocketserver.h"

	#include <QtCore/qbuffer.h>
	#include <QtCore/qbytearray.h>
	#include <QtCore/qfile.h>
	#include <QtCore/qpointer.h>
	#include <QtCore/qtimer.h>
	#include <QtCore/qurlquery.h>
	#include <QtGui/qclipboard.h>
	#include <QtGui/qicon.h>
	#include <QtGui/qguiapplication.h>
	#include <QtNetwork/qnetworkinterface.h>
	#include <QtNetwork/qtcpserver.h>
	#include <QtNetwork/qtcpsocket.h>

	#include <cctype>
	#include <cstdlib>

	QT_BEGIN_NAMESPACE

	static Q_LOGGING_CATEGORY(lc, "qt.qpa.webgl.httpserver")

	struct HttpRequest {
	quint16 port = 0;

	bool readMethod(QTcpSocket *socket);
	bool readUrl(QTcpSocket *socket);
	bool readStatus(QTcpSocket *socket);
	bool readHeader(QTcpSocket *socket);

	enum class State {
	ReadingMethod,
	ReadingUrl,
	ReadingStatus,
	ReadingHeader,
	ReadingBody,
	AllDone
	} state = State::ReadingMethod;
	QByteArray fragment;

	enum class Method {
	Unknown,
	Head,
	Get,
	Put,
	Post,
	Delete,
	} method = Method::Unknown;
	quint32 byteSize = 0;
	QUrl url;
	QPair<quint8, quint8> version;
	QMap<QByteArray, QByteArray> headers;
	};

	class QWebGLHttpServerPrivate
	{
	public:
	QMap<QTcpSocket *, HttpRequest> clients;
	QMap<QString, QPointer<QIODevice>> customRequestDevices;
	QTcpServer server;
	QPointer<QWebGLWebSocketServer> webSocketServer;
	};

	QWebGLHttpServer::QWebGLHttpServer(QWebGLWebSocketServer webSocketServer, QObject parent) :
	QObject(parent),
	d_ptr(new QWebGLHttpServerPrivate)
	{
	Q_D(QWebGLHttpServer);
	d->webSocketServer = webSocketServer;

	connect(&d->server, &QTcpServer::newConnection, this, &QWebGLHttpServer::clientConnected);
	}

	QWebGLHttpServer::~QWebGLHttpServer()
	{}

	bool QWebGLHttpServer::listen(const QHostAddress &address, quint16 port)
	{
	Q_D(QWebGLHttpServer);
	const auto ok = d->server.listen(address, port);
	qCDebug(lc, "Listening in port %d", port);
	return ok;
	}

	bool QWebGLHttpServer::isListening() const
	{
	Q_D(const QWebGLHttpServer);
	return d->server.isListening();
	}

	quint16 QWebGLHttpServer::serverPort() const
	{
	Q_D(const QWebGLHttpServer);
	return d->server.serverPort();
	}

	QIODevice *QWebGLHttpServer::customRequestDevice(const QString &name)
	{
	Q_D(const QWebGLHttpServer);
	return d->customRequestDevices.value(name, nullptr).data();
	}

	void QWebGLHttpServer::setCustomRequestDevice(const QString &name, QIODevice *device)
	{
	Q_D(QWebGLHttpServer);
	if (d->customRequestDevices.value(name))
	d->customRequestDevices[name]->deleteLater();
	d->customRequestDevices.insert(name, device);
	}

	QString QWebGLHttpServer::errorString() const
	{
	Q_D(const QWebGLHttpServer);
	return d->server.errorString();
	}

	void QWebGLHttpServer::clientConnected()
	{
	Q_D(QWebGLHttpServer);
	auto socket = d->server.nextPendingConnection();
	connect(socket, &QTcpSocket::disconnected, this, &QWebGLHttpServer::clientDisconnected);
	connect(socket, &QTcpSocket::readyRead, this, &QWebGLHttpServer::readData);
	}

	void QWebGLHttpServer::clientDisconnected()
	{
	Q_D(QWebGLHttpServer);
	auto socket = qobject_cast<QTcpSocket *>(sender());
	Q_ASSERT(socket);
	d->clients.remove(socket);
	socket->deleteLater();
	}

	void QWebGLHttpServer::readData()
	{
	Q_D(QWebGLHttpServer);
	auto socket = qobject_cast<QTcpSocket *>(sender());
	if (!d->clients.contains(socket))
	d->clients[socket].port = d->server.serverPort();

	auto request = &d->clients[socket];
	bool error = false;

	request->byteSize += socket->bytesAvailable();
	if (Q_UNLIKELY(request->byteSize > 2048)) {
	socket->write(QByteArrayLiteral("HTTP 413 – Request entity too large\r\n"));
	socket->disconnectFromHost();
	d->clients.remove(socket);
	return;
	}

	if (Q_LIKELY(request->state == HttpRequest::State::ReadingMethod))
	if (Q_UNLIKELY(error = !request->readMethod(socket)))
	qCWarning(lc, "QWebGLHttpServer::readData: Invalid Method");

	if (Q_LIKELY(!error && request->state == HttpRequest::State::ReadingUrl))
	if (Q_UNLIKELY(error = !request->readUrl(socket)))
	qCWarning(lc, "QWebGLHttpServer::readData: Invalid URL");

	if (Q_LIKELY(!error && request->state == HttpRequest::State::ReadingStatus))
	if (Q_UNLIKELY(error = !request->readStatus(socket)))
	qCWarning(lc, "QWebGLHttpServer::readData: Invalid Status");

	if (Q_LIKELY(!error && request->state == HttpRequest::State::ReadingHeader))
	if (Q_UNLIKELY(error = !request->readHeader(socket)))
	qCWarning(lc, "QWebGLHttpServer::readData: Invalid Header");

	if (error) {
	socket->disconnectFromHost();
	d->clients.remove(socket);
	} else if (!request->url.isEmpty()) {
	Q_ASSERT(request->state != HttpRequest::State::ReadingUrl);
	answerClient(socket, request->url);
	d->clients.remove(socket);
	}
	}

	void QWebGLHttpServer::answerClient(QTcpSocket *socket, const QUrl &url)
	{
	Q_D(QWebGLHttpServer);
	bool disconnect = true;
	const auto path = url.path();

	qCDebug(lc, "%s requested: %s",
	qPrintable(socket->localAddress().toString()), qPrintable(path));

	QByteArray answer = QByteArrayLiteral("HTTP/1.1 404 Not Found\r\n"
	"Content-Type: text/html\r\n"
	"Content-Length: 136\r\n\r\n"
	"<html>"
	"<head><title>404 Not Found</title></head>"
	"<body bgcolor=\"white\">"
	"<center><h1>404 Not Found</h1></center>"
	"</body>"
	"</html>");
	const auto addData = [&answer](const QByteArray &contentType, const QByteArray &data)
	{
	answer = QByteArrayLiteral("HTTP/1.0 200 OK \r\n");
	QByteArray ret;
	const auto dataSize = QString::number(data.size()).toUtf8();
	answer += QByteArrayLiteral("Content-Type: ") + contentType + QByteArrayLiteral("\r\n") +
	QByteArrayLiteral("Content-Length: ") + dataSize + QByteArrayLiteral("\r\n\r\n") +
	data;
	};

	if (path == QLatin1String("/")) {
	QFile file(QStringLiteral(":/webgl/index.html"));
	Q_ASSERT(file.exists());
	file.open(QIODevice::ReadOnly \| QIODevice::Text);
	Q_ASSERT(file.isOpen());
	auto data = file.readAll();
	addData(QByteArrayLiteral("text/html; charset=\"utf-8\""), data);
	} else if (path == QStringLiteral("/clipboard")) {
	#ifndef QT_NO_CLIPBOARD
	auto data = qGuiApp->clipboard()->text().toUtf8();
	addData(QByteArrayLiteral("text/html; charset=\"utf-8\""), data);
	#else
	qCWarning(lc, "Qt was built without clipboard support");
	#endif
	} else if (path == QStringLiteral("/webqt.js")) {
	QFile file(QStringLiteral(":/webgl/webqt.jsx"));
	Q_ASSERT(file.exists());
	file.open(QIODevice::ReadOnly \| QIODevice::Text);
	Q_ASSERT(file.isOpen());
	const auto host = url.host().toUtf8();
	const auto port = QString::number(d->webSocketServer->port()).toUtf8();
	QByteArray data = "var host = \"" + host + "\";\r\nvar port = " + port + ";\r\n";
	data += file.readAll();
	addData(QByteArrayLiteral("application/javascript"), data);
	} else if (path == QStringLiteral("/favicon.ico")) {
	QFile file(QStringLiteral(":/webgl/favicon.ico"));
	Q_ASSERT(file.exists());
	file.open(QIODevice::ReadOnly);
	Q_ASSERT(file.isOpen());
	auto data = file.readAll();
	addData(QByteArrayLiteral("image/x-icon"), data);
	} else if (path == QStringLiteral("/favicon.png")) {
	QBuffer buffer;
	qGuiApp->windowIcon().pixmap(16, 16).save(&buffer, "png");
	addData(QByteArrayLiteral("image/x-icon"), buffer.data());
	} else if (auto device = d->customRequestDevices.value(path)) {
	answer = QByteArrayLiteral("HTTP/1.0 200 OK \r\n"
	"Content-Type: text/plain; charset=\"utf-8\"\r\n"
	"Connection: Keep.Alive\r\n\r\n") +
	device->readAll();
	auto timer = new QTimer(device);
	timer->setSingleShot(false);
	connect(timer, &QTimer::timeout, [device, socket]()
	{
	if (device->bytesAvailable())
	socket->write(device->readAll());
	});
	timer->start(1000);
	disconnect = false;
	}
	socket->write(answer);
	if (disconnect)
	socket->disconnectFromHost();
	}

	bool HttpRequest::readMethod(QTcpSocket *socket)
	{
	bool finished = false;
	while (socket->bytesAvailable() && !finished) {
	const auto c = socket->read(1).at(0);
	if (std::isupper(c) && fragment.size() < 6)
	fragment += c;
	else
	finished = true;
	}
	if (finished) {
	if (fragment == "HEAD")
	method = Method::Head;
	else if (fragment == "GET")
	method = Method::Get;
	else if (fragment == "PUT")
	method = Method::Put;
	else if (fragment == "POST")
	method = Method::Post;
	else if (fragment == "DELETE")
	method = Method::Delete;
	else
	qCWarning(lc, "QWebGLHttpServer::HttpRequest::readMethod: Invalid operation %s",
	fragment.data());

	state = State::ReadingUrl;
	fragment.clear();

	return method != Method::Unknown;
	}
	return true;
	}

	bool HttpRequest::readUrl(QTcpSocket *socket)
	{
	bool finished = false;
	while (socket->bytesAvailable() && !finished) {
	char c;
	if (!socket->getChar(&c))
	return false;
	if (std::isspace(c))
	finished = true;
	else
	fragment += c;
	}
	if (finished) {
	if (!fragment.startsWith("/")) {
	qCWarning(lc, "QWebGLHttpServer::HttpRequest::readUrl: Invalid URL path %s",
	fragment.constData());
	return false;
	}
	url.setUrl(QStringLiteral("http://localhost:") + QString::number(port) +
	QString::fromUtf8(fragment));
	state = State::ReadingStatus;
	if (!url.isValid()) {
	qCWarning(lc, "QWebGLHttpServer::HttpRequest::readUrl: Invalid URL %s",
	fragment.constData());
	return false;
	}
	fragment.clear();
	return true;
	}
	return true;
	}

	bool HttpRequest::readStatus(QTcpSocket *socket)
	{
	bool finished = false;
	while (socket->bytesAvailable() && !finished) {
	fragment += socket->read(1);
	if (fragment.endsWith("\r\n")) {
	finished = true;
	fragment.chop(2);
	}
	}
	if (finished) {
	if (!std::isdigit(fragment.at(fragment.size() - 3)) \|\|
	!std::isdigit(fragment.at(fragment.size() - 1))) {
	qCWarning(lc, "QWebGLHttpServer::HttpRequest::::readStatus: Invalid version");
	return false;
	}
	version = qMakePair(fragment.at(fragment.size() - 3) - '0',
	fragment.at(fragment.size() - 1) - '0');
	state = State::ReadingHeader;
	fragment.clear();
	}
	return true;
	}

	bool HttpRequest::readHeader(QTcpSocket *socket)
	{
	while (socket->bytesAvailable()) {
	fragment += socket->read(1);
	if (fragment.endsWith("\r\n")) {
	if (fragment == "\r\n") {
	state = State::ReadingBody;
	fragment.clear();
	return true;
	} else {
	fragment.chop(2);
	const int index = fragment.indexOf(':');
	if (index == -1)
	return false;

	const QByteArray key = fragment.mid(0, index).trimmed();
	const QByteArray value = fragment.mid(index + 1).trimmed();
	headers.insert(key, value);
	if (QStringLiteral("host").compare(key, Qt::CaseInsensitive) == 0) {
	auto parts = value.split(':');
	if (parts.size() == 1) {
	url.setHost(parts.first());
	url.setPort(80);
	} else {
	url.setHost(parts.first());
	url.setPort(std::strtoul(parts.at(1).constData(), nullptr, 10));
	}
	}
	fragment.clear();
	}
	}
	}
	return false;
	}

	QT_END_NAMESPACE