#include "coreirclisthelper.h"
#include "corenetwork.h"
#include "coresession.h"
+#include "ctcpevent.h"
#include "ircevent.h"
#include "ircuser.h"
#include "messageevent.h"
#include "netsplit.h"
+#include "quassel.h"
CoreSessionEventProcessor::CoreSessionEventProcessor(CoreSession *session)
- : QObject(session),
+ : BasicHandler("handleCtcp", session),
_coreSession(session)
{
connect(coreSession(), SIGNAL(networkDisconnected(NetworkId)), this, SLOT(destroyNetsplits(NetworkId)));
QHash<QString, Netsplit *> splits = _netsplits.take(net);
qDeleteAll(splits);
}
+
+/*******************************/
+/******** CTCP HANDLING ********/
+/*******************************/
+
+void CoreSessionEventProcessor::processCtcpEvent(CtcpEvent *e) {
+ if(e->testFlag(EventManager::Self))
+ return; // ignore ctcp events generated by user input
+
+ if(e->type() != EventManager::CtcpEvent || e->ctcpType() != CtcpEvent::Query)
+ return;
+
+ handle(e->ctcpCmd(), Q_ARG(CtcpEvent *, e));
+}
+
+void CoreSessionEventProcessor::defaultHandler(const QString &ctcpCmd, CtcpEvent *e) {
+ // This handler is only there to avoid warnings for unknown CTCPs
+ Q_UNUSED(e);
+ Q_UNUSED(ctcpCmd);
+}
+
+void CoreSessionEventProcessor::handleCtcpAction(CtcpEvent *e) {
+ // This handler is only there to feed CLIENTINFO
+ Q_UNUSED(e);
+}
+
+void CoreSessionEventProcessor::handleCtcpClientinfo(CtcpEvent *e) {
+ QStringList supportedHandlers;
+ foreach(QString handler, providesHandlers())
+ supportedHandlers << handler.toUpper();
+ qSort(supportedHandlers);
+ e->setReply(supportedHandlers.join(" "));
+}
+
+void CoreSessionEventProcessor::handleCtcpPing(CtcpEvent *e) {
+ e->setReply(e->param());
+}
+
+void CoreSessionEventProcessor::handleCtcpTime(CtcpEvent *e) {
+ e->setReply(QDateTime::currentDateTime().toString());
+}
+
+void CoreSessionEventProcessor::handleCtcpVersion(CtcpEvent *e) {
+ e->setReply(QString("Quassel IRC %1 (built on %2) -- http://www.quassel-irc.org")
+ .arg(Quassel::buildInfo().plainVersionString).arg(Quassel::buildInfo().buildDate));
+}
#ifndef CORESESSIONEVENTPROCESSOR_H
#define CORESESSIONEVENTPROCESSOR_H
+#include "basichandler.h"
#include "corenetwork.h"
#include "networkevent.h"
class CoreSession;
+class CtcpEvent;
class IrcEvent;
class IrcEventNumeric;
class Netsplit;
-class CoreSessionEventProcessor : public QObject {
+class CoreSessionEventProcessor : public BasicHandler {
Q_OBJECT
public:
// Q_INVOKABLE void processIrcEvent(IrcEvent *event);
+ /* CTCP handlers */
+ Q_INVOKABLE void processCtcpEvent(CtcpEvent *event);
+
+ Q_INVOKABLE void handleCtcpAction(CtcpEvent *event);
+ Q_INVOKABLE void handleCtcpClientinfo(CtcpEvent *event);
+ Q_INVOKABLE void handleCtcpPing(CtcpEvent *event);
+ Q_INVOKABLE void handleCtcpTime(CtcpEvent *event);
+ Q_INVOKABLE void handleCtcpVersion(CtcpEvent *event);
+ Q_INVOKABLE void defaultHandler(const QString &ctcpCmd, CtcpEvent *event);
+
protected:
bool checkParamCount(IrcEvent *event, int minParams);
inline CoreNetwork *coreNetwork(NetworkEvent *e) const { return qobject_cast<CoreNetwork *>(e->network()); }
}
if(!ctcpEvents.isEmpty()) {
_replies.insert(uuid, CtcpReply(coreNetwork(e), nickFromMask(e->prefix())));
- CtcpEvent *flushEvent = new CtcpEvent(uuid);
+ CtcpEvent *flushEvent = new CtcpEvent(EventManager::CtcpEventFlush, e->network(), e->prefix(), e->target(),
+ ctcptype, "INVALID", QString(), e->timestamp(), uuid);
ctcpEvents << flushEvent;
foreach(CtcpEvent *event, ctcpEvents) {
coreSession()->eventManager()->sendEvent(event);
}
} else if(e->type() == EventManager::CtcpEventFlush && _replies.contains(e->uuid())) {
CtcpReply reply = _replies.take(e->uuid());
- packedReply(net, reply.bufferName, reply.replies);
+ if(reply.replies.count())
+ packedReply(net, reply.bufferName, reply.replies);
}
}
#include "eventstringifier.h"
#include "coresession.h"
+#include "ctcpevent.h"
#include "messageevent.h"
-EventStringifier::EventStringifier(CoreSession *parent) : QObject(parent),
+EventStringifier::EventStringifier(CoreSession *parent) : BasicHandler("handleCtcp", parent),
_coreSession(parent),
_whois(false)
{
}
*/
+
+/*******************************/
+/******** CTCP HANDLING ********/
+/*******************************/
+
+void EventStringifier::processCtcpEvent(CtcpEvent *e) {
+ if(e->type() != EventManager::CtcpEvent)
+ return;
+
+ if(e->testFlag(EventManager::Self)) {
+ displayMsg(e, Message::Action, tr("sending CTCP-%1 request to %2").arg(e->ctcpCmd(), e->target()), e->network()->myNick());
+ return;
+ }
+
+ handle(e->ctcpCmd(), Q_ARG(CtcpEvent *, e));
+}
+
+void EventStringifier::defaultHandler(const QString &ctcpCmd, CtcpEvent *e) {
+ Q_UNUSED(ctcpCmd);
+ if(e->ctcpType() == CtcpEvent::Query) {
+ QString unknown;
+ if(e->reply().isNull()) // all known core-side handlers (except for ACTION) set a reply!
+ //: Optional "unknown" in "Received unknown CTCP-FOO request by bar"
+ unknown = tr("unknown") + ' ';
+ displayMsg(e, Message::Server, tr("Received %1CTCP-%2 request by %3").arg(unknown, e->ctcpCmd(), e->prefix()));
+ return;
+ }
+ displayMsg(e, Message::Server, tr("Received CTCP-%1 answer from %2: %3").arg(e->ctcpCmd(), nickFromMask(e->prefix()), e->param()));
+}
+
+void EventStringifier::handleCtcpAction(CtcpEvent *e) {
+ displayMsg(e, Message::Action, e->param(), e->prefix(), e->target());
+}
+
+void EventStringifier::handleCtcpPing(CtcpEvent *e) {
+ if(e->ctcpType() == CtcpEvent::Query)
+ defaultHandler(e->ctcpCmd(), e);
+ else {
+ displayMsg(e, Message::Server, tr("Received CTCP-PING answer from %1 with %2 seconds round trip time")
+ .arg(nickFromMask(e->prefix())).arg(QDateTime::fromTime_t(e->param().toInt()).secsTo(e->timestamp())));
+ }
+}
#ifndef EVENTSTRINGIFIER_H
#define EVENTSTRINGIFIER_H
-#include <QObject>
-
+#include "basichandler.h"
#include "ircevent.h"
#include "message.h"
class CoreSession;
+class CtcpEvent;
class MessageEvent;
//! Generates user-visible MessageEvents from incoming IrcEvents
/* replaces the string-generating parts of the old IrcServerHandler */
-class EventStringifier : public QObject {
+class EventStringifier : public BasicHandler {
Q_OBJECT
public:
// Q_INVOKABLE void processIrcEvent(IrcEvent *event);
+ /* CTCP handlers */
+ Q_INVOKABLE void processCtcpEvent(CtcpEvent *event);
+
+ Q_INVOKABLE void handleCtcpAction(CtcpEvent *event);
+ Q_INVOKABLE void handleCtcpPing(CtcpEvent *event);
+ Q_INVOKABLE void defaultHandler(const QString &cmd, CtcpEvent *event);
+
public slots:
//! Creates and sends a MessageEvent
void displayMsg(NetworkEvent *event,
if(!net->isChannelName(target))
target = nickFromMask(prefix);
}
- events << new IrcEventRawMessage(EventManager::IrcEventRawNotice, net, msg, prefix, target, e->timestamp());
+ events << new IrcEventRawMessage(EventManager::IrcEventRawNotice, net, params[1], prefix, target, e->timestamp());
}
}
break;