248 lines
10 KiB
C++
248 lines
10 KiB
C++
// SPDX-License-Identifier: GPL-3.0-or-later
|
|
|
|
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
|
|
*
|
|
* Copyright (C) 2013 - 2024, nymea GmbH
|
|
* Copyright (C) 2024 - 2025, chargebyte austria GmbH
|
|
*
|
|
* This file is part of nymea-remoteproxy.
|
|
*
|
|
* nymea-remoteproxy is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* nymea-remoteproxy is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with nymea-remoteproxy. If not, see <https://www.gnu.org/licenses/>.
|
|
*
|
|
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
|
|
|
|
#include <QUrl>
|
|
#include <QUuid>
|
|
#include <QHash>
|
|
#include <QCoreApplication>
|
|
#include <QLoggingCategory>
|
|
#include <QCommandLineParser>
|
|
#include <QCommandLineOption>
|
|
|
|
#include "serverconnection.h"
|
|
#include "clientconnection.h"
|
|
|
|
#include "../version.h"
|
|
|
|
static QHash<QString, bool> s_loggingFilters;
|
|
static const char *const normal = "\033[0m";
|
|
static const char *const warning = "\e[33m";
|
|
static const char *const error = "\e[31m";
|
|
|
|
static void loggingCategoryFilter(QLoggingCategory *category)
|
|
{
|
|
if (s_loggingFilters.contains(category->categoryName())) {
|
|
bool debugEnabled = s_loggingFilters.value(category->categoryName());
|
|
category->setEnabled(QtDebugMsg, debugEnabled);
|
|
category->setEnabled(QtWarningMsg, debugEnabled || s_loggingFilters.value("Warnings"));
|
|
} else {
|
|
// Enable default debug output
|
|
category->setEnabled(QtDebugMsg, true);
|
|
category->setEnabled(QtWarningMsg, s_loggingFilters.value("qml") || s_loggingFilters.value("Warnings"));
|
|
}
|
|
}
|
|
|
|
static void consoleLogHandler(QtMsgType type, const QMessageLogContext& context, const QString& message)
|
|
{
|
|
switch (type) {
|
|
case QtInfoMsg:
|
|
if (context.category == QStringLiteral("default")) {
|
|
fprintf(stdout, "%s\n", message.toUtf8().data());
|
|
} else {
|
|
fprintf(stdout, "%s: %s\n", context.category, message.toUtf8().data());
|
|
}
|
|
break;
|
|
case QtDebugMsg:
|
|
if (context.category == QStringLiteral("default")) {
|
|
fprintf(stdout, "%s\n", message.toUtf8().data());
|
|
} else {
|
|
fprintf(stdout, "%s: %s\n", context.category, message.toUtf8().data());
|
|
}
|
|
break;
|
|
case QtWarningMsg:
|
|
fprintf(stdout, "%s%s: %s%s\n", warning, context.category, message.toUtf8().data(), normal);
|
|
break;
|
|
case QtCriticalMsg:
|
|
fprintf(stdout, "%s%s: %s%s\n", error, context.category, message.toUtf8().data(), normal);
|
|
break;
|
|
case QtFatalMsg:
|
|
fprintf(stdout, "%s%s: %s%s\n", error, context.category, message.toUtf8().data(), normal);
|
|
break;
|
|
}
|
|
fflush(stdout);
|
|
}
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
qInstallMessageHandler(consoleLogHandler);
|
|
|
|
QCoreApplication application(argc, argv);
|
|
application.setApplicationName(SERVER_NAME_STRING);
|
|
application.setOrganizationName("nymea");
|
|
application.setApplicationVersion(SERVER_VERSION_STRING);
|
|
|
|
// Default debug categories
|
|
s_loggingFilters.insert("RemoteProxyClientJsonRpc", false);
|
|
s_loggingFilters.insert("RemoteProxyClientJsonRpcTraffic", false);
|
|
s_loggingFilters.insert("RemoteProxyClientWebSocket", false);
|
|
s_loggingFilters.insert("RemoteProxyClientTcpSocket", false);
|
|
s_loggingFilters.insert("RemoteProxyClientConnection", false);
|
|
s_loggingFilters.insert("RemoteProxyClientConnectionTraffic", false);
|
|
s_loggingFilters.insert("TunnelProxySocketServer", false);
|
|
s_loggingFilters.insert("TunnelProxySocketServerTraffic", false);
|
|
s_loggingFilters.insert("TunnelProxyRemoteConnection", false);
|
|
|
|
QCommandLineParser parser;
|
|
parser.addHelpOption();
|
|
parser.addVersionOption();
|
|
parser.setApplicationDescription(QString("\nThe nymea remote proxy tunnel client application. This application allowes to register as client"
|
|
"or server on the tunnel proxy interface.\n\n"
|
|
"Version: %1\n"
|
|
"API version: %2\n\n"
|
|
"Copyright %3 %4 nymea GmbH <developer@nymea.io>\n")
|
|
.arg(SERVER_VERSION_STRING)
|
|
.arg(API_VERSION_STRING)
|
|
.arg(QChar(0xA9))
|
|
.arg(COPYRIGHT_YEAR_STRING));
|
|
|
|
QCommandLineOption urlOption(QStringList() << "u" << "url", "The proxy server url. Default ssl://dev-remoteproxy.nymea.io:2213", "url");
|
|
urlOption.setDefaultValue("ssl://dev-remoteproxy.nymea.io:2213");
|
|
parser.addOption(urlOption);
|
|
|
|
QCommandLineOption insecureOption(QStringList() << "i" << "ignore-ssl", "Ignore SSL certificate errors.");
|
|
parser.addOption(insecureOption);
|
|
|
|
QCommandLineOption serverOption(QStringList() << "s" << "server", "Connect as tunnel proxy server connection.");
|
|
parser.addOption(serverOption);
|
|
|
|
QCommandLineOption clientOption(QStringList() << "c" << "client", "Connect as tunnel proxy client connection. The server uuid is required.");
|
|
parser.addOption(clientOption);
|
|
|
|
QCommandLineOption nameOption(QStringList() << "n" << "name", "The name of the connecting client. If not specified a default name will be selected.", "name");
|
|
parser.addOption(nameOption);
|
|
|
|
QCommandLineOption randomDataOption(QStringList() << "r" << "random", "Send random data trough the tunnel. If you start a server, it will echo any client data received.");
|
|
parser.addOption(randomDataOption);
|
|
|
|
QCommandLineOption uuidOption(QStringList() << "uuid", "The uuid of the connecting client. If not specified, a new one will be created.", "uuid");
|
|
parser.addOption(uuidOption);
|
|
|
|
QCommandLineOption serverUuidOption(QStringList() << "server-uuid", "The uuid of the server you want to connect to as client connection.", "uuid");
|
|
parser.addOption(serverUuidOption);
|
|
|
|
QCommandLineOption verboseOption(QStringList() << "verbose", "Print more information about the connection.");
|
|
parser.addOption(verboseOption);
|
|
|
|
QCommandLineOption veryVerboseOption(QStringList() << "very-verbose", "Print the complete traffic information from the connection.");
|
|
parser.addOption(veryVerboseOption);
|
|
|
|
parser.process(application);
|
|
|
|
// Make sure not server and client given
|
|
if (parser.isSet(serverOption) && parser.isSet(clientOption)) {
|
|
qCritical() << "Please specify either beeing a client or a server connection, not both.";
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
// Get the uuid to pick for the connection
|
|
QUuid uuid(parser.value(uuidOption));
|
|
if (uuid.isNull()) {
|
|
uuid = QUuid::createUuid();
|
|
qDebug() << "Picking automatic UUID" << uuid.toString();
|
|
}
|
|
|
|
QUrl serverUrl(parser.value(urlOption));
|
|
if (!serverUrl.isValid()) {
|
|
qCritical() << "Invalid proxy server url passed." << parser.value(urlOption);
|
|
exit(-1);
|
|
}
|
|
|
|
// Server, or if not specified server too
|
|
if (parser.isSet(serverOption) || (!parser.isSet(serverOption) && !parser.isSet(clientOption))) {
|
|
QString name = parser.value("name");
|
|
if (name.isEmpty()) {
|
|
name = "Server connection";
|
|
qDebug() << "Picking automatic name" << name;
|
|
}
|
|
|
|
// Enable verbose
|
|
if (parser.isSet(verboseOption) || parser.isSet(veryVerboseOption)) {
|
|
s_loggingFilters["default"] = true;
|
|
s_loggingFilters["TunnelProxySocketServer"] = true;
|
|
s_loggingFilters["TunnelProxyRemoteConnection"] = true;
|
|
}
|
|
|
|
// Enable very verbose
|
|
if (parser.isSet(veryVerboseOption)) {
|
|
s_loggingFilters["RemoteProxyClientJsonRpc"] = true;
|
|
s_loggingFilters["RemoteProxyClientJsonRpcTraffic"] = true;
|
|
s_loggingFilters["RemoteProxyClientWebSocket"] = true;
|
|
s_loggingFilters["RemoteProxyClientTcpSocket"] = true;
|
|
s_loggingFilters["RemoteProxyClientConnection"] = true;
|
|
s_loggingFilters["RemoteProxyClientConnectionTraffic"] = true;
|
|
s_loggingFilters["TunnelProxySocketServerTraffic"] = true;
|
|
}
|
|
QLoggingCategory::installFilter(loggingCategoryFilter);
|
|
|
|
|
|
// Create the server connection
|
|
ServerConnection *server = new ServerConnection(serverUrl, name, uuid, parser.isSet(insecureOption), parser.isSet(randomDataOption));
|
|
server->startServer();
|
|
|
|
} else {
|
|
// Client
|
|
QString name = parser.value("name");
|
|
if (name.isEmpty()) {
|
|
name = "Client connection";
|
|
qDebug() << "Picking automatic name" << name;
|
|
}
|
|
|
|
if (!parser.isSet(serverUuidOption)) {
|
|
qCritical() << "Please specify the server UUID you want to connect to using the --server-uuid parameter.";
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
QUuid serverUuid(parser.value(serverUuidOption));
|
|
if (serverUuid.isNull()) {
|
|
qCritical() << "The given server uuid is not valid." << parser.value(serverUuidOption);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
// Enable verbose
|
|
if (parser.isSet(verboseOption) || parser.isSet(veryVerboseOption)) {
|
|
s_loggingFilters["default"] = true;
|
|
s_loggingFilters["TunnelProxySocketServer"] = true;
|
|
s_loggingFilters["TunnelProxyRemoteConnection"] = true;
|
|
}
|
|
|
|
// Enable very verbose
|
|
if (parser.isSet(veryVerboseOption)) {
|
|
s_loggingFilters["RemoteProxyClientJsonRpc"] = true;
|
|
s_loggingFilters["RemoteProxyClientJsonRpcTraffic"] = true;
|
|
s_loggingFilters["RemoteProxyClientWebSocket"] = true;
|
|
s_loggingFilters["RemoteProxyClientTcpSocket"] = true;
|
|
s_loggingFilters["RemoteProxyClientConnection"] = true;
|
|
s_loggingFilters["RemoteProxyClientConnectionTraffic"] = true;
|
|
s_loggingFilters["TunnelProxySocketServerTraffic"] = true;
|
|
}
|
|
QLoggingCategory::installFilter(loggingCategoryFilter);
|
|
|
|
// Create the server connection
|
|
ClientConnection *client = new ClientConnection(serverUrl, name, uuid, serverUuid, parser.isSet(insecureOption), parser.isSet(randomDataOption));
|
|
client->connectToServer();
|
|
}
|
|
|
|
return application.exec();
|
|
}
|