diff --git a/core/backends/lan/landevicelink.cpp b/core/backends/lan/landevicelink.cpp
index 77883a5d..7fe1fd54 100644
--- a/core/backends/lan/landevicelink.cpp
+++ b/core/backends/lan/landevicelink.cpp
@@ -1,161 +1,164 @@
 /**
  * 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 <http://www.gnu.org/licenses/>.
  */
 
 #include <KLocalizedString>
 
 #include "landevicelink.h"
 #include "core_debug.h"
 #include "kdeconnectconfig.h"
 #include "backends/linkprovider.h"
 #include "uploadjob.h"
 #include "downloadjob.h"
 #include "socketlinereader.h"
 #include "lanlinkprovider.h"
 
 LanDeviceLink::LanDeviceLink(const QString& deviceId, LinkProvider* parent, QSslSocket* socket, ConnectionStarted connectionSource)
     : DeviceLink(deviceId, parent)
     , mSocketLineReader(nullptr)
 {
     reset(socket, connectionSource);
 }
 
 void LanDeviceLink::reset(QSslSocket* socket, ConnectionStarted connectionSource)
 {
     if (mSocketLineReader) {
         disconnect(mSocketLineReader->mSocket, &QAbstractSocket::disconnected, this, &QObject::deleteLater);
         delete mSocketLineReader;
     }
 
     mSocketLineReader = new SocketLineReader(socket, this);
 
     connect(socket, &QAbstractSocket::disconnected, this, &QObject::deleteLater);
     connect(mSocketLineReader, &SocketLineReader::readyRead, this, &LanDeviceLink::dataReceived);
 
     //We take ownership of the socket.
     //When the link provider destroys us,
     //the socket (and the reader) will be
     //destroyed as well
     socket->setParent(mSocketLineReader);
 
     mConnectionSource = connectionSource;
 
+    QHostAddress addr = socket->peerAddress();
+    mHostAddress = (addr.protocol() == QAbstractSocket::IPv6Protocol) ? QHostAddress(addr.toIPv4Address()) : addr;
+
     QString certString = KdeConnectConfig::instance()->getDeviceProperty(deviceId(), QStringLiteral("certificate"));
     DeviceLink::setPairStatus(certString.isEmpty()? PairStatus::NotPaired : PairStatus::Paired);
 }
 
 QString LanDeviceLink::name()
 {
     return QStringLiteral("LanLink"); // Should be same in both android and kde version
 }
 
 bool LanDeviceLink::sendPackage(NetworkPackage& np)
 {
     if (np.hasPayload()) {
         np.setPayloadTransferInfo(sendPayload(np)->transferInfo());
     }
 
     int written = mSocketLineReader->write(np.serialize());
 
     //Actually we can't detect if a package is received or not. We keep TCP
     //"ESTABLISHED" connections that look legit (return true when we use them),
     //but that are actually broken (until keepalive detects that they are down).
     return (written != -1);
 }
 
 UploadJob* LanDeviceLink::sendPayload(const NetworkPackage& np)
 {
     UploadJob* job = new UploadJob(np.payload(), deviceId());
     job->start();
     return job;
 }
 
 void LanDeviceLink::dataReceived()
 {
     if (mSocketLineReader->bytesAvailable() == 0) return;
 
     const QByteArray serializedPackage = mSocketLineReader->readLine();
     NetworkPackage package(QString::null);
     NetworkPackage::unserialize(serializedPackage, &package);
 
     //qCDebug(KDECONNECT_CORE) << "LanDeviceLink dataReceived" << serializedPackage;
 
     if (package.type() == PACKAGE_TYPE_PAIR) {
         //TODO: Handle pair/unpair requests and forward them (to the pairing handler?)
         qobject_cast<LanLinkProvider*>(provider())->incomingPairPackage(this, package);
         return;
     }
 
     if (package.hasPayloadTransferInfo()) {
         //qCDebug(KDECONNECT_CORE) << "HasPayloadTransferInfo";
         QVariantMap transferInfo = package.payloadTransferInfo();
         //FIXME: The next two lines shouldn't be needed! Why are they here?
         transferInfo.insert(QStringLiteral("useSsl"), true);
         transferInfo.insert(QStringLiteral("deviceId"), deviceId());
         DownloadJob* job = new DownloadJob(mSocketLineReader->peerAddress(), transferInfo);
         job->start();
         package.setPayload(job->getPayload(), package.payloadSize());
     }
 
     Q_EMIT receivedPackage(package);
 
     if (mSocketLineReader->bytesAvailable() > 0) {
         QMetaObject::invokeMethod(this, "dataReceived", Qt::QueuedConnection);
     }
 
 }
 
 void LanDeviceLink::userRequestsPair()
 {
     if (mSocketLineReader->peerCertificate().isNull()) {
         Q_EMIT pairingError(i18n("This device cannot be paired because it is running an old version of KDE Connect."));
     } else {
         qobject_cast<LanLinkProvider*>(provider())->userRequestsPair(deviceId());
     }
 }
 
 void LanDeviceLink::userRequestsUnpair()
 {
     qobject_cast<LanLinkProvider*>(provider())->userRequestsUnpair(deviceId());
 }
 
 void LanDeviceLink::setPairStatus(PairStatus status)
 {
     if (status == Paired && mSocketLineReader->peerCertificate().isNull()) {
         Q_EMIT pairingError(i18n("This device cannot be paired because it is running an old version of KDE Connect."));
         return;
     }
 
     DeviceLink::setPairStatus(status);
     if (status == Paired) {
         Q_ASSERT(KdeConnectConfig::instance()->trustedDevices().contains(deviceId()));
         Q_ASSERT(!mSocketLineReader->peerCertificate().isNull());
         KdeConnectConfig::instance()->setDeviceProperty(deviceId(), QStringLiteral("certificate"), mSocketLineReader->peerCertificate().toPem());
     }
 }
 
 bool LanDeviceLink::linkShouldBeKeptAlive() {
 
     return true;     //FIXME: Current implementation is broken, so for now we will keep links always established
 
     //We keep the remotely initiated connections, since the remotes require them if they want to request
     //pairing to us, or connections that are already paired. TODO: Keep connections in the process of pairing
     //return (mConnectionSource == ConnectionStarted::Remotely || pairStatus() == Paired);
 
 }
