#include "sqlitestorage.h"
-#include <QCryptographicHash>
#include <QtSql>
#include "network.h"
+#include "util.h"
+
SqliteStorage::SqliteStorage(QObject *parent)
: AbstractSqlStorage(parent)
{
}
UserId SqliteStorage::addUser(const QString &user, const QString &password) {
- QByteArray cryptopass = QCryptographicHash::hash(password.toUtf8(), QCryptographicHash::Sha1);
- cryptopass = cryptopass.toHex();
-
QSqlQuery query(logDb());
query.prepare(queryString("insert_quasseluser"));
query.bindValue(":username", user);
- query.bindValue(":password", cryptopass);
+ query.bindValue(":password", cryptedPassword(password));
query.exec();
if(query.lastError().isValid() && query.lastError().number() == 19) { // user already exists - sadly 19 seems to be the general constraint violation error...
return 0;
}
void SqliteStorage::updateUser(UserId user, const QString &password) {
- QByteArray cryptopass = QCryptographicHash::hash(password.toUtf8(), QCryptographicHash::Sha1);
- cryptopass = cryptopass.toHex();
-
QSqlQuery query(logDb());
query.prepare(queryString("update_userpassword"));
query.bindValue(":userid", user.toInt());
- query.bindValue(":password", cryptopass);
+ query.bindValue(":password", cryptedPassword(password));
query.exec();
}
}
UserId SqliteStorage::validateUser(const QString &user, const QString &password) {
- QByteArray cryptopass = QCryptographicHash::hash(password.toUtf8(), QCryptographicHash::Sha1);
- cryptopass = cryptopass.toHex();
-
QSqlQuery query(logDb());
query.prepare(queryString("select_authuser"));
query.bindValue(":username", user);
- query.bindValue(":password", cryptopass);
+ query.bindValue(":password", cryptedPassword(password));
query.exec();
if(query.first()) {
return true;
}
+bool SqliteStorage::isValidBuffer(const UserId &user, const BufferId &bufferId) {
+ QSqlQuery query(logDb());
+ query.prepare(queryString("select_bufferExists"));
+ query.bindValue(":userid", user.toInt());
+ query.bindValue(":bufferid", bufferId.toInt());
+ query.exec();
+
+ watchQuery(&query);
+ if(!query.first())
+ return false;
+
+ Q_ASSERT(!query.next());
+ return true;
+}
+
NetworkId SqliteStorage::getNetworkId(UserId user, const QString &network) {
QSqlQuery query(logDb());
query.prepare("SELECT networkid FROM network "
return NetworkId();
}
+QList<NetworkId> SqliteStorage::connectedNetworks(UserId user) {
+ QList<NetworkId> connectedNets;
+ QSqlQuery query(logDb());
+ query.prepare(queryString("select_connected_networks"));
+ query.bindValue(":userid", user.toInt());
+ query.exec();
+ watchQuery(&query);
+
+ while(query.next()) {
+ connectedNets << query.value(0).toInt();
+ }
+
+ return connectedNets;
+}
+
+void SqliteStorage::setNetworkConnected(UserId user, const NetworkId &networkId, bool isConnected) {
+ QSqlQuery query(logDb());
+ query.prepare(queryString("update_network_connected"));
+ query.bindValue(":userid", user.toInt());
+ query.bindValue(":networkid", networkId.toInt());
+ query.bindValue(":connected", isConnected ? 1 : 0);
+ query.exec();
+ watchQuery(&query);
+}
+
+QHash<QString, QString> SqliteStorage::persistentChannels(UserId user, const NetworkId &networkId) {
+ QHash<QString, QString> persistentChans;
+ QSqlQuery query(logDb());
+ query.prepare(queryString("select_persistent_channels"));
+ query.bindValue(":userid", user.toInt());
+ query.bindValue(":networkid", networkId.toInt());
+ query.exec();
+ watchQuery(&query);
+
+ while(query.next()) {
+ persistentChans[query.value(0).toString()] = query.value(1).toString();
+ }
+
+ return persistentChans;
+}
+
+void SqliteStorage::setChannelPersistent(UserId user, const NetworkId &networkId, const QString &channel, bool isJoined) {
+ QSqlQuery query(logDb());
+ query.prepare(queryString("update_buffer_persistent_channel"));
+ query.bindValue(":userid", user.toInt());
+ query.bindValue(":networkId", networkId.toInt());
+ query.bindValue(":buffercname", channel.toLower());
+ query.bindValue(":joined", isJoined ? 1 : 0);
+ query.exec();
+ watchQuery(&query);
+}
+
+void SqliteStorage::setPersistentChannelKey(UserId user, const NetworkId &networkId, const QString &channel, const QString &key) {
+ QSqlQuery query(logDb());
+ query.prepare(queryString("update_buffer_set_channel_key"));
+ query.bindValue(":userid", user.toInt());
+ query.bindValue(":networkId", networkId.toInt());
+ query.bindValue(":buffercname", channel.toLower());
+ query.bindValue(":key", key);
+ query.exec();
+ watchQuery(&query);
+}
+
+
void SqliteStorage::createBuffer(UserId user, const NetworkId &networkId, BufferInfo::Type type, const QString &buffer) {
QSqlQuery *query = cachedQuery("insert_buffer");
query->bindValue(":userid", user.toInt());
return bufferInfo;
}
+BufferInfo SqliteStorage::getBufferInfo(UserId user, const BufferId &bufferId) {
+ QSqlQuery query(logDb());
+ query.prepare(queryString("select_buffer_by_id"));
+ query.bindValue(":userid", user.toInt());
+ query.bindValue(":bufferid", bufferId.toInt());
+ query.exec();
+ if(!watchQuery(&query))
+ return BufferInfo();
+
+ if(!query.first())
+ return BufferInfo();
+
+ BufferInfo bufferInfo(query.value(0).toInt(), query.value(1).toInt(), (BufferInfo::Type)query.value(2).toInt(), 0, query.value(4).toString());
+ Q_ASSERT(!query.next());
+
+ return bufferInfo;
+}
+
QList<BufferInfo> SqliteStorage::requestBuffers(UserId user, QDateTime since) {
uint time = 0;
if(since.isValid())
return bufferlist;
}
-void SqliteStorage::setBufferLastSeen(UserId user, const BufferId &bufferId, const QDateTime &seenDate) {
+bool SqliteStorage::removeBuffer(const UserId &user, const BufferId &bufferId) {
+ if(!isValidBuffer(user, bufferId))
+ return false;
+
+ QSqlQuery delBacklogQuery(logDb());
+ delBacklogQuery.prepare(queryString("delete_backlog_for_buffer"));
+ delBacklogQuery.bindValue(":bufferid", bufferId.toInt());
+ delBacklogQuery.exec();
+ if(!watchQuery(&delBacklogQuery))
+ return false;
+
+ QSqlQuery delBufferQuery(logDb());
+ delBufferQuery.prepare(queryString("delete_buffer_for_bufferid"));
+ delBufferQuery.bindValue(":bufferid", bufferId.toInt());
+ delBufferQuery.exec();
+ if(!watchQuery(&delBufferQuery))
+ return false;
+
+ return true;
+}
+
+BufferId SqliteStorage::renameBuffer(const UserId &user, const NetworkId &networkId, const QString &newName, const QString &oldName) {
+ // check if such a buffer exists...
+ QSqlQuery existsQuery(logDb());
+ existsQuery.prepare(queryString("select_bufferByName"));
+ existsQuery.bindValue(":networkid", networkId.toInt());
+ existsQuery.bindValue(":userid", user.toInt());
+ existsQuery.bindValue(":buffercname", oldName.toLower());
+ existsQuery.exec();
+ if(!watchQuery(&existsQuery))
+ return false;
+
+ if(!existsQuery.first())
+ return false;
+
+ const int bufferid = existsQuery.value(0).toInt();
+
+ Q_ASSERT(!existsQuery.next());
+
+ // ... and if the new name is still free.
+ existsQuery.bindValue(":networkid", networkId.toInt());
+ existsQuery.bindValue(":userid", user.toInt());
+ existsQuery.bindValue(":buffercname", newName.toLower());
+ existsQuery.exec();
+ if(!watchQuery(&existsQuery))
+ return false;
+
+ if(existsQuery.first())
+ return false;
+
+ QSqlQuery renameBufferQuery(logDb());
+ renameBufferQuery.prepare(queryString("update_buffer_name"));
+ renameBufferQuery.bindValue(":buffername", newName);
+ renameBufferQuery.bindValue(":buffercname", newName.toLower());
+ renameBufferQuery.bindValue(":bufferid", bufferid);
+ renameBufferQuery.exec();
+ if(watchQuery(&existsQuery))
+ return BufferId(bufferid);
+ else
+ return BufferId();
+}
+
+void SqliteStorage::setBufferLastSeenMsg(UserId user, const BufferId &bufferId, const MsgId &msgId) {
QSqlQuery *query = cachedQuery("update_buffer_lastseen");
query->bindValue(":userid", user.toInt());
query->bindValue(":bufferid", bufferId.toInt());
- query->bindValue(":lastseen", seenDate.toTime_t());
+ query->bindValue(":lastseenmsgid", msgId.toInt());
query->exec();
watchQuery(query);
}
-QHash<BufferId, QDateTime> SqliteStorage::bufferLastSeenDates(UserId user) {
- QHash<BufferId, QDateTime> lastSeenHash;
+QHash<BufferId, MsgId> SqliteStorage::bufferLastSeenMsgIds(UserId user) {
+ QHash<BufferId, MsgId> lastSeenHash;
QSqlQuery query(logDb());
- query.prepare(queryString("select_buffer_lastseen_dates"));
+ query.prepare(queryString("select_buffer_lastseen_messages"));
query.bindValue(":userid", user.toInt());
query.exec();
if(!watchQuery(&query))
return lastSeenHash;
while(query.next()) {
- lastSeenHash[query.value(0).toInt()] = QDateTime::fromTime_t(query.value(1).toUInt());
+ lastSeenHash[query.value(0).toInt()] = query.value(1).toInt();
}
return lastSeenHash;
}
}
}
- QSqlQuery *getLastMessageIdQuery = cachedQuery("select_lastMessage");
- getLastMessageIdQuery->bindValue(":time", msg.timestamp().toTime_t());
- getLastMessageIdQuery->bindValue(":bufferid", msg.bufferInfo().bufferId().toInt());
- getLastMessageIdQuery->bindValue(":type", msg.type());
- getLastMessageIdQuery->bindValue(":sender", msg.sender());
- getLastMessageIdQuery->exec();
-
- if(getLastMessageIdQuery->first()) {
- return getLastMessageIdQuery->value(0).toInt();
- } else { // somethin went wrong... :(
- qDebug() << getLastMessageIdQuery->lastQuery() << "time/bufferid/type/sender:" << msg.timestamp().toTime_t() << msg.bufferInfo().bufferId() << msg.type() << msg.sender();
- Q_ASSERT(false);
- return 0;
- }
+ MsgId msgId = logMessageQuery->lastInsertId().toInt();
+ Q_ASSERT(msgId.isValid());
+ return msgId;
}
-QList<Message> SqliteStorage::requestMsgs(BufferInfo buffer, int lastmsgs, int offset) {
+QList<Message> SqliteStorage::requestMsgs(UserId user, BufferId bufferId, int lastmsgs, int offset) {
QList<Message> messagelist;
- // we have to determine the real offset first
- QSqlQuery *offsetQuery = cachedQuery("select_messagesOffset");
- offsetQuery->bindValue(":bufferid", buffer.bufferId().toInt());
- offsetQuery->bindValue(":messageid", offset);
- offsetQuery->exec();
- offsetQuery->first();
- offset = offsetQuery->value(0).toInt();
+
+ BufferInfo bufferInfo = getBufferInfo(user, bufferId);
+ if(!bufferInfo.isValid())
+ return messagelist;
+
+ if(offset == -1) {
+ offset = 0;
+ } else {
+ // we have to determine the real offset first
+ QSqlQuery *offsetQuery = cachedQuery("select_messagesOffset");
+ offsetQuery->bindValue(":bufferid", bufferId.toInt());
+ offsetQuery->bindValue(":messageid", offset);
+ offsetQuery->exec();
+ offsetQuery->first();
+ offset = offsetQuery->value(0).toInt();
+ }
// now let's select the messages
QSqlQuery *msgQuery = cachedQuery("select_messages");
- msgQuery->bindValue(":bufferid", buffer.bufferId().toInt());
+ msgQuery->bindValue(":bufferid", bufferId.toInt());
msgQuery->bindValue(":limit", lastmsgs);
msgQuery->bindValue(":offset", offset);
msgQuery->exec();
while(msgQuery->next()) {
Message msg(QDateTime::fromTime_t(msgQuery->value(1).toInt()),
- buffer,
+ bufferInfo,
(Message::Type)msgQuery->value(2).toUInt(),
msgQuery->value(5).toString(),
msgQuery->value(4).toString(),
}
-QList<Message> SqliteStorage::requestMsgs(BufferInfo buffer, QDateTime since, int offset) {
+QList<Message> SqliteStorage::requestMsgs(UserId user, BufferId bufferId, QDateTime since, int offset) {
QList<Message> messagelist;
+
+ BufferInfo bufferInfo = getBufferInfo(user, bufferId);
+ if(!bufferInfo.isValid())
+ return messagelist;
+
// we have to determine the real offset first
QSqlQuery *offsetQuery = cachedQuery("select_messagesSinceOffset");
- offsetQuery->bindValue(":bufferid", buffer.bufferId().toInt());
+ offsetQuery->bindValue(":bufferid", bufferId.toInt());
offsetQuery->bindValue(":since", since.toTime_t());
offsetQuery->exec();
offsetQuery->first();
// now let's select the messages
QSqlQuery *msgQuery = cachedQuery("select_messagesSince");
- msgQuery->bindValue(":bufferid", buffer.bufferId().toInt());
+ msgQuery->bindValue(":bufferid", bufferId.toInt());
msgQuery->bindValue(":since", since.toTime_t());
msgQuery->bindValue(":offset", offset);
msgQuery->exec();
while(msgQuery->next()) {
Message msg(QDateTime::fromTime_t(msgQuery->value(1).toInt()),
- buffer,
+ bufferInfo,
(Message::Type)msgQuery->value(2).toUInt(),
msgQuery->value(5).toString(),
msgQuery->value(4).toString(),
}
-QList<Message> SqliteStorage::requestMsgRange(BufferInfo buffer, int first, int last) {
+QList<Message> SqliteStorage::requestMsgRange(UserId user, BufferId bufferId, int first, int last) {
QList<Message> messagelist;
+
+ BufferInfo bufferInfo = getBufferInfo(user, bufferId);
+ if(!bufferInfo.isValid())
+ return messagelist;
+
QSqlQuery *rangeQuery = cachedQuery("select_messageRange");
- rangeQuery->bindValue(":bufferid", buffer.bufferId().toInt());
+ rangeQuery->bindValue(":bufferid", bufferId.toInt());
rangeQuery->bindValue(":firstmsg", first);
rangeQuery->bindValue(":lastmsg", last);
rangeQuery->exec();
while(rangeQuery->next()) {
Message msg(QDateTime::fromTime_t(rangeQuery->value(1).toInt()),
- buffer,
+ bufferInfo,
(Message::Type)rangeQuery->value(2).toUInt(),
rangeQuery->value(5).toString(),
rangeQuery->value(4).toString(),
}
QString SqliteStorage::backlogFile() {
- // kinda ugly, but I currently see no other way to do that
-#ifdef Q_OS_WIN32
- QString quasselDir = QDir::homePath() + qgetenv("APPDATA") + "\\quassel\\";
-#else
- QString quasselDir = QDir::homePath() + "/.quassel/";
-#endif
-
- QDir qDir(quasselDir);
- if(!qDir.exists(quasselDir))
- qDir.mkpath(quasselDir);
-
- return quasselDir + "quassel-storage.sqlite";
+ return quasselDir().absolutePath() + "/quassel-storage.sqlite";
}
+
+// ONLY NEEDED FOR MIGRATION
+bool SqliteStorage::init(const QVariantMap &settings) {
+ if(!AbstractSqlStorage::init(settings))
+ return false;
+
+ QSqlQuery checkMigratedQuery(logDb());
+ checkMigratedQuery.prepare("SELECT DISTINCT typeOf(password) FROM quasseluser");
+ checkMigratedQuery.exec();
+ if(!watchQuery(&checkMigratedQuery))
+ return false;
+
+ if(!checkMigratedQuery.first())
+ return true; // table is empty -> no work to be done
+
+ QString passType = checkMigratedQuery.value(0).toString().toLower();
+ if(passType == "text")
+ return true; // allready migrated
+
+ Q_ASSERT(passType == "blob");
+
+ QSqlQuery getPasswordsQuery(logDb());
+ getPasswordsQuery.prepare("SELECT userid, password FROM quasseluser");
+ getPasswordsQuery.exec();
+
+ if(!watchQuery(&getPasswordsQuery)) {
+ qWarning() << "unable to migrate to new password format!";
+ return false;
+ }
+
+ QHash<int, QByteArray> passHash;
+ while(getPasswordsQuery.next()) {
+ passHash[getPasswordsQuery.value(0).toInt()] = getPasswordsQuery.value(1).toByteArray();
+ }
+
+ QSqlQuery setPasswordsQuery(logDb());
+ setPasswordsQuery.prepare("UPDATE quasseluser SET password = :password WHERE userid = :userid");
+ foreach(int userId, passHash.keys()) {
+ setPasswordsQuery.bindValue(":password", QString(passHash[userId]));
+ setPasswordsQuery.bindValue(":userid", userId);
+ setPasswordsQuery.exec();
+ watchQuery(&setPasswordsQuery);
+ }
+
+ qDebug() << "successfully migrated passwords!";
+ return true;
+}