pegasus/anope
1
0
Fork 0
mirror of https://github.com/anope/anope.git synced 2026-07-03 23:43:12 +02:00
Code Activity
Files
38d475d41b9a72a76b0ad4e49bb62f71d56b45df
anope/src/core/os_stats.c
T
certus certus@31f1291d-b8d6-0310-a050-a5561fc1590b 570acfa25f # BUILD : 1.7.14 (1099) # BUGS : # NOTES : removed all that clone stuff 
git-svn-id: svn://svn.anope.org/anope/trunk@1099 31f1291d-b8d6-0310-a050-a5561fc1590b


git-svn-id: http://anope.svn.sourceforge.net/svnroot/anope/trunk@823 5417fbe8-f217-4b02-8779-1006273d7864
2006-07-22 21:13:32 +00:00

449 lines
16 KiB
C
Raw Blame History

/* OperServ core functions
*
* (C) 2003-2005 Anope Team
* Contact us at info@anope.org
*
* Please read COPYING and README for further details.
*
* Based on the original code of Epona by Lara.
* Based on the original code of Services by Andy Church.
*
* $Id$
*
*/
/*************************************************************************/
#include "module.h"
int do_stats(User * u);
void get_operserv_stats(long *nrec, long *memuse);
void myOperServHelp(User * u);
/**
* Create the command, and tell anope about it.
* @param argc Argument count
* @param argv Argument list
* @return MOD_CONT to allow the module, MOD_STOP to stop it
**/
int AnopeInit(int argc, char **argv)
{
Command *c;
moduleAddAuthor("Anope");
moduleAddVersion("$Id$");
moduleSetType(CORE);
c = createCommand("STATS", do_stats, is_services_oper, OPER_HELP_STATS,
-1, -1, -1, -1);
moduleAddCommand(OPERSERV, c, MOD_UNIQUE);
c = createCommand("UPTIME", do_stats, is_services_oper,
OPER_HELP_STATS, -1, -1, -1, -1);
moduleAddCommand(OPERSERV, c, MOD_UNIQUE);
moduleSetOperHelp(myOperServHelp);
return MOD_CONT;
}
/**
* Unload the module
**/
void AnopeFini(void)
{
}
/**
* Add the help response to anopes /os help output.
* @param u The user who is requesting help
**/
void myOperServHelp(User * u)
{
if (is_services_oper(u)) {
notice_lang(s_OperServ, u, OPER_HELP_CMD_STATS);
}
}
/**
* Count servers connected to server s
* @param s The server to start counting from
* @return Amount of servers connected to server s
**/
int stats_count_servers(Server * s)
{
int count = 0;
while (s) {
count++;
if (s->links)
count += stats_count_servers(s->links);
s = s->next;
}
return count;
}
/**
* The /os stats command.
* @param u The user who issued the command
* @param MOD_CONT to continue processing other modules, MOD_STOP to stop processing.
**/
int do_stats(User * u)
{
time_t uptime = time(NULL) - start_time;
char *extra = strtok(NULL, "");
int days = uptime / 86400, hours = (uptime / 3600) % 24,
mins = (uptime / 60) % 60, secs = uptime % 60;
struct tm *tm;
char timebuf[64];
char buf[512];
int buflen;
int i;
if (extra && stricmp(extra, "ALL") != 0) {
if (stricmp(extra, "AKILL") == 0) {
int timeout;
/* AKILLs */
notice_lang(s_OperServ, u, OPER_STATS_AKILL_COUNT,
akills.count);
timeout = AutokillExpiry + 59;
if (timeout >= 172800)
notice_lang(s_OperServ, u, OPER_STATS_AKILL_EXPIRE_DAYS,
timeout / 86400);
else if (timeout >= 86400)
notice_lang(s_OperServ, u, OPER_STATS_AKILL_EXPIRE_DAY);
else if (timeout >= 7200)
notice_lang(s_OperServ, u, OPER_STATS_AKILL_EXPIRE_HOURS,
timeout / 3600);
else if (timeout >= 3600)
notice_lang(s_OperServ, u, OPER_STATS_AKILL_EXPIRE_HOUR);
else if (timeout >= 120)
notice_lang(s_OperServ, u, OPER_STATS_AKILL_EXPIRE_MINS,
timeout / 60);
else if (timeout >= 60)
notice_lang(s_OperServ, u, OPER_STATS_AKILL_EXPIRE_MIN);
else
notice_lang(s_OperServ, u, OPER_STATS_AKILL_EXPIRE_NONE);
if (ircd->sgline) {
/* SGLINEs */
notice_lang(s_OperServ, u, OPER_STATS_SGLINE_COUNT,
sglines.count);
timeout = SGLineExpiry + 59;
if (timeout >= 172800)
notice_lang(s_OperServ, u,
OPER_STATS_SGLINE_EXPIRE_DAYS,
timeout / 86400);
else if (timeout >= 86400)
notice_lang(s_OperServ, u,
OPER_STATS_SGLINE_EXPIRE_DAY);
else if (timeout >= 7200)
notice_lang(s_OperServ, u,
OPER_STATS_SGLINE_EXPIRE_HOURS,
timeout / 3600);
else if (timeout >= 3600)
notice_lang(s_OperServ, u,
OPER_STATS_SGLINE_EXPIRE_HOUR);
else if (timeout >= 120)
notice_lang(s_OperServ, u,
OPER_STATS_SGLINE_EXPIRE_MINS,
timeout / 60);
else if (timeout >= 60)
notice_lang(s_OperServ, u,
OPER_STATS_SGLINE_EXPIRE_MIN);
else
notice_lang(s_OperServ, u,
OPER_STATS_SGLINE_EXPIRE_NONE);
}
if (ircd->sqline) {
/* SQLINEs */
notice_lang(s_OperServ, u, OPER_STATS_SQLINE_COUNT,
sqlines.count);
timeout = SQLineExpiry + 59;
if (timeout >= 172800)
notice_lang(s_OperServ, u,
OPER_STATS_SQLINE_EXPIRE_DAYS,
timeout / 86400);
else if (timeout >= 86400)
notice_lang(s_OperServ, u,
OPER_STATS_SQLINE_EXPIRE_DAY);
else if (timeout >= 7200)
notice_lang(s_OperServ, u,
OPER_STATS_SQLINE_EXPIRE_HOURS,
timeout / 3600);
else if (timeout >= 3600)
notice_lang(s_OperServ, u,
OPER_STATS_SQLINE_EXPIRE_HOUR);
else if (timeout >= 120)
notice_lang(s_OperServ, u,
OPER_STATS_SQLINE_EXPIRE_MINS,
timeout / 60);
else if (timeout >= 60)
notice_lang(s_OperServ, u,
OPER_STATS_SQLINE_EXPIRE_MIN);
else
notice_lang(s_OperServ, u,
OPER_STATS_SQLINE_EXPIRE_NONE);
}
if (ircd->szline) {
/* SZLINEs */
notice_lang(s_OperServ, u, OPER_STATS_SZLINE_COUNT,
szlines.count);
timeout = SZLineExpiry + 59;
if (timeout >= 172800)
notice_lang(s_OperServ, u,
OPER_STATS_SZLINE_EXPIRE_DAYS,
timeout / 86400);
else if (timeout >= 86400)
notice_lang(s_OperServ, u,
OPER_STATS_SZLINE_EXPIRE_DAY);
else if (timeout >= 7200)
notice_lang(s_OperServ, u,
OPER_STATS_SZLINE_EXPIRE_HOURS,
timeout / 3600);
else if (timeout >= 3600)
notice_lang(s_OperServ, u,
OPER_STATS_SZLINE_EXPIRE_HOUR);
else if (timeout >= 120)
notice_lang(s_OperServ, u,
OPER_STATS_SZLINE_EXPIRE_MINS,
timeout / 60);
else if (timeout >= 60)
notice_lang(s_OperServ, u,
OPER_STATS_SZLINE_EXPIRE_MIN);
else
notice_lang(s_OperServ, u,
OPER_STATS_SZLINE_EXPIRE_NONE);
}
return MOD_CONT;
} else if (!stricmp(extra, "RESET")) {
if (is_services_admin(u)) {
maxusercnt = usercnt;
notice_lang(s_OperServ, u, OPER_STATS_RESET);
} else {
notice_lang(s_OperServ, u, PERMISSION_DENIED);
}
return MOD_CONT;
} else if (stricmp(extra, "MEMORY") && stricmp(extra, "UPLINK")) {
notice_lang(s_OperServ, u, OPER_STATS_UNKNOWN_OPTION, extra);
}
}
if (!extra || ((stricmp(extra, "MEMORY") != 0)
&& (stricmp(extra, "UPLINK") != 0))) {
notice_lang(s_OperServ, u, OPER_STATS_CURRENT_USERS, usercnt,
opcnt);
tm = localtime(&maxusertime);
strftime_lang(timebuf, sizeof(timebuf), u,
STRFTIME_DATE_TIME_FORMAT, tm);
notice_lang(s_OperServ, u, OPER_STATS_MAX_USERS, maxusercnt,
timebuf);
if (days > 1) {
notice_lang(s_OperServ, u, OPER_STATS_UPTIME_DHMS,
days, hours, mins, secs);
} else if (days == 1) {
notice_lang(s_OperServ, u, OPER_STATS_UPTIME_1DHMS,
days, hours, mins, secs);
} else {
if (hours > 1) {
if (mins != 1) {
if (secs != 1) {
notice_lang(s_OperServ, u, OPER_STATS_UPTIME_HMS,
hours, mins, secs);
} else {
notice_lang(s_OperServ, u, OPER_STATS_UPTIME_HM1S,
hours, mins, secs);
}
} else {
if (secs != 1) {
notice_lang(s_OperServ, u, OPER_STATS_UPTIME_H1MS,
hours, mins, secs);
} else {
notice_lang(s_OperServ, u, OPER_STATS_UPTIME_H1M1S,
hours, mins, secs);
}
}
} else if (hours == 1) {
if (mins != 1) {
if (secs != 1) {
notice_lang(s_OperServ, u, OPER_STATS_UPTIME_1HMS,
hours, mins, secs);
} else {
notice_lang(s_OperServ, u, OPER_STATS_UPTIME_1HM1S,
hours, mins, secs);
}
} else {
if (secs != 1) {
notice_lang(s_OperServ, u, OPER_STATS_UPTIME_1H1MS,
hours, mins, secs);
} else {
notice_lang(s_OperServ, u,
OPER_STATS_UPTIME_1H1M1S, hours, mins,
secs);
}
}
} else {
if (mins != 1) {
if (secs != 1) {
notice_lang(s_OperServ, u, OPER_STATS_UPTIME_MS,
mins, secs);
} else {
notice_lang(s_OperServ, u, OPER_STATS_UPTIME_M1S,
mins, secs);
}
} else {
if (secs != 1) {
notice_lang(s_OperServ, u, OPER_STATS_UPTIME_1MS,
mins, secs);
} else {
notice_lang(s_OperServ, u, OPER_STATS_UPTIME_1M1S,
mins, secs);
}
}
}
}
}
if (extra && ((stricmp(extra, "ALL") == 0)
|| (stricmp(extra, "UPLINK") == 0))
&& is_services_admin(u)) {
buf[0] = '\0';
buflen = 511; /* How confusing, this is the amount of space left! */
for (i = 0; capab_info[i].token; i++) {
if (uplink_capab & capab_info[i].flag) {
strncat(buf, " ", buflen);
buflen--;
strncat(buf, capab_info[i].token, buflen);
buflen -= strlen(capab_info[i].token);
/* Special cases */
if (capab_info[i].flag == CAPAB_CHANMODE) {
strncat(buf, "=", buflen);
buflen--;
strncat(buf, ircd->chanmodes, buflen);
buflen -= strlen(ircd->chanmodes);
}
if (capab_info[i].flag == CAPAB_NICKCHARS) {
strncat(buf, "=", buflen);
buflen--;
if (ircd->nickchars) {
strncat(buf, ircd->nickchars, buflen);
buflen -= strlen(ircd->nickchars);
} /* leave blank if it was null */
}
}
}
notice_lang(s_OperServ, u, OPER_STATS_UPLINK_SERVER,
serv_uplink->name);
notice_lang(s_OperServ, u, OPER_STATS_UPLINK_CAPAB, buf);
notice_lang(s_OperServ, u, OPER_STATS_UPLINK_SERVER_COUNT,
stats_count_servers(serv_uplink));
}
if (extra && ((stricmp(extra, "ALL") == 0)
|| (stricmp(extra, "MEMORY") == 0))
&& is_services_admin(u)) {
long count, mem;
notice_lang(s_OperServ, u, OPER_STATS_BYTES_READ,
total_read / 1024);
notice_lang(s_OperServ, u, OPER_STATS_BYTES_WRITTEN,
total_written / 1024);
get_user_stats(&count, &mem);
notice_lang(s_OperServ, u, OPER_STATS_USER_MEM, count,
(mem + 512) / 1024);
get_channel_stats(&count, &mem);
notice_lang(s_OperServ, u, OPER_STATS_CHANNEL_MEM, count,
(mem + 512) / 1024);
get_core_stats(&count, &mem);
notice_lang(s_OperServ, u, OPER_STATS_GROUPS_MEM, count,
(mem + 512) / 1024);
get_aliases_stats(&count, &mem);
notice_lang(s_OperServ, u, OPER_STATS_ALIASES_MEM, count,
(mem + 512) / 1024);
get_chanserv_stats(&count, &mem);
notice_lang(s_OperServ, u, OPER_STATS_CHANSERV_MEM, count,
(mem + 512) / 1024);
get_botserv_stats(&count, &mem);
notice_lang(s_OperServ, u, OPER_STATS_BOTSERV_MEM, count,
(mem + 512) / 1024);
get_operserv_stats(&count, &mem);
notice_lang(s_OperServ, u, OPER_STATS_OPERSERV_MEM, count,
(mem + 512) / 1024);
get_session_stats(&count, &mem);
notice_lang(s_OperServ, u, OPER_STATS_SESSIONS_MEM, count,
(mem + 512) / 1024);
}
return MOD_CONT;
}
void get_operserv_stats(long *nrec, long *memuse)
{
int i;
long mem = 0, count = 0, mem2 = 0, count2 = 0;
Akill *ak;
SXLine *sx;
count += akills.count;
mem += akills.capacity;
mem += akills.count * sizeof(Akill);
for (i = 0; i < akills.count; i++) {
ak = akills.list[i];
mem += strlen(ak->user) + 1;
mem += strlen(ak->host) + 1;
mem += strlen(ak->by) + 1;
mem += strlen(ak->reason) + 1;
}
if (ircd->sgline) {
count += sglines.count;
mem += sglines.capacity;
mem += sglines.count * sizeof(SXLine);
for (i = 0; i < sglines.count; i++) {
sx = sglines.list[i];
mem += strlen(sx->mask) + 1;
mem += strlen(sx->by) + 1;
mem += strlen(sx->reason) + 1;
}
}
if (ircd->sqline) {
count += sqlines.count;
mem += sqlines.capacity;
mem += sqlines.count * sizeof(SXLine);
for (i = 0; i < sqlines.count; i++) {
sx = sqlines.list[i];
mem += strlen(sx->mask) + 1;
mem += strlen(sx->by) + 1;
mem += strlen(sx->reason) + 1;
}
}
if (ircd->szline) {
count += szlines.count;
mem += szlines.capacity;
mem += szlines.count * sizeof(SXLine);
for (i = 0; i < szlines.count; i++) {
sx = szlines.list[i];
mem += strlen(sx->mask) + 1;
mem += strlen(sx->by) + 1;
mem += strlen(sx->reason) + 1;
}
}
get_news_stats(&count2, &mem2);
count += count2;
mem += mem2;
get_exception_stats(&count2, &mem2);
count += count2;
mem += mem2;
*nrec = count;
*memuse = mem;
}
View Git Blame Copy Permalink