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