src/core/postgresqlstorage.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2005-07 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 "postgresqlstorage.h"
  22
  23 #include <QtSql>
  24
  25 #include "logger.h"
  26 #include "network.h"
  27 #include "quassel.h"
  28
  29 PostgreSqlStorage::PostgreSqlStorage(QObject *parent)
  30   : AbstractSqlStorage(parent),
  31     _port(-1)
  32 {
  33 }
  34
  35 PostgreSqlStorage::~PostgreSqlStorage() {
  36 }
  37
  38 bool PostgreSqlStorage::isAvailable() const {
  39   if(!QSqlDatabase::isDriverAvailable("QPSQL")) return false;
  40   return true;
  41 }
  42
  43 QString PostgreSqlStorage::displayName() const {
  44   return QString("PostgreSQL");
  45 }
  46
  47 QString PostgreSqlStorage::description() const {
  48   // FIXME: proper description
  49   return tr("PostgreSQL Turbo Bomber HD!");
  50 }
  51
  52 QVariantMap PostgreSqlStorage::setupKeys() const {
  53   QVariantMap map;
  54   map["Username"] = QVariant(QString("quassel"));
  55   map["Password"] = QVariant(QString());
  56   map["Hostname"] = QVariant(QString("localhost"));
  57   map["Port"] = QVariant(5432);
  58   map["Database"] = QVariant(QString("quassel"));
  59   return map;
  60 }
  61
  62 void PostgreSqlStorage::setConnectionProperties(const QVariantMap &properties) {
  63   _userName = properties["Username"].toString();
  64   _password = properties["Password"].toString();
  65   _hostName = properties["Hostname"].toString();
  66   _port = properties["Port"].toInt();
  67   _databaseName = properties["Database"].toString();
  68 }
  69
  70 int PostgreSqlStorage::installedSchemaVersion() {
  71   QSqlQuery query = logDb().exec("SELECT value FROM coreinfo WHERE key = 'schemaversion'");
  72   if(query.first())
  73     return query.value(0).toInt();
  74
  75   // maybe it's really old... (schema version 0)
  76   query = logDb().exec("SELECT MAX(version) FROM coreinfo");
  77   if(query.first())
  78     return query.value(0).toInt();
  79
  80   return AbstractSqlStorage::installedSchemaVersion();
  81 }
  82
  83 bool PostgreSqlStorage::updateSchemaVersion(int newVersion) {
  84   QSqlQuery query(logDb());
  85   query.prepare("UPDATE coreinfo SET value = :version WHERE key = 'schemaversion'");
  86   query.bindValue(":version", newVersion);
  87   query.exec();
  88
  89   bool success = true;
  90   if(query.lastError().isValid()) {
  91     qCritical() << "PostgreSqlStorage::updateSchemaVersion(int): Updating schema version failed!";
  92     success = false;
  93   }
  94   return success;
  95 }
  96
  97 bool PostgreSqlStorage::setupSchemaVersion(int version) {
  98   QSqlQuery query(logDb());
  99   query.prepare("INSERT INTO coreinfo (key, value) VALUES ('schemaversion', :version)");
 100   query.bindValue(":version", version);
 101   query.exec();
 102
 103   bool success = true;
 104   if(query.lastError().isValid()) {
 105     qCritical() << "PostgreSqlStorage::setupSchemaVersion(int): Updating schema version failed!";
 106     success = false;
 107   }
 108   return success;
 109 }
 110
 111 UserId PostgreSqlStorage::addUser(const QString &user, const QString &password) {
 112   QSqlQuery query(logDb());
 113   query.prepare(queryString("insert_quasseluser"));
 114   query.bindValue(":username", user);
 115   query.bindValue(":password", cryptedPassword(password));
 116   safeExec(query);
 117   if(!watchQuery(query))
 118     return 0;
 119
 120   query.first();
 121   UserId uid = query.value(0).toInt();
 122   emit userAdded(uid, user);
 123   return uid;
 124 }
 125
 126 void PostgreSqlStorage::updateUser(UserId user, const QString &password) {
 127   QSqlQuery query(logDb());
 128   query.prepare(queryString("update_userpassword"));
 129   query.bindValue(":userid", user.toInt());
 130   query.bindValue(":password", cryptedPassword(password));
 131   safeExec(query);
 132 }
 133
 134 void PostgreSqlStorage::renameUser(UserId user, const QString &newName) {
 135   QSqlQuery query(logDb());
 136   query.prepare(queryString("update_username"));
 137   query.bindValue(":userid", user.toInt());
 138   query.bindValue(":username", newName);
 139   safeExec(query);
 140   emit userRenamed(user, newName);
 141 }
 142
 143 UserId PostgreSqlStorage::validateUser(const QString &user, const QString &password) {
 144   QSqlQuery query(logDb());
 145   query.prepare(queryString("select_authuser"));
 146   query.bindValue(":username", user);
 147   query.bindValue(":password", cryptedPassword(password));
 148   safeExec(query);
 149
 150   if(query.first()) {
 151     return query.value(0).toInt();
 152   } else {
 153     return 0;
 154   }
 155 }
 156
 157 UserId PostgreSqlStorage::internalUser() {
 158   QSqlQuery query(logDb());
 159   query.prepare(queryString("select_internaluser"));
 160   safeExec(query);
 161
 162   if(query.first()) {
 163     return query.value(0).toInt();
 164   } else {
 165     return 0;
 166   }
 167 }
 168
 169 void PostgreSqlStorage::delUser(UserId user) {
 170   QSqlDatabase db = logDb();
 171   if(!db.transaction()) {
 172     qWarning() << "PostgreSqlStorage::delUser(): cannot start transaction!";
 173     return;
 174   }
 175
 176   QSqlQuery query(db);
 177   query.prepare(queryString("delete_quasseluser"));
 178   query.bindValue(":userid", user.toInt());
 179   safeExec(query);
 180   if(!watchQuery(query)) {
 181     db.rollback();
 182     return;
 183   } else {
 184     db.commit();
 185     emit userRemoved(user);
 186   }
 187 }
 188
 189 void PostgreSqlStorage::setUserSetting(UserId userId, const QString &settingName, const QVariant &data) {
 190   QByteArray rawData;
 191   QDataStream out(&rawData, QIODevice::WriteOnly);
 192   out.setVersion(QDataStream::Qt_4_2);
 193   out << data;
 194
 195   QSqlDatabase db = logDb();
 196   QSqlQuery query(db);
 197   query.prepare(queryString("insert_user_setting"));
 198   query.bindValue(":userid", userId.toInt());
 199   query.bindValue(":settingname", settingName);
 200   query.bindValue(":settingvalue", rawData);
 201   safeExec(query);
 202
 203   if(query.lastError().isValid()) {
 204     QSqlQuery updateQuery(db);
 205     updateQuery.prepare(queryString("update_user_setting"));
 206     updateQuery.bindValue(":userid", userId.toInt());
 207     updateQuery.bindValue(":settingname", settingName);
 208     updateQuery.bindValue(":settingvalue", rawData);
 209     safeExec(updateQuery);
 210   }
 211
 212 }
 213
 214 QVariant PostgreSqlStorage::getUserSetting(UserId userId, const QString &settingName, const QVariant &defaultData) {
 215   QSqlQuery query(logDb());
 216   query.prepare(queryString("select_user_setting"));
 217   query.bindValue(":userid", userId.toInt());
 218   query.bindValue(":settingname", settingName);
 219   safeExec(query);
 220
 221   if(query.first()) {
 222     QVariant data;
 223     QByteArray rawData = query.value(0).toByteArray();
 224     QDataStream in(&rawData, QIODevice::ReadOnly);
 225     in.setVersion(QDataStream::Qt_4_2);
 226     in >> data;
 227     return data;
 228   } else {
 229     return defaultData;
 230   }
 231 }
 232
 233 IdentityId PostgreSqlStorage::createIdentity(UserId user, CoreIdentity &identity) {
 234   IdentityId identityId;
 235
 236   QSqlDatabase db = logDb();
 237   if(!db.transaction()) {
 238     qWarning() << "PostgreSqlStorage::createIdentity(): Unable to start Transaction!";
 239     qWarning() << " -" << qPrintable(db.lastError().text());
 240     return identityId;
 241   }
 242
 243   QSqlQuery query(db);
 244   query.prepare(queryString("insert_identity"));
 245   query.bindValue(":userid", user.toInt());
 246   query.bindValue(":identityname", identity.identityName());
 247   query.bindValue(":realname", identity.realName());
 248   query.bindValue(":awaynick", identity.awayNick());
 249   query.bindValue(":awaynickenabled", identity.awayNickEnabled());
 250   query.bindValue(":awayreason", identity.awayReason());
 251   query.bindValue(":awayreasonenabled", identity.awayReasonEnabled());
 252   query.bindValue(":autoawayenabled", identity.awayReasonEnabled());
 253   query.bindValue(":autoawaytime", identity.autoAwayTime());
 254   query.bindValue(":autoawayreason", identity.autoAwayReason());
 255   query.bindValue(":autoawayreasonenabled", identity.autoAwayReasonEnabled());
 256   query.bindValue(":detachawayenabled", identity.detachAwayEnabled());
 257   query.bindValue(":detachawayreason", identity.detachAwayReason());
 258   query.bindValue(":detachawayreasonenabled", identity.detachAwayReasonEnabled());
 259   query.bindValue(":ident", identity.ident());
 260   query.bindValue(":kickreason", identity.kickReason());
 261   query.bindValue(":partreason", identity.partReason());
 262   query.bindValue(":quitreason", identity.quitReason());
 263 #ifdef HAVE_SSL
 264   query.bindValue(":sslcert", identity.sslCert().toPem());
 265   query.bindValue(":sslkey", identity.sslKey().toPem());
 266 #else
 267   query.bindValue(":sslcert", QByteArray());
 268   query.bindValue(":sslkey", QByteArray());
 269 #endif
 270   safeExec(query);
 271   if(query.lastError().isValid()) {
 272     watchQuery(query);
 273     db.rollback();
 274     return IdentityId();
 275   }
 276
 277   query.first();
 278   identityId = query.value(0).toInt();
 279   identity.setId(identityId);
 280
 281   if(!identityId.isValid()) {
 282     watchQuery(query);
 283     db.rollback();
 284     return IdentityId();
 285   }
 286
 287   QSqlQuery insertNickQuery(db);
 288   insertNickQuery.prepare(queryString("insert_nick"));
 289   foreach(QString nick, identity.nicks()) {
 290     insertNickQuery.bindValue(":identityid", identityId.toInt());
 291     insertNickQuery.bindValue(":nick", nick);
 292     safeExec(insertNickQuery);
 293     if(!watchQuery(insertNickQuery)) {
 294       db.rollback();
 295       return IdentityId();
 296     }
 297   }
 298
 299   if(!db.commit()) {
 300     qWarning() << "PostgreSqlStorage::createIdentity(): commiting data failed!";
 301     qWarning() << " -" << qPrintable(db.lastError().text());
 302     return IdentityId();
 303   }
 304   return identityId;
 305 }
 306
 307 bool PostgreSqlStorage::updateIdentity(UserId user, const CoreIdentity &identity) {
 308   QSqlDatabase db = logDb();
 309   if(!db.transaction()) {
 310     qWarning() << "PostgreSqlStorage::updateIdentity(): Unable to start Transaction!";
 311     qWarning() << " -" << qPrintable(db.lastError().text());
 312     return false;
 313   }
 314
 315   QSqlQuery checkQuery(db);
 316   checkQuery.prepare(queryString("select_checkidentity"));
 317   checkQuery.bindValue(":identityid", identity.id().toInt());
 318   checkQuery.bindValue(":userid", user.toInt());
 319   safeExec(checkQuery);
 320
 321   // there should be exactly one identity for the given id and user
 322   if(!checkQuery.first() || checkQuery.value(0).toInt() != 1) {
 323     db.rollback();
 324     return false;
 325   }
 326
 327   QSqlQuery query(db);
 328   query.prepare(queryString("update_identity"));
 329   query.bindValue(":identityname", identity.identityName());
 330   query.bindValue(":realname", identity.realName());
 331   query.bindValue(":awaynick", identity.awayNick());
 332   query.bindValue(":awaynickenabled", identity.awayNickEnabled());
 333   query.bindValue(":awayreason", identity.awayReason());
 334   query.bindValue(":awayreasonenabled", identity.awayReasonEnabled());
 335   query.bindValue(":autoawayenabled", identity.awayReasonEnabled());
 336   query.bindValue(":autoawaytime", identity.autoAwayTime());
 337   query.bindValue(":autoawayreason", identity.autoAwayReason());
 338   query.bindValue(":autoawayreasonenabled", identity.autoAwayReasonEnabled());
 339   query.bindValue(":detachawayenabled", identity.detachAwayEnabled());
 340   query.bindValue(":detachawayreason", identity.detachAwayReason());
 341   query.bindValue(":detachawayreasonenabled", identity.detachAwayReasonEnabled());
 342   query.bindValue(":ident", identity.ident());
 343   query.bindValue(":kickreason", identity.kickReason());
 344   query.bindValue(":partreason", identity.partReason());
 345   query.bindValue(":quitreason", identity.quitReason());
 346 #ifdef HAVE_SSL
 347   query.bindValue(":sslcert", identity.sslCert().toPem());
 348   query.bindValue(":sslkey", identity.sslKey().toPem());
 349 #else
 350   query.bindValue(":sslcert", QByteArray());
 351   query.bindValue(":sslkey", QByteArray());
 352 #endif
 353   query.bindValue(":identityid", identity.id().toInt());
 354
 355   safeExec(query);
 356   if(!watchQuery(query)) {
 357     db.rollback();
 358     return false;
 359   }
 360
 361   QSqlQuery deleteNickQuery(db);
 362   deleteNickQuery.prepare(queryString("delete_nicks"));
 363   deleteNickQuery.bindValue(":identityid", identity.id().toInt());
 364   safeExec(deleteNickQuery);
 365   if(!watchQuery(deleteNickQuery)) {
 366     db.rollback();
 367     return false;
 368   }
 369
 370   QSqlQuery insertNickQuery(db);
 371   insertNickQuery.prepare(queryString("insert_nick"));
 372   foreach(QString nick, identity.nicks()) {
 373     insertNickQuery.bindValue(":identityid", identity.id().toInt());
 374     insertNickQuery.bindValue(":nick", nick);
 375     safeExec(insertNickQuery);
 376     if(!watchQuery(insertNickQuery)) {
 377       db.rollback();
 378       return false;
 379     }
 380   }
 381
 382   if(!db.commit()) {
 383     qWarning() << "PostgreSqlStorage::updateIdentity(): commiting data failed!";
 384     qWarning() << " -" << qPrintable(db.lastError().text());
 385     return false;
 386   }
 387   return true;
 388 }
 389
 390 void PostgreSqlStorage::removeIdentity(UserId user, IdentityId identityId) {
 391   QSqlDatabase db = logDb();
 392   if(!db.transaction()) {
 393     qWarning() << "PostgreSqlStorage::removeIdentity(): Unable to start Transaction!";
 394     qWarning() << " -" << qPrintable(db.lastError().text());
 395     return;
 396   }
 397
 398   QSqlQuery query(db);
 399   query.prepare(queryString("delete_identity"));
 400   query.bindValue(":identityid", identityId.toInt());
 401   query.bindValue(":userid", user.toInt());
 402   safeExec(query);
 403   if(!watchQuery(query)) {
 404     db.rollback();
 405   } else {
 406     db.commit();
 407   }
 408 }
 409
 410 QList<CoreIdentity> PostgreSqlStorage::identities(UserId user) {
 411   QList<CoreIdentity> identities;
 412
 413   QSqlDatabase db = logDb();
 414   if(!beginReadOnlyTransaction(db)) {
 415     qWarning() << "PostgreSqlStorage::identites(): cannot start read only transaction!";
 416     qWarning() << " -" << qPrintable(db.lastError().text());
 417     return identities;
 418   }
 419
 420   QSqlQuery query(db);
 421   query.prepare(queryString("select_identities"));
 422   query.bindValue(":userid", user.toInt());
 423
 424   QSqlQuery nickQuery(db);
 425   nickQuery.prepare(queryString("select_nicks"));
 426
 427   safeExec(query);
 428
 429   while(query.next()) {
 430     CoreIdentity identity(IdentityId(query.value(0).toInt()));
 431
 432     identity.setIdentityName(query.value(1).toString());
 433     identity.setRealName(query.value(2).toString());
 434     identity.setAwayNick(query.value(3).toString());
 435     identity.setAwayNickEnabled(!!query.value(4).toInt());
 436     identity.setAwayReason(query.value(5).toString());
 437     identity.setAwayReasonEnabled(!!query.value(6).toInt());
 438     identity.setAutoAwayEnabled(!!query.value(7).toInt());
 439     identity.setAutoAwayTime(query.value(8).toInt());
 440     identity.setAutoAwayReason(query.value(9).toString());
 441     identity.setAutoAwayReasonEnabled(!!query.value(10).toInt());
 442     identity.setDetachAwayEnabled(!!query.value(11).toInt());
 443     identity.setDetachAwayReason(query.value(12).toString());
 444     identity.setDetachAwayReasonEnabled(!!query.value(13).toInt());
 445     identity.setIdent(query.value(14).toString());
 446     identity.setKickReason(query.value(15).toString());
 447     identity.setPartReason(query.value(16).toString());
 448     identity.setQuitReason(query.value(17).toString());
 449 #ifdef HAVE_SSL
 450     identity.setSslCert(query.value(18).toByteArray());
 451     identity.setSslKey(query.value(19).toByteArray());
 452 #endif
 453
 454     nickQuery.bindValue(":identityid", identity.id().toInt());
 455     QList<QString> nicks;
 456     safeExec(nickQuery);
 457     watchQuery(nickQuery);
 458     while(nickQuery.next()) {
 459       nicks << nickQuery.value(0).toString();
 460     }
 461     identity.setNicks(nicks);
 462     identities << identity;
 463   }
 464   db.commit();
 465   return identities;
 466 }
 467
 468 NetworkId PostgreSqlStorage::createNetwork(UserId user, const NetworkInfo &info) {
 469   NetworkId networkId;
 470
 471   QSqlDatabase db = logDb();
 472   if(!db.transaction()) {
 473     qWarning() << "PostgreSqlStorage::createNetwork(): failed to begin transaction!";
 474     qWarning() << " -" << qPrintable(db.lastError().text());
 475     return false;
 476   }
 477
 478   QSqlQuery query(db);
 479   query.prepare(queryString("insert_network"));
 480   query.bindValue(":userid", user.toInt());
 481   bindNetworkInfo(query, info);
 482   safeExec(query);
 483   if(query.lastError().isValid()) {
 484     watchQuery(query);
 485     db.rollback();
 486     return NetworkId();
 487   }
 488
 489   query.first();
 490   networkId = query.value(0).toInt();
 491
 492   if(!networkId.isValid()) {
 493     watchQuery(query);
 494     db.rollback();
 495     return NetworkId();
 496   }
 497
 498   QSqlQuery insertServersQuery(db);
 499   insertServersQuery.prepare(queryString("insert_server"));
 500   foreach(Network::Server server, info.serverList) {
 501     insertServersQuery.bindValue(":userid", user.toInt());
 502     insertServersQuery.bindValue(":networkid", networkId.toInt());
 503     bindServerInfo(insertServersQuery, server);
 504     safeExec(insertServersQuery);
 505     if(!watchQuery(insertServersQuery)) {
 506       db.rollback();
 507       return NetworkId();
 508     }
 509   }
 510
 511   if(!db.commit()) {
 512     qWarning() << "PostgreSqlStorage::updateNetwork(): commiting data failed!";
 513     qWarning() << " -" << qPrintable(db.lastError().text());
 514     return NetworkId();
 515   }
 516   return networkId;
 517 }
 518
 519 void PostgreSqlStorage::bindNetworkInfo(QSqlQuery &query, const NetworkInfo &info) {
 520   query.bindValue(":networkname", info.networkName);
 521   query.bindValue(":identityid", info.identity.toInt());
 522   query.bindValue(":encodingcodec", QString(info.codecForEncoding));
 523   query.bindValue(":decodingcodec", QString(info.codecForDecoding));
 524   query.bindValue(":servercodec", QString(info.codecForServer));
 525   query.bindValue(":userandomserver", info.useRandomServer);
 526   query.bindValue(":perform", info.perform.join("\n"));
 527   query.bindValue(":useautoidentify", info.useAutoIdentify);
 528   query.bindValue(":autoidentifyservice", info.autoIdentifyService);
 529   query.bindValue(":autoidentifypassword", info.autoIdentifyPassword);
 530   query.bindValue(":useautoreconnect", info.useAutoReconnect);
 531   query.bindValue(":autoreconnectinterval", info.autoReconnectInterval);
 532   query.bindValue(":autoreconnectretries", info.autoReconnectRetries);
 533   query.bindValue(":unlimitedconnectretries", info.unlimitedReconnectRetries);
 534   query.bindValue(":rejoinchannels", info.rejoinChannels);
 535   if(info.networkId.isValid())
 536     query.bindValue(":networkid", info.networkId.toInt());
 537 }
 538
 539 void PostgreSqlStorage::bindServerInfo(QSqlQuery &query, const Network::Server &server) {
 540   query.bindValue(":hostname", server.host);
 541   query.bindValue(":port", server.port);
 542   query.bindValue(":password", server.password);
 543   query.bindValue(":ssl", server.useSsl);
 544   query.bindValue(":sslversion", server.sslVersion);
 545   query.bindValue(":useproxy", server.useProxy);
 546   query.bindValue(":proxytype", server.proxyType);
 547   query.bindValue(":proxyhost", server.proxyHost);
 548   query.bindValue(":proxyport", server.proxyPort);
 549   query.bindValue(":proxyuser", server.proxyUser);
 550   query.bindValue(":proxypass", server.proxyPass);
 551 }
 552
 553 bool PostgreSqlStorage::updateNetwork(UserId user, const NetworkInfo &info) {
 554   QSqlDatabase db = logDb();
 555   if(!db.transaction()) {
 556     qWarning() << "PostgreSqlStorage::updateNetwork(): failed to begin transaction!";
 557     qWarning() << " -" << qPrintable(db.lastError().text());
 558     return false;
 559   }
 560
 561   QSqlQuery updateQuery(db);
 562   updateQuery.prepare(queryString("update_network"));
 563   updateQuery.bindValue(":userid", user.toInt());
 564   bindNetworkInfo(updateQuery, info);
 565   safeExec(updateQuery);
 566   if(!watchQuery(updateQuery)) {
 567     db.rollback();
 568     return false;
 569   }
 570   if(updateQuery.numRowsAffected() != 1) {
 571     // seems this is not our network...
 572     db.rollback();
 573     return false;
 574   }
 575
 576   QSqlQuery dropServersQuery(db);
 577   dropServersQuery.prepare("DELETE FROM ircserver WHERE networkid = :networkid");
 578   dropServersQuery.bindValue(":networkid", info.networkId.toInt());
 579   safeExec(dropServersQuery);
 580   if(!watchQuery(dropServersQuery)) {
 581     db.rollback();
 582     return false;
 583   }
 584
 585   QSqlQuery insertServersQuery(db);
 586   insertServersQuery.prepare(queryString("insert_server"));
 587   foreach(Network::Server server, info.serverList) {
 588     insertServersQuery.bindValue(":userid", user.toInt());
 589     insertServersQuery.bindValue(":networkid", info.networkId.toInt());
 590     bindServerInfo(insertServersQuery, server);
 591     safeExec(insertServersQuery);
 592     if(!watchQuery(insertServersQuery)) {
 593       db.rollback();
 594       return false;
 595     }
 596   }
 597
 598   if(!db.commit()) {
 599     qWarning() << "PostgreSqlStorage::updateNetwork(): commiting data failed!";
 600     qWarning() << " -" << qPrintable(db.lastError().text());
 601     return false;
 602   }
 603   return true;
 604 }
 605
 606 bool PostgreSqlStorage::removeNetwork(UserId user, const NetworkId &networkId) {
 607   QSqlDatabase db = logDb();
 608   if(!db.transaction()) {
 609     qWarning() << "PostgreSqlStorage::removeNetwork(): cannot start transaction!";
 610     qWarning() << " -" << qPrintable(db.lastError().text());
 611     return false;
 612   }
 613
 614   QSqlQuery query(db);
 615   query.prepare(queryString("delete_network"));
 616   query.bindValue(":userid", user.toInt());
 617   query.bindValue(":networkid", networkId.toInt());
 618   safeExec(query);
 619   if(!watchQuery(query)) {
 620     db.rollback();
 621     return false;
 622   }
 623
 624   db.commit();
 625   return true;
 626 }
 627
 628 QList<NetworkInfo> PostgreSqlStorage::networks(UserId user) {
 629   QList<NetworkInfo> nets;
 630
 631   QSqlDatabase db = logDb();
 632   if(!beginReadOnlyTransaction(db)) {
 633     qWarning() << "PostgreSqlStorage::networks(): cannot start read only transaction!";
 634     qWarning() << " -" << qPrintable(db.lastError().text());
 635     return nets;
 636   }
 637
 638   QSqlQuery networksQuery(db);
 639   networksQuery.prepare(queryString("select_networks_for_user"));
 640   networksQuery.bindValue(":userid", user.toInt());
 641
 642   QSqlQuery serversQuery(db);
 643   serversQuery.prepare(queryString("select_servers_for_network"));
 644
 645   safeExec(networksQuery);
 646   if(!watchQuery(networksQuery)) {
 647     db.rollback();
 648     return nets;
 649   }
 650
 651   while(networksQuery.next()) {
 652     NetworkInfo net;
 653     net.networkId = networksQuery.value(0).toInt();
 654     net.networkName = networksQuery.value(1).toString();
 655     net.identity = networksQuery.value(2).toInt();
 656     net.codecForServer = networksQuery.value(3).toString().toAscii();
 657     net.codecForEncoding = networksQuery.value(4).toString().toAscii();
 658     net.codecForDecoding = networksQuery.value(5).toString().toAscii();
 659     net.useRandomServer = networksQuery.value(6).toBool();
 660     net.perform = networksQuery.value(7).toString().split("\n");
 661     net.useAutoIdentify = networksQuery.value(8).toBool();
 662     net.autoIdentifyService = networksQuery.value(9).toString();
 663     net.autoIdentifyPassword = networksQuery.value(10).toString();
 664     net.useAutoReconnect = networksQuery.value(11).toBool();
 665     net.autoReconnectInterval = networksQuery.value(12).toUInt();
 666     net.autoReconnectRetries = networksQuery.value(13).toInt();
 667     net.unlimitedReconnectRetries = networksQuery.value(14).toBool();
 668     net.rejoinChannels = networksQuery.value(15).toBool();
 669
 670     serversQuery.bindValue(":networkid", net.networkId.toInt());
 671     safeExec(serversQuery);
 672     if(!watchQuery(serversQuery)) {
 673       db.rollback();
 674       return nets;
 675     }
 676
 677     Network::ServerList servers;
 678     while(serversQuery.next()) {
 679       Network::Server server;
 680       server.host = serversQuery.value(0).toString();
 681       server.port = serversQuery.value(1).toUInt();
 682       server.password = serversQuery.value(2).toString();
 683       server.useSsl = serversQuery.value(3).toBool();
 684       server.sslVersion = serversQuery.value(4).toInt();
 685       server.useProxy = serversQuery.value(5).toBool();
 686       server.proxyType = serversQuery.value(6).toInt();
 687       server.proxyHost = serversQuery.value(7).toString();
 688       server.proxyPort = serversQuery.value(8).toUInt();
 689       server.proxyUser = serversQuery.value(9).toString();
 690       server.proxyPass = serversQuery.value(10).toString();
 691       servers << server;
 692     }
 693     net.serverList = servers;
 694     nets << net;
 695   }
 696   db.commit();
 697   return nets;
 698 }
 699
 700 QList<NetworkId> PostgreSqlStorage::connectedNetworks(UserId user) {
 701   QList<NetworkId> connectedNets;
 702
 703   QSqlDatabase db = logDb();
 704   if(!beginReadOnlyTransaction(db)) {
 705     qWarning() << "PostgreSqlStorage::connectedNetworks(): cannot start read only transaction!";
 706     qWarning() << " -" << qPrintable(db.lastError().text());
 707     return connectedNets;
 708   }
 709
 710   QSqlQuery query(db);
 711   query.prepare(queryString("select_connected_networks"));
 712   query.bindValue(":userid", user.toInt());
 713   safeExec(query);
 714   watchQuery(query);
 715
 716   while(query.next()) {
 717     connectedNets << query.value(0).toInt();
 718   }
 719
 720   db.commit();
 721   return connectedNets;
 722 }
 723
 724 void PostgreSqlStorage::setNetworkConnected(UserId user, const NetworkId &networkId, bool isConnected) {
 725   QSqlQuery query(logDb());
 726   query.prepare(queryString("update_network_connected"));
 727   query.bindValue(":userid", user.toInt());
 728   query.bindValue(":networkid", networkId.toInt());
 729   query.bindValue(":connected", isConnected);
 730   safeExec(query);
 731   watchQuery(query);
 732 }
 733
 734 QHash<QString, QString> PostgreSqlStorage::persistentChannels(UserId user, const NetworkId &networkId) {
 735   QHash<QString, QString> persistentChans;
 736
 737   QSqlDatabase db = logDb();
 738   if(!beginReadOnlyTransaction(db)) {
 739     qWarning() << "PostgreSqlStorage::persistentChannels(): cannot start read only transaction!";
 740     qWarning() << " -" << qPrintable(db.lastError().text());
 741     return persistentChans;
 742   }
 743
 744   QSqlQuery query(db);
 745   query.prepare(queryString("select_persistent_channels"));
 746   query.bindValue(":userid", user.toInt());
 747   query.bindValue(":networkid", networkId.toInt());
 748   safeExec(query);
 749   watchQuery(query);
 750
 751   while(query.next()) {
 752     persistentChans[query.value(0).toString()] = query.value(1).toString();
 753   }
 754
 755   db.commit();
 756   return persistentChans;
 757 }
 758
 759 void PostgreSqlStorage::setChannelPersistent(UserId user, const NetworkId &networkId, const QString &channel, bool isJoined) {
 760   QSqlQuery query(logDb());
 761   query.prepare(queryString("update_buffer_persistent_channel"));
 762   query.bindValue(":userid", user.toInt());
 763   query.bindValue(":networkId", networkId.toInt());
 764   query.bindValue(":buffercname", channel.toLower());
 765   query.bindValue(":joined", isJoined);
 766   safeExec(query);
 767   watchQuery(query);
 768 }
 769
 770 void PostgreSqlStorage::setPersistentChannelKey(UserId user, const NetworkId &networkId, const QString &channel, const QString &key) {
 771   QSqlQuery query(logDb());
 772   query.prepare(queryString("update_buffer_set_channel_key"));
 773   query.bindValue(":userid", user.toInt());
 774   query.bindValue(":networkId", networkId.toInt());
 775   query.bindValue(":buffercname", channel.toLower());
 776   query.bindValue(":key", key);
 777   safeExec(query);
 778   watchQuery(query);
 779 }
 780
 781 QString PostgreSqlStorage::awayMessage(UserId user, NetworkId networkId) {
 782   QSqlQuery query(logDb());
 783   query.prepare(queryString("select_network_awaymsg"));
 784   query.bindValue(":userid", user.toInt());
 785   query.bindValue(":networkid", networkId.toInt());
 786   safeExec(query);
 787   watchQuery(query);
 788   QString awayMsg;
 789   if(query.first())
 790     awayMsg = query.value(0).toString();
 791   return awayMsg;
 792 }
 793
 794 void PostgreSqlStorage::setAwayMessage(UserId user, NetworkId networkId, const QString &awayMsg) {
 795   QSqlQuery query(logDb());
 796   query.prepare(queryString("update_network_set_awaymsg"));
 797   query.bindValue(":userid", user.toInt());
 798   query.bindValue(":networkid", networkId.toInt());
 799   query.bindValue(":awaymsg", awayMsg);
 800   safeExec(query);
 801   watchQuery(query);
 802 }
 803
 804 QString PostgreSqlStorage::userModes(UserId user, NetworkId networkId) {
 805   QSqlQuery query(logDb());
 806   query.prepare(queryString("select_network_usermode"));
 807   query.bindValue(":userid", user.toInt());
 808   query.bindValue(":networkid", networkId.toInt());
 809   safeExec(query);
 810   watchQuery(query);
 811   QString modes;
 812   if(query.first())
 813     modes = query.value(0).toString();
 814   return modes;
 815 }
 816
 817 void PostgreSqlStorage::setUserModes(UserId user, NetworkId networkId, const QString &userModes) {
 818   QSqlQuery query(logDb());
 819   query.prepare(queryString("update_network_set_usermode"));
 820   query.bindValue(":userid", user.toInt());
 821   query.bindValue(":networkid", networkId.toInt());
 822   query.bindValue(":usermode", userModes);
 823   safeExec(query);
 824   watchQuery(query);
 825 }
 826
 827 BufferInfo PostgreSqlStorage::bufferInfo(UserId user, const NetworkId &networkId, BufferInfo::Type type, const QString &buffer, bool create) {
 828   QSqlDatabase db = logDb();
 829   if(!db.transaction()) {
 830     qWarning() << "PostgreSqlStorage::bufferInfo(): cannot start read only transaction!";
 831     qWarning() << " -" << qPrintable(db.lastError().text());
 832     return BufferInfo();
 833   }
 834
 835   QSqlQuery query(db);
 836   query.prepare(queryString("select_bufferByName"));
 837   query.bindValue(":networkid", networkId.toInt());
 838   query.bindValue(":userid", user.toInt());
 839   query.bindValue(":buffercname", buffer.toLower());
 840   safeExec(query);
 841
 842   if(query.first()) {
 843     BufferInfo bufferInfo = BufferInfo(query.value(0).toInt(), networkId, (BufferInfo::Type)query.value(1).toInt(), 0, buffer);
 844     if(query.next()) {
 845       qCritical() << "PostgreSqlStorage::bufferInfo(): received more then one Buffer!";
 846       qCritical() << "         Query:" << query.lastQuery();
 847       qCritical() << "  bound Values:";
 848       QList<QVariant> list = query.boundValues().values();
 849       for (int i = 0; i < list.size(); ++i)
 850         qCritical() << i << ":" << list.at(i).toString().toAscii().data();
 851       Q_ASSERT(false);
 852     }
 853     db.commit();
 854     return bufferInfo;
 855   }
 856
 857   if(!create) {
 858     db.rollback();
 859     return BufferInfo();
 860   }
 861
 862   QSqlQuery createQuery(db);
 863   createQuery.prepare(queryString("insert_buffer"));
 864   createQuery.bindValue(":userid", user.toInt());
 865   createQuery.bindValue(":networkid", networkId.toInt());
 866   createQuery.bindValue(":buffertype", (int)type);
 867   createQuery.bindValue(":buffername", buffer);
 868   createQuery.bindValue(":buffercname", buffer.toLower());
 869   safeExec(createQuery);
 870
 871   if(createQuery.lastError().isValid()) {
 872     qWarning() << "PostgreSqlStorage::bufferInfo(): unable to create buffer";
 873     watchQuery(createQuery);
 874     db.rollback();
 875     return BufferInfo();
 876   }
 877
 878   createQuery.first();
 879
 880   BufferInfo bufferInfo = BufferInfo(createQuery.value(0).toInt(), networkId, type, 0, buffer);
 881   db.commit();
 882   return bufferInfo;
 883 }
 884
 885 BufferInfo PostgreSqlStorage::getBufferInfo(UserId user, const BufferId &bufferId) {
 886   QSqlQuery query(logDb());
 887   query.prepare(queryString("select_buffer_by_id"));
 888   query.bindValue(":userid", user.toInt());
 889   query.bindValue(":bufferid", bufferId.toInt());
 890   safeExec(query);
 891   if(!watchQuery(query))
 892     return BufferInfo();
 893
 894   if(!query.first())
 895     return BufferInfo();
 896
 897   BufferInfo bufferInfo(query.value(0).toInt(), query.value(1).toInt(), (BufferInfo::Type)query.value(2).toInt(), 0, query.value(4).toString());
 898   Q_ASSERT(!query.next());
 899
 900   return bufferInfo;
 901 }
 902
 903 QList<BufferInfo> PostgreSqlStorage::requestBuffers(UserId user) {
 904   QList<BufferInfo> bufferlist;
 905
 906   QSqlDatabase db = logDb();
 907   if(!beginReadOnlyTransaction(db)) {
 908     qWarning() << "PostgreSqlStorage::requestBuffers(): cannot start read only transaction!";
 909     qWarning() << " -" << qPrintable(db.lastError().text());
 910     return bufferlist;
 911   }
 912
 913   QSqlQuery query(db);
 914   query.prepare(queryString("select_buffers"));
 915   query.bindValue(":userid", user.toInt());
 916
 917   safeExec(query);
 918   watchQuery(query);
 919   while(query.next()) {
 920     bufferlist << BufferInfo(query.value(0).toInt(), query.value(1).toInt(), (BufferInfo::Type)query.value(2).toInt(), query.value(3).toInt(), query.value(4).toString());
 921   }
 922   db.commit();
 923   return bufferlist;
 924 }
 925
 926 QList<BufferId> PostgreSqlStorage::requestBufferIdsForNetwork(UserId user, NetworkId networkId) {
 927   QList<BufferId> bufferList;
 928
 929   QSqlDatabase db = logDb();
 930   if(!beginReadOnlyTransaction(db)) {
 931     qWarning() << "PostgreSqlStorage::requestBufferIdsForNetwork(): cannot start read only transaction!";
 932     qWarning() << " -" << qPrintable(db.lastError().text());
 933     return bufferList;
 934   }
 935
 936   QSqlQuery query(db);
 937   query.prepare(queryString("select_buffers_for_network"));
 938   query.bindValue(":networkid", networkId.toInt());
 939   query.bindValue(":userid", user.toInt());
 940
 941   safeExec(query);
 942   watchQuery(query);
 943   while(query.next()) {
 944     bufferList << BufferId(query.value(0).toInt());
 945   }
 946   db.commit();
 947   return bufferList;
 948 }
 949
 950 bool PostgreSqlStorage::removeBuffer(const UserId &user, const BufferId &bufferId) {
 951   QSqlDatabase db = logDb();
 952   if(!db.transaction()) {
 953     qWarning() << "PostgreSqlStorage::removeBuffer(): cannot start transaction!";
 954     return false;
 955   }
 956
 957   QSqlQuery query(db);
 958   query.prepare(queryString("delete_buffer_for_bufferid"));
 959   query.bindValue(":userid", user.toInt());
 960   query.bindValue(":bufferid", bufferId.toInt());
 961   safeExec(query);
 962   if(!watchQuery(query)) {
 963     db.rollback();
 964     return false;
 965   }
 966
 967   int numRows = query.numRowsAffected();
 968   switch(numRows) {
 969   case 0:
 970     db.commit();
 971     return false;
 972   case 1:
 973     db.commit();
 974     return false;
 975   default:
 976     // there was more then one buffer deleted...
 977     qWarning() << "PostgreSqlStorage::removeBuffer(): Userid" << user << "BufferId" << "caused deletion of" << numRows << "Buffers! Rolling back transaction...";
 978     db.rollback();
 979     return false;
 980   }
 981 }
 982
 983 bool PostgreSqlStorage::renameBuffer(const UserId &user, const BufferId &bufferId, const QString &newName) {
 984   QSqlDatabase db = logDb();
 985   if(!db.transaction()) {
 986     qWarning() << "PostgreSqlStorage::renameBuffer(): cannot start transaction!";
 987     return false;
 988   }
 989
 990   QSqlQuery query(db);
 991   query.prepare(queryString("update_buffer_name"));
 992   query.bindValue(":buffername", newName);
 993   query.bindValue(":buffercname", newName.toLower());
 994   query.bindValue(":userid", user.toInt());
 995   query.bindValue(":bufferid", bufferId.toInt());
 996   safeExec(query);
 997   if(query.lastError().isValid()) {
 998     watchQuery(query);
 999     db.rollback();
1000     return false;
1001   }
1002
1003   int numRows = query.numRowsAffected();
1004   switch(numRows) {
1005   case 0:
1006     db.commit();
1007     return false;
1008   case 1:
1009     db.commit();
1010     return false;
1011   default:
1012     // there was more then one buffer deleted...
1013     qWarning() << "PostgreSqlStorage::renameBuffer(): Userid" << user << "BufferId" << "affected" << numRows << "Buffers! Rolling back transaction...";
1014     db.rollback();
1015     return false;
1016   }
1017 }
1018
1019 bool PostgreSqlStorage::mergeBuffersPermanently(const UserId &user, const BufferId &bufferId1, const BufferId &bufferId2) {
1020   QSqlDatabase db = logDb();
1021   if(!db.transaction()) {
1022     qWarning() << "PostgreSqlStorage::mergeBuffersPermanently(): cannot start transaction!";
1023     qWarning() << " -" << qPrintable(db.lastError().text());
1024     return false;
1025   }
1026
1027   QSqlQuery checkQuery(db);
1028   checkQuery.prepare("SELECT count(*) FROM buffer"
1029                      "WHERE userid = :userid AND bufferid IN (:buffer1, :buffer2)");
1030   checkQuery.bindValue(":userid", user.toInt());
1031   checkQuery.bindValue(":buffer1", bufferId1.toInt());
1032   checkQuery.bindValue(":buffer2", bufferId2.toInt());
1033   safeExec(checkQuery);
1034   if(!watchQuery(checkQuery)) {
1035     db.rollback();
1036     return false;
1037   }
1038   checkQuery.first();
1039   if(checkQuery.value(0).toInt() != 2) {
1040     db.rollback();
1041     return false;
1042   }
1043
1044   QSqlQuery query(db);
1045   query.prepare(queryString("update_backlog_bufferid"));
1046   query.bindValue(":oldbufferid", bufferId2.toInt());
1047   query.bindValue(":newbufferid", bufferId1.toInt());
1048   safeExec(query);
1049   if(!watchQuery(query)) {
1050     db.rollback();
1051     return false;
1052   }
1053
1054   QSqlQuery delBufferQuery(logDb());
1055   delBufferQuery.prepare(queryString("delete_buffer_for_bufferid"));
1056   delBufferQuery.bindValue(":bufferid", bufferId2.toInt());
1057   safeExec(delBufferQuery);
1058   if(!watchQuery(delBufferQuery)) {
1059     db.rollback();
1060     return false;
1061   }
1062
1063   db.commit();
1064   return true;
1065 }
1066
1067 void PostgreSqlStorage::setBufferLastSeenMsg(UserId user, const BufferId &bufferId, const MsgId &msgId) {
1068   QSqlQuery query(logDb());
1069   query.prepare(queryString("update_buffer_lastseen"));
1070
1071   query.bindValue(":userid", user.toInt());
1072   query.bindValue(":bufferid", bufferId.toInt());
1073   query.bindValue(":lastseenmsgid", msgId.toInt());
1074   safeExec(query);
1075   watchQuery(query);
1076 }
1077
1078 QHash<BufferId, MsgId> PostgreSqlStorage::bufferLastSeenMsgIds(UserId user) {
1079   QHash<BufferId, MsgId> lastSeenHash;
1080
1081   QSqlDatabase db = logDb();
1082   if(!beginReadOnlyTransaction(db)) {
1083     qWarning() << "PostgreSqlStorage::bufferLastSeenMsgIds(): cannot start read only transaction!";
1084     qWarning() << " -" << qPrintable(db.lastError().text());
1085     return lastSeenHash;
1086   }
1087
1088   QSqlQuery query(db);
1089   query.prepare(queryString("select_buffer_lastseen_messages"));
1090   query.bindValue(":userid", user.toInt());
1091   safeExec(query);
1092   if(!watchQuery(query)) {
1093     db.rollback();
1094     return lastSeenHash;
1095   }
1096
1097   while(query.next()) {
1098     lastSeenHash[query.value(0).toInt()] = query.value(1).toInt();
1099   }
1100
1101   db.commit();
1102   return lastSeenHash;
1103 }
1104
1105 bool PostgreSqlStorage::logMessage(Message &msg) {
1106   QSqlDatabase db = logDb();
1107   if(!db.transaction()) {
1108     qWarning() << "PostgreSqlStorage::logMessage(): cannot start transaction!";
1109     qWarning() << " -" << qPrintable(db.lastError().text());
1110     return false;
1111   }
1112
1113   if(!prepareQuery("insert_message", queryString("insert_message"), db)) {
1114     qWarning() << "PostgreSqlStorage::logMessages(): unable to prepare query:" << queryString("insert_message");
1115     qWarning() << "  Error:" << db.lastError().text();
1116     db.rollback();
1117     return false;
1118   }
1119
1120   QVariantList params;
1121   params << msg.timestamp()
1122          << msg.bufferInfo().bufferId().toInt()
1123          << msg.type()
1124          << (int)msg.flags()
1125          << msg.sender()
1126          << msg.contents();
1127   QSqlQuery logMessageQuery = executePreparedQuery("insert_message", params, db);
1128
1129   if(logMessageQuery.lastError().isValid()) {
1130     // first we need to reset the transaction
1131     db.rollback();
1132     db.transaction();
1133
1134
1135     // it's possible that the sender was already added by another thread
1136     // since the insert might fail we're setting a savepoint
1137     savePoint("sender_sp1", db);
1138     QSqlQuery addSenderQuery = executePreparedQuery("insert_sender", msg.sender(), db);
1139     if(addSenderQuery.lastError().isValid())
1140       rollbackSavePoint("sender_sp1", db);
1141     else
1142       releaseSavePoint("sender_sp1", db);
1143
1144     logMessageQuery = db.exec(logMessageQuery.lastQuery());
1145     if(!watchQuery(logMessageQuery)) {
1146       qDebug() << "==================== Sender Query:";
1147       watchQuery(addSenderQuery);
1148       qDebug() << "==================== /Sender Query";
1149       db.rollback();
1150       return false;
1151     }
1152   }
1153
1154   logMessageQuery.first();
1155   MsgId msgId = logMessageQuery.value(0).toInt();
1156   db.commit();
1157   if(msgId.isValid()) {
1158     msg.setMsgId(msgId);
1159     return true;
1160   } else {
1161     return false;
1162   }
1163 }
1164
1165 bool PostgreSqlStorage::logMessages(MessageList &msgs) {
1166   QSqlDatabase db = logDb();
1167   if(!db.transaction()) {
1168     qWarning() << "PostgreSqlStorage::logMessage(): cannot start transaction!";
1169     qWarning() << " -" << qPrintable(db.lastError().text());
1170     return false;
1171   }
1172
1173   if(!prepareQuery("insert_sender", queryString("insert_sender"), db)) {
1174     qWarning() << "PostgreSqlStorage::logMessages(): unable to prepare query:" << queryString("insert_sender");
1175     qWarning() << "  Error:" << db.lastError().text();
1176     db.rollback();
1177     return false;
1178   }
1179   QSet<QString> senders;
1180   for(int i = 0; i < msgs.count(); i++) {
1181     const QString &sender = msgs.at(i).sender();
1182     if(senders.contains(sender))
1183       continue;
1184     senders << sender;
1185
1186     savePoint("sender_sp", db);
1187     QSqlQuery addSenderQuery = executePreparedQuery("insert_sender", sender, db);
1188     if(addSenderQuery.lastError().isValid())
1189       rollbackSavePoint("sender_sp", db);
1190     else
1191       releaseSavePoint("sender_sp", db);
1192   }
1193
1194   // yes we loop twice over the same list. This avoids alternating queries.
1195   if(!prepareQuery("insert_message", queryString("insert_message"), db)) {
1196     qWarning() << "PostgreSqlStorage::logMessages(): unable to prepare query:" << queryString("insert_message");
1197     qWarning() << "  Error:" << db.lastError().text();
1198     db.rollback();
1199     return false;
1200   }
1201   bool error = false;
1202   for(int i = 0; i < msgs.count(); i++) {
1203     Message &msg = msgs[i];
1204     QVariantList params;
1205     params << msg.timestamp()
1206            << msg.bufferInfo().bufferId().toInt()
1207            << msg.type()
1208            << (int)msg.flags()
1209            << msg.sender()
1210            << msg.contents();
1211     QSqlQuery logMessageQuery = executePreparedQuery("insert_message", params, db);
1212     if(!watchQuery(logMessageQuery)) {
1213       db.rollback();
1214       error = true;
1215       break;
1216     } else {
1217       logMessageQuery.first();
1218       msg.setMsgId(logMessageQuery.value(0).toInt());
1219     }
1220   }
1221
1222   if(error) {
1223     // we had a rollback in the db so we need to reset all msgIds
1224     for(int i = 0; i < msgs.count(); i++) {
1225       msgs[i].setMsgId(MsgId());
1226     }
1227     return false;
1228   }
1229
1230   db.commit();
1231   return true;
1232 }
1233
1234 QList<Message> PostgreSqlStorage::requestMsgs(UserId user, BufferId bufferId, MsgId first, MsgId last, int limit) {
1235   QList<Message> messagelist;
1236
1237   QSqlDatabase db = logDb();
1238   if(!beginReadOnlyTransaction(db)) {
1239     qWarning() << "PostgreSqlStorage::requestMsgs(): cannot start read only transaction!";
1240     qWarning() << " -" << qPrintable(db.lastError().text());
1241     return messagelist;
1242   }
1243
1244   BufferInfo bufferInfo = getBufferInfo(user, bufferId);
1245   if(!bufferInfo.isValid()) {
1246     db.rollback();
1247     return messagelist;
1248   }
1249
1250   QSqlQuery query(db);
1251   if(last == -1 && first == -1) {
1252     query.prepare(queryString("select_messages"));
1253   } else if(last == -1) {
1254     query.prepare(queryString("select_messagesNewerThan"));
1255     query.bindValue(":firstmsg", first.toInt());
1256   } else {
1257     query.prepare(queryString("select_messagesRange"));
1258     query.bindValue(":lastmsg", last.toInt());
1259     query.bindValue(":firstmsg", first.toInt());
1260   }
1261   query.bindValue(":bufferid", bufferId.toInt());
1262   safeExec(query);
1263   if(!watchQuery(query)) {
1264     db.rollback();
1265     return messagelist;
1266   }
1267
1268   QDateTime timestamp;
1269   for(int i = 0; i < limit && query.next(); i++) {
1270     timestamp = query.value(1).toDateTime();
1271     timestamp.setTimeSpec(Qt::UTC);
1272     Message msg(timestamp,
1273                 bufferInfo,
1274                 (Message::Type)query.value(2).toUInt(),
1275                 query.value(5).toString(),
1276                 query.value(4).toString(),
1277                 (Message::Flags)query.value(3).toUInt());
1278     msg.setMsgId(query.value(0).toInt());
1279     messagelist << msg;
1280   }
1281
1282   db.commit();
1283   return messagelist;
1284 }
1285
1286 QList<Message> PostgreSqlStorage::requestAllMsgs(UserId user, MsgId first, MsgId last, int limit) {
1287   QList<Message> messagelist;
1288
1289   // requestBuffers uses it's own transaction.
1290   QHash<BufferId, BufferInfo> bufferInfoHash;
1291   foreach(BufferInfo bufferInfo, requestBuffers(user)) {
1292     bufferInfoHash[bufferInfo.bufferId()] = bufferInfo;
1293   }
1294
1295   QSqlDatabase db = logDb();
1296   if(!beginReadOnlyTransaction(db)) {
1297     qWarning() << "PostgreSqlStorage::requestAllMsgs(): cannot start read only transaction!";
1298     qWarning() << " -" << qPrintable(db.lastError().text());
1299     return messagelist;
1300   }
1301
1302   QSqlQuery query(db);
1303   if(last == -1) {
1304     query.prepare(queryString("select_messagesAllNew"));
1305   } else {
1306     query.prepare(queryString("select_messagesAll"));
1307     query.bindValue(":lastmsg", last.toInt());
1308   }
1309   query.bindValue(":userid", user.toInt());
1310   query.bindValue(":firstmsg", first.toInt());
1311   safeExec(query);
1312   if(!watchQuery(query)) {
1313     db.rollback();
1314     return messagelist;
1315   }
1316
1317   QDateTime timestamp;
1318   for(int i = 0; i < limit && query.next(); i++) {
1319     timestamp = query.value(1).toDateTime();
1320     timestamp.setTimeSpec(Qt::UTC);
1321     Message msg(timestamp,
1322                 bufferInfoHash[query.value(1).toInt()],
1323                 (Message::Type)query.value(3).toUInt(),
1324                 query.value(6).toString(),
1325                 query.value(5).toString(),
1326                 (Message::Flags)query.value(4).toUInt());
1327     msg.setMsgId(query.value(0).toInt());
1328     messagelist << msg;
1329   }
1330
1331   db.commit();
1332   return messagelist;
1333 }
1334
1335 // void PostgreSqlStorage::safeExec(QSqlQuery &query) {
1336 //   qDebug() << "PostgreSqlStorage::safeExec";
1337 //   qDebug() << "   executing:\n" << query.executedQuery();
1338 //   qDebug() << "   bound Values:";
1339 //   QList<QVariant> list = query.boundValues().values();
1340 //   for (int i = 0; i < list.size(); ++i)
1341 //     qCritical() << i << ": " << list.at(i).toString().toAscii().data();
1342
1343 //   query.exec();
1344
1345 //   qDebug() << "Success:" << !query.lastError().isValid();
1346 //   qDebug();
1347
1348 //   if(!query.lastError().isValid())
1349 //     return;
1350
1351 //   qDebug() << "==================== ERROR ====================";
1352 //   watchQuery(query);
1353 //   qDebug() << "===============================================";
1354 //   qDebug();
1355 //   return;
1356 // }
1357
1358 bool PostgreSqlStorage::beginReadOnlyTransaction(QSqlDatabase &db) {
1359   QSqlQuery query = db.exec("BEGIN TRANSACTION READ ONLY");
1360   return !query.lastError().isValid();
1361 }
1362
1363 bool PostgreSqlStorage::prepareQuery(const QString &handle, const QString &query, const QSqlDatabase &db) {
1364   if(_preparedQueries.contains(db.connectionName()) && _preparedQueries[db.connectionName()].contains(handle))
1365     return true; // already prepared
1366
1367   QMutexLocker locker(&_queryHashMutex);
1368
1369   static unsigned int stmtCount = 0;
1370   QString queryId = QLatin1String("quassel_") + QString::number(++stmtCount, 16);
1371   // qDebug() << "prepare:" << QString("PREPARE %1 AS %2").arg(queryId).arg(query);
1372   db.exec(QString("PREPARE %1 AS %2").arg(queryId).arg(query));
1373   if(db.lastError().isValid()) {
1374     return false;
1375   } else {
1376     _preparedQueries[db.connectionName()][handle] = queryId;
1377     return true;
1378   }
1379 }
1380
1381 QSqlQuery PostgreSqlStorage::executePreparedQuery(const QString &handle, const QVariantList &params, const QSqlDatabase &db) {
1382   if(!_preparedQueries.contains(db.connectionName()) || !_preparedQueries[db.connectionName()].contains(handle)) {
1383     qWarning() << "PostgreSqlStorage::executePreparedQuery() no prepared Query with handle" << handle << "on Database" << db.connectionName();
1384     return QSqlQuery();
1385   }
1386
1387   QSqlDriver *driver = db.driver();
1388
1389   QStringList paramStrings;
1390   QSqlField field;
1391   for(int i = 0; i < params.count(); i++) {
1392     const QVariant &value = params.at(i);
1393     field.setType(value.type());
1394     if(value.isNull())
1395       field.clear();
1396     else
1397       field.setValue(value);
1398
1399     paramStrings << driver->formatValue(field);
1400   }
1401
1402   const QString &queryId = _preparedQueries[db.connectionName()][handle];
1403   if(params.isEmpty()) {
1404     return db.exec(QString("EXECUTE %1").arg(queryId));
1405   } else {
1406     // qDebug() << "preparedExec:" << QString("EXECUTE %1 (%2)").arg(queryId).arg(paramStrings.join(", "));
1407     return db.exec(QString("EXECUTE %1 (%2)").arg(queryId).arg(paramStrings.join(", ")));
1408   }
1409 }
1410
1411 QSqlQuery PostgreSqlStorage::executePreparedQuery(const QString &handle, const QVariant &param, const QSqlDatabase &db) {
1412   if(!_preparedQueries.contains(db.connectionName()) || !_preparedQueries[db.connectionName()].contains(handle)) {
1413     qWarning() << "PostgreSqlStorage::executePreparedQuery() no prepared Query with handle" << handle << "on Database" << db.connectionName();
1414     return QSqlQuery();
1415   }
1416
1417   QSqlField field;
1418   field.setType(param.type());
1419   if(param.isNull())
1420     field.clear();
1421   else
1422     field.setValue(param);
1423
1424   const QString &queryId = _preparedQueries[db.connectionName()][handle];
1425   QString paramString = db.driver()->formatValue(field);
1426
1427   // qDebug() << "preparedExec:" << QString("EXECUTE %1 (%2)").arg(queryId).arg(paramString);
1428   return db.exec(QString("EXECUTE %1 (%2)").arg(queryId).arg(paramString));
1429 }
1430
1431 void PostgreSqlStorage::deallocateQuery(const QString &handle, const QSqlDatabase &db) {
1432   if(!_preparedQueries.contains(db.connectionName()) || !_preparedQueries[db.connectionName()].contains(handle)) {
1433     return;
1434   }
1435   QMutexLocker locker(&_queryHashMutex);
1436   QString queryId = _preparedQueries[db.connectionName()].take(handle);
1437   db.exec(QString("DEALLOCATE %1").arg(queryId));
1438 }
1439
1440
1441
1442
1443
1444 // ========================================
1445 //  PostgreSqlMigrationWriter
1446 // ========================================
1447 PostgreSqlMigrationWriter::PostgreSqlMigrationWriter()
1448   : PostgreSqlStorage()
1449 {
1450 }
1451
1452 bool PostgreSqlMigrationWriter::prepareQuery(MigrationObject mo) {
1453   QString query;
1454   switch(mo) {
1455   case QuasselUser:
1456     query = queryString("migrate_write_quasseluser");
1457     break;
1458   case Sender:
1459     query = queryString("migrate_write_sender");
1460     break;
1461   case Identity:
1462     query = queryString("migrate_write_identity");
1463     break;
1464   case IdentityNick:
1465     query = queryString("migrate_write_identity_nick");
1466     break;
1467   case Network:
1468     query = queryString("migrate_write_network");
1469     break;
1470   case Buffer:
1471     query = queryString("migrate_write_buffer");
1472     break;
1473   case Backlog:
1474     query = queryString("migrate_write_backlog");
1475     break;
1476   case IrcServer:
1477     query = queryString("migrate_write_ircserver");
1478     break;
1479   case UserSetting:
1480     query = queryString("migrate_write_usersetting");
1481     break;
1482   }
1483   newQuery(query, logDb());
1484   return true;
1485 }
1486
1487 //bool PostgreSqlMigrationWriter::writeUser(const QuasselUserMO &user) {
1488 bool PostgreSqlMigrationWriter::writeMo(const QuasselUserMO &user) {
1489   bindValue(0, user.id.toInt());
1490   bindValue(1, user.username);
1491   bindValue(2, user.password);
1492   return exec();
1493 }
1494
1495 //bool PostgreSqlMigrationWriter::writeSender(const SenderMO &sender) {
1496 bool PostgreSqlMigrationWriter::writeMo(const SenderMO &sender) {
1497   bindValue(0, sender.senderId);
1498   bindValue(1, sender.sender);
1499   return exec();
1500 }
1501
1502 //bool PostgreSqlMigrationWriter::writeIdentity(const IdentityMO &identity) {
1503 bool PostgreSqlMigrationWriter::writeMo(const IdentityMO &identity) {
1504   bindValue(0, identity.id.toInt());
1505   bindValue(1, identity.userid.toInt());
1506   bindValue(2, identity.identityname);
1507   bindValue(3, identity.realname);
1508   bindValue(4, identity.awayNick);
1509   bindValue(5, identity.awayNickEnabled);
1510   bindValue(6, identity.awayReason);
1511   bindValue(7, identity.awayReasonEnabled);
1512   bindValue(8, identity.autoAwayEnabled);
1513   bindValue(9, identity.autoAwayTime);
1514   bindValue(10, identity.autoAwayReason);
1515   bindValue(11, identity.autoAwayReasonEnabled);
1516   bindValue(12, identity.detachAwayEnabled);
1517   bindValue(13, identity.detachAwayReason);
1518   bindValue(14, identity.detchAwayReasonEnabled);
1519   bindValue(15, identity.ident);
1520   bindValue(16, identity.kickReason);
1521   bindValue(17, identity.partReason);
1522   bindValue(18, identity.quitReason);
1523   bindValue(19, identity.sslCert);
1524   bindValue(20, identity.sslKey);
1525   return exec();
1526 }
1527
1528 //bool PostgreSqlMigrationWriter::writeIdentityNick(const IdentityNickMO &identityNick) {
1529 bool PostgreSqlMigrationWriter::writeMo(const IdentityNickMO &identityNick) {
1530   bindValue(0, identityNick.nickid);
1531   bindValue(1, identityNick.identityId.toInt());
1532   bindValue(2, identityNick.nick);
1533   return exec();
1534 }
1535
1536 //bool PostgreSqlMigrationWriter::writeNetwork(const NetworkMO &network) {
1537 bool PostgreSqlMigrationWriter::writeMo(const NetworkMO &network) {
1538   bindValue(0, network.networkid.toInt());
1539   bindValue(1, network.userid.toInt());
1540   bindValue(2, network.networkname);
1541   bindValue(3, network.identityid.toInt());
1542   bindValue(4, network.encodingcodec);
1543   bindValue(5, network.decodingcodec);
1544   bindValue(6, network.servercodec);
1545   bindValue(7, network.userandomserver);
1546   bindValue(8, network.perform);
1547   bindValue(9, network.useautoidentify);
1548   bindValue(10, network.autoidentifyservice);
1549   bindValue(11, network.autoidentifypassword);
1550   bindValue(12, network.useautoreconnect);
1551   bindValue(13, network.autoreconnectinterval);
1552   bindValue(14, network.autoreconnectretries);
1553   bindValue(15, network.unlimitedconnectretries);
1554   bindValue(16, network.rejoinchannels);
1555   bindValue(17, network.connected);
1556   bindValue(18, network.usermode);
1557   bindValue(19, network.awaymessage);
1558   bindValue(20, network.attachperform);
1559   bindValue(21, network.detachperform);
1560   return exec();
1561 }
1562
1563 //bool PostgreSqlMigrationWriter::writeBuffer(const BufferMO &buffer) {
1564 bool PostgreSqlMigrationWriter::writeMo(const BufferMO &buffer) {
1565   bindValue(0, buffer.bufferid.toInt());
1566   bindValue(1, buffer.userid.toInt());
1567   bindValue(2, buffer.groupid);
1568   bindValue(3, buffer.networkid.toInt());
1569   bindValue(4, buffer.buffername);
1570   bindValue(5, buffer.buffercname);
1571   bindValue(6, (int)buffer.buffertype);
1572   bindValue(7, buffer.lastseenmsgid);
1573   bindValue(8, buffer.key);
1574   bindValue(9, buffer.joined);
1575   return exec();
1576 }
1577
1578 //bool PostgreSqlMigrationWriter::writeBacklog(const BacklogMO &backlog) {
1579 bool PostgreSqlMigrationWriter::writeMo(const BacklogMO &backlog) {
1580   bindValue(0, backlog.messageid.toInt());
1581   bindValue(1, backlog.time);
1582   bindValue(2, backlog.bufferid.toInt());
1583   bindValue(3, backlog.type);
1584   bindValue(4, (int)backlog.flags);
1585   bindValue(5, backlog.senderid);
1586   bindValue(6, backlog.message);
1587   return exec();
1588 }
1589
1590 //bool PostgreSqlMigrationWriter::writeIrcServer(const IrcServerMO &ircserver) {
1591 bool PostgreSqlMigrationWriter::writeMo(const IrcServerMO &ircserver) {
1592   bindValue(0, ircserver.serverid);
1593   bindValue(1, ircserver.userid.toInt());
1594   bindValue(2, ircserver.networkid.toInt());
1595   bindValue(3, ircserver.hostname);
1596   bindValue(4, ircserver.port);
1597   bindValue(5, ircserver.password);
1598   bindValue(6, ircserver.ssl);
1599   bindValue(7, ircserver.sslversion);
1600   bindValue(8, ircserver.useproxy);
1601   bindValue(9, ircserver.proxytype);
1602   bindValue(10, ircserver.proxyhost);
1603   bindValue(11, ircserver.proxyport);
1604   bindValue(12, ircserver.proxyuser);
1605   bindValue(13, ircserver.proxypass);
1606   return exec();
1607 }
1608
1609 //bool PostgreSqlMigrationWriter::writeUserSetting(const UserSettingMO &userSetting) {
1610 bool PostgreSqlMigrationWriter::writeMo(const UserSettingMO &userSetting) {
1611   bindValue(0, userSetting.userid.toInt());
1612   bindValue(1, userSetting.settingname);
1613   bindValue(2, userSetting.settingvalue);
1614   return exec();
1615 }