X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fcoremods%2Fcore_whois.cpp;h=7fbaf222619de1d3185abb9477f1fbaab81e8da1;hb=abbf70b2a35edaf17631e43027828011296924ad;hp=c2fac75773bb1bb9efdfed2e93b90a608ea47925;hpb=d865b434865907bfad0a187dd403d4ca8144e469;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/coremods/core_whois.cpp b/src/coremods/core_whois.cpp index c2fac7577..7fbaf2226 100644 --- a/src/coremods/core_whois.cpp +++ b/src/coremods/core_whois.cpp @@ -20,6 +20,35 @@ #include "inspircd.h" +#include "modules/whois.h" + +enum +{ + // From RFC 1459. + RPL_WHOISUSER = 311, + RPL_WHOISOPERATOR = 313, + RPL_WHOISIDLE = 317, + RPL_WHOISCHANNELS = 319, + + // From UnrealIRCd. + RPL_WHOISHOST = 378, + RPL_WHOISMODES = 379, + + // InspIRCd-specific. + RPL_CHANNELSMSG = 651 +}; + +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 { @@ -55,10 +84,12 @@ class CommandWhois : public SplitCommand Events::ModuleEventProvider evprov; Events::ModuleEventProvider lineevprov; - void DoWhois(LocalUser* user, User* dest, unsigned long signon, unsigned long idle); + void DoWhois(LocalUser* user, User* dest, time_t signon, unsigned long idle); void SendChanList(WhoisContextImpl& whois); public: + SplitWhoisState splitwhois; + /** Constructor for whois. */ CommandWhois(Module* parent) @@ -78,8 +109,8 @@ 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; }; class WhoisNumericSink @@ -101,7 +132,7 @@ class WhoisChanListNumericBuilder : public Numeric::GenericBuilder<' ', false, W { public: WhoisChanListNumericBuilder(WhoisContextImpl& whois) - : Numeric::GenericBuilder<' ', false, WhoisNumericSink>(WhoisNumericSink(whois), 319, false, whois.GetSource()->nick.size() + whois.GetTarget()->nick.size() + 1) + : 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()); } @@ -109,9 +140,9 @@ class WhoisChanListNumericBuilder : public Numeric::GenericBuilder<' ', false, W class WhoisChanList { - const ServerConfig::OperSpyWhoisState spywhois; + const SplitWhoisState& splitwhois; WhoisChanListNumericBuilder num; - WhoisChanListNumericBuilder spynum; + WhoisChanListNumericBuilder secretnum; std::string prefixstr; void AddMember(Membership* memb, WhoisChanListNumericBuilder& out) @@ -124,10 +155,10 @@ class WhoisChanList } public: - WhoisChanList(WhoisContextImpl& whois) - : spywhois(whois.GetSource()->HasPrivPermission("users/auspex") ? ServerInstance->Config->OperSpyWhois : ServerConfig::SPYWHOIS_NONE) + WhoisChanList(WhoisContextImpl& whois, const SplitWhoisState& sws) + : splitwhois(sws) , num(whois) - , spynum(whois) + , secretnum(whois) { } @@ -138,102 +169,105 @@ class WhoisChanList void AddHidden(Membership* memb) { - if (spywhois == ServerConfig::SPYWHOIS_NONE) - return; - AddMember(memb, (spywhois == ServerConfig::SPYWHOIS_SPLITMSG ? spynum : num)); + AddMember(memb, splitwhois == SPLITWHOIS_NONE ? num : secretnum); } void Flush(WhoisContextImpl& whois) { num.Flush(); - if (!spynum.IsEmpty()) - whois.SendLine(336, "is on private/secret channels:"); - spynum.Flush(); + if (!secretnum.IsEmpty() && splitwhois == SPLITWHOIS_SPLITMSG) + whois.SendLine(RPL_CHANNELSMSG, "is on private/secret channels:"); + secretnum.Flush(); } }; void CommandWhois::SendChanList(WhoisContextImpl& whois) { - WhoisChanList chanlist(whois); + WhoisChanList chanlist(whois, splitwhois); 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; - /* 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 ((whois.IsSelfWhois()) || ((!c->IsModeSet(privatemode)) && (!c->IsModeSet(secretmode))) || (c->HasUser(whois.GetSource()))) + + // Anyone can view channels which are not private or secret. + if (!c->IsModeSet(privatemode) && !c->IsModeSet(secretmode)) chanlist.AddVisible(memb); - else + + // 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); } -void CommandWhois::DoWhois(LocalUser* user, User* dest, unsigned long signon, unsigned long idle) +void CommandWhois::DoWhois(LocalUser* user, User* dest, time_t signon, unsigned long idle) { WhoisContextImpl whois(user, dest, lineevprov); - whois.SendLine(311, dest->ident, dest->GetDisplayedHost(), '*', dest->fullname); + whois.SendLine(RPL_WHOISUSER, dest->ident, dest->GetDisplayedHost(), '*', dest->GetRealName()); if (whois.IsSelfWhois() || user->HasPrivPermission("users/auspex")) { - whois.SendLine(378, InspIRCd::Format("is connecting from %s@%s %s", dest->ident.c_str(), dest->GetRealHost().c_str(), dest->GetIPString().c_str())); + whois.SendLine(RPL_WHOISHOST, InspIRCd::Format("is connecting from %s@%s %s", dest->ident.c_str(), dest->GetRealHost().c_str(), dest->GetIPString().c_str())); } SendChanList(whois); - if (!whois.IsSelfWhois() && !ServerInstance->Config->HideWhoisServer.empty() && !user->HasPrivPermission("servers/auspex")) + if (!whois.IsSelfWhois() && !ServerInstance->Config->HideServer.empty() && !user->HasPrivPermission("servers/auspex")) { - whois.SendLine(312, ServerInstance->Config->HideWhoisServer, ServerInstance->Config->Network); + whois.SendLine(RPL_WHOISSERVER, ServerInstance->Config->HideServer, ServerInstance->Config->Network); } else { - whois.SendLine(312, dest->server->GetName(), dest->server->GetDesc()); + whois.SendLine(RPL_WHOISSERVER, dest->server->GetName(), dest->server->GetDesc()); } if (dest->IsAway()) { - whois.SendLine(301, dest->awaymsg); + whois.SendLine(RPL_AWAY, dest->awaymsg); } if (dest->IsOper()) { if (ServerInstance->Config->GenericOper) - whois.SendLine(313, "is an IRC operator"); + whois.SendLine(RPL_WHOISOPERATOR, "is an IRC operator"); else - whois.SendLine(313, 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())); + 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 (whois.IsSelfWhois() || user->HasPrivPermission("users/auspex")) { if (dest->IsModeSet(snomaskmode)) { - whois.SendLine(379, InspIRCd::Format("is using modes %s %s", dest->GetModeLetters().c_str(), 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 { - whois.SendLine(379, InspIRCd::Format("is using modes %s", dest->GetModeLetters().c_str())); + whois.SendLine(RPL_WHOISMODES, InspIRCd::Format("is using modes %s", dest->GetModeLetters().c_str())); } } 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)) { - whois.SendLine(317, idle, signon, "seconds idle, signon time"); + whois.SendLine(RPL_WHOISIDLE, idle, signon, "seconds idle, signon time"); } - whois.SendLine(318, "End of /WHOIS list."); + 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; @@ -247,17 +281,18 @@ CmdResult CommandWhois::HandleRemote(const std::vector& parameters, if (!localuser) return CMD_FAILURE; - unsigned long idle = ConvToInt(parameters.back()); + 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; @@ -275,14 +310,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; @@ -301,4 +336,35 @@ CmdResult CommandWhois::HandleLocal(const std::vector& parameters, 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"); + if (stdalgo::string::equalsci(splitwhois, "no")) + cmd.splitwhois = SPLITWHOIS_NONE; + else if (stdalgo::string::equalsci(splitwhois, "split")) + cmd.splitwhois = SPLITWHOIS_SPLIT; + else if (stdalgo::string::equalsci(splitwhois, "splitmsg")) + cmd.splitwhois = SPLITWHOIS_SPLITMSG; + else + throw ModuleException(splitwhois + " is an invalid value, at " + tag->getTagLocation()); + } + + Version GetVersion() CXX11_OVERRIDE + { + return Version("Provides the WHOIS command", VF_VENDOR|VF_CORE); + } +}; + +MODULE_INIT(CoreModWhois)