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     socket->flush(); // ensure that the write cache is flushed before we switch to ssl
 551
 552 #ifdef HAVE_SSL
 553     // after we told the client that we are ssl capable we switch to ssl mode
 554     if(supportSsl && msg["UseSsl"].toBool()) {
 555       qDebug() << qPrintable(tr("Starting TLS for Client:"))  << qPrintable(socket->peerAddress().toString());
 556       connect(sslSocket, SIGNAL(sslErrors(const QList<QSslError> &)), this, SLOT(sslErrors(const QList<QSslError> &)));
 557       sslSocket->startServerEncryption();
 558     }
 559 #endif
 560
 561 #ifndef QT_NO_COMPRESS
 562     if(supportsCompression && msg["UseCompression"].toBool()) {
 563       socket->setProperty("UseCompression", true);
 564       qDebug() << "Using compression for Client:" << qPrintable(socket->peerAddress().toString());
 565     }
 566 #endif
 567
 568   } else {
 569     // for the rest, we need an initialized connection
 570     if(!clientInfo.contains(socket)) {
 571       QVariantMap reply;
 572       reply["MsgType"] = "ClientLoginReject";
 573       reply["Error"] = tr("<b>Client not initialized!</b><br>You need to send an init message before trying to login.");
 574       SignalProxy::writeDataToDevice(socket, reply);
 575       qWarning() << qPrintable(tr("Client")) << qPrintable(socket->peerAddress().toString()) << qPrintable(tr("did not send an init message before trying to login, rejecting."));
 576       socket->close(); return;
 577     }
 578     if(msg["MsgType"] == "CoreSetupData") {
 579       QVariantMap reply;
 580       QString result = setupCore(msg["SetupData"].toMap());
 581       if(!result.isEmpty()) {
 582         reply["MsgType"] = "CoreSetupReject";
 583         reply["Error"] = result;
 584       } else {
 585         reply["MsgType"] = "CoreSetupAck";
 586       }
 587       SignalProxy::writeDataToDevice(socket, reply);
 588     } else if(msg["MsgType"] == "ClientLogin") {
 589       QVariantMap reply;
 590       UserId uid = _storage->validateUser(msg["User"].toString(), msg["Password"].toString());
 591       if(uid == 0) {
 592         reply["MsgType"] = "ClientLoginReject";
 593         reply["Error"] = tr("<b>Invalid username or password!</b><br>The username/password combination you supplied could not be found in the database.");
 594         SignalProxy::writeDataToDevice(socket, reply);
 595         return;
 596       }
 597       reply["MsgType"] = "ClientLoginAck";
 598       SignalProxy::writeDataToDevice(socket, reply);
 599       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()));
 600       setupClientSession(socket, uid);
 601     }
 602   }
 603 }
 604
 605 // Potentially called during the initialization phase (before handing the connection off to the session)
 606 void Core::clientDisconnected() {
 607   QTcpSocket *socket = qobject_cast<QTcpSocket *>(sender());
 608   if(socket) {
 609     // here it's safe to call methods on socket!
 610     quInfo() << qPrintable(tr("Non-authed client disconnected.")) << qPrintable(socket->peerAddress().toString());
 611     blocksizes.remove(socket);
 612     clientInfo.remove(socket);
 613     socket->deleteLater();
 614   } else {
 615     // we have to crawl through the hashes and see if we find a victim to remove
 616     qDebug() << qPrintable(tr("Non-authed client disconnected. (socket allready destroyed)"));
 617
 618     // DO NOT CALL ANY METHODS ON socket!!
 619     socket = static_cast<QTcpSocket *>(sender());
 620
 621     QHash<QTcpSocket *, quint32>::iterator blockSizeIter = blocksizes.begin();
 622     while(blockSizeIter != blocksizes.end()) {
 623       if(blockSizeIter.key() == socket) {
 624         blockSizeIter = blocksizes.erase(blockSizeIter);
 625       } else {
 626         blockSizeIter++;
 627       }
 628     }
 629
 630     QHash<QTcpSocket *, QVariantMap>::iterator clientInfoIter = clientInfo.begin();
 631     while(clientInfoIter != clientInfo.end()) {
 632       if(clientInfoIter.key() == socket) {
 633         clientInfoIter = clientInfo.erase(clientInfoIter);
 634       } else {
 635         clientInfoIter++;
 636       }
 637     }
 638   }
 639
 640
 641   // make server listen again if still not configured
 642   if (!_configured) {
 643     startListening();
 644   }
 645
 646   // TODO remove unneeded sessions - if necessary/possible...
 647   // Suggestion: kill sessions if they are not connected to any network and client.
 648 }
 649
 650 void Core::setupClientSession(QTcpSocket *socket, UserId uid) {
 651   // Find or create session for validated user
 652   SessionThread *sess;
 653   if(sessions.contains(uid)) sess = sessions[uid];
 654   else sess = createSession(uid);
 655   // Hand over socket, session then sends state itself
 656   disconnect(socket, 0, this, 0);
 657   socket->flush(); // ensure that the write cache is flushed before we hand over the connection to another thread.
 658   blocksizes.remove(socket);
 659   clientInfo.remove(socket);
 660   if(!sess) {
 661     qWarning() << qPrintable(tr("Could not initialize session for client:")) << qPrintable(socket->peerAddress().toString());
 662     socket->close();
 663   }
 664   sess->addClient(socket);
 665 }
 666
 667 void Core::setupInternalClientSession(SignalProxy *proxy) {
 668   if(!_configured) {
 669     stopListening();
 670     setupCoreForInternalUsage();
 671   }
 672
 673   UserId uid;
 674   if(_storage) {
 675     uid = _storage->internalUser();
 676   } else {
 677     qWarning() << "Core::setupInternalClientSession(): You're trying to run monolithic Quassel with an unusable Backend! Go fix it!";
 678     return;
 679   }
 680
 681   // Find or create session for validated user
 682   SessionThread *sess;
 683   if(sessions.contains(uid))
 684     sess = sessions[uid];
 685   else
 686     sess = createSession(uid);
 687   sess->addClient(proxy);
 688 }
 689
 690 SessionThread *Core::createSession(UserId uid, bool restore) {
 691   if(sessions.contains(uid)) {
 692     qWarning() << "Calling createSession() when a session for the user already exists!";
 693     return 0;
 694   }
 695   SessionThread *sess = new SessionThread(uid, restore, this);
 696   sessions[uid] = sess;
 697   sess->start();
 698   return sess;
 699 }
 700
 701 #ifdef HAVE_SSL
 702 void Core::sslErrors(const QList<QSslError> &errors) {
 703   Q_UNUSED(errors);
 704   QSslSocket *socket = qobject_cast<QSslSocket *>(sender());
 705   if(socket)
 706     socket->ignoreSslErrors();
 707 }
 708 #endif
 709
 710 void Core::socketError(QAbstractSocket::SocketError err) {
 711   QAbstractSocket *socket = qobject_cast<QAbstractSocket *>(sender());
 712   if(socket && err != QAbstractSocket::RemoteHostClosedError)
 713     qWarning() << "Core::socketError()" << socket << err << socket->errorString();
 714 }
 715
 716 // migration / backend selection
 717 bool Core::selectBackend(const QString &backend) {
 718   // reregister all storage backends
 719   registerStorageBackends();
 720   if(!_storageBackends.contains(backend)) {
 721     qWarning() << qPrintable(QString("Core::selectBackend(): unsupported backend: %1").arg(backend));
 722     qWarning() << "    supported backends are:" << qPrintable(QStringList(_storageBackends.keys()).join(", "));
 723     return false;
 724   }
 725
 726   Storage *storage = _storageBackends[backend];
 727   QVariantMap settings = promptForSettings(storage);
 728
 729   Storage::State storageState = storage->init(settings);
 730   switch(storageState) {
 731   case Storage::IsReady:
 732     saveBackendSettings(backend, settings);
 733     qWarning() << "Switched backend to:" << qPrintable(backend);
 734     qWarning() << "Backend already initialized. Skipping Migration";
 735     return true;
 736   case Storage::NotAvailable:
 737     qCritical() << "Backend is not available:" << qPrintable(backend);
 738     return false;
 739   case Storage::NeedsSetup:
 740     if(!storage->setup(settings)) {
 741       qWarning() << qPrintable(QString("Core::selectBackend(): unable to setup backend: %1").arg(backend));
 742       return false;
 743     }
 744
 745     if(storage->init(settings) != Storage::IsReady) {
 746       qWarning() << qPrintable(QString("Core::migrateBackend(): unable to initialize backend: %1").arg(backend));
 747       return false;
 748     }
 749
 750     saveBackendSettings(backend, settings);
 751     qWarning() << "Switched backend to:" << qPrintable(backend);
 752     break;
 753   }
 754
 755   // let's see if we have a current storage object we can migrate from
 756   AbstractSqlMigrationReader *reader = getMigrationReader(_storage);
 757   AbstractSqlMigrationWriter *writer = getMigrationWriter(storage);
 758   if(reader && writer) {
 759     qDebug() << qPrintable(QString("Migrating Storage backend %1 to %2...").arg(_storage->displayName(), storage->displayName()));
 760     delete _storage;
 761     _storage = 0;
 762     delete storage;
 763     storage = 0;
 764     if(reader->migrateTo(writer)) {
 765       qDebug() << "Migration finished!";
 766       saveBackendSettings(backend, settings);
 767       return true;
 768     }
 769     return false;
 770     qWarning() << qPrintable(QString("Core::migrateDb(): unable to migrate storage backend! (No migration writer for %1)").arg(backend));
 771   }
 772
 773   // inform the user why we cannot merge
 774   if(!_storage) {
 775     qWarning() << "No currently active backend. Skipping migration.";
 776   } else if(!reader) {
 777     qWarning() << "Currently active backend does not support migration:" << qPrintable(_storage->displayName());
 778   }
 779   if(writer) {
 780     qWarning() << "New backend does not support migration:" << qPrintable(backend);
 781   }
 782
 783   // so we were unable to merge, but let's create a user \o/
 784   _storage = storage;
 785   createUser();
 786   return true;
 787 }
 788
 789 void Core::createUser() {
 790   QTextStream out(stdout);
 791   QTextStream in(stdin);
 792   out << "Add a new user:" << endl;
 793   out << "Username: ";
 794   out.flush();
 795   QString username = in.readLine().trimmed();
 796
 797   disableStdInEcho();
 798   out << "Password: ";
 799   out.flush();
 800   QString password = in.readLine().trimmed();
 801   out << endl;
 802   out << "Repeat Password: ";
 803   out.flush();
 804   QString password2 = in.readLine().trimmed();
 805   out << endl;
 806   enableStdInEcho();
 807
 808   if(password != password2) {
 809     qWarning() << "Passwords don't match!";
 810     return;
 811   }
 812   if(password.isEmpty()) {
 813     qWarning() << "Password is empty!";
 814     return;
 815   }
 816
 817   if(_storage->addUser(username, password).isValid()) {
 818     out << "Added user " << username << " successfully!" << endl;
 819   } else {
 820     qWarning() << "Unable to add user:" << qPrintable(username);
 821   }
 822 }
 823
 824 void Core::changeUserPass(const QString &username) {
 825   QTextStream out(stdout);
 826   QTextStream in(stdin);
 827   UserId userId = _storage->getUserId(username);
 828   if(!userId.isValid()) {
 829     out << "User " << username << " does not exist." << endl;
 830     return;
 831   }
 832
 833   out << "Change password for user: " << username << endl;
 834
 835   disableStdInEcho();
 836   out << "New Password: ";
 837   out.flush();
 838   QString password = in.readLine().trimmed();
 839   out << endl;
 840   out << "Repeat Password: ";
 841   out.flush();
 842   QString password2 = in.readLine().trimmed();
 843   out << endl;
 844   enableStdInEcho();
 845
 846   if(password != password2) {
 847     qWarning() << "Passwords don't match!";
 848     return;
 849   }
 850   if(password.isEmpty()) {
 851     qWarning() << "Password is empty!";
 852     return;
 853   }
 854
 855   if(_storage->updateUser(userId, password)) {
 856     out << "Password changed successfuly!" << endl;
 857   } else {
 858     qWarning() << "Failed to change password!";
 859   }
 860 }
 861
 862 AbstractSqlMigrationReader *Core::getMigrationReader(Storage *storage) {
 863   if(!storage)
 864     return 0;
 865
 866   AbstractSqlStorage *sqlStorage = qobject_cast<AbstractSqlStorage *>(storage);
 867   if(!sqlStorage) {
 868     qDebug() << "Core::migrateDb(): only SQL based backends can be migrated!";
 869     return 0;
 870   }
 871
 872   return sqlStorage->createMigrationReader();
 873 }
 874
 875 AbstractSqlMigrationWriter *Core::getMigrationWriter(Storage *storage) {
 876   if(!storage)
 877     return 0;
 878
 879   AbstractSqlStorage *sqlStorage = qobject_cast<AbstractSqlStorage *>(storage);
 880   if(!sqlStorage) {
 881     qDebug() << "Core::migrateDb(): only SQL based backends can be migrated!";
 882     return 0;
 883   }
 884
 885   return sqlStorage->createMigrationWriter();
 886 }
 887
 888 void Core::saveBackendSettings(const QString &backend, const QVariantMap &settings) {
 889   QVariantMap dbsettings;
 890   dbsettings["Backend"] = backend;
 891   dbsettings["ConnectionProperties"] = settings;
 892   CoreSettings().setStorageSettings(dbsettings);
 893 }
 894
 895 QVariantMap Core::promptForSettings(const Storage *storage) {
 896   QVariantMap settings;
 897
 898   QStringList keys = storage->setupKeys();
 899   if(keys.isEmpty())
 900     return settings;
 901
 902   QTextStream out(stdout);
 903   QTextStream in(stdin);
 904   out << "Default values are in brackets" << endl;
 905
 906   QVariantMap defaults = storage->setupDefaults();
 907   QString value;
 908   foreach(QString key, keys) {
 909     QVariant val;
 910     if(defaults.contains(key)) {
 911       val = defaults[key];
 912     }
 913     out << key;
 914     if(!val.toString().isEmpty()) {
 915       out << " (" << val.toString() << ")";
 916     }
 917     out << ": ";
 918     out.flush();
 919
 920     bool noEcho = QString("password").toLower().startsWith(key.toLower());
 921     if(noEcho) {
 922       disableStdInEcho();
 923     }
 924     value = in.readLine().trimmed();
 925     if(noEcho) {
 926       out << endl;
 927       enableStdInEcho();
 928     }
 929
 930     if(!value.isEmpty()) {
 931       switch(defaults[key].type()) {
 932       case QVariant::Int:
 933         val = QVariant(value.toInt());
 934         break;
 935       default:
 936         val = QVariant(value);
 937       }
 938     }
 939     settings[key] = val;
 940   }
 941   return settings;
 942 }
 943
 944
 945 #ifdef Q_OS_WIN32
 946 void Core::stdInEcho(bool on) {
 947   HANDLE hStdin = GetStdHandle(STD_INPUT_HANDLE);
 948   DWORD mode = 0;
 949   GetConsoleMode(hStdin, &mode);
 950   if(on)
 951     mode |= ENABLE_ECHO_INPUT;
 952   else
 953     mode &= ~ENABLE_ECHO_INPUT;
 954   SetConsoleMode(hStdin, mode);
 955 }
 956 #else
 957 void Core::stdInEcho(bool on) {
 958   termios t;
 959   tcgetattr(STDIN_FILENO, &t);
 960   if(on)
 961     t.c_lflag |= ECHO;
 962   else
 963     t.c_lflag &= ~ECHO;
 964   tcsetattr(STDIN_FILENO, TCSANOW, &t);
 965 }
 966 #endif /* Q_OS_WIN32 */