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 "common.h"
  27 #include "client.h"
  28 #include "hash.h"
  29 #include "channel.h"
  30 #include "hash.h"
  31 #include "ircd.h"
  32 #include "numeric.h"
  33 #include "s_conf.h"
  34 #include "s_serv.h"
  35 #include "send.h"
  36 #include "match.h"
  37 #include "s_conf.h"
  38 #include "logger.h"
  39 #include "msg.h"
  40 #include "parse.h"
  41 #include "modules.h"
  42 #include "hook.h"
  43 #include "s_newconf.h"
  44 #include "ipv4_from_ipv6.h"
  45 #include "ratelimit.h"
  46 #include "s_assert.h"
  47
  48 static const char whois_desc[] =
  49         "Provides the WHOIS command to display information about a user";
  50
  51 static void do_whois(struct Client *client_p, struct Client *source_p, int parc, const char *parv[]);
  52 static void single_whois(struct Client *source_p, struct Client *target_p, int operspy);
  53
  54 static int m_whois(struct MsgBuf *, struct Client *, struct Client *, int, const char **);
  55 static int ms_whois(struct MsgBuf *, struct Client *, struct Client *, int, const char **);
  56
  57 struct Message whois_msgtab = {
  58         "WHOIS", 0, 0, 0, 0,
  59         {mg_unreg, {m_whois, 2}, {ms_whois, 2}, mg_ignore, mg_ignore, {m_whois, 2}}
  60 };
  61
  62 int doing_whois_hook;
  63 int doing_whois_global_hook;
  64 int doing_whois_channel_visibility_hook;
  65
  66 mapi_clist_av1 whois_clist[] = { &whois_msgtab, NULL };
  67 mapi_hlist_av1 whois_hlist[] = {
  68         { "doing_whois",                        &doing_whois_hook },
  69         { "doing_whois_global",                 &doing_whois_global_hook },
  70         { "doing_whois_channel_visibility",     &doing_whois_channel_visibility_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 int
  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 0;
  92                 }
  93
  94                 if(!IsOper(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 0;
 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 0;
 112
 113                 parv[1] = parv[2];
 114
 115         }
 116         do_whois(client_p, source_p, parc, parv);
 117
 118         return 0;
 119 }
 120
 121 /*
 122  * ms_whois
 123  *      parv[1] = server to reply
 124  *      parv[2] = nickname to whois
 125  */
 126 static int
 127 ms_whois(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
 128 {
 129         struct Client *target_p;
 130
 131         /* note: early versions of ratbox allowed users to issue a remote
 132          * whois with a blank parv[2], so we cannot treat it as a protocol
 133          * violation. --anfl
 134          */
 135         if(parc < 3 || EmptyString(parv[2]))
 136         {
 137                 sendto_one(source_p, form_str(ERR_NONICKNAMEGIVEN),
 138                                 me.name, source_p->name);
 139                 return 0;
 140         }
 141
 142         /* check if parv[1] exists */
 143         if((target_p = find_client(parv[1])) == NULL)
 144         {
 145                 sendto_one_numeric(source_p, ERR_NOSUCHSERVER,
 146                                    form_str(ERR_NOSUCHSERVER),
 147                                    IsDigit(parv[1][0]) ? "*" : parv[1]);
 148                 return 0;
 149         }
 150
 151         /* if parv[1] isnt my client, or me, someone else is supposed
 152          * to be handling the request.. so send it to them
 153          */
 154         if(!MyClient(target_p) && !IsMe(target_p))
 155         {
 156                 sendto_one(target_p, ":%s WHOIS %s :%s",
 157                            get_id(source_p, target_p),
 158                            get_id(target_p, target_p), parv[2]);
 159                 return 0;
 160         }
 161
 162         /* ok, the target is either us, or a client on our server, so perform the whois
 163          * but first, parv[1] == server to perform the whois on, parv[2] == person
 164          * to whois, so make parv[1] = parv[2] so do_whois is ok -- fl_
 165          */
 166         parv[1] = parv[2];
 167         do_whois(client_p, source_p, parc, parv);
 168
 169         return 0;
 170 }
 171
 172 /* do_whois
 173  *
 174  * inputs       - pointer to
 175  * output       -
 176  * side effects -
 177  */
 178 static void
 179 do_whois(struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
 180 {
 181         struct Client *target_p;
 182         char *nick;
 183         char *p = NULL;
 184         int operspy = 0;
 185
 186         nick = LOCAL_COPY(parv[1]);
 187         if((p = strchr(nick, ',')))
 188                 *p = '\0';
 189
 190         if(IsOperSpy(source_p) && *nick == '!')
 191         {
 192                 operspy = 1;
 193                 nick++;
 194         }
 195
 196         target_p = find_named_person(nick);
 197         if(target_p != NULL)
 198         {
 199                 if(operspy)
 200                 {
 201                         char buffer[BUFSIZE];
 202
 203                         snprintf(buffer, sizeof(buffer), "%s!%s@%s %s",
 204                                 target_p->name, target_p->username,
 205                                 target_p->host, target_p->servptr->name);
 206                         report_operspy(source_p, "WHOIS", buffer);
 207                 }
 208
 209                 single_whois(source_p, target_p, operspy);
 210         }
 211         else
 212                 sendto_one_numeric(source_p, ERR_NOSUCHNICK,
 213                                    form_str(ERR_NOSUCHNICK),
 214                                    nick);
 215
 216         sendto_one_numeric(source_p, RPL_ENDOFWHOIS,
 217                            form_str(RPL_ENDOFWHOIS), parv[1]);
 218         return;
 219 }
 220
 221 /*
 222  * single_whois()
 223  *
 224  * Inputs       - source_p client to report to
 225  *              - target_p client to report on
 226  * Output       - if found return 1
 227  * Side Effects - do a single whois on given client
 228  *                writing results to source_p
 229  */
 230 static void
 231 single_whois(struct Client *source_p, struct Client *target_p, int operspy)
 232 {
 233         char buf[BUFSIZE];
 234         rb_dlink_node *ptr;
 235         struct membership *msptr;
 236         struct Channel *chptr;
 237         int cur_len = 0;
 238         int mlen;
 239         char *t;
 240         int tlen;
 241         hook_data_client hdata;
 242         int extra_space = 0;
 243 #ifdef RB_IPV6
 244         struct sockaddr_in ip4;
 245 #endif
 246
 247         if(target_p->user == NULL)
 248         {
 249                 s_assert(0);
 250                 return;
 251         }
 252
 253         sendto_one_numeric(source_p, RPL_WHOISUSER, form_str(RPL_WHOISUSER),
 254                            target_p->name, target_p->username,
 255                            target_p->host, target_p->info);
 256
 257         cur_len = mlen = sprintf(buf, form_str(RPL_WHOISCHANNELS),
 258                                     get_id(&me, source_p), get_id(source_p, source_p),
 259                                     target_p->name);
 260
 261         /* Make sure it won't overflow when sending it to the client
 262          * in full names; note that serverhiding may require more space
 263          * for a different server name (not done here) -- jilles
 264          */
 265         if (!MyConnect(source_p))
 266         {
 267                 extra_space = strlen(source_p->name) - 9;
 268                 if (extra_space < 0)
 269                         extra_space = 0;
 270                 extra_space += strlen(me.name) - 2; /* make sure >= 0 */
 271                 cur_len += extra_space;
 272         }
 273
 274         t = buf + mlen;
 275
 276         hdata.client = source_p;
 277         hdata.target = target_p;
 278
 279         if (!IsService(target_p))
 280         {
 281                 RB_DLINK_FOREACH(ptr, target_p->user->channel.head)
 282                 {
 283                         msptr = ptr->data;
 284                         chptr = msptr->chptr;
 285
 286                         hdata.chptr = chptr;
 287
 288                         hdata.approved = ShowChannel(source_p, chptr);
 289                         call_hook(doing_whois_channel_visibility_hook, &hdata);
 290
 291                         if(hdata.approved || operspy)
 292                         {
 293                                 if((cur_len + strlen(chptr->chname) + 3) > (BUFSIZE - 5))
 294                                 {
 295                                         sendto_one(source_p, "%s", buf);
 296                                         cur_len = mlen + extra_space;
 297                                         t = buf + mlen;
 298                                 }
 299
 300                                 tlen = sprintf(t, "%s%s%s ",
 301                                                 hdata.approved ? "" : "!",
 302                                                 find_channel_status(msptr, 1),
 303                                                 chptr->chname);
 304                                 t += tlen;
 305                                 cur_len += tlen;
 306                         }
 307                 }
 308         }
 309
 310         if(cur_len > mlen + extra_space)
 311                 sendto_one(source_p, "%s", buf);
 312
 313         sendto_one_numeric(source_p, RPL_WHOISSERVER, form_str(RPL_WHOISSERVER),
 314                            target_p->name, target_p->servptr->name,
 315                            target_p->servptr->info);
 316
 317         if(target_p->user->away)
 318                 sendto_one_numeric(source_p, RPL_AWAY, form_str(RPL_AWAY),
 319                                    target_p->name, target_p->user->away);
 320
 321         if(IsOper(target_p) && (!ConfigFileEntry.hide_opers_in_whois || IsOper(source_p)))
 322         {
 323                 sendto_one_numeric(source_p, RPL_WHOISOPERATOR, form_str(RPL_WHOISOPERATOR),
 324                                    target_p->name,
 325                                    IsService(target_p) ? ConfigFileEntry.servicestring :
 326                                    (IsAdmin(target_p) ? GlobalSetOptions.adminstring :
 327                                     GlobalSetOptions.operstring));
 328         }
 329
 330         if(MyClient(target_p) && !EmptyString(target_p->localClient->opername) && IsOper(source_p))
 331         {
 332                 char buf[512];
 333                 snprintf(buf, sizeof(buf), "is opered as %s, privset %s",
 334                             target_p->localClient->opername, target_p->localClient->privset->name);
 335                 sendto_one_numeric(source_p, RPL_WHOISSPECIAL, form_str(RPL_WHOISSPECIAL),
 336                                    target_p->name, buf);
 337         }
 338
 339         if(IsSSLClient(target_p))
 340         {
 341                 char cbuf[256] = "is using a secure connection";
 342
 343                 if (MyClient(target_p) && target_p->localClient->cipher_string != NULL)
 344                         rb_snprintf_append(cbuf, sizeof(cbuf), " [%s]", target_p->localClient->cipher_string);
 345
 346                 sendto_one_numeric(source_p, RPL_WHOISSECURE, form_str(RPL_WHOISSECURE),
 347                                    target_p->name, cbuf);
 348                 if((source_p == target_p || IsOper(source_p)) &&
 349                                 target_p->certfp != NULL)
 350                         sendto_one_numeric(source_p, RPL_WHOISCERTFP,
 351                                         form_str(RPL_WHOISCERTFP),
 352                                         target_p->name, target_p->certfp);
 353         }
 354
 355         if(MyClient(target_p))
 356         {
 357                 if (IsDynSpoof(target_p) && (IsOper(source_p) || source_p == target_p))
 358                 {
 359                         /* trick here: show a nonoper their own IP if
 360                          * dynamic spoofed but not if auth{} spoofed
 361                          * -- jilles */
 362                         ClearDynSpoof(target_p);
 363                         sendto_one_numeric(source_p, RPL_WHOISHOST,
 364                                            form_str(RPL_WHOISHOST),
 365                                            target_p->name, target_p->orighost,
 366                                            show_ip(source_p, target_p) ? target_p->sockhost : "255.255.255.255");
 367                         SetDynSpoof(target_p);
 368                 }
 369                 else if(ConfigFileEntry.use_whois_actually && show_ip(source_p, target_p))
 370                         sendto_one_numeric(source_p, RPL_WHOISACTUALLY,
 371                                            form_str(RPL_WHOISACTUALLY),
 372                                            target_p->name, target_p->sockhost);
 373
 374 #ifdef RB_IPV6
 375                 if (target_p->localClient->ip.ss_family == AF_INET6 &&
 376                                 (show_ip(source_p, target_p) ||
 377                                  (source_p == target_p && !IsIPSpoof(target_p))) &&
 378                                 ipv4_from_ipv6((struct sockaddr_in6 *)&target_p->localClient->ip, &ip4))
 379                 {
 380                         rb_inet_ntop_sock((struct sockaddr *)&ip4,
 381                                         buf, sizeof buf);
 382                         sendto_one_numeric(source_p, RPL_WHOISTEXT,
 383                                         "%s :Underlying IPv4 is %s",
 384                                         target_p->name, buf);
 385                 }
 386 #endif /* RB_IPV6 */
 387
 388                 sendto_one_numeric(source_p, RPL_WHOISIDLE, form_str(RPL_WHOISIDLE),
 389                                    target_p->name,
 390                                    (long)(rb_current_time() - target_p->localClient->last),
 391                                    (unsigned long)target_p->localClient->firsttime);
 392         }
 393         else
 394         {
 395                 if (IsDynSpoof(target_p) && (IsOper(source_p) || source_p == target_p))
 396                 {
 397                         ClearDynSpoof(target_p);
 398                         sendto_one_numeric(source_p, RPL_WHOISHOST,
 399                                            form_str(RPL_WHOISHOST),
 400                                            target_p->name, target_p->orighost,
 401                                            show_ip(source_p, target_p) && !EmptyString(target_p->sockhost) && strcmp(target_p->sockhost, "0")? target_p->sockhost : "255.255.255.255");
 402                         SetDynSpoof(target_p);
 403                 }
 404                 else if(ConfigFileEntry.use_whois_actually && show_ip(source_p, target_p) &&
 405                    !EmptyString(target_p->sockhost) && strcmp(target_p->sockhost, "0"))
 406                 {
 407                         sendto_one_numeric(source_p, RPL_WHOISACTUALLY,
 408                                            form_str(RPL_WHOISACTUALLY),
 409                                            target_p->name, target_p->sockhost);
 410
 411                 }
 412         }
 413
 414         /* doing_whois_hook must only be called for local clients,
 415          * doing_whois_global_hook must only be called for local targets
 416          */
 417         /* it is important that these are called *before* RPL_ENDOFWHOIS is
 418          * sent, services compatibility code depends on it. --anfl
 419          */
 420         if(MyClient(source_p))
 421                 call_hook(doing_whois_hook, &hdata);
 422         else
 423                 call_hook(doing_whois_global_hook, &hdata);
 424
 425         return;
 426 }