modules/m_whois.c

   1 /*
   2  *  ircd-ratbox: A slightly useful ircd.
   3  *  m_whois.c: Shows who a user is.
   4  *
   5  *  Copyright (C) 1990 Jarkko Oikarinen and University of Oulu, Co Center
   6  *  Copyright (C) 1996-2002 Hybrid Development Team
   7  *  Copyright (C) 2002-2005 ircd-ratbox development team
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
  22  *  USA
  23  */
  24
  25 #include "stdinc.h"
  26 #include "client.h"
  27 #include "hash.h"
  28 #include "channel.h"
  29 #include "hash.h"
  30 #include "ircd.h"
  31 #include "numeric.h"
  32 #include "s_conf.h"
  33 #include "s_serv.h"
  34 #include "send.h"
  35 #include "match.h"
  36 #include "s_conf.h"
  37 #include "logger.h"
  38 #include "msg.h"
  39 #include "parse.h"
  40 #include "modules.h"
  41 #include "hook.h"
  42 #include "s_newconf.h"
  43 #include "ratelimit.h"
  44 #include "s_assert.h"
  45
  46 static const char whois_desc[] =
  47         "Provides the WHOIS command to display information about a user";
  48
  49 static void do_whois(struct Client *client_p, struct Client *source_p, int parc, const char *parv[]);
  50 static void single_whois(struct Client *source_p, struct Client *target_p, int operspy);
  51
  52 static void m_whois(struct MsgBuf *, struct Client *, struct Client *, int, const char **);
  53 static void ms_whois(struct MsgBuf *, struct Client *, struct Client *, int, const char **);
  54
  55 struct Message whois_msgtab = {
  56         "WHOIS", 0, 0, 0, 0,
  57         {mg_unreg, {m_whois, 2}, {ms_whois, 2}, mg_ignore, mg_ignore, {m_whois, 2}}
  58 };
  59
  60 int doing_whois_hook;
  61 int doing_whois_global_hook;
  62 int doing_whois_channel_visibility_hook;
  63 int doing_whois_show_idle_hook;
  64
  65 mapi_clist_av1 whois_clist[] = { &whois_msgtab, NULL };
  66 mapi_hlist_av1 whois_hlist[] = {
  67         { "doing_whois",                        &doing_whois_hook },
  68         { "doing_whois_global",                 &doing_whois_global_hook },
  69         { "doing_whois_channel_visibility",     &doing_whois_channel_visibility_hook },
  70         { "doing_whois_show_idle",              &doing_whois_show_idle_hook },
  71         { NULL, NULL }
  72 };
  73
  74 DECLARE_MODULE_AV2(whois, NULL, NULL, whois_clist, whois_hlist, NULL, NULL, NULL, whois_desc);
  75
  76 /*
  77  * m_whois
  78  *      parv[1] = nickname masklist
  79  */
  80 static void
  81 m_whois(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
  82 {
  83         static time_t last_used = 0;
  84
  85         if(parc > 2)
  86         {
  87                 if(EmptyString(parv[2]))
  88                 {
  89                         sendto_one(source_p, form_str(ERR_NONICKNAMEGIVEN),
  90                                         me.name, source_p->name);
  91                         return;
  92                 }
  93
  94                 if(!IsOperGeneral(source_p))
  95                 {
  96                         /* seeing as this is going across servers, we should limit it */
  97                         if((last_used + ConfigFileEntry.pace_wait_simple) > rb_current_time() || !ratelimit_client(source_p, 2))
  98                         {
  99                                 sendto_one(source_p, form_str(RPL_LOAD2HI),
 100                                            me.name, source_p->name, "WHOIS");
 101                                 sendto_one_numeric(source_p, RPL_ENDOFWHOIS,
 102                                                    form_str(RPL_ENDOFWHOIS), parv[2]);
 103                                 return;
 104                         }
 105                         else
 106                                 last_used = rb_current_time();
 107                 }
 108
 109                 if(hunt_server(client_p, source_p, ":%s WHOIS %s :%s", 1, parc, parv) !=
 110                    HUNTED_ISME)
 111                         return;
 112
 113                 parv[1] = parv[2];
 114
 115         }
 116         do_whois(client_p, source_p, parc, parv);
 117 }
 118
 119 /*
 120  * ms_whois
 121  *      parv[1] = server to reply
 122  *      parv[2] = nickname to whois
 123  */
 124 static void
 125 ms_whois(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
 126 {
 127         struct Client *target_p;
 128
 129         /* note: early versions of ratbox allowed users to issue a remote
 130          * whois with a blank parv[2], so we cannot treat it as a protocol
 131          * violation. --anfl
 132          */
 133         if(parc < 3 || EmptyString(parv[2]))
 134         {
 135                 sendto_one(source_p, form_str(ERR_NONICKNAMEGIVEN),
 136                                 me.name, source_p->name);
 137                 return;
 138         }
 139
 140         /* check if parv[1] exists */
 141         if((target_p = find_client(parv[1])) == NULL)
 142         {
 143                 sendto_one_numeric(source_p, ERR_NOSUCHSERVER,
 144                                    form_str(ERR_NOSUCHSERVER),
 145                                    IsDigit(parv[1][0]) ? "*" : parv[1]);
 146                 return;
 147         }
 148
 149         /* if parv[1] isnt my client, or me, someone else is supposed
 150          * to be handling the request.. so send it to them
 151          */
 152         if(!MyClient(target_p) && !IsMe(target_p))
 153         {
 154                 sendto_one(target_p, ":%s WHOIS %s :%s",
 155                            get_id(source_p, target_p),
 156                            get_id(target_p, target_p), parv[2]);
 157                 return;
 158         }
 159
 160         /* ok, the target is either us, or a client on our server, so perform the whois
 161          * but first, parv[1] == server to perform the whois on, parv[2] == person
 162          * to whois, so make parv[1] = parv[2] so do_whois is ok -- fl_
 163          */
 164         parv[1] = parv[2];
 165         do_whois(client_p, source_p, parc, parv);
 166 }
 167
 168 /* do_whois
 169  *
 170  * inputs       - pointer to
 171  * output       -
 172  * side effects -
 173  */
 174 static void
 175 do_whois(struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
 176 {
 177         struct Client *target_p;
 178         char *nick;
 179         char *p = NULL;
 180         int operspy = 0;
 181
 182         nick = LOCAL_COPY(parv[1]);
 183         if((p = strchr(nick, ',')))
 184                 *p = '\0';
 185
 186         if(IsOperSpy(source_p) && *nick == '!')
 187         {
 188                 operspy = 1;
 189                 nick++;
 190         }
 191
 192         target_p = find_named_person(nick);
 193         if(target_p != NULL)
 194         {
 195                 if(operspy)
 196                 {
 197                         char buffer[BUFSIZE];
 198
 199                         snprintf(buffer, sizeof(buffer), "%s!%s@%s %s",
 200                                 target_p->name, target_p->username,
 201                                 target_p->host, target_p->servptr->name);
 202                         report_operspy(source_p, "WHOIS", buffer);
 203                 }
 204
 205                 single_whois(source_p, target_p, operspy);
 206         }
 207         else
 208                 sendto_one_numeric(source_p, ERR_NOSUCHNICK,
 209                                    form_str(ERR_NOSUCHNICK),
 210                                    nick);
 211
 212         sendto_one_numeric(source_p, RPL_ENDOFWHOIS,
 213                            form_str(RPL_ENDOFWHOIS), parv[1]);
 214 }
 215
 216 /*
 217  * single_whois()
 218  *
 219  * Inputs       - source_p client to report to
 220  *              - target_p client to report on
 221  * Output       - if found return 1
 222  * Side Effects - do a single whois on given client
 223  *                writing results to source_p
 224  */
 225 static void
 226 single_whois(struct Client *source_p, struct Client *target_p, int operspy)
 227 {
 228         char buf[BUFSIZE];
 229         hook_data_client hdata;
 230         struct sockaddr_in ip4;
 231
 232         if(target_p->user == NULL)
 233         {
 234                 s_assert(0);
 235                 return;
 236         }
 237
 238         sendto_one_numeric(source_p, RPL_WHOISUSER, form_str(RPL_WHOISUSER),
 239                            target_p->name, target_p->username,
 240                            target_p->host, target_p->info);
 241
 242         send_multiline_init(source_p, " ", form_str(RPL_WHOISCHANNELS),
 243                                     get_id(&me, source_p), get_id(source_p, source_p),
 244                                     target_p->name);
 245
 246         /* Make sure it won't overflow when sending it to the client
 247          * in full names; note that serverhiding may require more space
 248          * for a different server name (not done here) -- jilles
 249          */
 250         send_multiline_remote_pad(source_p, &me);
 251         send_multiline_remote_pad(source_p, source_p);
 252
 253         hdata.client = source_p;
 254         hdata.target = target_p;
 255
 256         if (!IsService(target_p))
 257         {
 258                 hook_data_channel_visibility hdata_vis;
 259                 rb_dlink_node *ps, *pt;
 260                 struct Channel *chptr;
 261                 struct membership *ms, *mt;
 262
 263                 hdata_vis.client = source_p;
 264                 hdata_vis.target = target_p;
 265
 266                 ITER_COMM_CHANNELS(ps, pt, source_p->user->channel.head, target_p->user->channel.head, ms, mt, chptr)
 267                 {
 268                         if (mt == NULL)
 269                                 continue;
 270
 271                         hdata_vis.chptr = chptr;
 272                         hdata_vis.clientms = ms;
 273                         hdata_vis.targetms = mt;
 274                         hdata_vis.approved = ms != NULL || PubChannel(chptr);
 275
 276                         call_hook(doing_whois_channel_visibility_hook, &hdata_vis);
 277
 278                         if(hdata_vis.approved || operspy)
 279                         {
 280                                 send_multiline_item(source_p, "%s%s%s",
 281                                                 hdata_vis.approved ? "" : "!",
 282                                                 find_channel_status(mt, 1),
 283                                                 chptr->chname);
 284                         }
 285                 }
 286         }
 287
 288         send_multiline_fini(source_p, NULL);
 289
 290         sendto_one_numeric(source_p, RPL_WHOISSERVER, form_str(RPL_WHOISSERVER),
 291                            target_p->name, target_p->servptr->name,
 292                            target_p->servptr->info);
 293
 294         if(target_p->user->away)
 295                 sendto_one_numeric(source_p, RPL_AWAY, form_str(RPL_AWAY),
 296                                    target_p->name, target_p->user->away);
 297
 298         char *s = NULL;
 299         if (IsService(target_p))
 300         {
 301                 s = ConfigFileEntry.servicestring;
 302         }
 303         if (!EmptyString(target_p->user->opername) && IsOper(target_p))
 304         {
 305                 if (target_p == source_p || HasPrivilege(source_p, "oper:privs"))
 306                 {
 307                         const char *privset = "(missing)";
 308                         if (target_p->user->privset != NULL)
 309                                 privset = target_p->user->privset->name;
 310                         snprintf(buf, sizeof buf, "is opered as %s, privset %s", target_p->user->opername, privset);
 311                         s = buf;
 312                 }
 313                 else if (IsOper(source_p) && SeesOper(target_p, source_p))
 314                 {
 315                         snprintf(buf, sizeof buf, "is opered as %s", target_p->user->opername);
 316                         s = buf;
 317                 }
 318                 else if (!ConfigFileEntry.hide_opers_in_whois && SeesOper(target_p, source_p))
 319                 {
 320                         s = IsAdmin(target_p) ? GlobalSetOptions.adminstring :
 321                             GlobalSetOptions.operstring;
 322                 }
 323         }
 324         if (s != NULL)
 325         {
 326                 sendto_one_numeric(source_p, RPL_WHOISOPERATOR, form_str(RPL_WHOISOPERATOR),
 327                                 target_p->name, s);
 328         }
 329
 330         if(IsSecureClient(target_p))
 331         {
 332                 char cbuf[256] = "is using a secure connection";
 333
 334                 if (MyClient(target_p) && target_p->localClient->cipher_string != NULL &&
 335                                 (!ConfigFileEntry.tls_ciphers_oper_only || source_p == target_p || IsOper(source_p)))
 336                         rb_snprintf_append(cbuf, sizeof(cbuf), " [%s]", target_p->localClient->cipher_string);
 337
 338                 sendto_one_numeric(source_p, RPL_WHOISSECURE, form_str(RPL_WHOISSECURE),
 339                                    target_p->name, cbuf);
 340                 if((source_p == target_p || IsOperGeneral(source_p)) &&
 341                                 target_p->certfp != NULL)
 342                         sendto_one_numeric(source_p, RPL_WHOISCERTFP,
 343                                         form_str(RPL_WHOISCERTFP),
 344                                         target_p->name, target_p->certfp);
 345         }
 346
 347         if(MyClient(target_p))
 348         {
 349                 if (IsDynSpoof(target_p) && (HasPrivilege(source_p, "auspex:hostname") || source_p == target_p))
 350                 {
 351                         /* trick here: show a nonoper their own IP if
 352                          * dynamic spoofed but not if auth{} spoofed
 353                          * -- jilles */
 354                         ClearDynSpoof(target_p);
 355                         sendto_one_numeric(source_p, RPL_WHOISHOST,
 356                                            form_str(RPL_WHOISHOST),
 357                                            target_p->name, target_p->orighost,
 358                                            show_ip(source_p, target_p) ? target_p->sockhost : "255.255.255.255");
 359                         SetDynSpoof(target_p);
 360                 }
 361                 else if(ConfigFileEntry.use_whois_actually && show_ip(source_p, target_p))
 362                         sendto_one_numeric(source_p, RPL_WHOISACTUALLY,
 363                                            form_str(RPL_WHOISACTUALLY),
 364                                            target_p->name, target_p->sockhost);
 365
 366                 if (GET_SS_FAMILY(&target_p->localClient->ip) == AF_INET6 &&
 367                                 (show_ip(source_p, target_p) ||
 368                                  (source_p == target_p && !IsIPSpoof(target_p))) &&
 369                                 rb_ipv4_from_ipv6((struct sockaddr_in6 *)&target_p->localClient->ip, &ip4))
 370                 {
 371                         rb_inet_ntop_sock((struct sockaddr *)&ip4,
 372                                         buf, sizeof buf);
 373                         sendto_one_numeric(source_p, RPL_WHOISTEXT,
 374                                         "%s :Underlying IPv4 is %s",
 375                                         target_p->name, buf);
 376                 }
 377
 378                 /* fire the doing_whois_show_idle hook to allow modules to tell us whether to show the idle time */
 379                 hook_data_client_approval hdata_showidle;
 380
 381                 hdata_showidle.client = source_p;
 382                 hdata_showidle.target = target_p;
 383                 hdata_showidle.approved = WHOIS_IDLE_SHOW;
 384
 385                 call_hook(doing_whois_show_idle_hook, &hdata_showidle);
 386
 387                 sendto_one_numeric(source_p, RPL_WHOISIDLE, form_str(RPL_WHOISIDLE),
 388                            target_p->name,
 389                            hdata_showidle.approved ? (long)(rb_current_time() - target_p->localClient->last) : 0,
 390                            (unsigned long)target_p->localClient->firsttime);
 391
 392                 if (hdata_showidle.approved == WHOIS_IDLE_AUSPEX || hdata_showidle.approved == WHOIS_IDLE_HIDE)
 393                         /* if the target has hidden their idle time, notify the source */
 394                         sendto_one_numeric(source_p, RPL_WHOISTEXT, form_str(RPL_WHOISTEXT), target_p->name, "is using a private idle time");
 395         }
 396         else
 397         {
 398                 if (IsDynSpoof(target_p) && (HasPrivilege(source_p, "auspex:hostname") || source_p == target_p))
 399                 {
 400                         ClearDynSpoof(target_p);
 401                         sendto_one_numeric(source_p, RPL_WHOISHOST,
 402                                            form_str(RPL_WHOISHOST),
 403                                            target_p->name, target_p->orighost,
 404                                            show_ip(source_p, target_p) && !EmptyString(target_p->sockhost) && strcmp(target_p->sockhost, "0")? target_p->sockhost : "255.255.255.255");
 405                         SetDynSpoof(target_p);
 406                 }
 407                 else if(ConfigFileEntry.use_whois_actually && show_ip(source_p, target_p) &&
 408                    !EmptyString(target_p->sockhost) && strcmp(target_p->sockhost, "0"))
 409                 {
 410                         sendto_one_numeric(source_p, RPL_WHOISACTUALLY,
 411                                            form_str(RPL_WHOISACTUALLY),
 412                                            target_p->name, target_p->sockhost);
 413
 414                 }
 415         }
 416
 417         /* doing_whois_hook must only be called for local clients,
 418          * doing_whois_global_hook must only be called for local targets
 419          */
 420         /* it is important that these are called *before* RPL_ENDOFWHOIS is
 421          * sent, services compatibility code depends on it. --anfl
 422          */
 423         if(MyClient(source_p))
 424                 call_hook(doing_whois_hook, &hdata);
 425         else
 426                 call_hook(doing_whois_global_hook, &hdata);
 427 }