File indexing completed on 2024-04-28 04:57:01

 /**
  * SPDX-FileCopyrightText: 2015 Albert Vaca Cintora <albertvaka@gmail.com>
  *
  * SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
  */
 
 #include "pairinghandler.h"
 
 #include "core_debug.h"
 
 #include <KLocalizedString>
 
 PairingHandler::PairingHandler(Device *parent, PairState initialState)
     : QObject(parent)
     , m_device(parent)
     , m_pairState(initialState)
 {
     m_pairingTimeout.setSingleShot(true);
     m_pairingTimeout.setInterval(pairingTimeoutMsec);
     connect(&m_pairingTimeout, &QTimer::timeout, this, &PairingHandler::pairingTimeout);
 }
 
 void PairingHandler::packetReceived(const NetworkPacket &np)
 {
     m_pairingTimeout.stop();
     bool wantsPair = np.get<bool>(QStringLiteral("pair"));
     if (wantsPair) {
         switch (m_pairState) {
         case PairState::Requested:
             pairingDone();
             break;
         case PairState::RequestedByPeer:
             qCDebug(KDECONNECT_CORE) << "Ignoring second pairing request before the first one timed out";
             break;
         case PairState::Paired:
         case PairState::NotPaired:
             if (m_pairState == PairState::Paired) {
                 qWarning() << "Received pairing request from a device we already trusted.";
                 // It would be nice to auto-accept the pairing request here, but since the pairing accept and pairing request
                 // messages are identical, this could create an infinite loop if both devices are "accepting" each other pairs.
                 // Instead, unpair and handle as if "NotPaired".
                 m_pairState = PairState::NotPaired;
                 Q_EMIT unpaired();
             }
             m_pairState = PairState::RequestedByPeer;
             m_pairingTimeout.start();
             Q_EMIT incomingPairRequest();
             break;
         }
     } else { // wantsPair == false
         qCDebug(KDECONNECT_CORE) << "Unpair request received";
         switch (m_pairState) {
         case PairState::NotPaired:
             qCDebug(KDECONNECT_CORE) << "Ignoring unpair request for already unpaired device";
             break;
         case PairState::Requested: // We started pairing and got rejected
         case PairState::RequestedByPeer: // They stared pairing, then cancelled
             m_pairState = PairState::NotPaired;
             Q_EMIT pairingFailed(i18n("Canceled by other peer"));
             break;
         case PairState::Paired:
             m_pairState = PairState::NotPaired;
             Q_EMIT unpaired();
             break;
         }
     }
 }
 
 bool PairingHandler::requestPairing()
 {
     m_pairingTimeout.stop();
 
     if (m_pairState == PairState::Paired) {
         qWarning() << m_device->name() << ": requestPairing was called on an already paired device.";
         Q_EMIT pairingFailed(i18n("%1: Already paired", m_device->name()));
         return false;
     }
     if (m_pairState == PairState::RequestedByPeer) {
         qWarning() << m_device->name() << ": Pairing already started by the other end, accepting their request.";
         return acceptPairing();
     }
 
     if (!m_device->isReachable()) {
         Q_EMIT pairingFailed(i18n("%1: Device not reachable", m_device->name()));
         return false;
     }
 
     m_pairState = PairState::Requested;
 
     m_pairingTimeout.start();
 
     NetworkPacket np(PACKET_TYPE_PAIR, {{QStringLiteral("pair"), true}});
     const bool success = m_device->sendPacket(np);
     if (!success) {
         m_pairingTimeout.stop();
         qWarning() << m_device->name() << ": Failed to send pair request packet.";
         m_pairState = PairState::NotPaired;
         Q_EMIT pairingFailed(i18n("%1: Device not reachable", m_device->name()));
     }
     return success;
 }
 
 bool PairingHandler::acceptPairing()
 {
     m_pairingTimeout.stop();
     NetworkPacket np(PACKET_TYPE_PAIR, {{QStringLiteral("pair"), true}});
     const bool success = m_device->sendPacket(np);
     if (success) {
         pairingDone();
     } else {
         qWarning() << "Failed to send packet accepting pairing";
         m_pairState = PairState::NotPaired;
         Q_EMIT pairingFailed(i18n("Device not reachable"));
     }
     return success;
 }
 
 void PairingHandler::cancelPairing()
 {
     m_pairingTimeout.stop();
     m_pairState = PairState::NotPaired;
     NetworkPacket np(PACKET_TYPE_PAIR, {{QStringLiteral("pair"), false}});
     m_device->sendPacket(np);
     Q_EMIT pairingFailed(i18n("Cancelled by user"));
 }
 
 void PairingHandler::unpair()
 {
     m_pairState = PairState::NotPaired;
     NetworkPacket np(PACKET_TYPE_PAIR, {{QStringLiteral("pair"), false}});
     m_device->sendPacket(np);
     Q_EMIT unpaired();
 }
 
 void PairingHandler::pairingTimeout()
 {
     NetworkPacket np(PACKET_TYPE_PAIR, {{QStringLiteral("pair"), false}});
     m_device->sendPacket(np);
     m_pairState = PairState::NotPaired;
     Q_EMIT pairingFailed(i18n("Timed out"));
 }
 
 void PairingHandler::pairingDone()
 {
     qCDebug(KDECONNECT_CORE) << "Pairing done";
     m_pairState = PairState::Paired;
     Q_EMIT pairingSuccessful();
 }
 
 #include "moc_pairinghandler.cpp"