portchecker.cpp

Go to the documentation of this file.

 
// Copyright (c) 2017 MythTV Developers <mythtv-dev@mythtv.org>
//
// This is part of MythTV (https://www.mythtv.org)
//
// This program 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 2 of the License, or
// (at your option) any later version.
//
// This program 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 this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
 
#include <QtGlobal>
#if QT_VERSION >= QT_VERSION_CHECK(6,0,0)
#include <QtSystemDetection>
#endif
#include <QCoreApplication>
#include <QHostAddress>
#include <QTcpSocket>
#include <QEventLoop>
#include <QNetworkInterface>
#include <QNetworkAddressEntry>
 
#include <thread>
 
#include "mythcorecontext.h"
#include "mythlogging.h"
#include "mythtimer.h"
#include "portchecker.h"
 
#define LOC QString("PortChecker::%1(): ").arg(__func__)
 
bool PortChecker::checkPort(QString &host, int port, std::chrono::milliseconds timeLimit, bool linkLocalOnly)
{
    LOG(VB_GENERAL, LOG_DEBUG, LOC + QString("host %1 port %2 timeLimit %3 linkLocalOnly %4")
        .arg(host).arg(port).arg(timeLimit.count()).arg(linkLocalOnly));
    m_cancelCheck = false;
    QHostAddress addr;
    bool isIPAddress = addr.setAddress(host);
    bool islinkLocal = false;
// Windows does not need the scope on the ip address so we can skip
// some processing
#ifndef Q_OS_WINDOWS
    if (isIPAddress
      && addr.protocol() == QAbstractSocket::IPv6Protocol
      && addr.isInSubnet(QHostAddress::parseSubnet("fe80::/10")))
        islinkLocal = true;
#endif
    if (linkLocalOnly)
    {
        if (islinkLocal)
        {
            // If we already know the scope, set it here and return
            if (gCoreContext->GetScopeForAddress(addr))
            {
                host = addr.toString();
                return true;
            }
        }
        else
        {
            return false;
        }
    }
    QList<QNetworkInterface> cards = QNetworkInterface::allInterfaces();
#ifndef Q_OS_WINDOWS
    QListIterator<QNetworkInterface> iCard = cards;
#endif
    MythTimer timer(MythTimer::kStartRunning);
    QTcpSocket socket(this);
    QAbstractSocket::SocketState state = QAbstractSocket::UnconnectedState;
    int retryCount = 0;
    QString scope;
    bool testedAll = false;
    while (state != QAbstractSocket::ConnectedState
        && (timer.elapsed() < timeLimit))
    {
        if (state == QAbstractSocket::UnconnectedState)
        {
// Windows does not need the scope on the ip address so we can skip
// some processing
#ifndef Q_OS_WINDOWS
            int iCardsEnd = 0;
            if (islinkLocal && !gCoreContext->GetScopeForAddress(addr))
            {
                addr.setScopeId(QString());
                while (addr.scopeId().isEmpty() && iCardsEnd<2)
                {
                    // search for the next available IPV6 interface.
                    if (iCard.hasNext())
                    {
                        QNetworkInterface card = iCard.next();
                        LOG(VB_GENERAL, LOG_DEBUG, QString("Trying interface %1").arg(card.name()));
                        unsigned int flags = card.flags();
                        if ((flags & QNetworkInterface::IsLoopBack)
                         || !(flags & QNetworkInterface::IsRunning))
                            continue;
                        // check that IPv6 is enabled on that interface
                        QList<QNetworkAddressEntry> addresses = card.addressEntries();
                        bool foundv6 = false;
                        for (const auto& ae : std::as_const(addresses))
                        {
                            if (ae.ip().protocol() == QAbstractSocket::IPv6Protocol)
                            {
                                foundv6 = true;
                                break;
                            }
                        }
                        if (foundv6)
                        {
                            scope = card.name();
                            addr.setScopeId(scope);
                            break;
                        }
                    }
                    else
                    {
                        // Get a new list in case a new interface
                        // has been added.
                        cards = QNetworkInterface::allInterfaces();
                        iCard = cards;
                        iCard.toFront();
                        testedAll=true;
                        iCardsEnd++;
                    }
                }
            }
            if (iCardsEnd > 1)
            {
                LOG(VB_GENERAL, LOG_ERR, LOC + QString("There is no IPV6 compatible interface for %1")
                  .arg(host));
                break;
            }
#endif
            QString dest;
            if (isIPAddress)
                dest=addr.toString();
            else
                dest=host;
            socket.connectToHost(dest, port);
            retryCount=0;
        }
        else
        {
            retryCount++;
        }
        // This retry count of 6 means 3 seconds of waiting for
        // connection before aborting and starting a new connection attempt.
        if (retryCount > 6)
            socket.abort();
        processEvents();
        // Check if user got impatient and canceled
        if (m_cancelCheck)
            break;
        std::this_thread::sleep_for(500ms);
        state = socket.state();
        LOG(VB_GENERAL, LOG_DEBUG, LOC + QString("socket state %1")
            .arg(state));
        if (linkLocalOnly
          && state == QAbstractSocket::UnconnectedState
          && testedAll)
            break;
    }
    if (state == QAbstractSocket::ConnectedState
      && islinkLocal && !scope.isEmpty())
    {
       gCoreContext->SetScopeForAddress(addr);
       host = addr.toString();
    }
    socket.abort();
    processEvents();
    return (state == QAbstractSocket::ConnectedState);
}
 
// static method
bool PortChecker::resolveLinkLocal(QString &host, int port, std::chrono::milliseconds timeLimit)
{
    PortChecker checker;
    return checker.checkPort(host,port,timeLimit,true);
}
 
void PortChecker::processEvents(void)
{
    qApp->processEvents(QEventLoop::AllEvents, 250);
    qApp->processEvents(QEventLoop::AllEvents, 250);
}
 
void PortChecker::cancelPortCheck(void)
{
    m_cancelCheck = true;
}
 
 
/* vim: set expandtab tabstop=4 shiftwidth=4: */