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