diff --git a/core/backends/lan/compositeuploadjob.cpp b/core/backends/lan/compositeuploadjob.cpp
index 8b90fecd..e5f88ac5 100644
--- a/core/backends/lan/compositeuploadjob.cpp
+++ b/core/backends/lan/compositeuploadjob.cpp
@@ -1,307 +1,311 @@
 /**
  * Copyright 2018 Erik Duisters <e.duisters1@gmail.com>
  *
  * 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) version 3 or any later version
  * accepted by the membership of KDE e.V. (or its successor approved
  * by the membership of KDE e.V.), which shall act as a proxy
  * defined in Section 14 of version 3 of the license.
  *
  * 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, see <https://www.gnu.org/licenses/>.
  */
 
 #include "compositeuploadjob.h"
 #include <core_debug.h>
 #include <KLocalizedString>
 #include <KJobTrackerInterface>
 #include "lanlinkprovider.h"
 #include <daemon.h>
 #include "plugins/share/shareplugin.h"
 #include "qtcompat_p.h"
 
 #ifdef HAVE_KIO
 #include <kio/global.h>
 #endif
 
 CompositeUploadJob::CompositeUploadJob(const QString& deviceId, bool displayNotification)
     : KCompositeJob()
     , m_server(new Server(this))
     , m_socket(nullptr)
     , m_port(0)
     , m_deviceId(deviceId)
     , m_running(false)
     , m_currentJobNum(1)
     , m_totalJobs(0)
     , m_currentJobSendPayloadSize(0)
     , m_totalSendPayloadSize(0)
     , m_totalPayloadSize(0)
     , m_currentJob(nullptr)
     , m_prevElapsedTime(0)
     , m_updatePacketPending(false)
 {
     setCapabilities(Killable);
 
     if (displayNotification) {
         Daemon::instance()->jobTracker()->registerJob(this);
     }
 }
 
 bool CompositeUploadJob::isRunning()
 {
     return m_running;
 }
 
 void CompositeUploadJob::start() {
     if (m_running) {
         qCWarning(KDECONNECT_CORE) << "CompositeUploadJob::start() - already running";
         return;
     }
 
     if (!hasSubjobs()) {
         qCWarning(KDECONNECT_CORE) << "CompositeUploadJob::start() - there are no subjobs to start";
         emitResult();
         return;
     }
 
     if (!startListening()) {
         return;
     }
 
     connect(m_server, &QTcpServer::newConnection, this, &CompositeUploadJob::newConnection);
 
     m_running = true;
 
     //Give SharePlugin some time to add subjobs
     QMetaObject::invokeMethod(this, "startNextSubJob", Qt::QueuedConnection);
 }
 
 bool CompositeUploadJob::startListening()
 {
     m_port = MIN_PORT;
     while (!m_server->listen(QHostAddress::Any, m_port)) {
         m_port++;
         if (m_port > MAX_PORT) { //No ports available?
             qCWarning(KDECONNECT_CORE) << "CompositeUploadJob::startListening() - Error opening a port in range" << MIN_PORT << "-" << MAX_PORT;
             m_port = 0;
             setError(NoPortAvailable);
             setErrorText(i18n("Couldn't find an available port"));
             emitResult();
             return false;
         }
     }
 
     qCDebug(KDECONNECT_CORE) << "CompositeUploadJob::startListening() - listening on port: " << m_port;
     return true;
 }
 
 void CompositeUploadJob::startNextSubJob()
 {
     m_currentJob = qobject_cast<UploadJob*>(subjobs().at(0));
     m_currentJobSendPayloadSize = 0;
     emitDescription(m_currentJob->getNetworkPacket().get<QString>(QStringLiteral("filename")));
 
 #ifdef SAILFISHOS
     connect(m_currentJob, SIGNAL(processedAmount(KJob*,KJob::Unit,qulonglong)), this, SLOT(slotProcessedAmount(KJob*,KJob::Unit,qulonglong)));
 #else
     connect(m_currentJob, QOverload<KJob*,KJob::Unit,qulonglong>::of(&UploadJob::processedAmount), this, &CompositeUploadJob::slotProcessedAmount);
 #endif
     //Already done by KCompositeJob
     //connect(m_currentJob, &KJob::result, this, &CompositeUploadJob::slotResult);
 
     //TODO: Create a copy of the networkpacket that can be re-injected if sending via lan fails?
     NetworkPacket np = m_currentJob->getNetworkPacket();
 #if QT_VERSION < QT_VERSION_CHECK(5,8,0)
     np.setPayload({}, np.payloadSize());
 #else
     np.setPayload(nullptr, np.payloadSize());
 #endif
     np.setPayloadTransferInfo({{QStringLiteral("port"), m_port}});
     np.set<int>(QStringLiteral("numberOfFiles"), m_totalJobs);
     np.set<quint64>(QStringLiteral("totalPayloadSize"), m_totalPayloadSize);
 
     if (Daemon::instance()->getDevice(m_deviceId)->sendPacket(np)) {
         m_server->resumeAccepting();
     } else {
         setError(SendingNetworkPacketFailed);
         setErrorText(i18n("Failed to send packet to %1", Daemon::instance()->getDevice(m_deviceId)->name()));
 
         emitResult();
     }
 }
 
 void CompositeUploadJob::newConnection()
 {
     m_server->pauseAccepting();
 
     m_socket = m_server->nextPendingConnection();
 
     if (!m_socket) {
         qCDebug(KDECONNECT_CORE) << "CompositeUploadJob::newConnection() - m_server->nextPendingConnection() returned a nullptr";
         return;
     }
 
     m_currentJob->setSocket(m_socket);
 
     connect(m_socket, &QSslSocket::disconnected, this, &CompositeUploadJob::socketDisconnected);
+#if QT_VERSION < QT_VERSION_CHECK(5,15,0)
     connect(m_socket, QOverload<QAbstractSocket::SocketError>::of(&QAbstractSocket::error), this, &CompositeUploadJob::socketError);
+#else
+    connect(m_socket, &QAbstractSocket::errorOccurred, this, &CompositeUploadJob::socketError);
+#endif
     connect(m_socket, QOverload<const QList<QSslError> &>::of(&QSslSocket::sslErrors), this, &CompositeUploadJob::sslError);
     connect(m_socket, &QSslSocket::encrypted, this, &CompositeUploadJob::encrypted);
 
     LanLinkProvider::configureSslSocket(m_socket, m_deviceId, true);
 
     m_socket->startServerEncryption();
 }
 
 void CompositeUploadJob::socketDisconnected()
 {
     m_socket->close();
 }
 
 void CompositeUploadJob::socketError(QAbstractSocket::SocketError error)
 {
     Q_UNUSED(error);
 
     //Do not close the socket because when android closes the socket (share is cancelled) closing the socket leads to a cyclic socketError and eventually a segv
     setError(SocketError);
     emitResult();
 
     m_running = false;
 }
 
 void CompositeUploadJob::sslError(const QList<QSslError>& errors)
 {
     Q_UNUSED(errors);
 
     m_socket->close();
     setError(SslError);
     emitResult();
 
     m_running = false;
 }
 
 void CompositeUploadJob::encrypted()
 {
     if (!m_timer.isValid()) {
         m_timer.start();
     }
 
     m_currentJob->start();
 }
 
 bool CompositeUploadJob::addSubjob(KJob* job)
 {
     if (UploadJob *uploadJob = qobject_cast<UploadJob*>(job)) {
         NetworkPacket np = uploadJob->getNetworkPacket();
 
         m_totalJobs++;
 
         if (np.payloadSize() >= 0 ) {
             m_totalPayloadSize += np.payloadSize();
             setTotalAmount(Bytes, m_totalPayloadSize);
         }
 
         QString filename;
         QString filenameArg = QStringLiteral("filename");
 
         if (m_currentJob) {
             filename = m_currentJob->getNetworkPacket().get<QString>(filenameArg);
         } else {
             filename = np.get<QString>(filenameArg);
         }
 
         emitDescription(filename);
 
         if (m_running && m_currentJob && !m_updatePacketPending) {
             m_updatePacketPending = true;
             QMetaObject::invokeMethod(this, "sendUpdatePacket", Qt::QueuedConnection);
         }
 
         return KCompositeJob::addSubjob(job);
     } else {
         qCDebug(KDECONNECT_CORE) << "CompositeUploadJob::addSubjob() - you can only add UploadJob's, ignoring";
         return false;
     }
 }
 
 void CompositeUploadJob::sendUpdatePacket() {
     NetworkPacket np(PACKET_TYPE_SHARE_REQUEST_UPDATE);
     np.set<int>(QStringLiteral("numberOfFiles"), m_totalJobs);
     np.set<quint64>(QStringLiteral("totalPayloadSize"), m_totalPayloadSize);
 
     Daemon::instance()->getDevice(m_deviceId)->sendPacket(np);
 
     m_updatePacketPending = false;
 }
 
 bool CompositeUploadJob::doKill()
 {
     if (m_running) {
         m_running = false;
 
         return m_currentJob->stop();
     }
 
     return true;
 }
 
 void CompositeUploadJob::slotProcessedAmount(KJob *job, KJob::Unit unit, qulonglong amount) {
     Q_UNUSED(job);
 
     m_currentJobSendPayloadSize = amount;
     quint64 uploaded = m_totalSendPayloadSize + m_currentJobSendPayloadSize;
 
     if (uploaded == m_totalPayloadSize || m_prevElapsedTime == 0 || m_timer.elapsed() - m_prevElapsedTime >= 100) {
         m_prevElapsedTime = m_timer.elapsed();
         setProcessedAmount(unit, uploaded);
 
         const auto elapsed = m_timer.elapsed();
         if (elapsed > 0) {
             emitSpeed((1000 * uploaded) / elapsed);
         }
     }
 }
 
 void CompositeUploadJob::slotResult(KJob *job) {
     //Copies job error and errorText and emits result if job is in error otherwise removes job from subjob list
     KCompositeJob::slotResult(job);
 
     if (error() || !m_running) {
         return;
     }
 
     m_totalSendPayloadSize += m_currentJobSendPayloadSize;
 
     if (hasSubjobs()) {
         m_currentJobNum++;
         startNextSubJob();
     } else {
         QPair<QString, QString> field2;
         field2.first = QStringLiteral("Files");
         field2.second = i18np("Sent 1 file", "Sent %1 files", m_totalJobs);
         Q_EMIT description(this, i18n("Sending to %1", Daemon::instance()->getDevice(this->m_deviceId)->name()),
                            { QString(), QString() }, field2
         );
         emitResult();
     }
 }
 
 void CompositeUploadJob::emitDescription(const QString& currentFileName) {
     QPair<QString, QString> field2;
 
     if (m_totalJobs > 1) {
         field2.first = i18n("Progress");
         field2.second = i18n("Sending file %1 of %2", m_currentJobNum, m_totalJobs);
     }
 
     Q_EMIT description(this, i18n("Sending to %1", Daemon::instance()->getDevice(this->m_deviceId)->name()),
                        { i18n("File"), currentFileName }, field2
     );
 }