diff --git a/core/backends/lan/landevicelink.h b/core/backends/lan/landevicelink.h
index 8eb15868..5438f85b 100644
--- a/core/backends/lan/landevicelink.h
+++ b/core/backends/lan/landevicelink.h
@@ -1,65 +1,68 @@
 /**
  * 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 <http://www.gnu.org/licenses/>.
  */
 
 #ifndef LANDEVICELINK_H
 #define LANDEVICELINK_H
 
 #include <QObject>
 #include <QString>
 #include <QSslSocket>
 #include <QSslCertificate>
 
 #include <kdeconnectcore_export.h>
 #include "backends/devicelink.h"
 #include "uploadjob.h"
 
 class SocketLineReader;
 
 class KDECONNECTCORE_EXPORT LanDeviceLink
     : public DeviceLink
 {
     Q_OBJECT
 
 public:
     enum ConnectionStarted : bool { Locally, Remotely };
 
     LanDeviceLink(const QString& deviceId, LinkProvider* parent, QSslSocket* socket, ConnectionStarted connectionSource);
     void reset(QSslSocket* socket, ConnectionStarted connectionSource);
 
     QString name() override;
     bool sendPackage(NetworkPackage& np) override;
     UploadJob* sendPayload(const NetworkPackage& np);
 
     void userRequestsPair() override;
     void userRequestsUnpair() override;
 
     void setPairStatus(PairStatus status) override;
 
     bool linkShouldBeKeptAlive() override;
 
+    QHostAddress hostAddress() const { return mHostAddress; }
+
 private Q_SLOTS:
     void dataReceived();
 
 private:
     SocketLineReader* mSocketLineReader;
     ConnectionStarted mConnectionSource;
+    QHostAddress mHostAddress;
 };
 
 #endif
diff --git a/core/device.cpp b/core/device.cpp
index d0f8565f..3ad8dcdf 100644
--- a/core/device.cpp
+++ b/core/device.cpp
@@ -1,477 +1,489 @@
 /**
  * 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 <http://www.gnu.org/licenses/>.
  */
 
 #include "device.h"
 
 #ifdef interface // MSVC language extension, QDBusConnection uses this as a variable name
 #undef interface
 #endif
 
 #include <QDBusConnection>
 #include <QSslCertificate>
 
 #include <KSharedConfig>
 #include <KConfigGroup>
 #include <KLocalizedString>
 
 #include "core_debug.h"
 #include "kdeconnectplugin.h"
 #include "pluginloader.h"
 #include "backends/devicelink.h"
