diff --git a/dataengines/dict/dictengine.cpp b/dataengines/dict/dictengine.cpp
index 02eee25ee..4315dc68e 100644
--- a/dataengines/dict/dictengine.cpp
+++ b/dataengines/dict/dictengine.cpp
@@ -1,241 +1,243 @@
 /*
  *   Copyright (C) 2007 Thomas Georgiou <TAGeorgiou@gmail.com> and Jeff Cooper <weirdsox11@gmail.com>
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU Library General Public License version 2 as
  *   published by the Free Software Foundation
  *
  *   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 Library 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.
  */
 
 #include "dictengine.h"
 #include <iostream>
 
 #include <QDebug>
 #include <QTcpSocket>
 
 #include <Plasma/DataContainer>
 
 DictEngine::DictEngine(QObject* parent, const QVariantList& args)
     : Plasma::DataEngine(parent, args)
     , m_tcpSocket(0)
 {
     Q_UNUSED(args)
     m_serverName = QLatin1String("dict.org"); //In case we need to switch it later
     m_dictName = QLatin1String("wn"); //Default, good dictionary
 }
 
 DictEngine::~DictEngine()
 {
 }
 
 void DictEngine::setDict(const QString &dict)
 {
     m_dictName = dict;
 }
 
 void DictEngine::setServer(const QString &server)
 {
     m_serverName = server;
 }
 
 static QString wnToHtml(const QString &word, QByteArray &text)
 {
     Q_UNUSED(word)
     QList<QByteArray> splitText = text.split('\n');
     QString def;
     def += QLatin1String("<dl>\n");
     QRegExp linkRx(QStringLiteral("\\{(.*)\\}"));
     linkRx.setMinimal(true);
 
     bool isFirst=true;
     while (!splitText.empty()) {
         //150 n definitions retrieved - definitions follow
         //151 word database name - text follows
         //250 ok (optional timing information here)
         //552 No match
         QString currentLine = splitText.takeFirst();
         if (currentLine.startsWith(QLatin1String("151"))) {
             isFirst = true;
             continue;
         }
 
         if (currentLine.startsWith('.')) {
             def += QLatin1String("</dd>");
             continue;
         }
 
         if (!(currentLine.startsWith(QLatin1String("150"))
            || currentLine.startsWith(QLatin1String("151"))
            || currentLine.startsWith(QLatin1String("250"))
            || currentLine.startsWith(QLatin1String("552")))) {
             currentLine.replace(linkRx,QLatin1String("<a href=\"\\1\">\\1</a>"));
 
             if (isFirst) {
                 def += "<dt><b>" + currentLine + "</b></dt>\n<dd>";
                 isFirst = false;
                 continue;
             } else {
                 if (currentLine.contains(QRegExp(QStringLiteral("([1-9]{1,2}:)")))) {
                     def += QLatin1String("\n<br>\n");
                 }
                 currentLine.replace(QRegExp(QStringLiteral("^([\\s\\S]*[1-9]{1,2}:)")), QLatin1String("<b>\\1</b>"));
                 def += currentLine;
                 continue;
             }
         }
 
     }
 
     def += QLatin1String("</dl>");
     return def;
 }
 
 void DictEngine::getDefinition()
 {
     m_tcpSocket->readAll();
     QByteArray ret;
 
     m_tcpSocket->write(QByteArray("DEFINE "));
     m_tcpSocket->write(m_dictName.toLatin1());
     m_tcpSocket->write(QByteArray(" \""));
     m_tcpSocket->write(m_currentWord.toUtf8());
     m_tcpSocket->write(QByteArray("\"\n"));
     m_tcpSocket->flush();
 
     while (!ret.contains("250") && !ret.contains("552") && !ret.contains("550")) {
         m_tcpSocket->waitForReadyRead();
         ret += m_tcpSocket->readAll();
     }
 
     connect(m_tcpSocket, &QTcpSocket::disconnected, this, &DictEngine::socketClosed);
     m_tcpSocket->disconnectFromHost();
     //       setData(m_currentWord, m_dictName, ret);
     //       qWarning()<<ret;
     setData(m_currentWord, QStringLiteral("text"), wnToHtml(m_currentWord,ret));
 }
 
 void DictEngine::getDicts()
 {
     QMap<QString, QString> theHash;
     m_tcpSocket->readAll();
     QByteArray ret;
 
     m_tcpSocket->write(QByteArray("SHOW DB\n"));;
     m_tcpSocket->flush();
 
     m_tcpSocket->waitForReadyRead();
     while (!ret.contains("250")) {
         m_tcpSocket->waitForReadyRead();
         ret += m_tcpSocket->readAll();
     }
 
     QList<QByteArray> retLines = ret.split('\n');
     QString tmp1, tmp2;
 
     while (!retLines.empty()) {
         QString curr(retLines.takeFirst());
 
         if (curr.startsWith(QLatin1String("554"))) {
             //TODO: What happens if no DB available?
             //TODO: Eventually there will be functionality to change the server...
             break;
         }
 
         // ignore status code and empty lines
         if (curr.startsWith(QLatin1String("250")) || curr.startsWith(QLatin1String("110"))
            || curr.isEmpty()) {
             continue;
         }
 
         if (!curr.startsWith('-') && !curr.startsWith('.')) {
             curr = curr.trimmed();
             tmp1 = curr.section(' ', 0, 0);
             tmp2 = curr.section(' ', 1);
   //          theHash.insert(tmp1, tmp2);
             //qDebug() << tmp1 + "  " + tmp2;
             setData(QStringLiteral("list-dictionaries"), tmp1, tmp2);
         }
     }
 
     m_tcpSocket->disconnectFromHost();
 //    setData("list-dictionaries", "dictionaries", QByteArray(theHash);
 }
 
 
 
 void DictEngine::socketClosed()
 {
-    m_tcpSocket->deleteLater();
+    if (m_tcpSocket) {
+        m_tcpSocket->deleteLater();
+    }
     m_tcpSocket = 0;
 }
 
 bool DictEngine::sourceRequestEvent(const QString &query)
 {
     // FIXME: this is COMPLETELY broken .. it can only look up one query at a time!
     //        a DataContainer subclass that does the look up should probably be made
     if (m_currentQuery == query) {
         return false;
     }
 
     if (m_tcpSocket) {
         m_tcpSocket->abort(); //stop if lookup is in progress and new query is requested
         m_tcpSocket->deleteLater();
         m_tcpSocket = 0;
     }
 
     QStringList queryParts = query.split(':', QString::SkipEmptyParts);
     if (queryParts.isEmpty()) {
         return false;
     }
 
     m_currentWord = queryParts.last();
     m_currentQuery = query;
 
     //asked for a dictionary?
     if (queryParts.count() > 1) {
         setDict(queryParts[queryParts.count()-2]);
     //default to wordnet
     } else {
         setDict(QStringLiteral("wn"));
     }
 
     //asked for a server?
     if (queryParts.count() > 2) {
         setServer(queryParts[queryParts.count()-3]);
     //default to wordnet
     } else {
         setServer(QStringLiteral("dict.org"));
     }
 
     if (m_currentWord.simplified().isEmpty()) {
         setData(m_currentWord, m_dictName, QString());
     } else {
         setData(m_currentWord, m_dictName, QString());
         m_tcpSocket = new QTcpSocket(this);
         m_tcpSocket->abort();
         connect(m_tcpSocket, &QTcpSocket::disconnected, this, &DictEngine::socketClosed);
 
         if (m_currentWord == QLatin1String("list-dictionaries")) {
             connect(m_tcpSocket, &QTcpSocket::readyRead, this, &DictEngine::getDicts);
         } else {
             connect(m_tcpSocket, &QTcpSocket::readyRead, this, &DictEngine::getDefinition);
         }
 
         m_tcpSocket->connectToHost(m_serverName, 2628);
     }
 
     return true;
 }
 
 K_EXPORT_PLASMA_DATAENGINE_WITH_JSON(dict, DictEngine , "plasma-dataengine-dict.json")
 
 #include "dictengine.moc"