mirror of
https://github.com/moonlight-stream/moonlight-qt
synced 2024-12-15 13:52:28 +00:00
810 lines
27 KiB
C++
810 lines
27 KiB
C++
#include "computermanager.h"
|
|
#include "boxartmanager.h"
|
|
#include "nvhttp.h"
|
|
#include "settings/streamingpreferences.h"
|
|
|
|
#include <Limelight.h>
|
|
#include <QtEndian>
|
|
|
|
#include <QThread>
|
|
#include <QThreadPool>
|
|
#include <QCoreApplication>
|
|
|
|
#define SER_HOSTS "hosts"
|
|
|
|
class PcMonitorThread : public QThread
|
|
{
|
|
Q_OBJECT
|
|
|
|
#define TRIES_BEFORE_OFFLINING 2
|
|
#define POLLS_PER_APPLIST_FETCH 10
|
|
|
|
public:
|
|
PcMonitorThread(NvComputer* computer)
|
|
: m_Computer(computer)
|
|
{
|
|
setObjectName("Polling thread for " + computer->name);
|
|
}
|
|
|
|
private:
|
|
bool tryPollComputer(QString address, bool& changed)
|
|
{
|
|
NvHTTP http(address, m_Computer->serverCert);
|
|
|
|
QString serverInfo;
|
|
try {
|
|
serverInfo = http.getServerInfo(NvHTTP::NvLogLevel::NVLL_NONE, true);
|
|
} catch (...) {
|
|
return false;
|
|
}
|
|
|
|
NvComputer newState(address, serverInfo, QSslCertificate());
|
|
|
|
// Ensure the machine that responded is the one we intended to contact
|
|
if (m_Computer->uuid != newState.uuid) {
|
|
qInfo() << "Found unexpected PC " << newState.name << " looking for " << m_Computer->name;
|
|
return false;
|
|
}
|
|
|
|
changed = m_Computer->update(newState);
|
|
return true;
|
|
}
|
|
|
|
bool updateAppList(bool& changed)
|
|
{
|
|
Q_ASSERT(m_Computer->activeAddress != nullptr);
|
|
|
|
NvHTTP http(m_Computer->activeAddress, m_Computer->serverCert);
|
|
|
|
QVector<NvApp> appList;
|
|
|
|
try {
|
|
appList = http.getAppList();
|
|
if (appList.isEmpty()) {
|
|
return false;
|
|
}
|
|
} catch (...) {
|
|
return false;
|
|
}
|
|
|
|
QWriteLocker lock(&m_Computer->lock);
|
|
changed = m_Computer->updateAppList(appList);
|
|
return true;
|
|
}
|
|
|
|
void run() override
|
|
{
|
|
// Always fetch the applist the first time
|
|
int pollsSinceLastAppListFetch = POLLS_PER_APPLIST_FETCH;
|
|
while (!isInterruptionRequested()) {
|
|
bool stateChanged = false;
|
|
bool online = false;
|
|
bool wasOnline = m_Computer->state == NvComputer::CS_ONLINE;
|
|
for (int i = 0; i < (wasOnline ? TRIES_BEFORE_OFFLINING : 1) && !online; i++) {
|
|
for (auto& address : m_Computer->uniqueAddresses()) {
|
|
if (isInterruptionRequested()) {
|
|
return;
|
|
}
|
|
|
|
if (tryPollComputer(address, stateChanged)) {
|
|
if (!wasOnline) {
|
|
qInfo() << m_Computer->name << "is now online at" << m_Computer->activeAddress;
|
|
}
|
|
online = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check if we failed after all retry attempts
|
|
// Note: we don't need to acquire the read lock here,
|
|
// because we're on the writing thread.
|
|
if (!online && m_Computer->state != NvComputer::CS_OFFLINE) {
|
|
qInfo() << m_Computer->name << "is now offline";
|
|
m_Computer->state = NvComputer::CS_OFFLINE;
|
|
stateChanged = true;
|
|
}
|
|
|
|
// Grab the applist if it's empty or it's been long enough that we need to refresh
|
|
pollsSinceLastAppListFetch++;
|
|
if (m_Computer->state == NvComputer::CS_ONLINE &&
|
|
m_Computer->pairState == NvComputer::PS_PAIRED &&
|
|
(m_Computer->appList.isEmpty() || pollsSinceLastAppListFetch >= POLLS_PER_APPLIST_FETCH)) {
|
|
// Notify prior to the app list poll since it may take a while, and we don't
|
|
// want to delay onlining of a machine, especially if we already have a cached list.
|
|
if (stateChanged) {
|
|
emit computerStateChanged(m_Computer);
|
|
stateChanged = false;
|
|
}
|
|
|
|
if (updateAppList(stateChanged)) {
|
|
pollsSinceLastAppListFetch = 0;
|
|
}
|
|
}
|
|
|
|
if (stateChanged) {
|
|
// Tell anyone listening that we've changed state
|
|
emit computerStateChanged(m_Computer);
|
|
}
|
|
|
|
// Wait a bit to poll again, but do it in 100 ms chunks
|
|
// so we can be interrupted reasonably quickly.
|
|
// FIXME: QWaitCondition would be better.
|
|
for (int i = 0; i < 30 && !isInterruptionRequested(); i++) {
|
|
QThread::msleep(100);
|
|
}
|
|
}
|
|
}
|
|
|
|
signals:
|
|
void computerStateChanged(NvComputer* computer);
|
|
|
|
private:
|
|
NvComputer* m_Computer;
|
|
};
|
|
|
|
ComputerManager::ComputerManager(QObject *parent)
|
|
: QObject(parent),
|
|
m_PollingRef(0),
|
|
m_MdnsBrowser(nullptr)
|
|
{
|
|
QSettings settings;
|
|
|
|
// Inflate our hosts from QSettings
|
|
int hosts = settings.beginReadArray(SER_HOSTS);
|
|
for (int i = 0; i < hosts; i++) {
|
|
settings.setArrayIndex(i);
|
|
NvComputer* computer = new NvComputer(settings);
|
|
m_KnownHosts[computer->uuid] = computer;
|
|
}
|
|
settings.endArray();
|
|
|
|
// To quit in a timely manner, we must block additional requests
|
|
// after we receive the aboutToQuit() signal. This is neccessary
|
|
// because NvHTTP uses aboutToQuit() to abort requests in progres
|
|
// while quitting, however this is a one time signal - additional
|
|
// requests would not be aborted and block termination.
|
|
connect(QCoreApplication::instance(), SIGNAL(aboutToQuit()), this, SLOT(handleAboutToQuit()));
|
|
}
|
|
|
|
ComputerManager::~ComputerManager()
|
|
{
|
|
QWriteLocker lock(&m_Lock);
|
|
|
|
// Delete machines that haven't been resolved yet
|
|
while (!m_PendingResolution.isEmpty()) {
|
|
MdnsPendingComputer* computer = m_PendingResolution.first();
|
|
delete computer;
|
|
m_PendingResolution.removeFirst();
|
|
}
|
|
|
|
// Delete the browser to stop discovery
|
|
delete m_MdnsBrowser;
|
|
m_MdnsBrowser = nullptr;
|
|
|
|
// Interrupt polling
|
|
for (ComputerPollingEntry* entry : m_PollEntries) {
|
|
entry->interrupt();
|
|
}
|
|
|
|
// Delete all polling entries (and associated threads)
|
|
for (ComputerPollingEntry* entry : m_PollEntries) {
|
|
delete entry;
|
|
}
|
|
|
|
// Destroy all NvComputer objects now that polling is halted
|
|
for (NvComputer* computer : m_KnownHosts) {
|
|
delete computer;
|
|
}
|
|
}
|
|
|
|
void ComputerManager::saveHosts()
|
|
{
|
|
QSettings settings;
|
|
QReadLocker lock(&m_Lock);
|
|
|
|
settings.remove(SER_HOSTS);
|
|
settings.beginWriteArray(SER_HOSTS);
|
|
int i = 0;
|
|
for (const NvComputer* computer : m_KnownHosts) {
|
|
settings.setArrayIndex(i++);
|
|
computer->serialize(settings);
|
|
}
|
|
settings.endArray();
|
|
}
|
|
|
|
QHostAddress ComputerManager::getBestGlobalAddressV6(QVector<QHostAddress> &addresses)
|
|
{
|
|
for (const QHostAddress& address : addresses) {
|
|
if (address.protocol() == QAbstractSocket::IPv6Protocol) {
|
|
if (address.isInSubnet(QHostAddress("fe80::"), 10)) {
|
|
// Link-local
|
|
continue;
|
|
}
|
|
|
|
if (address.isInSubnet(QHostAddress("fec0::"), 10)) {
|
|
qInfo() << "Ignoring site-local address:" << address;
|
|
continue;
|
|
}
|
|
|
|
if (address.isInSubnet(QHostAddress("fc00::"), 7)) {
|
|
qInfo() << "Ignoring ULA:" << address;
|
|
continue;
|
|
}
|
|
|
|
if (address.isInSubnet(QHostAddress("2002::"), 16)) {
|
|
qInfo() << "Ignoring 6to4 address:" << address;
|
|
continue;
|
|
}
|
|
|
|
if (address.isInSubnet(QHostAddress("2001::"), 32)) {
|
|
qInfo() << "Ignoring Teredo address:" << address;
|
|
continue;
|
|
}
|
|
|
|
return address;
|
|
}
|
|
}
|
|
|
|
return QHostAddress();
|
|
}
|
|
|
|
void ComputerManager::startPolling()
|
|
{
|
|
QWriteLocker lock(&m_Lock);
|
|
|
|
if (++m_PollingRef > 1) {
|
|
return;
|
|
}
|
|
|
|
StreamingPreferences prefs;
|
|
|
|
if (prefs.enableMdns) {
|
|
// Start an MDNS query for GameStream hosts
|
|
m_MdnsBrowser = new QMdnsEngine::Browser(&m_MdnsServer, "_nvstream._tcp.local.", &m_MdnsCache);
|
|
connect(m_MdnsBrowser, &QMdnsEngine::Browser::serviceAdded,
|
|
this, [this](const QMdnsEngine::Service& service) {
|
|
qInfo() << "Discovered mDNS host:" << service.hostname();
|
|
|
|
MdnsPendingComputer* pendingComputer = new MdnsPendingComputer(&m_MdnsServer, service);
|
|
connect(pendingComputer, &MdnsPendingComputer::resolvedHost,
|
|
this, &ComputerManager::handleMdnsServiceResolved);
|
|
m_PendingResolution.append(pendingComputer);
|
|
});
|
|
}
|
|
else {
|
|
qWarning() << "mDNS is disabled by user preference";
|
|
}
|
|
|
|
// Start polling threads for each known host
|
|
QMapIterator<QString, NvComputer*> i(m_KnownHosts);
|
|
while (i.hasNext()) {
|
|
i.next();
|
|
startPollingComputer(i.value());
|
|
}
|
|
}
|
|
|
|
// Must hold m_Lock for write
|
|
void ComputerManager::startPollingComputer(NvComputer* computer)
|
|
{
|
|
if (m_PollingRef == 0) {
|
|
return;
|
|
}
|
|
|
|
ComputerPollingEntry* pollingEntry;
|
|
|
|
if (!m_PollEntries.contains(computer->uuid)) {
|
|
pollingEntry = m_PollEntries[computer->uuid] = new ComputerPollingEntry();
|
|
}
|
|
else {
|
|
pollingEntry = m_PollEntries[computer->uuid];
|
|
}
|
|
|
|
if (!pollingEntry->isActive()) {
|
|
PcMonitorThread* thread = new PcMonitorThread(computer);
|
|
connect(thread, SIGNAL(computerStateChanged(NvComputer*)),
|
|
this, SLOT(handleComputerStateChanged(NvComputer*)));
|
|
pollingEntry->setActiveThread(thread);
|
|
thread->start();
|
|
}
|
|
}
|
|
|
|
void ComputerManager::handleMdnsServiceResolved(MdnsPendingComputer* computer,
|
|
QVector<QHostAddress>& addresses)
|
|
{
|
|
QHostAddress v6Global = getBestGlobalAddressV6(addresses);
|
|
bool added = false;
|
|
|
|
// Add the host using the IPv4 address
|
|
for (const QHostAddress& address : addresses) {
|
|
if (address.protocol() == QAbstractSocket::IPv4Protocol) {
|
|
// NB: We don't just call addNewHost() here with v6Global because the IPv6
|
|
// address may not be reachable (if the user hasn't installed the IPv6 helper yet
|
|
// or if this host lacks outbound IPv6 capability). We want to add IPv6 even if
|
|
// it's not currently reachable.
|
|
addNewHost(address.toString(), true, v6Global);
|
|
added = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!added) {
|
|
// If we get here, there wasn't an IPv4 address so we'll do it v6-only
|
|
for (const QHostAddress& address : addresses) {
|
|
if (address.protocol() == QAbstractSocket::IPv6Protocol) {
|
|
// Use a link-local or site-local address for the "local address"
|
|
if (address.isInSubnet(QHostAddress("fe80::"), 10) ||
|
|
address.isInSubnet(QHostAddress("fec0::"), 10) ||
|
|
address.isInSubnet(QHostAddress("fc00::"), 7)) {
|
|
addNewHost(address.toString(), true, v6Global);
|
|
added = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
m_PendingResolution.removeOne(computer);
|
|
computer->deleteLater();
|
|
}
|
|
|
|
void ComputerManager::handleComputerStateChanged(NvComputer* computer)
|
|
{
|
|
emit computerStateChanged(computer);
|
|
|
|
if (computer->pendingQuit && computer->currentGameId == 0) {
|
|
computer->pendingQuit = false;
|
|
emit quitAppCompleted(QVariant());
|
|
}
|
|
|
|
// Save updated hosts to QSettings
|
|
saveHosts();
|
|
}
|
|
|
|
QVector<NvComputer*> ComputerManager::getComputers()
|
|
{
|
|
QReadLocker lock(&m_Lock);
|
|
|
|
return QVector<NvComputer*>::fromList(m_KnownHosts.values());
|
|
}
|
|
|
|
class DeferredHostDeletionTask : public QRunnable
|
|
{
|
|
public:
|
|
DeferredHostDeletionTask(ComputerManager* cm, NvComputer* computer)
|
|
: m_Computer(computer),
|
|
m_ComputerManager(cm) {}
|
|
|
|
void run()
|
|
{
|
|
ComputerPollingEntry* pollingEntry;
|
|
|
|
// Only do the minimum amount of work while holding the writer lock.
|
|
// We must release it before calling saveHosts().
|
|
{
|
|
QWriteLocker lock(&m_ComputerManager->m_Lock);
|
|
|
|
pollingEntry = m_ComputerManager->m_PollEntries.take(m_Computer->uuid);
|
|
|
|
m_ComputerManager->m_KnownHosts.remove(m_Computer->uuid);
|
|
}
|
|
|
|
// Persist the new host list
|
|
m_ComputerManager->saveHosts();
|
|
|
|
// Delete the polling entry first. This will stop all polling threads too.
|
|
delete pollingEntry;
|
|
|
|
// Delete cached box art
|
|
BoxArtManager::deleteBoxArt(m_Computer);
|
|
|
|
// Finally, delete the computer itself. This must be done
|
|
// last because the polling thread might be using it.
|
|
delete m_Computer;
|
|
}
|
|
|
|
private:
|
|
NvComputer* m_Computer;
|
|
ComputerManager* m_ComputerManager;
|
|
};
|
|
|
|
void ComputerManager::deleteHost(NvComputer* computer)
|
|
{
|
|
// Punt to a worker thread to avoid stalling the
|
|
// UI while waiting for the polling thread to die
|
|
QThreadPool::globalInstance()->start(new DeferredHostDeletionTask(this, computer));
|
|
}
|
|
|
|
void ComputerManager::renameHost(NvComputer* computer, QString name)
|
|
{
|
|
{
|
|
QWriteLocker(&computer->lock);
|
|
|
|
computer->name = name;
|
|
computer->hasCustomName = true;
|
|
}
|
|
|
|
// Notify the UI of the state change
|
|
handleComputerStateChanged(computer);
|
|
}
|
|
|
|
void ComputerManager::clientSideAttributeUpdated(NvComputer* computer)
|
|
{
|
|
// Persist the change
|
|
saveHosts();
|
|
|
|
// Notify the UI of the state change
|
|
handleComputerStateChanged(computer);
|
|
}
|
|
|
|
void ComputerManager::handleAboutToQuit()
|
|
{
|
|
QWriteLocker lock(&m_Lock);
|
|
|
|
// Interrupt polling threads immediately, so they
|
|
// avoid making additional requests while quitting
|
|
for (ComputerPollingEntry* entry : m_PollEntries) {
|
|
entry->interrupt();
|
|
}
|
|
}
|
|
|
|
class PendingPairingTask : public QObject, public QRunnable
|
|
{
|
|
Q_OBJECT
|
|
|
|
public:
|
|
PendingPairingTask(ComputerManager* computerManager, NvComputer* computer, QString pin)
|
|
: m_Computer(computer),
|
|
m_Pin(pin)
|
|
{
|
|
connect(this, &PendingPairingTask::pairingCompleted,
|
|
computerManager, &ComputerManager::pairingCompleted);
|
|
}
|
|
|
|
signals:
|
|
void pairingCompleted(NvComputer* computer, QString error);
|
|
|
|
private:
|
|
void run()
|
|
{
|
|
NvPairingManager pairingManager(m_Computer->activeAddress);
|
|
|
|
try {
|
|
NvPairingManager::PairState result = pairingManager.pair(m_Computer->appVersion, m_Pin, m_Computer->serverCert);
|
|
switch (result)
|
|
{
|
|
case NvPairingManager::PairState::PIN_WRONG:
|
|
emit pairingCompleted(m_Computer, "The PIN from the PC didn't match. Please try again.");
|
|
break;
|
|
case NvPairingManager::PairState::FAILED:
|
|
emit pairingCompleted(m_Computer, "Pairing failed. Please try again.");
|
|
break;
|
|
case NvPairingManager::PairState::ALREADY_IN_PROGRESS:
|
|
emit pairingCompleted(m_Computer, "Another pairing attempt is already in progress.");
|
|
break;
|
|
case NvPairingManager::PairState::PAIRED:
|
|
emit pairingCompleted(m_Computer, nullptr);
|
|
break;
|
|
}
|
|
} catch (const GfeHttpResponseException& e) {
|
|
emit pairingCompleted(m_Computer, "GeForce Experience returned error: " + e.toQString());
|
|
} catch (const QtNetworkReplyException& e) {
|
|
emit pairingCompleted(m_Computer, e.toQString());
|
|
}
|
|
}
|
|
|
|
NvComputer* m_Computer;
|
|
QString m_Pin;
|
|
};
|
|
|
|
void ComputerManager::pairHost(NvComputer* computer, QString pin)
|
|
{
|
|
// Punt to a worker thread to avoid stalling the
|
|
// UI while waiting for pairing to complete
|
|
PendingPairingTask* pairing = new PendingPairingTask(this, computer, pin);
|
|
QThreadPool::globalInstance()->start(pairing);
|
|
}
|
|
|
|
class PendingQuitTask : public QObject, public QRunnable
|
|
{
|
|
Q_OBJECT
|
|
|
|
public:
|
|
PendingQuitTask(ComputerManager* computerManager, NvComputer* computer)
|
|
: m_Computer(computer)
|
|
{
|
|
connect(this, &PendingQuitTask::quitAppFailed,
|
|
computerManager, &ComputerManager::quitAppCompleted);
|
|
}
|
|
|
|
signals:
|
|
void quitAppFailed(QString error);
|
|
|
|
private:
|
|
void run()
|
|
{
|
|
NvHTTP http(m_Computer->activeAddress, m_Computer->serverCert);
|
|
|
|
try {
|
|
if (m_Computer->currentGameId != 0) {
|
|
http.quitApp();
|
|
}
|
|
} catch (const GfeHttpResponseException& e) {
|
|
{
|
|
QWriteLocker lock(&m_Computer->lock);
|
|
m_Computer->pendingQuit = false;
|
|
}
|
|
if (e.getStatusCode() == 599) {
|
|
// 599 is a special code we make a custom message for
|
|
emit quitAppFailed(tr("The running game wasn't started by this PC. "
|
|
"You must quit the game on the host PC manually or use the device that originally started the game."));
|
|
}
|
|
else {
|
|
emit quitAppFailed(e.toQString());
|
|
}
|
|
} catch (const QtNetworkReplyException& e) {
|
|
{
|
|
QWriteLocker lock(&m_Computer->lock);
|
|
m_Computer->pendingQuit = false;
|
|
}
|
|
emit quitAppFailed(e.toQString());
|
|
}
|
|
}
|
|
|
|
NvComputer* m_Computer;
|
|
};
|
|
|
|
void ComputerManager::quitRunningApp(NvComputer* computer)
|
|
{
|
|
QWriteLocker lock(&computer->lock);
|
|
computer->pendingQuit = true;
|
|
|
|
PendingQuitTask* quit = new PendingQuitTask(this, computer);
|
|
QThreadPool::globalInstance()->start(quit);
|
|
}
|
|
|
|
void ComputerManager::stopPollingAsync()
|
|
{
|
|
QWriteLocker lock(&m_Lock);
|
|
|
|
Q_ASSERT(m_PollingRef > 0);
|
|
if (--m_PollingRef > 0) {
|
|
return;
|
|
}
|
|
|
|
// Delete machines that haven't been resolved yet
|
|
while (!m_PendingResolution.isEmpty()) {
|
|
MdnsPendingComputer* computer = m_PendingResolution.first();
|
|
computer->deleteLater();
|
|
m_PendingResolution.removeFirst();
|
|
}
|
|
|
|
// Delete the browser to stop discovery
|
|
delete m_MdnsBrowser;
|
|
m_MdnsBrowser = nullptr;
|
|
|
|
// Interrupt all threads, but don't wait for them to terminate
|
|
for (ComputerPollingEntry* entry : m_PollEntries) {
|
|
entry->interrupt();
|
|
}
|
|
}
|
|
|
|
class PendingAddTask : public QObject, public QRunnable
|
|
{
|
|
Q_OBJECT
|
|
|
|
public:
|
|
PendingAddTask(ComputerManager* computerManager, QString address, QHostAddress mdnsIpv6Address, bool mdns)
|
|
: m_ComputerManager(computerManager),
|
|
m_Address(address),
|
|
m_MdnsIpv6Address(mdnsIpv6Address),
|
|
m_Mdns(mdns)
|
|
{
|
|
connect(this, &PendingAddTask::computerAddCompleted,
|
|
computerManager, &ComputerManager::computerAddCompleted);
|
|
connect(this, &PendingAddTask::computerStateChanged,
|
|
computerManager, &ComputerManager::handleComputerStateChanged);
|
|
}
|
|
|
|
signals:
|
|
void computerAddCompleted(QVariant success, QVariant detectedPortBlocking);
|
|
|
|
void computerStateChanged(NvComputer* computer);
|
|
|
|
private:
|
|
QString fetchServerInfo(NvHTTP& http)
|
|
{
|
|
QString serverInfo;
|
|
try {
|
|
// There's a race condition between GameStream servers reporting presence over
|
|
// mDNS and the HTTPS server being ready to respond to our queries. To work
|
|
// around this issue, we will issue the request again after a few seconds if
|
|
// we see a ServiceUnavailableError error.
|
|
try {
|
|
serverInfo = http.getServerInfo(NvHTTP::NVLL_VERBOSE);
|
|
} catch (const QtNetworkReplyException& e) {
|
|
if (e.getError() == QNetworkReply::ServiceUnavailableError) {
|
|
qWarning() << "Retrying request in 5 seconds after ServiceUnavailableError";
|
|
QThread::sleep(5);
|
|
serverInfo = http.getServerInfo(NvHTTP::NVLL_VERBOSE);
|
|
qInfo() << "Retry successful";
|
|
}
|
|
else {
|
|
// Rethrow other errors
|
|
throw e;
|
|
}
|
|
}
|
|
return serverInfo;
|
|
} catch (...) {
|
|
if (!m_Mdns) {
|
|
StreamingPreferences prefs;
|
|
int portTestResult;
|
|
|
|
if (prefs.detectNetworkBlocking) {
|
|
// We failed to connect to the specified PC. Let's test to make sure this network
|
|
// isn't blocking Moonlight, so we can tell the user about it.
|
|
portTestResult = LiTestClientConnectivity("qt.conntest.moonlight-stream.org", 443,
|
|
ML_PORT_FLAG_TCP_47984 | ML_PORT_FLAG_TCP_47989);
|
|
}
|
|
else {
|
|
portTestResult = 0;
|
|
}
|
|
|
|
emit computerAddCompleted(false, portTestResult != 0 && portTestResult != ML_TEST_RESULT_INCONCLUSIVE);
|
|
}
|
|
return QString();
|
|
}
|
|
}
|
|
|
|
void run()
|
|
{
|
|
NvHTTP http(m_Address, QSslCertificate());
|
|
|
|
qInfo() << "Processing new PC at" << m_Address << "from" << (m_Mdns ? "mDNS" : "user") << m_MdnsIpv6Address;
|
|
|
|
// Perform initial serverinfo fetch over HTTP since we don't know which cert to use
|
|
QString serverInfo = fetchServerInfo(http);
|
|
if (serverInfo.isEmpty() && !m_MdnsIpv6Address.isNull()) {
|
|
// Retry using the global IPv6 address if the IPv4 or link-local IPv6 address fails
|
|
http.setAddress(m_MdnsIpv6Address.toString());
|
|
serverInfo = fetchServerInfo(http);
|
|
}
|
|
if (serverInfo.isEmpty()) {
|
|
return;
|
|
}
|
|
|
|
// Create initial newComputer using HTTP serverinfo with no pinned cert
|
|
NvComputer* newComputer = new NvComputer(http.address(), serverInfo, QSslCertificate());
|
|
|
|
// Check if we have a record of this host UUID to pull the pinned cert
|
|
NvComputer* existingComputer;
|
|
{
|
|
QReadLocker lock(&m_ComputerManager->m_Lock);
|
|
existingComputer = m_ComputerManager->m_KnownHosts.value(newComputer->uuid);
|
|
if (existingComputer != nullptr) {
|
|
http.setServerCert(existingComputer->serverCert);
|
|
}
|
|
}
|
|
|
|
// Fetch serverinfo again over HTTPS with the pinned cert
|
|
if (existingComputer != nullptr) {
|
|
serverInfo = fetchServerInfo(http);
|
|
if (serverInfo.isEmpty()) {
|
|
return;
|
|
}
|
|
|
|
// Update the polled computer with the HTTPS information
|
|
NvComputer httpsComputer(http.address(), serverInfo, QSslCertificate());
|
|
newComputer->update(httpsComputer);
|
|
}
|
|
|
|
// Update addresses depending on the context
|
|
if (m_Mdns) {
|
|
// Only update local address if we actually reached the PC via this address.
|
|
// If we reached it via the IPv6 address after the local address failed,
|
|
// don't store the non-working local address.
|
|
if (http.address() == m_Address) {
|
|
newComputer->localAddress = m_Address;
|
|
}
|
|
|
|
// Get the WAN IP address using STUN if we're on mDNS over IPv4
|
|
if (QHostAddress(newComputer->localAddress).protocol() == QAbstractSocket::IPv4Protocol) {
|
|
quint32 addr;
|
|
int err = LiFindExternalAddressIP4("stun.moonlight-stream.org", 3478, &addr);
|
|
if (err == 0) {
|
|
newComputer->remoteAddress = QHostAddress(qFromBigEndian(addr)).toString();
|
|
}
|
|
else {
|
|
qWarning() << "STUN failed to get WAN address:" << err;
|
|
}
|
|
}
|
|
|
|
if (!m_MdnsIpv6Address.isNull()) {
|
|
Q_ASSERT(m_MdnsIpv6Address.protocol() == QAbstractSocket::IPv6Protocol);
|
|
newComputer->ipv6Address = m_MdnsIpv6Address.toString();
|
|
}
|
|
}
|
|
else {
|
|
newComputer->manualAddress = m_Address;
|
|
}
|
|
|
|
QHostAddress hostAddress(m_Address);
|
|
bool addressIsSiteLocalV4 =
|
|
hostAddress.isInSubnet(QHostAddress("10.0.0.0"), 8) ||
|
|
hostAddress.isInSubnet(QHostAddress("172.16.0.0"), 12) ||
|
|
hostAddress.isInSubnet(QHostAddress("192.168.0.0"), 16);
|
|
|
|
{
|
|
// Check if this PC already exists
|
|
QWriteLocker lock(&m_ComputerManager->m_Lock);
|
|
NvComputer* existingComputer = m_ComputerManager->m_KnownHosts.value(newComputer->uuid);
|
|
if (existingComputer != nullptr) {
|
|
// Fold it into the existing PC
|
|
bool changed = existingComputer->update(*newComputer);
|
|
delete newComputer;
|
|
|
|
// Drop the lock before notifying
|
|
lock.unlock();
|
|
|
|
// For non-mDNS clients, let them know it succeeded
|
|
if (!m_Mdns) {
|
|
emit computerAddCompleted(true, false);
|
|
}
|
|
|
|
// Tell our client if something changed
|
|
if (changed) {
|
|
qInfo() << existingComputer->name << "is now at" << existingComputer->activeAddress;
|
|
emit computerStateChanged(existingComputer);
|
|
}
|
|
}
|
|
else {
|
|
// Store this in our active sets
|
|
m_ComputerManager->m_KnownHosts[newComputer->uuid] = newComputer;
|
|
|
|
// Start polling if enabled (write lock required)
|
|
m_ComputerManager->startPollingComputer(newComputer);
|
|
|
|
// Drop the lock before notifying
|
|
lock.unlock();
|
|
|
|
// If this wasn't added via mDNS but it is a RFC 1918 IPv4 address and not a VPN,
|
|
// go ahead and do the STUN request now to populate an external address.
|
|
if (!m_Mdns && addressIsSiteLocalV4 && !newComputer->isReachableOverVpn()) {
|
|
quint32 addr;
|
|
int err = LiFindExternalAddressIP4("stun.moonlight-stream.org", 3478, &addr);
|
|
if (err == 0) {
|
|
lock.relock();
|
|
newComputer->remoteAddress = QHostAddress(qFromBigEndian(addr)).toString();
|
|
lock.unlock();
|
|
}
|
|
else {
|
|
qWarning() << "STUN failed to get WAN address:" << err;
|
|
}
|
|
}
|
|
|
|
// For non-mDNS clients, let them know it succeeded
|
|
if (!m_Mdns) {
|
|
emit computerAddCompleted(true, false);
|
|
}
|
|
|
|
// Tell our client about this new PC
|
|
emit computerStateChanged(newComputer);
|
|
}
|
|
}
|
|
}
|
|
|
|
ComputerManager* m_ComputerManager;
|
|
QString m_Address;
|
|
QHostAddress m_MdnsIpv6Address;
|
|
bool m_Mdns;
|
|
};
|
|
|
|
void ComputerManager::addNewHost(QString address, bool mdns, QHostAddress mdnsIpv6Address)
|
|
{
|
|
// Punt to a worker thread to avoid stalling the
|
|
// UI while waiting for serverinfo query to complete
|
|
PendingAddTask* addTask = new PendingAddTask(this, address, mdnsIpv6Address, mdns);
|
|
QThreadPool::globalInstance()->start(addTask);
|
|
}
|
|
|
|
#include "computermanager.moc"
|