diff --git a/core/backends/lan/lanlinkprovider.cpp b/core/backends/lan/lanlinkprovider.cpp
index 0c200a4f..d9a7d8fa 100644
--- a/core/backends/lan/lanlinkprovider.cpp
+++ b/core/backends/lan/lanlinkprovider.cpp
@@ -1,571 +1,579 @@
 /**
  * Copyright 2013 Albert Vaca <albertvaka@gmail.com>
  *
  * 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) version 3 or any later version
  * accepted by the membership of KDE e.V. (or its successor approved
  * by the membership of KDE e.V.), which shall act as a proxy
  * defined in Section 14 of version 3 of the license.
  *
  * 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, see <https://www.gnu.org/licenses/>.
  */
 
 #include "lanlinkprovider.h"
 #include "core_debug.h"
 
 #ifndef Q_OS_WIN
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <netinet/tcp.h>
 #include <netdb.h>
 #endif
 
 #include <QHostInfo>
 #include <QTcpServer>
 #include <QMetaEnum>
 #include <QNetworkProxy>
 #include <QUdpSocket>
 #include <QNetworkSession>
 #include <QNetworkConfigurationManager>
 #include <QSslCipher>
 #include <QSslConfiguration>
 
 #include "daemon.h"
 #include "landevicelink.h"
 #include "lanpairinghandler.h"
 #include "kdeconnectconfig.h"
 #include "qtcompat_p.h"
 
 #define MIN_VERSION_WITH_SSL_SUPPORT 6
 
 LanLinkProvider::LanLinkProvider(
         bool testMode,
         quint16 udpBroadcastPort,
         quint16 udpListenPort
     )
     : m_server(new Server(this))
     , m_udpSocket(this)
     , m_tcpPort(0)
     , m_udpBroadcastPort(udpBroadcastPort)
     , m_udpListenPort(udpListenPort)
     , m_testMode(testMode)
     , m_combineBroadcastsTimer(this)
 {
 
     m_combineBroadcastsTimer.setInterval(0); // increase this if waiting a single event-loop iteration is not enough
     m_combineBroadcastsTimer.setSingleShot(true);
     connect(&m_combineBroadcastsTimer, &QTimer::timeout, this, &LanLinkProvider::broadcastToNetwork);
 
     connect(&m_udpSocket, &QIODevice::readyRead, this, &LanLinkProvider::udpBroadcastReceived);
 
     m_server->setProxy(QNetworkProxy::NoProxy);
     connect(m_server, &QTcpServer::newConnection, this, &LanLinkProvider::newConnection);
 
     m_udpSocket.setProxy(QNetworkProxy::NoProxy);
 
     //Detect when a network interface changes status, so we announce ourselves in the new network
     QNetworkConfigurationManager* networkManager = new QNetworkConfigurationManager(this);
     connect(networkManager, &QNetworkConfigurationManager::configurationChanged, this, &LanLinkProvider::onNetworkConfigurationChanged);
 
 }
 
 void LanLinkProvider::onNetworkConfigurationChanged(const QNetworkConfiguration& config)
 {
     if (m_lastConfig != config && config.state() == QNetworkConfiguration::Active) {
         m_lastConfig = config;
         onNetworkChange();
     }
 }
 
 LanLinkProvider::~LanLinkProvider()
 {
 }
 
 void LanLinkProvider::onStart()
 {
     const QHostAddress bindAddress = m_testMode? QHostAddress::LocalHost : QHostAddress::Any;
 
     bool success = m_udpSocket.bind(bindAddress, m_udpListenPort, QUdpSocket::ShareAddress);
     if (!success) {
         QAbstractSocket::SocketError sockErr = m_udpSocket.error();
         // Refer to https://doc.qt.io/qt-5/qabstractsocket.html#SocketError-enum to decode socket error number
         QString errorMessage = QString::fromLatin1(QMetaEnum::fromType<QAbstractSocket::SocketError>().valueToKey(sockErr));
         qCritical(KDECONNECT_CORE)
             << QLatin1String("Failed to bind UDP socket on port")
             << m_udpListenPort
             << QLatin1String("with error")
             << errorMessage;
     }
     Q_ASSERT(success);
 
     m_tcpPort = MIN_TCP_PORT;
     while (!m_server->listen(bindAddress, m_tcpPort)) {
         m_tcpPort++;
         if (m_tcpPort > MAX_TCP_PORT) { //No ports available?
             qCritical(KDECONNECT_CORE) << "Error opening a port in range" << MIN_TCP_PORT << "-" << MAX_TCP_PORT;
             m_tcpPort = 0;
             return;
         }
     }
 
     onNetworkChange();
     qCDebug(KDECONNECT_CORE) << "LanLinkProvider started";
 }
 
 void LanLinkProvider::onStop()
 {
     m_udpSocket.close();
     m_server->close();
     qCDebug(KDECONNECT_CORE) << "LanLinkProvider stopped";
 }
 
 void LanLinkProvider::onNetworkChange()
 {
     if (m_combineBroadcastsTimer.isActive()) {
         qCDebug(KDECONNECT_CORE()) << "Preventing duplicate broadcasts";
         return;
     }
     m_combineBroadcastsTimer.start();
 }
 
 //I'm in a new network, let's be polite and introduce myself
 void LanLinkProvider::broadcastToNetwork()
 {
 
     if (!m_server->isListening()) {
         //Not started
         return;
     }
 
     Q_ASSERT(m_tcpPort != 0);
 
     qCDebug(KDECONNECT_CORE()) << "Broadcasting identity packet";
 
     QHostAddress destAddress = m_testMode? QHostAddress::LocalHost : QHostAddress(QStringLiteral("255.255.255.255"));
 
     NetworkPacket np(QLatin1String(""));
     NetworkPacket::createIdentityPacket(&np);
     np.set(QStringLiteral("tcpPort"), m_tcpPort);
 
 #ifdef Q_OS_WIN
     //On Windows we need to broadcast from every local IP address to reach all networks
     QUdpSocket sendSocket;
     sendSocket.setProxy(QNetworkProxy::NoProxy);
     for (const QNetworkInterface& iface : QNetworkInterface::allInterfaces()) {
         if ( (iface.flags() & QNetworkInterface::IsUp)
           && (iface.flags() & QNetworkInterface::IsRunning)
           && (iface.flags() & QNetworkInterface::CanBroadcast)) {
             for (const QNetworkAddressEntry& ifaceAddress : iface.addressEntries()) {
                 QHostAddress sourceAddress = ifaceAddress.ip();
                 if (sourceAddress.protocol() == QAbstractSocket::IPv4Protocol && sourceAddress != QHostAddress::LocalHost) {
                     qCDebug(KDECONNECT_CORE()) << "Broadcasting as" << sourceAddress;
                     sendSocket.writeDatagram(np.serialize(), destAddress, m_udpBroadcastPort);
                     sendSocket.close();
                 }
             }
         }
     }
 #else
     m_udpSocket.writeDatagram(np.serialize(), destAddress, m_udpBroadcastPort);
 #endif
 
 }
 
 //I'm the existing device, a new device is kindly introducing itself.
 //I will create a TcpSocket and try to connect. This can result in either tcpSocketConnected() or connectError().
 void LanLinkProvider::udpBroadcastReceived()
 {
     while (m_udpSocket.hasPendingDatagrams()) {
 
         QByteArray datagram;
         datagram.resize(m_udpSocket.pendingDatagramSize());
         QHostAddress sender;
 
         m_udpSocket.readDatagram(datagram.data(), datagram.size(), &sender);
 
         if (sender.isLoopback() && !m_testMode)
             continue;
 
         NetworkPacket* receivedPacket = new NetworkPacket(QLatin1String(""));
         bool success = NetworkPacket::unserialize(datagram, receivedPacket);
 
         //qCDebug(KDECONNECT_CORE) << "udp connection from " << receivedPacket->;
 
         //qCDebug(KDECONNECT_CORE) << "Datagram " << datagram.data() ;
 
         if (!success) {
             qCDebug(KDECONNECT_CORE) << "Could not unserialize UDP packet";
             delete receivedPacket;
             continue;
         }
 
         if (receivedPacket->type() != PACKET_TYPE_IDENTITY) {
             qCDebug(KDECONNECT_CORE) << "Received a UDP packet of wrong type" << receivedPacket->type();
             delete receivedPacket;
             continue;
         }
 
         if (receivedPacket->get<QString>(QStringLiteral("deviceId")) == KdeConnectConfig::instance().deviceId()) {
             //qCDebug(KDECONNECT_CORE) << "Ignoring my own broadcast";
             delete receivedPacket;
             continue;
         }
 
         int tcpPort = receivedPacket->get<int>(QStringLiteral("tcpPort"));
 
         //qCDebug(KDECONNECT_CORE) << "Received Udp identity packet from" << sender << " asking for a tcp connection on port " << tcpPort;
 
         QSslSocket* socket = new QSslSocket(this);
         socket->setProxy(QNetworkProxy::NoProxy);
         m_receivedIdentityPackets[socket].np = receivedPacket;
         m_receivedIdentityPackets[socket].sender = sender;
         connect(socket, &QAbstractSocket::connected, this, &LanLinkProvider::tcpSocketConnected);
+#if QT_VERSION < QT_VERSION_CHECK(5,15,0)
         connect(socket, QOverload<QAbstractSocket::SocketError>::of(&QAbstractSocket::error), this, &LanLinkProvider::connectError);
+#else
+        connect(socket, &QAbstractSocket::errorOccurred, this, &LanLinkProvider::connectError);
+#endif
         socket->connectToHost(sender, tcpPort);
     }
 }
 
 void LanLinkProvider::connectError(QAbstractSocket::SocketError socketError)
 {
     QSslSocket* socket = qobject_cast<QSslSocket*>(sender());
     if (!socket) return;
 
     qCDebug(KDECONNECT_CORE) << "Socket error" << socketError;
     qCDebug(KDECONNECT_CORE) << "Fallback (1), try reverse connection (send udp packet)" << socket->errorString();
     NetworkPacket np(QLatin1String(""));
     NetworkPacket::createIdentityPacket(&np);
     np.set(QStringLiteral("tcpPort"), m_tcpPort);
     m_udpSocket.writeDatagram(np.serialize(), m_receivedIdentityPackets[socket].sender, m_udpBroadcastPort);
 
     //The socket we created didn't work, and we didn't manage
     //to create a LanDeviceLink from it, deleting everything.
     delete m_receivedIdentityPackets.take(socket).np;
     delete socket;
 }
 
 //We received a UDP packet and answered by connecting to them by TCP. This gets called on a successful connection.
 void LanLinkProvider::tcpSocketConnected()
 {
     QSslSocket* socket = qobject_cast<QSslSocket*>(sender());
 
     if (!socket) return;
     // TODO Delete me?
+#if QT_VERSION < QT_VERSION_CHECK(5,15,0)
     disconnect(socket, QOverload<QAbstractSocket::SocketError>::of(&QAbstractSocket::error), this, &LanLinkProvider::connectError);
+#else
+    disconnect(socket, &QAbstractSocket::errorOccurred, this, &LanLinkProvider::connectError);
+#endif
 
     configureSocket(socket);
 
     // If socket disconnects due to any reason after connection, link on ssl failure
     connect(socket, &QAbstractSocket::disconnected, socket, &QObject::deleteLater);
 
     NetworkPacket* receivedPacket = m_receivedIdentityPackets[socket].np;
     const QString& deviceId = receivedPacket->get<QString>(QStringLiteral("deviceId"));
     //qCDebug(KDECONNECT_CORE) << "tcpSocketConnected" << socket->isWritable();
 
     // If network is on ssl, do not believe when they are connected, believe when handshake is completed
     NetworkPacket np2(QLatin1String(""));
     NetworkPacket::createIdentityPacket(&np2);
     socket->write(np2.serialize());
     bool success = socket->waitForBytesWritten();
 
     if (success) {
 
         qCDebug(KDECONNECT_CORE) << "TCP connection done (i'm the existing device)";
 
         // if ssl supported
         if (receivedPacket->get<int>(QStringLiteral("protocolVersion")) >= MIN_VERSION_WITH_SSL_SUPPORT) {
 
             bool isDeviceTrusted = KdeConnectConfig::instance().trustedDevices().contains(deviceId);
             configureSslSocket(socket, deviceId, isDeviceTrusted);
 
             qCDebug(KDECONNECT_CORE) << "Starting server ssl (I'm the client TCP socket)";
 
             connect(socket, &QSslSocket::encrypted, this, &LanLinkProvider::encrypted);
 
             if (isDeviceTrusted) {
                 connect(socket, QOverload<const QList<QSslError> &>::of(&QSslSocket::sslErrors), this, &LanLinkProvider::sslErrors);
             }
 
             socket->startServerEncryption();
 
             return; // Return statement prevents from deleting received packet, needed in slot "encrypted"
         } else {
             qWarning() << receivedPacket->get<QString>(QStringLiteral("deviceName")) << "uses an old protocol version, this won't work";
             //addLink(deviceId, socket, receivedPacket, LanDeviceLink::Remotely);
         }
 
     } else {
         //I think this will never happen, but if it happens the deviceLink
         //(or the socket that is now inside it) might not be valid. Delete them.
         qCDebug(KDECONNECT_CORE) << "Fallback (2), try reverse connection (send udp packet)";
         m_udpSocket.writeDatagram(np2.serialize(), m_receivedIdentityPackets[socket].sender, m_udpBroadcastPort);
     }
 
     delete m_receivedIdentityPackets.take(socket).np;
     //We don't delete the socket because now it's owned by the LanDeviceLink
 }
 
 void LanLinkProvider::encrypted()
 {
     qCDebug(KDECONNECT_CORE) << "Socket successfully established an SSL connection";
 
     QSslSocket* socket = qobject_cast<QSslSocket*>(sender());
     if (!socket) return;
     // TODO delete me?
     disconnect(socket, QOverload<const QList<QSslError> &>::of(&QSslSocket::sslErrors), this, &LanLinkProvider::sslErrors);
 
     Q_ASSERT(socket->mode() != QSslSocket::UnencryptedMode);
     LanDeviceLink::ConnectionStarted connectionOrigin = (socket->mode() == QSslSocket::SslClientMode)? LanDeviceLink::Locally : LanDeviceLink::Remotely;
 
     NetworkPacket* receivedPacket = m_receivedIdentityPackets[socket].np;
     const QString& deviceId = receivedPacket->get<QString>(QStringLiteral("deviceId"));
 
     addLink(deviceId, socket, receivedPacket, connectionOrigin);
 
     // Copied from tcpSocketConnected slot, now delete received packet
     delete m_receivedIdentityPackets.take(socket).np;
 }
 
 void LanLinkProvider::sslErrors(const QList<QSslError>& errors)
 {
     QSslSocket* socket = qobject_cast<QSslSocket*>(sender());
     if (!socket) return;
 
     qCDebug(KDECONNECT_CORE) << "Failing due to " << errors;
     Device* device = Daemon::instance()->getDevice(socket->peerVerifyName());
     if (device) {
         device->unpair();
     }
 
     delete m_receivedIdentityPackets.take(socket).np;
     // Socket disconnects itself on ssl error and will be deleted by deleteLater slot, no need to delete manually
 }
 
 //I'm the new device and this is the answer to my UDP identity packet (no data received yet). They are connecting to us through TCP, and they should send an identity.
 void LanLinkProvider::newConnection()
 {
     qCDebug(KDECONNECT_CORE) << "LanLinkProvider newConnection";
 
     while (m_server->hasPendingConnections()) {
         QSslSocket* socket = m_server->nextPendingConnection();
         configureSocket(socket);
         //This socket is still managed by us (and child of the QTcpServer), if
         //it disconnects before we manage to pass it to a LanDeviceLink, it's
         //our responsibility to delete it. We do so with this connection.
         connect(socket, &QAbstractSocket::disconnected,
                 socket, &QObject::deleteLater);
         connect(socket, &QIODevice::readyRead,
                 this, &LanLinkProvider::dataReceived);
 
     }
 }
 
 //I'm the new device and this is the answer to my UDP identity packet (data received)
 void LanLinkProvider::dataReceived()
 {
     QSslSocket* socket = qobject_cast<QSslSocket*>(sender());
 #if QT_VERSION < QT_VERSION_CHECK(5,7,0)
     if (!socket->canReadLine())
         return;
 #else
     socket->startTransaction();
 #endif
 
     const QByteArray data = socket->readLine();
 
     qCDebug(KDECONNECT_CORE) << "LanLinkProvider received reply:" << data;
 
     NetworkPacket* np = new NetworkPacket(QLatin1String(""));
     bool success = NetworkPacket::unserialize(data, np);
 
 #if QT_VERSION < QT_VERSION_CHECK(5,7,0)
     if (!success) {
         delete np;
         return;
     }
 #else
     if (!success) {
         delete np;
         socket->rollbackTransaction();
         return;
     }
     socket->commitTransaction();
 #endif
 
     if (np->type() != PACKET_TYPE_IDENTITY) {
         qCWarning(KDECONNECT_CORE) << "LanLinkProvider/newConnection: Expected identity, received " << np->type();
         delete np;
         return;
     }
 
     // Needed in "encrypted" if ssl is used, similar to "tcpSocketConnected"
     m_receivedIdentityPackets[socket].np = np;
 
     const QString& deviceId = np->get<QString>(QStringLiteral("deviceId"));
     //qCDebug(KDECONNECT_CORE) << "Handshaking done (i'm the new device)";
 
     //This socket will now be owned by the LanDeviceLink or we don't want more data to be received, forget about it
     disconnect(socket, &QIODevice::readyRead, this, &LanLinkProvider::dataReceived);
 
     if (np->get<int>(QStringLiteral("protocolVersion")) >= MIN_VERSION_WITH_SSL_SUPPORT) {
 
         bool isDeviceTrusted = KdeConnectConfig::instance().trustedDevices().contains(deviceId);
         configureSslSocket(socket, deviceId, isDeviceTrusted);
 
         qCDebug(KDECONNECT_CORE) << "Starting client ssl (but I'm the server TCP socket)";
 
         connect(socket, &QSslSocket::encrypted, this, &LanLinkProvider::encrypted);
 
         if (isDeviceTrusted) {
             connect(socket, QOverload<const QList<QSslError> &>::of(&QSslSocket::sslErrors), this, &LanLinkProvider::sslErrors);
         }
 
         socket->startClientEncryption();
 
     } else {
         qWarning() << np->get<QString>(QStringLiteral("deviceName")) << "uses an old protocol version, this won't work";
         //addLink(deviceId, socket, np, LanDeviceLink::Locally);
         delete m_receivedIdentityPackets.take(socket).np;
     }
 }
 
 void LanLinkProvider::deviceLinkDestroyed(QObject* destroyedDeviceLink)
 {
     const QString id = destroyedDeviceLink->property("deviceId").toString();
     //qCDebug(KDECONNECT_CORE) << "deviceLinkDestroyed" << id;
     QMap< QString, LanDeviceLink* >::iterator linkIterator = m_links.find(id);
     Q_ASSERT(linkIterator != m_links.end());
     if (linkIterator != m_links.end()) {
         Q_ASSERT(linkIterator.value() == destroyedDeviceLink);
         m_links.erase(linkIterator);
         auto pairingHandler = m_pairingHandlers.take(id);
         if (pairingHandler) {
             pairingHandler->deleteLater();
         }
     }
 
 }
 
 void LanLinkProvider::configureSslSocket(QSslSocket* socket, const QString& deviceId, bool isDeviceTrusted)
 {
     // Setting supported ciphers manually, to match those on Android (FIXME: Test if this can be left unconfigured and still works for Android 4)
     QList<QSslCipher> socketCiphers;
     socketCiphers.append(QSslCipher(QStringLiteral("ECDHE-ECDSA-AES256-GCM-SHA384")));
     socketCiphers.append(QSslCipher(QStringLiteral("ECDHE-ECDSA-AES128-GCM-SHA256")));
     socketCiphers.append(QSslCipher(QStringLiteral("ECDHE-RSA-AES128-SHA")));
 
     // Configure for ssl
     QSslConfiguration sslConfig;
     sslConfig.setCiphers(socketCiphers);
 
     socket->setSslConfiguration(sslConfig);
     socket->setLocalCertificate(KdeConnectConfig::instance().certificate());
     socket->setPrivateKey(KdeConnectConfig::instance().privateKeyPath());
     socket->setPeerVerifyName(deviceId);
 
     if (isDeviceTrusted) {
         QString certString = KdeConnectConfig::instance().getDeviceProperty(deviceId, QStringLiteral("certificate"), QString());
         socket->addCaCertificate(QSslCertificate(certString.toLatin1()));
         socket->setPeerVerifyMode(QSslSocket::VerifyPeer);
     } else {
         socket->setPeerVerifyMode(QSslSocket::QueryPeer);
     }
 
     //Usually SSL errors are only bad for trusted devices. Uncomment this section to log errors in any case, for debugging.
     //QObject::connect(socket, static_cast<void (QSslSocket::*)(const QList<QSslError>&)>(&QSslSocket::sslErrors), [](const QList<QSslError>& errors)
     //{
     //    Q_FOREACH (const QSslError& error, errors) {
     //        qCDebug(KDECONNECT_CORE) << "SSL Error:" << error.errorString();
     //    }
     //});
 }
 
 void LanLinkProvider::configureSocket(QSslSocket* socket) {
 
     socket->setProxy(QNetworkProxy::NoProxy);
 
     socket->setSocketOption(QAbstractSocket::KeepAliveOption, QVariant(1));
 
     #ifdef TCP_KEEPIDLE
         // time to start sending keepalive packets (seconds)
         int maxIdle = 10;
         setsockopt(socket->socketDescriptor(), IPPROTO_TCP, TCP_KEEPIDLE, &maxIdle, sizeof(maxIdle));
     #endif
 
     #ifdef TCP_KEEPINTVL
         // interval between keepalive packets after the initial period (seconds)
         int interval = 5;
         setsockopt(socket->socketDescriptor(), IPPROTO_TCP, TCP_KEEPINTVL, &interval, sizeof(interval));
     #endif
 
     #ifdef TCP_KEEPCNT
         // number of missed keepalive packets before disconnecting
         int count = 3;
         setsockopt(socket->socketDescriptor(), IPPROTO_TCP, TCP_KEEPCNT, &count, sizeof(count));
     #endif
 
 }
 
 void LanLinkProvider::addLink(const QString& deviceId, QSslSocket* socket, NetworkPacket* receivedPacket, LanDeviceLink::ConnectionStarted connectionOrigin)
 {
     // Socket disconnection will now be handled by LanDeviceLink
     disconnect(socket, &QAbstractSocket::disconnected, socket, &QObject::deleteLater);
 
     LanDeviceLink* deviceLink;
     //Do we have a link for this device already?
     QMap< QString, LanDeviceLink* >::iterator linkIterator = m_links.find(deviceId);
     if (linkIterator != m_links.end()) {
         //qCDebug(KDECONNECT_CORE) << "Reusing link to" << deviceId;
         deviceLink = linkIterator.value();
         deviceLink->reset(socket, connectionOrigin);
     } else {
         deviceLink = new LanDeviceLink(deviceId, this, socket, connectionOrigin);
         connect(deviceLink, &QObject::destroyed, this, &LanLinkProvider::deviceLinkDestroyed);
         m_links[deviceId] = deviceLink;
         if (m_pairingHandlers.contains(deviceId)) {
             //We shouldn't have a pairinghandler if we didn't have a link.
             //Crash if debug, recover if release (by setting the new devicelink to the old pairinghandler)
             Q_ASSERT(m_pairingHandlers.contains(deviceId));
             m_pairingHandlers[deviceId]->setDeviceLink(deviceLink);
         }
     }
     Q_EMIT onConnectionReceived(*receivedPacket, deviceLink);
 }
 
 LanPairingHandler* LanLinkProvider::createPairingHandler(DeviceLink* link)
 {
     LanPairingHandler* ph = m_pairingHandlers.value(link->deviceId());
     if (!ph) {
         ph = new LanPairingHandler(link);
         qCDebug(KDECONNECT_CORE) << "creating pairing handler for" << link->deviceId();
         connect (ph, &LanPairingHandler::pairingError, link, &DeviceLink::pairingError);
         m_pairingHandlers[link->deviceId()] = ph;
     }
     return ph;
 }
 
 void LanLinkProvider::userRequestsPair(const QString& deviceId)
 {
     LanPairingHandler* ph = createPairingHandler(m_links.value(deviceId));
     ph->requestPairing();
 }
 
 void LanLinkProvider::userRequestsUnpair(const QString& deviceId)
 {
     LanPairingHandler* ph = createPairingHandler(m_links.value(deviceId));
     ph->unpair();
 }
 
 void LanLinkProvider::incomingPairPacket(DeviceLink* deviceLink, const NetworkPacket& np)
 {
     LanPairingHandler* ph = createPairingHandler(deviceLink);
     ph->packetReceived(np);
 }
 
