003f6dafc1225f7b14097f6f4e05578fe74ea051
[quassel.git] / src / core / core.cpp
1 /***************************************************************************
2  *   Copyright (C) 2005-09 by the Quassel Project                          *
3  *   devel@quassel-irc.org                                                 *
4  *                                                                         *
5  *   This program is free software; you can redistribute it and/or modify  *
6  *   it under the terms of the GNU General Public License as published by  *
7  *   the Free Software Foundation; either version 2 of the License, or     *
8  *   (at your option) version 3.                                           *
9  *                                                                         *
10  *   This program is distributed in the hope that it will be useful,       *
11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
13  *   GNU General Public License for more details.                          *
14  *                                                                         *
15  *   You should have received a copy of the GNU General Public License     *
16  *   along with this program; if not, write to the                         *
17  *   Free Software Foundation, Inc.,                                       *
18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
19  ***************************************************************************/
20
21 #include <QCoreApplication>
22
23 #include "core.h"
24 #include "coresession.h"
25 #include "coresettings.h"
26 #include "postgresqlstorage.h"
27 #include "quassel.h"
28 #include "signalproxy.h"
29 #include "sqlitestorage.h"
30 #include "network.h"
31 #include "logger.h"
32
33 #include "util.h"
34
35 // migration related
36 #include <QFile>
37 #ifdef Q_OS_WIN32
38 #  include <windows.h>
39 #else
40 #  include <termios.h>
41 #endif /* Q_OS_WIN32 */
42
43 Core *Core::instanceptr = 0;
44
45 Core *Core::instance() {
46   if(instanceptr) return instanceptr;
47   instanceptr = new Core();
48   instanceptr->init();
49   return instanceptr;
50 }
51
52 void Core::destroy() {
53   delete instanceptr;
54   instanceptr = 0;
55 }
56
57 Core::Core()
58   : _storage(0)
59 {
60   _startTime = QDateTime::currentDateTime().toUTC();  // for uptime :)
61
62   Quassel::loadTranslation(QLocale::system());
63
64   // FIXME: MIGRATION 0.3 -> 0.4: Move database and core config to new location
65   // Move settings, note this does not delete the old files
66 #ifdef Q_WS_MAC
67     QSettings newSettings("quassel-irc.org", "quasselcore");
68 #else
69
70 # ifdef Q_WS_WIN
71     QSettings::Format format = QSettings::IniFormat;
72 # else
73     QSettings::Format format = QSettings::NativeFormat;
74 # endif
75     QString newFilePath = Quassel::configDirPath() + "quasselcore"
76     + ((format == QSettings::NativeFormat) ? QLatin1String(".conf") : QLatin1String(".ini"));
77     QSettings newSettings(newFilePath, format);
78 #endif /* Q_WS_MAC */
79
80   if(newSettings.value("Config/Version").toUInt() == 0) {
81 #   ifdef Q_WS_MAC
82     QString org = "quassel-irc.org";
83 #   else
84     QString org = "Quassel Project";
85 #   endif
86     QSettings oldSettings(org, "Quassel Core");
87     if(oldSettings.allKeys().count()) {
88       qWarning() << "\n\n*** IMPORTANT: Config and data file locations have changed. Attempting to auto-migrate your core settings...";
89       foreach(QString key, oldSettings.allKeys())
90         newSettings.setValue(key, oldSettings.value(key));
91       newSettings.setValue("Config/Version", 1);
92       qWarning() << "*   Your core settings have been migrated to" << newSettings.fileName();
93
94 #ifndef Q_WS_MAC /* we don't need to move the db and cert for mac */
95 #ifdef Q_OS_WIN32
96       QString quasselDir = qgetenv("APPDATA") + "/quassel/";
97 #elif defined Q_WS_MAC
98       QString quasselDir = QDir::homePath() + "/Library/Application Support/Quassel/";
99 #else
100       QString quasselDir = QDir::homePath() + "/.quassel/";
101 #endif
102
103       QFileInfo info(Quassel::configDirPath() + "quassel-storage.sqlite");
104       if(!info.exists()) {
105       // move database, if we found it
106         QFile oldDb(quasselDir + "quassel-storage.sqlite");
107         if(oldDb.exists()) {
108           bool success = oldDb.rename(Quassel::configDirPath() + "quassel-storage.sqlite");
109           if(success)
110             qWarning() << "*   Your database has been moved to" << Quassel::configDirPath() + "quassel-storage.sqlite";
111           else
112             qWarning() << "!!! Moving your database has failed. Please move it manually into" << Quassel::configDirPath();
113         }
114       }
115       // move certificate
116       QFileInfo certInfo(quasselDir + "quasselCert.pem");
117       if(certInfo.exists()) {
118         QFile cert(quasselDir + "quasselCert.pem");
119         bool success = cert.rename(Quassel::configDirPath() + "quasselCert.pem");
120         if(success)
121           qWarning() << "*   Your certificate has been moved to" << Quassel::configDirPath() + "quasselCert.pem";
122         else
123           qWarning() << "!!! Moving your certificate has failed. Please move it manually into" << Quassel::configDirPath();
124       }
125 #endif /* !Q_WS_MAC */
126       qWarning() << "*** Migration completed.\n\n";
127     }
128   }
129   // MIGRATION end
130
131   // check settings version
132   // so far, we only have 1
133   CoreSettings s;
134   if(s.version() != 1) {
135     qCritical() << "Invalid core settings version, terminating!";
136     exit(EXIT_FAILURE);
137   }
138
139   registerStorageBackends();
140
141   connect(&_storageSyncTimer, SIGNAL(timeout()), this, SLOT(syncStorage()));
142   _storageSyncTimer.start(10 * 60 * 1000); // 10 minutes
143 }
144
145 void Core::init() {
146   CoreSettings cs;
147   _configured = initStorage(cs.storageSettings().toMap());
148
149   if(Quassel::isOptionSet("select-backend")) {
150     selectBackend(Quassel::optionValue("select-backend"));
151     exit(0);
152   }
153
154   if(!_configured) {
155     if(!_storageBackends.count()) {
156       qWarning() << qPrintable(tr("Could not initialize any storage backend! Exiting..."));
157       qWarning() << qPrintable(tr("Currently, Quassel supports SQLite3 and PostgreSQL. You need to build your\n"
158                                   "Qt library with the sqlite or postgres plugin enabled in order for quasselcore\n"
159                                   "to work."));
160       exit(1); // TODO make this less brutal (especially for mono client -> popup)
161     }
162     qWarning() << "Core is currently not configured! Please connect with a Quassel Client for basic setup.";
163   }
164
165   if(Quassel::isOptionSet("add-user")) {
166     createUser();
167     exit(0);
168   }
169
170   if(Quassel::isOptionSet("change-userpass")) {
171     changeUserPass(Quassel::optionValue("change-userpass"));
172     exit(0);
173   }
174
175   connect(&_server, SIGNAL(newConnection()), this, SLOT(incomingConnection()));
176   connect(&_v6server, SIGNAL(newConnection()), this, SLOT(incomingConnection()));
177   if(!startListening()) exit(1); // TODO make this less brutal
178 }
179
180 Core::~Core() {
181   foreach(QTcpSocket *socket, blocksizes.keys()) {
182     socket->disconnectFromHost();  // disconnect non authed clients
183   }
184   qDeleteAll(sessions);
185   qDeleteAll(_storageBackends);
186 }
187
188 /*** Session Restore ***/
189
190 void Core::saveState() {
191   CoreSettings s;
192   QVariantMap state;
193   QVariantList activeSessions;
194   foreach(UserId user, instance()->sessions.keys()) activeSessions << QVariant::fromValue<UserId>(user);
195   state["CoreStateVersion"] = 1;
196   state["ActiveSessions"] = activeSessions;
197   s.setCoreState(state);
198 }
199
200 void Core::restoreState() {
201   if(!instance()->_configured) {
202     // qWarning() << qPrintable(tr("Cannot restore a state for an unconfigured core!"));
203     return;
204   }
205   if(instance()->sessions.count()) {
206     qWarning() << qPrintable(tr("Calling restoreState() even though active sessions exist!"));
207     return;
208   }
209   CoreSettings s;
210   /* We don't check, since we are at the first version since switching to Git
211   uint statever = s.coreState().toMap()["CoreStateVersion"].toUInt();
212   if(statever < 1) {
213     qWarning() << qPrintable(tr("Core state too old, ignoring..."));
214     return;
215   }
216   */
217   QVariantList activeSessions = s.coreState().toMap()["ActiveSessions"].toList();
218   if(activeSessions.count() > 0) {
219     quInfo() << "Restoring previous core state...";
220     foreach(QVariant v, activeSessions) {
221       UserId user = v.value<UserId>();
222       instance()->createSession(user, true);
223     }
224   }
225 }
226
227 /*** Core Setup ***/
228 QString Core::setupCoreForInternalUsage() {
229   Q_ASSERT(!_storageBackends.isEmpty());
230   QVariantMap setupData;
231   qsrand(QDateTime::currentDateTime().toTime_t());
232   int pass = 0;
233   for(int i = 0; i < 10; i++) {
234     pass *= 10;
235     pass += qrand() % 10;
236   }
237   setupData["AdminUser"] = "AdminUser";
238   setupData["AdminPasswd"] = QString::number(pass);
239   setupData["Backend"] = _storageBackends[_storageBackends.keys().first()]->displayName();
240   return setupCore(setupData);
241 }
242
243 QString Core::setupCore(QVariantMap setupData) {
244   QString user = setupData.take("AdminUser").toString();
245   QString password = setupData.take("AdminPasswd").toString();
246   if(user.isEmpty() || password.isEmpty()) {
247     return tr("Admin user or password not set.");
248   }
249   _configured = initStorage(setupData, true);
250   if(!_configured) {
251     return tr("Could not setup storage!");
252   }
253   CoreSettings s;
254   s.setStorageSettings(setupData);
255   quInfo() << qPrintable(tr("Creating admin user..."));
256   _storage->addUser(user, password);
257   startListening();  // TODO check when we need this
258   return QString();
259 }
260
261 /*** Storage Handling ***/
262 void Core::registerStorageBackends() {
263   // Register storage backends here!
264   registerStorageBackend(new SqliteStorage(this));
265   registerStorageBackend(new PostgreSqlStorage(this));
266 }
267
268 bool Core::registerStorageBackend(Storage *backend) {
269   if(backend->isAvailable()) {
270     _storageBackends[backend->displayName()] = backend;
271     return true;
272   } else {
273     backend->deleteLater();
274     return false;
275   }
276 }
277
278 void Core::unregisterStorageBackends() {
279   foreach(Storage *s, _storageBackends.values()) {
280     s->deleteLater();
281   }
282   _storageBackends.clear();
283 }
284
285 void Core::unregisterStorageBackend(Storage *backend) {
286   _storageBackends.remove(backend->displayName());
287   backend->deleteLater();
288 }
289
290 // old db settings:
291 // "Type" => "sqlite"
292 bool Core::initStorage(const QString &backend, QVariantMap settings, bool setup) {
293   _storage = 0;
294
295   if(backend.isEmpty()) {
296     return false;
297   }
298
299   Storage *storage = 0;
300   if(_storageBackends.contains(backend)) {
301     storage = _storageBackends[backend];
302   } else {
303     qCritical() << "Selected storage backend is not available:" << backend;
304     return false;
305   }
306
307   Storage::State storageState = storage->init(settings);
308   switch(storageState) {
309   case Storage::NeedsSetup:
310     if(!setup)
311       return false; // trigger setup process
312     if(storage->setup(settings))
313       return initStorage(backend, settings, false);
314     // if setup wasn't successfull we mark the backend as unavailable
315   case Storage::NotAvailable:
316     qCritical() << "Selected storage backend is not available:" << backend;
317     storage->deleteLater();
318     _storageBackends.remove(backend);
319     storage = 0;
320     return false;
321   case Storage::IsReady:
322     // delete all other backends
323     _storageBackends.remove(backend);
324     unregisterStorageBackends();
325     connect(storage, SIGNAL(bufferInfoUpdated(UserId, const BufferInfo &)), this, SIGNAL(bufferInfoUpdated(UserId, const BufferInfo &)));
326   }
327   _storage = storage;
328   return true;
329 }
330
331 bool Core::initStorage(QVariantMap dbSettings, bool setup) {
332   return initStorage(dbSettings["Backend"].toString(), dbSettings["ConnectionProperties"].toMap(), setup);
333 }
334
335
336 void Core::syncStorage() {
337   if(_storage)
338     _storage->sync();
339 }
340
341 /*** Storage Access ***/
342 bool Core::createNetwork(UserId user, NetworkInfo &info) {
343   NetworkId networkId = instance()->_storage->createNetwork(user, info);
344   if(!networkId.isValid())
345     return false;
346
347   info.networkId = networkId;
348   return true;
349 }
350
351 /*** Network Management ***/
352
353 bool Core::startListening() {
354   // in mono mode we only start a local port if a port is specified in the cli call
355   if(Quassel::runMode() == Quassel::Monolithic && !Quassel::isOptionSet("port"))
356     return true;
357
358   bool success = false;
359   uint port = Quassel::optionValue("port").toUInt();
360
361   const QString listen = Quassel::optionValue("listen");
362   const QStringList listen_list = listen.split(",", QString::SkipEmptyParts);
363   if(listen_list.size() > 0) {
364     foreach (const QString listen_term, listen_list) {  // TODO: handle multiple interfaces for same TCP version gracefully
365       QHostAddress addr;
366       if(!addr.setAddress(listen_term)) {
367         qCritical() << qPrintable(
368           tr("Invalid listen address %1")
369             .arg(listen_term)
370         );
371       } else {
372         switch(addr.protocol()) {
373           case QAbstractSocket::IPv4Protocol:
374             if(_server.listen(addr, port)) {
375               quInfo() << qPrintable(
376                 tr("Listening for GUI clients on IPv4 %1 port %2 using protocol version %3")
377                   .arg(addr.toString())
378                   .arg(_server.serverPort())
379                   .arg(Quassel::buildInfo().protocolVersion)
380               );
381               success = true;
382             } else
383               quWarning() << qPrintable(
384                 tr("Could not open IPv4 interface %1:%2: %3")
385                   .arg(addr.toString())
386                   .arg(port)
387                   .arg(_server.errorString()));
388             break;
389           case QAbstractSocket::IPv6Protocol:
390             if(_v6server.listen(addr, port)) {
391               quInfo() << qPrintable(
392                 tr("Listening for GUI clients on IPv6 %1 port %2 using protocol version %3")
393                   .arg(addr.toString())
394                   .arg(_v6server.serverPort())
395                   .arg(Quassel::buildInfo().protocolVersion)
396               );
397               success = true;
398             } else {
399               // if v4 succeeded on Any, the port will be already in use - don't display the error then
400               // FIXME: handle this more sanely, make sure we can listen to both v4 and v6 by default!
401               if(!success || _v6server.serverError() != QAbstractSocket::AddressInUseError)
402                 quWarning() << qPrintable(
403                   tr("Could not open IPv6 interface %1:%2: %3")
404                   .arg(addr.toString())
405                   .arg(port)
406                   .arg(_v6server.errorString()));
407             }
408             break;
409           default:
410             qCritical() << qPrintable(
411               tr("Invalid listen address %1, unknown network protocol")
412                   .arg(listen_term)
413             );
414             break;
415         }
416       }
417     }
418   }
419   if(!success)
420     quError() << qPrintable(tr("Could not open any network interfaces to listen on!"));
421
422   return success;
423 }
424
425 void Core::stopListening(const QString &reason) {
426   bool wasListening = false;
427   if(_server.isListening()) {
428     wasListening = true;
429     _server.close();
430   }
431   if(_v6server.isListening()) {
432     wasListening = true;
433     _v6server.close();
434   }
435   if(wasListening) {
436     if(reason.isEmpty())
437       quInfo() << "No longer listening for GUI clients.";
438     else
439       quInfo() << qPrintable(reason);
440   }
441 }
442
443 void Core::incomingConnection() {
444   QTcpServer *server = qobject_cast<QTcpServer *>(sender());
445   Q_ASSERT(server);
446   while(server->hasPendingConnections()) {
447     QTcpSocket *socket = server->nextPendingConnection();
448     connect(socket, SIGNAL(disconnected()), this, SLOT(clientDisconnected()));
449     connect(socket, SIGNAL(readyRead()), this, SLOT(clientHasData()));
450     connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(socketError(QAbstractSocket::SocketError)));
451
452     QVariantMap clientInfo;
453     blocksizes.insert(socket, (quint32)0);
454     quInfo() << qPrintable(tr("Client connected from"))  << qPrintable(socket->peerAddress().toString());
455
456     if(!_configured) {
457       stopListening(tr("Closing server for basic setup."));
458     }
459   }
460 }
461
462 void Core::clientHasData() {
463   QTcpSocket *socket = dynamic_cast<QTcpSocket*>(sender());
464   Q_ASSERT(socket && blocksizes.contains(socket));
465   QVariant item;
466   while(SignalProxy::readDataFromDevice(socket, blocksizes[socket], item)) {
467     QVariantMap msg = item.toMap();
468     processClientMessage(socket, msg);
469     if(!blocksizes.contains(socket)) break;  // this socket is no longer ours to handle!
470   }
471 }
472
473 void Core::processClientMessage(QTcpSocket *socket, const QVariantMap &msg) {
474   if(!msg.contains("MsgType")) {
475     // Client is way too old, does not even use the current init format
476     qWarning() << qPrintable(tr("Antique client trying to connect... refusing."));
477     socket->close();
478     return;
479   }
480   // OK, so we have at least an init message format we can understand
481   if(msg["MsgType"] == "ClientInit") {
482     QVariantMap reply;
483
484     // Just version information -- check it!
485     uint ver = msg["ProtocolVersion"].toUInt();
486     if(ver < Quassel::buildInfo().coreNeedsProtocol) {
487       reply["MsgType"] = "ClientInitReject";
488       reply["Error"] = tr("<b>Your Quassel Client is too old!</b><br>"
489       "This core needs at least client/core protocol version %1.<br>"
490       "Please consider upgrading your client.").arg(Quassel::buildInfo().coreNeedsProtocol);
491       SignalProxy::writeDataToDevice(socket, reply);
492       qWarning() << qPrintable(tr("Client")) << qPrintable(socket->peerAddress().toString()) << qPrintable(tr("too old, rejecting."));
493       socket->close(); return;
494     }
495
496     reply["CoreVersion"] = Quassel::buildInfo().fancyVersionString;
497     reply["CoreDate"] = Quassel::buildInfo().buildDate;
498     reply["ProtocolVersion"] = Quassel::buildInfo().protocolVersion;
499     // TODO: Make the core info configurable
500     int uptime = startTime().secsTo(QDateTime::currentDateTime().toUTC());
501     int updays = uptime / 86400; uptime %= 86400;
502     int uphours = uptime / 3600; uptime %= 3600;
503     int upmins = uptime / 60;
504     reply["CoreInfo"] = tr("<b>Quassel Core Version %1</b><br>"
505                            "Built: %2<br>"
506                            "Up %3d%4h%5m (since %6)").arg(Quassel::buildInfo().fancyVersionString)
507                                                      .arg(Quassel::buildInfo().buildDate)
508       .arg(updays).arg(uphours,2,10,QChar('0')).arg(upmins,2,10,QChar('0')).arg(startTime().toString(Qt::TextDate));
509
510 #ifdef HAVE_SSL
511     SslServer *sslServer = qobject_cast<SslServer *>(&_server);
512     QSslSocket *sslSocket = qobject_cast<QSslSocket *>(socket);
513     bool supportSsl = (bool)sslServer && (bool)sslSocket && sslServer->isCertValid();
514 #else
515     bool supportSsl = false;
516 #endif
517
518 #ifndef QT_NO_COMPRESS
519     bool supportsCompression = true;
520 #else
521     bool supportsCompression = false;
522 #endif
523
524     reply["SupportSsl"] = supportSsl;
525     reply["SupportsCompression"] = supportsCompression;
526     // switch to ssl/compression after client has been informed about our capabilities (see below)
527
528     reply["LoginEnabled"] = true;
529
530     // check if we are configured, start wizard otherwise
531     if(!_configured) {
532       reply["Configured"] = false;
533       QList<QVariant> backends;
534       foreach(Storage *backend, _storageBackends.values()) {
535         QVariantMap v;
536         v["DisplayName"] = backend->displayName();
537         v["Description"] = backend->description();
538         v["SetupKeys"] = backend->setupKeys();
539         v["SetupDefaults"] = backend->setupDefaults();
540         backends.append(v);
541       }
542       reply["StorageBackends"] = backends;
543       reply["LoginEnabled"] = false;
544     } else {
545       reply["Configured"] = true;
546     }
547     clientInfo[socket] = msg; // store for future reference
548     reply["MsgType"] = "ClientInitAck";
549     SignalProxy::writeDataToDevice(socket, reply);
550
551 #ifdef HAVE_SSL
552     // after we told the client that we are ssl capable we switch to ssl mode
553     if(supportSsl && msg["UseSsl"].toBool()) {
554       qDebug() << qPrintable(tr("Starting TLS for Client:"))  << qPrintable(socket->peerAddress().toString());
555       connect(sslSocket, SIGNAL(sslErrors(const QList<QSslError> &)), this, SLOT(sslErrors(const QList<QSslError> &)));
556       sslSocket->startServerEncryption();
557     }
558 #endif
559
560 #ifndef QT_NO_COMPRESS
561     if(supportsCompression && msg["UseCompression"].toBool()) {
562       socket->setProperty("UseCompression", true);
563       qDebug() << "Using compression for Client:" << qPrintable(socket->peerAddress().toString());
564     }
565 #endif
566
567   } else {
568     // for the rest, we need an initialized connection
569     if(!clientInfo.contains(socket)) {
570       QVariantMap reply;
571       reply["MsgType"] = "ClientLoginReject";
572       reply["Error"] = tr("<b>Client not initialized!</b><br>You need to send an init message before trying to login.");
573       SignalProxy::writeDataToDevice(socket, reply);
574       qWarning() << qPrintable(tr("Client")) << qPrintable(socket->peerAddress().toString()) << qPrintable(tr("did not send an init message before trying to login, rejecting."));
575       socket->close(); return;
576     }
577     if(msg["MsgType"] == "CoreSetupData") {
578       QVariantMap reply;
579       QString result = setupCore(msg["SetupData"].toMap());
580       if(!result.isEmpty()) {
581         reply["MsgType"] = "CoreSetupReject";
582         reply["Error"] = result;
583       } else {
584         reply["MsgType"] = "CoreSetupAck";
585       }
586       SignalProxy::writeDataToDevice(socket, reply);
587     } else if(msg["MsgType"] == "ClientLogin") {
588       QVariantMap reply;
589       UserId uid = _storage->validateUser(msg["User"].toString(), msg["Password"].toString());
590       if(uid == 0) {
591         reply["MsgType"] = "ClientLoginReject";
592         reply["Error"] = tr("<b>Invalid username or password!</b><br>The username/password combination you supplied could not be found in the database.");
593         SignalProxy::writeDataToDevice(socket, reply);
594         return;
595       }
596       reply["MsgType"] = "ClientLoginAck";
597       SignalProxy::writeDataToDevice(socket, reply);
598       quInfo() << qPrintable(tr("Client")) << qPrintable(socket->peerAddress().toString()) << qPrintable(tr("initialized and authenticated successfully as \"%1\" (UserId: %2).").arg(msg["User"].toString()).arg(uid.toInt()));
599       setupClientSession(socket, uid);
600     }
601   }
602 }
603
604 // Potentially called during the initialization phase (before handing the connection off to the session)
605 void Core::clientDisconnected() {
606   QTcpSocket *socket = qobject_cast<QTcpSocket *>(sender());
607   if(socket) {
608     // here it's safe to call methods on socket!
609     quInfo() << qPrintable(tr("Non-authed client disconnected.")) << qPrintable(socket->peerAddress().toString());
610     blocksizes.remove(socket);
611     clientInfo.remove(socket);
612     socket->deleteLater();
613   } else {
614     // we have to crawl through the hashes and see if we find a victim to remove
615     qDebug() << qPrintable(tr("Non-authed client disconnected. (socket allready destroyed)"));
616
617     // DO NOT CALL ANY METHODS ON socket!!
618     socket = static_cast<QTcpSocket *>(sender());
619
620     QHash<QTcpSocket *, quint32>::iterator blockSizeIter = blocksizes.begin();
621     while(blockSizeIter != blocksizes.end()) {
622       if(blockSizeIter.key() == socket) {
623         blockSizeIter = blocksizes.erase(blockSizeIter);
624       } else {
625         blockSizeIter++;
626       }
627     }
628
629     QHash<QTcpSocket *, QVariantMap>::iterator clientInfoIter = clientInfo.begin();
630     while(clientInfoIter != clientInfo.end()) {
631       if(clientInfoIter.key() == socket) {
632         clientInfoIter = clientInfo.erase(clientInfoIter);
633       } else {
634         clientInfoIter++;
635       }
636     }
637   }
638
639
640   // make server listen again if still not configured
641   if (!_configured) {
642     startListening();
643   }
644
645   // TODO remove unneeded sessions - if necessary/possible...
646   // Suggestion: kill sessions if they are not connected to any network and client.
647 }
648
649 void Core::setupClientSession(QTcpSocket *socket, UserId uid) {
650   // Find or create session for validated user
651   SessionThread *sess;
652   if(sessions.contains(uid)) sess = sessions[uid];
653   else sess = createSession(uid);
654   // Hand over socket, session then sends state itself
655   disconnect(socket, 0, this, 0);
656   blocksizes.remove(socket);
657   clientInfo.remove(socket);
658   if(!sess) {
659     qWarning() << qPrintable(tr("Could not initialize session for client:")) << qPrintable(socket->peerAddress().toString());
660     socket->close();
661   }
662   sess->addClient(socket);
663 }
664
665 void Core::setupInternalClientSession(SignalProxy *proxy) {
666   if(!_configured) {
667     stopListening();
668     setupCoreForInternalUsage();
669   }
670
671   UserId uid = _storage->internalUser();
672
673   // Find or create session for validated user
674   SessionThread *sess;
675   if(sessions.contains(uid))
676     sess = sessions[uid];
677   else
678     sess = createSession(uid);
679   sess->addClient(proxy);
680 }
681
682 SessionThread *Core::createSession(UserId uid, bool restore) {
683   if(sessions.contains(uid)) {
684     qWarning() << "Calling createSession() when a session for the user already exists!";
685     return 0;
686   }
687   SessionThread *sess = new SessionThread(uid, restore, this);
688   sessions[uid] = sess;
689   sess->start();
690   return sess;
691 }
692
693 #ifdef HAVE_SSL
694 void Core::sslErrors(const QList<QSslError> &errors) {
695   Q_UNUSED(errors);
696   QSslSocket *socket = qobject_cast<QSslSocket *>(sender());
697   if(socket)
698     socket->ignoreSslErrors();
699 }
700 #endif
701
702 void Core::socketError(QAbstractSocket::SocketError err) {
703   QAbstractSocket *socket = qobject_cast<QAbstractSocket *>(sender());
704   if(socket && err != QAbstractSocket::RemoteHostClosedError)
705     qWarning() << "Core::socketError()" << socket << err << socket->errorString();
706 }
707
708 // migration / backend selection
709 bool Core::selectBackend(const QString &backend) {
710   // reregister all storage backends
711   registerStorageBackends();
712   if(!_storageBackends.contains(backend)) {
713     qWarning() << qPrintable(QString("Core::selectBackend(): unsupported backend: %1").arg(backend));
714     qWarning() << "    supported backends are:" << qPrintable(QStringList(_storageBackends.keys()).join(", "));
715     return false;
716   }
717
718   Storage *storage = _storageBackends[backend];
719   QVariantMap settings = promptForSettings(storage);
720
721   Storage::State storageState = storage->init(settings);
722   switch(storageState) {
723   case Storage::IsReady:
724     saveBackendSettings(backend, settings);
725     qWarning() << "Switched backend to:" << qPrintable(backend);
726     qWarning() << "Backend already initialized. Skipping Migration";
727     return true;
728   case Storage::NotAvailable:
729     qCritical() << "Backend is not available:" << qPrintable(backend);
730     return false;
731   case Storage::NeedsSetup:
732     if(!storage->setup(settings)) {
733       qWarning() << qPrintable(QString("Core::selectBackend(): unable to setup backend: %1").arg(backend));
734       return false;
735     }
736
737     if(storage->init(settings) != Storage::IsReady) {
738       qWarning() << qPrintable(QString("Core::migrateBackend(): unable to initialize backend: %1").arg(backend));
739       return false;
740     }
741
742     saveBackendSettings(backend, settings);
743     qWarning() << "Switched backend to:" << qPrintable(backend);
744     break;
745   }
746
747   // let's see if we have a current storage object we can migrate from
748   AbstractSqlMigrationReader *reader = getMigrationReader(_storage);
749   AbstractSqlMigrationWriter *writer = getMigrationWriter(storage);
750   if(reader && writer) {
751     qDebug() << qPrintable(QString("Migrating Storage backend %1 to %2...").arg(_storage->displayName(), storage->displayName()));
752     delete _storage;
753     _storage = 0;
754     delete storage;
755     storage = 0;
756     if(reader->migrateTo(writer)) {
757       qDebug() << "Migration finished!";
758       saveBackendSettings(backend, settings);
759       return true;
760     }
761     return false;
762     qWarning() << qPrintable(QString("Core::migrateDb(): unable to migrate storage backend! (No migration writer for %1)").arg(backend));
763   }
764
765   // inform the user why we cannot merge
766   if(!_storage) {
767     qWarning() << "No currently active backend. Skipping migration.";
768   } else if(!reader) {
769     qWarning() << "Currently active backend does not support migration:" << qPrintable(_storage->displayName());
770   }
771   if(writer) {
772     qWarning() << "New backend does not support migration:" << qPrintable(backend);
773   }
774
775   // so we were unable to merge, but let's create a user \o/
776   _storage = storage;
777   createUser();
778   return true;
779 }
780
781 void Core::createUser() {
782   QTextStream out(stdout);
783   QTextStream in(stdin);
784   out << "Add a new user:" << endl;
785   out << "Username: ";
786   out.flush();
787   QString username = in.readLine().trimmed();
788
789   disableStdInEcho();
790   out << "Password: ";
791   out.flush();
792   QString password = in.readLine().trimmed();
793   out << endl;
794   out << "Repeat Password: ";
795   out.flush();
796   QString password2 = in.readLine().trimmed();
797   out << endl;
798   enableStdInEcho();
799
800   if(password != password2) {
801     qWarning() << "Passwords don't match!";
802     return;
803   }
804   if(password.isEmpty()) {
805     qWarning() << "Password is empty!";
806     return;
807   }
808
809   if(_storage->addUser(username, password).isValid()) {
810     out << "Added user " << username << " successfully!" << endl;
811   } else {
812     qWarning() << "Unable to add user:" << qPrintable(username);
813   }
814 }
815
816 void Core::changeUserPass(const QString &username) {
817   QTextStream out(stdout);
818   QTextStream in(stdin);
819   UserId userId = _storage->getUserId(username);
820   if(!userId.isValid()) {
821     out << "User " << username << " does not exist." << endl;
822     return;
823   }
824
825   out << "Change password for user: " << username << endl;
826
827   disableStdInEcho();
828   out << "New Password: ";
829   out.flush();
830   QString password = in.readLine().trimmed();
831   out << endl;
832   out << "Repeat Password: ";
833   out.flush();
834   QString password2 = in.readLine().trimmed();
835   out << endl;
836   enableStdInEcho();
837
838   if(password != password2) {
839     qWarning() << "Passwords don't match!";
840     return;
841   }
842   if(password.isEmpty()) {
843     qWarning() << "Password is empty!";
844     return;
845   }
846
847   if(_storage->updateUser(userId, password)) {
848     out << "Password changed successfuly!" << endl;
849   } else {
850     qWarning() << "Failed to change password!";
851   }
852 }
853
854 AbstractSqlMigrationReader *Core::getMigrationReader(Storage *storage) {
855   if(!storage)
856     return 0;
857
858   AbstractSqlStorage *sqlStorage = qobject_cast<AbstractSqlStorage *>(storage);
859   if(!sqlStorage) {
860     qDebug() << "Core::migrateDb(): only SQL based backends can be migrated!";
861     return 0;
862   }
863
864   return sqlStorage->createMigrationReader();
865 }
866
867 AbstractSqlMigrationWriter *Core::getMigrationWriter(Storage *storage) {
868   if(!storage)
869     return 0;
870
871   AbstractSqlStorage *sqlStorage = qobject_cast<AbstractSqlStorage *>(storage);
872   if(!sqlStorage) {
873     qDebug() << "Core::migrateDb(): only SQL based backends can be migrated!";
874     return 0;
875   }
876
877   return sqlStorage->createMigrationWriter();
878 }
879
880 void Core::saveBackendSettings(const QString &backend, const QVariantMap &settings) {
881   QVariantMap dbsettings;
882   dbsettings["Backend"] = backend;
883   dbsettings["ConnectionProperties"] = settings;
884   CoreSettings().setStorageSettings(dbsettings);
885 }
886
887 QVariantMap Core::promptForSettings(const Storage *storage) {
888   QVariantMap settings;
889
890   QStringList keys = storage->setupKeys();
891   if(keys.isEmpty())
892     return settings;
893
894   QTextStream out(stdout);
895   QTextStream in(stdin);
896   out << "Default values are in brackets" << endl;
897
898   QVariantMap defaults = storage->setupDefaults();
899   QString value;
900   foreach(QString key, keys) {
901     QVariant val;
902     if(defaults.contains(key)) {
903       val = defaults[key];
904     }
905     out << key;
906     if(!val.toString().isEmpty()) {
907       out << " (" << val.toString() << ")";
908     }
909     out << ": ";
910     out.flush();
911
912     bool noEcho = QString("password").toLower().startsWith(key.toLower());
913     if(noEcho) {
914       disableStdInEcho();
915     }
916     value = in.readLine().trimmed();
917     if(noEcho) {
918       out << endl;
919       enableStdInEcho();
920     }
921
922     if(!value.isEmpty()) {
923       switch(defaults[key].type()) {
924       case QVariant::Int:
925         val = QVariant(value.toInt());
926         break;
927       default:
928         val = QVariant(value);
929       }
930     }
931     settings[key] = val;
932   }
933   return settings;
934 }
935
936
937 #ifdef Q_OS_WIN32
938 void Core::stdInEcho(bool on) {
939   HANDLE hStdin = GetStdHandle(STD_INPUT_HANDLE);
940   DWORD mode = 0;
941   GetConsoleMode(hStdin, &mode);
942   if(on)
943     mode |= ENABLE_ECHO_INPUT;
944   else
945     mode &= ~ENABLE_ECHO_INPUT;
946   SetConsoleMode(hStdin, mode);
947 }
948 #else
949 void Core::stdInEcho(bool on) {
950   termios t;
951   tcgetattr(STDIN_FILENO, &t);
952   if(on)
953     t.c_lflag |= ECHO;
954   else
955     t.c_lflag &= ~ECHO;
956   tcsetattr(STDIN_FILENO, TCSANOW, &t);
957 }
958 #endif /* Q_OS_WIN32 */