src/coremods/core_whois.cpp

   1 /*
   2  * InspIRCd -- Internet Relay Chat Daemon
   3  *
   4  *   Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org>
   5  *   Copyright (C) 2008 Thomas Stagner <aquanight@inspircd.org>
   6  *   Copyright (C) 2007 Robin Burchell <robin+git@viroteck.net>
   7  *
   8  * This file is part of InspIRCd.  InspIRCd is free software: you can
   9  * redistribute it and/or modify it under the terms of the GNU General Public
  10  * License as published by the Free Software Foundation, version 2.
  11  *
  12  * This program is distributed in the hope that it will be useful, but WITHOUT
  13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  14  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  15  * details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21
  22 #include "inspircd.h"
  23
  24 class WhoisContextImpl : public Whois::Context
  25 {
  26         Events::ModuleEventProvider& lineevprov;
  27
  28  public:
  29         WhoisContextImpl(LocalUser* src, User* targ, Events::ModuleEventProvider& evprov)
  30                 : Whois::Context(src, targ)
  31                 , lineevprov(evprov)
  32         {
  33         }
  34
  35         using Whois::Context::SendLine;
  36         void SendLine(unsigned int numeric, const std::string& text) CXX11_OVERRIDE;
  37 };
  38
  39 void WhoisContextImpl::SendLine(unsigned int numeric, const std::string& text)
  40 {
  41         std::string copy_text = target->nick;
  42         copy_text.push_back(' ');
  43         copy_text.append(text);
  44
  45         ModResult MOD_RESULT;
  46         FIRST_MOD_RESULT_CUSTOM(lineevprov, Whois::LineEventListener, OnWhoisLine, MOD_RESULT, (*this, numeric, copy_text));
  47
  48         if (MOD_RESULT != MOD_RES_DENY)
  49                 source->WriteNumeric(numeric, copy_text);
  50 }
  51
  52 /** Handle /WHOIS.
  53  */
  54 class CommandWhois : public SplitCommand
  55 {
  56         ChanModeReference secretmode;
  57         ChanModeReference privatemode;
  58         UserModeReference snomaskmode;
  59         Events::ModuleEventProvider evprov;
  60         Events::ModuleEventProvider lineevprov;
  61
  62         void SplitChanList(WhoisContextImpl& whois, const std::string& cl);
  63         void DoWhois(LocalUser* user, User* dest, unsigned long signon, unsigned long idle);
  64         std::string ChannelList(User* source, User* dest, bool spy);
  65
  66  public:
  67         /** Constructor for whois.
  68          */
  69         CommandWhois(Module* parent)
  70                 : SplitCommand(parent, "WHOIS", 1)
  71                 , secretmode(parent, "secret")
  72                 , privatemode(parent, "private")
  73                 , snomaskmode(parent, "snomask")
  74                 , evprov(parent, "event/whois")
  75                 , lineevprov(parent, "event/whoisline")
  76         {
  77                 Penalty = 2;
  78                 syntax = "<nick>{,<nick>}";
  79         }
  80
  81         /** Handle command.
  82          * @param parameters The parameters to the command
  83          * @param user The user issuing the command
  84          * @return A value from CmdResult to indicate command success or failure.
  85          */
  86         CmdResult HandleLocal(const std::vector<std::string>& parameters, LocalUser* user);
  87         CmdResult HandleRemote(const std::vector<std::string>& parameters, RemoteUser* target);
  88 };
  89
  90 std::string CommandWhois::ChannelList(User* source, User* dest, bool spy)
  91 {
  92         std::string list;
  93
  94         for (User::ChanList::iterator i = dest->chans.begin(); i != dest->chans.end(); i++)
  95         {
  96                 Membership* memb = *i;
  97                 Channel* c = memb->chan;
  98                 /* If the target is the sender, neither +p nor +s is set, or
  99                  * the channel contains the user, it is not a spy channel
 100                  */
 101                 if (spy != (source == dest || !(c->IsModeSet(privatemode) || c->IsModeSet(secretmode)) || c->HasUser(source)))
 102                 {
 103                         char prefix = memb->GetPrefixChar();
 104                         if (prefix)
 105                                 list.push_back(prefix);
 106                         list.append(c->name).push_back(' ');
 107                 }
 108         }
 109
 110         return list;
 111 }
 112
 113 void CommandWhois::SplitChanList(WhoisContextImpl& whois, const std::string& cl)
 114 {
 115         std::string line;
 116         std::ostringstream prefix;
 117         std::string::size_type start, pos;
 118
 119         prefix << ":";
 120         line = prefix.str();
 121         const std::string::size_type namelen = ServerInstance->Config->ServerName.length() + 6 + whois.GetTarget()->nick.length() + 1;
 122
 123         for (start = 0; (pos = cl.find(' ', start)) != std::string::npos; start = pos+1)
 124         {
 125                 if (line.length() + namelen + pos - start > 510)
 126                 {
 127                         whois.SendLine(319, line);
 128                         line = prefix.str();
 129                 }
 130
 131                 line.append(cl, start, pos - start + 1);
 132         }
 133
 134         if (line.length() != prefix.str().length())
 135         {
 136                 whois.SendLine(319, line);
 137         }
 138 }
 139
 140 void CommandWhois::DoWhois(LocalUser* user, User* dest, unsigned long signon, unsigned long idle)
 141 {
 142         WhoisContextImpl whois(user, dest, lineevprov);
 143
 144         whois.SendLine(311, "%s %s * :%s", dest->ident.c_str(), dest->dhost.c_str(), dest->fullname.c_str());
 145         if (whois.IsSelfWhois() || user->HasPrivPermission("users/auspex"))
 146         {
 147                 whois.SendLine(378, ":is connecting from %s@%s %s", dest->ident.c_str(), dest->host.c_str(), dest->GetIPString().c_str());
 148         }
 149
 150         std::string cl = ChannelList(user, dest, false);
 151         const ServerConfig::OperSpyWhoisState state = user->HasPrivPermission("users/auspex") ? ServerInstance->Config->OperSpyWhois : ServerConfig::SPYWHOIS_NONE;
 152
 153         if (state == ServerConfig::SPYWHOIS_SINGLEMSG)
 154                 cl.append(ChannelList(user, dest, true));
 155
 156         SplitChanList(whois, cl);
 157
 158         if (state == ServerConfig::SPYWHOIS_SPLITMSG)
 159         {
 160                 std::string scl = ChannelList(user, dest, true);
 161                 if (scl.length())
 162                 {
 163                         whois.SendLine(336, ":is on private/secret channels:");
 164                         SplitChanList(whois, scl);
 165                 }
 166         }
 167         if (!whois.IsSelfWhois() && !ServerInstance->Config->HideWhoisServer.empty() && !user->HasPrivPermission("servers/auspex"))
 168         {
 169                 whois.SendLine(312, "%s :%s", ServerInstance->Config->HideWhoisServer.c_str(), ServerInstance->Config->Network.c_str());
 170         }
 171         else
 172         {
 173                 whois.SendLine(312, "%s :%s", dest->server->GetName().c_str(), dest->server->GetDesc().c_str());
 174         }
 175
 176         if (dest->IsAway())
 177         {
 178                 whois.SendLine(301, ":%s", dest->awaymsg.c_str());
 179         }
 180
 181         if (dest->IsOper())
 182         {
 183                 if (ServerInstance->Config->GenericOper)
 184                         whois.SendLine(313, ":is an IRC operator");
 185                 else
 186                         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());
 187         }
 188
 189         if (whois.IsSelfWhois() || user->HasPrivPermission("users/auspex"))
 190         {
 191                 if (dest->IsModeSet(snomaskmode))
 192                 {
 193                         whois.SendLine(379, ":is using modes +%s %s", dest->FormatModes(), snomaskmode->GetUserParameter(dest).c_str());
 194                 }
 195                 else
 196                 {
 197                         whois.SendLine(379, ":is using modes +%s", dest->FormatModes());
 198                 }
 199         }
 200
 201         FOREACH_MOD_CUSTOM(evprov, Whois::EventListener, OnWhois, (whois));
 202
 203         /*
 204          * We only send these if we've been provided them. That is, if hidewhois is turned off, and user is local, or
 205          * if remote whois is queried, too. This is to keep the user hidden, and also since you can't reliably tell remote time. -- w00t
 206          */
 207         if ((idle) || (signon))
 208         {
 209                 whois.SendLine(317, "%lu %lu :seconds idle, signon time", idle, signon);
 210         }
 211
 212         whois.SendLine(318, ":End of /WHOIS list.");
 213 }
 214
 215 CmdResult CommandWhois::HandleRemote(const std::vector<std::string>& parameters, RemoteUser* target)
 216 {
 217         if (parameters.size() < 2)
 218                 return CMD_FAILURE;
 219
 220         User* user = ServerInstance->FindUUID(parameters[0]);
 221         if (!user)
 222                 return CMD_FAILURE;
 223
 224         // User doing the whois must be on this server
 225         LocalUser* localuser = IS_LOCAL(user);
 226         if (!localuser)
 227                 return CMD_FAILURE;
 228
 229         unsigned long idle = ConvToInt(parameters.back());
 230         DoWhois(localuser, target, target->signon, idle);
 231
 232         return CMD_SUCCESS;
 233 }
 234
 235 CmdResult CommandWhois::HandleLocal(const std::vector<std::string>& parameters, LocalUser* user)
 236 {
 237         User *dest;
 238         int userindex = 0;
 239         unsigned long idle = 0, signon = 0;
 240
 241         if (CommandParser::LoopCall(user, this, parameters, 0))
 242                 return CMD_SUCCESS;
 243
 244         /*
 245          * If 2 paramters are specified (/whois nick nick), ignore the first one like spanningtree
 246          * does, and use the second one, otherwise, use the only paramter. -- djGrrr
 247          */
 248         if (parameters.size() > 1)
 249                 userindex = 1;
 250
 251         dest = ServerInstance->FindNickOnly(parameters[userindex]);
 252
 253         if ((dest) && (dest->registered == REG_ALL))
 254         {
 255                 /*
 256                  * Okay. Umpteenth attempt at doing this, so let's re-comment...
 257                  * For local users (/w localuser), we show idletime if hidewhois is disabled
 258                  * For local users (/w localuser localuser), we always show idletime, hence parameters.size() > 1 check.
 259                  * For remote users (/w remoteuser), we do NOT show idletime
 260                  * For remote users (/w remoteuser remoteuser), spanningtree will handle calling do_whois, so we can ignore this case.
 261                  * Thanks to djGrrr for not being impatient while I have a crap day coding. :p -- w00t
 262                  */
 263                 LocalUser* localuser = IS_LOCAL(dest);
 264                 if (localuser && (ServerInstance->Config->HideWhoisServer.empty() || parameters.size() > 1))
 265                 {
 266                         idle = labs((long)((localuser->idle_lastmsg)-ServerInstance->Time()));
 267                         signon = dest->signon;
 268                 }
 269
 270                 DoWhois(user,dest,signon,idle);
 271         }
 272         else
 273         {
 274                 /* no such nick/channel */
 275                 user->WriteNumeric(ERR_NOSUCHNICK, "%s :No such nick/channel", !parameters[userindex].empty() ? parameters[userindex].c_str() : "*");
 276                 user->WriteNumeric(RPL_ENDOFWHOIS, "%s :End of /WHOIS list.", !parameters[userindex].empty() ? parameters[userindex].c_str() : "*");
 277                 return CMD_FAILURE;
 278         }
 279
 280         return CMD_SUCCESS;
 281 }
 282
 283 COMMAND_INIT(CommandWhois)