+void CoreSession::recvMessageFromServer(NetworkId networkId,
+ Message::Type type,
+ BufferInfo::Type bufferType,
+ const QString& target,
+ const QString& text_,
+ const QString& sender,
+ Message::Flags flags)
+{
+ // U+FDD0 and U+FDD1 are special characters for Qt's text engine, specifically they mark the boundaries of
+ // text frames in a QTextDocument. This might lead to problems in widgets displaying QTextDocuments (such as
+ // KDE's notifications), hence we remove those just to be safe.
+ QString text = text_;
+ text.remove(QChar(0xfdd0)).remove(QChar(0xfdd1));
+ RawMessage rawMsg(networkId, type, bufferType, target, text, sender, flags);
+
+ // check for HardStrictness ignore
+ CoreNetwork* currentNetwork = network(networkId);
+ QString networkName = currentNetwork ? currentNetwork->networkName() : QString("");
+ if (_ignoreListManager.match(rawMsg, networkName) == IgnoreListManager::HardStrictness)
+ return;
+
+ if (currentNetwork && _highlightRuleManager.match(rawMsg, currentNetwork->myNick(), currentNetwork->identityPtr()->nicks()))
+ rawMsg.flags |= Message::Flag::Highlight;
+
+ _messageQueue << rawMsg;
+ if (!_processMessages) {
+ _processMessages = true;
+ QCoreApplication::postEvent(this, new ProcessMessagesEvent());
+ }
+}
+
+void CoreSession::recvStatusMsgFromServer(QString msg)
+{
+ auto* net = qobject_cast<CoreNetwork*>(sender());
+ Q_ASSERT(net);
+ emit displayStatusMsg(net->networkName(), msg);
+}
+
+void CoreSession::processMessageEvent(MessageEvent* event)
+{
+ recvMessageFromServer(event->networkId(),
+ event->msgType(),
+ event->bufferType(),
+ event->target().isNull() ? "" : event->target(),
+ event->text().isNull() ? "" : event->text(),
+ event->sender().isNull() ? "" : event->sender(),
+ event->msgFlags());
+}
+
+QList<BufferInfo> CoreSession::buffers() const
+{
+ return Core::requestBuffers(user());
+}
+
+void CoreSession::customEvent(QEvent* event)
+{
+ if (event->type() != QEvent::User)
+ return;
+
+ processMessages();
+ event->accept();
+}
+
+void CoreSession::processMessages()
+{
+ if (_messageQueue.count() == 1) {
+ const RawMessage& rawMsg = _messageQueue.first();
+ bool createBuffer = !(rawMsg.flags & Message::Redirected);
+ BufferInfo bufferInfo = Core::bufferInfo(user(), rawMsg.networkId, rawMsg.bufferType, rawMsg.target, createBuffer);
+ if (!bufferInfo.isValid()) {
+ Q_ASSERT(!createBuffer);
+ bufferInfo = Core::bufferInfo(user(), rawMsg.networkId, BufferInfo::StatusBuffer, "");
+ }
+ Message msg(bufferInfo,
+ rawMsg.type,
+ rawMsg.text,
+ rawMsg.sender,
+ senderPrefixes(rawMsg.sender, bufferInfo),
+ realName(rawMsg.sender, rawMsg.networkId),
+ avatarUrl(rawMsg.sender, rawMsg.networkId),
+ rawMsg.flags);
+ if (Core::storeMessage(msg))
+ emit displayMsg(msg);
+ }
+ else {
+ QHash<NetworkId, QHash<QString, BufferInfo>> bufferInfoCache;
+ MessageList messages;
+ QList<RawMessage> redirectedMessages; // list of Messages which don't enforce a buffer creation
+ BufferInfo bufferInfo;
+ for (int i = 0; i < _messageQueue.count(); i++) {
+ const RawMessage& rawMsg = _messageQueue.at(i);
+ if (bufferInfoCache.contains(rawMsg.networkId) && bufferInfoCache[rawMsg.networkId].contains(rawMsg.target)) {
+ bufferInfo = bufferInfoCache[rawMsg.networkId][rawMsg.target];
+ }
+ else {
+ bool createBuffer = !(rawMsg.flags & Message::Redirected);
+ bufferInfo = Core::bufferInfo(user(), rawMsg.networkId, rawMsg.bufferType, rawMsg.target, createBuffer);
+ if (!bufferInfo.isValid()) {
+ Q_ASSERT(!createBuffer);
+ redirectedMessages << rawMsg;
+ continue;
+ }
+ bufferInfoCache[rawMsg.networkId][rawMsg.target] = bufferInfo;
+ }
+ Message msg(bufferInfo,
+ rawMsg.type,
+ rawMsg.text,
+ rawMsg.sender,
+ senderPrefixes(rawMsg.sender, bufferInfo),
+ realName(rawMsg.sender, rawMsg.networkId),
+ avatarUrl(rawMsg.sender, rawMsg.networkId),
+ rawMsg.flags);
+ messages << msg;
+ }
+
+ // recheck if there exists a buffer to store a redirected message in
+ for (int i = 0; i < redirectedMessages.count(); i++) {
+ const RawMessage& rawMsg = redirectedMessages.at(i);
+ if (bufferInfoCache.contains(rawMsg.networkId) && bufferInfoCache[rawMsg.networkId].contains(rawMsg.target)) {
+ bufferInfo = bufferInfoCache[rawMsg.networkId][rawMsg.target];
+ }
+ else {
+ // no luck -> we store them in the StatusBuffer
+ bufferInfo = Core::bufferInfo(user(), rawMsg.networkId, BufferInfo::StatusBuffer, "");
+ // add the StatusBuffer to the Cache in case there are more Messages for the original target
+ bufferInfoCache[rawMsg.networkId][rawMsg.target] = bufferInfo;
+ }
+ Message msg(bufferInfo,
+ rawMsg.type,
+ rawMsg.text,
+ rawMsg.sender,
+ senderPrefixes(rawMsg.sender, bufferInfo),
+ realName(rawMsg.sender, rawMsg.networkId),
+ avatarUrl(rawMsg.sender, rawMsg.networkId),
+ rawMsg.flags);
+ messages << msg;
+ }
+
+ if (Core::storeMessages(messages)) {
+ // FIXME: extend protocol to a displayMessages(MessageList)
+ for (int i = 0; i < messages.count(); i++) {
+ emit displayMsg(messages[i]);
+ }
+ }
+ }
+ _processMessages = false;
+ _messageQueue.clear();
+}
+
+QString CoreSession::senderPrefixes(const QString& sender, const BufferInfo& bufferInfo) const
+{
+ CoreNetwork* currentNetwork = network(bufferInfo.networkId());
+ if (!currentNetwork) {
+ return {};
+ }
+
+ if (bufferInfo.type() != BufferInfo::ChannelBuffer) {
+ return {};
+ }
+
+ IrcChannel* currentChannel = currentNetwork->ircChannel(bufferInfo.bufferName());
+ if (!currentChannel) {
+ return {};
+ }
+
+ const QString modes = currentChannel->userModes(nickFromMask(sender).toLower());
+ return currentNetwork->modesToPrefixes(modes);
+}
+
+QString CoreSession::realName(const QString& sender, NetworkId networkId) const
+{
+ CoreNetwork* currentNetwork = network(networkId);
+ if (!currentNetwork) {
+ return {};
+ }
+
+ IrcUser* currentUser = currentNetwork->ircUser(nickFromMask(sender));
+ if (!currentUser) {
+ return {};
+ }
+
+ return currentUser->realName();
+}
+
+QString CoreSession::avatarUrl(const QString& sender, NetworkId networkId) const
+{
+ Q_UNUSED(sender);
+ Q_UNUSED(networkId);
+ // Currently we do not have a way to retrieve this value yet.
+ //
+ // This likely will require implementing IRCv3's METADATA spec.
+ // See https://ircv3.net/irc/
+ // And https://blog.irccloud.com/avatars/
+ return "";
+}
+
+Protocol::SessionState CoreSession::sessionState() const
+{
+ QVariantList bufferInfos;
+ QVariantList networkIds;
+ QVariantList identities;
+
+ foreach (const BufferInfo& id, buffers())
+ bufferInfos << QVariant::fromValue(id);
+ foreach (const NetworkId& id, _networks.keys())
+ networkIds << QVariant::fromValue(id);
+ foreach (const Identity* i, _identities.values())
+ identities << QVariant::fromValue(*i);
+
+ return Protocol::SessionState(identities, bufferInfos, networkIds);
+}
+
+void CoreSession::initScriptEngine()
+{
+ signalProxy()->attachSlot(SIGNAL(scriptRequest(QString)), this, &CoreSession::scriptRequest);
+ signalProxy()->attachSignal(this, &CoreSession::scriptResult);
+
+ // FIXME
+ // QScriptValue storage_ = scriptEngine->newQObject(storage);
+ // scriptEngine->globalObject().setProperty("storage", storage_);
+}
+
+void CoreSession::scriptRequest(QString script)
+{
+ emit scriptResult(scriptEngine->evaluate(script).toString());
+}
+
+/*** Identity Handling ***/
+void CoreSession::createIdentity(const Identity& identity, const QVariantMap& additional)
+{
+#ifndef HAVE_SSL
+ Q_UNUSED(additional)
+#endif
+
+ CoreIdentity coreIdentity(identity);
+#ifdef HAVE_SSL
+ if (additional.contains("KeyPem"))
+ coreIdentity.setSslKey(additional["KeyPem"].toByteArray());
+ if (additional.contains("CertPem"))
+ coreIdentity.setSslCert(additional["CertPem"].toByteArray());
+#endif
+ qDebug() << Q_FUNC_INFO;
+ IdentityId id = Core::createIdentity(user(), coreIdentity);
+ if (!id.isValid())
+ return;
+ else
+ createIdentity(coreIdentity);
+}
+
+const QString CoreSession::strictCompliantIdent(const CoreIdentity* identity)
+{
+ if (_strictIdentEnabled) {
+ // Strict mode enabled: only allow the user's Quassel username as an ident
+ return Core::instance()->strictSysIdent(_user);
+ }
+ else {
+ // Strict mode disabled: allow any identity specified
+ return identity->ident();
+ }
+}
+
+void CoreSession::createIdentity(const CoreIdentity& identity)
+{
+ auto* coreIdentity = new CoreIdentity(identity, this);
+ _identities[identity.id()] = coreIdentity;
+ // CoreIdentity has its own synchronize method since its "private" sslManager needs to be synced as well
+ coreIdentity->synchronize(signalProxy());
+ connect(coreIdentity, &SyncableObject::updated, this, &CoreSession::updateIdentityBySender);
+ emit identityCreated(*coreIdentity);
+}
+
+void CoreSession::updateIdentityBySender()
+{
+ auto* identity = qobject_cast<CoreIdentity*>(sender());
+ if (!identity)
+ return;
+ Core::updateIdentity(user(), *identity);
+}