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(1, ':');
 116         std::string::size_type start, pos;
 117
 118         const std::string::size_type namelen = ServerInstance->Config->ServerName.length() + 6 + whois.GetTarget()->nick.length() + 1;
 119
 120         for (start = 0; (pos = cl.find(' ', start)) != std::string::npos; start = pos+1)
 121         {
 122                 if (line.length() + namelen + pos - start > 510)
 123                 {
 124                         whois.SendLine(319, line);
 125                         line.erase(1);
 126                 }
 127
 128                 line.append(cl, start, pos - start + 1);
 129         }
 130
 131         if (line.length() > 1)
 132         {
 133                 whois.SendLine(319, line);
 134         }
 135 }
 136
 137 void CommandWhois::DoWhois(LocalUser* user, User* dest, unsigned long signon, unsigned long idle)
 138 {
 139         WhoisContextImpl whois(user, dest, lineevprov);
 140
 141         whois.SendLine(311, "%s %s * :%s", dest->ident.c_str(), dest->dhost.c_str(), dest->fullname.c_str());
 142         if (whois.IsSelfWhois() || user->HasPrivPermission("users/auspex"))
 143         {
 144                 whois.SendLine(378, ":is connecting from %s@%s %s", dest->ident.c_str(), dest->host.c_str(), dest->GetIPString().c_str());
 145         }
 146
 147         std::string cl = ChannelList(user, dest, false);
 148         const ServerConfig::OperSpyWhoisState state = user->HasPrivPermission("users/auspex") ? ServerInstance->Config->OperSpyWhois : ServerConfig::SPYWHOIS_NONE;
 149
 150         if (state == ServerConfig::SPYWHOIS_SINGLEMSG)
 151                 cl.append(ChannelList(user, dest, true));
 152
 153         SplitChanList(whois, cl);
 154
 155         if (state == ServerConfig::SPYWHOIS_SPLITMSG)
 156         {
 157                 std::string scl = ChannelList(user, dest, true);
 158                 if (scl.length())
 159                 {
 160                         whois.SendLine(336, ":is on private/secret channels:");
 161                         SplitChanList(whois, scl);
 162                 }
 163         }
 164         if (!whois.IsSelfWhois() && !ServerInstance->Config->HideWhoisServer.empty() && !user->HasPrivPermission("servers/auspex"))
 165         {
 166                 whois.SendLine(312, "%s :%s", ServerInstance->Config->HideWhoisServer.c_str(), ServerInstance->Config->Network.c_str());
 167         }
 168         else
 169         {
 170                 whois.SendLine(312, "%s :%s", dest->server->GetName().c_str(), dest->server->GetDesc().c_str());
 171         }
 172
 173         if (dest->IsAway())
 174         {
 175                 whois.SendLine(301, ":%s", dest->awaymsg.c_str());
 176         }
 177
 178         if (dest->IsOper())
 179         {
 180                 if (ServerInstance->Config->GenericOper)
 181                         whois.SendLine(313, ":is an IRC operator");
 182                 else
 183                         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());
 184         }
 185
 186         if (whois.IsSelfWhois() || user->HasPrivPermission("users/auspex"))
 187         {
 188                 if (dest->IsModeSet(snomaskmode))
 189                 {
 190                         whois.SendLine(379, ":is using modes +%s %s", dest->FormatModes(), snomaskmode->GetUserParameter(dest).c_str());
 191                 }
 192                 else
 193                 {
 194                         whois.SendLine(379, ":is using modes +%s", dest->FormatModes());
 195                 }
 196         }
 197
 198         FOREACH_MOD_CUSTOM(evprov, Whois::EventListener, OnWhois, (whois));
 199
 200         /*
 201          * We only send these if we've been provided them. That is, if hidewhois is turned off, and user is local, or
 202          * if remote whois is queried, too. This is to keep the user hidden, and also since you can't reliably tell remote time. -- w00t
 203          */
 204         if ((idle) || (signon))
 205         {
 206                 whois.SendLine(317, "%lu %lu :seconds idle, signon time", idle, signon);
 207         }
 208
 209         whois.SendLine(318, ":End of /WHOIS list.");
 210 }
 211
 212 CmdResult CommandWhois::HandleRemote(const std::vector<std::string>& parameters, RemoteUser* target)
 213 {
 214         if (parameters.size() < 2)
 215                 return CMD_FAILURE;
 216
 217         User* user = ServerInstance->FindUUID(parameters[0]);
 218         if (!user)
 219                 return CMD_FAILURE;
 220
 221         // User doing the whois must be on this server
 222         LocalUser* localuser = IS_LOCAL(user);
 223         if (!localuser)
 224                 return CMD_FAILURE;
 225
 226         unsigned long idle = ConvToInt(parameters.back());
 227         DoWhois(localuser, target, target->signon, idle);
 228
 229         return CMD_SUCCESS;
 230 }
 231
 232 CmdResult CommandWhois::HandleLocal(const std::vector<std::string>& parameters, LocalUser* user)
 233 {
 234         User *dest;
 235         int userindex = 0;
 236         unsigned long idle = 0, signon = 0;
 237
 238         if (CommandParser::LoopCall(user, this, parameters, 0))
 239                 return CMD_SUCCESS;
 240
 241         /*
 242          * If 2 paramters are specified (/whois nick nick), ignore the first one like spanningtree
 243          * does, and use the second one, otherwise, use the only paramter. -- djGrrr
 244          */
 245         if (parameters.size() > 1)
 246                 userindex = 1;
 247
 248         dest = ServerInstance->FindNickOnly(parameters[userindex]);
 249
 250         if ((dest) && (dest->registered == REG_ALL))
 251         {
 252                 /*
 253                  * Okay. Umpteenth attempt at doing this, so let's re-comment...
 254                  * For local users (/w localuser), we show idletime if hidewhois is disabled
 255                  * For local users (/w localuser localuser), we always show idletime, hence parameters.size() > 1 check.
 256                  * For remote users (/w remoteuser), we do NOT show idletime
 257                  * For remote users (/w remoteuser remoteuser), spanningtree will handle calling do_whois, so we can ignore this case.
 258                  * Thanks to djGrrr for not being impatient while I have a crap day coding. :p -- w00t
 259                  */
 260                 LocalUser* localuser = IS_LOCAL(dest);
 261                 if (localuser && (ServerInstance->Config->HideWhoisServer.empty() || parameters.size() > 1))
 262                 {
 263                         idle = labs((long)((localuser->idle_lastmsg)-ServerInstance->Time()));
 264                         signon = dest->signon;
 265                 }
 266
 267                 DoWhois(user,dest,signon,idle);
 268         }
 269         else
 270         {
 271                 /* no such nick/channel */
 272                 user->WriteNumeric(ERR_NOSUCHNICK, "%s :No such nick/channel", !parameters[userindex].empty() ? parameters[userindex].c_str() : "*");
 273                 user->WriteNumeric(RPL_ENDOFWHOIS, "%s :End of /WHOIS list.", !parameters[userindex].empty() ? parameters[userindex].c_str() : "*");
 274                 return CMD_FAILURE;
 275         }
 276
 277         return CMD_SUCCESS;
 278 }
 279
 280 COMMAND_INIT(CommandWhois)