X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fcoremods%2Fcore_whois.cpp;h=c1c4777ef24c397b4bcaff5c555ed290a47ce811;hb=e2b0f3dc9ef4d56c71d7abda13e6139ca092e387;hp=7464e052753cad86ab0235389e32ad137d212d64;hpb=3ccae741b8c60acc2d95f2dc54d7e69014090807;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/coremods/core_whois.cpp b/src/coremods/core_whois.cpp index 7464e0527..c1c4777ef 100644 --- a/src/coremods/core_whois.cpp +++ b/src/coremods/core_whois.cpp @@ -1,9 +1,17 @@ /* * InspIRCd -- Internet Relay Chat Daemon * + * Copyright (C) 2019 Matt Schatz + * Copyright (C) 2018 linuxdaemon + * Copyright (C) 2018 Dylan Frank + * Copyright (C) 2017-2018, 2020 Sadie Powell + * Copyright (C) 2012-2016 Attila Molnar + * Copyright (C) 2012, 2019 Robby + * Copyright (C) 2009 Uli Schlachter * Copyright (C) 2009 Daniel De Graaf - * Copyright (C) 2008 Thomas Stagner * Copyright (C) 2007 Robin Burchell + * Copyright (C) 2007 Dennis Friis + * Copyright (C) 2006-2008, 2010 Craig Edwards * * This file is part of InspIRCd. InspIRCd is free software: you can * redistribute it and/or modify it under the terms of the GNU General Public @@ -20,6 +28,43 @@ #include "inspircd.h" +#include "modules/whois.h" + +enum SplitWhoisState +{ + // Don't split private/secret channels into a separate RPL_WHOISCHANNELS numeric. + SPLITWHOIS_NONE, + + // Split private/secret channels into a separate RPL_WHOISCHANNELS numeric. + SPLITWHOIS_SPLIT, + + // Split private/secret channels into a separate RPL_WHOISCHANNELS numeric with RPL_CHANNELSMSG to explain the split. + SPLITWHOIS_SPLITMSG +}; + +class WhoisContextImpl : public Whois::Context +{ + Events::ModuleEventProvider& lineevprov; + + public: + WhoisContextImpl(LocalUser* src, User* targ, Events::ModuleEventProvider& evprov) + : Whois::Context(src, targ) + , lineevprov(evprov) + { + } + + using Whois::Context::SendLine; + void SendLine(Numeric::Numeric& numeric) CXX11_OVERRIDE; +}; + +void WhoisContextImpl::SendLine(Numeric::Numeric& numeric) +{ + ModResult MOD_RESULT; + FIRST_MOD_RESULT_CUSTOM(lineevprov, Whois::LineEventListener, OnWhoisLine, MOD_RESULT, (*this, numeric)); + + if (MOD_RESULT != MOD_RES_DENY) + source->WriteNumeric(numeric); +} /** Handle /WHOIS. */ @@ -28,12 +73,21 @@ class CommandWhois : public SplitCommand ChanModeReference secretmode; ChanModeReference privatemode; UserModeReference snomaskmode; + Events::ModuleEventProvider evprov; + Events::ModuleEventProvider lineevprov; - void SplitChanList(User* source, User* dest, const std::string& cl); - void DoWhois(User* user, User* dest, unsigned long signon, unsigned long idle); - std::string ChannelList(User* source, User* dest, bool spy); + void DoWhois(LocalUser* user, User* dest, time_t signon, unsigned long idle); + void SendChanList(WhoisContextImpl& whois); public: + /** If true then all opers are shown with a generic 'is a server operator' line rather than the oper type. */ + bool genericoper; + + /** How to handle private/secret channels in the WHOIS response. */ + SplitWhoisState splitwhois; + + + /** Constructor for whois. */ CommandWhois(Module* parent) @@ -41,9 +95,11 @@ class CommandWhois : public SplitCommand , secretmode(parent, "secret") , privatemode(parent, "private") , snomaskmode(parent, "snomask") + , evprov(parent, "event/whois") + , lineevprov(parent, "event/whoisline") { Penalty = 2; - syntax = "{,}"; + syntax = "[] [,]+"; } /** Handle command. @@ -51,134 +107,165 @@ class CommandWhois : public SplitCommand * @param user The user issuing the command * @return A value from CmdResult to indicate command success or failure. */ - CmdResult HandleLocal(const std::vector& parameters, LocalUser* user); - CmdResult HandleRemote(const std::vector& parameters, RemoteUser* target); + CmdResult HandleLocal(LocalUser* user, const Params& parameters) CXX11_OVERRIDE; + CmdResult HandleRemote(RemoteUser* target, const Params& parameters) CXX11_OVERRIDE; }; -std::string CommandWhois::ChannelList(User* source, User* dest, bool spy) +class WhoisNumericSink { - std::string list; + WhoisContextImpl& whois; + public: + WhoisNumericSink(WhoisContextImpl& whoisref) + : whois(whoisref) + { + } - for (User::ChanList::iterator i = dest->chans.begin(); i != dest->chans.end(); i++) + void operator()(Numeric::Numeric& numeric) const { - Membership* memb = *i; - Channel* c = memb->chan; - /* If the target is the sender, neither +p nor +s is set, or - * the channel contains the user, it is not a spy channel - */ - if (spy != (source == dest || !(c->IsModeSet(privatemode) || c->IsModeSet(secretmode)) || c->HasUser(source))) - { - char prefix = memb->GetPrefixChar(); - if (prefix) - list.push_back(prefix); - list.append(c->name).push_back(' '); - } + whois.SendLine(numeric); } +}; - return list; -} +class WhoisChanListNumericBuilder : public Numeric::GenericBuilder<' ', false, WhoisNumericSink> +{ + public: + WhoisChanListNumericBuilder(WhoisContextImpl& whois) + : Numeric::GenericBuilder<' ', false, WhoisNumericSink>(WhoisNumericSink(whois), RPL_WHOISCHANNELS, false, whois.GetSource()->nick.size() + whois.GetTarget()->nick.size() + 1) + { + GetNumeric().push(whois.GetTarget()->nick).push(std::string()); + } +}; -void CommandWhois::SplitChanList(User* source, User* dest, const std::string& cl) +class WhoisChanList { - std::string line; - std::ostringstream prefix; - std::string::size_type start, pos; + const SplitWhoisState& splitwhois; + WhoisChanListNumericBuilder num; + WhoisChanListNumericBuilder secretnum; + std::string prefixstr; - prefix << dest->nick << " :"; - line = prefix.str(); - int namelen = ServerInstance->Config->ServerName.length() + 6; + void AddMember(Membership* memb, WhoisChanListNumericBuilder& out) + { + prefixstr.clear(); + const char prefix = memb->GetPrefixChar(); + if (prefix) + prefixstr.push_back(prefix); + out.Add(prefixstr, memb->chan->name); + } - for (start = 0; (pos = cl.find(' ', start)) != std::string::npos; start = pos+1) + public: + WhoisChanList(WhoisContextImpl& whois, const SplitWhoisState& sws) + : splitwhois(sws) + , num(whois) + , secretnum(whois) { - if (line.length() + namelen + pos - start > 510) - { - ServerInstance->SendWhoisLine(source, dest, 319, line); - line = prefix.str(); - } + } - line.append(cl, start, pos - start + 1); + void AddVisible(Membership* memb) + { + AddMember(memb, num); } - if (line.length() != prefix.str().length()) + void AddHidden(Membership* memb) { - ServerInstance->SendWhoisLine(source, dest, 319, line); + AddMember(memb, splitwhois == SPLITWHOIS_NONE ? num : secretnum); } -} -void CommandWhois::DoWhois(User* user, User* dest, unsigned long signon, unsigned long idle) -{ - ServerInstance->SendWhoisLine(user, dest, 311, "%s %s %s * :%s", dest->nick.c_str(), dest->ident.c_str(), dest->dhost.c_str(), dest->fullname.c_str()); - if (user == dest || user->HasPrivPermission("users/auspex")) + void Flush(WhoisContextImpl& whois) { - ServerInstance->SendWhoisLine(user, dest, 378, "%s :is connecting from %s@%s %s", dest->nick.c_str(), dest->ident.c_str(), dest->host.c_str(), dest->GetIPString().c_str()); + num.Flush(); + if (!secretnum.IsEmpty() && splitwhois == SPLITWHOIS_SPLITMSG) + whois.SendLine(RPL_CHANNELSMSG, "is on private/secret channels:"); + secretnum.Flush(); } +}; - std::string cl = ChannelList(user, dest, false); - const ServerConfig::OperSpyWhoisState state = user->HasPrivPermission("users/auspex") ? ServerInstance->Config->OperSpyWhois : ServerConfig::SPYWHOIS_NONE; +void CommandWhois::SendChanList(WhoisContextImpl& whois) +{ + WhoisChanList chanlist(whois, splitwhois); - if (state == ServerConfig::SPYWHOIS_SINGLEMSG) - cl.append(ChannelList(user, dest, true)); + User* const target = whois.GetTarget(); + bool hasoperpriv = whois.GetSource()->HasPrivPermission("users/channel-spy"); + for (User::ChanList::iterator i = target->chans.begin(); i != target->chans.end(); ++i) + { + Membership* memb = *i; + Channel* c = memb->chan; + + // Anyone can view channels which are not private or secret. + if (!c->IsModeSet(privatemode) && !c->IsModeSet(secretmode)) + chanlist.AddVisible(memb); - SplitChanList(user, dest, cl); + // Hidden channels are visible when the following conditions are true: + // (1) The source user and the target user are the same. + // (2) The source user is a member of the hidden channel. + // (3) The source user is an oper with the users/channel-spy privilege. + else if (whois.IsSelfWhois() || c->HasUser(whois.GetSource()) || hasoperpriv) + chanlist.AddHidden(memb); + } + + chanlist.Flush(whois); +} - if (state == ServerConfig::SPYWHOIS_SPLITMSG) +void CommandWhois::DoWhois(LocalUser* user, User* dest, time_t signon, unsigned long idle) +{ + WhoisContextImpl whois(user, dest, lineevprov); + + whois.SendLine(RPL_WHOISUSER, dest->ident, dest->GetDisplayedHost(), '*', dest->GetRealName()); + if (whois.IsSelfWhois() || user->HasPrivPermission("users/auspex")) { - std::string scl = ChannelList(user, dest, true); - if (scl.length()) - { - ServerInstance->SendWhoisLine(user, dest, 336, "%s :is on private/secret channels:", dest->nick.c_str()); - SplitChanList(user, dest, scl); - } + whois.SendLine(RPL_WHOISHOST, InspIRCd::Format("is connecting from %s@%s %s", dest->ident.c_str(), dest->GetRealHost().c_str(), dest->GetIPString().c_str())); } - if (user != dest && !ServerInstance->Config->HideWhoisServer.empty() && !user->HasPrivPermission("servers/auspex")) + + SendChanList(whois); + + if (!whois.IsSelfWhois() && !ServerInstance->Config->HideServer.empty() && !user->HasPrivPermission("servers/auspex")) { - ServerInstance->SendWhoisLine(user, dest, 312, "%s %s :%s", dest->nick.c_str(), ServerInstance->Config->HideWhoisServer.c_str(), ServerInstance->Config->Network.c_str()); + whois.SendLine(RPL_WHOISSERVER, ServerInstance->Config->HideServer, ServerInstance->Config->Network); } else { - ServerInstance->SendWhoisLine(user, dest, 312, "%s %s :%s", dest->nick.c_str(), dest->server->GetName().c_str(), dest->server->GetDesc().c_str()); + whois.SendLine(RPL_WHOISSERVER, dest->server->GetName(), dest->server->GetDesc()); } if (dest->IsAway()) { - ServerInstance->SendWhoisLine(user, dest, 301, "%s :%s", dest->nick.c_str(), dest->awaymsg.c_str()); + whois.SendLine(RPL_AWAY, dest->awaymsg); } if (dest->IsOper()) { - if (ServerInstance->Config->GenericOper) - ServerInstance->SendWhoisLine(user, dest, 313, "%s :is an IRC operator", dest->nick.c_str()); + if (genericoper) + whois.SendLine(RPL_WHOISOPERATOR, "is a server operator"); else - ServerInstance->SendWhoisLine(user, dest, 313, "%s :is %s %s on %s", dest->nick.c_str(), (strchr("AEIOUaeiou",dest->oper->name[0]) ? "an" : "a"),dest->oper->name.c_str(), ServerInstance->Config->Network.c_str()); + whois.SendLine(RPL_WHOISOPERATOR, InspIRCd::Format("is %s %s on %s", (strchr("AEIOUaeiou",dest->oper->name[0]) ? "an" : "a"), dest->oper->name.c_str(), ServerInstance->Config->Network.c_str())); } - if (user == dest || user->HasPrivPermission("users/auspex")) + if (whois.IsSelfWhois() || user->HasPrivPermission("users/auspex")) { if (dest->IsModeSet(snomaskmode)) { - ServerInstance->SendWhoisLine(user, dest, 379, "%s :is using modes +%s %s", dest->nick.c_str(), dest->FormatModes(), snomaskmode->GetUserParameter(dest).c_str()); + whois.SendLine(RPL_WHOISMODES, InspIRCd::Format("is using modes %s %s", dest->GetModeLetters().c_str(), snomaskmode->GetUserParameter(dest).c_str())); } else { - ServerInstance->SendWhoisLine(user, dest, 379, "%s :is using modes +%s", dest->nick.c_str(), dest->FormatModes()); + whois.SendLine(RPL_WHOISMODES, InspIRCd::Format("is using modes %s", dest->GetModeLetters().c_str())); } } - FOREACH_MOD(OnWhois, (user,dest)); + FOREACH_MOD_CUSTOM(evprov, Whois::EventListener, OnWhois, (whois)); /* - * We only send these if we've been provided them. That is, if hidewhois is turned off, and user is local, or + * We only send these if we've been provided them. That is, if hideserver is turned off, and user is local, or * if remote whois is queried, too. This is to keep the user hidden, and also since you can't reliably tell remote time. -- w00t */ if ((idle) || (signon)) { - ServerInstance->SendWhoisLine(user, dest, 317, "%s %lu %lu :seconds idle, signon time", dest->nick.c_str(), idle, signon); + whois.SendLine(RPL_WHOISIDLE, idle, signon, "seconds idle, signon time"); } - ServerInstance->SendWhoisLine(user, dest, 318, "%s :End of /WHOIS list.", dest->nick.c_str()); + whois.SendLine(RPL_ENDOFWHOIS, "End of /WHOIS list."); } -CmdResult CommandWhois::HandleRemote(const std::vector& parameters, RemoteUser* target) +CmdResult CommandWhois::HandleRemote(RemoteUser* target, const Params& parameters) { if (parameters.size() < 2) return CMD_FAILURE; @@ -187,24 +274,30 @@ CmdResult CommandWhois::HandleRemote(const std::vector& parameters, if (!user) return CMD_FAILURE; - unsigned long idle = ConvToInt(parameters.back()); - DoWhois(user, target, target->signon, idle); + // User doing the whois must be on this server + LocalUser* localuser = IS_LOCAL(user); + if (!localuser) + return CMD_FAILURE; + + unsigned long idle = ConvToNum(parameters.back()); + DoWhois(localuser, target, target->signon, idle); return CMD_SUCCESS; } -CmdResult CommandWhois::HandleLocal(const std::vector& parameters, LocalUser* user) +CmdResult CommandWhois::HandleLocal(LocalUser* user, const Params& parameters) { User *dest; - int userindex = 0; - unsigned long idle = 0, signon = 0; + unsigned int userindex = 0; + unsigned long idle = 0; + time_t signon = 0; if (CommandParser::LoopCall(user, this, parameters, 0)) return CMD_SUCCESS; /* - * If 2 paramters are specified (/whois nick nick), ignore the first one like spanningtree - * does, and use the second one, otherwise, use the only paramter. -- djGrrr + * If 2 parameters are specified (/whois nick nick), ignore the first one like spanningtree + * does, and use the second one, otherwise, use the only parameter. -- djGrrr */ if (parameters.size() > 1) userindex = 1; @@ -215,14 +308,14 @@ CmdResult CommandWhois::HandleLocal(const std::vector& parameters, { /* * Okay. Umpteenth attempt at doing this, so let's re-comment... - * For local users (/w localuser), we show idletime if hidewhois is disabled + * For local users (/w localuser), we show idletime if hideserver is disabled * For local users (/w localuser localuser), we always show idletime, hence parameters.size() > 1 check. * For remote users (/w remoteuser), we do NOT show idletime * For remote users (/w remoteuser remoteuser), spanningtree will handle calling do_whois, so we can ignore this case. * Thanks to djGrrr for not being impatient while I have a crap day coding. :p -- w00t */ LocalUser* localuser = IS_LOCAL(dest); - if (localuser && (ServerInstance->Config->HideWhoisServer.empty() || parameters.size() > 1)) + if (localuser && (ServerInstance->Config->HideServer.empty() || parameters.size() > 1)) { idle = labs((long)((localuser->idle_lastmsg)-ServerInstance->Time())); signon = dest->signon; @@ -233,12 +326,48 @@ CmdResult CommandWhois::HandleLocal(const std::vector& parameters, else { /* no such nick/channel */ - user->WriteNumeric(ERR_NOSUCHNICK, "%s :No such nick/channel", !parameters[userindex].empty() ? parameters[userindex].c_str() : "*"); - user->WriteNumeric(RPL_ENDOFWHOIS, "%s :End of /WHOIS list.", !parameters[userindex].empty() ? parameters[userindex].c_str() : "*"); + user->WriteNumeric(Numerics::NoSuchNick(!parameters[userindex].empty() ? parameters[userindex] : "*")); + user->WriteNumeric(RPL_ENDOFWHOIS, (!parameters[userindex].empty() ? parameters[userindex] : "*"), "End of /WHOIS list."); return CMD_FAILURE; } return CMD_SUCCESS; } -COMMAND_INIT(CommandWhois) +class CoreModWhois : public Module +{ + private: + CommandWhois cmd; + + public: + CoreModWhois() + : cmd(this) + { + } + + void ReadConfig(ConfigStatus&) CXX11_OVERRIDE + { + ConfigTag* tag = ServerInstance->Config->ConfValue("options"); + const std::string splitwhois = tag->getString("splitwhois", "no", 1); + SplitWhoisState newsplitstate; + if (stdalgo::string::equalsci(splitwhois, "no")) + newsplitstate = SPLITWHOIS_NONE; + else if (stdalgo::string::equalsci(splitwhois, "split")) + newsplitstate = SPLITWHOIS_SPLIT; + else if (stdalgo::string::equalsci(splitwhois, "splitmsg")) + newsplitstate = SPLITWHOIS_SPLITMSG; + else + throw ModuleException(splitwhois + " is an invalid value, at " + tag->getTagLocation()); + + ConfigTag* security = ServerInstance->Config->ConfValue("security"); + cmd.genericoper = security->getBool("genericoper"); + cmd.splitwhois = newsplitstate; + } + + Version GetVersion() CXX11_OVERRIDE + { + return Version("Provides the WHOIS command", VF_VENDOR|VF_CORE); + } +}; + +MODULE_INIT(CoreModWhois)