websocketpp::http::status_code::value SessionApi::handleLogin(ApiRequest& aRequest, bool aIsSecure, const WebSocketPtr& aSocket, const string& aIP) {
const auto& reqJson = aRequest.getRequestBody();
auto username = JsonUtil::getField<string>("username", reqJson, false);
auto password = JsonUtil::getField<string>("password", reqJson, false);
auto inactivityMinutes = JsonUtil::getOptionalFieldDefault<uint64_t>("max_inactivity", reqJson, WEBCFG(DEFAULT_SESSION_IDLE_TIMEOUT).uint64());
auto userSession = JsonUtil::getOptionalFieldDefault<bool>("user_session", reqJson, false);
auto session = WebServerManager::getInstance()->getUserManager().authenticate(username, password,
aIsSecure, inactivityMinutes, userSession, aIP);
if (!session) {
aRequest.setResponseErrorStr("Invalid username or password");
return websocketpp::http::status_code::unauthorized;
}
json retJson = {
{ "permissions", session->getUser()->getPermissions() },
{ "token", session->getAuthToken() },
{ "user", session->getUser()->getUserName() },
{ "system", getSystemInfo(aIP) },
{ "run_wizard", SETTING(WIZARD_RUN) },
{ "cid", ClientManager::getInstance()->getMyCID().toBase32() },
};
if (aSocket) {
session->onSocketConnected(aSocket);
aSocket->setSession(session);
}
aRequest.setResponseBody(retJson);
return websocketpp::http::status_code::ok;
}
QstProtocol::QstProtocol(QObject *parent)
: QTcpSocket(parent)
, tx_msg_id(1)
, port(0)
, onData_busy(false)
, enable_reconnect(false)
, reconnect_interval(10000)
, last_data_received(false)
, connection_valid(false)
, debug_on(false)
, m_auto_unpack(true)
{
static int id1 = qRegisterMetaType<QstMessage>(); Q_UNUSED(id1);
static int id2 = qRegisterMetaType<QstMessage*>(); Q_UNUSED(id2);
static int id3 = qRegisterMetaType<const QstMessage*>(); Q_UNUSED(id3);
unique_id = QString::number(++g_unique_id);
if (debug_on) {
qDebug() << QString("%1 QstProtocol::QstProtocol()").arg(uniqueId()).toLatin1();
}
cur_message = 0;
rx_busy = false;
QObject::connect( &connect_timer, SIGNAL(timeout()), this, SLOT(connectTimeout()), Qt::DirectConnection );
QObject::connect( this,SIGNAL(connected()),this,SLOT(onSocketConnected()), Qt::DirectConnection );
QObject::connect( this,SIGNAL(disconnected()),this,SLOT(onSocketClosed()), Qt::DirectConnection );
QObject::connect( this,SIGNAL(readyRead()),this,SLOT(onData()), Qt::DirectConnection );
// initialize. Any time is better than no time.
rx_timer.start();
}
void FileTransfertUpload::receiveAcceptFile(NetworkClient *client, int port)
{
if (port == 0) {
_errors++;
emit clientError("Client reject file.");
check_nbr();
} else {
QTcpSocket *socket = new QTcpSocket(this);
socket->connectToHost(client->getTcpSocket()->peerAddress(), port);
connect(socket, SIGNAL(connected()), this, SLOT(onSocketConnected()));
connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(onSocketError(QAbstractSocket::SocketError)));
connect(socket, SIGNAL(bytesWritten(qint64)), this, SLOT(onSocketWritten()));
}
}
api_return SessionApi::handleSocketConnect(ApiRequest& aRequest, bool aIsSecure, const WebSocketPtr& aSocket) {
auto sessionToken = JsonUtil::getField<string>("authorization", aRequest.getRequestBody(), false);
auto session = WebServerManager::getInstance()->getUserManager().getSession(sessionToken);
if (!session) {
aRequest.setResponseErrorStr("Invalid session token");
return websocketpp::http::status_code::bad_request;
}
if (session->isSecure() != aIsSecure) {
aRequest.setResponseErrorStr("Invalid protocol");
return websocketpp::http::status_code::bad_request;
}
session->onSocketConnected(aSocket);
aSocket->setSession(session);
return websocketpp::http::status_code::ok;
}
DefaultConnection::DefaultConnection(IConnectionPlugin *APlugin, QObject *AParent) : QObject(AParent)
{
FPlugin = APlugin;
FSrvQueryId = START_QUERY_ID;
connect(&FDns, SIGNAL(resultsReady(int, const QJDns::Response &)),SLOT(onDnsResultsReady(int, const QJDns::Response &)));
connect(&FDns, SIGNAL(error(int, QJDns::Error)),SLOT(onDnsError(int, QJDns::Error)));
connect(&FDns, SIGNAL(shutdownFinished()),SLOT(onDnsShutdownFinished()));
FSocket.setProtocol(QSsl::AnyProtocol);
connect(&FSocket, SIGNAL(connected()), SLOT(onSocketConnected()));
connect(&FSocket, SIGNAL(encrypted()), SLOT(onSocketEncrypted()));
connect(&FSocket, SIGNAL(readyRead()), SLOT(onSocketReadyRead()));
connect(&FSocket, SIGNAL(modeChanged(QSslSocket::SslMode)), SIGNAL(modeChanged(QSslSocket::SslMode)));
connect(&FSocket, SIGNAL(error(QAbstractSocket::SocketError)), SLOT(onSocketError(QAbstractSocket::SocketError)));
connect(&FSocket, SIGNAL(sslErrors(const QList<QSslError> &)), SLOT(onSocketSSLErrors(const QList<QSslError> &)));
connect(&FSocket, SIGNAL(disconnected()), SLOT(onSocketDisconnected()));
FConnectTimer.setSingleShot(true);
FConnectTimer.setInterval(CONNECT_TIMEOUT);
connect(&FConnectTimer,SIGNAL(timeout()),SLOT(onConnectTimerTimeout()));
}
