Adds initial intermediate qt6 porting state

qt6-after/qt6-migrated-legatus/Lts/Common/httq/include/httq/AbstractServer.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <httq/httq_export.h>
+
+#include <QObject>
+#include <QHostAddress>
+
+
+class QTcpServer;
+class QWebSocketServer;
+
+
+namespace httq
+{
+class HttpRequest;
+class LoggerFactory;
+class Logger;
+
+
+class HTTQ_EXPORT AbstractServer : public QObject
+{
+  Q_OBJECT
+public:
+  explicit AbstractServer(QObject *parent = nullptr);
+
+  virtual bool newHttpConnection(HttpRequest *request) = 0;
+  virtual QWebSocketServer *webSocketServer() const { return nullptr; }
+  virtual LoggerFactory *createLoggerFactory();
+  LoggerFactory *getLoggerFactory();
+  bool listen(qint16 port, const QHostAddress &host = QHostAddress::Any);
+
+private slots:
+  void slotNewConnection();
+
+private:
+  QTcpServer *mSvr;
+  LoggerFactory *mLoggerFactory { nullptr };
+  Logger *mLogger;
+};
+}

qt6-after/qt6-migrated-legatus/Lts/Common/httq/include/httq/DataStream.h

@@ -0,0 +1,53 @@
+#pragma once
+
+#include <httq/httq_export.h>
+#include <httq/Logger.h>
+
+#include <QObject>
+#include <QScopedPointer>
+
+
+class QIODevice;
+
+
+namespace httq
+{
+class HttpRequest;
+
+class HTTQ_EXPORT DataStream : public QObject
+{
+  Q_OBJECT
+
+private:
+  explicit DataStream(QIODevice *from, QIODevice *to, const QByteArray &bodyPartial,
+                      qint64 fileLength, size_t bufferSize, LoggerFactory *loggerFactory,
+                      QObject *parent = nullptr);
+
+public:
+  ~DataStream();
+
+private:
+  friend class HttpRequest;
+
+  void readNext();
+  void writeNext();
+
+  bool mReadyWrite { true };
+  
+  QByteArray mBuffer;
+  QByteArray mBodyPartial;
+  QIODevice *mFrom;
+  QIODevice *mTo;
+  
+  qint64 mBufferSize;
+  qint64 alreadyRead { 0 };
+  qint64 mFileLength;
+  bool mFromSupportsSignals { false };
+  bool mToSupportsSignals { false };
+  QScopedPointer<Logger> mLogger;
+
+signals:
+  void signalDone();
+
+};
+}

qt6-after/qt6-migrated-legatus/Lts/Common/httq/include/httq/HttpRequest.h

@@ -0,0 +1,112 @@
+#pragma once
+
+#include <httq/httq_export.h>
+#include <http_parser.h>
+
+#include <QObject>
+#include <QByteArray>
+#include <QUrl>
+#include <QMap>
+#include <QString>
+#include <QUrlQuery>
+
+
+class QTcpSocket;
+class QIODevice;
+
+
+namespace httq
+{
+class AbstractServer;
+class Logger;
+class DataStream;
+class HttpRequest;
+
+
+struct HttpRequestData
+{
+  QByteArray mData;
+  QUrl mUrl;
+  QString mCurrentHeaderField;
+  QMap<QString, QString> mHeaders;
+  bool mDone { false };
+  QByteArray mBodyPartial;
+  QUrlQuery mQuery;
+  HttpRequest *mHttpRquest;
+};
+
+
+class HTTQ_EXPORT HttpRequest : public QObject
+{
+  Q_OBJECT
+
+private:
+  explicit HttpRequest(QTcpSocket *cli, AbstractServer *parent = nullptr);
+public:
+  ~HttpRequest();
+
+  qint64 availableBytes() const;
+  http_method method() const { return (enum http_method)mParser.method; }
+  QString methodString() const { return QString::fromUtf8(http_method_str(method())); }
+  const QUrl &url() const { return mData.mUrl; }
+  const QUrlQuery &query() const { return mData.mQuery; }
+  qint64 contentLength() const { return mContentLength; }
+  const QMap<QString, QString> &requestHeaders() const { return mData.mHeaders; }
+  
+  
+  Logger *logger() { return mLogger; }
+  QString toString() const;
+
+  
+  void addHeader(const QString &key, const QString &value);
+  void write(int status, const QByteArray &data, const QString &contentType);
+  void write(int status, const QJsonValue &jsonValue);
+  DataStream *createDataStreamFromClient(QIODevice *to, qint64 fileSize, qint64 bufferSize = 1024 * 1024);
+  DataStream *createDataStreamToClient(int status, const QString &contentType, QIODevice *from, qint64 fileSize, qint64 bufferSize = 1024 * 1024);
+
+  friend class DataStream;
+
+
+private:
+  friend class AbstractServer;
+
+  
+  void writeStatusHeader(int status);
+  void writeHeaders();
+
+  static int on_message_begin(http_parser *parser);
+  static int on_url(http_parser *parser, const char *at, size_t length);
+  static int on_status(http_parser *parser, const char *at, size_t length);
+  static int on_header_field(http_parser *parser, const char *at, size_t length);
+  static int on_header_value(http_parser *parser, const char *at, size_t length);
+  static int on_headers_complete(http_parser *parser);
+  static int on_body(http_parser *parser, const char *at, size_t length);
+  static int on_message_complete(http_parser *parser);
+  static int on_chunk_header(http_parser *parser);
+  static int on_chunk_complete(http_parser *parser);
+
+  static HttpRequestData *data(http_parser *parser) { return static_cast<HttpRequestData *>(parser->data); }
+  static Logger *dataLogger(http_parser *parser) { return static_cast<HttpRequestData *>(parser->data)->mHttpRquest->logger(); }
+
+
+  QTcpSocket *mCli;
+  http_parser mParser;
+  http_parser_settings mParserSettings;
+  HttpRequestData mData;
+  bool mDone { false };
+  qint64 mContentLength { 0 };
+  qint64 alreadyRead { 0 };
+  QMap<QString, QString> mHeaders;
+  Logger *mLogger;
+
+
+private slots:
+  void slotReadyRead();
+
+
+signals:
+  void signalUpgrade(QTcpSocket *sock);
+  void signalReady();
+
+};
+}

qt6-after/qt6-migrated-legatus/Lts/Common/httq/include/httq/Logger.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include <httq/httq_export.h>
+
+#include <QScopedPointer>
+#include <QPointer>
+
+
+namespace httq
+{
+class Logger;
+
+
+class HTTQ_EXPORT LoggerFactory : public QObject
+{
+  Q_OBJECT
+
+public:
+  LoggerFactory(QObject *parent)
+    : QObject(parent)
+  {}
+
+  virtual Logger *createLogger(QObject *parent);
+};
+
+
+class HTTQ_EXPORT Logger : public QObject
+{
+  Q_OBJECT
+public:
+  Logger(LoggerFactory *loggerFactory, QObject *parent);
+
+  virtual void debug(const QString &message);
+  virtual void warning(const QString &message);
+  virtual void error(const QString &message);
+
+  virtual LoggerFactory *getLoggerFactory() const
+  {
+    Q_ASSERT(mLoggerFactory);
+    return mLoggerFactory;
+  }
+
+protected:
+  QPointer<LoggerFactory> mLoggerFactory;
+
+private:
+  QDebug qtLogger(const QString &type, QDebug debug);
+
+  QString mPath;
+};
+}