+#include "backends/lan/landevicelink.h"
 #include "backends/linkprovider.h"
 #include "networkpackage.h"
 #include "kdeconnectconfig.h"
 #include "daemon.h"
 
 static void warn(const QString &info)
 {
     qWarning() << "Device pairing error" << info;
 }
 
 Device::Device(QObject* parent, const QString& id)
     : QObject(parent)
     , m_deviceId(id)
     , m_protocolVersion(NetworkPackage::ProtocolVersion) //We don't know it yet
 {
     KdeConnectConfig::DeviceInfo info = KdeConnectConfig::instance()->getTrustedDevice(id);
 
     m_deviceName = info.deviceName;
     m_deviceType = str2type(info.deviceType);
 
     //Register in bus
     QDBusConnection::sessionBus().registerObject(dbusPath(), this, QDBusConnection::ExportScriptableContents | QDBusConnection::ExportAdaptors);
 
     //Assume every plugin is supported until addLink is called and we can get the actual list
     m_supportedPlugins = PluginLoader::instance()->getPluginList().toSet();
 
     connect(this, &Device::pairingError, this, &warn);
 }
 
 Device::Device(QObject* parent, const NetworkPackage& identityPackage, DeviceLink* dl)
     : QObject(parent)
     , m_deviceId(identityPackage.get<QString>(QStringLiteral("deviceId")))
     , m_deviceName(identityPackage.get<QString>(QStringLiteral("deviceName")))
 {
     addLink(identityPackage, dl);
 
     //Register in bus
     QDBusConnection::sessionBus().registerObject(dbusPath(), this, QDBusConnection::ExportScriptableContents | QDBusConnection::ExportAdaptors);
 
     connect(this, &Device::pairingError, this, &warn);
 }
 
 Device::~Device()
 {
     qDeleteAll(m_deviceLinks);
     m_deviceLinks.clear();
 }
 
 bool Device::hasPlugin(const QString& name) const
 {
     return m_plugins.contains(name);
 }
 
 QStringList Device::loadedPlugins() const
 {
     return m_plugins.keys();
 }
 
 void Device::reloadPlugins()
 {
     QHash<QString, KdeConnectPlugin*> newPluginMap, oldPluginMap = m_plugins;
     QMultiMap<QString, KdeConnectPlugin*> newPluginsByIncomingCapability;
 
     if (isTrusted() && isReachable()) { //Do not load any plugin for unpaired devices, nor useless loading them for unreachable devices
 
         PluginLoader* loader = PluginLoader::instance();
 
         for (const QString& pluginName : qAsConst(m_supportedPlugins)) {
             const KPluginMetaData service = loader->getPluginInfo(pluginName);
 
             const bool pluginEnabled = isPluginEnabled(pluginName);
             const QSet<QString> incomingCapabilities = KPluginMetaData::readStringList(service.rawData(), QStringLiteral("X-KdeConnect-SupportedPackageType")).toSet();
 
             if (pluginEnabled) {
                 KdeConnectPlugin* plugin = m_plugins.take(pluginName);
 
                 if (!plugin) {
                     plugin = loader->instantiatePluginForDevice(pluginName, this);
                 }
                 Q_ASSERT(plugin);
 
                 for (const QString& interface : incomingCapabilities) {
                     newPluginsByIncomingCapability.insert(interface, plugin);
                 }
 
                 newPluginMap[pluginName] = plugin;
             }
         }
     }
 
     const bool differentPlugins = oldPluginMap != newPluginMap;
 
     //Erase all left plugins in the original map (meaning that we don't want
     //them anymore, otherwise they would have been moved to the newPluginMap)
     qDeleteAll(m_plugins);
     m_plugins = newPluginMap;
     m_pluginsByIncomingCapability = newPluginsByIncomingCapability;
 
     QDBusConnection bus = QDBusConnection::sessionBus();
     for (KdeConnectPlugin* plugin : qAsConst(m_plugins)) {
         //TODO: see how it works in Android (only done once, when created)
         plugin->connected();
 
         const QString dbusPath = plugin->dbusPath();
         if (!dbusPath.isEmpty()) {
             bus.registerObject(dbusPath, plugin, QDBusConnection::ExportAllProperties | QDBusConnection::ExportScriptableInvokables | QDBusConnection::ExportScriptableSignals | QDBusConnection::ExportScriptableSlots);
         }
     }
     if (differentPlugins) {
         Q_EMIT pluginsChanged();
     }
 }
 
 QString Device::pluginsConfigFile() const
 {
     return KdeConnectConfig::instance()->deviceConfigDir(id()).absoluteFilePath(QStringLiteral("config"));
 }
 
 void Device::requestPair()
 {
     if (isTrusted()) {
         Q_EMIT pairingError(i18n("Already paired"));
         return;
     }
 
     if (!isReachable()) {
         Q_EMIT pairingError(i18n("Device not reachable"));
         return;
     }
 
     for (DeviceLink* dl : qAsConst(m_deviceLinks)) {
         dl->userRequestsPair();
     }
 }
 
 void Device::unpair()
 {
     for (DeviceLink* dl : qAsConst(m_deviceLinks)) {
         dl->userRequestsUnpair();
     }
     KdeConnectConfig::instance()->removeTrustedDevice(id());
     Q_EMIT trustedChanged(false);
 }
 
 void Device::pairStatusChanged(DeviceLink::PairStatus status)
 {
     if (status == DeviceLink::NotPaired) {
         KdeConnectConfig::instance()->removeTrustedDevice(id());
 
         for (DeviceLink* dl : qAsConst(m_deviceLinks)) {
             if (dl != sender()) {
                 dl->setPairStatus(DeviceLink::NotPaired);
             }
         }
     } else {
         KdeConnectConfig::instance()->addTrustedDevice(id(), name(), type());
     }
 
     reloadPlugins(); //Will load/unload plugins
 
     bool isTrusted = (status == DeviceLink::Paired);
     Q_EMIT trustedChanged(isTrusted);
     Q_ASSERT(isTrusted == this->isTrusted());
 }
 
 static bool lessThan(DeviceLink* p1, DeviceLink* p2)
 {
     return p1->provider()->priority() > p2->provider()->priority();
 }
 
 void Device::addLink(const NetworkPackage& identityPackage, DeviceLink* link)
 {
     //qCDebug(KDECONNECT_CORE) << "Adding link to" << id() << "via" << link->provider();
 
     Q_ASSERT(!m_deviceLinks.contains(link));
 
     m_protocolVersion = identityPackage.get<int>(QStringLiteral("protocolVersion"), -1);
     if (m_protocolVersion != NetworkPackage::ProtocolVersion) {
         qCWarning(KDECONNECT_CORE) << m_deviceName << "- warning, device uses a different protocol version" << m_protocolVersion << "expected" << NetworkPackage::ProtocolVersion;
     }
 
     connect(link, &QObject::destroyed,
             this, &Device::linkDestroyed);
 
     m_deviceLinks.append(link);
 
     //re-read the device name from the identityPackage because it could have changed
     setName(identityPackage.get<QString>(QStringLiteral("deviceName")));
     m_deviceType = str2type(identityPackage.get<QString>(QStringLiteral("deviceType")));
 
     //Theoretically we will never add two links from the same provider (the provider should destroy
     //the old one before this is called), so we do not have to worry about destroying old links.
     //-- Actually, we should not destroy them or the provider will store an invalid ref!
 
     connect(link, &DeviceLink::receivedPackage,
             this, &Device::privateReceivedPackage);
 
     qSort(m_deviceLinks.begin(), m_deviceLinks.end(), lessThan);
 
     const bool capabilitiesSupported = identityPackage.has(QStringLiteral("incomingCapabilities")) || identityPackage.has(QStringLiteral("outgoingCapabilities"));
     if (capabilitiesSupported) {
         const QSet<QString> outgoingCapabilities = identityPackage.get<QStringList>(QStringLiteral("outgoingCapabilities")).toSet()
                           , incomingCapabilities = identityPackage.get<QStringList>(QStringLiteral("incomingCapabilities")).toSet();
 
         m_supportedPlugins = PluginLoader::instance()->pluginsForCapabilities(incomingCapabilities, outgoingCapabilities);
         //qDebug() << "new plugins for" << m_deviceName << m_supportedPlugins << incomingCapabilities << outgoingCapabilities;
     } else {
         m_supportedPlugins = PluginLoader::instance()->getPluginList().toSet();
     }
 
     reloadPlugins();
 
     if (m_deviceLinks.size() == 1) {
         Q_EMIT reachableChanged(true);
     }
 
     connect(link, &DeviceLink::pairStatusChanged, this, &Device::pairStatusChanged);
     connect(link, &DeviceLink::pairingRequest, this, &Device::addPairingRequest);
     connect(link, &DeviceLink::pairingRequestExpired, this, &Device::removePairingRequest);
     connect(link, &DeviceLink::pairingError, this, &Device::pairingError);
 }
 
 void Device::addPairingRequest(PairingHandler* handler)
 {
     const bool wasEmpty = m_pairRequests.isEmpty();
     m_pairRequests.insert(handler);
 
     if (wasEmpty != m_pairRequests.isEmpty())
         Q_EMIT hasPairingRequestsChanged(!m_pairRequests.isEmpty());
 }
 
 void Device::removePairingRequest(PairingHandler* handler)
 {
     const bool wasEmpty = m_pairRequests.isEmpty();
     m_pairRequests.remove(handler);
 
     if (wasEmpty != m_pairRequests.isEmpty())
         Q_EMIT hasPairingRequestsChanged(!m_pairRequests.isEmpty());
 }
 
 bool Device::hasPairingRequests() const
 {
     return !m_pairRequests.isEmpty();
 }
 
 void Device::acceptPairing()
 {
     if (m_pairRequests.isEmpty())
         qWarning() << "no pair requests to accept!";
 
     //copying because the pairing handler will be removed upon accept
     const auto prCopy = m_pairRequests;
     for (auto ph: prCopy)
         ph->acceptPairing();
 }
 
 void Device::rejectPairing()
 {
     if (m_pairRequests.isEmpty())
         qWarning() << "no pair requests to reject!";
 
     //copying because the pairing handler will be removed upon reject
     const auto prCopy = m_pairRequests;
     for (auto ph: prCopy)
         ph->rejectPairing();
 }
 
 void Device::linkDestroyed(QObject* o)
 {
     removeLink(static_cast<DeviceLink*>(o));
 }
 
 void Device::removeLink(DeviceLink* link)
 {
     m_deviceLinks.removeAll(link);
 
     //qCDebug(KDECONNECT_CORE) << "RemoveLink" << m_deviceLinks.size() << "links remaining";
 
     if (m_deviceLinks.isEmpty()) {
         reloadPlugins();
         Q_EMIT reachableChanged(false);
     }
 }
 
 bool Device::sendPackage(NetworkPackage& np)
 {
     Q_ASSERT(np.type() != PACKAGE_TYPE_PAIR);
     Q_ASSERT(isTrusted());
 
     //Maybe we could block here any package that is not an identity or a pairing package to prevent sending non encrypted data
     for (DeviceLink* dl : qAsConst(m_deviceLinks)) {
         if (dl->sendPackage(np)) return true;
     }
 
     return false;
 }
 
 void Device::privateReceivedPackage(const NetworkPackage& np)
 {
     Q_ASSERT(np.type() != PACKAGE_TYPE_PAIR);
     if (isTrusted()) {
         const QList<KdeConnectPlugin*> plugins = m_pluginsByIncomingCapability.values(np.type());
         if (plugins.isEmpty()) {
             qWarning() << "discarding unsupported package" << np.type() << "for" << name();
         }
         for (KdeConnectPlugin* plugin : plugins) {
             plugin->receivePackage(np);
         }
     } else {
         qCDebug(KDECONNECT_CORE) << "device" << name() << "not paired, ignoring package" << np.type();
         unpair();
     }
 
 }
 
 bool Device::isTrusted() const
 {
     return KdeConnectConfig::instance()->trustedDevices().contains(id());
 }
 
 QStringList Device::availableLinks() const
 {
     QStringList sl;
     sl.reserve(m_deviceLinks.size());
     for (DeviceLink* dl : qAsConst(m_deviceLinks)) {
         sl.append(dl->provider()->name());
     }
     return sl;
 }
 
 void Device::cleanUnneededLinks() {
     if (isTrusted()) {
         return;
     }
     for(int i = 0; i < m_deviceLinks.size(); ) {
         DeviceLink* dl = m_deviceLinks[i];
         if (!dl->linkShouldBeKeptAlive()) {
             dl->deleteLater();
             m_deviceLinks.remove(i);
         } else {
             i++;
         }
     }
 }
 
