2 * ircd-ratbox: A slightly useful ircd.
3 * m_whois.c: Shows who a user is.
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
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.
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.
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
43 #include "s_newconf.h"
44 #include "ipv4_from_ipv6.h"
45 #include "ratelimit.h"
48 static void do_whois(struct Client
*client_p
, struct Client
*source_p
, int parc
, const char *parv
[]);
49 static void single_whois(struct Client
*source_p
, struct Client
*target_p
, int operspy
);
51 static int m_whois(struct MsgBuf
*, struct Client
*, struct Client
*, int, const char **);
52 static int ms_whois(struct MsgBuf
*, struct Client
*, struct Client
*, int, const char **);
53 static const char whois_desc
[] =
54 "Provides the WHOIS command to display information about a user";
56 struct Message whois_msgtab
= {
58 {mg_unreg
, {m_whois
, 2}, {ms_whois
, 2}, mg_ignore
, mg_ignore
, {m_whois
, 2}}
62 int doing_whois_global_hook
;
63 int doing_whois_channel_visibility_hook
;
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
},
73 DECLARE_MODULE_AV2(whois
, NULL
, NULL
, whois_clist
, whois_hlist
, NULL
, NULL
, NULL
, whois_desc
);
77 * parv[1] = nickname masklist
80 m_whois(struct MsgBuf
*msgbuf_p
, struct Client
*client_p
, struct Client
*source_p
, int parc
, const char *parv
[])
82 static time_t last_used
= 0;
86 if(EmptyString(parv
[2]))
88 sendto_one(source_p
, form_str(ERR_NONICKNAMEGIVEN
),
89 me
.name
, source_p
->name
);
95 /* seeing as this is going across servers, we should limit it */
96 if((last_used
+ ConfigFileEntry
.pace_wait_simple
) > rb_current_time() || !ratelimit_client(source_p
, 2))
98 sendto_one(source_p
, form_str(RPL_LOAD2HI
),
99 me
.name
, source_p
->name
, "WHOIS");
100 sendto_one_numeric(source_p
, RPL_ENDOFWHOIS
,
101 form_str(RPL_ENDOFWHOIS
), parv
[2]);
105 last_used
= rb_current_time();
108 if(hunt_server(client_p
, source_p
, ":%s WHOIS %s :%s", 1, parc
, parv
) !=
115 do_whois(client_p
, source_p
, parc
, parv
);
122 * parv[1] = server to reply
123 * parv[2] = nickname to whois
126 ms_whois(struct MsgBuf
*msgbuf_p
, struct Client
*client_p
, struct Client
*source_p
, int parc
, const char *parv
[])
128 struct Client
*target_p
;
130 /* note: early versions of ratbox allowed users to issue a remote
131 * whois with a blank parv[2], so we cannot treat it as a protocol
134 if(parc
< 3 || EmptyString(parv
[2]))
136 sendto_one(source_p
, form_str(ERR_NONICKNAMEGIVEN
),
137 me
.name
, source_p
->name
);
141 /* check if parv[1] exists */
142 if((target_p
= find_client(parv
[1])) == NULL
)
144 sendto_one_numeric(source_p
, ERR_NOSUCHSERVER
,
145 form_str(ERR_NOSUCHSERVER
),
146 IsDigit(parv
[1][0]) ? "*" : parv
[1]);
150 /* if parv[1] isnt my client, or me, someone else is supposed
151 * to be handling the request.. so send it to them
153 if(!MyClient(target_p
) && !IsMe(target_p
))
155 sendto_one(target_p
, ":%s WHOIS %s :%s",
156 get_id(source_p
, target_p
),
157 get_id(target_p
, target_p
), parv
[2]);
161 /* ok, the target is either us, or a client on our server, so perform the whois
162 * but first, parv[1] == server to perform the whois on, parv[2] == person
163 * to whois, so make parv[1] = parv[2] so do_whois is ok -- fl_
166 do_whois(client_p
, source_p
, parc
, parv
);
173 * inputs - pointer to
178 do_whois(struct Client
*client_p
, struct Client
*source_p
, int parc
, const char *parv
[])
180 struct Client
*target_p
;
185 nick
= LOCAL_COPY(parv
[1]);
186 if((p
= strchr(nick
, ',')))
189 if(IsOperSpy(source_p
) && *nick
== '!')
195 target_p
= find_named_person(nick
);
200 char buffer
[BUFSIZE
];
202 snprintf(buffer
, sizeof(buffer
), "%s!%s@%s %s",
203 target_p
->name
, target_p
->username
,
204 target_p
->host
, target_p
->servptr
->name
);
205 report_operspy(source_p
, "WHOIS", buffer
);
208 single_whois(source_p
, target_p
, operspy
);
211 sendto_one_numeric(source_p
, ERR_NOSUCHNICK
,
212 form_str(ERR_NOSUCHNICK
),
215 sendto_one_numeric(source_p
, RPL_ENDOFWHOIS
,
216 form_str(RPL_ENDOFWHOIS
), parv
[1]);
223 * Inputs - source_p client to report to
224 * - target_p client to report on
225 * Output - if found return 1
226 * Side Effects - do a single whois on given client
227 * writing results to source_p
230 single_whois(struct Client
*source_p
, struct Client
*target_p
, int operspy
)
234 struct membership
*msptr
;
235 struct Channel
*chptr
;
240 hook_data_client hdata
;
243 struct sockaddr_in ip4
;
246 if(target_p
->user
== NULL
)
252 sendto_one_numeric(source_p
, RPL_WHOISUSER
, form_str(RPL_WHOISUSER
),
253 target_p
->name
, target_p
->username
,
254 target_p
->host
, target_p
->info
);
256 cur_len
= mlen
= sprintf(buf
, form_str(RPL_WHOISCHANNELS
),
257 get_id(&me
, source_p
), get_id(source_p
, source_p
),
260 /* Make sure it won't overflow when sending it to the client
261 * in full names; note that serverhiding may require more space
262 * for a different server name (not done here) -- jilles
264 if (!MyConnect(source_p
))
266 extra_space
= strlen(source_p
->name
) - 9;
269 extra_space
+= strlen(me
.name
) - 2; /* make sure >= 0 */
270 cur_len
+= extra_space
;
275 hdata
.client
= source_p
;
276 hdata
.target
= target_p
;
278 if (!IsService(target_p
))
280 RB_DLINK_FOREACH(ptr
, target_p
->user
->channel
.head
)
283 chptr
= msptr
->chptr
;
287 hdata
.approved
= ShowChannel(source_p
, chptr
);
288 call_hook(doing_whois_channel_visibility_hook
, &hdata
);
290 if(hdata
.approved
|| operspy
)
292 if((cur_len
+ strlen(chptr
->chname
) + 3) > (BUFSIZE
- 5))
294 sendto_one(source_p
, "%s", buf
);
295 cur_len
= mlen
+ extra_space
;
299 tlen
= sprintf(t
, "%s%s%s ",
300 hdata
.approved
? "" : "!",
301 find_channel_status(msptr
, 1),
309 if(cur_len
> mlen
+ extra_space
)
310 sendto_one(source_p
, "%s", buf
);
312 sendto_one_numeric(source_p
, RPL_WHOISSERVER
, form_str(RPL_WHOISSERVER
),
313 target_p
->name
, target_p
->servptr
->name
,
314 target_p
->servptr
->info
);
316 if(target_p
->user
->away
)
317 sendto_one_numeric(source_p
, RPL_AWAY
, form_str(RPL_AWAY
),
318 target_p
->name
, target_p
->user
->away
);
320 if(IsOper(target_p
) && (!ConfigFileEntry
.hide_opers_in_whois
|| IsOper(source_p
)))
322 sendto_one_numeric(source_p
, RPL_WHOISOPERATOR
, form_str(RPL_WHOISOPERATOR
),
324 IsService(target_p
) ? ConfigFileEntry
.servicestring
:
325 (IsAdmin(target_p
) ? GlobalSetOptions
.adminstring
:
326 GlobalSetOptions
.operstring
));
329 if(MyClient(target_p
) && !EmptyString(target_p
->localClient
->opername
) && IsOper(source_p
))
332 snprintf(buf
, sizeof(buf
), "is opered as %s, privset %s",
333 target_p
->localClient
->opername
, target_p
->localClient
->privset
->name
);
334 sendto_one_numeric(source_p
, RPL_WHOISSPECIAL
, form_str(RPL_WHOISSPECIAL
),
335 target_p
->name
, buf
);
338 if(IsSSLClient(target_p
))
340 char cbuf
[256] = "is using a secure connection";
342 if (MyClient(target_p
) && target_p
->localClient
->cipher_string
!= NULL
)
343 rb_snprintf_append(cbuf
, sizeof(cbuf
), " [%s]", target_p
->localClient
->cipher_string
);
345 sendto_one_numeric(source_p
, RPL_WHOISSECURE
, form_str(RPL_WHOISSECURE
),
346 target_p
->name
, cbuf
);
347 if((source_p
== target_p
|| IsOper(source_p
)) &&
348 target_p
->certfp
!= NULL
)
349 sendto_one_numeric(source_p
, RPL_WHOISCERTFP
,
350 form_str(RPL_WHOISCERTFP
),
351 target_p
->name
, target_p
->certfp
);
354 if(MyClient(target_p
))
356 if (IsDynSpoof(target_p
) && (IsOper(source_p
) || source_p
== target_p
))
358 /* trick here: show a nonoper their own IP if
359 * dynamic spoofed but not if auth{} spoofed
361 ClearDynSpoof(target_p
);
362 sendto_one_numeric(source_p
, RPL_WHOISHOST
,
363 form_str(RPL_WHOISHOST
),
364 target_p
->name
, target_p
->orighost
,
365 show_ip(source_p
, target_p
) ? target_p
->sockhost
: "255.255.255.255");
366 SetDynSpoof(target_p
);
368 else if(ConfigFileEntry
.use_whois_actually
&& show_ip(source_p
, target_p
))
369 sendto_one_numeric(source_p
, RPL_WHOISACTUALLY
,
370 form_str(RPL_WHOISACTUALLY
),
371 target_p
->name
, target_p
->sockhost
);
374 if (target_p
->localClient
->ip
.ss_family
== AF_INET6
&&
375 (show_ip(source_p
, target_p
) ||
376 (source_p
== target_p
&& !IsIPSpoof(target_p
))) &&
377 ipv4_from_ipv6((struct sockaddr_in6
*)&target_p
->localClient
->ip
, &ip4
))
379 rb_inet_ntop_sock((struct sockaddr
*)&ip4
,
381 sendto_one_numeric(source_p
, RPL_WHOISTEXT
,
382 "%s :Underlying IPv4 is %s",
383 target_p
->name
, buf
);
387 sendto_one_numeric(source_p
, RPL_WHOISIDLE
, form_str(RPL_WHOISIDLE
),
389 (long)(rb_current_time() - target_p
->localClient
->last
),
390 (unsigned long)target_p
->localClient
->firsttime
);
394 if (IsDynSpoof(target_p
) && (IsOper(source_p
) || source_p
== target_p
))
396 ClearDynSpoof(target_p
);
397 sendto_one_numeric(source_p
, RPL_WHOISHOST
,
398 form_str(RPL_WHOISHOST
),
399 target_p
->name
, target_p
->orighost
,
400 show_ip(source_p
, target_p
) && !EmptyString(target_p
->sockhost
) && strcmp(target_p
->sockhost
, "0")? target_p
->sockhost
: "255.255.255.255");
401 SetDynSpoof(target_p
);
403 else if(ConfigFileEntry
.use_whois_actually
&& show_ip(source_p
, target_p
) &&
404 !EmptyString(target_p
->sockhost
) && strcmp(target_p
->sockhost
, "0"))
406 sendto_one_numeric(source_p
, RPL_WHOISACTUALLY
,
407 form_str(RPL_WHOISACTUALLY
),
408 target_p
->name
, target_p
->sockhost
);
413 /* doing_whois_hook must only be called for local clients,
414 * doing_whois_global_hook must only be called for local targets
416 /* it is important that these are called *before* RPL_ENDOFWHOIS is
417 * sent, services compatibility code depends on it. --anfl
419 if(MyClient(source_p
))
420 call_hook(doing_whois_hook
, &hdata
);
422 call_hook(doing_whois_global_hook
, &hdata
);