src/core/sqlitestorage.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2005-2019 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  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *
  19  ***************************************************************************/
  20
  21 #include "sqlitestorage.h"
  22
  23 #include <QtSql>
  24
  25 #include "network.h"
  26 #include "quassel.h"
  27
  28 int SqliteStorage::_maxRetryCount = 150;
  29
  30 SqliteStorage::SqliteStorage(QObject* parent)
  31     : AbstractSqlStorage(parent)
  32 {}
  33
  34 bool SqliteStorage::isAvailable() const
  35 {
  36     if (!QSqlDatabase::isDriverAvailable("QSQLITE"))
  37         return false;
  38     return true;
  39 }
  40
  41 QString SqliteStorage::backendId() const
  42 {
  43     return QString("SQLite");
  44 }
  45
  46 QString SqliteStorage::displayName() const
  47 {
  48     // Note: Pre-0.13 clients use the displayName property for backend idenfication
  49     // We identify the backend to use for the monolithic core by its displayname.
  50     // so only change this string if you _really_ have to and make sure the core
  51     // setup for the mono client still works ;)
  52     return backendId();
  53 }
  54
  55 QString SqliteStorage::description() const
  56 {
  57     return tr("SQLite is a file-based database engine that does not require any setup. It is suitable for small and medium-sized "
  58               "databases that do not require access via network. Use SQLite if your Quassel Core should store its data on the same machine "
  59               "it is running on, and if you only expect a few users to use your core.");
  60 }
  61
  62 int SqliteStorage::installedSchemaVersion()
  63 {
  64     // only used when there is a singlethread (during startup)
  65     // so we don't need locking here
  66     QSqlQuery query = logDb().exec("SELECT value FROM coreinfo WHERE key = 'schemaversion'");
  67     if (query.first())
  68         return query.value(0).toInt();
  69
  70     // maybe it's really old... (schema version 0)
  71     query = logDb().exec("SELECT MAX(version) FROM coreinfo");
  72     if (query.first())
  73         return query.value(0).toInt();
  74
  75     return AbstractSqlStorage::installedSchemaVersion();
  76 }
  77
  78 bool SqliteStorage::updateSchemaVersion(int newVersion)
  79 {
  80     // only used when there is a singlethread (during startup)
  81     // so we don't need locking here
  82     QSqlQuery query(logDb());
  83     query.prepare("UPDATE coreinfo SET value = :version WHERE key = 'schemaversion'");
  84     query.bindValue(":version", newVersion);
  85     query.exec();
  86
  87     bool success = true;
  88     if (query.lastError().isValid()) {
  89         qCritical() << "SqliteStorage::updateSchemaVersion(int): Updating schema version failed!";
  90         success = false;
  91     }
  92     return success;
  93 }
  94
  95 bool SqliteStorage::setupSchemaVersion(int version)
  96 {
  97     // only used when there is a singlethread (during startup)
  98     // so we don't need locking here
  99     QSqlQuery query(logDb());
 100     query.prepare("INSERT INTO coreinfo (key, value) VALUES ('schemaversion', :version)");
 101     query.bindValue(":version", version);
 102     query.exec();
 103
 104     bool success = true;
 105     if (query.lastError().isValid()) {
 106         qCritical() << "SqliteStorage::setupSchemaVersion(int): Updating schema version failed!";
 107         success = false;
 108     }
 109     return success;
 110 }
 111
 112 UserId SqliteStorage::addUser(const QString& user, const QString& password, const QString& authenticator)
 113 {
 114     QSqlDatabase db = logDb();
 115     UserId uid;
 116
 117     db.transaction();
 118     // this scope ensures that the query is freed in sqlite before we call unlock()
 119     // this ensures that our thread doesn't hold a internal after unlock is called
 120     // (see sqlites doc on implicit locking for details)
 121     {
 122         QSqlQuery query(db);
 123         query.prepare(queryString("insert_quasseluser"));
 124         query.bindValue(":username", user);
 125         query.bindValue(":password", hashPassword(password));
 126         query.bindValue(":hashversion", Storage::HashVersion::Latest);
 127         query.bindValue(":authenticator", authenticator);
 128         lockForWrite();
 129         safeExec(query);
 130         if (query.lastError().isValid()
 131             && query.lastError().number() == 19) {  // user already exists - sadly 19 seems to be the general constraint violation error...
 132             db.rollback();
 133         }
 134         else {
 135             uid = query.lastInsertId().toInt();
 136             db.commit();
 137         }
 138     }
 139     unlock();
 140
 141     if (uid.isValid())
 142         emit userAdded(uid, user);
 143     return uid;
 144 }
 145
 146 bool SqliteStorage::updateUser(UserId user, const QString& password)
 147 {
 148     QSqlDatabase db = logDb();
 149     bool success = false;
 150
 151     db.transaction();
 152     {
 153         QSqlQuery query(db);
 154         query.prepare(queryString("update_userpassword"));
 155         query.bindValue(":userid", user.toInt());
 156         query.bindValue(":password", hashPassword(password));
 157         query.bindValue(":hashversion", Storage::HashVersion::Latest);
 158         lockForWrite();
 159         safeExec(query);
 160         success = query.numRowsAffected() != 0;
 161         db.commit();
 162     }
 163     unlock();
 164     return success;
 165 }
 166
 167 void SqliteStorage::renameUser(UserId user, const QString& newName)
 168 {
 169     QSqlDatabase db = logDb();
 170     db.transaction();
 171     {
 172         QSqlQuery query(db);
 173         query.prepare(queryString("update_username"));
 174         query.bindValue(":userid", user.toInt());
 175         query.bindValue(":username", newName);
 176         lockForWrite();
 177         safeExec(query);
 178         db.commit();
 179     }
 180     unlock();
 181     emit userRenamed(user, newName);
 182 }
 183
 184 UserId SqliteStorage::validateUser(const QString& user, const QString& password)
 185 {
 186     UserId userId;
 187     QString hashedPassword;
 188     Storage::HashVersion hashVersion = Storage::HashVersion::Latest;
 189
 190     {
 191         QSqlQuery query(logDb());
 192         query.prepare(queryString("select_authuser"));
 193         query.bindValue(":username", user);
 194
 195         lockForRead();
 196         safeExec(query);
 197
 198         if (query.first()) {
 199             userId = query.value(0).toInt();
 200             hashedPassword = query.value(1).toString();
 201             hashVersion = static_cast<Storage::HashVersion>(query.value(2).toInt());
 202         }
 203     }
 204     unlock();
 205
 206     UserId returnUserId;
 207     if (userId != 0 && checkHashedPassword(userId, password, hashedPassword, hashVersion)) {
 208         returnUserId = userId;
 209     }
 210     return returnUserId;
 211 }
 212
 213 UserId SqliteStorage::getUserId(const QString& username)
 214 {
 215     UserId userId;
 216
 217     {
 218         QSqlQuery query(logDb());
 219         query.prepare(queryString("select_userid"));
 220         query.bindValue(":username", username);
 221
 222         lockForRead();
 223         safeExec(query);
 224
 225         if (query.first()) {
 226             userId = query.value(0).toInt();
 227         }
 228     }
 229     unlock();
 230
 231     return userId;
 232 }
 233
 234 QString SqliteStorage::getUserAuthenticator(const UserId userid)
 235 {
 236     QString authenticator = QString("");
 237
 238     {
 239         QSqlQuery query(logDb());
 240         query.prepare(queryString("select_authenticator"));
 241         query.bindValue(":userid", userid.toInt());
 242
 243         lockForRead();
 244         safeExec(query);
 245
 246         if (query.first()) {
 247             authenticator = query.value(0).toString();
 248         }
 249     }
 250     unlock();
 251
 252     return authenticator;
 253 }
 254
 255 UserId SqliteStorage::internalUser()
 256 {
 257     UserId userId;
 258
 259     {
 260         QSqlQuery query(logDb());
 261         query.prepare(queryString("select_internaluser"));
 262         lockForRead();
 263         safeExec(query);
 264
 265         if (query.first()) {
 266             userId = query.value(0).toInt();
 267         }
 268     }
 269     unlock();
 270
 271     return userId;
 272 }
 273
 274 void SqliteStorage::delUser(UserId user)
 275 {
 276     QSqlDatabase db = logDb();
 277     db.transaction();
 278
 279     lockForWrite();
 280     {
 281         QSqlQuery query(db);
 282         query.prepare(queryString("delete_backlog_by_uid"));
 283         query.bindValue(":userid", user.toInt());
 284         safeExec(query);
 285
 286         query.prepare(queryString("delete_buffers_by_uid"));
 287         query.bindValue(":userid", user.toInt());
 288         safeExec(query);
 289
 290         query.prepare(queryString("delete_networks_by_uid"));
 291         query.bindValue(":userid", user.toInt());
 292         safeExec(query);
 293
 294         query.prepare(queryString("delete_quasseluser"));
 295         query.bindValue(":userid", user.toInt());
 296         safeExec(query);
 297         // I hate the lack of foreign keys and on delete cascade... :(
 298         db.commit();
 299     }
 300     unlock();
 301
 302     emit userRemoved(user);
 303 }
 304
 305 void SqliteStorage::setUserSetting(UserId userId, const QString& settingName, const QVariant& data)
 306 {
 307     QByteArray rawData;
 308     QDataStream out(&rawData, QIODevice::WriteOnly);
 309     out.setVersion(QDataStream::Qt_4_2);
 310     out << data;
 311
 312     QSqlDatabase db = logDb();
 313     db.transaction();
 314     {
 315         QSqlQuery query(db);
 316         query.prepare(queryString("insert_user_setting"));
 317         query.bindValue(":userid", userId.toInt());
 318         query.bindValue(":settingname", settingName);
 319         query.bindValue(":settingvalue", rawData);
 320         lockForWrite();
 321         safeExec(query);
 322
 323         if (query.lastError().isValid()) {
 324             QSqlQuery updateQuery(db);
 325             updateQuery.prepare(queryString("update_user_setting"));
 326             updateQuery.bindValue(":userid", userId.toInt());
 327             updateQuery.bindValue(":settingname", settingName);
 328             updateQuery.bindValue(":settingvalue", rawData);
 329             safeExec(updateQuery);
 330         }
 331         db.commit();
 332     }
 333     unlock();
 334 }
 335
 336 QVariant SqliteStorage::getUserSetting(UserId userId, const QString& settingName, const QVariant& defaultData)
 337 {
 338     QVariant data = defaultData;
 339     {
 340         QSqlQuery query(logDb());
 341         query.prepare(queryString("select_user_setting"));
 342         query.bindValue(":userid", userId.toInt());
 343         query.bindValue(":settingname", settingName);
 344         lockForRead();
 345         safeExec(query);
 346
 347         if (query.first()) {
 348             QByteArray rawData = query.value(0).toByteArray();
 349             QDataStream in(&rawData, QIODevice::ReadOnly);
 350             in.setVersion(QDataStream::Qt_4_2);
 351             in >> data;
 352         }
 353     }
 354     unlock();
 355     return data;
 356 }
 357
 358 void SqliteStorage::setCoreState(const QVariantList& data)
 359 {
 360     QByteArray rawData;
 361     QDataStream out(&rawData, QIODevice::WriteOnly);
 362     out.setVersion(QDataStream::Qt_4_2);
 363     out << data;
 364
 365     QSqlDatabase db = logDb();
 366     db.transaction();
 367     {
 368         QSqlQuery query(db);
 369         query.prepare(queryString("insert_core_state"));
 370         query.bindValue(":key", "active_sessions");
 371         query.bindValue(":value", rawData);
 372         lockForWrite();
 373         safeExec(query);
 374
 375         if (query.lastError().isValid()) {
 376             QSqlQuery updateQuery(db);
 377             updateQuery.prepare(queryString("update_core_state"));
 378             updateQuery.bindValue(":key", "active_sessions");
 379             updateQuery.bindValue(":value", rawData);
 380             safeExec(updateQuery);
 381         }
 382         db.commit();
 383     }
 384     unlock();
 385 }
 386
 387 QVariantList SqliteStorage::getCoreState(const QVariantList& defaultData)
 388 {
 389     QVariantList data;
 390     {
 391         QSqlQuery query(logDb());
 392         query.prepare(queryString("select_core_state"));
 393         query.bindValue(":key", "active_sessions");
 394         lockForRead();
 395         safeExec(query);
 396
 397         if (query.first()) {
 398             QByteArray rawData = query.value(0).toByteArray();
 399             QDataStream in(&rawData, QIODevice::ReadOnly);
 400             in.setVersion(QDataStream::Qt_4_2);
 401             in >> data;
 402         }
 403         else {
 404             data = defaultData;
 405         }
 406     }
 407     unlock();
 408     return data;
 409 }
 410
 411 IdentityId SqliteStorage::createIdentity(UserId user, CoreIdentity& identity)
 412 {
 413     IdentityId identityId;
 414
 415     QSqlDatabase db = logDb();
 416     db.transaction();
 417
 418     {
 419         QSqlQuery query(db);
 420         query.prepare(queryString("insert_identity"));
 421         query.bindValue(":userid", user.toInt());
 422         query.bindValue(":identityname", identity.identityName());
 423         query.bindValue(":realname", identity.realName());
 424         query.bindValue(":awaynick", identity.awayNick());
 425         query.bindValue(":awaynickenabled", identity.awayNickEnabled() ? 1 : 0);
 426         query.bindValue(":awayreason", identity.awayReason());
 427         query.bindValue(":awayreasonenabled", identity.awayReasonEnabled() ? 1 : 0);
 428         query.bindValue(":autoawayenabled", identity.awayReasonEnabled() ? 1 : 0);
 429         query.bindValue(":autoawaytime", identity.autoAwayTime());
 430         query.bindValue(":autoawayreason", identity.autoAwayReason());
 431         query.bindValue(":autoawayreasonenabled", identity.autoAwayReasonEnabled() ? 1 : 0);
 432         query.bindValue(":detachawayenabled", identity.detachAwayEnabled() ? 1 : 0);
 433         query.bindValue(":detachawayreason", identity.detachAwayReason());
 434         query.bindValue(":detachawayreasonenabled", identity.detachAwayReasonEnabled() ? 1 : 0);
 435         query.bindValue(":ident", identity.ident());
 436         query.bindValue(":kickreason", identity.kickReason());
 437         query.bindValue(":partreason", identity.partReason());
 438         query.bindValue(":quitreason", identity.quitReason());
 439 #ifdef HAVE_SSL
 440         query.bindValue(":sslcert", identity.sslCert().toPem());
 441         query.bindValue(":sslkey", identity.sslKey().toPem());
 442 #else
 443         query.bindValue(":sslcert", QByteArray());
 444         query.bindValue(":sslkey", QByteArray());
 445 #endif
 446
 447         lockForWrite();
 448         safeExec(query);
 449
 450         identityId = query.lastInsertId().toInt();
 451         if (!identityId.isValid()) {
 452             watchQuery(query);
 453         }
 454         else {
 455             QSqlQuery deleteNickQuery(db);
 456             deleteNickQuery.prepare(queryString("delete_nicks"));
 457             deleteNickQuery.bindValue(":identityid", identityId.toInt());
 458             safeExec(deleteNickQuery);
 459
 460             QSqlQuery insertNickQuery(db);
 461             insertNickQuery.prepare(queryString("insert_nick"));
 462             foreach (QString nick, identity.nicks()) {
 463                 insertNickQuery.bindValue(":identityid", identityId.toInt());
 464                 insertNickQuery.bindValue(":nick", nick);
 465                 safeExec(insertNickQuery);
 466             }
 467         }
 468         db.commit();
 469     }
 470     unlock();
 471     identity.setId(identityId);
 472     return identityId;
 473 }
 474
 475 bool SqliteStorage::updateIdentity(UserId user, const CoreIdentity& identity)
 476 {
 477     QSqlDatabase db = logDb();
 478     bool error = false;
 479     db.transaction();
 480
 481     {
 482         QSqlQuery checkQuery(db);
 483         checkQuery.prepare(queryString("select_checkidentity"));
 484         checkQuery.bindValue(":identityid", identity.id().toInt());
 485         checkQuery.bindValue(":userid", user.toInt());
 486         lockForRead();
 487         safeExec(checkQuery);
 488
 489         // there should be exactly one identity for the given id and user
 490         error = (!checkQuery.first() || checkQuery.value(0).toInt() != 1);
 491     }
 492     if (error) {
 493         unlock();
 494         return false;
 495     }
 496
 497     {
 498         QSqlQuery query(db);
 499         query.prepare(queryString("update_identity"));
 500         query.bindValue(":identityname", identity.identityName());
 501         query.bindValue(":realname", identity.realName());
 502         query.bindValue(":awaynick", identity.awayNick());
 503         query.bindValue(":awaynickenabled", identity.awayNickEnabled() ? 1 : 0);
 504         query.bindValue(":awayreason", identity.awayReason());
 505         query.bindValue(":awayreasonenabled", identity.awayReasonEnabled() ? 1 : 0);
 506         query.bindValue(":autoawayenabled", identity.awayReasonEnabled() ? 1 : 0);
 507         query.bindValue(":autoawaytime", identity.autoAwayTime());
 508         query.bindValue(":autoawayreason", identity.autoAwayReason());
 509         query.bindValue(":autoawayreasonenabled", identity.autoAwayReasonEnabled() ? 1 : 0);
 510         query.bindValue(":detachawayenabled", identity.detachAwayEnabled() ? 1 : 0);
 511         query.bindValue(":detachawayreason", identity.detachAwayReason());
 512         query.bindValue(":detachawayreasonenabled", identity.detachAwayReasonEnabled() ? 1 : 0);
 513         query.bindValue(":ident", identity.ident());
 514         query.bindValue(":kickreason", identity.kickReason());
 515         query.bindValue(":partreason", identity.partReason());
 516         query.bindValue(":quitreason", identity.quitReason());
 517 #ifdef HAVE_SSL
 518         query.bindValue(":sslcert", identity.sslCert().toPem());
 519         query.bindValue(":sslkey", identity.sslKey().toPem());
 520 #else
 521         query.bindValue(":sslcert", QByteArray());
 522         query.bindValue(":sslkey", QByteArray());
 523 #endif
 524         query.bindValue(":identityid", identity.id().toInt());
 525         safeExec(query);
 526         watchQuery(query);
 527
 528         QSqlQuery deleteNickQuery(db);
 529         deleteNickQuery.prepare(queryString("delete_nicks"));
 530         deleteNickQuery.bindValue(":identityid", identity.id().toInt());
 531         safeExec(deleteNickQuery);
 532         watchQuery(deleteNickQuery);
 533
 534         QSqlQuery insertNickQuery(db);
 535         insertNickQuery.prepare(queryString("insert_nick"));
 536         foreach (QString nick, identity.nicks()) {
 537             insertNickQuery.bindValue(":identityid", identity.id().toInt());
 538             insertNickQuery.bindValue(":nick", nick);
 539             safeExec(insertNickQuery);
 540             watchQuery(insertNickQuery);
 541         }
 542         db.commit();
 543     }
 544     unlock();
 545     return true;
 546 }
 547
 548 void SqliteStorage::removeIdentity(UserId user, IdentityId identityId)
 549 {
 550     QSqlDatabase db = logDb();
 551     db.transaction();
 552
 553     bool error = false;
 554     {
 555         QSqlQuery checkQuery(db);
 556         checkQuery.prepare(queryString("select_checkidentity"));
 557         checkQuery.bindValue(":identityid", identityId.toInt());
 558         checkQuery.bindValue(":userid", user.toInt());
 559         lockForRead();
 560         safeExec(checkQuery);
 561
 562         // there should be exactly one identity for the given id and user
 563         error = (!checkQuery.first() || checkQuery.value(0).toInt() != 1);
 564     }
 565     if (error) {
 566         unlock();
 567         return;
 568     }
 569
 570     {
 571         QSqlQuery deleteNickQuery(db);
 572         deleteNickQuery.prepare(queryString("delete_nicks"));
 573         deleteNickQuery.bindValue(":identityid", identityId.toInt());
 574         safeExec(deleteNickQuery);
 575
 576         QSqlQuery deleteIdentityQuery(db);
 577         deleteIdentityQuery.prepare(queryString("delete_identity"));
 578         deleteIdentityQuery.bindValue(":identityid", identityId.toInt());
 579         deleteIdentityQuery.bindValue(":userid", user.toInt());
 580         safeExec(deleteIdentityQuery);
 581         db.commit();
 582     }
 583     unlock();
 584 }
 585
 586 QList<CoreIdentity> SqliteStorage::identities(UserId user)
 587 {
 588     QList<CoreIdentity> identities;
 589     QSqlDatabase db = logDb();
 590     db.transaction();
 591
 592     {
 593         QSqlQuery query(db);
 594         query.prepare(queryString("select_identities"));
 595         query.bindValue(":userid", user.toInt());
 596
 597         QSqlQuery nickQuery(db);
 598         nickQuery.prepare(queryString("select_nicks"));
 599
 600         lockForRead();
 601         safeExec(query);
 602
 603         while (query.next()) {
 604             CoreIdentity identity(IdentityId(query.value(0).toInt()));
 605
 606             identity.setIdentityName(query.value(1).toString());
 607             identity.setRealName(query.value(2).toString());
 608             identity.setAwayNick(query.value(3).toString());
 609             identity.setAwayNickEnabled(!!query.value(4).toInt());
 610             identity.setAwayReason(query.value(5).toString());
 611             identity.setAwayReasonEnabled(!!query.value(6).toInt());
 612             identity.setAutoAwayEnabled(!!query.value(7).toInt());
 613             identity.setAutoAwayTime(query.value(8).toInt());
 614             identity.setAutoAwayReason(query.value(9).toString());
 615             identity.setAutoAwayReasonEnabled(!!query.value(10).toInt());
 616             identity.setDetachAwayEnabled(!!query.value(11).toInt());
 617             identity.setDetachAwayReason(query.value(12).toString());
 618             identity.setDetachAwayReasonEnabled(!!query.value(13).toInt());
 619             identity.setIdent(query.value(14).toString());
 620             identity.setKickReason(query.value(15).toString());
 621             identity.setPartReason(query.value(16).toString());
 622             identity.setQuitReason(query.value(17).toString());
 623 #ifdef HAVE_SSL
 624             identity.setSslCert(query.value(18).toByteArray());
 625             identity.setSslKey(query.value(19).toByteArray());
 626 #endif
 627
 628             nickQuery.bindValue(":identityid", identity.id().toInt());
 629             QList<QString> nicks;
 630             safeExec(nickQuery);
 631             watchQuery(nickQuery);
 632             while (nickQuery.next()) {
 633                 nicks << nickQuery.value(0).toString();
 634             }
 635             identity.setNicks(nicks);
 636             identities << identity;
 637         }
 638         db.commit();
 639     }
 640     unlock();
 641     return identities;
 642 }
 643
 644 NetworkId SqliteStorage::createNetwork(UserId user, const NetworkInfo& info)
 645 {
 646     NetworkId networkId;
 647
 648     QSqlDatabase db = logDb();
 649     db.transaction();
 650
 651     bool error = false;
 652     {
 653         QSqlQuery query(db);
 654         query.prepare(queryString("insert_network"));
 655         query.bindValue(":userid", user.toInt());
 656         bindNetworkInfo(query, info);
 657         lockForWrite();
 658         safeExec(query);
 659         if (!watchQuery(query)) {
 660             db.rollback();
 661             error = true;
 662         }
 663         else {
 664             networkId = query.lastInsertId().toInt();
 665         }
 666     }
 667     if (error) {
 668         unlock();
 669         return {};
 670     }
 671
 672     {
 673         QSqlQuery insertServersQuery(db);
 674         insertServersQuery.prepare(queryString("insert_server"));
 675         foreach (Network::Server server, info.serverList) {
 676             insertServersQuery.bindValue(":userid", user.toInt());
 677             insertServersQuery.bindValue(":networkid", networkId.toInt());
 678             bindServerInfo(insertServersQuery, server);
 679             safeExec(insertServersQuery);
 680             if (!watchQuery(insertServersQuery)) {
 681                 db.rollback();
 682                 error = true;
 683                 break;
 684             }
 685         }
 686         if (!error)
 687             db.commit();
 688     }
 689     unlock();
 690     if (error)
 691         return {};
 692     else
 693         return networkId;
 694 }
 695
 696 void SqliteStorage::bindNetworkInfo(QSqlQuery& query, const NetworkInfo& info)
 697 {
 698     query.bindValue(":networkname", info.networkName);
 699     query.bindValue(":identityid", info.identity.toInt());
 700     query.bindValue(":encodingcodec", QString(info.codecForEncoding));
 701     query.bindValue(":decodingcodec", QString(info.codecForDecoding));
 702     query.bindValue(":servercodec", QString(info.codecForServer));
 703     query.bindValue(":userandomserver", info.useRandomServer ? 1 : 0);
 704     query.bindValue(":perform", info.perform.join("\n"));
 705     query.bindValue(":useautoidentify", info.useAutoIdentify ? 1 : 0);
 706     query.bindValue(":autoidentifyservice", info.autoIdentifyService);
 707     query.bindValue(":autoidentifypassword", info.autoIdentifyPassword);
 708     query.bindValue(":usesasl", info.useSasl ? 1 : 0);
 709     query.bindValue(":saslaccount", info.saslAccount);
 710     query.bindValue(":saslpassword", info.saslPassword);
 711     query.bindValue(":useautoreconnect", info.useAutoReconnect ? 1 : 0);
 712     query.bindValue(":autoreconnectinterval", info.autoReconnectInterval);
 713     query.bindValue(":autoreconnectretries", info.autoReconnectRetries);
 714     query.bindValue(":unlimitedconnectretries", info.unlimitedReconnectRetries ? 1 : 0);
 715     query.bindValue(":rejoinchannels", info.rejoinChannels ? 1 : 0);
 716     // Custom rate limiting
 717     query.bindValue(":usecustomessagerate", info.useCustomMessageRate ? 1 : 0);
 718     query.bindValue(":messagerateburstsize", info.messageRateBurstSize);
 719     query.bindValue(":messageratedelay", info.messageRateDelay);
 720     query.bindValue(":unlimitedmessagerate", info.unlimitedMessageRate ? 1 : 0);
 721     if (info.networkId.isValid())
 722         query.bindValue(":networkid", info.networkId.toInt());
 723 }
 724
 725 void SqliteStorage::bindServerInfo(QSqlQuery& query, const Network::Server& server)
 726 {
 727     query.bindValue(":hostname", server.host);
 728     query.bindValue(":port", server.port);
 729     query.bindValue(":password", server.password);
 730     query.bindValue(":ssl", server.useSsl ? 1 : 0);
 731     query.bindValue(":sslversion", server.sslVersion);
 732     query.bindValue(":useproxy", server.useProxy ? 1 : 0);
 733     query.bindValue(":proxytype", server.proxyType);
 734     query.bindValue(":proxyhost", server.proxyHost);
 735     query.bindValue(":proxyport", server.proxyPort);
 736     query.bindValue(":proxyuser", server.proxyUser);
 737     query.bindValue(":proxypass", server.proxyPass);
 738     query.bindValue(":sslverify", server.sslVerify ? 1 : 0);
 739 }
 740
 741 bool SqliteStorage::updateNetwork(UserId user, const NetworkInfo& info)
 742 {
 743     QSqlDatabase db = logDb();
 744     bool error = false;
 745     db.transaction();
 746
 747     {
 748         QSqlQuery updateQuery(db);
 749         updateQuery.prepare(queryString("update_network"));
 750         updateQuery.bindValue(":userid", user.toInt());
 751         bindNetworkInfo(updateQuery, info);
 752
 753         lockForWrite();
 754         safeExec(updateQuery);
 755         if (!watchQuery(updateQuery) || updateQuery.numRowsAffected() != 1) {
 756             error = true;
 757             db.rollback();
 758         }
 759     }
 760     if (error) {
 761         unlock();
 762         return false;
 763     }
 764
 765     {
 766         QSqlQuery dropServersQuery(db);
 767         dropServersQuery.prepare("DELETE FROM ircserver WHERE networkid = :networkid");
 768         dropServersQuery.bindValue(":networkid", info.networkId.toInt());
 769         safeExec(dropServersQuery);
 770         if (!watchQuery(dropServersQuery)) {
 771             error = true;
 772             db.rollback();
 773         }
 774     }
 775     if (error) {
 776         unlock();
 777         return false;
 778     }
 779
 780     {
 781         QSqlQuery insertServersQuery(db);
 782         insertServersQuery.prepare(queryString("insert_server"));
 783         foreach (Network::Server server, info.serverList) {
 784             insertServersQuery.bindValue(":userid", user.toInt());
 785             insertServersQuery.bindValue(":networkid", info.networkId.toInt());
 786             bindServerInfo(insertServersQuery, server);
 787             safeExec(insertServersQuery);
 788             if (!watchQuery(insertServersQuery)) {
 789                 error = true;
 790                 db.rollback();
 791                 break;
 792             }
 793         }
 794     }
 795
 796     db.commit();
 797     unlock();
 798     return !error;
 799 }
 800
 801 bool SqliteStorage::removeNetwork(UserId user, const NetworkId& networkId)
 802 {
 803     QSqlDatabase db = logDb();
 804     bool error = false;
 805     db.transaction();
 806
 807     {
 808         QSqlQuery deleteNetworkQuery(db);
 809         deleteNetworkQuery.prepare(queryString("delete_network"));
 810         deleteNetworkQuery.bindValue(":networkid", networkId.toInt());
 811         deleteNetworkQuery.bindValue(":userid", user.toInt());
 812         lockForWrite();
 813         safeExec(deleteNetworkQuery);
 814         if (!watchQuery(deleteNetworkQuery) || deleteNetworkQuery.numRowsAffected() != 1) {
 815             error = true;
 816             db.rollback();
 817         }
 818     }
 819     if (error) {
 820         unlock();
 821         return false;
 822     }
 823
 824     {
 825         QSqlQuery deleteBacklogQuery(db);
 826         deleteBacklogQuery.prepare(queryString("delete_backlog_for_network"));
 827         deleteBacklogQuery.bindValue(":networkid", networkId.toInt());
 828         safeExec(deleteBacklogQuery);
 829         if (!watchQuery(deleteBacklogQuery)) {
 830             db.rollback();
 831             error = true;
 832         }
 833     }
 834     if (error) {
 835         unlock();
 836         return false;
 837     }
 838
 839     {
 840         QSqlQuery deleteBuffersQuery(db);
 841         deleteBuffersQuery.prepare(queryString("delete_buffers_for_network"));
 842         deleteBuffersQuery.bindValue(":networkid", networkId.toInt());
 843         safeExec(deleteBuffersQuery);
 844         if (!watchQuery(deleteBuffersQuery)) {
 845             db.rollback();
 846             error = true;
 847         }
 848     }
 849     if (error) {
 850         unlock();
 851         return false;
 852     }
 853
 854     {
 855         QSqlQuery deleteServersQuery(db);
 856         deleteServersQuery.prepare(queryString("delete_ircservers_for_network"));
 857         deleteServersQuery.bindValue(":networkid", networkId.toInt());
 858         safeExec(deleteServersQuery);
 859         if (!watchQuery(deleteServersQuery)) {
 860             db.rollback();
 861             error = true;
 862         }
 863     }
 864     if (error) {
 865         unlock();
 866         return false;
 867     }
 868
 869     db.commit();
 870     unlock();
 871     return true;
 872 }
 873
 874 QList<NetworkInfo> SqliteStorage::networks(UserId user)
 875 {
 876     QList<NetworkInfo> nets;
 877
 878     QSqlDatabase db = logDb();
 879     db.transaction();
 880
 881     {
 882         QSqlQuery networksQuery(db);
 883         networksQuery.prepare(queryString("select_networks_for_user"));
 884         networksQuery.bindValue(":userid", user.toInt());
 885
 886         QSqlQuery serversQuery(db);
 887         serversQuery.prepare(queryString("select_servers_for_network"));
 888
 889         lockForRead();
 890         safeExec(networksQuery);
 891         if (watchQuery(networksQuery)) {
 892             while (networksQuery.next()) {
 893                 NetworkInfo net;
 894                 net.networkId = networksQuery.value(0).toInt();
 895                 net.networkName = networksQuery.value(1).toString();
 896                 net.identity = networksQuery.value(2).toInt();
 897                 net.codecForServer = networksQuery.value(3).toString().toLatin1();
 898                 net.codecForEncoding = networksQuery.value(4).toString().toLatin1();
 899                 net.codecForDecoding = networksQuery.value(5).toString().toLatin1();
 900                 net.useRandomServer = networksQuery.value(6).toInt() == 1 ? true : false;
 901                 net.perform = networksQuery.value(7).toString().split("\n");
 902                 net.useAutoIdentify = networksQuery.value(8).toInt() == 1 ? true : false;
 903                 net.autoIdentifyService = networksQuery.value(9).toString();
 904                 net.autoIdentifyPassword = networksQuery.value(10).toString();
 905                 net.useAutoReconnect = networksQuery.value(11).toInt() == 1 ? true : false;
 906                 net.autoReconnectInterval = networksQuery.value(12).toUInt();
 907                 net.autoReconnectRetries = networksQuery.value(13).toInt();
 908                 net.unlimitedReconnectRetries = networksQuery.value(14).toInt() == 1 ? true : false;
 909                 net.rejoinChannels = networksQuery.value(15).toInt() == 1 ? true : false;
 910                 net.useSasl = networksQuery.value(16).toInt() == 1 ? true : false;
 911                 net.saslAccount = networksQuery.value(17).toString();
 912                 net.saslPassword = networksQuery.value(18).toString();
 913                 // Custom rate limiting
 914                 net.useCustomMessageRate = networksQuery.value(19).toInt() == 1 ? true : false;
 915                 net.messageRateBurstSize = networksQuery.value(20).toUInt();
 916                 net.messageRateDelay = networksQuery.value(21).toUInt();
 917                 net.unlimitedMessageRate = networksQuery.value(22).toInt() == 1 ? true : false;
 918
 919                 serversQuery.bindValue(":networkid", net.networkId.toInt());
 920                 safeExec(serversQuery);
 921                 if (!watchQuery(serversQuery)) {
 922                     nets.clear();
 923                     break;
 924                 }
 925                 else {
 926                     Network::ServerList servers;
 927                     while (serversQuery.next()) {
 928                         Network::Server server;
 929                         server.host = serversQuery.value(0).toString();
 930                         server.port = serversQuery.value(1).toUInt();
 931                         server.password = serversQuery.value(2).toString();
 932                         server.useSsl = serversQuery.value(3).toInt() == 1 ? true : false;
 933                         server.sslVersion = serversQuery.value(4).toInt();
 934                         server.useProxy = serversQuery.value(5).toInt() == 1 ? true : false;
 935                         server.proxyType = serversQuery.value(6).toInt();
 936                         server.proxyHost = serversQuery.value(7).toString();
 937                         server.proxyPort = serversQuery.value(8).toUInt();
 938                         server.proxyUser = serversQuery.value(9).toString();
 939                         server.proxyPass = serversQuery.value(10).toString();
 940                         server.sslVerify = serversQuery.value(11).toInt() == 1 ? true : false;
 941                         servers << server;
 942                     }
 943                     net.serverList = servers;
 944                     nets << net;
 945                 }
 946             }
 947         }
 948     }
 949     db.commit();
 950     unlock();
 951     return nets;
 952 }
 953
 954 QList<NetworkId> SqliteStorage::connectedNetworks(UserId user)
 955 {
 956     QList<NetworkId> connectedNets;
 957
 958     QSqlDatabase db = logDb();
 959     db.transaction();
 960
 961     {
 962         QSqlQuery query(db);
 963         query.prepare(queryString("select_connected_networks"));
 964         query.bindValue(":userid", user.toInt());
 965         lockForRead();
 966         safeExec(query);
 967         watchQuery(query);
 968
 969         while (query.next()) {
 970             connectedNets << query.value(0).toInt();
 971         }
 972         db.commit();
 973     }
 974     unlock();
 975     return connectedNets;
 976 }
 977
 978 void SqliteStorage::setNetworkConnected(UserId user, const NetworkId& networkId, bool isConnected)
 979 {
 980     QSqlDatabase db = logDb();
 981     db.transaction();
 982
 983     {
 984         QSqlQuery query(db);
 985         query.prepare(queryString("update_network_connected"));
 986         query.bindValue(":userid", user.toInt());
 987         query.bindValue(":networkid", networkId.toInt());
 988         query.bindValue(":connected", isConnected ? 1 : 0);
 989
 990         lockForWrite();
 991         safeExec(query);
 992         watchQuery(query);
 993         db.commit();
 994     }
 995     unlock();
 996 }
 997
 998 QHash<QString, QString> SqliteStorage::persistentChannels(UserId user, const NetworkId& networkId)
 999 {
1000     QHash<QString, QString> persistentChans;
1001
1002     QSqlDatabase db = logDb();
1003     db.transaction();
1004     {
1005         QSqlQuery query(db);
1006         query.prepare(queryString("select_persistent_channels"));
1007         query.bindValue(":userid", user.toInt());
1008         query.bindValue(":networkid", networkId.toInt());
1009
1010         lockForRead();
1011         safeExec(query);
1012         watchQuery(query);
1013         while (query.next()) {
1014             persistentChans[query.value(0).toString()] = query.value(1).toString();
1015         }
1016     }
1017     unlock();
1018     return persistentChans;
1019 }
1020
1021 void SqliteStorage::setChannelPersistent(UserId user, const NetworkId& networkId, const QString& channel, bool isJoined)
1022 {
1023     QSqlDatabase db = logDb();
1024     db.transaction();
1025
1026     {
1027         QSqlQuery query(db);
1028         query.prepare(queryString("update_buffer_persistent_channel"));
1029         query.bindValue(":userid", user.toInt());
1030         query.bindValue(":networkid", networkId.toInt());
1031         query.bindValue(":buffercname", channel.toLower());
1032         query.bindValue(":joined", isJoined ? 1 : 0);
1033
1034         lockForWrite();
1035         safeExec(query);
1036         watchQuery(query);
1037         db.commit();
1038     }
1039     unlock();
1040 }
1041
1042 void SqliteStorage::setPersistentChannelKey(UserId user, const NetworkId& networkId, const QString& channel, const QString& key)
1043 {
1044     QSqlDatabase db = logDb();
1045     db.transaction();
1046
1047     {
1048         QSqlQuery query(db);
1049         query.prepare(queryString("update_buffer_set_channel_key"));
1050         query.bindValue(":userid", user.toInt());
1051         query.bindValue(":networkid", networkId.toInt());
1052         query.bindValue(":buffercname", channel.toLower());
1053         query.bindValue(":key", key);
1054
1055         lockForWrite();
1056         safeExec(query);
1057         watchQuery(query);
1058         db.commit();
1059     }
1060     unlock();
1061 }
1062
1063 QString SqliteStorage::awayMessage(UserId user, NetworkId networkId)
1064 {
1065     QSqlDatabase db = logDb();
1066     db.transaction();
1067
1068     QString awayMsg;
1069     {
1070         QSqlQuery query(db);
1071         query.prepare(queryString("select_network_awaymsg"));
1072         query.bindValue(":userid", user.toInt());
1073         query.bindValue(":networkid", networkId.toInt());
1074
1075         lockForRead();
1076         safeExec(query);
1077         watchQuery(query);
1078         if (query.first())
1079             awayMsg = query.value(0).toString();
1080         db.commit();
1081     }
1082     unlock();
1083
1084     return awayMsg;
1085 }
1086
1087 void SqliteStorage::setAwayMessage(UserId user, NetworkId networkId, const QString& awayMsg)
1088 {
1089     QSqlDatabase db = logDb();
1090     db.transaction();
1091
1092     {
1093         QSqlQuery query(db);
1094         query.prepare(queryString("update_network_set_awaymsg"));
1095         query.bindValue(":userid", user.toInt());
1096         query.bindValue(":networkid", networkId.toInt());
1097         query.bindValue(":awaymsg", awayMsg);
1098
1099         lockForWrite();
1100         safeExec(query);
1101         watchQuery(query);
1102         db.commit();
1103     }
1104     unlock();
1105 }
1106
1107 QString SqliteStorage::userModes(UserId user, NetworkId networkId)
1108 {
1109     QSqlDatabase db = logDb();
1110     db.transaction();
1111
1112     QString modes;
1113     {
1114         QSqlQuery query(db);
1115         query.prepare(queryString("select_network_usermode"));
1116         query.bindValue(":userid", user.toInt());
1117         query.bindValue(":networkid", networkId.toInt());
1118
1119         lockForRead();
1120         safeExec(query);
1121         watchQuery(query);
1122         if (query.first())
1123             modes = query.value(0).toString();
1124         db.commit();
1125     }
1126     unlock();
1127
1128     return modes;
1129 }
1130
1131 void SqliteStorage::setUserModes(UserId user, NetworkId networkId, const QString& userModes)
1132 {
1133     QSqlDatabase db = logDb();
1134     db.transaction();
1135
1136     {
1137         QSqlQuery query(db);
1138         query.prepare(queryString("update_network_set_usermode"));
1139         query.bindValue(":userid", user.toInt());
1140         query.bindValue(":networkid", networkId.toInt());
1141         query.bindValue(":usermode", userModes);
1142
1143         lockForWrite();
1144         safeExec(query);
1145         watchQuery(query);
1146         db.commit();
1147     }
1148     unlock();
1149 }
1150
1151 BufferInfo SqliteStorage::bufferInfo(UserId user, const NetworkId& networkId, BufferInfo::Type type, const QString& buffer, bool create)
1152 {
1153     QSqlDatabase db = logDb();
1154     db.transaction();
1155
1156     BufferInfo bufferInfo;
1157     {
1158         QSqlQuery query(db);
1159         query.prepare(queryString("select_bufferByName"));
1160         query.bindValue(":networkid", networkId.toInt());
1161         query.bindValue(":userid", user.toInt());
1162         query.bindValue(":buffercname", buffer.toLower());
1163
1164         lockForRead();
1165         safeExec(query);
1166
1167         if (query.first()) {
1168             bufferInfo = BufferInfo(query.value(0).toInt(), networkId, (BufferInfo::Type)query.value(1).toInt(), 0, buffer);
1169             if (query.next()) {
1170                 qCritical() << "SqliteStorage::getBufferInfo(): received more then one Buffer!";
1171                 qCritical() << "         Query:" << query.lastQuery();
1172                 qCritical() << "  bound Values:";
1173                 QList<QVariant> list = query.boundValues().values();
1174                 for (int i = 0; i < list.size(); ++i)
1175                     qCritical() << i << ":" << list.at(i).toString().toLatin1().data();
1176                 Q_ASSERT(false);
1177             }
1178         }
1179         else if (create) {
1180             // let's create the buffer
1181             QSqlQuery createQuery(db);
1182             createQuery.prepare(queryString("insert_buffer"));
1183             createQuery.bindValue(":userid", user.toInt());
1184             createQuery.bindValue(":networkid", networkId.toInt());
1185             createQuery.bindValue(":buffertype", (int)type);
1186             createQuery.bindValue(":buffername", buffer);
1187             createQuery.bindValue(":buffercname", buffer.toLower());
1188             createQuery.bindValue(":joined", type & BufferInfo::ChannelBuffer ? 1 : 0);
1189
1190             unlock();
1191             lockForWrite();
1192             safeExec(createQuery);
1193             watchQuery(createQuery);
1194             bufferInfo = BufferInfo(createQuery.lastInsertId().toInt(), networkId, type, 0, buffer);
1195         }
1196     }
1197     db.commit();
1198     unlock();
1199     return bufferInfo;
1200 }
1201
1202 BufferInfo SqliteStorage::getBufferInfo(UserId user, const BufferId& bufferId)
1203 {
1204     QSqlDatabase db = logDb();
1205     db.transaction();
1206
1207     BufferInfo bufferInfo;
1208     {
1209         QSqlQuery query(db);
1210         query.prepare(queryString("select_buffer_by_id"));
1211         query.bindValue(":userid", user.toInt());
1212         query.bindValue(":bufferid", bufferId.toInt());
1213
1214         lockForRead();
1215         safeExec(query);
1216
1217         if (watchQuery(query) && query.first()) {
1218             bufferInfo = BufferInfo(query.value(0).toInt(),
1219                                     query.value(1).toInt(),
1220                                     (BufferInfo::Type)query.value(2).toInt(),
1221                                     0,
1222                                     query.value(4).toString());
1223             Q_ASSERT(!query.next());
1224         }
1225         db.commit();
1226     }
1227     unlock();
1228     return bufferInfo;
1229 }
1230
1231 QList<BufferInfo> SqliteStorage::requestBuffers(UserId user)
1232 {
1233     QList<BufferInfo> bufferlist;
1234
1235     QSqlDatabase db = logDb();
1236     db.transaction();
1237
1238     {
1239         QSqlQuery query(db);
1240         query.prepare(queryString("select_buffers"));
1241         query.bindValue(":userid", user.toInt());
1242
1243         lockForRead();
1244         safeExec(query);
1245         watchQuery(query);
1246         while (query.next()) {
1247             bufferlist << BufferInfo(query.value(0).toInt(),
1248                                      query.value(1).toInt(),
1249                                      (BufferInfo::Type)query.value(2).toInt(),
1250                                      query.value(3).toInt(),
1251                                      query.value(4).toString());
1252         }
1253         db.commit();
1254     }
1255     unlock();
1256
1257     return bufferlist;
1258 }
1259
1260 QList<BufferId> SqliteStorage::requestBufferIdsForNetwork(UserId user, NetworkId networkId)
1261 {
1262     QList<BufferId> bufferList;
1263
1264     QSqlDatabase db = logDb();
1265     db.transaction();
1266
1267     {
1268         QSqlQuery query(db);
1269         query.prepare(queryString("select_buffers_for_network"));
1270         query.bindValue(":networkid", networkId.toInt());
1271         query.bindValue(":userid", user.toInt());
1272
1273         lockForRead();
1274         safeExec(query);
1275         watchQuery(query);
1276         while (query.next()) {
1277             bufferList << BufferId(query.value(0).toInt());
1278         }
1279         db.commit();
1280     }
1281     unlock();
1282
1283     return bufferList;
1284 }
1285
1286 bool SqliteStorage::removeBuffer(const UserId& user, const BufferId& bufferId)
1287 {
1288     QSqlDatabase db = logDb();
1289     db.transaction();
1290
1291     bool error = false;
1292     {
1293         QSqlQuery delBufferQuery(db);
1294         delBufferQuery.prepare(queryString("delete_buffer_for_bufferid"));
1295         delBufferQuery.bindValue(":bufferid", bufferId.toInt());
1296         delBufferQuery.bindValue(":userid", user.toInt());
1297
1298         lockForWrite();
1299         safeExec(delBufferQuery);
1300
1301         error = (!watchQuery(delBufferQuery) || delBufferQuery.numRowsAffected() != 1);
1302     }
1303
1304     if (error) {
1305         db.rollback();
1306         unlock();
1307         return false;
1308     }
1309
1310     {
1311         QSqlQuery delBacklogQuery(db);
1312         delBacklogQuery.prepare(queryString("delete_backlog_for_buffer"));
1313         delBacklogQuery.bindValue(":bufferid", bufferId.toInt());
1314
1315         safeExec(delBacklogQuery);
1316         error = !watchQuery(delBacklogQuery);
1317     }
1318
1319     if (error) {
1320         db.rollback();
1321     }
1322     else {
1323         db.commit();
1324     }
1325     unlock();
1326     return !error;
1327 }
1328
1329 bool SqliteStorage::renameBuffer(const UserId& user, const BufferId& bufferId, const QString& newName)
1330 {
1331     QSqlDatabase db = logDb();
1332     db.transaction();
1333
1334     bool error = false;
1335     {
1336         QSqlQuery query(db);
1337         query.prepare(queryString("update_buffer_name"));
1338         query.bindValue(":buffername", newName);
1339         query.bindValue(":buffercname", newName.toLower());
1340         query.bindValue(":bufferid", bufferId.toInt());
1341         query.bindValue(":userid", user.toInt());
1342
1343         lockForWrite();
1344         safeExec(query);
1345
1346         error = query.lastError().isValid();
1347         // unexepcted error occured (19 == constraint violation)
1348         if (error && query.lastError().number() != 19) {
1349             watchQuery(query);
1350         }
1351         else {
1352             error |= (query.numRowsAffected() != 1);
1353         }
1354     }
1355     if (error) {
1356         db.rollback();
1357     }
1358     else {
1359         db.commit();
1360     }
1361     unlock();
1362     return !error;
1363 }
1364
1365 bool SqliteStorage::mergeBuffersPermanently(const UserId& user, const BufferId& bufferId1, const BufferId& bufferId2)
1366 {
1367     QSqlDatabase db = logDb();
1368     db.transaction();
1369
1370     bool error = false;
1371     {
1372         QSqlQuery checkQuery(db);
1373         checkQuery.prepare(queryString("select_buffers_for_merge"));
1374         checkQuery.bindValue(":oldbufferid", bufferId2.toInt());
1375         checkQuery.bindValue(":newbufferid", bufferId1.toInt());
1376         checkQuery.bindValue(":userid", user.toInt());
1377
1378         lockForRead();
1379         safeExec(checkQuery);
1380         error = (!checkQuery.first() || checkQuery.value(0).toInt() != 2);
1381     }
1382     if (error) {
1383         db.rollback();
1384         unlock();
1385         return false;
1386     }
1387
1388     {
1389         QSqlQuery query(db);
1390         query.prepare(queryString("update_backlog_bufferid"));
1391         query.bindValue(":oldbufferid", bufferId2.toInt());
1392         query.bindValue(":newbufferid", bufferId1.toInt());
1393         safeExec(query);
1394         error = !watchQuery(query);
1395     }
1396     if (error) {
1397         db.rollback();
1398         unlock();
1399         return false;
1400     }
1401
1402     {
1403         QSqlQuery delBufferQuery(db);
1404         delBufferQuery.prepare(queryString("delete_buffer_for_bufferid"));
1405         delBufferQuery.bindValue(":bufferid", bufferId2.toInt());
1406         delBufferQuery.bindValue(":userid", user.toInt());
1407         safeExec(delBufferQuery);
1408         error = !watchQuery(delBufferQuery);
1409     }
1410
1411     if (error) {
1412         db.rollback();
1413     }
1414     else {
1415         db.commit();
1416     }
1417     unlock();
1418     return !error;
1419 }
1420
1421 void SqliteStorage::setBufferLastSeenMsg(UserId user, const BufferId& bufferId, const MsgId& msgId)
1422 {
1423     QSqlDatabase db = logDb();
1424     db.transaction();
1425
1426     {
1427         QSqlQuery query(db);
1428         query.prepare(queryString("update_buffer_lastseen"));
1429         query.bindValue(":userid", user.toInt());
1430         query.bindValue(":bufferid", bufferId.toInt());
1431         query.bindValue(":lastseenmsgid", msgId.toQint64());
1432
1433         lockForWrite();
1434         safeExec(query);
1435         watchQuery(query);
1436     }
1437     db.commit();
1438     unlock();
1439 }
1440
1441 QHash<BufferId, MsgId> SqliteStorage::bufferLastSeenMsgIds(UserId user)
1442 {
1443     QHash<BufferId, MsgId> lastSeenHash;
1444
1445     QSqlDatabase db = logDb();
1446     db.transaction();
1447
1448     bool error = false;
1449     {
1450         QSqlQuery query(db);
1451         query.prepare(queryString("select_buffer_lastseen_messages"));
1452         query.bindValue(":userid", user.toInt());
1453
1454         lockForRead();
1455         safeExec(query);
1456         error = !watchQuery(query);
1457         if (!error) {
1458             while (query.next()) {
1459                 lastSeenHash[query.value(0).toInt()] = query.value(1).toLongLong();
1460             }
1461         }
1462     }
1463
1464     db.commit();
1465     unlock();
1466     return lastSeenHash;
1467 }
1468
1469 void SqliteStorage::setBufferMarkerLineMsg(UserId user, const BufferId& bufferId, const MsgId& msgId)
1470 {
1471     QSqlDatabase db = logDb();
1472     db.transaction();
1473
1474     {
1475         QSqlQuery query(db);
1476         query.prepare(queryString("update_buffer_markerlinemsgid"));
1477         query.bindValue(":userid", user.toInt());
1478         query.bindValue(":bufferid", bufferId.toInt());
1479         query.bindValue(":markerlinemsgid", msgId.toQint64());
1480
1481         lockForWrite();
1482         safeExec(query);
1483         watchQuery(query);
1484     }
1485     db.commit();
1486     unlock();
1487 }
1488
1489 QHash<BufferId, MsgId> SqliteStorage::bufferMarkerLineMsgIds(UserId user)
1490 {
1491     QHash<BufferId, MsgId> markerLineHash;
1492
1493     QSqlDatabase db = logDb();
1494     db.transaction();
1495
1496     bool error = false;
1497     {
1498         QSqlQuery query(db);
1499         query.prepare(queryString("select_buffer_markerlinemsgids"));
1500         query.bindValue(":userid", user.toInt());
1501
1502         lockForRead();
1503         safeExec(query);
1504         error = !watchQuery(query);
1505         if (!error) {
1506             while (query.next()) {
1507                 markerLineHash[query.value(0).toInt()] = query.value(1).toLongLong();
1508             }
1509         }
1510     }
1511
1512     db.commit();
1513     unlock();
1514     return markerLineHash;
1515 }
1516
1517 void SqliteStorage::setBufferActivity(UserId user, BufferId bufferId, Message::Types bufferActivity)
1518 {
1519     QSqlDatabase db = logDb();
1520     db.transaction();
1521
1522     {
1523         QSqlQuery query(db);
1524         query.prepare(queryString("update_buffer_bufferactivity"));
1525         query.bindValue(":userid", user.toInt());
1526         query.bindValue(":bufferid", bufferId.toInt());
1527         query.bindValue(":bufferactivity", (int)bufferActivity);
1528
1529         lockForWrite();
1530         safeExec(query);
1531         watchQuery(query);
1532     }
1533     db.commit();
1534     unlock();
1535 }
1536
1537 QHash<BufferId, Message::Types> SqliteStorage::bufferActivities(UserId user)
1538 {
1539     QHash<BufferId, Message::Types> bufferActivityHash;
1540
1541     QSqlDatabase db = logDb();
1542     db.transaction();
1543
1544     bool error = false;
1545     {
1546         QSqlQuery query(db);
1547         query.prepare(queryString("select_buffer_bufferactivities"));
1548         query.bindValue(":userid", user.toInt());
1549
1550         lockForRead();
1551         safeExec(query);
1552         error = !watchQuery(query);
1553         if (!error) {
1554             while (query.next()) {
1555                 bufferActivityHash[query.value(0).toInt()] = Message::Types(query.value(1).toInt());
1556             }
1557         }
1558     }
1559
1560     db.commit();
1561     unlock();
1562     return bufferActivityHash;
1563 }
1564
1565 Message::Types SqliteStorage::bufferActivity(BufferId bufferId, MsgId lastSeenMsgId)
1566 {
1567     QSqlDatabase db = logDb();
1568     db.transaction();
1569
1570     Message::Types result = Message::Types(nullptr);
1571     {
1572         QSqlQuery query(db);
1573         query.prepare(queryString("select_buffer_bufferactivity"));
1574         query.bindValue(":bufferid", bufferId.toInt());
1575         query.bindValue(":lastseenmsgid", lastSeenMsgId.toQint64());
1576
1577         lockForRead();
1578         safeExec(query);
1579         if (query.first())
1580             result = Message::Types(query.value(0).toInt());
1581     }
1582
1583     db.commit();
1584     unlock();
1585     return result;
1586 }
1587
1588 QHash<QString, QByteArray> SqliteStorage::bufferCiphers(UserId user, const NetworkId& networkId)
1589 {
1590     QHash<QString, QByteArray> bufferCiphers;
1591
1592     QSqlDatabase db = logDb();
1593     db.transaction();
1594     {
1595         QSqlQuery query(db);
1596         query.prepare(queryString("select_buffer_ciphers"));
1597         query.bindValue(":userid", user.toInt());
1598         query.bindValue(":networkid", networkId.toInt());
1599
1600         lockForRead();
1601         safeExec(query);
1602         watchQuery(query);
1603         while (query.next()) {
1604             bufferCiphers[query.value(0).toString()] = QByteArray::fromHex(query.value(1).toString().toUtf8());
1605         }
1606     }
1607     unlock();
1608     return bufferCiphers;
1609 }
1610
1611 void SqliteStorage::setBufferCipher(UserId user, const NetworkId& networkId, const QString& bufferName, const QByteArray& cipher)
1612 {
1613     QSqlDatabase db = logDb();
1614     db.transaction();
1615
1616     {
1617         QSqlQuery query(db);
1618         query.prepare(queryString("update_buffer_cipher"));
1619         query.bindValue(":userid", user.toInt());
1620         query.bindValue(":networkid", networkId.toInt());
1621         query.bindValue(":buffercname", bufferName.toLower());
1622         query.bindValue(":cipher", QString(cipher.toHex()));
1623
1624         lockForWrite();
1625         safeExec(query);
1626         watchQuery(query);
1627         db.commit();
1628     }
1629     unlock();
1630 }
1631
1632 void SqliteStorage::setHighlightCount(UserId user, BufferId bufferId, int count)
1633 {
1634     QSqlDatabase db = logDb();
1635     db.transaction();
1636
1637     {
1638         QSqlQuery query(db);
1639         query.prepare(queryString("update_buffer_highlightcount"));
1640         query.bindValue(":userid", user.toInt());
1641         query.bindValue(":bufferid", bufferId.toInt());
1642         query.bindValue(":highlightcount", count);
1643
1644         lockForWrite();
1645         safeExec(query);
1646         watchQuery(query);
1647     }
1648     db.commit();
1649     unlock();
1650 }
1651
1652 QHash<BufferId, int> SqliteStorage::highlightCounts(UserId user)
1653 {
1654     QHash<BufferId, int> highlightCountHash;
1655
1656     QSqlDatabase db = logDb();
1657     db.transaction();
1658
1659     bool error = false;
1660     {
1661         QSqlQuery query(db);
1662         query.prepare(queryString("select_buffer_highlightcounts"));
1663         query.bindValue(":userid", user.toInt());
1664
1665         lockForRead();
1666         safeExec(query);
1667         error = !watchQuery(query);
1668         if (!error) {
1669             while (query.next()) {
1670                 highlightCountHash[query.value(0).toInt()] = query.value(1).toInt();
1671             }
1672         }
1673     }
1674
1675     db.commit();
1676     unlock();
1677     return highlightCountHash;
1678 }
1679
1680 int SqliteStorage::highlightCount(BufferId bufferId, MsgId lastSeenMsgId)
1681 {
1682     QSqlDatabase db = logDb();
1683     db.transaction();
1684
1685     int result = 0;
1686     {
1687         QSqlQuery query(db);
1688         query.prepare(queryString("select_buffer_highlightcount"));
1689         query.bindValue(":bufferid", bufferId.toInt());
1690         query.bindValue(":lastseenmsgid", lastSeenMsgId.toQint64());
1691
1692         lockForRead();
1693         safeExec(query);
1694         if (query.first())
1695             result = query.value(0).toInt();
1696     }
1697
1698     db.commit();
1699     unlock();
1700     return result;
1701 }
1702
1703 bool SqliteStorage::logMessage(Message& msg)
1704 {
1705     QSqlDatabase db = logDb();
1706     db.transaction();
1707
1708     bool error = false;
1709     {
1710         QSqlQuery logMessageQuery(db);
1711         logMessageQuery.prepare(queryString("insert_message"));
1712         // As of SQLite schema version 31, timestamps are stored in milliseconds instead of
1713         // seconds.  This nets us more precision as well as simplifying 64-bit time.
1714         logMessageQuery.bindValue(":time", msg.timestamp().toMSecsSinceEpoch());
1715         logMessageQuery.bindValue(":bufferid", msg.bufferInfo().bufferId().toInt());
1716         logMessageQuery.bindValue(":type", msg.type());
1717         logMessageQuery.bindValue(":flags", (int)msg.flags());
1718         logMessageQuery.bindValue(":sender", msg.sender());
1719         logMessageQuery.bindValue(":realname", msg.realName());
1720         logMessageQuery.bindValue(":avatarurl", msg.avatarUrl());
1721         logMessageQuery.bindValue(":senderprefixes", msg.senderPrefixes());
1722         logMessageQuery.bindValue(":message", msg.contents());
1723
1724         lockForWrite();
1725         safeExec(logMessageQuery);
1726
1727         if (logMessageQuery.lastError().isValid()) {
1728             // constraint violation - must be NOT NULL constraint - probably the sender is missing...
1729             if (logMessageQuery.lastError().number() == 19) {
1730                 QSqlQuery addSenderQuery(db);
1731                 addSenderQuery.prepare(queryString("insert_sender"));
1732                 addSenderQuery.bindValue(":sender", msg.sender());
1733                 addSenderQuery.bindValue(":realname", msg.realName());
1734                 addSenderQuery.bindValue(":avatarurl", msg.avatarUrl());
1735                 safeExec(addSenderQuery);
1736                 safeExec(logMessageQuery);
1737                 error = !watchQuery(logMessageQuery);
1738             }
1739             else {
1740                 watchQuery(logMessageQuery);
1741             }
1742         }
1743         if (!error) {
1744             MsgId msgId = logMessageQuery.lastInsertId().toLongLong();
1745             if (msgId.isValid()) {
1746                 msg.setMsgId(msgId);
1747             }
1748             else {
1749                 error = true;
1750             }
1751         }
1752     }
1753
1754     if (error) {
1755         db.rollback();
1756     }
1757     else {
1758         db.commit();
1759     }
1760
1761     unlock();
1762     return !error;
1763 }
1764
1765 bool SqliteStorage::logMessages(MessageList& msgs)
1766 {
1767     QSqlDatabase db = logDb();
1768     db.transaction();
1769
1770     {
1771         QSet<SenderData> senders;
1772         QSqlQuery addSenderQuery(db);
1773         addSenderQuery.prepare(queryString("insert_sender"));
1774         lockForWrite();
1775         for (int i = 0; i < msgs.count(); i++) {
1776             auto& msg = msgs.at(i);
1777             SenderData sender = {msg.sender(), msg.realName(), msg.avatarUrl()};
1778             if (senders.contains(sender))
1779                 continue;
1780             senders << sender;
1781
1782             addSenderQuery.bindValue(":sender", sender.sender);
1783             addSenderQuery.bindValue(":realname", sender.realname);
1784             addSenderQuery.bindValue(":avatarurl", sender.avatarurl);
1785             safeExec(addSenderQuery);
1786         }
1787     }
1788
1789     bool error = false;
1790     {
1791         QSqlQuery logMessageQuery(db);
1792         logMessageQuery.prepare(queryString("insert_message"));
1793         for (int i = 0; i < msgs.count(); i++) {
1794             Message& msg = msgs[i];
1795             // As of SQLite schema version 31, timestamps are stored in milliseconds instead of
1796             // seconds.  This nets us more precision as well as simplifying 64-bit time.
1797             logMessageQuery.bindValue(":time", msg.timestamp().toMSecsSinceEpoch());
1798             logMessageQuery.bindValue(":bufferid", msg.bufferInfo().bufferId().toInt());
1799             logMessageQuery.bindValue(":type", msg.type());
1800             logMessageQuery.bindValue(":flags", (int)msg.flags());
1801             logMessageQuery.bindValue(":sender", msg.sender());
1802             logMessageQuery.bindValue(":realname", msg.realName());
1803             logMessageQuery.bindValue(":avatarurl", msg.avatarUrl());
1804             logMessageQuery.bindValue(":senderprefixes", msg.senderPrefixes());
1805             logMessageQuery.bindValue(":message", msg.contents());
1806
1807             safeExec(logMessageQuery);
1808             if (!watchQuery(logMessageQuery)) {
1809                 error = true;
1810                 break;
1811             }
1812             else {
1813                 msg.setMsgId(logMessageQuery.lastInsertId().toLongLong());
1814             }
1815         }
1816     }
1817
1818     if (error) {
1819         db.rollback();
1820         unlock();
1821         // we had a rollback in the db so we need to reset all msgIds
1822         for (int i = 0; i < msgs.count(); i++) {
1823             msgs[i].setMsgId(MsgId());
1824         }
1825     }
1826     else {
1827         db.commit();
1828         unlock();
1829     }
1830     return !error;
1831 }
1832
1833 QList<Message> SqliteStorage::requestMsgs(UserId user, BufferId bufferId, MsgId first, MsgId last, int limit)
1834 {
1835     QList<Message> messagelist;
1836
1837     QSqlDatabase db = logDb();
1838     db.transaction();
1839
1840     bool error = false;
1841     BufferInfo bufferInfo;
1842     {
1843         // code duplication from getBufferInfo:
1844         // this is due to the impossibility of nesting transactions and recursive locking
1845         QSqlQuery bufferInfoQuery(db);
1846         bufferInfoQuery.prepare(queryString("select_buffer_by_id"));
1847         bufferInfoQuery.bindValue(":userid", user.toInt());
1848         bufferInfoQuery.bindValue(":bufferid", bufferId.toInt());
1849
1850         lockForRead();
1851         safeExec(bufferInfoQuery);
1852         error = !watchQuery(bufferInfoQuery) || !bufferInfoQuery.first();
1853         if (!error) {
1854             bufferInfo = BufferInfo(bufferInfoQuery.value(0).toInt(),
1855                                     bufferInfoQuery.value(1).toInt(),
1856                                     (BufferInfo::Type)bufferInfoQuery.value(2).toInt(),
1857                                     0,
1858                                     bufferInfoQuery.value(4).toString());
1859             error = !bufferInfo.isValid();
1860         }
1861     }
1862     if (error) {
1863         db.rollback();
1864         unlock();
1865         return messagelist;
1866     }
1867
1868     {
1869         QSqlQuery query(db);
1870         if (last == -1 && first == -1) {
1871             query.prepare(queryString("select_messagesNewestK"));
1872         }
1873         else if (last == -1) {
1874             query.prepare(queryString("select_messagesNewerThan"));
1875             query.bindValue(":firstmsg", first.toQint64());
1876         }
1877         else {
1878             query.prepare(queryString("select_messagesRange"));
1879             query.bindValue(":lastmsg", last.toQint64());
1880             query.bindValue(":firstmsg", first.toQint64());
1881         }
1882         query.bindValue(":bufferid", bufferId.toInt());
1883         query.bindValue(":limit", limit);
1884
1885         safeExec(query);
1886         watchQuery(query);
1887
1888         while (query.next()) {
1889             Message msg(
1890                 // As of SQLite schema version 31, timestamps are stored in milliseconds instead of
1891                 // seconds.  This nets us more precision as well as simplifying 64-bit time.
1892                 QDateTime::fromMSecsSinceEpoch(query.value(1).toLongLong()),
1893                 bufferInfo,
1894                 (Message::Type)query.value(2).toInt(),
1895                 query.value(8).toString(),
1896                 query.value(4).toString(),
1897                 query.value(5).toString(),
1898                 query.value(6).toString(),
1899                 query.value(7).toString(),
1900                 (Message::Flags)query.value(3).toInt());
1901             msg.setMsgId(query.value(0).toLongLong());
1902             messagelist << msg;
1903         }
1904     }
1905     db.commit();
1906     unlock();
1907
1908     return messagelist;
1909 }
1910
1911 QList<Message> SqliteStorage::requestMsgsFiltered(
1912     UserId user, BufferId bufferId, MsgId first, MsgId last, int limit, Message::Types type, Message::Flags flags)
1913 {
1914     QList<Message> messagelist;
1915
1916     QSqlDatabase db = logDb();
1917     db.transaction();
1918
1919     bool error = false;
1920     BufferInfo bufferInfo;
1921     {
1922         // code dupication from getBufferInfo:
1923         // this is due to the impossibility of nesting transactions and recursive locking
1924         QSqlQuery bufferInfoQuery(db);
1925         bufferInfoQuery.prepare(queryString("select_buffer_by_id"));
1926         bufferInfoQuery.bindValue(":userid", user.toInt());
1927         bufferInfoQuery.bindValue(":bufferid", bufferId.toInt());
1928
1929         lockForRead();
1930         safeExec(bufferInfoQuery);
1931         error = !watchQuery(bufferInfoQuery) || !bufferInfoQuery.first();
1932         if (!error) {
1933             bufferInfo = BufferInfo(bufferInfoQuery.value(0).toInt(),
1934                                     bufferInfoQuery.value(1).toInt(),
1935                                     (BufferInfo::Type)bufferInfoQuery.value(2).toInt(),
1936                                     0,
1937                                     bufferInfoQuery.value(4).toString());
1938             error = !bufferInfo.isValid();
1939         }
1940     }
1941     if (error) {
1942         db.rollback();
1943         unlock();
1944         return messagelist;
1945     }
1946
1947     {
1948         QSqlQuery query(db);
1949         if (last == -1 && first == -1) {
1950             query.prepare(queryString("select_messagesNewestK_filtered"));
1951         }
1952         else if (last == -1) {
1953             query.prepare(queryString("select_messagesNewerThan_filtered"));
1954             query.bindValue(":firstmsg", first.toQint64());
1955         }
1956         else {
1957             query.prepare(queryString("select_messagesRange_filtered"));
1958             query.bindValue(":lastmsg", last.toQint64());
1959             query.bindValue(":firstmsg", first.toQint64());
1960         }
1961         query.bindValue(":bufferid", bufferId.toInt());
1962         query.bindValue(":limit", limit);
1963         int typeRaw = type;
1964         query.bindValue(":type", typeRaw);
1965         int flagsRaw = flags;
1966         query.bindValue(":flags", flagsRaw);
1967
1968         safeExec(query);
1969         watchQuery(query);
1970
1971         while (query.next()) {
1972             Message msg(
1973                 // As of SQLite schema version 31, timestamps are stored in milliseconds
1974                 // instead of seconds.  This nets us more precision as well as simplifying
1975                 // 64-bit time.
1976                 QDateTime::fromMSecsSinceEpoch(query.value(1).toLongLong()),
1977                 bufferInfo,
1978                 (Message::Type)query.value(2).toInt(),
1979                 query.value(8).toString(),
1980                 query.value(4).toString(),
1981                 query.value(5).toString(),
1982                 query.value(6).toString(),
1983                 query.value(7).toString(),
1984                 Message::Flags{query.value(3).toInt()});
1985             msg.setMsgId(query.value(0).toLongLong());
1986             messagelist << msg;
1987         }
1988     }
1989     db.commit();
1990     unlock();
1991
1992     return messagelist;
1993 }
1994
1995 QList<Message> SqliteStorage::requestAllMsgs(UserId user, MsgId first, MsgId last, int limit)
1996 {
1997     QList<Message> messagelist;
1998
1999     QSqlDatabase db = logDb();
2000     db.transaction();
2001
2002     QHash<BufferId, BufferInfo> bufferInfoHash;
2003     {
2004         QSqlQuery bufferInfoQuery(db);
2005         bufferInfoQuery.prepare(queryString("select_buffers"));
2006         bufferInfoQuery.bindValue(":userid", user.toInt());
2007
2008         lockForRead();
2009         safeExec(bufferInfoQuery);
2010         watchQuery(bufferInfoQuery);
2011         while (bufferInfoQuery.next()) {
2012             BufferInfo bufferInfo = BufferInfo(bufferInfoQuery.value(0).toInt(),
2013                                                bufferInfoQuery.value(1).toInt(),
2014                                                (BufferInfo::Type)bufferInfoQuery.value(2).toInt(),
2015                                                bufferInfoQuery.value(3).toInt(),
2016                                                bufferInfoQuery.value(4).toString());
2017             bufferInfoHash[bufferInfo.bufferId()] = bufferInfo;
2018         }
2019
2020         QSqlQuery query(db);
2021         if (last == -1) {
2022             query.prepare(queryString("select_messagesAllNew"));
2023         }
2024         else {
2025             query.prepare(queryString("select_messagesAll"));
2026             query.bindValue(":lastmsg", last.toQint64());
2027         }
2028         query.bindValue(":userid", user.toInt());
2029         query.bindValue(":firstmsg", first.toQint64());
2030         query.bindValue(":limit", limit);
2031         safeExec(query);
2032
2033         watchQuery(query);
2034
2035         while (query.next()) {
2036             Message msg(
2037                 // As of SQLite schema version 31, timestamps are stored in milliseconds instead of
2038                 // seconds.  This nets us more precision as well as simplifying 64-bit time.
2039                 QDateTime::fromMSecsSinceEpoch(query.value(2).toLongLong()),
2040                 bufferInfoHash[query.value(1).toInt()],
2041                 (Message::Type)query.value(3).toInt(),
2042                 query.value(9).toString(),
2043                 query.value(5).toString(),
2044                 query.value(6).toString(),
2045                 query.value(7).toString(),
2046                 query.value(8).toString(),
2047                 (Message::Flags)query.value(4).toInt());
2048             msg.setMsgId(query.value(0).toLongLong());
2049             messagelist << msg;
2050         }
2051     }
2052     db.commit();
2053     unlock();
2054     return messagelist;
2055 }
2056
2057 QList<Message> SqliteStorage::requestAllMsgsFiltered(UserId user, MsgId first, MsgId last, int limit, Message::Types type, Message::Flags flags)
2058 {
2059     QList<Message> messagelist;
2060
2061     QSqlDatabase db = logDb();
2062     db.transaction();
2063
2064     QHash<BufferId, BufferInfo> bufferInfoHash;
2065     {
2066         QSqlQuery bufferInfoQuery(db);
2067         bufferInfoQuery.prepare(queryString("select_buffers"));
2068         bufferInfoQuery.bindValue(":userid", user.toInt());
2069
2070         lockForRead();
2071         safeExec(bufferInfoQuery);
2072         watchQuery(bufferInfoQuery);
2073         while (bufferInfoQuery.next()) {
2074             BufferInfo bufferInfo = BufferInfo(bufferInfoQuery.value(0).toInt(),
2075                                                bufferInfoQuery.value(1).toInt(),
2076                                                (BufferInfo::Type)bufferInfoQuery.value(2).toInt(),
2077                                                bufferInfoQuery.value(3).toInt(),
2078                                                bufferInfoQuery.value(4).toString());
2079             bufferInfoHash[bufferInfo.bufferId()] = bufferInfo;
2080         }
2081
2082         QSqlQuery query(db);
2083         if (last == -1) {
2084             query.prepare(queryString("select_messagesAllNew_filtered"));
2085         }
2086         else {
2087             query.prepare(queryString("select_messagesAll_filtered"));
2088             query.bindValue(":lastmsg", last.toQint64());
2089         }
2090         query.bindValue(":userid", user.toInt());
2091         query.bindValue(":firstmsg", first.toQint64());
2092         query.bindValue(":limit", limit);
2093         int typeRaw = type;
2094         query.bindValue(":type", typeRaw);
2095         int flagsRaw = flags;
2096         query.bindValue(":flags", flagsRaw);
2097         safeExec(query);
2098
2099         watchQuery(query);
2100
2101         while (query.next()) {
2102             Message msg(
2103                 // As of SQLite schema version 31, timestamps are stored in milliseconds
2104                 // instead of seconds.  This nets us more precision as well as simplifying
2105                 // 64-bit time.
2106                 QDateTime::fromMSecsSinceEpoch(query.value(2).toLongLong()),
2107                 bufferInfoHash[query.value(1).toInt()],
2108                 (Message::Type)query.value(3).toInt(),
2109                 query.value(9).toString(),
2110                 query.value(5).toString(),
2111                 query.value(6).toString(),
2112                 query.value(7).toString(),
2113                 query.value(8).toString(),
2114                 Message::Flags{query.value(4).toInt()});
2115             msg.setMsgId(query.value(0).toLongLong());
2116             messagelist << msg;
2117         }
2118     }
2119     db.commit();
2120     unlock();
2121     return messagelist;
2122 }
2123
2124 QMap<UserId, QString> SqliteStorage::getAllAuthUserNames()
2125 {
2126     QMap<UserId, QString> authusernames;
2127
2128     QSqlDatabase db = logDb();
2129     db.transaction();
2130     {
2131         QSqlQuery query(db);
2132         query.prepare(queryString("select_all_authusernames"));
2133
2134         lockForRead();
2135         safeExec(query);
2136         watchQuery(query);
2137         while (query.next()) {
2138             authusernames[query.value(0).toInt()] = query.value(1).toString();
2139         }
2140     }
2141     db.commit();
2142     unlock();
2143     return authusernames;
2144 }
2145
2146 QString SqliteStorage::backlogFile()
2147 {
2148     return Quassel::configDirPath() + "quassel-storage.sqlite";
2149 }
2150
2151 bool SqliteStorage::safeExec(QSqlQuery& query, int retryCount)
2152 {
2153     query.exec();
2154
2155     if (!query.lastError().isValid())
2156         return true;
2157
2158     switch (query.lastError().number()) {
2159     case 5:  // SQLITE_BUSY         5   /* The database file is locked */
2160              // fallthrough
2161     case 6:  // SQLITE_LOCKED       6   /* A table in the database is locked */
2162         if (retryCount < _maxRetryCount)
2163             return safeExec(query, retryCount + 1);
2164         break;
2165     default:
2166         ;
2167     }
2168     return false;
2169 }
2170
2171 // ========================================
2172 //  SqliteMigration
2173 // ========================================
2174 SqliteMigrationReader::SqliteMigrationReader()
2175     : SqliteStorage()
2176 {}
2177
2178 void SqliteMigrationReader::setMaxId(MigrationObject mo)
2179 {
2180     QString queryString;
2181     switch (mo) {
2182     case Sender:
2183         queryString = "SELECT max(senderid) FROM sender";
2184         break;
2185     case Backlog:
2186         queryString = "SELECT max(messageid) FROM backlog";
2187         break;
2188     default:
2189         _maxId = 0;
2190         return;
2191     }
2192     QSqlQuery query = logDb().exec(queryString);
2193     query.first();
2194     _maxId = query.value(0).toLongLong();
2195 }
2196
2197 bool SqliteMigrationReader::prepareQuery(MigrationObject mo)
2198 {
2199     setMaxId(mo);
2200
2201     switch (mo) {
2202     case QuasselUser:
2203         newQuery(queryString("migrate_read_quasseluser"), logDb());
2204         break;
2205     case Identity:
2206         newQuery(queryString("migrate_read_identity"), logDb());
2207         break;
2208     case IdentityNick:
2209         newQuery(queryString("migrate_read_identity_nick"), logDb());
2210         break;
2211     case Network:
2212         newQuery(queryString("migrate_read_network"), logDb());
2213         break;
2214     case Buffer:
2215         newQuery(queryString("migrate_read_buffer"), logDb());
2216         break;
2217     case Sender:
2218         newQuery(queryString("migrate_read_sender"), logDb());
2219         bindValue(0, 0);
2220         bindValue(1, stepSize());
2221         break;
2222     case Backlog:
2223         newQuery(queryString("migrate_read_backlog"), logDb());
2224         bindValue(0, 0);
2225         bindValue(1, stepSize());
2226         break;
2227     case IrcServer:
2228         newQuery(queryString("migrate_read_ircserver"), logDb());
2229         break;
2230     case UserSetting:
2231         newQuery(queryString("migrate_read_usersetting"), logDb());
2232         break;
2233     case CoreState:
2234         newQuery(queryString("migrate_read_corestate"), logDb());
2235         break;
2236     }
2237     return exec();
2238 }
2239
2240 bool SqliteMigrationReader::readMo(QuasselUserMO& user)
2241 {
2242     if (!next())
2243         return false;
2244
2245     user.id = value(0).toInt();
2246     user.username = value(1).toString();
2247     user.password = value(2).toString();
2248     user.hashversion = value(3).toInt();
2249     user.authenticator = value(4).toString();
2250     return true;
2251 }
2252
2253 bool SqliteMigrationReader::readMo(IdentityMO& identity)
2254 {
2255     if (!next())
2256         return false;
2257
2258     identity.id = value(0).toInt();
2259     identity.userid = value(1).toInt();
2260     identity.identityname = value(2).toString();
2261     identity.realname = value(3).toString();
2262     identity.awayNick = value(4).toString();
2263     identity.awayNickEnabled = value(5).toInt() == 1 ? true : false;
2264     identity.awayReason = value(6).toString();
2265     identity.awayReasonEnabled = value(7).toInt() == 1 ? true : false;
2266     identity.autoAwayEnabled = value(8).toInt() == 1 ? true : false;
2267     identity.autoAwayTime = value(9).toInt();
2268     identity.autoAwayReason = value(10).toString();
2269     identity.autoAwayReasonEnabled = value(11).toInt() == 1 ? true : false;
2270     identity.detachAwayEnabled = value(12).toInt() == 1 ? true : false;
2271     identity.detachAwayReason = value(13).toString();
2272     identity.detachAwayReasonEnabled = value(14).toInt() == 1 ? true : false;
2273     identity.ident = value(15).toString();
2274     identity.kickReason = value(16).toString();
2275     identity.partReason = value(17).toString();
2276     identity.quitReason = value(18).toString();
2277     identity.sslCert = value(19).toByteArray();
2278     identity.sslKey = value(20).toByteArray();
2279     return true;
2280 }
2281
2282 bool SqliteMigrationReader::readMo(IdentityNickMO& identityNick)
2283 {
2284     if (!next())
2285         return false;
2286
2287     identityNick.nickid = value(0).toInt();
2288     identityNick.identityId = value(1).toInt();
2289     identityNick.nick = value(2).toString();
2290     return true;
2291 }
2292
2293 bool SqliteMigrationReader::readMo(NetworkMO& network)
2294 {
2295     if (!next())
2296         return false;
2297
2298     network.networkid = value(0).toInt();
2299     network.userid = value(1).toInt();
2300     network.networkname = value(2).toString();
2301     network.identityid = value(3).toInt();
2302     network.encodingcodec = value(4).toString();
2303     network.decodingcodec = value(5).toString();
2304     network.servercodec = value(6).toString();
2305     network.userandomserver = value(7).toInt() == 1 ? true : false;
2306     network.perform = value(8).toString();
2307     network.useautoidentify = value(9).toInt() == 1 ? true : false;
2308     network.autoidentifyservice = value(10).toString();
2309     network.autoidentifypassword = value(11).toString();
2310     network.useautoreconnect = value(12).toInt() == 1 ? true : false;
2311     network.autoreconnectinterval = value(13).toInt();
2312     network.autoreconnectretries = value(14).toInt();
2313     network.unlimitedconnectretries = value(15).toInt() == 1 ? true : false;
2314     network.rejoinchannels = value(16).toInt() == 1 ? true : false;
2315     network.connected = value(17).toInt() == 1 ? true : false;
2316     network.usermode = value(18).toString();
2317     network.awaymessage = value(19).toString();
2318     network.attachperform = value(20).toString();
2319     network.detachperform = value(21).toString();
2320     network.usesasl = value(22).toInt() == 1 ? true : false;
2321     network.saslaccount = value(23).toString();
2322     network.saslpassword = value(24).toString();
2323     // Custom rate limiting
2324     network.usecustommessagerate = value(25).toInt() == 1 ? true : false;
2325     network.messagerateburstsize = value(26).toInt();
2326     network.messageratedelay = value(27).toUInt();
2327     network.unlimitedmessagerate = value(28).toInt() == 1 ? true : false;
2328     return true;
2329 }
2330
2331 bool SqliteMigrationReader::readMo(BufferMO& buffer)
2332 {
2333     if (!next())
2334         return false;
2335
2336     buffer.bufferid = value(0).toInt();
2337     buffer.userid = value(1).toInt();
2338     buffer.groupid = value(2).toInt();
2339     buffer.networkid = value(3).toInt();
2340     buffer.buffername = value(4).toString();
2341     buffer.buffercname = value(5).toString();
2342     buffer.buffertype = value(6).toInt();
2343     buffer.lastmsgid = value(7).toLongLong();
2344     buffer.lastseenmsgid = value(8).toLongLong();
2345     buffer.markerlinemsgid = value(9).toLongLong();
2346     buffer.bufferactivity = value(10).toInt();
2347     buffer.highlightcount = value(11).toInt();
2348     buffer.key = value(12).toString();
2349     buffer.joined = value(13).toInt() == 1 ? true : false;
2350     buffer.cipher = value(14).toString();
2351     return true;
2352 }
2353
2354 bool SqliteMigrationReader::readMo(SenderMO& sender)
2355 {
2356     int skipSteps = 0;
2357     while (!next()) {
2358         if (sender.senderId < _maxId) {
2359             bindValue(0, sender.senderId + (skipSteps * stepSize()));
2360             bindValue(1, sender.senderId + ((skipSteps + 1) * stepSize()));
2361             skipSteps++;
2362             if (!exec())
2363                 return false;
2364         }
2365         else {
2366             return false;
2367         }
2368     }
2369
2370     sender.senderId = value(0).toLongLong();
2371     sender.sender = value(1).toString();
2372     sender.realname = value(2).toString();
2373     sender.avatarurl = value(3).toString();
2374     return true;
2375 }
2376
2377 bool SqliteMigrationReader::readMo(BacklogMO& backlog)
2378 {
2379     qint64 skipSteps = 0;
2380     while (!next()) {
2381         if (backlog.messageid < _maxId) {
2382             bindValue(0, backlog.messageid.toQint64() + (skipSteps * stepSize()));
2383             bindValue(1, backlog.messageid.toQint64() + ((skipSteps + 1) * stepSize()));
2384             skipSteps++;
2385             if (!exec())
2386                 return false;
2387         }
2388         else {
2389             return false;
2390         }
2391     }
2392
2393     backlog.messageid = value(0).toLongLong();
2394     // As of SQLite schema version 31, timestamps are stored in milliseconds instead of
2395     // seconds.  This nets us more precision as well as simplifying 64-bit time.
2396     backlog.time = QDateTime::fromMSecsSinceEpoch(value(1).toLongLong()).toUTC();
2397     backlog.bufferid = value(2).toInt();
2398     backlog.type = value(3).toInt();
2399     backlog.flags = value(4).toInt();
2400     backlog.senderid = value(5).toLongLong();
2401     backlog.senderprefixes = value(6).toString();
2402     backlog.message = value(7).toString();
2403     return true;
2404 }
2405
2406 bool SqliteMigrationReader::readMo(IrcServerMO& ircserver)
2407 {
2408     if (!next())
2409         return false;
2410
2411     ircserver.serverid = value(0).toInt();
2412     ircserver.userid = value(1).toInt();
2413     ircserver.networkid = value(2).toInt();
2414     ircserver.hostname = value(3).toString();
2415     ircserver.port = value(4).toInt();
2416     ircserver.password = value(5).toString();
2417     ircserver.ssl = value(6).toInt() == 1 ? true : false;
2418     ircserver.sslversion = value(7).toInt();
2419     ircserver.useproxy = value(8).toInt() == 1 ? true : false;
2420     ircserver.proxytype = value(9).toInt();
2421     ircserver.proxyhost = value(10).toString();
2422     ircserver.proxyport = value(11).toInt();
2423     ircserver.proxyuser = value(12).toString();
2424     ircserver.proxypass = value(13).toString();
2425     ircserver.sslverify = value(14).toInt() == 1 ? true : false;
2426     return true;
2427 }
2428
2429 bool SqliteMigrationReader::readMo(UserSettingMO& userSetting)
2430 {
2431     if (!next())
2432         return false;
2433
2434     userSetting.userid = value(0).toInt();
2435     userSetting.settingname = value(1).toString();
2436     userSetting.settingvalue = value(2).toByteArray();
2437
2438     return true;
2439 }
2440
2441 bool SqliteMigrationReader::readMo(CoreStateMO& coreState)
2442 {
2443     if (!next())
2444         return false;
2445
2446     coreState.key = value(0).toString();
2447     coreState.value = value(1).toByteArray();
2448
2449     return true;
2450 }