+QHostAddress Device::getLocalIpAddress() const
+{
+    for (DeviceLink* dl : m_deviceLinks) {
+        LanDeviceLink* ldl = dynamic_cast<LanDeviceLink*>(dl);
+        if (ldl) {
+            return ldl->hostAddress();
+        }
+    }
+    return QHostAddress::Null;
+}
+
 Device::DeviceType Device::str2type(const QString &deviceType) {
     if (deviceType == QLatin1String("desktop")) return Desktop;
     if (deviceType == QLatin1String("laptop")) return Laptop;
     if (deviceType == QLatin1String("smartphone") || deviceType == QLatin1String("phone")) return Phone;
     if (deviceType == QLatin1String("tablet")) return Tablet;
     return Unknown;
 }
 
 QString Device::type2str(Device::DeviceType deviceType) {
     if (deviceType == Desktop) return QStringLiteral("desktop");
     if (deviceType == Laptop) return QStringLiteral("laptop");
     if (deviceType == Phone) return QStringLiteral("smartphone");
     if (deviceType == Tablet) return QStringLiteral("tablet");
     return QStringLiteral("unknown");
 }
 
 QString Device::statusIconName() const
 {
     return iconForStatus(isReachable(), isTrusted());
 }
 
 QString Device::iconName() const
 {
 
     return iconForStatus(true, false);
 }
 
 QString Device::iconForStatus(bool reachable, bool trusted) const
 {
     Device::DeviceType deviceType = m_deviceType;
     if (deviceType == Device::Unknown) {
         deviceType = Device::Phone; //Assume phone if we don't know the type
     } else if (deviceType == Device::Desktop) {
         deviceType = Device::Device::Laptop; // We don't have desktop icon yet
     }
 
     QString status = (reachable? (trusted? QStringLiteral("connected") : QStringLiteral("disconnected")) : QStringLiteral("trusted"));
     QString type = type2str(deviceType);
 
     return type+status;
 }
 
 void Device::setName(const QString &name)
 {
     if (m_deviceName != name) {
         m_deviceName = name;
         Q_EMIT nameChanged(name);
     }
 }
 
 KdeConnectPlugin* Device::plugin(const QString& pluginName) const
 {
     return m_plugins[pluginName];
 }
 
 void Device::setPluginEnabled(const QString& pluginName, bool enabled)
 {
     KConfigGroup pluginStates = KSharedConfig::openConfig(pluginsConfigFile())->group("Plugins");
 
     const QString enabledKey = pluginName + QStringLiteral("Enabled");
     pluginStates.writeEntry(enabledKey, enabled);
     reloadPlugins();
 }
 
 bool Device::isPluginEnabled(const QString& pluginName) const
 {
     const QString enabledKey = pluginName + QStringLiteral("Enabled");
     KConfigGroup pluginStates = KSharedConfig::openConfig(pluginsConfigFile())->group("Plugins");
 
     return (pluginStates.hasKey(enabledKey) ? pluginStates.readEntry(enabledKey, false)
                                             : PluginLoader::instance()->getPluginInfo(pluginName).isEnabledByDefault());
 }
 
 QString Device::encryptionInfo() const
 {
     QString result;
     QCryptographicHash::Algorithm digestAlgorithm = QCryptographicHash::Algorithm::Sha1;
 
     QString localSha1 = QString::fromLatin1(KdeConnectConfig::instance()->certificate().digest(digestAlgorithm).toHex());
     for (int i = 2; i<localSha1.size(); i += 3) {
         localSha1.insert(i, ':'); // Improve readability
     }
     result += i18n("SHA1 fingerprint of your device certificate is: %1\n", localSha1);
 
     std::string  remotePem = KdeConnectConfig::instance()->getDeviceProperty(id(), QStringLiteral("certificate")).toStdString();
     QSslCertificate remoteCertificate = QSslCertificate(QByteArray(remotePem.c_str(), (int)remotePem.size()));
     QString remoteSha1 = QString::fromLatin1(remoteCertificate.digest(digestAlgorithm).toHex());
     for (int i = 2; i < remoteSha1.size(); i += 3) {
         remoteSha1.insert(i, ':'); // Improve readability
     }
     result += i18n("SHA1 fingerprint of remote device certificate is: %1\n", remoteSha1);
 
     return result;
 }
 
