Dual-Stack AO2 Client to handle both TCP and Websocket connections seemlessly

Attorney_Online.pro

@@ -1,4 +1,4 @@
-QT += core gui widgets network
+QT += core gui widgets network websockets
 
 TARGET = Attorney_Online
 TEMPLATE = app

CMakeLists.txt

@@ -31,10 +31,10 @@ endif()
 target_include_directories(Attorney_Online PRIVATE include)
 
 # Target Lib
-find_package(Qt5 COMPONENTS Core Gui Network Widgets Concurrent REQUIRED)
+find_package(Qt5 COMPONENTS Core Gui Network Widgets Concurrent WebSockets REQUIRED)
 target_link_directories(Attorney_Online PRIVATE lib)
 target_link_libraries(Attorney_Online PRIVATE Qt5::Core Qt5::Gui Qt5::Network Qt5::Widgets Qt5::Concurrent
-    bass bassmidi bassopus discord-rpc)
+    Qt5::WebSockets bass bassmidi bassopus discord-rpc)
 target_compile_definitions(Attorney_Online PRIVATE DISCORD)
 
 # Subdirectories

include/datatypes.h

@@ -1,13 +1,25 @@
 #ifndef DATATYPES_H
 #define DATATYPES_H
 
+#include <QMap>
 #include <QString>
 
