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 <QCoreApplication>
#include <QHostAddress>
#include <QTcpSocket>
#include <QThread>
#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 _WIN32
    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 _WIN32
    QListIterator<QNetworkInterface> iCard = cards;
#endif
    MythTimer timer(MythTimer::kStartRunning);
    QTcpSocket socket(this);
    QAbstractSocket::SocketState state = QAbstractSocket::UnconnectedState;
    QString scope;
    bool testedAll = false;
    while (state != QAbstractSocket::ConnectedState
        && (timer.elapsed() < timeLimit))
    {
// Windows does not need the scope on the ip address so we can skip
// some processing
#ifndef _WIN32
        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);
 
        MythTimer attempt_time {MythTimer::kStartRunning};
        static constexpr std::chrono::milliseconds k_poll_interval {1ms};
        while (state != QAbstractSocket::ConnectedState
                && (timer.elapsed() < timeLimit)
                && attempt_time.elapsed() < 3s
               )
        {
            if (QCoreApplication::instance() != nullptr &&
                QThread::currentThread() == QCoreApplication::instance()->thread()
                )
            {
                QCoreApplication::processEvents(QEventLoop::AllEvents, k_poll_interval.count());
                std::this_thread::sleep_for(1ns); // force thread to be de-scheduled
            }
            else
            {
                std::this_thread::sleep_for(k_poll_interval);
            }
            state = socket.state();
            LOG(VB_GENERAL, LOG_DEBUG, LOC + QString("host %1 port %2 socket state %3, attempt time: %4")
                .arg(host, QString::number(port), QString::number(state),
                    QString::number(attempt_time.elapsed().count())
                    )
                );
            // Check if user got impatient and canceled
            if (m_cancelCheck)
                break;
            if (linkLocalOnly && testedAll
                && state == QAbstractSocket::UnconnectedState
                && attempt_time.elapsed() > 500ms
                )
                break;
        }
        socket.abort();
        // Check if user got impatient and canceled
        if (m_cancelCheck)
            break;
        if (linkLocalOnly
          && state == QAbstractSocket::UnconnectedState
          && testedAll)
            break;
    }
    if (state == QAbstractSocket::ConnectedState
      && islinkLocal && !scope.isEmpty())
    {
       gCoreContext->SetScopeForAddress(addr);
       host = addr.toString();
    }
    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::cancelPortCheck(void)
{
    m_cancelCheck = true;
}
 
 
/* vim: set expandtab tabstop=4 shiftwidth=4: */