1 /***************************************************************************
2 * Copyright (C) 2005-07 by The Quassel IRC Development Team *
3 * devel@quassel-irc.org *
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) any later version. *
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. *
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 ***************************************************************************/
25 #include "coreproxy.h"
26 #include "sqlitestorage.h"
31 Core *Core::instanceptr = 0;
33 Core * Core::instance() {
34 if(instanceptr) return instanceptr;
35 instanceptr = new Core();
40 void Core::destroy() {
50 if(!SqliteStorage::isAvailable()) {
51 qFatal("Sqlite is currently required! Please make sure your Qt library has sqlite support enabled.");
53 //SqliteStorage::init();
54 storage = new SqliteStorage();
55 connect(Global::instance(), SIGNAL(dataPutLocally(UserId, QString)), this, SLOT(updateGlobalData(UserId, QString)));
56 connect(&server, SIGNAL(newConnection()), this, SLOT(incomingConnection()));
57 //startListening(); // FIXME
58 if(Global::runMode == Global::Monolithic) { // TODO Make GUI user configurable
59 guiUser = storage->validateUser("Default", "password");
60 if(!guiUser) guiUser = storage->addUser("Default", "password");
62 Global::setGuiUser(guiUser);
63 createSession(guiUser);
66 // Read global settings from config file
68 s.beginGroup("Global");
69 foreach(QString unum, s.childGroups()) {
70 UserId uid = unum.toUInt();
72 foreach(QString key, s.childKeys()) {
73 Global::updateData(uid, key, s.value(key));
81 foreach(QTcpSocket *sock, validClients.keys()) {
88 CoreSession *Core::session(UserId uid) {
89 Core *core = instance();
90 if(core->sessions.contains(uid)) return core->sessions[uid];
94 CoreSession *Core::guiSession() {
95 Core *core = instance();
96 if(core->guiUser && core->sessions.contains(core->guiUser)) return core->sessions[core->guiUser];
100 CoreSession *Core::createSession(UserId uid) {
101 Core *core = instance();
102 Q_ASSERT(!core->sessions.contains(uid));
103 CoreSession *sess = new CoreSession(uid, core->storage);
104 core->sessions[uid] = sess;
105 connect(sess, SIGNAL(proxySignal(CoreSignal, QVariant, QVariant, QVariant)), core, SLOT(recvProxySignal(CoreSignal, QVariant, QVariant, QVariant)));
110 bool Core::startListening(uint port) {
111 if(!server.listen(QHostAddress::Any, port)) {
112 qWarning(QString(QString("Could not open GUI client port %1: %2").arg(port).arg(server.errorString())).toAscii());
115 qDebug() << "Listening for GUI clients on port" << server.serverPort();
119 void Core::stopListening() {
121 qDebug() << "No longer listening for GUI clients.";
124 void Core::incomingConnection() {
125 // TODO implement SSL
126 QTcpSocket *socket = server.nextPendingConnection();
127 connect(socket, SIGNAL(disconnected()), this, SLOT(clientDisconnected()));
128 connect(socket, SIGNAL(readyRead()), this, SLOT(clientHasData()));
129 blockSizes.insert(socket, (quint32)0);
130 qDebug() << "Client connected from " << socket->peerAddress().toString();
133 void Core::clientHasData() {
134 QTcpSocket *socket = dynamic_cast<QTcpSocket*>(sender());
135 Q_ASSERT(socket && blockSizes.contains(socket));
136 quint32 bsize = blockSizes.value(socket);
138 while(readDataFromDevice(socket, bsize, item)) {
139 if(validClients.contains(socket)) {
140 QList<QVariant> sigdata = item.toList();
141 if((GUISignal)sigdata[0].toInt() == GS_UPDATE_GLOBAL_DATA) {
142 processClientUpdate(socket, sigdata[1].toString(), sigdata[2]);
144 sessions[validClients[socket]]->processSignal((GUISignal)sigdata[0].toInt(), sigdata[1], sigdata[2], sigdata[3]);
147 // we need to auth the client
149 processClientInit(socket, item);
150 } catch(Storage::AuthError) {
151 qWarning() << "Authentification error!"; // FIXME
154 } catch(Exception e) {
155 qWarning() << "Client init error:" << e.msg();
160 blockSizes[socket] = bsize = 0;
162 blockSizes[socket] = bsize;
165 void Core::clientDisconnected() {
166 QTcpSocket *socket = dynamic_cast<QTcpSocket*>(sender());
167 blockSizes.remove(socket);
168 validClients.remove(socket);
169 qDebug() << "Client disconnected.";
170 // TODO remove unneeded sessions - if necessary/possible...
173 void Core::processClientInit(QTcpSocket *socket, const QVariant &v) {
174 VarMap msg = v.toMap();
175 if(msg["GUIProtocol"].toUInt() != GUI_PROTOCOL) {
176 //qWarning() << "Client version mismatch.";
177 throw Exception("GUI client version mismatch");
180 UserId uid = storage->validateUser(msg["User"].toString(), msg["Password"].toString()); // throws exception if this failed
182 // Find or create session for validated user
184 if(sessions.contains(uid)) sess = sessions[uid];
186 sess = createSession(uid);
187 validClients[socket] = uid;
192 QStringList dataKeys = Global::keys(uid);
194 foreach(key, dataKeys) {
195 coreData[key] = Global::data(key);
197 reply["CoreData"] = coreData;
198 reply["SessionState"] = sess->sessionState();
199 QList<QVariant> sigdata;
200 sigdata.append(CS_CORE_STATE); sigdata.append(QVariant(reply)); sigdata.append(QVariant()); sigdata.append(QVariant());
201 writeDataToDevice(socket, QVariant(sigdata));
202 sess->sendServerStates();
205 void Core::processClientUpdate(QTcpSocket *socket, QString key, const QVariant &data) {
206 UserId uid = validClients[socket];
207 Global::updateData(uid, key, data);
208 QList<QVariant> sigdata;
209 sigdata.append(CS_UPDATE_GLOBAL_DATA); sigdata.append(key); sigdata.append(data); sigdata.append(QVariant());
210 foreach(QTcpSocket *s, validClients.keys()) {
211 if(validClients[s] == uid && s != socket) writeDataToDevice(s, QVariant(sigdata));
215 void Core::updateGlobalData(UserId uid, QString key) {
216 QVariant data = Global::data(uid, key);
217 QList<QVariant> sigdata;
218 sigdata.append(CS_UPDATE_GLOBAL_DATA); sigdata.append(key); sigdata.append(data); sigdata.append(QVariant());
219 foreach(QTcpSocket *socket, validClients.keys()) {
220 if(validClients[socket] == uid) writeDataToDevice(socket, QVariant(sigdata));
224 void Core::recvProxySignal(CoreSignal sig, QVariant arg1, QVariant arg2, QVariant arg3) {
225 CoreSession *sess = qobject_cast<CoreSession*>(sender());
227 UserId uid = sess->userId();
228 QList<QVariant> sigdata;
229 sigdata.append(sig); sigdata.append(arg1); sigdata.append(arg2); sigdata.append(arg3);
230 //qDebug() << "Sending signal: " << sigdata;
231 foreach(QTcpSocket *socket, validClients.keys()) {
232 if(validClients[socket] == uid) writeDataToDevice(socket, QVariant(sigdata));
237 // Read global settings from config file
239 s.beginGroup("Global");
241 foreach(key, s.childKeys()) {
242 global->updateData(key, s.value(key));
245 global->updateData("CoreReady", true);
246 // Now that we are in sync, we can connect signals to automatically store further updates.
247 // I don't think we care if global data changed locally or if it was updated by a client.
248 connect(global, SIGNAL(dataUpdatedRemotely(QString)), SLOT(globalDataUpdated(QString)));
249 connect(global, SIGNAL(dataPutLocally(QString)), SLOT(globalDataUpdated(QString)));
254 CoreSession::CoreSession(UserId uid, Storage *_storage) : user(uid), storage(_storage) {
255 coreProxy = new CoreProxy();
256 connect(coreProxy, SIGNAL(send(CoreSignal, QVariant, QVariant, QVariant)), this, SIGNAL(proxySignal(CoreSignal, QVariant, QVariant, QVariant)));
258 connect(coreProxy, SIGNAL(requestServerStates()), this, SIGNAL(serverStateRequested()));
259 connect(coreProxy, SIGNAL(gsRequestConnect(QStringList)), this, SLOT(connectToIrc(QStringList)));
260 connect(coreProxy, SIGNAL(gsUserInput(BufferId, QString)), this, SLOT(msgFromGui(BufferId, QString)));
261 connect(coreProxy, SIGNAL(gsImportBacklog()), storage, SLOT(importOldBacklog()));
262 connect(coreProxy, SIGNAL(gsRequestBacklog(BufferId, QVariant, QVariant)), this, SLOT(sendBacklog(BufferId, QVariant, QVariant)));
263 connect(this, SIGNAL(displayMsg(Message)), coreProxy, SLOT(csDisplayMsg(Message)));
264 connect(this, SIGNAL(displayStatusMsg(QString, QString)), coreProxy, SLOT(csDisplayStatusMsg(QString, QString)));
265 connect(this, SIGNAL(backlogData(BufferId, QList<QVariant>, bool)), coreProxy, SLOT(csBacklogData(BufferId, QList<QVariant>, bool)));
266 connect(this, SIGNAL(bufferIdUpdated(BufferId)), coreProxy, SLOT(csUpdateBufferId(BufferId)));
267 connect(storage, SIGNAL(bufferIdUpdated(BufferId)), coreProxy, SLOT(csUpdateBufferId(BufferId)));
268 connect(Global::instance(), SIGNAL(dataUpdatedRemotely(UserId, QString)), this, SLOT(globalDataUpdated(UserId, QString)));
269 connect(Global::instance(), SIGNAL(dataPutLocally(UserId, QString)), this, SLOT(globalDataUpdated(UserId, QString)));
273 CoreSession::~CoreSession() {
277 UserId CoreSession::userId() {
281 void CoreSession::processSignal(GUISignal sig, QVariant arg1, QVariant arg2, QVariant arg3) {
282 coreProxy->recv(sig, arg1, arg2, arg3);
285 void CoreSession::globalDataUpdated(UserId uid, QString key) {
286 Q_ASSERT(uid == userId());
287 QVariant data = Global::data(userId(), key);
289 s.setValue(QString("Global/%1/").arg(userId())+key, data);
292 void CoreSession::connectToIrc(QStringList networks) {
293 foreach(QString net, networks) {
294 if(servers.contains(net)) {
297 Server *server = new Server(userId(), net);
298 connect(this, SIGNAL(serverStateRequested()), server, SLOT(sendState()));
299 connect(this, SIGNAL(connectToIrc(QString)), server, SLOT(connectToIrc(QString)));
300 connect(this, SIGNAL(disconnectFromIrc(QString)), server, SLOT(disconnectFromIrc(QString)));
301 connect(this, SIGNAL(msgFromGui(QString, QString, QString)), server, SLOT(userInput(QString, QString, QString)));
302 connect(server, SIGNAL(serverState(QString, VarMap)), coreProxy, SLOT(csServerState(QString, VarMap)));
303 //connect(server, SIGNAL(displayMsg(Message)), this, SLOT(recvMessageFromServer(Message)));
304 connect(server, SIGNAL(displayMsg(Message::Type, QString, QString, QString, quint8)), this, SLOT(recvMessageFromServer(Message::Type, QString, QString, QString, quint8)));
305 connect(server, SIGNAL(displayStatusMsg(QString)), this, SLOT(recvStatusMsgFromServer(QString)));
306 connect(server, SIGNAL(modeSet(QString, QString, QString)), coreProxy, SLOT(csModeSet(QString, QString, QString)));
307 connect(server, SIGNAL(topicSet(QString, QString, QString)), coreProxy, SLOT(csTopicSet(QString, QString, QString)));
308 connect(server, SIGNAL(nickAdded(QString, QString, VarMap)), coreProxy, SLOT(csNickAdded(QString, QString, VarMap)));
309 connect(server, SIGNAL(nickRenamed(QString, QString, QString)), coreProxy, SLOT(csNickRenamed(QString, QString, QString)));
310 connect(server, SIGNAL(nickRemoved(QString, QString)), coreProxy, SLOT(csNickRemoved(QString, QString)));
311 connect(server, SIGNAL(nickUpdated(QString, QString, VarMap)), coreProxy, SLOT(csNickUpdated(QString, QString, VarMap)));
312 connect(server, SIGNAL(ownNickSet(QString, QString)), coreProxy, SLOT(csOwnNickSet(QString, QString)));
313 connect(server, SIGNAL(queryRequested(QString, QString)), coreProxy, SLOT(csQueryRequested(QString, QString)));
314 // TODO add error handling
315 connect(server, SIGNAL(connected(QString)), coreProxy, SLOT(csServerConnected(QString)));
316 connect(server, SIGNAL(disconnected(QString)), this, SLOT(serverDisconnected(QString)));
319 servers[net] = server;
321 emit connectToIrc(net);
325 void CoreSession::serverDisconnected(QString net) {
328 coreProxy->csServerDisconnected(net);
331 void CoreSession::msgFromGui(BufferId bufid, QString msg) {
332 emit msgFromGui(bufid.network(), bufid.buffer(), msg);
335 // ALL messages coming pass through these functions before going to the GUI.
336 // So this is the perfect place for storing the backlog and log stuff.
338 void CoreSession::recvMessageFromServer(Message::Type type, QString target, QString text, QString sender, quint8 flags) {
339 Server *s = qobject_cast<Server*>(this->sender());
342 if((flags & Message::PrivMsg) && !(flags & Message::Self)) {
343 buf = storage->getBufferId(user, s->getNetwork(), nickFromMask(sender));
345 buf = storage->getBufferId(user, s->getNetwork(), target);
347 Message msg(buf, type, text, sender, flags);
348 msg.msgId = storage->logMessage(msg); //qDebug() << msg.msgId;
350 emit displayMsg(msg);
353 void CoreSession::recvStatusMsgFromServer(QString msg) {
354 Server *s = qobject_cast<Server*>(sender());
356 emit displayStatusMsg(s->getNetwork(), msg);
360 QList<BufferId> CoreSession::buffers() const {
361 return storage->requestBuffers(user);
365 QVariant CoreSession::sessionState() {
367 QList<QVariant> bufs;
368 foreach(BufferId id, storage->requestBuffers(user)) { bufs.append(QVariant::fromValue(id)); }
374 void CoreSession::sendServerStates() {
375 emit serverStateRequested();
378 void CoreSession::sendBacklog(BufferId id, QVariant v1, QVariant v2) {
380 QList<Message> msglist;
381 if(v1.type() == QVariant::DateTime) {
385 msglist = storage->requestMsgs(id, v1.toInt(), v2.toInt());
388 // Send messages out in smaller packages - we don't want to make the signal data too large!
389 for(int i = 0; i < msglist.count(); i++) {
390 log.append(QVariant::fromValue(msglist[i]));
391 if(log.count() >= 5) {
392 emit backlogData(id, log, i >= msglist.count() - 1);
396 if(log.count() > 0) emit backlogData(id, log, true);