diff --git a/core/device.h b/core/device.h
index d3ec0435..326adf86 100644
--- a/core/device.h
+++ b/core/device.h
@@ -1,161 +1,164 @@
 /**
  * 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 <http://www.gnu.org/licenses/>.
  */
 
 #ifndef DEVICE_H
 #define DEVICE_H
 
 #include <QObject>
 #include <QString>
 #include <QVector>
 #include <QSet>
+#include <QHostAddress>
 
 #include "networkpackage.h"
 #include "backends/devicelink.h"
 
 class DeviceLink;
 class KdeConnectPlugin;
 
 class KDECONNECTCORE_EXPORT Device
     : public QObject
 {
     Q_OBJECT
     Q_CLASSINFO("D-Bus Interface", "org.kde.kdeconnect.device")
     Q_PROPERTY(QString type READ type CONSTANT)
     Q_PROPERTY(QString name READ name NOTIFY nameChanged)
     Q_PROPERTY(QString iconName READ iconName CONSTANT)
     Q_PROPERTY(QString statusIconName READ statusIconName)
     Q_PROPERTY(bool isReachable READ isReachable NOTIFY reachableChanged)
     Q_PROPERTY(bool isTrusted READ isTrusted NOTIFY trustedChanged)
     Q_PROPERTY(QStringList supportedPlugins READ supportedPlugins NOTIFY pluginsChanged)
     Q_PROPERTY(bool hasPairingRequests READ hasPairingRequests NOTIFY hasPairingRequestsChanged)
 
 public:
 
     enum DeviceType {
         Unknown,
         Desktop,
         Laptop,
         Phone,
         Tablet,
     };
 
     /**
      * Restores the @p device from the saved configuration
      *
      * We already know it but we need to wait for an incoming DeviceLink to communicate
      */
     Device(QObject* parent, const QString& id);
 
     /**
      * Device known via an incoming connection sent to us via a devicelink.
      *
      * We know everything but we don't trust it yet
      */
     Device(QObject* parent, const NetworkPackage& np, DeviceLink* dl);
 
     ~Device() override;
 
     QString id() const { return m_deviceId; }
     QString name() const { return m_deviceName; }
     QString dbusPath() const { return "/modules/kdeconnect/devices/"+id(); }
     QString type() const { return type2str(m_deviceType); }
     QString iconName() const;
     QString statusIconName() const;
     Q_SCRIPTABLE QString encryptionInfo() const;
 
     //Add and remove links
     void addLink(const NetworkPackage& identityPackage, DeviceLink*);
     void removeLink(DeviceLink*);
 
     Q_SCRIPTABLE bool isTrusted() const;
 
     Q_SCRIPTABLE QStringList availableLinks() const;
     bool isReachable() const { return !m_deviceLinks.isEmpty(); }
 
     Q_SCRIPTABLE QStringList loadedPlugins() const;
     Q_SCRIPTABLE bool hasPlugin(const QString& name) const;
 
     Q_SCRIPTABLE QString pluginsConfigFile() const;
 
     KdeConnectPlugin* plugin(const QString& pluginName) const;
     void setPluginEnabled(const QString& pluginName, bool enabled);
     bool isPluginEnabled(const QString& pluginName) const;
 
     void cleanUnneededLinks();
 
     int protocolVersion() { return m_protocolVersion; }
     QStringList supportedPlugins() const { return m_supportedPlugins.toList(); }
 
+    QHostAddress getLocalIpAddress() const;
+
 public Q_SLOTS:
     ///sends a @p np package to the device
     ///virtual for testing purposes.
     virtual bool sendPackage(NetworkPackage& np);
 
     //Dbus operations
 public Q_SLOTS:
     Q_SCRIPTABLE void requestPair(); //to all links
     Q_SCRIPTABLE void unpair(); //from all links
     Q_SCRIPTABLE void reloadPlugins(); //from kconf
 
     Q_SCRIPTABLE void acceptPairing();
     Q_SCRIPTABLE void rejectPairing();
     Q_SCRIPTABLE bool hasPairingRequests() const;
 
 private Q_SLOTS:
     void privateReceivedPackage(const NetworkPackage& np);
     void linkDestroyed(QObject* o);
     void pairStatusChanged(DeviceLink::PairStatus current);
     void addPairingRequest(PairingHandler* handler);
     void removePairingRequest(PairingHandler* handler);
 
 Q_SIGNALS:
     Q_SCRIPTABLE void pluginsChanged();
     Q_SCRIPTABLE void reachableChanged(bool reachable);
     Q_SCRIPTABLE void trustedChanged(bool trusted);
     Q_SCRIPTABLE void pairingError(const QString& error);
     Q_SCRIPTABLE void nameChanged(const QString& name);
 
     Q_SCRIPTABLE void hasPairingRequestsChanged(bool hasPairingRequests);
 
 private: //Methods
     static DeviceType str2type(const QString &deviceType);
     static QString type2str(DeviceType deviceType);
 
     void setName(const QString &name);
     QString iconForStatus(bool reachable, bool paired) const;
 
 private: //Fields (TODO: dPointer!)
     const QString m_deviceId;
     QString m_deviceName;
     DeviceType m_deviceType;
     int m_protocolVersion;
 
     QVector<DeviceLink*> m_deviceLinks;
     QHash<QString, KdeConnectPlugin*> m_plugins;
 
     //Capabilities stuff
     QMultiMap<QString, KdeConnectPlugin*> m_pluginsByIncomingCapability;
     QSet<QString> m_supportedPlugins;
     QSet<PairingHandler*> m_pairRequests;
 };
 
 Q_DECLARE_METATYPE(Device*)
 
 #endif // DEVICE_H