+enum connection_type {
+  TCP,
+  WEBSOCKETS,
+};
+
+static QMap<QString, connection_type> to_connection_type = {
+    {"tcp", connection_type::TCP},
+    {"ws", connection_type::WEBSOCKETS}
+};
+
 struct server_type {
   QString name;
   QString desc;
   QString ip;
   int port;
+  connection_type socket_type;
 };
 
 struct emote_type {

include/networkmanager.h

@@ -6,7 +6,7 @@
 
 #include <QDnsLookup>
 #include <QNetworkAccessManager>
-#include <QTcpSocket>
+#include <QtWebSockets/QWebSocket>
 #include <QTime>
 #include <QTimer>
 
@@ -21,16 +21,20 @@ enum MSDocumentType {
 class NetworkManager : public QObject {
   Q_OBJECT
 
-public:
-  explicit NetworkManager(AOApplication *parent);
-  ~NetworkManager() = default;
-
+private:
   AOApplication *ao_app;
   QNetworkAccessManager *http;
-  QTcpSocket *server_socket;
+
+  union {
+    QWebSocket *ws;
+    QTcpSocket *tcp;
+  } server_socket;
+  connection_type active_connection_type;
+  bool connected = false;
+
   QTimer *heartbeat_timer;
 
-  const QString DEFAULT_MS_BASEURL = "https://servers.aceattorneyonline.com";
+  const QString DEFAULT_MS_BASEURL = "http://servers.aceattorneyonline.com";
   QString ms_baseurl = DEFAULT_MS_BASEURL;
 
   const int heartbeat_interval = 60 * 5 * 1000;
@@ -40,12 +44,17 @@ class NetworkManager : public QObject {
 
   unsigned int s_decryptor = 5;
 
+public:
+  explicit NetworkManager(AOApplication *parent);
+  ~NetworkManager() = default;
+
   void connect_to_server(server_type p_server);
+  void disconnect_from_server();
 
 public slots:
   void get_server_list(const std::function<void()> &cb);
   void ship_server_packet(QString p_packet);
-  void handle_server_packet();
+  void handle_server_packet(const QString& p_data);
 
   void request_document(MSDocumentType document_type,
                         const std::function<void(QString)> &cb);

src/aoapplication.cpp

@@ -146,8 +146,20 @@ void AOApplication::add_favorite_server(int p_server)
   server_type fav_server = server_list.at(p_server);
 
   QString str_port = QString::number(fav_server.port);
+  QString network_type;
+  switch (fav_server.socket_type) {
+  default:
+    fav_server.socket_type = TCP;
+    Q_FALLTHROUGH();
+  case TCP:
+    network_type = "tcp";
+    break;
+  case WEBSOCKETS:
+    network_type = "ws";
+    break;
+  }
 
-  QString server_line = fav_server.ip + ":" + str_port + ":" + fav_server.name;
+  QString server_line = fav_server.ip + ":" + str_port + ":" + fav_server.name + ":" + network_type;
 
   write_to_serverlist_txt(server_line);
 }

src/networkmanager.cpp

@@ -4,6 +4,7 @@
 #include "debug_functions.h"
 #include "lobby.h"
 
+#include <QAbstractSocket>
 #include <QJsonArray>
 #include <QJsonDocument>
 #include <QNetworkReply>
@@ -12,15 +13,9 @@ NetworkManager::NetworkManager(AOApplication *parent) : QObject(parent)
 {
   ao_app = parent;
 
-  server_socket = new QTcpSocket(this);
   http = new QNetworkAccessManager(this);
   heartbeat_timer = new QTimer(this);
 
-  connect(server_socket, &QTcpSocket::readyRead, this,
-          &NetworkManager::handle_server_packet);
-  connect(server_socket, &QTcpSocket::disconnected, ao_app,
-          &AOApplication::server_disconnected);
-
   QString master_config =
       ao_app->configini->value("master", "").value<QString>();
   if (!master_config.isEmpty() && QUrl(master_config).scheme().startsWith("http")) {
@@ -60,10 +55,18 @@ void NetworkManager::ms_request_finished(QNetworkReply *reply,
     const auto entry = entryRef.toObject();
     server_type server;
     server.ip = entry["ip"].toString();
-    server.port = entry["port"].toInt();
     server.name = entry["name"].toString();
     server.desc = entry["description"].toString(tr("No description provided."));
-    server_list.append(server);
+    if (entry["ws_port"].isDouble()) {
+      server.socket_type = WEBSOCKETS;
+      server.port = entry["ws_port"].toInt();
+    } else {
+      server.socket_type = TCP;
+      server.port = entry["port"].toInt();
+    }
+    if (server.port != 0) {
+        server_list.append(server);
+    }
   }
   ao_app->set_server_list(server_list);
 
@@ -128,26 +131,99 @@ void NetworkManager::request_document(MSDocumentType document_type,
 
 void NetworkManager::connect_to_server(server_type p_server)
 {
-  server_socket->close();
-  server_socket->abort();
+  disconnect_from_server();
 
   qInfo().nospace().noquote() << "connecting to " << p_server.ip << ":"
                               << p_server.port;
 
-  server_socket->connectToHost(p_server.ip, p_server.port);
+  switch (p_server.socket_type) {
+  default:
+    p_server.socket_type = TCP;
+    [[fallthrough]];
+  case TCP:
+    qInfo() << "using TCP backend";
+    server_socket.tcp = new QTcpSocket(this);
+
+    connect(server_socket.tcp, &QAbstractSocket::connected, this, [] {
+      qDebug() << "established connection to server";
+    });
+    connect(server_socket.tcp, &QIODevice::readyRead, this, [this] {
+      handle_server_packet(QString::fromUtf8(server_socket.tcp->readAll()));
+    });
+    connect(server_socket.tcp, &QAbstractSocket::disconnected, ao_app,
+            &AOApplication::server_disconnected);
+    connect(server_socket.tcp, &QAbstractSocket::errorOccurred, this, [this] {
+      qCritical() << "TCP socket error:" << server_socket.tcp->errorString();
+    });
+
+    server_socket.tcp->connectToHost(p_server.ip, p_server.port);
+    break;
+  case WEBSOCKETS:
+    qInfo() << "using WebSockets backend";
+    server_socket.ws = new QWebSocket(QString(), QWebSocketProtocol::VersionLatest, this);
+
+    connect(server_socket.ws, &QWebSocket::connected, this, [] {
+      qDebug() << "established connection to server";
+    });
+    connect(server_socket.ws, &QWebSocket::textMessageReceived, this,
+            &NetworkManager::handle_server_packet);
+    connect(server_socket.ws, &QWebSocket::disconnected, ao_app,
+            &AOApplication::server_disconnected);
+    connect(server_socket.ws, QOverload<QAbstractSocket::SocketError>::of(&QWebSocket::error),
+            this, [this] {
+      qCritical() << "WebSockets error:" << server_socket.ws->errorString();
+    });
+
+    QUrl url;
+    url.setScheme("ws");
+    url.setHost(p_server.ip);
+    url.setPort(p_server.port);
+    QNetworkRequest req(url);
+    req.setHeader(QNetworkRequest::UserAgentHeader, get_user_agent());
+    server_socket.ws->open(req);
+    break;
+  }
+
+  connected = true;
+  active_connection_type = p_server.socket_type;
+}
+
+void NetworkManager::disconnect_from_server()
+{
+  if (!connected)
+    return;
+
+  switch (active_connection_type) {
+  case TCP:
+    server_socket.tcp->close();
+    server_socket.tcp->deleteLater();
+    break;
+  case WEBSOCKETS:
+    server_socket.ws->close(QWebSocketProtocol::CloseCodeGoingAway);
+    server_socket.ws->deleteLater();
+    break;
+  }
+
+  connected = false;
 }
 
 void NetworkManager::ship_server_packet(QString p_packet)
 {
-  server_socket->write(p_packet.toUtf8());
+  switch (active_connection_type) {
+  case TCP:
+    server_socket.tcp->write(p_packet.toUtf8());
+    break;
+  case WEBSOCKETS:
+    server_socket.ws->sendTextMessage(p_packet);
+    break;
+  }
 }
 
-void NetworkManager::handle_server_packet()
+void NetworkManager::handle_server_packet(const QString& p_data)
 {
-  QByteArray buffer = server_socket->readAll();
-  QString in_data = QString::fromUtf8(buffer, buffer.size());
+  QString in_data = p_data;
 
-  if (!in_data.endsWith("%")) {
+  if (!p_data.endsWith("%")) {
     partial_packet = true;
     temp_packet += in_data;
     return;

src/text_file_functions.cpp

@@ -278,6 +278,16 @@ QVector<server_type> AOApplication::read_serverlist_txt()
         f_server.ip = line_contents.at(0);
         f_server.port = line_contents.at(1).toInt();
         f_server.name = line_contents.at(2);
+
+        if (line_contents.size() >= 4) {
+          QString socket_type = line_contents.at(3).toLower();
+          if (socket_type == "ws" || socket_type == "tcp") {
+            f_server.socket_type = to_connection_type.value(socket_type);
+          }
+          else {
+            qWarning() << "Serverlist.txt - Unknown socket type: " << socket_type;
+          }
+        }
         f_server.desc = "";
 
         f_server_list.append(f_server);