diff --git a/core/filetransferjob.cpp b/core/filetransferjob.cpp
index 5b7f0e1e..a9ccdcab 100644
--- a/core/filetransferjob.cpp
+++ b/core/filetransferjob.cpp
@@ -1,153 +1,157 @@
 /*
  * Copyright 2013 Albert Vaca <albertvaka@gmail.com>
  * Copyright 2015 Aleix Pol i Gonzalez <aleixpol@kde.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) version 3 or any later version
  * accepted by the membership of KDE e.V. (or its successor approved
  * by the membership of KDE e.V.), which shall act as a proxy
  * defined in Section 14 of version 3 of the license.
  *
  * 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, see <https://www.gnu.org/licenses/>.
  */
 
 #include "filetransferjob.h"
 #include "daemon.h"
 #include <core_debug.h>
 
 #include <qalgorithms.h>
 #include <QFileInfo>
 #include <QDebug>
 
 #include <KLocalizedString>
 
 FileTransferJob::FileTransferJob(const NetworkPacket* np, const QUrl& destination)
     : KJob()
     , m_origin(np->payload())
     , m_reply(nullptr)
     , m_from(QStringLiteral("KDE Connect"))
     , m_destination(destination)
     , m_speedBytes(0)
     , m_written(0)
     , m_size(np->payloadSize())
     , m_np(np)
 {
     Q_ASSERT(m_origin);
     //Disabled this assert: QBluetoothSocket doesn't report "->isReadable() == true" until it's connected
     //Q_ASSERT(m_origin->isReadable());
     if (m_destination.scheme().isEmpty()) {
         qCWarning(KDECONNECT_CORE) << "Destination QUrl" << m_destination << "lacks a scheme. Setting its scheme to 'file'.";
         m_destination.setScheme(QStringLiteral("file"));
     }
 
     setCapabilities(Killable);
     qCDebug(KDECONNECT_CORE) << "FileTransferJob Downloading payload to" << destination << "size:" << m_size;
 }
 
 void FileTransferJob::start()
 {
     QMetaObject::invokeMethod(this, "doStart", Qt::QueuedConnection);
     //qCDebug(KDECONNECT_CORE) << "FileTransferJob start";
 }
 
 void FileTransferJob::doStart()
 {
     if (m_destination.isLocalFile() && QFile::exists(m_destination.toLocalFile())) {
         setError(2);
         setErrorText(i18n("Filename already present"));
         emitResult();
         return;
     }
 
     if (m_origin->bytesAvailable())
         startTransfer();
     connect(m_origin.data(), &QIODevice::readyRead, this, &FileTransferJob::startTransfer);
 }
 
 void FileTransferJob::startTransfer()
 {
     // Don't put each ready read
     if (m_reply)
         return;
 
     setProcessedAmount(Bytes, 0);
 
     QNetworkRequest req(m_destination);
     if (m_size >= 0) {
         setTotalAmount(Bytes, m_size);
         req.setHeader(QNetworkRequest::ContentLengthHeader, m_size);
     }
     m_reply = Daemon::instance()->networkAccessManager()->put(req, m_origin.data());
 
     connect(m_reply, &QNetworkReply::uploadProgress, this, [this](qint64 bytesSent, qint64 /*bytesTotal*/) {
         if (!m_timer.isValid())
             m_timer.start();
         setProcessedAmount(Bytes, bytesSent);
 
         const auto elapsed = m_timer.elapsed();
         if (elapsed > 0) {
             emitSpeed((1000 * bytesSent) / elapsed);
         }
 
         m_written = bytesSent;
     });
+#if QT_VERSION < QT_VERSION_CHECK(5,15,0)
     connect(m_reply, static_cast<void (QNetworkReply::*)(QNetworkReply::NetworkError)>(&QNetworkReply::error),
             this, &FileTransferJob::transferFailed);
+#else
+    connect(m_reply, &QNetworkReply::errorOccurred, this, &FileTransferJob::transferFailed);
+#endif
     connect(m_reply, &QNetworkReply::finished, this, &FileTransferJob::transferFinished);
 }
 
 void FileTransferJob::transferFailed(QNetworkReply::NetworkError error)
 {
     qCDebug(KDECONNECT_CORE) << "Couldn't transfer the file successfully" << error << m_reply->errorString();
     setError(error);
     setErrorText(i18n("Received incomplete file: %1", m_reply->errorString()));
     emitResult();
 
     m_reply->close();
 }
 
 void FileTransferJob::transferFinished()
 {
     //TODO: MD5-check the file
     if (m_size == m_written) {
         qCDebug(KDECONNECT_CORE) << "Finished transfer" << m_destination;
         emitResult();
     } else {
         qCDebug(KDECONNECT_CORE) << "Received incomplete file ("<< m_written << "/" << m_size << "bytes ), deleting";
 
         deleteDestinationFile();
 
         setError(3);
         setErrorText(i18n("Received incomplete file from: %1", m_from));
         emitResult();
     }
 }
 
 void FileTransferJob::deleteDestinationFile()
 {
     if (m_destination.isLocalFile() && QFile::exists(m_destination.toLocalFile())) {
         QFile::remove(m_destination.toLocalFile());
     }
 }
 
 bool FileTransferJob::doKill()
 {
     if (m_reply) {
         m_reply->close();
     }
     if (m_origin) {
         m_origin->close();
     }
 
     deleteDestinationFile();
 
     return true;
 }