/* * Anope IRC Services * * Copyright (C) 2006-2017 Anope Team * * This file is part of Anope. Anope is free software; you can * redistribute it and/or modify it under the terms of the GNU * General Public License as published by the Free Software * Foundation, version 2. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, see see . */ /* Dependencies: anope_protocol.ratbox */ #include "module.h" #include "modules/sasl.h" #include "modules/protocol/hybrid.h" #include "modules/protocol/charybdis.h" #include "modules/chanserv/mode.h" static Anope::string UplinkSID; class ChannelModeLargeBan : public ChannelMode { public: ChannelModeLargeBan(const Anope::string &mname, char modeChar) : ChannelMode(mname, modeChar) { } bool CanSet(User *u) const override { return u && u->HasMode("OPER"); } }; void charybdis::senders::NickIntroduction::Send(User *user) { Anope::string modes = "+" + user->GetModes(); Uplink::Send(Me, "EUID", user->nick, 1, user->timestamp, modes, user->GetIdent(), user->host, 0, user->GetUID(), "*", "*", user->realname); } void charybdis::senders::SASL::Send(const ::SASL::Message& message) { Server *s = Server::Find(message.target.substr(0, 3)); Uplink::Send(Me, "ENCAP", s ? s->GetName() : message.target.substr(0, 3), "SASL", message.source, message.target, message.type, message.data, message.ext.empty() ? "" : message.ext); } void charybdis::senders::SASLMechanisms::Send(const std::vector& mechanisms) { Anope::string mechlist; for (unsigned int i = 0; i < mechanisms.size(); ++i) { mechlist += "," + mechanisms[i]; } Uplink::Send(Me, "ENCAP", "*", "MECHLIST", mechlist.empty() ? "" : mechlist.substr(1)); } void charybdis::senders::SVSHold::Send(const Anope::string& nick, time_t delay) { Uplink::Send(Me, "ENCAP", "*", "NICKDELAY", delay, nick); } void charybdis::senders::SVSHoldDel::Send(const Anope::string& nick) { Uplink::Send(Me, "ENCAP", "*", "NICKDELAY", 0, nick); } void charybdis::senders::SVSLogin::Send(const Anope::string& uid, const Anope::string& acc, const Anope::string& vident, const Anope::string& vhost) { Server *s = Server::Find(uid.substr(0, 3)); Uplink::Send(Me, "ENCAP", s ? s->GetName() : uid.substr(0, 3), "SVSLOGIN", uid, "*", vident.empty() ? "*" : vident, vhost.empty() ? "*" : vhost, acc); } void charybdis::senders::VhostDel::Send(User* u) { IRCD->Send(u, "", u->host); } void charybdis::senders::VhostSet::Send(User* u, const Anope::string& vident, const Anope::string& vhost) { Uplink::Send(Me, "ENCAP", "*", "CHGHOST", u->GetUID(), vhost); } charybdis::Proto::Proto(Module *creator) : ts6::Proto(creator, "Charybdis 3.4+") , ratbox(creator) { DefaultPseudoclientModes = "+oiS"; CanCertFP = true; CanSNLine = true; CanSQLine = true; CanSQLineChannel = true; CanSZLine = true; CanSVSNick = true; CanSVSHold = true; CanSetVHost = true; RequiresID = true; MaxModes = 4; } void charybdis::Proto::Handshake() { Uplink::Send("PASS", Config->Uplinks[Anope::CurrentUplink].password, "TS", 6, Me->GetSID()); /* * Received: CAPAB :BAN CHW CLUSTER ENCAP EOPMOD EUID EX IE KLN * KNOCK MLOCK QS RSFNC SAVE SERVICES TB UNKLN * * BAN - Can do BAN message * CHW - Can do channel wall @# * CLUSTER - Supports umode +l, can send LOCOPS (encap only) * ENCAP - Can do ENCAP message * EOPMOD - Can do channel wall =# (for cmode +z) * EUID - Can do EUID (its similar to UID but includes the ENCAP REALHOST and ENCAP LOGIN information) * EX - Can do channel +e exemptions * GLN - Can set G:Lines * IE - Can do invite exceptions * KLN - Can set K:Lines (encap only) * KNOCK - Supports KNOCK * MLOCK - Supports MLOCK * RSFNC - Forces a nickname change and propagates it (encap only) * SERVICES - Support channel mode +r (only registered users may join) * SAVE - Resolve a nick collision by changing a nickname to the UID. * TB - Supports topic burst * UNKLN - Can do UNKLINE (encap only) * QS - Can handle quit storm removal */ Uplink::Send("CAPAB", "BAN CHW CLUSTER ENCAP EOPMOD EUID EX IE KLN KNOCK MLOCK QS RSFNC SERVICES TB UNKLN"); /* Make myself known to myself in the serverlist */ Uplink::Send("SERVER", Me->GetName(), Me->GetHops() + 1, Me->GetDescription()); /* * Received: SVINFO 6 6 0 :1353235537 * arg[0] = current TS version * arg[1] = minimum required TS version * arg[2] = '0' * arg[3] = server's idea of UTC time */ Uplink::Send("SVINFO", 6, 6, 0, Anope::CurTime); } void charybdis::Encap::Run(MessageSource &source, const std::vector ¶ms) { // In a burst, states that the source user is logged in as the account. if (params[1] == "LOGIN" || params[1] == "SU") { User *u = source.GetUser(); NickServ::Account *nc = NickServ::FindAccount(params[2]); if (!u || !nc) return; u->Login(nc); } // Received: :42XAAAAAE ENCAP * CERTFP :3f122a9cc7811dbad3566bf2cec3009007c0868f else if (params[1] == "CERTFP") { User *u = source.GetUser(); if (!u) return; u->fingerprint = params[2]; EventManager::Get()->Dispatch(&Event::Fingerprint::OnFingerprint, u); } /* * Received: :42X ENCAP * SASL 42XAAAAAH * S PLAIN * Received: :42X ENCAP * SASL 42XAAAAAC * D A * * Part of a SASL authentication exchange. The mode is 'C' to send some data * (base64 encoded), or 'S' to end the exchange (data indicates type of * termination: 'A' for abort, 'F' for authentication failure, 'S' for * authentication success). * * Charybdis only accepts messages from SASL agents; these must have umode +S */ else if (params[1] == "SASL" && sasl && params.size() >= 6) { SASL::Message m; m.source = params[2]; m.target = params[3]; m.type = params[4]; m.data = params[5]; m.ext = params.size() > 6 ? params[6] : ""; sasl->ProcessMessage(m); } } void charybdis::EUID::Run(MessageSource &source, const std::vector ¶ms) { NickServ::Nick *na = NULL; if (params[9] != "*") na = NickServ::FindNick(params[9]); time_t ts = Anope::CurTime; try { ts = convertTo(params[2]); } catch (const ConvertException &) { } User::OnIntroduce(params[0], params[4], (params[8] != "*" ? params[8] : params[5]), params[5], params[6], source.GetServer(), params[10], ts, params[3], params[7], na ? na->GetAccount() : NULL); } // we can't use this function from ratbox because we set a local variable here // SERVER dev.anope.de 1 :charybdis test server void charybdis::ServerMessage::Run(MessageSource &source, const std::vector ¶ms) { // Servers other then our immediate uplink are introduced via SID if (params[1] != "1") return; new Server(source.GetServer() == NULL ? Me : source.GetServer(), params[0], 1, params[2], UplinkSID); IRCD->Send(Me->GetName(), params[0]); } // we can't use this function from ratbox because we set a local variable here void charybdis::Pass::Run(MessageSource &source, const std::vector ¶ms) { // UplinkSID is used in server handler UplinkSID = params[3]; } class ProtoCharybdis : public Module , public EventHook , public EventHook { ServiceReference mlocks; charybdis::Proto ircd_proto; /* Core message handlers */ rfc1459::Away message_away; rfc1459::Capab message_capab; rfc1459::Error message_error; rfc1459::Invite message_invite; rfc1459::Kick message_kick; rfc1459::Kill message_kill; rfc1459::Mode message_mode; rfc1459::MOTD message_motd; rfc1459::Notice message_notice; rfc1459::Part message_part; rfc1459::Ping message_ping; rfc1459::Privmsg message_privmsg; rfc1459::Quit message_quit; rfc1459::SQuit message_squit; rfc1459::Stats message_stats; rfc1459::Time message_time; rfc1459::Topic message_topic; rfc1459::Version message_version; rfc1459::Whois message_whois; /* Our message handlers */ hybrid::BMask message_bmask; charybdis::Encap message_encap; charybdis::EUID message_euid; ratbox::Join message_join; hybrid::Nick message_nick; charybdis::Pass message_pass; hybrid::Pong message_pong; charybdis::ServerMessage message_server; hybrid::SID message_sid; hybrid::SJoin message_sjoin; ratbox::TB message_tb; hybrid::TMode message_tmode; ratbox::UID message_uid; /* Core message senders */ rfc1459::senders::Invite sender_invite; rfc1459::senders::Kick sender_kick; rfc1459::senders::Kill sender_svskill; rfc1459::senders::ModeChannel sender_mode_chan; rfc1459::senders::ModeUser sender_mode_user; rfc1459::senders::NickChange sender_nickchange; rfc1459::senders::Notice sender_notice; rfc1459::senders::Part sender_part; rfc1459::senders::Ping sender_ping; rfc1459::senders::Pong sender_pong; rfc1459::senders::Privmsg sender_privmsg; rfc1459::senders::Quit sender_quit; rfc1459::senders::SQuit sender_squit; hybrid::senders::Akill sender_akill; hybrid::senders::AkillDel sender_akill_del; hybrid::senders::MessageChannel sender_channel; hybrid::senders::GlobalNotice sender_global_notice; hybrid::senders::GlobalPrivmsg sender_global_privmsg; hybrid::senders::Join sender_join; hybrid::senders::MessageServer sender_server; hybrid::senders::SGLine sender_sgline; hybrid::senders::SGLineDel sender_sgline_del; hybrid::senders::SVSHold sender_svshold; hybrid::senders::SVSHoldDel sender_svsholddel; ratbox::senders::Login sender_login; ratbox::senders::Logout sender_logout; ratbox::senders::SQLine sender_sqline; ratbox::senders::SQLineDel sender_sqline_del; ratbox::senders::SVSNick sender_svsnick; ratbox::senders::Topic sender_topic; ratbox::senders::Wallops sender_wallops; charybdis::senders::NickIntroduction sender_nickintroduction; charybdis::senders::SASL sender_sasl; charybdis::senders::SASLMechanisms sender_sasl_mechs; charybdis::senders::SVSLogin sender_svslogin; charybdis::senders::VhostDel sender_vhost_del; charybdis::senders::VhostSet sender_vhost_set; bool use_server_side_mlock; public: ProtoCharybdis(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, PROTOCOL | VENDOR) , EventHook(this) , EventHook(this) , ircd_proto(this) , message_away(this) , message_capab(this) , message_error(this) , message_invite(this) , message_kick(this) , message_kill(this) , message_mode(this) , message_motd(this) , message_notice(this) , message_part(this) , message_ping(this) , message_privmsg(this) , message_quit(this) , message_squit(this) , message_stats(this) , message_time(this) , message_topic(this) , message_version(this) , message_whois(this) , message_bmask(this) , message_encap(this) , message_euid(this) , message_join(this) , message_nick(this) , message_pass(this) , message_pong(this) , message_server(this) , message_sid(this) , message_sjoin(this) , message_tb(this) , message_tmode(this) , message_uid(this) , sender_akill(this) , sender_akill_del(this) , sender_channel(this) , sender_global_notice(this) , sender_global_privmsg(this) , sender_invite(this) , sender_join(this) , sender_kick(this) , sender_svskill(this) , sender_login(this) , sender_logout(this) , sender_mode_chan(this) , sender_mode_user(this) , sender_nickchange(this) , sender_nickintroduction(this) , sender_notice(this) , sender_part(this) , sender_ping(this) , sender_pong(this) , sender_privmsg(this) , sender_quit(this) , sender_server(this) , sender_sasl(this) , sender_sasl_mechs(this) , sender_sgline(this) , sender_sgline_del(this) , sender_sqline(this) , sender_sqline_del(this) , sender_squit(this) , sender_svshold(this) , sender_svsholddel(this) , sender_svslogin(this) , sender_svsnick(this) , sender_topic(this) , sender_vhost_del(this) , sender_vhost_set(this) , sender_wallops(this) { IRCD = &ircd_proto; } ~ProtoCharybdis() { IRCD = nullptr; } void OnReload(Configuration::Conf *conf) override { use_server_side_mlock = conf->GetModule(this)->Get("use_server_side_mlock"); } void OnChannelSync(Channel *c) override { if (!c->ci || !mlocks) return; if (use_server_side_mlock && Servers::Capab.count("MLOCK") > 0) { Anope::string modes = mlocks->GetMLockAsString(c->ci, false).replace_all_cs("+", "").replace_all_cs("-", ""); Uplink::Send(Me, "MLOCK", c->creation_time, c->ci->GetName(), modes); } } EventReturn OnMLock(ChanServ::Channel *ci, ModeLock *lock) override { if (!mlocks) return EVENT_CONTINUE; ChannelMode *cm = ModeManager::FindChannelModeByName(lock->GetName()); if (use_server_side_mlock && cm && ci->c && (cm->type == MODE_REGULAR || cm->type == MODE_PARAM) && Servers::Capab.count("MLOCK") > 0) { Anope::string modes = mlocks->GetMLockAsString(ci, false).replace_all_cs("+", "").replace_all_cs("-", "") + cm->mchar; Uplink::Send(Me, "MLOCK", ci->c->creation_time, ci->GetName(), modes); } return EVENT_CONTINUE; } EventReturn OnUnMLock(ChanServ::Channel *ci, ModeLock *lock) override { if (!mlocks) return EVENT_CONTINUE; ChannelMode *cm = ModeManager::FindChannelModeByName(lock->GetName()); if (use_server_side_mlock && cm && ci->c && (cm->type == MODE_REGULAR || cm->type == MODE_PARAM) && Servers::Capab.count("MLOCK") > 0) { Anope::string modes = mlocks->GetMLockAsString(ci, false).replace_all_cs("+", "").replace_all_cs("-", "").replace_all_cs(cm->mchar, ""); Uplink::Send(Me, "MLOCK", ci->c->creation_time, ci->GetName(), modes); } return EVENT_CONTINUE; } }; template<> void ModuleInfo(ModuleDef *def) { def->Depends("ratbox"); } MODULE_INIT(ProtoCharybdis)