X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcore%2Fcoresession.cpp;h=d258df7f03cc7f63329bae6dba7d384e00203a10;hp=112aa8564d8775feb96405bfa15693379d1a0b72;hb=6eefdfc697067d184a589fc8a231b16316c09106;hpb=695758015a80eb8c158a9ac4c0f1c0b547e70df3

diff --git a/src/core/coresession.cpp b/src/core/coresession.cpp
index 112aa856..d258df7f 100644
--- a/src/core/coresession.cpp
+++ b/src/core/coresession.cpp
@@ -1,5 +1,5 @@
 /***************************************************************************
- *   Copyright (C) 2005-2015 by the Quassel Project                        *
+ *   Copyright (C) 2005-2018 by the Quassel Project                        *
  *   devel@quassel-irc.org                                                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
@@ -27,9 +27,11 @@
 #include "corebuffersyncer.h"
 #include "corebacklogmanager.h"
 #include "corebufferviewmanager.h"
+#include "coredccconfig.h"
 #include "coreeventmanager.h"
 #include "coreidentity.h"
 #include "coreignorelistmanager.h"
+#include "coreinfo.h"
 #include "coreirclisthelper.h"
 #include "corenetwork.h"
 #include "corenetworkconfig.h"
@@ -42,7 +44,7 @@
 #include "ircchannel.h"
 #include "ircparser.h"
 #include "ircuser.h"
-#include "logger.h"
+#include "logmessage.h"
 #include "messageevent.h"
 #include "remotepeer.h"
 #include "storage.h"
@@ -56,17 +58,19 @@ public:
 };
 
 
-CoreSession::CoreSession(UserId uid, bool restoreState, QObject *parent)
+CoreSession::CoreSession(UserId uid, bool restoreState, bool strictIdentEnabled, QObject *parent)
     : QObject(parent),
     _user(uid),
+    _strictIdentEnabled(strictIdentEnabled),
     _signalProxy(new SignalProxy(SignalProxy::Server, this)),
     _aliasManager(this),
     _bufferSyncer(new CoreBufferSyncer(this)),
     _backlogManager(new CoreBacklogManager(this)),
     _bufferViewManager(new CoreBufferViewManager(_signalProxy, this)),
+    _dccConfig(new CoreDccConfig(this)),
     _ircListHelper(new CoreIrcListHelper(this)),
     _networkConfig(new CoreNetworkConfig("GlobalNetworkConfig", this)),
-    _coreInfo(this),
+    _coreInfo(new CoreInfo(this)),
     _transferManager(new CoreTransferManager(this)),
     _eventManager(new CoreEventManager(this)),
     _eventStringifier(new EventStringifier(this)),
@@ -75,16 +79,17 @@ CoreSession::CoreSession(UserId uid, bool restoreState, QObject *parent)
     _ircParser(new IrcParser(this)),
     scriptEngine(new QScriptEngine(this)),
     _processMessages(false),
-    _ignoreListManager(this)
+    _ignoreListManager(this),
+    _highlightRuleManager(this)
 {
     SignalProxy *p = signalProxy();
     p->setHeartBeatInterval(30);
     p->setMaxHeartBeatCount(60); // 30 mins until we throw a dead socket out
 
-    connect(p, SIGNAL(peerRemoved(Peer*)), SLOT(removeClient(Peer*)));
+    connect(p, &SignalProxy::peerRemoved, this, &CoreSession::removeClient);
 
-    connect(p, SIGNAL(connected()), SLOT(clientsConnected()));
-    connect(p, SIGNAL(disconnected()), SLOT(clientsDisconnected()));
+    connect(p, &SignalProxy::connected, this, &CoreSession::clientsConnected);
+    connect(p, &SignalProxy::disconnected, this, &CoreSession::clientsDisconnected);
 
     p->attachSlot(SIGNAL(sendInput(BufferInfo, QString)), this, SLOT(msgFromClient(BufferInfo, QString)));
     p->attachSignal(this, SIGNAL(displayMsg(Message)));
@@ -100,6 +105,19 @@ CoreSession::CoreSession(UserId uid, bool restoreState, QObject *parent)
     p->attachSlot(SIGNAL(createNetwork(const NetworkInfo &, const QStringList &)), this, SLOT(createNetwork(const NetworkInfo &, const QStringList &)));
     p->attachSlot(SIGNAL(removeNetwork(NetworkId)), this, SLOT(removeNetwork(NetworkId)));
 
+    p->attachSlot(SIGNAL(changePassword(PeerPtr,QString,QString,QString)), this, SLOT(changePassword(PeerPtr,QString,QString,QString)));
+    p->attachSignal(this, SIGNAL(passwordChanged(PeerPtr,bool)));
+
+    p->attachSlot(SIGNAL(kickClient(int)), this, SLOT(kickClient(int)));
+    p->attachSignal(this, SIGNAL(disconnectFromCore()));
+
+    QVariantMap data;
+    data["quasselVersion"] = Quassel::buildInfo().fancyVersionString;
+    data["quasselBuildDate"] = Quassel::buildInfo().commitDate; // "BuildDate" for compatibility
+    data["startTime"] = Core::instance()->startTime();
+    data["sessionConnectedClients"] = 0;
+    _coreInfo->setCoreData(data);
+
     loadSettings();
     initScriptEngine();
 
@@ -113,15 +131,20 @@ CoreSession::CoreSession(UserId uid, bool restoreState, QObject *parent)
     eventManager()->registerObject(ctcpParser(), EventManager::LowPriority, "send");
 
     // periodically save our session state
-    connect(&(Core::instance()->syncTimer()), SIGNAL(timeout()), this, SLOT(saveSessionState()));
+    connect(Core::instance()->syncTimer(), &QTimer::timeout, this, &CoreSession::saveSessionState);
 
     p->synchronize(_bufferSyncer);
     p->synchronize(&aliasManager());
     p->synchronize(_backlogManager);
+    p->synchronize(dccConfig());
     p->synchronize(ircListHelper());
     p->synchronize(networkConfig());
-    p->synchronize(&_coreInfo);
+    p->synchronize(_coreInfo);
     p->synchronize(&_ignoreListManager);
+    p->synchronize(&_highlightRuleManager);
+    // Listen to network removed events
+    connect(this, &CoreSession::networkRemoved,
+        &_highlightRuleManager, &HighlightRuleManager::networkRemoved);
     p->synchronize(transferManager());
     // Restore session state
     if (restoreState)
@@ -131,11 +154,33 @@ CoreSession::CoreSession(UserId uid, bool restoreState, QObject *parent)
 }
 
 
-CoreSession::~CoreSession()
+void CoreSession::shutdown()
 {
     saveSessionState();
-    foreach(CoreNetwork *net, _networks.values()) {
-        delete net;
+
+    // Request disconnect from all connected networks in parallel, and wait until every network
+    // has emitted the disconnected() signal before deleting the session itself
+    for (CoreNetwork *net : _networks.values()) {
+        if (net->socketState() != QAbstractSocket::UnconnectedState) {
+            _networksPendingDisconnect.insert(net->networkId());
+            connect(net, &CoreNetwork::disconnected, this, &CoreSession::onNetworkDisconnected);
+            net->shutdown();
+        }
+    }
+
+    if (_networksPendingDisconnect.isEmpty()) {
+        // Nothing to do, suicide so the core can shut down
+        deleteLater();
+    }
+}
+
+
+void CoreSession::onNetworkDisconnected(NetworkId networkId)
+{
+    _networksPendingDisconnect.remove(networkId);
+    if (_networksPendingDisconnect.isEmpty()) {
+        // We're done, suicide so the core can shut down
+        deleteLater();
     }
 }
 
@@ -143,14 +188,14 @@ CoreSession::~CoreSession()
 CoreNetwork *CoreSession::network(NetworkId id) const
 {
     if (_networks.contains(id)) return _networks[id];
-    return 0;
+    return nullptr;
 }
 
 
 CoreIdentity *CoreSession::identity(IdentityId id) const
 {
     if (_identities.contains(id)) return _identities[id];
-    return 0;
+    return nullptr;
 }
 
 
@@ -172,7 +217,7 @@ void CoreSession::loadSettings()
                 networkIter = networkInfos.erase(networkIter);
             }
             else {
-                networkIter++;
+                ++networkIter;
             }
         }
         s.removeIdentity(id);
@@ -200,7 +245,7 @@ void CoreSession::saveSessionState() const
 void CoreSession::restoreSessionState()
 {
     QList<NetworkId> nets = Core::connectedNetworks(user());
-    CoreNetwork *net = 0;
+    CoreNetwork *net = nullptr;
     foreach(NetworkId id, nets) {
         net = network(id);
         Q_ASSERT(net);
@@ -211,23 +256,29 @@ void CoreSession::restoreSessionState()
 
 void CoreSession::addClient(RemotePeer *peer)
 {
+    signalProxy()->setTargetPeer(peer);
+
     peer->dispatch(sessionState());
     signalProxy()->addPeer(peer);
+    _coreInfo->setConnectedClientData(signalProxy()->peerCount(), signalProxy()->peerData());
+
+    signalProxy()->setTargetPeer(nullptr);
 }
 
 
 void CoreSession::addClient(InternalPeer *peer)
 {
     signalProxy()->addPeer(peer);
-    emit sessionState(sessionState());
+    emit sessionStateReceived(sessionState());
 }
 
 
 void CoreSession::removeClient(Peer *peer)
 {
-    RemotePeer *p = qobject_cast<RemotePeer *>(peer);
+    auto *p = qobject_cast<RemotePeer *>(peer);
     if (p)
         quInfo() << qPrintable(tr("Client")) << p->description() << qPrintable(tr("disconnected (UserId: %1).").arg(user().toInt()));
+    _coreInfo->setConnectedClientData(signalProxy()->peerCount(), signalProxy()->peerData());
 }
 
 
@@ -237,6 +288,17 @@ QHash<QString, QString> CoreSession::persistentChannels(NetworkId id) const
 }
 
 
+QHash<QString, QByteArray> CoreSession::bufferCiphers(NetworkId id) const
+{
+    return Core::bufferCiphers(user(), id);
+}
+
+void CoreSession::setBufferCipher(NetworkId id, const QString &bufferName, const QByteArray &cipher) const
+{
+    Core::setBufferCipher(user(), id, bufferName, cipher);
+}
+
+
 // FIXME switch to BufferId
 void CoreSession::msgFromClient(BufferInfo bufinfo, QString msg)
 {
@@ -268,6 +330,10 @@ void CoreSession::recvMessageFromServer(NetworkId networkId, Message::Type type,
     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;
@@ -278,7 +344,7 @@ void CoreSession::recvMessageFromServer(NetworkId networkId, Message::Type type,
 
 void CoreSession::recvStatusMsgFromServer(QString msg)
 {
-    CoreNetwork *net = qobject_cast<CoreNetwork *>(sender());
+    auto *net = qobject_cast<CoreNetwork *>(sender());
     Q_ASSERT(net);
     emit displayStatusMsg(net->networkName(), msg);
 }
@@ -320,7 +386,9 @@ void CoreSession::processMessages()
             Q_ASSERT(!createBuffer);
             bufferInfo = Core::bufferInfo(user(), rawMsg.networkId, BufferInfo::StatusBuffer, "");
         }
-        Message msg(bufferInfo, rawMsg.type, rawMsg.text, rawMsg.sender, rawMsg.flags);
+        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);
     }
@@ -344,7 +412,9 @@ void CoreSession::processMessages()
                 }
                 bufferInfoCache[rawMsg.networkId][rawMsg.target] = bufferInfo;
             }
-            Message msg(bufferInfo, rawMsg.type, rawMsg.text, rawMsg.sender, rawMsg.flags);
+            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;
         }
 
@@ -360,7 +430,9 @@ void CoreSession::processMessages()
                 // 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, rawMsg.flags);
+            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;
         }
 
@@ -375,6 +447,52 @@ void CoreSession::processMessages()
     _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
 {
@@ -432,21 +550,30 @@ void CoreSession::createIdentity(const Identity &identity, const QVariantMap &ad
         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)
 {
-    CoreIdentity *coreIdentity = new CoreIdentity(identity, this);
+    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, SIGNAL(updated()), this, SLOT(updateIdentityBySender()));
+    connect(coreIdentity, &SyncableObject::updated, this, &CoreSession::updateIdentityBySender);
     emit identityCreated(*coreIdentity);
 }
 
 
 void CoreSession::updateIdentityBySender()
 {
-    CoreIdentity *identity = qobject_cast<CoreIdentity *>(sender());
+    auto *identity = qobject_cast<CoreIdentity *>(sender());
     if (!identity)
         return;
     Core::updateIdentity(user(), *identity);
@@ -482,7 +609,7 @@ void CoreSession::createNetwork(const NetworkInfo &info_, const QStringList &per
     id = info.networkId.toInt();
     if (!_networks.contains(id)) {
         // create persistent chans
-        QRegExp rx("\\s*(\\S+)(?:\\s*(\\S+))?\\s*");
+        QRegExp rx(R"(\s*(\S+)(?:\s*(\S+))?\s*)");
         foreach(QString channel, persistentChans) {
             if (!rx.exactMatch(channel)) {
                 qWarning() << QString("Invalid persistent channel declaration: %1").arg(channel);
@@ -495,10 +622,9 @@ void CoreSession::createNetwork(const NetworkInfo &info_, const QStringList &per
         }
 
         CoreNetwork *net = new CoreNetwork(id, this);
-        connect(net, SIGNAL(displayMsg(NetworkId, Message::Type, BufferInfo::Type, const QString &, const QString &, const QString &, Message::Flags)),
-            SLOT(recvMessageFromServer(NetworkId, Message::Type, BufferInfo::Type, const QString &, const QString &, const QString &, Message::Flags)));
-        connect(net, SIGNAL(displayStatusMsg(QString)), SLOT(recvStatusMsgFromServer(QString)));
-        connect(net, SIGNAL(disconnected(NetworkId)), SIGNAL(networkDisconnected(NetworkId)));
+        connect(net, &CoreNetwork::displayMsg, this, &CoreSession::recvMessageFromServer);
+        connect(net, &CoreNetwork::displayStatusMsg, this, &CoreSession::recvStatusMsgFromServer);
+        connect(net, &CoreNetwork::disconnected, this, &CoreSession::networkDisconnected);
 
         net->setNetworkInfo(info);
         net->setProxy(signalProxy());
@@ -522,9 +648,9 @@ void CoreSession::removeNetwork(NetworkId id)
 
     if (net->connectionState() != Network::Disconnected) {
         // make sure we no longer receive data from the tcp buffer
-        disconnect(net, SIGNAL(displayMsg(NetworkId, Message::Type, BufferInfo::Type, const QString &, const QString &, const QString &, Message::Flags)), this, 0);
-        disconnect(net, SIGNAL(displayStatusMsg(QString)), this, 0);
-        connect(net, SIGNAL(disconnected(NetworkId)), this, SLOT(destroyNetwork(NetworkId)));
+        disconnect(net, &CoreNetwork::displayMsg, this, nullptr);
+        disconnect(net, &CoreNetwork::displayStatusMsg, this, nullptr);
+        connect(net, &CoreNetwork::disconnected, this, &CoreSession::destroyNetwork);
         net->disconnectFromIrc();
     }
     else {
@@ -545,7 +671,7 @@ void CoreSession::destroyNetwork(NetworkId id)
                 messageIter = _messageQueue.erase(messageIter);
             }
             else {
-                messageIter++;
+                ++messageIter;
             }
         }
         // remove buffers from syncer
@@ -570,12 +696,12 @@ void CoreSession::renameBuffer(const NetworkId &networkId, const QString &newNam
 void CoreSession::clientsConnected()
 {
     QHash<NetworkId, CoreNetwork *>::iterator netIter = _networks.begin();
-    Identity *identity = 0;
-    CoreNetwork *net = 0;
-    IrcUser *me = 0;
+    Identity *identity = nullptr;
+    CoreNetwork *net = nullptr;
+    IrcUser *me = nullptr;
     while (netIter != _networks.end()) {
         net = *netIter;
-        netIter++;
+        ++netIter;
 
         if (!net->isConnected())
             continue;
@@ -596,13 +722,13 @@ void CoreSession::clientsConnected()
 void CoreSession::clientsDisconnected()
 {
     QHash<NetworkId, CoreNetwork *>::iterator netIter = _networks.begin();
-    Identity *identity = 0;
-    CoreNetwork *net = 0;
-    IrcUser *me = 0;
+    Identity *identity = nullptr;
+    CoreNetwork *net = nullptr;
+    IrcUser *me = nullptr;
     QString awayReason;
     while (netIter != _networks.end()) {
         net = *netIter;
-        netIter++;
+        ++netIter;
 
         if (!net->isConnected())
             continue;
@@ -618,23 +744,48 @@ void CoreSession::clientsDisconnected()
             if (!identity->detachAwayReason().isEmpty())
                 awayReason = identity->detachAwayReason();
             net->setAutoAwayActive(true);
+            // Allow handleAway() to format the current date/time in the string.
             net->userInputHandler()->handleAway(BufferInfo(), awayReason);
         }
     }
 }
 
 
-void CoreSession::globalAway(const QString &msg)
+void CoreSession::globalAway(const QString &msg, const bool skipFormatting)
 {
     QHash<NetworkId, CoreNetwork *>::iterator netIter = _networks.begin();
-    CoreNetwork *net = 0;
+    CoreNetwork *net = nullptr;
     while (netIter != _networks.end()) {
         net = *netIter;
-        netIter++;
+        ++netIter;
 
         if (!net->isConnected())
             continue;
 
-        net->userInputHandler()->issueAway(msg, false /* no force away */);
+        net->userInputHandler()->issueAway(msg, false /* no force away */, skipFormatting);
+    }
+}
+
+void CoreSession::changePassword(PeerPtr peer, const QString &userName, const QString &oldPassword, const QString &newPassword) {
+    Q_UNUSED(peer);
+
+    bool success = false;
+    UserId uid = Core::validateUser(userName, oldPassword);
+    if (uid.isValid() && uid == user())
+        success = Core::changeUserPassword(uid, newPassword);
+
+    signalProxy()->restrictTargetPeers(signalProxy()->sourcePeer(), [&]{
+        emit passwordChanged(nullptr, success);
+    });
+}
+
+void CoreSession::kickClient(int peerId) {
+    auto peer = signalProxy()->peerById(peerId);
+    if (peer == nullptr) {
+        qWarning() << "Invalid peer Id: " << peerId;
+        return;
     }
+    signalProxy()->restrictTargetPeers(peer, [&]{
+        emit disconnectFromCore();
+    });
 }