ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/trunk/modules/m_stats.c
Revision: 4034
Committed: Sun Jun 22 11:59:24 2014 UTC (9 years, 9 months ago) by michael
Content type: text/x-csrc
File size: 52982 byte(s)
Log Message:
- m_stats.c: style corrections

File Contents

# Content
1 /*
2 * ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3 *
4 * Copyright (c) 1997-2014 ircd-hybrid development team
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
19 * USA
20 */
21
22 /*! \file m_stats.c
23 * \brief Includes required functions for processing the STATS command.
24 * \version $Id$
25 */
26
27 #include "stdinc.h"
28 #include "list.h"
29 #include "client.h"
30 #include "irc_string.h"
31 #include "ircd.h"
32 #include "listener.h"
33 #include "gline.h"
34 #include "conf.h"
35 #include "conf_class.h"
36 #include "hostmask.h"
37 #include "numeric.h"
38 #include "send.h"
39 #include "fdlist.h"
40 #include "s_bsd.h"
41 #include "misc.h"
42 #include "server.h"
43 #include "user.h"
44 #include "event.h"
45 #include "dbuf.h"
46 #include "hook.h"
47 #include "parse.h"
48 #include "modules.h"
49 #include "resv.h"
50 #include "whowas.h"
51 #include "watch.h"
52 #include "res.h"
53 #include "motd.h"
54
55
56 static const struct shared_flags
57 {
58 const unsigned int type;
59 const unsigned char letter;
60 } flag_table[] = {
61 { SHARED_KLINE, 'K' },
62 { SHARED_UNKLINE, 'U' },
63 { SHARED_XLINE, 'X' },
64 { SHARED_UNXLINE, 'Y' },
65 { SHARED_RESV, 'Q' },
66 { SHARED_UNRESV, 'R' },
67 { SHARED_LOCOPS, 'L' },
68 { SHARED_DLINE, 'D' },
69 { SHARED_UNDLINE, 'E' },
70 { 0, '\0' }
71 };
72
73 /*
74 * inputs - pointer to client requesting confitem report
75 * - ConfType to report
76 * output - none
77 * side effects -
78 */
79 static void
80 report_confitem_types(struct Client *source_p, enum maskitem_type type)
81 {
82 const dlink_node *ptr = NULL;
83 const struct MaskItem *conf = NULL;
84 char buf[IRCD_BUFSIZE];
85 char *p = NULL;
86
87 switch (type)
88 {
89 case CONF_XLINE:
90 DLINK_FOREACH(ptr, xconf_items.head)
91 {
92 conf = ptr->data;
93 sendto_one_numeric(source_p, &me, RPL_STATSXLINE,
94 conf->until ? 'x': 'X', conf->count,
95 conf->name, conf->reason);
96 }
97
98 break;
99
100 case CONF_ULINE:
101 DLINK_FOREACH(ptr, uconf_items.head)
102 {
103 conf = ptr->data;
104 p = buf;
105
106 *p++ = 'c';
107
108 for (const struct shared_flags *shared = flag_table; shared->type; ++shared)
109 if (shared->type & conf->flags)
110 *p++ = shared->letter;
111 else
112 *p++ = ToLower(shared->letter);
113
114 *p = '\0';
115
116 sendto_one_numeric(source_p, &me, RPL_STATSULINE, conf->name,
117 conf->user ? conf->user: "*",
118 conf->host ? conf->host: "*", buf);
119 }
120
121 DLINK_FOREACH(ptr, cluster_items.head)
122 {
123 conf = ptr->data;
124 p = buf;
125
126 *p++ = 'C';
127
128 for (const struct shared_flags *shared = flag_table; shared->type; ++shared)
129 if (shared->type & conf->flags)
130 *p++ = shared->letter;
131 else
132 *p++ = ToLower(shared->letter);
133
134 *p = '\0';
135
136 sendto_one_numeric(source_p, &me, RPL_STATSULINE, conf->name, "*", "*", buf);
137 }
138
139 break;
140
141 case CONF_OPER:
142 DLINK_FOREACH(ptr, oconf_items.head)
143 {
144 conf = ptr->data;
145
146 /* Don't allow non opers to see oper privs */
147 if (HasUMode(source_p, UMODE_OPER))
148 sendto_one_numeric(source_p, &me, RPL_STATSOLINE, 'O', conf->user, conf->host,
149 conf->name, oper_privs_as_string(conf->port),
150 conf->class->name);
151 else
152 sendto_one_numeric(source_p, &me, RPL_STATSOLINE, 'O', conf->user, conf->host,
153 conf->name, "0", conf->class->name);
154 }
155
156 break;
157
158 case CONF_SERVICE:
159 DLINK_FOREACH(ptr, service_items.head)
160 {
161 conf = ptr->data;
162 sendto_one_numeric(source_p, &me, RPL_STATSSERVICE, 'S', "*", conf->name, 0, 0);
163 }
164
165 break;
166
167 case CONF_SERVER:
168 DLINK_FOREACH(ptr, server_items.head)
169 {
170 p = buf;
171 conf = ptr->data;
172
173 buf[0] = '\0';
174
175 if (IsConfAllowAutoConn(conf))
176 *p++ = 'A';
177 if (IsConfSSL(conf))
178 *p++ = 'S';
179 if (buf[0] == '\0')
180 *p++ = '*';
181
182 *p = '\0';
183
184 /*
185 * Allow admins to see actual ips unless hide_server_ips is enabled
186 */
187 if (!ConfigServerHide.hide_server_ips && HasUMode(source_p, UMODE_ADMIN))
188 sendto_one_numeric(source_p, &me, RPL_STATSCLINE, 'C', conf->host,
189 buf, conf->name, conf->port,
190 conf->class->name);
191 else
192 sendto_one_numeric(source_p, &me, RPL_STATSCLINE, 'C',
193 "*@127.0.0.1", buf, conf->name, conf->port,
194 conf->class->name);
195 }
196
197 break;
198
199 default:
200 break;
201 }
202 }
203
204 /* report_resv()
205 *
206 * inputs - pointer to client pointer to report to.
207 * output - NONE
208 * side effects - report all resvs to client.
209 */
210 static void
211 report_resv(struct Client *source_p)
212 {
213 const dlink_node *ptr = NULL;
214
215 DLINK_FOREACH(ptr, cresv_items.head)
216 {
217 const struct MaskItem *conf = ptr->data;
218
219 sendto_one_numeric(source_p, &me, RPL_STATSQLINE,
220 conf->until ? 'q' : 'Q', conf->count,
221 conf->name, conf->reason);
222 }
223
224 DLINK_FOREACH(ptr, nresv_items.head)
225 {
226 const struct MaskItem *conf = ptr->data;
227
228 sendto_one_numeric(source_p, &me, RPL_STATSQLINE,
229 conf->until ? 'q' : 'Q', conf->count,
230 conf->name, conf->reason);
231 }
232 }
233
234 /*
235 * This is part of the STATS replies. There is no offical numeric for this
236 * since this isnt an official command, in much the same way as HASH isnt.
237 * It is also possible that some systems wont support this call or have
238 * different field names for "struct rusage".
239 * -avalon
240 */
241 static void
242 stats_usage(struct Client *source_p, int parc, char *parv[])
243 {
244 struct rusage rus;
245 time_t secs;
246 time_t rup;
247 #ifdef hz
248 # define hzz hz
249 #else
250 # ifdef HZ
251 # define hzz HZ
252 # else
253 int hzz = 1;
254 # endif
255 #endif
256
257 if (getrusage(RUSAGE_SELF, &rus) == -1)
258 {
259 sendto_one_notice(source_p, &me, ":Getruseage error: %s",
260 strerror(errno));
261 return;
262 }
263
264 secs = rus.ru_utime.tv_sec + rus.ru_stime.tv_sec;
265
266 if (secs == 0)
267 secs = 1;
268
269 rup = (CurrentTime - me.localClient->since) * hzz;
270
271 if (rup == 0)
272 rup = 1;
273
274 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
275 "R :CPU Secs %d:%02d User %d:%02d System %d:%02d",
276 (int)(secs/60), (int)(secs%60),
277 (int)(rus.ru_utime.tv_sec/60), (int)(rus.ru_utime.tv_sec%60),
278 (int)(rus.ru_stime.tv_sec/60), (int)(rus.ru_stime.tv_sec%60));
279 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
280 "R :RSS %ld ShMem %ld Data %ld Stack %ld",
281 rus.ru_maxrss,
282 (rus.ru_ixrss / rup), (rus.ru_idrss / rup),
283 (rus.ru_isrss / rup));
284 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
285 "R :Swaps %d Reclaims %d Faults %d",
286 (int)rus.ru_nswap,
287 (int)rus.ru_minflt, (int)rus.ru_majflt);
288 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
289 "R :Block in %d out %d",
290 (int)rus.ru_inblock,
291 (int)rus.ru_oublock);
292 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
293 "R :Msg Rcv %d Send %d",
294 (int)rus.ru_msgrcv,
295 (int)rus.ru_msgsnd);
296 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
297 "R :Signals %d Context Vol. %d Invol %d",
298 (int)rus.ru_nsignals,
299 (int)rus.ru_nvcsw, (int)rus.ru_nivcsw);
300 }
301
302 static void
303 stats_memory(struct Client *source_p, int parc, char *parv[])
304 {
305 const dlink_node *gptr = NULL;
306 const dlink_node *dlink = NULL;
307
308 unsigned int local_client_conf_count = 0; /* local client conf links */
309 unsigned int users_counted = 0; /* user structs */
310
311 unsigned int channel_members = 0;
312 unsigned int channel_invites = 0;
313 unsigned int channel_bans = 0;
314 unsigned int channel_except = 0;
315 unsigned int channel_invex = 0;
316
317 unsigned int wwu = 0; /* whowas users */
318 unsigned int class_count = 0; /* classes */
319 unsigned int aways_counted = 0;
320 unsigned int number_ips_stored; /* number of ip addresses hashed */
321
322 uint64_t channel_memory = 0;
323 uint64_t channel_ban_memory = 0;
324 uint64_t channel_except_memory = 0;
325 uint64_t channel_invex_memory = 0;
326
327 unsigned int safelist_count = 0;
328 uint64_t safelist_memory = 0;
329
330 uint64_t wwm = 0; /* whowas array memory used */
331 uint64_t conf_memory = 0; /* memory used by conf lines */
332 uint64_t mem_ips_stored; /* memory used by ip address hash */
333
334 uint64_t total_channel_memory = 0;
335 uint64_t totww = 0;
336
337 unsigned int local_client_count = 0;
338 unsigned int remote_client_count = 0;
339
340 uint64_t local_client_memory_used = 0;
341 uint64_t remote_client_memory_used = 0;
342
343 uint64_t total_memory = 0;
344 unsigned int topic_count = 0;
345
346 unsigned int watch_list_headers = 0; /* watchlist headers */
347 unsigned int watch_list_entries = 0; /* watchlist entries */
348 uint64_t watch_list_memory = 0; /* watchlist memory used */
349
350
351 DLINK_FOREACH(gptr, global_client_list.head)
352 {
353 const struct Client *target_p = gptr->data;
354
355 if (MyConnect(target_p))
356 {
357 ++local_client_count;
358 local_client_conf_count += dlink_list_length(&target_p->localClient->confs);
359 watch_list_entries += dlink_list_length(&target_p->localClient->watches);
360 }
361 else
362 ++remote_client_count;
363
364 if (IsClient(target_p))
365 {
366 ++users_counted;
367
368 if (target_p->away[0])
369 ++aways_counted;
370 }
371 }
372
373 /* Count up all channels, ban lists, except lists, Invex lists */
374 channel_memory = dlink_list_length(&channel_list) *
375 sizeof(struct Channel);
376 DLINK_FOREACH(gptr, channel_list.head)
377 {
378 const struct Ban *actualBan;
379 const struct Channel *chptr = gptr->data;
380
381 channel_members += dlink_list_length(&chptr->members);
382 channel_invites += dlink_list_length(&chptr->invites);
383
384 if (chptr->topic[0])
385 ++topic_count;
386
387 channel_bans += dlink_list_length(&chptr->banlist);
388 channel_ban_memory += dlink_list_length(&chptr->banlist) * sizeof(struct Ban);
389
390 DLINK_FOREACH(dlink, chptr->banlist.head)
391 {
392 actualBan = dlink->data;
393 assert(actualBan->who);
394
395 channel_ban_memory += actualBan->len + 1;
396 channel_ban_memory += strlen(actualBan->who) + 1;
397 }
398
399 channel_except += dlink_list_length(&chptr->exceptlist);
400 channel_except_memory += dlink_list_length(&chptr->exceptlist) * sizeof(struct Ban);
401
402 DLINK_FOREACH(dlink, chptr->exceptlist.head)
403 {
404 actualBan = dlink->data;
405 assert(actualBan->who);
406
407 channel_except_memory += actualBan->len + 1;
408 channel_except_memory += strlen(actualBan->who) + 1;
409 }
410
411 channel_invex += dlink_list_length(&chptr->invexlist);
412 channel_invex_memory += dlink_list_length(&chptr->invexlist) * sizeof(struct Ban);
413
414 DLINK_FOREACH(dlink, chptr->invexlist.head)
415 {
416 actualBan = dlink->data;
417 assert(actualBan->who);
418
419 channel_invex_memory += actualBan->len + 1;
420 channel_invex_memory += strlen(actualBan->who) + 1;
421 }
422 }
423
424 if ((safelist_count = dlink_list_length(&listing_client_list)))
425 {
426 safelist_memory = safelist_count * sizeof(struct ListTask);
427 DLINK_FOREACH(gptr, listing_client_list.head)
428 {
429 const struct Client *acptr = gptr->data;
430
431 DLINK_FOREACH(dlink, acptr->localClient->list_task->show_mask.head)
432 safelist_memory += strlen(dlink->data);
433
434 DLINK_FOREACH(dlink, acptr->localClient->list_task->hide_mask.head)
435 safelist_memory += strlen(dlink->data);
436 }
437 }
438
439 #if 0
440 /* XXX THIS has to be fixed !!!! -db */
441 /* count up all config items */
442 DLINK_FOREACH(dlink, ConfigItemList.head)
443 {
444 aconf = dlink->data;
445 conf_memory += aconf->host ? strlen(aconf->host)+1 : 0;
446 conf_memory += aconf->passwd ? strlen(aconf->passwd)+1 : 0;
447 conf_memory += aconf->name ? strlen(aconf->name)+1 : 0;
448 conf_memory += sizeof(struct AccessItem);
449 }
450 #endif
451 /* count up all classes */
452 class_count = dlink_list_length(class_get_list());
453
454 whowas_count_memory(&wwu, &wwm);
455 watch_count_memory(&watch_list_headers, &watch_list_memory);
456
457 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
458 "z :WATCH headers %u(%llu) entries %d(%u)",
459 watch_list_headers,
460 watch_list_memory, watch_list_entries,
461 watch_list_entries * sizeof(dlink_node) * 2);
462
463 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
464 "z :Clients %u(%u)",
465 users_counted,
466 (users_counted * sizeof(struct Client)));
467
468 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
469 "z :User aways %u", aways_counted);
470
471 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
472 "z :Attached confs %u(%llu)",
473 local_client_conf_count,
474 (unsigned long long)(local_client_conf_count * sizeof(dlink_node)));
475
476 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
477 "z :Resv channels %u(%lu) nicks %u(%lu)",
478 dlink_list_length(&cresv_items),
479 dlink_list_length(&cresv_items) * sizeof(struct MaskItem),
480 dlink_list_length(&nresv_items),
481 dlink_list_length(&nresv_items) * sizeof(struct MaskItem));
482
483 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
484 "z :Classes %u(%llu)",
485 class_count, (unsigned long long)(class_count * sizeof(struct ClassItem)));
486
487 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
488 "z :Channels %u(%llu) Topics %u(%u)",
489 dlink_list_length(&channel_list),
490 channel_memory, topic_count, topic_count *
491 (TOPICLEN + 1 + USERHOST_REPLYLEN));
492
493 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
494 "z :Bans %u(%llu)",
495 channel_bans, channel_ban_memory);
496
497 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
498 "z :Exceptions %u(%llu)",
499 channel_except, channel_except_memory);
500
501 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
502 "z :Invex %u(%llu)",
503 channel_invex, channel_invex_memory);
504
505 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
506 "z :Channel members %u(%llu) invites %u(%llu)",
507 channel_members,
508 (unsigned long long)(channel_members * sizeof(struct Membership)),
509 channel_invites, (unsigned long long)channel_invites * sizeof(dlink_node) * 2);
510
511 total_channel_memory = channel_memory + channel_ban_memory +
512 channel_members * sizeof(struct Membership) +
513 (channel_invites * sizeof(dlink_node)*2);
514
515 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
516 "z :Safelist %u(%llu)",
517 safelist_count, safelist_memory);
518
519 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
520 "z :Whowas users %u(%llu)",
521 wwu, (unsigned long long)(wwu * sizeof(struct Client)));
522
523 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
524 "z :Whowas array %u(%llu)",
525 NICKNAMEHISTORYLENGTH, wwm);
526
527 totww = wwu * sizeof(struct Client) + wwm;
528
529 motd_memory_count(source_p);
530 count_ip_hash(&number_ips_stored,&mem_ips_stored);
531 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
532 "z :iphash %u(%llu)",
533 number_ips_stored, mem_ips_stored);
534
535 total_memory = totww + total_channel_memory + conf_memory + class_count *
536 sizeof(struct ClassItem);
537 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
538 "z :Total: whowas %llu channel %llu conf %llu",
539 totww, total_channel_memory, conf_memory);
540
541 local_client_memory_used = local_client_count*(sizeof(struct Client) + sizeof(struct LocalUser));
542 total_memory += local_client_memory_used;
543 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
544 "z :Local client Memory in use: %u(%llu)",
545 local_client_count, local_client_memory_used);
546
547 remote_client_memory_used = remote_client_count * sizeof(struct Client);
548 total_memory += remote_client_memory_used;
549 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
550 "z :Remote client Memory in use: %u(%llu)",
551 remote_client_count, remote_client_memory_used);
552
553 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
554 "z :TOTAL: %llu",
555 me.name, RPL_STATSDEBUG, source_p->name,
556 total_memory);
557 }
558
559 static void
560 stats_dns_servers(struct Client *source_p)
561 {
562 report_dns_servers(source_p);
563 }
564
565 static void
566 stats_connect(struct Client *source_p, int parc, char *parv[])
567 {
568 report_confitem_types(source_p, CONF_SERVER);
569 }
570
571 /* stats_deny()
572 *
573 * input - client to report to
574 * output - none
575 * side effects - client is given dline list.
576 */
577 static void
578 stats_deny(struct Client *source_p, int parc, char *parv[])
579 {
580 const struct MaskItem *conf = NULL;
581 const dlink_node *ptr = NULL;
582
583 for (unsigned int i = 0; i < ATABLE_SIZE; ++i)
584 {
585 DLINK_FOREACH(ptr, atable[i].head)
586 {
587 const struct AddressRec *arec = ptr->data;
588
589 if (arec->type != CONF_DLINE)
590 continue;
591
592 conf = arec->conf;
593
594 /* Don't report a tdline as a dline */
595 if (conf->until)
596 continue;
597
598 sendto_one_numeric(source_p, &me, RPL_STATSDLINE, 'D', conf->host, conf->reason);
599 }
600 }
601 }
602
603 /* stats_tdeny()
604 *
605 * input - client to report to
606 * output - none
607 * side effects - client is given dline list.
608 */
609 static void
610 stats_tdeny(struct Client *source_p, int parc, char *parv[])
611 {
612 const struct MaskItem *conf = NULL;
613 const dlink_node *ptr = NULL;
614
615 for (unsigned int i = 0; i < ATABLE_SIZE; ++i)
616 {
617 DLINK_FOREACH(ptr, atable[i].head)
618 {
619 const struct AddressRec *arec = ptr->data;
620
621 if (arec->type != CONF_DLINE)
622 continue;
623
624 conf = arec->conf;
625
626 /* Don't report a permanent dline as a tdline */
627 if (!conf->until)
628 continue;
629
630 sendto_one_numeric(source_p, &me, RPL_STATSDLINE, 'd', conf->host, conf->reason);
631 }
632 }
633 }
634
635 /* stats_exempt()
636 *
637 * input - client to report to
638 * output - none
639 * side effects - client is given list of exempt blocks
640 */
641 static void
642 stats_exempt(struct Client *source_p, int parc, char *parv[])
643 {
644 const struct MaskItem *conf = NULL;
645 const dlink_node *ptr = NULL;
646
647 if (ConfigFileEntry.stats_e_disabled)
648 {
649 sendto_one_numeric(source_p, &me, ERR_NOPRIVILEGES);
650 return;
651 }
652
653 for (unsigned int i = 0; i < ATABLE_SIZE; ++i)
654 {
655 DLINK_FOREACH(ptr, atable[i].head)
656 {
657 const struct AddressRec *arec = ptr->data;
658
659 if (arec->type != CONF_EXEMPT)
660 continue;
661
662 conf = arec->conf;
663 sendto_one_numeric(source_p, &me, RPL_STATSDLINE, 'e', conf->host, "");
664 }
665 }
666 }
667
668 static void
669 stats_events(struct Client *source_p, int parc, char *parv[])
670 {
671 show_events(source_p);
672 }
673
674 /* stats_pending_glines()
675 *
676 * input - client pointer
677 * output - none
678 * side effects - client is shown list of pending glines
679 */
680 static void
681 stats_pending_glines(struct Client *source_p, int parc, char *parv[])
682 {
683 const dlink_node *dn_ptr = NULL;
684 const struct gline_pending *glp_ptr = NULL;
685 char timebuffer[MAX_DATE_STRING] = "";
686 struct tm *tmptr = NULL;
687
688 if (!ConfigFileEntry.glines)
689 {
690 sendto_one_notice(source_p, &me, ":This server does not support G-Lines");
691 return;
692 }
693
694 if (dlink_list_length(&pending_glines[GLINE_PENDING_ADD_TYPE]))
695 sendto_one_notice(source_p, &me, ":Pending G-lines");
696
697 DLINK_FOREACH(dn_ptr, pending_glines[GLINE_PENDING_ADD_TYPE].head)
698 {
699 glp_ptr = dn_ptr->data;
700 tmptr = localtime(&glp_ptr->vote_1.time_request);
701 strftime(timebuffer, MAX_DATE_STRING, "%Y/%m/%d %H:%M:%S", tmptr);
702
703 sendto_one_notice(source_p, &me, ":1) %s!%s@%s on %s requested gline at %s for %s@%s [%s]",
704 glp_ptr->vote_1.oper_nick,
705 glp_ptr->vote_1.oper_user, glp_ptr->vote_1.oper_host,
706 glp_ptr->vote_1.oper_server, timebuffer,
707 glp_ptr->user, glp_ptr->host, glp_ptr->vote_1.reason);
708
709 if (glp_ptr->vote_2.oper_nick[0])
710 {
711 tmptr = localtime(&glp_ptr->vote_2.time_request);
712 strftime(timebuffer, MAX_DATE_STRING, "%Y/%m/%d %H:%M:%S", tmptr);
713
714 sendto_one_notice(source_p, &me, ":2) %s!%s@%s on %s requested gline at %s for %s@%s [%s]",
715 glp_ptr->vote_2.oper_nick,
716 glp_ptr->vote_2.oper_user, glp_ptr->vote_2.oper_host,
717 glp_ptr->vote_2.oper_server, timebuffer,
718 glp_ptr->user, glp_ptr->host, glp_ptr->vote_2.reason);
719 }
720 }
721
722 sendto_one_notice(source_p, &me, ":End of Pending G-lines");
723
724 if (dlink_list_length(&pending_glines[GLINE_PENDING_DEL_TYPE]))
725 sendto_one_notice(source_p, &me, ":Pending UNG-lines");
726
727 DLINK_FOREACH(dn_ptr, pending_glines[GLINE_PENDING_DEL_TYPE].head)
728 {
729 glp_ptr = dn_ptr->data;
730 tmptr = localtime(&glp_ptr->vote_1.time_request);
731 strftime(timebuffer, MAX_DATE_STRING, "%Y/%m/%d %H:%M:%S", tmptr);
732
733 sendto_one_notice(source_p, &me, ":1) %s!%s@%s on %s requested ungline at %s for %s@%s [%s]",
734 glp_ptr->vote_1.oper_nick,
735 glp_ptr->vote_1.oper_user, glp_ptr->vote_1.oper_host,
736 glp_ptr->vote_1.oper_server, timebuffer,
737 glp_ptr->user, glp_ptr->host, glp_ptr->vote_1.reason);
738
739 if (glp_ptr->vote_2.oper_nick[0])
740 {
741 tmptr = localtime(&glp_ptr->vote_2.time_request);
742 strftime(timebuffer, MAX_DATE_STRING, "%Y/%m/%d %H:%M:%S", tmptr);
743
744 sendto_one_notice(source_p, &me, ":2) %s!%s@%s on %s requested ungline at %s for %s@%s [%s]",
745 glp_ptr->vote_2.oper_nick,
746 glp_ptr->vote_2.oper_user, glp_ptr->vote_2.oper_host,
747 glp_ptr->vote_2.oper_server, timebuffer,
748 glp_ptr->user, glp_ptr->host, glp_ptr->vote_2.reason);
749
750 }
751 }
752
753 sendto_one_notice(source_p, &me, ":End of Pending UNG-lines");
754 }
755
756 /* stats_glines()
757 *
758 * input - client pointer
759 * output - none
760 * side effects - client is shown list of glines
761 */
762 static void
763 stats_glines(struct Client *source_p, int parc, char *parv[])
764 {
765 const dlink_node *ptr = NULL;
766
767 if (!ConfigFileEntry.glines)
768 {
769 sendto_one_notice(source_p, &me, ":This server does not support G-Lines");
770 return;
771 }
772
773 for (unsigned int i = 0; i < ATABLE_SIZE; ++i)
774 {
775 DLINK_FOREACH(ptr, atable[i].head)
776 {
777 const struct AddressRec *arec = ptr->data;
778
779 if (arec->type == CONF_GLINE)
780 {
781 const struct MaskItem *conf = arec->conf;
782
783 sendto_one_numeric(source_p, &me, RPL_STATSKLINE, 'G',
784 conf->host ? conf->host : "*",
785 conf->user ? conf->user : "*",
786 conf->reason ? conf->reason : CONF_NOREASON);
787
788 }
789 }
790 }
791 }
792
793 static void
794 stats_hubleaf(struct Client *source_p, int parc, char *parv[])
795 {
796 const dlink_node *ptr = NULL, *dptr = NULL;
797
798 DLINK_FOREACH(ptr, server_items.head)
799 {
800 const struct MaskItem *conf = ptr->data;
801
802 DLINK_FOREACH(dptr, conf->hub_list.head)
803 sendto_one_numeric(source_p, &me, RPL_STATSHLINE, 'H', dptr->data, conf->name, 0, "*");
804 }
805
806 DLINK_FOREACH(ptr, server_items.head)
807 {
808 const struct MaskItem *conf = ptr->data;
809
810 DLINK_FOREACH(dptr, conf->leaf_list.head)
811 sendto_one_numeric(source_p, &me, RPL_STATSLLINE, 'L', dptr->data, conf->name, 0, "*");
812 }
813 }
814
815 /*
816 * show_iline_prefix()
817 *
818 * inputs - pointer to struct Client requesting output
819 * - pointer to struct MaskItem
820 * - name to which iline prefix will be prefixed to
821 * output - pointer to static string with prefixes listed in ascii form
822 * side effects - NONE
823 */
824 static const char *
825 show_iline_prefix(const struct Client *sptr, const struct MaskItem *conf)
826 {
827 static char prefix_of_host[USERLEN + 15];
828 char *prefix_ptr = prefix_of_host;
829
830 if (IsConfWebIRC(conf))
831 *prefix_ptr++ = '<';
832 if (IsNoTilde(conf))
833 *prefix_ptr++ = '-';
834 if (IsNeedIdentd(conf))
835 *prefix_ptr++ = '+';
836 if (!IsNeedPassword(conf))
837 *prefix_ptr++ = '&';
838 if (IsConfExemptResv(conf))
839 *prefix_ptr++ = '$';
840 if (IsConfDoSpoofIp(conf))
841 *prefix_ptr++ = '=';
842 if (MyOper(sptr) && IsConfExemptKline(conf))
843 *prefix_ptr++ = '^';
844 if (MyOper(sptr) && IsConfExemptGline(conf))
845 *prefix_ptr++ = '_';
846 if (MyOper(sptr) && IsConfExemptLimits(conf))
847 *prefix_ptr++ = '>';
848 if (IsConfCanFlood(conf))
849 *prefix_ptr++ = '|';
850
851 strlcpy(prefix_ptr, conf->user, USERLEN+1);
852
853 return prefix_of_host;
854 }
855
856 static void
857 report_auth(struct Client *source_p, int parc, char *parv[])
858 {
859 const struct MaskItem *conf = NULL;
860 const dlink_node *ptr = NULL;
861
862 for (unsigned int i = 0; i < ATABLE_SIZE; ++i)
863 {
864 DLINK_FOREACH(ptr, atable[i].head)
865 {
866 const struct AddressRec *arec = ptr->data;
867
868 if (arec->type != CONF_CLIENT)
869 continue;
870
871 conf = arec->conf;
872
873 if (!MyOper(source_p) && IsConfDoSpoofIp(conf))
874 continue;
875
876 /* We are doing a partial list, based on what matches the u@h of the
877 * sender, so prepare the strings for comparing --fl_
878 */
879 if (ConfigFileEntry.hide_spoof_ips)
880 sendto_one_numeric(source_p, &me, RPL_STATSILINE, 'I',
881 conf->name == NULL ? "*" : conf->name,
882 show_iline_prefix(source_p, conf),
883 IsConfDoSpoofIp(conf) ? "255.255.255.255" :
884 conf->host, conf->port,
885 conf->class->name);
886
887 else
888 sendto_one_numeric(source_p, &me, RPL_STATSILINE, 'I',
889 conf->name == NULL ? "*" : conf->name,
890 show_iline_prefix(source_p, conf),
891 conf->host, conf->port,
892 conf->class->name);
893 }
894 }
895 }
896
897 static void
898 stats_auth(struct Client *source_p, int parc, char *parv[])
899 {
900 /* Oper only, if unopered, return ERR_NOPRIVILEGES */
901 if (ConfigFileEntry.stats_i_oper_only == 2 && !HasUMode(source_p, UMODE_OPER))
902 sendto_one_numeric(source_p, &me, ERR_NOPRIVILEGES);
903
904 /* If unopered, only return matching auth blocks */
905 else if (ConfigFileEntry.stats_i_oper_only == 1 && !HasUMode(source_p, UMODE_OPER))
906 {
907 const struct MaskItem *conf = NULL;
908
909 if (MyConnect(source_p))
910 conf = find_conf_by_address(source_p->host,
911 &source_p->localClient->ip, CONF_CLIENT,
912 source_p->localClient->aftype,
913 source_p->username,
914 source_p->localClient->passwd, 1);
915 else
916 conf = find_conf_by_address(source_p->host, NULL, CONF_CLIENT, 0,
917 source_p->username, NULL, 1);
918
919 if (conf == NULL)
920 return;
921
922 sendto_one_numeric(source_p, &me, RPL_STATSILINE,
923 'I', "*", show_iline_prefix(source_p, conf),
924 conf->host, conf->port,
925 conf->class ? conf->class->name : "<default>");
926 }
927 else /* They are opered, or allowed to see all auth blocks */
928 report_auth(source_p, 0, NULL);
929 }
930
931 /* report_Klines()
932 * Inputs: Client to report to,
933 * type(==0 for perm, !=0 for temporary)
934 * mask
935 * Output: None
936 * Side effects: Reports configured K(or k)-lines to source_p.
937 */
938 static void
939 report_Klines(struct Client *source_p, int tkline)
940 {
941 const struct MaskItem *conf = NULL;
942 const dlink_node *ptr = NULL;
943 char c = '\0';
944
945 if (tkline)
946 c = 'k';
947 else
948 c = 'K';
949
950 for (unsigned int i = 0; i < ATABLE_SIZE; ++i)
951 {
952 DLINK_FOREACH(ptr, atable[i].head)
953 {
954 const struct AddressRec *arec = ptr->data;
955
956 if (arec->type != CONF_KLINE)
957 continue;
958
959 conf = arec->conf;
960
961 if ((!tkline && conf->until) ||
962 (tkline && !conf->until))
963 continue;
964
965 if (HasUMode(source_p, UMODE_OPER))
966 sendto_one_numeric(source_p, &me, RPL_STATSKLINE, c, conf->host, conf->user,
967 conf->reason);
968 else
969 sendto_one_numeric(source_p, &me, RPL_STATSKLINE, c, conf->host, conf->user,
970 conf->reason);
971 }
972 }
973 }
974
975 static void
976 stats_tklines(struct Client *source_p, int parc, char *parv[])
977 {
978 /* Oper only, if unopered, return ERR_NOPRIVILEGES */
979 if (ConfigFileEntry.stats_k_oper_only == 2 && !HasUMode(source_p, UMODE_OPER))
980 sendto_one_numeric(source_p, &me, ERR_NOPRIVILEGES);
981
982 /* If unopered, only return matching klines */
983 else if (ConfigFileEntry.stats_k_oper_only == 1 && !HasUMode(source_p, UMODE_OPER))
984 {
985 const struct MaskItem *conf = NULL;
986
987 if (MyConnect(source_p))
988 conf = find_conf_by_address(source_p->host,
989 &source_p->localClient->ip, CONF_KLINE,
990 source_p->localClient->aftype,
991 source_p->username, NULL, 1);
992 else
993 conf = find_conf_by_address(source_p->host, NULL, CONF_KLINE, 0,
994 source_p->username, NULL, 1);
995
996 if (!conf)
997 return;
998
999 /* Don't report a permanent kline as a tkline */
1000 if (!conf->until)
1001 return;
1002
1003 sendto_one_numeric(source_p, &me, RPL_STATSKLINE, 'k',
1004 conf->host, conf->user, conf->reason);
1005 }
1006 else /* They are opered, or allowed to see all klines */
1007 report_Klines(source_p, 1);
1008 }
1009
1010 static void
1011 stats_klines(struct Client *source_p, int parc, char *parv[])
1012 {
1013 /* Oper only, if unopered, return ERR_NOPRIVILEGES */
1014 if (ConfigFileEntry.stats_k_oper_only == 2 && !HasUMode(source_p, UMODE_OPER))
1015 sendto_one_numeric(source_p, &me, ERR_NOPRIVILEGES);
1016
1017 /* If unopered, only return matching klines */
1018 else if (ConfigFileEntry.stats_k_oper_only == 1 && !HasUMode(source_p, UMODE_OPER))
1019 {
1020 const struct MaskItem *conf = NULL;
1021
1022 /* Search for a kline */
1023 if (MyConnect(source_p))
1024 conf = find_conf_by_address(source_p->host,
1025 &source_p->localClient->ip, CONF_KLINE,
1026 source_p->localClient->aftype,
1027 source_p->username, NULL, 0);
1028 else
1029 conf = find_conf_by_address(source_p->host, NULL, CONF_KLINE, 0,
1030 source_p->username, NULL, 0);
1031
1032 if (!conf)
1033 return;
1034
1035 /* Don't report a tkline as a kline */
1036 if (conf->until)
1037 return;
1038
1039 sendto_one_numeric(source_p, &me, RPL_STATSKLINE, 'K',
1040 conf->host, conf->user, conf->reason);
1041 }
1042 else /* They are opered, or allowed to see all klines */
1043 report_Klines(source_p, 0);
1044 }
1045
1046 static void
1047 stats_messages(struct Client *source_p, int parc, char *parv[])
1048 {
1049 report_messages(source_p);
1050 }
1051
1052 static void
1053 stats_oper(struct Client *source_p, int parc, char *parv[])
1054 {
1055 if (!HasUMode(source_p, UMODE_OPER) && ConfigFileEntry.stats_o_oper_only)
1056 sendto_one_numeric(source_p, &me, ERR_NOPRIVILEGES);
1057 else
1058 report_confitem_types(source_p, CONF_OPER);
1059 }
1060
1061 /* stats_operedup()
1062 *
1063 * input - client pointer
1064 * output - none
1065 * side effects - client is shown a list of active opers
1066 */
1067 static void
1068 stats_operedup(struct Client *source_p, int parc, char *parv[])
1069 {
1070 const dlink_node *ptr = NULL;
1071 unsigned int opercount = 0;
1072 char buf[IRCD_BUFSIZE] = "";
1073
1074 DLINK_FOREACH(ptr, oper_list.head)
1075 {
1076 const struct Client *target_p = ptr->data;
1077
1078 if (HasUMode(target_p, UMODE_HIDDEN) && !HasUMode(source_p, UMODE_OPER))
1079 continue;
1080
1081 if (HasUMode(source_p, UMODE_OPER) || !HasUMode(target_p, UMODE_HIDEIDLE))
1082 snprintf(buf, sizeof(buf), "%u", idle_time_get(source_p, target_p));
1083 else
1084 strlcpy(buf, "n/a", sizeof(buf));
1085
1086 if (MyClient(source_p) && HasUMode(source_p, UMODE_OPER))
1087 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
1088 "p :[%c][%s] %s (%s@%s) Idle: %s",
1089 HasUMode(target_p, UMODE_ADMIN) ? 'A' : 'O',
1090 oper_privs_as_string(target_p->localClient->operflags),
1091 target_p->name, target_p->username, target_p->host, buf);
1092 else
1093 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
1094 "p :[%c] %s (%s@%s) Idle: %s",
1095 HasUMode(target_p, UMODE_ADMIN) ? 'A' : 'O',
1096 target_p->name, target_p->username, target_p->host, buf);
1097 ++opercount;
1098 }
1099
1100 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
1101 "p :%u OPER(s)", opercount);
1102 }
1103
1104 static void
1105 stats_ports(struct Client *source_p, int parc, char *parv[])
1106 {
1107 if (!HasUMode(source_p, UMODE_OPER) && ConfigFileEntry.stats_P_oper_only)
1108 sendto_one_numeric(source_p, &me, ERR_NOPRIVILEGES);
1109 else
1110 show_ports(source_p);
1111 }
1112
1113 static void
1114 stats_resv(struct Client *source_p, int parc, char *parv[])
1115 {
1116 report_resv(source_p);
1117 }
1118
1119 static void
1120 stats_service(struct Client *source_p, int parc, char *parv[])
1121 {
1122 report_confitem_types(source_p, CONF_SERVICE);
1123 }
1124
1125 static void
1126 stats_tstats(struct Client *source_p, int parc, char *parv[])
1127 {
1128 const struct Client *target_p = NULL;
1129 const dlink_node *ptr = NULL;
1130 struct ServerStatistics tmp;
1131 struct ServerStatistics *sp = &tmp;
1132
1133 memcpy(sp, &ServerStats, sizeof(struct ServerStatistics));
1134
1135 /*
1136 * must use the += operator. is_sv is not the number of currently
1137 * active server connections. Note the incrementation in
1138 * s_bsd.c:close_connection.
1139 */
1140 sp->is_sv += dlink_list_length(&serv_list);
1141
1142 DLINK_FOREACH(ptr, serv_list.head)
1143 {
1144 target_p = ptr->data;
1145
1146 sp->is_sbs += target_p->localClient->send.bytes;
1147 sp->is_sbr += target_p->localClient->recv.bytes;
1148 sp->is_sti += CurrentTime - target_p->localClient->firsttime;
1149 }
1150
1151 sp->is_cl += dlink_list_length(&local_client_list);
1152
1153 DLINK_FOREACH(ptr, local_client_list.head)
1154 {
1155 target_p = ptr->data;
1156
1157 sp->is_cbs += target_p->localClient->send.bytes;
1158 sp->is_cbr += target_p->localClient->recv.bytes;
1159 sp->is_cti += CurrentTime - target_p->localClient->firsttime;
1160 }
1161
1162 sp->is_ni += dlink_list_length(&unknown_list);
1163
1164 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
1165 "T :accepts %u refused %u",
1166 sp->is_ac, sp->is_ref);
1167 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
1168 "T :unknown commands %u prefixes %u",
1169 sp->is_unco, sp->is_unpf);
1170 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
1171 "T :nick collisions %u unknown closes %u",
1172 sp->is_kill, sp->is_ni);
1173 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
1174 "T :wrong direction %u empty %u",
1175 sp->is_wrdi, sp->is_empt);
1176 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
1177 "T :numerics seen %u",
1178 sp->is_num);
1179 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
1180 "T :auth successes %u fails %u",
1181 sp->is_asuc, sp->is_abad);
1182 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
1183 "T :Client Server");
1184 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
1185 "T :connected %u %u",
1186 (unsigned int)sp->is_cl,
1187 (unsigned int)sp->is_sv);
1188 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
1189 "T :bytes sent %llu %llu",
1190 sp->is_cbs, sp->is_sbs);
1191 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
1192 "T :bytes recv %llu %llu",
1193 sp->is_cbr, sp->is_sbr);
1194 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
1195 "T :time connected %u %u",
1196 (unsigned int)sp->is_cti,
1197 (unsigned int)sp->is_sti);
1198 }
1199
1200 static void
1201 stats_uptime(struct Client *source_p, int parc, char *parv[])
1202 {
1203 if (!HasUMode(source_p, UMODE_OPER) && ConfigFileEntry.stats_u_oper_only)
1204 sendto_one_numeric(source_p, &me, ERR_NOPRIVILEGES);
1205 else
1206 {
1207 time_t now = CurrentTime - me.localClient->since;
1208
1209 sendto_one_numeric(source_p, &me, RPL_STATSUPTIME, now / 86400,
1210 (now / 3600) % 24, (now / 60) % 60, now % 60);
1211
1212 if (!ConfigServerHide.disable_remote_commands || HasUMode(source_p, UMODE_OPER))
1213 sendto_one_numeric(source_p, &me, RPL_STATSCONN, Count.max_loc_con,
1214 Count.max_loc_cli, Count.totalrestartcount);
1215 }
1216 }
1217
1218 static void
1219 stats_shared(struct Client *source_p, int parc, char *parv[])
1220 {
1221 report_confitem_types(source_p, CONF_ULINE);
1222 }
1223
1224 /* stats_servers()
1225 *
1226 * input - client pointer
1227 * output - none
1228 * side effects - client is shown lists of who connected servers
1229 */
1230 static void
1231 stats_servers(struct Client *source_p, int parc, char *parv[])
1232 {
1233 const dlink_node *ptr = NULL;
1234
1235 DLINK_FOREACH(ptr, serv_list.head)
1236 {
1237 const struct Client *target_p = ptr->data;
1238
1239 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
1240 "v :%s (%s!%s@%s) Idle: %d",
1241 target_p->name,
1242 (target_p->serv->by[0] ? target_p->serv->by : "Remote."),
1243 "*", "*", (int)(CurrentTime - target_p->localClient->lasttime));
1244 }
1245
1246 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
1247 "v :%u Server(s)", dlink_list_length(&serv_list));
1248 }
1249
1250 static void
1251 stats_gecos(struct Client *source_p, int parc, char *parv[])
1252 {
1253 report_confitem_types(source_p, CONF_XLINE);
1254 }
1255
1256 static void
1257 stats_class(struct Client *source_p, int parc, char *parv[])
1258 {
1259 const dlink_node *ptr = NULL;
1260
1261 DLINK_FOREACH(ptr, class_get_list()->head)
1262 {
1263 const struct ClassItem *class = ptr->data;
1264
1265 sendto_one_numeric(source_p, &me, RPL_STATSYLINE, 'Y',
1266 class->name, class->ping_freq,
1267 class->con_freq,
1268 class->max_total, class->max_sendq,
1269 class->max_recvq,
1270 class->ref_count,
1271 class->number_per_cidr, class->cidr_bitlen_ipv4,
1272 class->number_per_cidr, class->cidr_bitlen_ipv6,
1273 class->active ? "active" : "disabled");
1274 }
1275 }
1276
1277 static void
1278 stats_servlinks(struct Client *source_p, int parc, char *parv[])
1279 {
1280 uint64_t sendB = 0, recvB = 0;
1281 time_t uptime = 0;
1282 dlink_node *ptr = NULL;
1283
1284 if (ConfigServerHide.flatten_links && !HasUMode(source_p, UMODE_OPER))
1285 {
1286 sendto_one_numeric(source_p, &me, ERR_NOPRIVILEGES);
1287 return;
1288 }
1289
1290 DLINK_FOREACH(ptr, serv_list.head)
1291 {
1292 struct Client *target_p = ptr->data;
1293
1294 if (HasFlag(target_p, FLAGS_SERVICE) && ConfigServerHide.hide_services)
1295 if (!HasUMode(source_p, UMODE_OPER))
1296 continue;
1297
1298 sendB += target_p->localClient->send.bytes;
1299 recvB += target_p->localClient->recv.bytes;
1300
1301 /* ":%s 211 %s %s %u %u %llu %u %llu :%u %u %s" */
1302 sendto_one_numeric(source_p, &me, RPL_STATSLINKINFO,
1303 get_client_name(target_p, HasUMode(source_p, UMODE_ADMIN) ? SHOW_IP : MASK_IP),
1304 dbuf_length(&target_p->localClient->buf_sendq),
1305 target_p->localClient->send.messages,
1306 target_p->localClient->send.bytes >> 10,
1307 target_p->localClient->recv.messages,
1308 target_p->localClient->recv.bytes >> 10,
1309 (unsigned)(CurrentTime - target_p->localClient->firsttime),
1310 (CurrentTime > target_p->localClient->since) ? (unsigned)(CurrentTime - target_p->localClient->since) : 0,
1311 HasUMode(source_p, UMODE_OPER) ? show_capabilities(target_p) : "TS");
1312 }
1313
1314 sendB >>= 10;
1315 recvB >>= 10;
1316
1317 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT, "? :%u total server(s)",
1318 dlink_list_length(&serv_list));
1319 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT, "? :Sent total: %7.2f %s",
1320 _GMKv(sendB), _GMKs(sendB));
1321 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT, "? :Recv total: %7.2f %s",
1322 _GMKv(recvB), _GMKs(recvB));
1323
1324 uptime = (CurrentTime - me.localClient->since);
1325
1326 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
1327 "? :Server send: %7.2f %s (%4.1f K/s)",
1328 _GMKv((me.localClient->send.bytes>>10)),
1329 _GMKs((me.localClient->send.bytes>>10)),
1330 (float)((float)((me.localClient->send.bytes) >> 10) /
1331 (float)uptime));
1332 sendto_one_numeric(source_p, &me, RPL_STATSDEBUG|SND_EXPLICIT,
1333 "? :Server recv: %7.2f %s (%4.1f K/s)",
1334 _GMKv((me.localClient->recv.bytes>>10)),
1335 _GMKs((me.localClient->recv.bytes>>10)),
1336 (float)((float)((me.localClient->recv.bytes) >> 10) /
1337 (float)uptime));
1338 }
1339
1340 /* parse_stats_args()
1341 *
1342 * inputs - arg count
1343 * - args
1344 * - doall flag
1345 * - wild card or not
1346 * output - pointer to name to use
1347 * side effects -
1348 * common parse routine for m_stats args
1349 *
1350 */
1351 static char *
1352 parse_stats_args(struct Client *source_p, int parc, char *parv[], int *doall, int *wilds)
1353 {
1354 if (parc > 2)
1355 {
1356 char *name = parv[2];
1357
1358 if (!irccmp(name, ID_or_name(&me, source_p)))
1359 *doall = 2;
1360 else if (!match(name, ID_or_name(&me, source_p)))
1361 *doall = 1;
1362
1363 *wilds = has_wildcards(name);
1364
1365 return name;
1366 }
1367
1368 return NULL;
1369 }
1370
1371 static void
1372 stats_L_list(struct Client *source_p, char *name, int doall, int wilds,
1373 dlink_list *list, char statchar)
1374 {
1375 dlink_node *ptr = NULL;
1376
1377 /*
1378 * Send info about connections which match, or all if the
1379 * mask matches from. Only restrictions are on those who
1380 * are invisible not being visible to 'foreigners' who use
1381 * a wild card based search to list it.
1382 */
1383 DLINK_FOREACH(ptr, list->head)
1384 {
1385 struct Client *target_p = ptr->data;
1386
1387 if (HasUMode(target_p, UMODE_INVISIBLE) && (doall || wilds) &&
1388 !(MyConnect(source_p) && HasUMode(source_p, UMODE_OPER)) &&
1389 !HasUMode(target_p, UMODE_OPER) && (target_p != source_p))
1390 continue;
1391
1392 if (!doall && wilds && match(name, target_p->name))
1393 continue;
1394
1395 if (!(doall || wilds) && irccmp(name, target_p->name))
1396 continue;
1397
1398 /*
1399 * This basically shows ips for our opers if it's not a server/admin, or
1400 * its one of our admins.
1401 */
1402 if (MyClient(source_p) && HasUMode(source_p, UMODE_OPER) &&
1403 (HasUMode(source_p, UMODE_ADMIN) ||
1404 (!IsServer(target_p) && !HasUMode(target_p, UMODE_ADMIN) &&
1405 !IsHandshake(target_p) && !IsConnecting(target_p))))
1406 {
1407 sendto_one_numeric(source_p, &me, RPL_STATSLINKINFO,
1408 (IsUpper(statchar)) ?
1409 get_client_name(target_p, SHOW_IP) :
1410 get_client_name(target_p, HIDE_IP),
1411 dbuf_length(&target_p->localClient->buf_sendq),
1412 target_p->localClient->send.messages,
1413 target_p->localClient->send.bytes>>10,
1414 target_p->localClient->recv.messages,
1415 target_p->localClient->recv.bytes>>10,
1416 (unsigned)(CurrentTime - target_p->localClient->firsttime),
1417 (CurrentTime > target_p->localClient->since) ? (unsigned)(CurrentTime - target_p->localClient->since) : 0,
1418 IsServer(target_p) ? show_capabilities(target_p) : "-");
1419 }
1420 else
1421 {
1422 /* If its a hidden ip, an admin, or a server, mask the real IP */
1423 if (IsIPSpoof(target_p) || IsServer(target_p) || HasUMode(target_p, UMODE_ADMIN) ||
1424 IsHandshake(target_p) || IsConnecting(target_p))
1425 sendto_one_numeric(source_p, &me, RPL_STATSLINKINFO,
1426 get_client_name(target_p, MASK_IP),
1427 dbuf_length(&target_p->localClient->buf_sendq),
1428 target_p->localClient->send.messages,
1429 target_p->localClient->send.bytes>>10,
1430 target_p->localClient->recv.messages,
1431 target_p->localClient->recv.bytes>>10,
1432 (unsigned)(CurrentTime - target_p->localClient->firsttime),
1433 (CurrentTime > target_p->localClient->since) ? (unsigned)(CurrentTime - target_p->localClient->since):0,
1434 IsServer(target_p) ? show_capabilities(target_p) : "-");
1435 else /* show the real IP */
1436 sendto_one_numeric(source_p, &me, RPL_STATSLINKINFO,
1437 (IsUpper(statchar)) ?
1438 get_client_name(target_p, SHOW_IP) :
1439 get_client_name(target_p, HIDE_IP),
1440 dbuf_length(&target_p->localClient->buf_sendq),
1441 target_p->localClient->send.messages,
1442 target_p->localClient->send.bytes>>10,
1443 target_p->localClient->recv.messages,
1444 target_p->localClient->recv.bytes>>10,
1445 (unsigned)(CurrentTime - target_p->localClient->firsttime),
1446 (CurrentTime > target_p->localClient->since) ? (unsigned)(CurrentTime - target_p->localClient->since):0,
1447 IsServer(target_p) ? show_capabilities(target_p) : "-");
1448 }
1449 }
1450 }
1451
1452 /*
1453 * stats_L
1454 *
1455 * inputs - pointer to client to report to
1456 * - doall flag
1457 * - wild card or not
1458 * output - NONE
1459 * side effects -
1460 */
1461 static void
1462 stats_L(struct Client *source_p, char *name,int doall,
1463 int wilds, char statchar)
1464 {
1465 stats_L_list(source_p, name, doall, wilds, &unknown_list, statchar);
1466 stats_L_list(source_p, name, doall, wilds, &local_client_list, statchar);
1467 stats_L_list(source_p, name, doall, wilds, &serv_list, statchar);
1468 }
1469
1470 static void
1471 stats_ltrace(struct Client *source_p, int parc, char *parv[])
1472 {
1473 int doall = 0;
1474 int wilds = 0;
1475 char *name = NULL;
1476 char statchar;
1477
1478 if ((name = parse_stats_args(source_p, parc, parv, &doall, &wilds)))
1479 {
1480 statchar = *parv[1];
1481 stats_L(source_p, name, doall, wilds, statchar);
1482 }
1483 else
1484 sendto_one_numeric(source_p, &me, ERR_NEEDMOREPARAMS, "STATS");
1485 }
1486
1487 static const struct StatsStruct
1488 {
1489 const unsigned char letter;
1490 void (*handler)();
1491 const unsigned int need_oper;
1492 const unsigned int need_admin;
1493 } stats_cmd_table[] = {
1494 /* letter function need_oper need_admin */
1495 { 'a', stats_dns_servers, 1, 1 },
1496 { 'A', stats_dns_servers, 1, 1 },
1497 { 'c', stats_connect, 1, 0 },
1498 { 'C', stats_connect, 1, 0 },
1499 { 'd', stats_tdeny, 1, 0 },
1500 { 'D', stats_deny, 1, 0 },
1501 { 'e', stats_exempt, 1, 0 },
1502 { 'E', stats_events, 1, 1 },
1503 { 'f', fd_dump, 1, 1 },
1504 { 'F', fd_dump, 1, 1 },
1505 { 'g', stats_pending_glines, 1, 0 },
1506 { 'G', stats_glines, 1, 0 },
1507 { 'h', stats_hooks, 1, 1 },
1508 { 'H', stats_hubleaf, 1, 0 },
1509 { 'i', stats_auth, 0, 0 },
1510 { 'I', stats_auth, 0, 0 },
1511 { 'k', stats_tklines, 0, 0 },
1512 { 'K', stats_klines, 0, 0 },
1513 { 'l', stats_ltrace, 1, 0 },
1514 { 'L', stats_ltrace, 1, 0 },
1515 { 'm', stats_messages, 0, 0 },
1516 { 'M', stats_messages, 0, 0 },
1517 { 'o', stats_oper, 0, 0 },
1518 { 'O', stats_oper, 0, 0 },
1519 { 'p', stats_operedup, 0, 0 },
1520 { 'P', stats_ports, 0, 0 },
1521 { 'q', stats_resv, 1, 0 },
1522 { 'Q', stats_resv, 1, 0 },
1523 { 'r', stats_usage, 1, 0 },
1524 { 'R', stats_usage, 1, 0 },
1525 { 's', stats_service, 1, 0 },
1526 { 'S', stats_service, 1, 0 },
1527 { 't', stats_tstats, 1, 0 },
1528 { 'T', motd_report, 1, 0 },
1529 { 'u', stats_uptime, 0, 0 },
1530 { 'U', stats_shared, 1, 0 },
1531 { 'v', stats_servers, 1, 0 },
1532 { 'x', stats_gecos, 1, 0 },
1533 { 'X', stats_gecos, 1, 0 },
1534 { 'y', stats_class, 1, 0 },
1535 { 'Y', stats_class, 1, 0 },
1536 { 'z', stats_memory, 1, 0 },
1537 { '?', stats_servlinks, 0, 0 },
1538 { '\0', NULL, 0, 0 }
1539 };
1540
1541 static void
1542 do_stats(struct Client *source_p, int parc, char *parv[])
1543 {
1544 const char statchar = *parv[1];
1545
1546 if (statchar == '\0')
1547 {
1548 sendto_one_numeric(source_p, &me, RPL_ENDOFSTATS, '*');
1549 return;
1550 }
1551
1552 for (const struct StatsStruct *tab = stats_cmd_table; tab->handler; ++tab)
1553 {
1554 if (tab->letter == statchar)
1555 {
1556 /* The stats table says what privs are needed, so check --fl_ */
1557 if ((tab->need_admin && !HasUMode(source_p, UMODE_ADMIN)) ||
1558 (tab->need_oper && !HasUMode(source_p, UMODE_OPER)))
1559 {
1560 sendto_one_numeric(source_p, &me, ERR_NOPRIVILEGES);
1561 break;
1562 }
1563
1564 sendto_realops_flags(UMODE_SPY, L_ALL, SEND_NOTICE,
1565 "STATS %c requested by %s (%s@%s) [%s]",
1566 statchar, source_p->name, source_p->username,
1567 source_p->host, source_p->servptr->name);
1568 tab->handler(source_p, parc, parv);
1569 break;
1570 }
1571 }
1572
1573 sendto_one_numeric(source_p, &me, RPL_ENDOFSTATS, statchar);
1574 }
1575
1576 /*
1577 * m_stats()
1578 * parv[0] = command
1579 * parv[1] = stat letter/command
1580 * parv[2] = (if present) server/mask in stats L
1581 */
1582 static int
1583 m_stats(struct Client *source_p, int parc, char *parv[])
1584 {
1585 static time_t last_used = 0;
1586
1587 /* Check the user is actually allowed to do /stats, and isnt flooding */
1588 if ((last_used + ConfigFileEntry.pace_wait) > CurrentTime)
1589 {
1590 sendto_one_numeric(source_p, &me, RPL_LOAD2HI);
1591 return 0;
1592 }
1593
1594 last_used = CurrentTime;
1595
1596 /* Is the stats meant for us? */
1597 if (!ConfigServerHide.disable_remote_commands)
1598 if (hunt_server(source_p, ":%s STATS %s :%s", 2, parc, parv) != HUNTED_ISME)
1599 return 0;
1600
1601 do_stats(source_p, parc, parv);
1602 return 0;
1603 }
1604
1605 /*
1606 * ms_stats()
1607 * parv[0] = command
1608 * parv[1] = stat letter/command
1609 * parv[2] = (if present) server/mask in stats L, or target
1610 */
1611 static int
1612 ms_stats(struct Client *source_p, int parc, char *parv[])
1613 {
1614 if (hunt_server(source_p, ":%s STATS %s :%s", 2, parc, parv) != HUNTED_ISME)
1615 return 0;
1616
1617 do_stats(source_p, parc, parv);
1618 return 0;
1619 }
1620
1621 static struct Message stats_msgtab =
1622 {
1623 "STATS", 0, 0, 2, MAXPARA, MFLG_SLOW, 0,
1624 { m_unregistered, m_stats, ms_stats, m_ignore, ms_stats, m_ignore }
1625 };
1626
1627 static void
1628 module_init(void)
1629 {
1630 mod_add_cmd(&stats_msgtab);
1631 }
1632
1633 static void
1634 module_exit(void)
1635 {
1636 mod_del_cmd(&stats_msgtab);
1637 }
1638
1639 struct module module_entry =
1640 {
1641 .node = { NULL, NULL, NULL },
1642 .name = NULL,
1643 .version = "$Revision$",
1644 .handle = NULL,
1645 .modinit = module_init,
1646 .modexit = module_exit,
1647 .flags = 0
1648 };

Properties

Name Value
svn:eol-style native
svn:keywords Id Revision