- QSqlQuery insertServersQuery(logDb());
- insertServersQuery.prepare(queryString("insert_server"));
- foreach(QVariant server_, info.serverList) {
- QVariantMap server = server_.toMap();
- insertServersQuery.bindValue(":hostname", server["Host"]);
- insertServersQuery.bindValue(":port", server["Port"].toInt());
- insertServersQuery.bindValue(":password", server["Password"]);
- insertServersQuery.bindValue(":ssl", server["UseSSL"].toBool() ? 1 : 0);
- insertServersQuery.bindValue(":userid", user.toInt());
- insertServersQuery.bindValue(":networkid", info.networkId.toInt());
-
- insertServersQuery.exec();
- if(!watchQuery(&insertServersQuery))
- return false;
- }
-
- return true;
-}
-
-bool SqliteStorage::removeNetwork(UserId user, const NetworkId &networkId) {
- if(!isValidNetwork(user, networkId))
- return false;
-
- bool withTransaction = logDb().driver()->hasFeature(QSqlDriver::Transactions);
- if(withTransaction) {
- sync();
- if(!logDb().transaction()) {
- qWarning() << "SqliteStorage::removeNetwork(): cannot start transaction. continuing with out rollback support!";
- withTransaction = false;
- }
- }
-
- QSqlQuery deleteBacklogQuery(logDb());
- deleteBacklogQuery.prepare(queryString("delete_backlog_for_network"));
- deleteBacklogQuery.bindValue(":networkid", networkId.toInt());
- deleteBacklogQuery.exec();
- if(!watchQuery(&deleteBacklogQuery)) {
- if(withTransaction)
- logDb().rollback();
- return false;
- }
-
- QSqlQuery deleteBuffersQuery(logDb());
- deleteBuffersQuery.prepare(queryString("delete_buffers_for_network"));
- deleteBuffersQuery.bindValue(":networkid", networkId.toInt());
- deleteBuffersQuery.exec();
- if(!watchQuery(&deleteBuffersQuery)) {
- if(withTransaction)
- logDb().rollback();
- return false;
- }
-
- QSqlQuery deleteServersQuery(logDb());
- deleteServersQuery.prepare(queryString("delete_ircservers_for_network"));
- deleteServersQuery.bindValue(":networkid", networkId.toInt());
- deleteServersQuery.exec();
- if(!watchQuery(&deleteServersQuery)) {
- if(withTransaction)
- logDb().rollback();
- return false;
- }
-
- QSqlQuery deleteNetworkQuery(logDb());
- deleteNetworkQuery.prepare(queryString("delete_network"));
- deleteNetworkQuery.bindValue(":networkid", networkId.toInt());
- deleteNetworkQuery.exec();
- if(!watchQuery(&deleteNetworkQuery)) {
- if(withTransaction)
- logDb().rollback();
- return false;
- }
+bool SqliteStorage::updateSchemaVersion(int newVersion, bool clearUpgradeStep)
+{
+ // only used when there is a singlethread (during startup)
+ // so we don't need locking here
+
+ QSqlDatabase db = logDb();
+
+ // Atomically update the schema version and clear the upgrade step, if specified
+ // Note: This will need reworked if "updateSchemaVersion" is ever called within a transaction.
+ db.transaction();
+
+ QSqlQuery query(db);
+ query.prepare("UPDATE coreinfo SET value = :version WHERE key = 'schemaversion'");
+ query.bindValue(":version", newVersion);
+ safeExec(query);
+
+ if (!watchQuery(query)) {
+ qCritical() << "SqliteStorage::updateSchemaVersion(int, bool): Updating schema version failed!";
+ db.rollback();
+ return false;
+ }
+
+ if (clearUpgradeStep) {
+ // Try clearing the upgrade step if requested
+ if (!setSchemaVersionUpgradeStep("")) {
+ db.rollback();
+ return false;
+ }
+ }
+
+ // Successful, commit and return true
+ db.commit();
+ return true;
+}
+
+bool SqliteStorage::setupSchemaVersion(int version)
+{
+ // only used when there is a singlethread (during startup)
+ // so we don't need locking here
+ QSqlQuery query(logDb());
+ query.prepare("INSERT INTO coreinfo (key, value) VALUES ('schemaversion', :version)");
+ query.bindValue(":version", version);
+ query.exec();
+
+ bool success = true;
+ if (query.lastError().isValid()) {
+ qCritical() << "SqliteStorage::setupSchemaVersion(int): Updating schema version failed!";
+ success = false;
+ }
+ return success;
+}
+
+QString SqliteStorage::schemaVersionUpgradeStep()
+{
+ // Only used when there is a singlethread (during startup), so we don't need locking here
+ QSqlQuery query(logDb());
+ query.prepare("SELECT value FROM coreinfo WHERE key = 'schemaupgradestep'");
+ safeExec(query);
+ watchQuery(query);
+ if (query.first())
+ return query.value(0).toString();
+
+ // Fall back to the default value
+ return AbstractSqlStorage::schemaVersionUpgradeStep();
+}
+
+bool SqliteStorage::setSchemaVersionUpgradeStep(QString upgradeQuery)
+{
+ // Only used when there is a singlethread (during startup), so we don't need locking here
+
+ // Intentionally do not wrap in a transaction so other functions can include multiple operations
+ QSqlQuery query(logDb());
+ query.prepare("UPDATE coreinfo SET value = :upgradestep WHERE key = 'schemaupgradestep'");
+ query.bindValue(":upgradestep", upgradeQuery);
+ safeExec(query);
+
+ // Don't wrap with watchQuery to avoid an alarming message in the log when the key is missing
+ // Make sure that the query didn't fail, and that some non-zero number of rows were affected
+ bool success = !query.lastError().isValid() && query.numRowsAffected() != 0;
+
+ if (!success) {
+ // The key might not exist (Quassel 0.13.0 and older). Try inserting it...
+ query = QSqlQuery(logDb());
+ query.prepare("INSERT INTO coreinfo (key, value) VALUES ('schemaupgradestep', :upgradestep)");
+ query.bindValue(":upgradestep", upgradeQuery);
+ safeExec(query);
+
+ if (!watchQuery(query)) {
+ qCritical() << Q_FUNC_INFO << "Setting schema upgrade step failed!";
+ success = false;
+ }
+ else {
+ success = true;
+ }
+ }
+ return success;
+}
+
+UserId SqliteStorage::addUser(const QString& user, const QString& password, const QString& authenticator)
+{
+ QSqlDatabase db = logDb();
+ UserId uid;
+
+ db.transaction();
+ // this scope ensures that the query is freed in sqlite before we call unlock()
+ // this ensures that our thread doesn't hold a internal after unlock is called
+ // (see sqlites doc on implicit locking for details)
+ {
+ QSqlQuery query(db);
+ query.prepare(queryString("insert_quasseluser"));
+ query.bindValue(":username", user);
+ query.bindValue(":password", hashPassword(password));
+ query.bindValue(":hashversion", Storage::HashVersion::Latest);
+ query.bindValue(":authenticator", authenticator);
+ lockForWrite();
+ safeExec(query);
+ if (query.lastError().isValid()
+ && query.lastError().nativeErrorCode() == QLatin1String{"19"}) { // user already exists - sadly 19 seems to be the general constraint violation error...
+ db.rollback();
+ }
+ else {
+ uid = query.lastInsertId().toInt();
+ db.commit();
+ }
+ }
+ unlock();
+
+ if (uid.isValid())
+ emit userAdded(uid, user);
+ return uid;
+}
+
+bool SqliteStorage::updateUser(UserId user, const QString& password)
+{
+ QSqlDatabase db = logDb();
+ bool success = false;
+
+ db.transaction();
+ {
+ QSqlQuery query(db);
+ query.prepare(queryString("update_userpassword"));
+ query.bindValue(":userid", user.toInt());
+ query.bindValue(":password", hashPassword(password));
+ query.bindValue(":hashversion", Storage::HashVersion::Latest);
+ lockForWrite();
+ safeExec(query);
+ success = query.numRowsAffected() != 0;
+ db.commit();
+ }
+ unlock();
+ return success;
+}
+
+void SqliteStorage::renameUser(UserId user, const QString& newName)
+{
+ QSqlDatabase db = logDb();
+ db.transaction();
+ {
+ QSqlQuery query(db);
+ query.prepare(queryString("update_username"));
+ query.bindValue(":userid", user.toInt());
+ query.bindValue(":username", newName);
+ lockForWrite();
+ safeExec(query);
+ db.commit();
+ }
+ unlock();
+ emit userRenamed(user, newName);
+}
+
+UserId SqliteStorage::validateUser(const QString& user, const QString& password)
+{
+ UserId userId;
+ QString hashedPassword;
+ Storage::HashVersion hashVersion = Storage::HashVersion::Latest;
+
+ {
+ QSqlQuery query(logDb());
+ query.prepare(queryString("select_authuser"));
+ query.bindValue(":username", user);
+
+ lockForRead();
+ safeExec(query);
+
+ if (query.first()) {
+ userId = query.value(0).toInt();
+ hashedPassword = query.value(1).toString();
+ hashVersion = static_cast<Storage::HashVersion>(query.value(2).toInt());
+ }
+ }
+ unlock();
+
+ UserId returnUserId;
+ if (userId != 0 && checkHashedPassword(userId, password, hashedPassword, hashVersion)) {
+ returnUserId = userId;
+ }
+ return returnUserId;
+}
+
+UserId SqliteStorage::getUserId(const QString& username)
+{
+ UserId userId;
+
+ {
+ QSqlQuery query(logDb());
+ query.prepare(queryString("select_userid"));
+ query.bindValue(":username", username);
+
+ lockForRead();
+ safeExec(query);
+
+ if (query.first()) {
+ userId = query.value(0).toInt();
+ }
+ }
+ unlock();
+
+ return userId;
+}
+
+QString SqliteStorage::getUserAuthenticator(const UserId userid)
+{
+ QString authenticator = QString("");
+
+ {
+ QSqlQuery query(logDb());
+ query.prepare(queryString("select_authenticator"));
+ query.bindValue(":userid", userid.toInt());
+
+ lockForRead();
+ safeExec(query);
+
+ if (query.first()) {
+ authenticator = query.value(0).toString();
+ }
+ }
+ unlock();
+
+ return authenticator;
+}
+
+UserId SqliteStorage::internalUser()
+{
+ UserId userId;
+
+ {
+ QSqlQuery query(logDb());
+ query.prepare(queryString("select_internaluser"));
+ lockForRead();
+ safeExec(query);
+
+ if (query.first()) {
+ userId = query.value(0).toInt();
+ }
+ }
+ unlock();
+
+ return userId;
+}
+
+void SqliteStorage::delUser(UserId user)
+{
+ QSqlDatabase db = logDb();
+ db.transaction();
+
+ lockForWrite();
+ {
+ QSqlQuery query(db);
+ query.prepare(queryString("delete_backlog_by_uid"));
+ query.bindValue(":userid", user.toInt());
+ safeExec(query);
+
+ query.prepare(queryString("delete_buffers_by_uid"));
+ query.bindValue(":userid", user.toInt());
+ safeExec(query);
+
+ query.prepare(queryString("delete_networks_by_uid"));
+ query.bindValue(":userid", user.toInt());
+ safeExec(query);
+
+ query.prepare(queryString("delete_quasseluser"));
+ query.bindValue(":userid", user.toInt());
+ safeExec(query);
+ // I hate the lack of foreign keys and on delete cascade... :(
+ db.commit();
+ }
+ unlock();
+
+ emit userRemoved(user);
+}
+
+void SqliteStorage::setUserSetting(UserId userId, const QString& settingName, const QVariant& data)
+{
+ QByteArray rawData;
+ QDataStream out(&rawData, QIODevice::WriteOnly);
+ out.setVersion(QDataStream::Qt_4_2);
+ out << data;
+
+ QSqlDatabase db = logDb();
+ db.transaction();
+ {
+ QSqlQuery query(db);
+ query.prepare(queryString("insert_user_setting"));
+ query.bindValue(":userid", userId.toInt());
+ query.bindValue(":settingname", settingName);
+ query.bindValue(":settingvalue", rawData);
+ lockForWrite();
+ safeExec(query);
+
+ if (query.lastError().isValid()) {
+ QSqlQuery updateQuery(db);
+ updateQuery.prepare(queryString("update_user_setting"));
+ updateQuery.bindValue(":userid", userId.toInt());
+ updateQuery.bindValue(":settingname", settingName);
+ updateQuery.bindValue(":settingvalue", rawData);
+ safeExec(updateQuery);
+ }
+ db.commit();
+ }
+ unlock();
+}
+
+QVariant SqliteStorage::getUserSetting(UserId userId, const QString& settingName, const QVariant& defaultData)
+{
+ QVariant data = defaultData;
+ {
+ QSqlQuery query(logDb());
+ query.prepare(queryString("select_user_setting"));
+ query.bindValue(":userid", userId.toInt());
+ query.bindValue(":settingname", settingName);
+ lockForRead();
+ safeExec(query);
+
+ if (query.first()) {
+ QByteArray rawData = query.value(0).toByteArray();
+ QDataStream in(&rawData, QIODevice::ReadOnly);
+ in.setVersion(QDataStream::Qt_4_2);
+ in >> data;
+ }
+ }
+ unlock();
+ return data;
+}
+
+void SqliteStorage::setCoreState(const QVariantList& data)
+{
+ QByteArray rawData;
+ QDataStream out(&rawData, QIODevice::WriteOnly);
+ out.setVersion(QDataStream::Qt_4_2);
+ out << data;
+
+ QSqlDatabase db = logDb();
+ db.transaction();
+ {
+ QSqlQuery query(db);
+ query.prepare(queryString("insert_core_state"));
+ query.bindValue(":key", "active_sessions");
+ query.bindValue(":value", rawData);
+ lockForWrite();
+ safeExec(query);
+
+ if (query.lastError().isValid()) {
+ QSqlQuery updateQuery(db);
+ updateQuery.prepare(queryString("update_core_state"));
+ updateQuery.bindValue(":key", "active_sessions");
+ updateQuery.bindValue(":value", rawData);
+ safeExec(updateQuery);
+ }
+ db.commit();
+ }
+ unlock();
+}
+
+QVariantList SqliteStorage::getCoreState(const QVariantList& defaultData)
+{
+ QVariantList data;
+ {
+ QSqlQuery query(logDb());
+ query.prepare(queryString("select_core_state"));
+ query.bindValue(":key", "active_sessions");
+ lockForRead();
+ safeExec(query);
+
+ if (query.first()) {
+ QByteArray rawData = query.value(0).toByteArray();
+ QDataStream in(&rawData, QIODevice::ReadOnly);
+ in.setVersion(QDataStream::Qt_4_2);
+ in >> data;
+ }
+ else {
+ data = defaultData;
+ }
+ }
+ unlock();
+ return data;
+}
+
+IdentityId SqliteStorage::createIdentity(UserId user, CoreIdentity& identity)
+{
+ IdentityId identityId;
+
+ QSqlDatabase db = logDb();
+ db.transaction();
+
+ {
+ QSqlQuery query(db);
+ query.prepare(queryString("insert_identity"));
+ query.bindValue(":userid", user.toInt());
+ query.bindValue(":identityname", identity.identityName());
+ query.bindValue(":realname", identity.realName());
+ query.bindValue(":awaynick", identity.awayNick());
+ query.bindValue(":awaynickenabled", identity.awayNickEnabled() ? 1 : 0);
+ query.bindValue(":awayreason", identity.awayReason());
+ query.bindValue(":awayreasonenabled", identity.awayReasonEnabled() ? 1 : 0);
+ query.bindValue(":autoawayenabled", identity.awayReasonEnabled() ? 1 : 0);
+ query.bindValue(":autoawaytime", identity.autoAwayTime());
+ query.bindValue(":autoawayreason", identity.autoAwayReason());
+ query.bindValue(":autoawayreasonenabled", identity.autoAwayReasonEnabled() ? 1 : 0);
+ query.bindValue(":detachawayenabled", identity.detachAwayEnabled() ? 1 : 0);
+ query.bindValue(":detachawayreason", identity.detachAwayReason());
+ query.bindValue(":detachawayreasonenabled", identity.detachAwayReasonEnabled() ? 1 : 0);
+ query.bindValue(":ident", identity.ident());
+ query.bindValue(":kickreason", identity.kickReason());
+ query.bindValue(":partreason", identity.partReason());
+ query.bindValue(":quitreason", identity.quitReason());
+ query.bindValue(":sslcert", identity.sslCert().toPem());
+ query.bindValue(":sslkey", identity.sslKey().toPem());
+
+ lockForWrite();
+ safeExec(query);
+
+ identityId = query.lastInsertId().toInt();
+ if (!identityId.isValid()) {
+ watchQuery(query);
+ }
+ else {
+ QSqlQuery deleteNickQuery(db);
+ deleteNickQuery.prepare(queryString("delete_nicks"));
+ deleteNickQuery.bindValue(":identityid", identityId.toInt());
+ safeExec(deleteNickQuery);
+
+ QSqlQuery insertNickQuery(db);
+ insertNickQuery.prepare(queryString("insert_nick"));
+ foreach (QString nick, identity.nicks()) {
+ insertNickQuery.bindValue(":identityid", identityId.toInt());
+ insertNickQuery.bindValue(":nick", nick);
+ safeExec(insertNickQuery);
+ }
+ }
+ db.commit();
+ }
+ unlock();
+ identity.setId(identityId);
+ return identityId;
+}