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