diff --git a/plugins/sftp/mounter.cpp b/plugins/sftp/mounter.cpp
index 7fb8f577..c2e7d6de 100644
--- a/plugins/sftp/mounter.cpp
+++ b/plugins/sftp/mounter.cpp
@@ -1,234 +1,241 @@
 /**
  * Copyright 2014 Samoilenko Yuri<kinnalru@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 <http://www.gnu.org/licenses/>.
  */
 
 #include "mounter.h"
 
 #include <unistd.h>
 #include <QDir>
 #include <QDebug>
 
 #include <KLocalizedString>
 
 #include "mountloop.h"
 #include "sftp_debug.h"
 #include "kdeconnectconfig.h"
 
 Mounter::Mounter(SftpPlugin* sftp)
     : QObject(sftp)
     , m_sftp(sftp)
     , m_proc(nullptr)
     , m_mountPoint(sftp->mountPoint())
     , m_started(false)
 {
 
     connect(m_sftp, &SftpPlugin::packageReceived, this, &Mounter::onPakcageReceived);
 
     connect(&m_connectTimer, &QTimer::timeout, this, &Mounter::onMountTimeout);
 
     connect(this, &Mounter::mounted, &m_connectTimer, &QTimer::stop);
     connect(this, &Mounter::failed, &m_connectTimer, &QTimer::stop);
 
     m_connectTimer.setInterval(10000);
     m_connectTimer.setSingleShot(true);
 
     QTimer::singleShot(0, this, &Mounter::start);
     qCDebug(KDECONNECT_PLUGIN_SFTP) << "Created mounter";
 }
 
 Mounter::~Mounter()
 {
     qCDebug(KDECONNECT_PLUGIN_SFTP) << "Destroy mounter";
     unmount(false);
 }
 
 bool Mounter::wait()
 {
     if (m_started)
     {
         return true;
     }
 
     qCDebug(KDECONNECT_PLUGIN_SFTP) << "Starting loop to wait for mount";
 
     MountLoop loop;
     connect(this, &Mounter::mounted, &loop, &MountLoop::successed);
     connect(this, &Mounter::failed, &loop, &MountLoop::failed);
     return loop.exec();
 }
 
 void Mounter::onPakcageReceived(const NetworkPackage& np)
 {
     if (np.get<bool>(QStringLiteral("stop"), false))
     {
         qCDebug(KDECONNECT_PLUGIN_SFTP) << "SFTP server stopped";
         unmount(false);
         return;
     }
 
     //This is the previous code, to access sftp server using KIO. Now we are
     //using the external binary sshfs, and accessing it as a local filesystem.
   /*
    *    QUrl url;
    *    url.setScheme("sftp");
    *    url.setHost(np.get<QString>("ip"));
    *    url.setPort(np.get<QString>("port").toInt());
    *    url.setUserName(np.get<QString>("user"));
    *    url.setPassword(np.get<QString>("password"));
    *    url.setPath(np.get<QString>("path"));
    *    new KRun(url, 0);
    *    Q_EMIT mounted();
    */
 
     unmount(false);
 
     m_proc = new KProcess();
     m_proc->setOutputChannelMode(KProcess::MergedChannels);
 
     connect(m_proc, &QProcess::started, this, &Mounter::onStarted);
     connect(m_proc, SIGNAL(error(QProcess::ProcessError)), SLOT(onError(QProcess::ProcessError)));
     connect(m_proc, SIGNAL(finished(int,QProcess::ExitStatus)), SLOT(onFinished(int,QProcess::ExitStatus)));
 
     QDir().mkpath(m_mountPoint);
 
     const QString program = QStringLiteral("sshfs");
 
     QString path;
     if (np.has(QStringLiteral("multiPaths"))) path = '/';
     else path = np.get<QString>(QStringLiteral("path"));
 
+    QHostAddress addr = m_sftp->device()->getLocalIpAddress();
+    if (addr == QHostAddress::Null) {
+        qCDebug(KDECONNECT_PLUGIN_SFTP) << "Device doesn't have a LanDeviceLink, unable to get IP address";
+        return;
+    }
+    QString ip = addr.toString();
+
     const QStringList arguments = QStringList()
         << QStringLiteral("%1@%2:%3").arg(
             np.get<QString>(QStringLiteral("user")),
-            np.get<QString>(QStringLiteral("ip")),
+            ip,
             path)
         << m_mountPoint
         << QStringLiteral("-p") << np.get<QString>(QStringLiteral("port"))
         << QStringLiteral("-f")
         << QStringLiteral("-F") << QStringLiteral("/dev/null") //Do not use ~/.ssh/config
         << QStringLiteral("-o") << "IdentityFile=" + KdeConnectConfig::instance()->privateKeyPath()
         << QStringLiteral("-o") << QStringLiteral("StrictHostKeyChecking=no") //Do not ask for confirmation because it is not a known host
         << QStringLiteral("-o") << QStringLiteral("UserKnownHostsFile=/dev/null") //Prevent storing as a known host
         << QStringLiteral("-o") << QStringLiteral("HostKeyAlgorithms=ssh-dss") //https://bugs.kde.org/show_bug.cgi?id=351725
         << QStringLiteral("-o") << QStringLiteral("uid=") + QString::number(getuid())
         << QStringLiteral("-o") << QStringLiteral("gid=") + QString::number(getgid())
         << QStringLiteral("-o") << QStringLiteral("ServerAliveInterval=30")
         << QStringLiteral("-o") << QStringLiteral("password_stdin")
         ;
 
     m_proc->setProgram(program, arguments);
 
     qCDebug(KDECONNECT_PLUGIN_SFTP) << "Starting process: " << m_proc->program().join(QStringLiteral(" "));
     m_proc->start();
 
     //qCDebug(KDECONNECT_PLUGIN_SFTP) << "Passing password: " << np.get<QString>("password").toLatin1();
     m_proc->write(np.get<QString>(QStringLiteral("password")).toLatin1());
     m_proc->write("\n");
 
 }
 
 void Mounter::onStarted()
 {
     qCDebug(KDECONNECT_PLUGIN_SFTP) << "Process started";
     m_started = true;
     Q_EMIT mounted();
 
     //m_proc->setStandardOutputFile("/tmp/kdeconnect-sftp.out");
     //m_proc->setStandardErrorFile("/tmp/kdeconnect-sftp.err");
 
     auto proc = m_proc;
     connect(m_proc, &KProcess::readyReadStandardError, [proc]() {
         qCDebug(KDECONNECT_PLUGIN_SFTP) << "stderr: " << proc->readAll();
     });
     connect(m_proc, &KProcess::readyReadStandardOutput, [proc]() {
         qCDebug(KDECONNECT_PLUGIN_SFTP) << "stdout:" << proc->readAll();
     });
 }
 
 void Mounter::onError(QProcess::ProcessError error)
 {
     if (error == QProcess::FailedToStart)
     {
         qCDebug(KDECONNECT_PLUGIN_SFTP) << "Process failed to start";
         m_started = false;
         Q_EMIT failed(i18n("Failed to start sshfs"));
     }
 }
 
 void Mounter::onFinished(int exitCode, QProcess::ExitStatus exitStatus)
 {
     if (exitStatus == QProcess::NormalExit)
     {
         qCDebug(KDECONNECT_PLUGIN_SFTP) << "Process finished (exit code: " << exitCode << ")";
         Q_EMIT unmounted();
     }
     else
     {
         qCDebug(KDECONNECT_PLUGIN_SFTP) << "Process failed (exit code:" << exitCode << ")";
         Q_EMIT failed(i18n("Error when accessing to filesystem"));
     }
 
     unmount(true);
 }
 
 void Mounter::onMountTimeout()
 {
     qCDebug(KDECONNECT_PLUGIN_SFTP) << "Timeout: device not responding";
     Q_EMIT failed(i18n("Failed to mount filesystem: device not responding"));
 }
 
 void Mounter::start()
 {
     NetworkPackage np(PACKAGE_TYPE_SFTP_REQUEST, {{"startBrowsing", true}});
     m_sftp->sendPackage(np);
 
     m_connectTimer.start();
 }
 
 void Mounter::unmount(bool finished)
 {
     qCDebug(KDECONNECT_PLUGIN_SFTP) << "Unmount" << m_proc;
     if (m_proc)
     {
         if (!finished)
         {
             //Process is still running, we want to stop it
             //But when the finished signal come, we might have already gone.
             //Disconnect everything.
             m_proc->disconnect();
             m_proc->kill();
 
             auto proc = m_proc;
             m_proc = nullptr;
             connect(proc, static_cast<void(QProcess::*)(int, QProcess::ExitStatus)>(&QProcess::finished),
                 [proc]() {
                     qCDebug(KDECONNECT_PLUGIN_SFTP) << "Free" << proc;
                     proc->deleteLater();
             });
             Q_EMIT unmounted();
         }
         else
             m_proc->deleteLater();
 
         //Free mount point (won't always succeed if the path is in use)
         KProcess::execute(QStringList() << QStringLiteral("fusermount") << QStringLiteral("-u") << m_mountPoint, 10000);
         m_proc = nullptr;
     }
     m_started = false;
 }