X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fcoremods%2Fcore_whois.cpp;h=c1c4777ef24c397b4bcaff5c555ed290a47ce811;hb=635cb9d65f6d7f6758ae8ed874da00c8d94b6e39;hp=1cd622092be90e85d8c35285ca44a33dde5fddab;hpb=4711113dff7fc33c96f95f417f2813f28c690e01;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/coremods/core_whois.cpp b/src/coremods/core_whois.cpp index 1cd622092..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,19 @@ #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 { @@ -33,20 +54,16 @@ class WhoisContextImpl : public Whois::Context } using Whois::Context::SendLine; - void SendLine(unsigned int numeric, const std::string& text) CXX11_OVERRIDE; + void SendLine(Numeric::Numeric& numeric) CXX11_OVERRIDE; }; -void WhoisContextImpl::SendLine(unsigned int numeric, const std::string& text) +void WhoisContextImpl::SendLine(Numeric::Numeric& numeric) { - std::string copy_text = target->nick; - copy_text.push_back(' '); - copy_text.append(text); - ModResult MOD_RESULT; - FIRST_MOD_RESULT_CUSTOM(lineevprov, Whois::LineEventListener, OnWhoisLine, MOD_RESULT, (*this, numeric, copy_text)); + FIRST_MOD_RESULT_CUSTOM(lineevprov, Whois::LineEventListener, OnWhoisLine, MOD_RESULT, (*this, numeric)); if (MOD_RESULT != MOD_RES_DENY) - source->WriteNumeric(numeric, copy_text); + source->WriteNumeric(numeric); } /** Handle /WHOIS. @@ -59,11 +76,18 @@ class CommandWhois : public SplitCommand Events::ModuleEventProvider evprov; Events::ModuleEventProvider lineevprov; - void SplitChanList(WhoisContextImpl& whois, const std::string& cl); - void DoWhois(LocalUser* 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) @@ -75,7 +99,7 @@ class CommandWhois : public SplitCommand , lineevprov(parent, "event/whoisline") { Penalty = 2; - syntax = "{,}"; + syntax = "[] [,]+"; } /** Handle command. @@ -83,138 +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(WhoisContextImpl& whois, const std::string& cl) +class WhoisChanList { - std::string line(1, ':'); - std::string::size_type start, pos; + const SplitWhoisState& splitwhois; + WhoisChanListNumericBuilder num; + WhoisChanListNumericBuilder secretnum; + std::string prefixstr; - // ":server.name 319 source target " ... "\r\n" - const std::string::size_type maxlen = ServerInstance->Config->Limits.MaxLine - 10 - ServerInstance->Config->ServerName.length() - whois.GetTarget()->nick.length() - whois.GetSource()->nick.length(); + 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() + pos - start > maxlen) - { - // Erase last ' ' and send - line.erase(line.length()-1); - whois.SendLine(319, line); - line.erase(1); - } + } - line.append(cl, start, pos - start + 1); + void AddVisible(Membership* memb) + { + AddMember(memb, num); } - if (line.length() > 1) + void AddHidden(Membership* memb) { - // Erase last ' ' and send - line.erase(line.length()-1); - whois.SendLine(319, line); + AddMember(memb, splitwhois == SPLITWHOIS_NONE ? num : secretnum); } -} -void CommandWhois::DoWhois(LocalUser* user, User* dest, unsigned long signon, unsigned long idle) + void Flush(WhoisContextImpl& whois) + { + num.Flush(); + if (!secretnum.IsEmpty() && splitwhois == SPLITWHOIS_SPLITMSG) + whois.SendLine(RPL_CHANNELSMSG, "is on private/secret channels:"); + secretnum.Flush(); + } +}; + +void CommandWhois::SendChanList(WhoisContextImpl& whois) { - WhoisContextImpl whois(user, dest, lineevprov); + WhoisChanList chanlist(whois, splitwhois); - whois.SendLine(311, "%s %s * :%s", dest->ident.c_str(), dest->dhost.c_str(), dest->fullname.c_str()); - if (whois.IsSelfWhois() || user->HasPrivPermission("users/auspex")) + 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) { - whois.SendLine(378, ":is connecting from %s@%s %s", dest->ident.c_str(), dest->host.c_str(), dest->GetIPString().c_str()); - } + Membership* memb = *i; + Channel* c = memb->chan; - std::string cl = ChannelList(user, dest, false); - const ServerConfig::OperSpyWhoisState state = user->HasPrivPermission("users/auspex") ? ServerInstance->Config->OperSpyWhois : ServerConfig::SPYWHOIS_NONE; + // Anyone can view channels which are not private or secret. + if (!c->IsModeSet(privatemode) && !c->IsModeSet(secretmode)) + chanlist.AddVisible(memb); - if (state == ServerConfig::SPYWHOIS_SINGLEMSG) - cl.append(ChannelList(user, dest, true)); + // 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); + } - SplitChanList(whois, cl); + chanlist.Flush(whois); +} + +void CommandWhois::DoWhois(LocalUser* user, User* dest, time_t signon, unsigned long idle) +{ + WhoisContextImpl whois(user, dest, lineevprov); - if (state == ServerConfig::SPYWHOIS_SPLITMSG) + 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()) - { - whois.SendLine(336, ":is on private/secret channels:"); - SplitChanList(whois, 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 (!whois.IsSelfWhois() && !ServerInstance->Config->HideWhoisServer.empty() && !user->HasPrivPermission("servers/auspex")) + + SendChanList(whois); + + if (!whois.IsSelfWhois() && !ServerInstance->Config->HideServer.empty() && !user->HasPrivPermission("servers/auspex")) { - whois.SendLine(312, "%s :%s", ServerInstance->Config->HideWhoisServer.c_str(), ServerInstance->Config->Network.c_str()); + whois.SendLine(RPL_WHOISSERVER, ServerInstance->Config->HideServer, ServerInstance->Config->Network); } else { - whois.SendLine(312, "%s :%s", dest->server->GetName().c_str(), dest->server->GetDesc().c_str()); + whois.SendLine(RPL_WHOISSERVER, dest->server->GetName(), dest->server->GetDesc()); } if (dest->IsAway()) { - whois.SendLine(301, ":%s", dest->awaymsg.c_str()); + whois.SendLine(RPL_AWAY, dest->awaymsg); } if (dest->IsOper()) { - if (ServerInstance->Config->GenericOper) - whois.SendLine(313, ":is an IRC operator"); + if (genericoper) + whois.SendLine(RPL_WHOISOPERATOR, "is a server operator"); else - whois.SendLine(313, ":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, ":is using modes +%s %s", 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 { - whois.SendLine(379, ":is using modes +%s", dest->FormatModes()); + 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, "%lu %lu :seconds idle, signon time", idle, signon); + 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; @@ -228,24 +279,25 @@ 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; /* - * 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; @@ -256,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; @@ -274,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)