pegasus/anope
1
0
Fork 0
mirror of https://github.com/anope/anope.git synced 2026-06-23 07:06:38 +02:00
Code Activity
Files
847cceaba350444510b37f685d51fdfc584b1fd2
anope/modules/protocol/plexus.cpp
T
Adam 847cceaba3 Create persistent channels on startup, which used to work and got lost somewhere 
Fix some oddities with using persistent channels with no botserv
Send list modes to uplink when bursting
Fix issues with persist + keepmodes
Fix /os modes clear all not clearing all status modes
Fix operwall on ratbox/plexus
Dont apply mlock in SetCorrectModes since that just recursively calls itself unncessarially
Change command logging to show the command name and not the service name
2013-08-25 04:48:43 -04:00

423 lines
15 KiB
C++
Raw Blame History

/* Plexus 3+ IRCD functions
*
* (C) 2003-2013 Anope Team
* Contact us at team@anope.org
*
* Please read COPYING and README for further details.
*
* Based on the original code of Epona by Lara.
* Based on the original code of Services by Andy Church.
*/
#include "module.h"
static Anope::string UplinkSID;
static ServiceReference<IRCDProto> hybrid("IRCDProto", "hybrid");
class PlexusProto : public IRCDProto
{
public:
PlexusProto(Module *creator) : IRCDProto(creator, "hybrid-7.2.3+plexus-3.0.1")
{
DefaultPseudoclientModes = "+oiU";
CanSVSNick = true;
CanSVSJoin = true;
CanSetVHost = true;
CanSetVIdent = true;
CanSNLine = true;
CanSQLine = true;
CanSQLineChannel = true;
CanSVSHold = true;
CanCertFP = true;
RequiresID = true;
MaxModes = 4;
}
void SendGlobalNotice(BotInfo *bi, const Server *dest, const Anope::string &msg) anope_override { hybrid->SendGlobalNotice(bi, dest, msg); }
void SendGlobalPrivmsg(BotInfo *bi, const Server *dest, const Anope::string &msg) anope_override { hybrid->SendGlobalPrivmsg(bi, dest, msg); }
void SendSQLine(User *u, const XLine *x) anope_override { hybrid->SendSQLine(u, x); }
void SendSQLineDel(const XLine *x) anope_override { hybrid->SendSQLineDel(x); }
void SendSGLineDel(const XLine *x) anope_override { hybrid->SendSGLineDel(x); }
void SendSGLine(User *u, const XLine *x) anope_override { hybrid->SendSGLine(u, x); }
void SendAkillDel(const XLine *x) anope_override { hybrid->SendAkillDel(x); }
void SendAkill(User *u, XLine *x) anope_override { hybrid->SendAkill(u, x); }
void SendServer(const Server *server) anope_override { hybrid->SendServer(server); }
void SendChannel(Channel *c) anope_override { hybrid->SendChannel(c); }
void SendSVSHold(const Anope::string &nick, time_t t) anope_override { hybrid->SendSVSHold(nick, t); }
void SendSVSHoldDel(const Anope::string &nick) anope_override { hybrid->SendSVSHoldDel(nick); }
void SendGlobopsInternal(const MessageSource &source, const Anope::string &buf) anope_override
{
UplinkSocket::Message(source) << "OPERWALL :" << buf;
}
void SendJoin(User *user, Channel *c, const ChannelStatus *status) anope_override
{
UplinkSocket::Message(Me) << "SJOIN " << c->creation_time << " " << c->name << " +" << c->GetModes(true, true) << " :" << user->GetUID();
if (status)
{
/* First save the channel status incase uc->Status == status */
ChannelStatus cs = *status;
/* If the user is internally on the channel with flags, kill them so that
* the stacker will allow this.
*/
ChanUserContainer *uc = c->FindUser(user);
if (uc != NULL)
uc->status.Clear();
BotInfo *setter = BotInfo::Find(user->nick);
for (size_t i = 0; i < cs.Modes().length(); ++i)
c->SetMode(setter, ModeManager::FindChannelModeByChar(cs.Modes()[i]), user->GetUID(), false);
if (uc != NULL)
uc->status = cs;
}
}
void SendForceNickChange(User *u, const Anope::string &newnick, time_t when) anope_override
{
UplinkSocket::Message(Me) << "ENCAP " << u->server->GetName() << " SVSNICK " << u->GetUID() << " " << u->timestamp << " " << newnick << " " << when;
}
void SendVhost(User *u, const Anope::string &ident, const Anope::string &host) anope_override
{
if (!ident.empty())
UplinkSocket::Message(Me) << "ENCAP * CHGIDENT " << u->GetUID() << " " << ident;
UplinkSocket::Message(Me) << "ENCAP * CHGHOST " << u->GetUID() << " " << host;
}
void SendVhostDel(User *u) anope_override
{
if (u->HasMode("CLOAK"))
u->RemoveMode(Config->GetClient("HostServ"), "CLOAK");
else
this->SendVhost(u, u->GetIdent(), u->chost);
}
void SendConnect() anope_override
{
UplinkSocket::Message() << "PASS " << Config->Uplinks[Anope::CurrentUplink].password << " TS 6 :" << Me->GetSID();
/* CAPAB
* QS - Can handle quit storm removal
* EX - Can do channel +e exemptions
* CHW - Can do channel wall @#
* LL - Can do lazy links
* IE - Can do invite exceptions
* EOB - Can do EOB message
* KLN - Can do KLINE message
* GLN - Can do GLINE message
* HUB - This server is a HUB
* AOPS - Can do anon ops (+a)
* UID - Can do UIDs
* ZIP - Can do ZIPlinks
* ENC - Can do ENCrypted links
* KNOCK - Supports KNOCK
* TBURST - Supports TBURST
* PARA - Supports invite broadcasting for +p
* ENCAP - Supports encapsulization of protocol messages
* SVS - Supports services protocol extensions
*/
UplinkSocket::Message() << "CAPAB :QS EX CHW IE EOB KLN UNKLN GLN HUB KNOCK TBURST PARA ENCAP SVS";
/* Make myself known to myself in the serverlist */
SendServer(Me);
/*
* SVINFO
* parv[0] = sender prefix
* parv[1] = TS_CURRENT for the server
* parv[2] = TS_MIN for the server
* parv[3] = server is standalone or connected to non-TS only
* parv[4] = server's idea of UTC time
*/
UplinkSocket::Message() << "SVINFO 6 5 0 :" << Anope::CurTime;
}
void SendClientIntroduction(User *u) anope_override
{
Anope::string modes = "+" + u->GetModes();
UplinkSocket::Message(Me) << "UID " << u->nick << " 1 " << u->timestamp << " " << modes << " " << u->GetIdent() << " " << u->host << " 255.255.255.255 " << u->GetUID() << " 0 " << u->host << " :" << u->realname;
}
void SendModeInternal(const MessageSource &source, User *u, const Anope::string &buf) anope_override
{
UplinkSocket::Message(source) << "ENCAP * SVSMODE " << u->GetUID() << " " << u->timestamp << " " << buf;
}
void SendLogin(User *u) anope_override
{
if (!u->Account())
return;
UplinkSocket::Message(Me) << "ENCAP * SU " << u->GetUID() << " " << u->Account()->display;
}
void SendLogout(User *u) anope_override
{
UplinkSocket::Message(Me) << "ENCAP * SU " << u->GetUID();
}
void SendTopic(const MessageSource &source, Channel *c) anope_override
{
UplinkSocket::Message(source) << "ENCAP * TOPIC " << c->name << " " << c->topic_setter << " " << c->topic_ts << " :" << c->topic;
}
void SendSVSJoin(const MessageSource &source, User *user, const Anope::string &chan, const Anope::string &param) anope_override
{
UplinkSocket::Message(source) << "ENCAP " << user->server->GetName() << " SVSJOIN " << user->GetUID() << " " << chan;
}
void SendSVSPart(const MessageSource &source, User *user, const Anope::string &chan, const Anope::string &param) anope_override
{
UplinkSocket::Message(source) << "ENCAP " << user->server->GetName() << " SVSPART " << user->GetUID() << " " << chan;
}
};
struct IRCDMessageEncap : IRCDMessage
{
IRCDMessageEncap(Module *creator) : IRCDMessage(creator, "ENCAP", 4) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); }
void Run(MessageSource &source, const std::vector<Anope::string> &params) anope_override
{
/*
* Received: :dev.anope.de ENCAP * SU DukePyrolator DukePyrolator
* params[0] = *
* params[1] = SU
* params[2] = nickname
* params[3] = account
*/
if (params[1].equals_cs("SU"))
{
User *u = User::Find(params[2]);
NickCore *nc = NickCore::Find(params[3]);
if (u && nc)
{
u->Login(nc);
}
}
/*
* Received: :dev.anope.de ENCAP * CERTFP DukePyrolator :3F122A9CC7811DBAD3566BF2CEC3009007C0868F
* params[0] = *
* params[1] = CERTFP
* params[2] = nickname
* params[3] = fingerprint
*/
else if (params[1].equals_cs("CERTFP"))
{
User *u = User::Find(params[2]);
if (u)
{
u->fingerprint = params[3];
FOREACH_MOD(OnFingerprint, (u));
}
}
return;
}
};
struct IRCDMessagePass : IRCDMessage
{
IRCDMessagePass(Module *creator) : IRCDMessage(creator, "PASS", 4) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); }
void Run(MessageSource &source, const std::vector<Anope::string> &params) anope_override
{
UplinkSID = params[3];
}
};
struct IRCDMessageServer : IRCDMessage
{
IRCDMessageServer(Module *creator) : IRCDMessage(creator, "SERVER", 3) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); }
/* 0 1 2 */
/* SERVER hades.arpa 1 :ircd-hybrid test server */
void Run(MessageSource &source, const std::vector<Anope::string> &params) anope_override
{
/* Servers other than 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);
}
};
struct IRCDMessageUID : IRCDMessage
{
IRCDMessageUID(Module *creator) : IRCDMessage(creator, "UID", 11) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); }
/*
params[0] = nick
params[1] = hop
params[2] = ts
params[3] = modes
params[4] = user
params[5] = host
params[6] = IP
params[7] = UID
params[8] = services stamp
params[9] = realhost
params[10] = info
*/
// :42X UID Adam 1 1348535644 +aow Adam 192.168.0.5 192.168.0.5 42XAAAAAB 0 192.168.0.5 :Adam
void Run(MessageSource &source, const std::vector<Anope::string> &params) anope_override
{
/* An IP of 0 means the user is spoofed */
Anope::string ip = params[6];
if (ip == "0")
ip.clear();
time_t ts;
try
{
ts = convertTo<time_t>(params[2]);
}
catch (const ConvertException &)
{
ts = Anope::CurTime;
}
NickAlias *na = NULL;
try
{
if (params[8].is_pos_number_only() && convertTo<time_t>(params[8]) == ts)
na = NickAlias::Find(params[0]);
}
catch (const ConvertException &) { }
if (params[8] != "0" && !na)
na = NickAlias::Find(params[8]);
new User(params[0], params[4], params[9], params[5], ip, source.GetServer(), params[10], ts, params[3], params[7], na ? *na->nc : NULL);
}
};
class ProtoPlexus : public Module
{
Module *m_hybrid;
PlexusProto ircd_proto;
/* Core message handlers */
Message::Away message_away;
Message::Capab message_capab;
Message::Error message_error;
Message::Invite message_invite;
Message::Kick message_kick;
Message::Kill message_kill;
Message::Mode message_mode;
Message::MOTD message_motd;
Message::Notice message_notice;
Message::Part message_part;
Message::Ping message_ping;
Message::Privmsg message_privmsg;
Message::Quit message_quit;
Message::SQuit message_squit;
Message::Stats message_stats;
Message::Time message_time;
Message::Topic message_topic;
Message::Version message_version;
Message::Whois message_whois;
/* Hybrid message handlers */
ServiceAlias message_bmask, message_eob, message_join, message_nick, message_sid, message_sjoin,
message_tburst, message_tmode;
/* Our message handlers */
IRCDMessageEncap message_encap;
IRCDMessagePass message_pass;
IRCDMessageServer message_server;
IRCDMessageUID message_uid;
void AddModes()
{
/* Add user modes */
ModeManager::AddUserMode(new UserModeOperOnly("ADMIN", 'a'));
ModeManager::AddUserMode(new UserMode("NOCTCP", 'C'));
ModeManager::AddUserMode(new UserMode("DEAF", 'D'));
ModeManager::AddUserMode(new UserMode("SOFTCALLERID", 'G'));
ModeManager::AddUserMode(new UserMode("CALLERID", 'g'));
ModeManager::AddUserMode(new UserMode("INVIS", 'i'));
ModeManager::AddUserMode(new UserModeOperOnly("LOCOPS", 'l'));
ModeManager::AddUserMode(new UserMode("OPER", 'o'));
ModeManager::AddUserMode(new UserMode("PRIV", 'p'));
ModeManager::AddUserMode(new UserModeOperOnly("NETADMIN", 'N'));
ModeManager::AddUserMode(new UserModeNoone("REGISTERED", 'r'));
ModeManager::AddUserMode(new UserMode("REGPRIV", 'R'));
ModeManager::AddUserMode(new UserModeOperOnly("SNOMASK", 's'));
ModeManager::AddUserMode(new UserModeNoone("SSL", 'S'));
ModeManager::AddUserMode(new UserMode("WALLOPS", 'w'));
ModeManager::AddUserMode(new UserModeNoone("WEBIRC", 'W'));
ModeManager::AddUserMode(new UserMode("CLOAK", 'x'));
ModeManager::AddUserMode(new UserModeOperOnly("OPERWALLS", 'z'));
/* b/e/I */
ModeManager::AddChannelMode(new ChannelModeList("BAN", 'b'));
ModeManager::AddChannelMode(new ChannelModeList("EXCEPT", 'e'));
ModeManager::AddChannelMode(new ChannelModeList("INVITEOVERRIDE", 'I'));
ModeManager::AddUserMode(new UserModeNoone("PROTECTED", 'U'));
/* v/h/o/a/q */
ModeManager::AddChannelMode(new ChannelModeStatus("VOICE", 'v', '+', 0));
ModeManager::AddChannelMode(new ChannelModeStatus("HALFOP", 'h', '%', 1));
ModeManager::AddChannelMode(new ChannelModeStatus("OP", 'o', '@', 2));
ModeManager::AddChannelMode(new ChannelModeStatus("PROTECT", 'a', '&', 3));
ModeManager::AddChannelMode(new ChannelModeStatus("OWNER", 'q', '~', 4));
/* l/k */
ModeManager::AddChannelMode(new ChannelModeParam("LIMIT", 'l'));
ModeManager::AddChannelMode(new ChannelModeKey('k'));
/* Add channel modes */
ModeManager::AddChannelMode(new ChannelMode("BANDWIDTH", 'B'));
ModeManager::AddChannelMode(new ChannelMode("NOCTCP", 'C'));
ModeManager::AddChannelMode(new ChannelMode("BLOCKCOLOR", 'c'));
ModeManager::AddChannelMode(new ChannelMode("INVITE", 'i'));
ModeManager::AddChannelMode(new ChannelMode("MODERATED", 'm'));
ModeManager::AddChannelMode(new ChannelMode("REGMODERATED", 'M'));
ModeManager::AddChannelMode(new ChannelMode("NOEXTERNAL", 'n'));
ModeManager::AddChannelMode(new ChannelMode("NONOTICE", 'N'));
ModeManager::AddChannelMode(new ChannelMode("PRIVATE", 'p'));
ModeManager::AddChannelMode(new ChannelMode("SECRET", 's'));
ModeManager::AddChannelMode(new ChannelMode("TOPIC", 't'));
ModeManager::AddChannelMode(new ChannelModeOperOnly("OPERONLY", 'O'));
ModeManager::AddChannelMode(new ChannelMode("REGMODERATED", 'M'));
ModeManager::AddChannelMode(new ChannelMode("REGISTEREDONLY", 'R'));
ModeManager::AddChannelMode(new ChannelMode("SSL", 'S'));
ModeManager::AddChannelMode(new ChannelMode("PERM", 'z'));
}
public:
ProtoPlexus(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, PROTOCOL | VENDOR),
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("IRCDMessage", "plexus/bmask", "hybrid/bmask"), message_eob("IRCDMessage", "plexus/eob", "hybrid/eob"),
message_join("IRCDMessage", "plexus/join", "hybrid/join"), message_nick("IRCDMessage", "plexus/nick", "hybrid/nick"),
message_sid("IRCDMessage", "plexus/sid", "hybrid/sid"),
message_sjoin("IRCDMessage", "plexus/sjoin", "hybrid/sjoin"), message_tburst("IRCDMessage", "plexus/tburst", "hybrid/tburst"),
message_tmode("IRCDMessage", "plexus/tmode", "hybrid/tmode"),
message_encap(this), message_pass(this), message_server(this), message_uid(this)
{
if (ModuleManager::LoadModule("hybrid", User::Find(creator)) != MOD_ERR_OK)
throw ModuleException("Unable to load hybrid");
m_hybrid = ModuleManager::FindModule("hybrid");
if (!m_hybrid)
throw ModuleException("Unable to find hybrid");
if (!hybrid)
throw ModuleException("No protocol interface for hybrid");
this->AddModes();
}
~ProtoPlexus()
{
ModuleManager::UnloadModule(m_hybrid, NULL);
}
};
MODULE_INIT(ProtoPlexus)
View Git Blame Copy Permalink