+void CoreUserInputHandler::handleJoin(const BufferInfo& bufferInfo, const QString& msg)
+{
+ Q_UNUSED(bufferInfo);
+
+ // trim spaces before chans or keys
+ QString sane_msg = msg;
+ sane_msg.replace(QRegExp(", +"), ",");
+ QStringList params = sane_msg.trimmed().split(" ");
+
+ QStringList chans = params[0].split(",", QString::SkipEmptyParts);
+ QStringList keys;
+ if (params.count() > 1)
+ keys = params[1].split(",");
+
+ int i;
+ for (i = 0; i < chans.count(); i++) {
+ if (!network()->isChannelName(chans[i]))
+ chans[i].prepend('#');
+
+ if (i < keys.count()) {
+ network()->addChannelKey(chans[i], keys[i]);
+ }
+ else {
+ network()->removeChannelKey(chans[i]);
+ }
+ }
+
+ static const char* cmd = "JOIN";
+ i = 0;
+ QStringList joinChans, joinKeys;
+ int slicesize = chans.count();
+ QList<QByteArray> encodedParams;
+
+ // go through all to-be-joined channels and (re)build the join list
+ while (i < chans.count()) {
+ joinChans.append(chans.at(i));
+ if (i < keys.count())
+ joinKeys.append(keys.at(i));
+
+ // if the channel list we built so far either contains all requested channels or exceeds
+ // the desired amount of channels in this slice, try to send what we have so far
+ if (++i == chans.count() || joinChans.count() >= slicesize) {
+ params.clear();
+ params.append(joinChans.join(","));
+ params.append(joinKeys.join(","));
+ encodedParams = serverEncode(params);
+ // check if it fits in one command
+ if (lastParamOverrun(cmd, encodedParams) == 0) {
+ emit putCmd(cmd, encodedParams);
+ }
+ else if (slicesize > 1) {
+ // back to start of slice, try again with half the amount of channels
+ i -= slicesize;
+ slicesize /= 2;
+ }
+ joinChans.clear();
+ joinKeys.clear();
+ }
+ }
+}
+
+void CoreUserInputHandler::handleKeyx(const BufferInfo& bufferInfo, const QString& msg)
+{
+ QString bufname = bufferInfo.bufferName().isNull() ? "" : bufferInfo.bufferName();
+#ifdef HAVE_QCA2
+ if (!bufferInfo.isValid())
+ return;
+
+ if (!Cipher::neededFeaturesAvailable()) {
+ emit displayMsg(NetworkInternalMessage(
+ Message::Error,
+ typeByTarget(bufname),
+ bufname,
+ tr("Error: QCA provider plugin not found. It is usually provided by the qca-ossl plugin.")
+ ));
+ return;
+ }
+
+ QStringList parms = msg.split(' ', QString::SkipEmptyParts);
+
+ if (parms.count() == 0 && !bufferInfo.bufferName().isEmpty() && bufferInfo.acceptsRegularMessages())
+ parms.prepend(bufferInfo.bufferName());
+ else if (parms.count() != 1) {
+ emit displayMsg(NetworkInternalMessage(
+ Message::Info,
+ typeByTarget(bufname),
+ bufname,
+ tr("[usage] /keyx [<nick>] Initiates a DH1080 key exchange with the target.")
+ ));
+ return;
+ }
+
+ QString target = parms.at(0);
+
+ if (network()->isChannelName(target)) {
+ emit displayMsg(NetworkInternalMessage(
+ Message::Info,
+ typeByTarget(bufname),
+ bufname,
+ tr("It is only possible to exchange keys in a query buffer.")
+ ));
+ return;
+ }
+
+ Cipher* cipher = network()->cipher(target);
+ if (!cipher) // happens when there is no CoreIrcChannel for the target
+ return;
+
+ QByteArray pubKey = cipher->initKeyExchange();
+ if (pubKey.isEmpty())
+ emit displayMsg(NetworkInternalMessage(
+ Message::Error,
+ typeByTarget(bufname),
+ bufname,
+ tr("Failed to initiate key exchange with %1.").arg(target)
+ ));
+ else {
+ QList<QByteArray> params;
+ params << serverEncode(target) << serverEncode("DH1080_INIT ") + pubKey;
+ emit putCmd("NOTICE", params);
+ emit displayMsg(NetworkInternalMessage(
+ Message::Info,
+ typeByTarget(bufname),
+ bufname,
+ tr("Initiated key exchange with %1.").arg(target)
+ ));
+ }
+#else
+ Q_UNUSED(msg)
+ emit displayMsg(NetworkInternalMessage(
+ Message::Error,
+ typeByTarget(bufname),
+ bufname,
+ tr("Error: Setting an encryption key requires Quassel to have been built "
+ "with support for the Qt Cryptographic Architecture (QCA) library. "
+ "Contact your distributor about a Quassel package with QCA "
+ "support, or rebuild Quassel with QCA present.")
+ ));
+#endif
+}
+
+void CoreUserInputHandler::handleKick(const BufferInfo& bufferInfo, const QString& msg)
+{
+ QString nick = msg.section(' ', 0, 0, QString::SectionSkipEmpty);
+ QString reason = msg.section(' ', 1, -1, QString::SectionSkipEmpty).trimmed();
+ if (reason.isEmpty())
+ reason = network()->identityPtr()->kickReason();
+
+ QList<QByteArray> params;
+ params << serverEncode(bufferInfo.bufferName()) << serverEncode(nick) << channelEncode(bufferInfo.bufferName(), reason);
+ emit putCmd("KICK", params);
+}
+
+void CoreUserInputHandler::handleKill(const BufferInfo& bufferInfo, const QString& msg)
+{
+ Q_UNUSED(bufferInfo)
+ QString nick = msg.section(' ', 0, 0, QString::SectionSkipEmpty);
+ QString pass = msg.section(' ', 1, -1, QString::SectionSkipEmpty);
+ QList<QByteArray> params;
+ params << serverEncode(nick) << serverEncode(pass);
+ emit putCmd("KILL", params);
+}
+
+void CoreUserInputHandler::handleList(const BufferInfo& bufferInfo, const QString& msg)
+{
+ Q_UNUSED(bufferInfo)
+ emit putCmd("LIST", serverEncode(msg.split(' ', QString::SkipEmptyParts)));
+}
+
+void CoreUserInputHandler::handleMe(const BufferInfo& bufferInfo, const QString& msg)
+{
+ if (bufferInfo.bufferName().isEmpty() || !bufferInfo.acceptsRegularMessages())
+ return; // server buffer
+ // FIXME make this a proper event
+
+ // Split apart messages at line feeds. The IRC protocol uses those to separate commands, so
+ // they need to be split into multiple messages.
+ QStringList messages = msg.split(QChar::LineFeed);
+
+ for (const auto& message : messages) {
+ // Handle each separated message independently
+ coreNetwork()->coreSession()->ctcpParser()->query(coreNetwork(), bufferInfo.bufferName(), "ACTION", message);
+ if (!network()->capEnabled(IrcCap::ECHO_MESSAGE)) {
+ emit displayMsg(NetworkInternalMessage(
+ Message::Action,
+ bufferInfo.type(),
+ bufferInfo.bufferName(),
+ message,
+ network()->myNick(),
+ Message::Self
+ ));
+ }
+ }