814 lines
27 KiB
C
814 lines
27 KiB
C
/*
|
|
* IRC - Internet Relay Chat, ircd/s_stats.c
|
|
* Copyright (C) 2000 Joseph Bongaarts
|
|
*
|
|
* See file AUTHORS in IRC package for additional names of
|
|
* the programmers.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 1, or (at your option)
|
|
* any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*/
|
|
#include "config.h"
|
|
|
|
#include "class.h"
|
|
#include "client.h"
|
|
#include "gline.h"
|
|
#include "hash.h"
|
|
#include "ircd.h"
|
|
#include "ircd_chattr.h"
|
|
#include "ircd_events.h"
|
|
#include "ircd_features.h"
|
|
#include "ircd_crypt.h"
|
|
#include "ircd_log.h"
|
|
#include "ircd_reply.h"
|
|
#include "ircd_string.h"
|
|
#include "listener.h"
|
|
#include "list.h"
|
|
#include "match.h"
|
|
#include "motd.h"
|
|
#include "msg.h"
|
|
#include "msgq.h"
|
|
#include "numeric.h"
|
|
#include "numnicks.h"
|
|
#include "querycmds.h"
|
|
#include "res.h"
|
|
#include "s_auth.h"
|
|
#include "s_bsd.h"
|
|
#include "s_conf.h"
|
|
#include "s_debug.h"
|
|
#include "s_misc.h"
|
|
#include "s_serv.h"
|
|
#include "s_stats.h"
|
|
#include "s_user.h"
|
|
#include "send.h"
|
|
#include "shun.h"
|
|
#include "struct.h"
|
|
#include "userload.h"
|
|
#include "zline.h"
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/time.h>
|
|
|
|
/** @file
|
|
* @brief Report configuration lines and other statistics from this
|
|
* server.
|
|
* @version $Id: s_stats.c 1922 2010-01-02 04:00:13Z entrope $
|
|
*
|
|
* Note: The info is reported in the order the server uses
|
|
* it--not reversed as in ircd.conf!
|
|
*/
|
|
|
|
/* The statsinfo array should only be used in this file, but just TRY
|
|
* telling the compiler that you want to forward declare a static
|
|
* array without specifying a length, and see how it responds. So we
|
|
* forward declare it "extern".
|
|
*/
|
|
extern struct StatDesc statsinfo[];
|
|
|
|
/** Report items from #GlobalConfList.
|
|
* Uses sd->sd_funcdata as a filter for ConfItem::status.
|
|
* @param[in] sptr Client requesting statistics.
|
|
* @param[in] sd Stats descriptor for request.
|
|
* @param[in] param Extra parameter from user (ignored).
|
|
*/
|
|
static void
|
|
stats_configured_links(struct Client *sptr, const struct StatDesc* sd,
|
|
char* param)
|
|
{
|
|
static char null[] = "<NULL>";
|
|
struct ConfItem *tmp;
|
|
unsigned short int port;
|
|
int maximum;
|
|
char *host, *name, *username, *hub_limit;
|
|
|
|
for (tmp = GlobalConfList; tmp; tmp = tmp->next)
|
|
{
|
|
if ((tmp->status & sd->sd_funcdata))
|
|
{
|
|
host = BadPtr(tmp->host) ? null : tmp->host;
|
|
name = BadPtr(tmp->name) ? null : tmp->name;
|
|
username = BadPtr(tmp->username) ? null : tmp->username;
|
|
hub_limit = BadPtr(tmp->hub_limit) ? null : tmp->hub_limit;
|
|
maximum = tmp->maximum;
|
|
port = tmp->address.port;
|
|
|
|
if (tmp->status & CONF_UWORLD)
|
|
send_reply(sptr, RPL_STATSULINE, host);
|
|
else if (tmp->status & CONF_SERVER)
|
|
send_reply(sptr, RPL_STATSCLINE, name, host, port, maximum, hub_limit, get_conf_class(tmp));
|
|
else if (tmp->status & CONF_CLIENT)
|
|
send_reply(sptr, RPL_STATSILINE,
|
|
(tmp->username ? tmp->username : ""), (tmp->username ? "@" : ""),
|
|
(tmp->host ? tmp->host : "*"), maximum,
|
|
(name[0] == ':' ? "0" : ""), (tmp->name ? tmp->name : "*"),
|
|
port, get_conf_class(tmp));
|
|
else if (tmp->status & CONF_OPERATOR)
|
|
{
|
|
int global = FlagHas(&tmp->privs_dirty, PRIV_PROPAGATE)
|
|
? FlagHas(&tmp->privs, PRIV_PROPAGATE)
|
|
: FlagHas(&tmp->conn_class->privs, PRIV_PROPAGATE);
|
|
send_reply(sptr, RPL_STATSOLINE, global ? 'O' : 'o',
|
|
username, host, name, get_conf_class(tmp));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Report connection rules from conf_get_crule_list().
|
|
* Uses sd->sd_funcdata as a filter for CRuleConf::type.
|
|
* @param[in] to Client requesting statistics.
|
|
* @param[in] sd Stats descriptor for request.
|
|
* @param[in] param Extra parameter from user (ignored).
|
|
*/
|
|
static void
|
|
stats_crule_list(struct Client* to, const struct StatDesc *sd,
|
|
char *param)
|
|
{
|
|
const struct CRuleConf* p = conf_get_crule_list();
|
|
|
|
for ( ; p; p = p->next)
|
|
{
|
|
if (p->type & sd->sd_funcdata)
|
|
send_reply(to, RPL_STATSDLINE, (p->type & CRULE_ALL ? 'D' : 'd'), p->hostmask, p->rule);
|
|
}
|
|
}
|
|
|
|
/** Report active event engine name.
|
|
* @param[in] to Client requesting statistics.
|
|
* @param[in] sd Stats descriptor for request (ignored).
|
|
* @param[in] param Extra parameter from user (ignored).
|
|
*/
|
|
static void
|
|
stats_engine(struct Client *to, const struct StatDesc *sd, char *param)
|
|
{
|
|
send_reply(to, RPL_STATSENGINE, engine_name());
|
|
}
|
|
|
|
/** Report client access lists.
|
|
* @param[in] to Client requesting statistics.
|
|
* @param[in] sd Stats descriptor for request.
|
|
* @param[in] param Filter for hostname or IP (NULL to show all).
|
|
*/
|
|
static void
|
|
stats_access(struct Client *to, const struct StatDesc *sd, char *param)
|
|
{
|
|
struct ConfItem *aconf;
|
|
int wilds = 0;
|
|
int count = 1000;
|
|
|
|
if (!param)
|
|
{
|
|
stats_configured_links(to, sd, param);
|
|
return;
|
|
}
|
|
|
|
wilds = string_has_wildcards(param);
|
|
|
|
for (aconf = GlobalConfList; aconf; aconf = aconf->next)
|
|
{
|
|
if (aconf->status != CONF_CLIENT)
|
|
continue;
|
|
if (wilds ? ((aconf->host && !mmatch(aconf->host, param))
|
|
|| (aconf->name && !mmatch(aconf->name, param)))
|
|
: ((aconf->host && !match(param, aconf->host))
|
|
|| (aconf->name && !match(param, aconf->name))))
|
|
{
|
|
send_reply(to, RPL_STATSILINE,
|
|
(aconf->username ? aconf->username : ""), (aconf->username ? "@" : ""),
|
|
(aconf->host ? aconf->host : "*"), aconf->maximum,
|
|
(aconf->name && aconf->name[0] == ':' ? "0":""),
|
|
aconf->name ? aconf->name : "*",
|
|
aconf->address.port, get_conf_class(aconf));
|
|
if (--count == 0)
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/** Report DenyConf entries.
|
|
* @param[in] to Client requesting list.
|
|
*/
|
|
static void
|
|
report_deny_list(struct Client* to)
|
|
{
|
|
const struct DenyConf* p = conf_get_deny_list();
|
|
for ( ; p; p = p->next)
|
|
send_reply(to, RPL_STATSKLINE, p->bits > 0 ? 'k' : 'K',
|
|
p->usermask ? p->usermask : "*",
|
|
p->hostmask ? p->hostmask : "*",
|
|
p->message ? p->message : "(none)",
|
|
p->realmask ? p->realmask : "*",
|
|
p->version ? p->version : "*",
|
|
p->countrymask ? p->countrymask : "*",
|
|
p->continentmask ? p->continentmask : "*");
|
|
}
|
|
|
|
/** Report K/k-lines to a user.
|
|
* @param[in] sptr Client requesting statistics.
|
|
* @param[in] sd Stats descriptor for request (ignored).
|
|
* @param[in] mask Filter for hostmasks to show.
|
|
*/
|
|
static void
|
|
stats_klines(struct Client *sptr, const struct StatDesc *sd, char *mask)
|
|
{
|
|
int wilds = 0;
|
|
int count = 3;
|
|
int limit_query = 0;
|
|
char *user = 0;
|
|
char *host;
|
|
const struct DenyConf* conf;
|
|
|
|
if (!IsAnOper(sptr))
|
|
limit_query = 1;
|
|
|
|
if (!mask)
|
|
{
|
|
if (limit_query)
|
|
need_more_params(sptr, "STATS K");
|
|
else
|
|
report_deny_list(sptr);
|
|
return;
|
|
}
|
|
|
|
if (!limit_query)
|
|
{
|
|
wilds = string_has_wildcards(mask);
|
|
count = 1000;
|
|
}
|
|
if ((host = strchr(mask, '@')))
|
|
{
|
|
user = mask;
|
|
*host++ = '\0';
|
|
}
|
|
else
|
|
host = mask;
|
|
|
|
for (conf = conf_get_deny_list(); conf; conf = conf->next)
|
|
{
|
|
/* Skip this block if the user is searching for a user-matching
|
|
* mask but the current Kill doesn't have a usermask, or if user
|
|
* is searching for a host-matching mask but the Kill has no
|
|
* hostmask, or if the user mask is specified and doesn't match,
|
|
* or if the host mask is specified and doesn't match.
|
|
*/
|
|
if ((user && !conf->usermask)
|
|
|| (host && !conf->hostmask)
|
|
|| (user && conf->usermask
|
|
&& (wilds
|
|
? mmatch(user, conf->usermask)
|
|
: match(conf->usermask, user)))
|
|
|| (host && conf->hostmask
|
|
&& (wilds
|
|
? mmatch(host, conf->hostmask)
|
|
: match(conf->hostmask, host))))
|
|
continue;
|
|
send_reply(sptr, RPL_STATSKLINE, conf->bits > 0 ? 'k' : 'K',
|
|
conf->usermask ? conf->usermask : "*",
|
|
conf->hostmask ? conf->hostmask : "*",
|
|
conf->message ? conf->message : "(none)",
|
|
conf->realmask ? conf->realmask : "*");
|
|
if (--count == 0)
|
|
return;
|
|
}
|
|
}
|
|
|
|
/** Report on servers and/or clients connected to the network.
|
|
* @param[in] sptr Client requesting statistics.
|
|
* @param[in] sd Stats descriptor for request (ignored).
|
|
* @param[in] name Filter for client names to show.
|
|
*/
|
|
static void
|
|
stats_links(struct Client* sptr, const struct StatDesc* sd, char* name)
|
|
{
|
|
struct Client *acptr;
|
|
int i;
|
|
int wilds = 0;
|
|
|
|
if (name)
|
|
wilds = string_has_wildcards(name);
|
|
|
|
/*
|
|
* Send info about connections which match, or all if the
|
|
* mask matches me.name. Only restrictions are on those who
|
|
* are invisible not being visible to 'foreigners' who use
|
|
* a wild card based search to list it.
|
|
*/
|
|
send_reply(sptr, SND_EXPLICIT | RPL_STATSLINKINFO, "Connection SendQ "
|
|
"SendM SendKBytes RcveM RcveKBytes :Open since");
|
|
for (i = 0; i <= HighestFd; i++)
|
|
{
|
|
if (!(acptr = LocalClientArray[i]))
|
|
continue;
|
|
/* Don't return clients when this is a request for `all' */
|
|
if (!name && IsUser(acptr))
|
|
continue;
|
|
/* Don't show invisible people to non opers unless they know the nick */
|
|
if (IsInvisible(acptr) && (!name || wilds) && !IsAnOper(acptr) &&
|
|
(acptr != sptr))
|
|
continue;
|
|
/* Only show the ones that match the given mask - if any */
|
|
if (name && wilds && match(name, cli_name(acptr)))
|
|
continue;
|
|
/* Skip all that do not match the specific query */
|
|
if (!(!name || wilds) && 0 != ircd_strcmp(name, cli_name(acptr)))
|
|
continue;
|
|
send_reply(sptr, SND_EXPLICIT | RPL_STATSLINKINFO,
|
|
"%s %u %u %Lu %u %Lu :%Tu",
|
|
(*(cli_name(acptr))) ? cli_name(acptr) : "<unregistered>",
|
|
(int)MsgQLength(&(cli_sendQ(acptr))), (int)cli_sendM(acptr),
|
|
(cli_sendB(acptr) >> 10), (int)cli_receiveM(acptr),
|
|
(cli_receiveB(acptr) >> 10), CurrentTime - cli_firsttime(acptr));
|
|
}
|
|
}
|
|
|
|
/** Report on loaded modules.
|
|
* @param[in] to Client requesting statistics.
|
|
* @param[in] sd Stats descriptor for request (ignored).
|
|
* @param[in] param Extra parameter from user (ignored).
|
|
*/
|
|
static void
|
|
stats_modules(struct Client* to, const struct StatDesc* sd, char* param)
|
|
{
|
|
crypt_mechs_t* mechs;
|
|
|
|
send_reply(to, SND_EXPLICIT | RPL_STATSLLINE,
|
|
"Module Description Entry Point");
|
|
|
|
/* atm the only "modules" we have are the crypto mechanisms,
|
|
eventualy they'll be part of a global dl module list, for now
|
|
i'll just output data about them -- hikari */
|
|
|
|
if(crypt_mechs_root == NULL)
|
|
return;
|
|
|
|
mechs = crypt_mechs_root->next;
|
|
|
|
for(;;)
|
|
{
|
|
if(mechs == NULL)
|
|
return;
|
|
|
|
send_reply(to, SND_EXPLICIT | RPL_STATSLLINE,
|
|
"%s %s 0x%X",
|
|
mechs->mech->shortname, mechs->mech->description,
|
|
mechs->mech->crypt_function);
|
|
|
|
mechs = mechs->next;
|
|
}
|
|
|
|
}
|
|
|
|
/** Report how many times each command has been used.
|
|
* @param[in] to Client requesting statistics.
|
|
* @param[in] sd Stats descriptor for request (ignored).
|
|
* @param[in] param Extra parameter from user (ignored).
|
|
*/
|
|
static void
|
|
stats_commands(struct Client* to, const struct StatDesc* sd, char* param)
|
|
{
|
|
struct Message *mptr;
|
|
|
|
for (mptr = msgtab; mptr->cmd; mptr++)
|
|
if (mptr->count)
|
|
send_reply(to, RPL_STATSCOMMANDS, mptr->cmd, mptr->count, mptr->bytes);
|
|
}
|
|
|
|
/** List channel quarantines.
|
|
* @param[in] to Client requesting statistics.
|
|
* @param[in] sd Stats descriptor for request (ignored).
|
|
* @param[in] param Filter for quarantined channel names.
|
|
*/
|
|
static void
|
|
stats_quarantine(struct Client* to, const struct StatDesc* sd, char* param)
|
|
{
|
|
struct qline *qline;
|
|
|
|
for (qline = GlobalQuarantineList; qline; qline = qline->next)
|
|
{
|
|
if (param && match(param, qline->chname)) /* narrow search */
|
|
continue;
|
|
send_reply(to, RPL_STATSQLINE, qline->chname, qline->reason);
|
|
}
|
|
}
|
|
|
|
/** List service pseudo-command mappings.
|
|
* @param[in] to Client requesting statistics.
|
|
* @param[in] sd Stats descriptor for request (ignored).
|
|
* @param[in] param Extra parameter from user (ignored).
|
|
*/
|
|
static void
|
|
stats_mapping(struct Client *to, const struct StatDesc* sd, char* param)
|
|
{
|
|
struct s_map *map;
|
|
|
|
send_reply(to, RPL_STATSRLINE, "Command", "Name", "Prepend", "Target");
|
|
for (map = GlobalServiceMapList; map; map = map->next) {
|
|
struct nick_host *nh;
|
|
for (nh = map->services; nh; nh = nh->next) {
|
|
send_reply(to, RPL_STATSRLINE, map->command, map->name,
|
|
(map->prepend ? map->prepend : "*"), nh->nick);
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Report server uptime and maximum connection/client counts.
|
|
* @param[in] to Client requesting statistics.
|
|
* @param[in] sd Stats descriptor for request (ignored).
|
|
* @param[in] param Extra parameter from user (ignored).
|
|
*/
|
|
static void
|
|
stats_uptime(struct Client* to, const struct StatDesc* sd, char* param)
|
|
{
|
|
time_t nowr;
|
|
|
|
nowr = CurrentTime - cli_since(&me);
|
|
send_reply(to, RPL_STATSUPTIME, nowr / 86400, (nowr / 3600) % 24,
|
|
(nowr / 60) % 60, nowr % 60);
|
|
send_reply(to, RPL_STATSCONN, max_connection_count, max_client_count);
|
|
}
|
|
|
|
/** Verbosely report on servers connected to the network.
|
|
* If sd->sd_funcdata != 0, then display in a more human-friendly format.
|
|
* @param[in] sptr Client requesting statistics.
|
|
* @param[in] sd Stats descriptor for request.
|
|
* @param[in] param Filter for server names to display.
|
|
*/
|
|
static void
|
|
stats_servers_verbose(struct Client* sptr, const struct StatDesc* sd,
|
|
char* param)
|
|
{
|
|
struct Client *acptr;
|
|
const char *fmt;
|
|
|
|
/*
|
|
* lowercase 'v' is for human-readable,
|
|
* uppercase 'V' is for machine-readable
|
|
*/
|
|
if (sd->sd_funcdata) {
|
|
send_reply(sptr, SND_EXPLICIT | RPL_STATSVERBOSE,
|
|
"%-20s %-20s Flags Hops Numeric Lag RTT Up Down "
|
|
"Clients/Max Proto %-10s :Info", "Servername", "Uplink",
|
|
"LinkTS");
|
|
fmt = "%-20s %-20s %c%c%c%c%c%c %4i %s %-4i %5i %4i %4i %4i %5i %5i P%-2i %Tu :%s";
|
|
} else {
|
|
fmt = "%s %s %c%c%c%c%c%c %i %s %i %i %i %i %i %i %i P%i %Tu :%s";
|
|
}
|
|
|
|
for (acptr = GlobalClientList; acptr; acptr = cli_next(acptr))
|
|
{
|
|
if (!IsServer(acptr) && !IsMe(acptr))
|
|
continue;
|
|
/* narrow search */
|
|
if (param && match(param, cli_name(acptr)))
|
|
continue;
|
|
send_reply(sptr, SND_EXPLICIT | RPL_STATSVERBOSE, fmt,
|
|
cli_name(acptr),
|
|
cli_name(cli_serv(acptr)->up),
|
|
IsBurst(acptr) ? 'B' : '-',
|
|
IsBurstAck(acptr) ? 'A' : '-',
|
|
IsHub(acptr) ? 'H' : '-',
|
|
IsService(acptr) ? 'S' : '-',
|
|
IsIPv6(acptr) ? '6' : '-',
|
|
IsOpLevels(acptr) ? 'O' : '-',
|
|
cli_hopcount(acptr),
|
|
NumServ(acptr),
|
|
base64toint(cli_yxx(acptr)),
|
|
cli_serv(acptr)->lag,
|
|
cli_serv(acptr)->asll_rtt,
|
|
cli_serv(acptr)->asll_to,
|
|
cli_serv(acptr)->asll_from,
|
|
(acptr == &me ? UserStats.local_clients : cli_serv(acptr)->clients),
|
|
cli_serv(acptr)->nn_mask,
|
|
cli_serv(acptr)->prot,
|
|
cli_serv(acptr)->timestamp,
|
|
cli_info(acptr));
|
|
}
|
|
}
|
|
|
|
static void
|
|
stats_webirc(struct Client* to, const struct StatDesc *sd, char* param)
|
|
{
|
|
const struct WebIRCConf *wline = conf_get_webirc_list();
|
|
char flags[6];
|
|
int i = 0;
|
|
|
|
for (; wline; wline = wline->next) {
|
|
memset(&flags, 0, 4);
|
|
flags[0] = '*';
|
|
i = 0;
|
|
|
|
if (FlagHas(&wline->flags, WFLAG_USERIDENT))
|
|
flags[i++] = 'u';
|
|
if (FlagHas(&wline->flags, WFLAG_NOIDENT))
|
|
flags[i++] = 'i';
|
|
if (FlagHas(&wline->flags, WFLAG_STRIPSSLFP))
|
|
flags[i++] = 'f';
|
|
if (FlagHas(&wline->flags, WFLAG_USEOPTIONS))
|
|
flags[i++] = 'o';
|
|
if (FlagHas(&wline->flags, WFLAG_TRUSTACCOUNT))
|
|
flags[i++] = 'a';
|
|
|
|
send_reply(to, RPL_STATSWLINE, wline->usermask, wline->hostmask,
|
|
(wline->ident ? wline->ident : "(none)"), flags,
|
|
(wline->description ? wline->description : ""));
|
|
}
|
|
}
|
|
|
|
static void
|
|
stats_excepts(struct Client* to, const struct StatDesc *sd, char* param)
|
|
{
|
|
const struct ExceptConf *eline = conf_get_except_list();
|
|
|
|
for (; eline; eline = eline->next)
|
|
send_reply(to, RPL_STATSELINE, eline->usermask, eline->hostmask,
|
|
(eline->flags & EFLAG_SHUN ? "s" : ""),
|
|
(eline->flags & EFLAG_KLINE ? "k" : ""),
|
|
(eline->flags & EFLAG_GLINE ? "g" : ""),
|
|
(eline->flags & EFLAG_ZLINE ? "z" : ""),
|
|
(eline->flags & EFLAG_IDENT ? "i" : ""),
|
|
(eline->flags & EFLAG_RDNS ? "r" : ""),
|
|
(eline->flags & EFLAG_IPCHECK ? "I" : ""),
|
|
(eline->flags & EFLAG_TARGLIMIT ? "t" : ""),
|
|
(eline->flags & EFLAG_LISTDELAY ? "l" : ""));
|
|
}
|
|
|
|
static void
|
|
stats_spoofhost(struct Client* to, const struct StatDesc *sd, char* param)
|
|
{
|
|
int y = 1, i = 1;
|
|
char* type;
|
|
const struct SHostConf* sconf = conf_get_shost_list();
|
|
|
|
for ( ; sconf; sconf = sconf->next) {
|
|
if (param && match(param, sconf->spoofhost)) { /* narrow search */
|
|
if (IsAnOper(to))
|
|
y++;
|
|
else
|
|
if (!EmptyString(sconf->passwd))
|
|
y++;
|
|
continue;
|
|
}
|
|
|
|
if (sconf->flags & SHFLAG_AUTOAPPLY)
|
|
type = "auto";
|
|
else if (IsAnOper(to) && EmptyString(sconf->passwd))
|
|
type = "oper";
|
|
else
|
|
type = "user";
|
|
|
|
send_reply(to, RPL_STATSSLINE, (param) ? y : i,
|
|
type, sconf->spoofhost,
|
|
(!IsAnOper(to) || EmptyString(sconf->usermask)) ? "" : sconf->usermask,
|
|
(!IsAnOper(to) || EmptyString(sconf->hostmask)) ? "" : sconf->hostmask);
|
|
i++;
|
|
}
|
|
}
|
|
|
|
/** Display objects allocated (and total memory used by them) for
|
|
* several types of structures.
|
|
* @param[in] to Client requesting statistics.
|
|
* @param[in] sd Stats descriptor for request (ignored).
|
|
* @param[in] param Extra parameter from user (ignored).
|
|
*/
|
|
static void
|
|
stats_meminfo(struct Client* to, const struct StatDesc* sd, char* param)
|
|
{
|
|
extern void bans_send_meminfo(struct Client *cptr);
|
|
|
|
class_send_meminfo(to);
|
|
bans_send_meminfo(to);
|
|
send_listinfo(to, 0);
|
|
}
|
|
|
|
/** Send a list of available statistics.
|
|
* @param[in] to Client requesting statistics.
|
|
* @param[in] sd Stats descriptor for request.
|
|
* @param[in] param Extra parameter from user (ignored).
|
|
*/
|
|
static void
|
|
stats_help(struct Client* to, const struct StatDesc* sd, char* param)
|
|
{
|
|
struct StatDesc *asd;
|
|
|
|
/* only if it's my user */
|
|
if (MyUser(to))
|
|
for (asd = statsinfo; asd->sd_name; asd++)
|
|
if (asd != sd) /* don't send the help for us */
|
|
sendcmdto_one(&me, CMD_NOTICE, to, "%C :%c (%s) - %s", to, asd->sd_c,
|
|
asd->sd_name, asd->sd_desc);
|
|
}
|
|
|
|
/** Contains information about all statistics. */
|
|
struct StatDesc statsinfo[] = {
|
|
{ 'a', "nameservers", STAT_FLAG_OPERFEAT|STAT_FLAG_LOCONLY, FEAT_HIS_STATS_a,
|
|
report_dns_servers, 0,
|
|
"DNS servers." },
|
|
{ 'c', "connect", STAT_FLAG_OPERFEAT, FEAT_HIS_STATS_c,
|
|
stats_configured_links, CONF_SERVER,
|
|
"Remote server connection lines." },
|
|
{ 'd', "maskrules", (STAT_FLAG_OPERFEAT | STAT_FLAG_CASESENS), FEAT_HIS_STATS_d,
|
|
stats_crule_list, CRULE_MASK,
|
|
"Dynamic routing configuration." },
|
|
{ 'D', "crules", (STAT_FLAG_OPERFEAT | STAT_FLAG_CASESENS), FEAT_HIS_STATS_d,
|
|
stats_crule_list, CRULE_ALL,
|
|
"Dynamic routing configuration." },
|
|
{ 'e', "engine", (STAT_FLAG_OPERFEAT | STAT_FLAG_CASESENS), FEAT_HIS_STATS_e,
|
|
stats_engine, 0,
|
|
"Report server event loop engine." },
|
|
{ 'E', "excepts", (STAT_FLAG_OPERFEAT | STAT_FLAG_CASESENS), FEAT_HIS_STATS_E,
|
|
stats_excepts, 0,
|
|
"Exception list." },
|
|
{ 'f', "features", (STAT_FLAG_OPERFEAT | STAT_FLAG_CASESENS), FEAT_HIS_STATS_f,
|
|
feature_report, 0,
|
|
"Feature settings." },
|
|
{ 'F', "featuresall", (STAT_FLAG_OPERFEAT | STAT_FLAG_CASESENS), FEAT_HIS_STATS_f,
|
|
feature_report, 1,
|
|
"All feature settings, including defaulted values." },
|
|
{ 'g', "glines", STAT_FLAG_OPERFEAT, FEAT_HIS_STATS_g,
|
|
gline_stats, 0,
|
|
"Global bans (G-lines)." },
|
|
{ 'i', "access", (STAT_FLAG_OPERFEAT | STAT_FLAG_VARPARAM), FEAT_HIS_STATS_i,
|
|
stats_access, CONF_CLIENT,
|
|
"Connection authorization lines." },
|
|
{ 'j', "histogram", (STAT_FLAG_OPERFEAT | STAT_FLAG_CASESENS), FEAT_HIS_STATS_j,
|
|
msgq_histogram, 0,
|
|
"Message length histogram." },
|
|
{ 'J', "jupes", (STAT_FLAG_OPERFEAT | STAT_FLAG_CASESENS), FEAT_HIS_STATS_J,
|
|
stats_nickjupes, 0,
|
|
"Nickname jupes." },
|
|
{ 'k', "klines", (STAT_FLAG_OPERFEAT | STAT_FLAG_VARPARAM), FEAT_HIS_STATS_k,
|
|
stats_klines, 0,
|
|
"Local bans (K-Lines)." },
|
|
{ 'l', "links", (STAT_FLAG_OPERFEAT | STAT_FLAG_VARPARAM | STAT_FLAG_CASESENS),
|
|
FEAT_HIS_STATS_l,
|
|
stats_links, 0,
|
|
"Current connections information." },
|
|
{ 'L', "modules", (STAT_FLAG_OPERFEAT | STAT_FLAG_CASESENS),
|
|
FEAT_HIS_STATS_L,
|
|
stats_modules, 0,
|
|
"Dynamically loaded modules." },
|
|
{ 'm', "commands", (STAT_FLAG_OPERFEAT | STAT_FLAG_CASESENS), FEAT_HIS_STATS_m,
|
|
stats_commands, 0,
|
|
"Message usage information." },
|
|
{ 'o', "operators", STAT_FLAG_OPERFEAT, FEAT_HIS_STATS_o,
|
|
stats_configured_links, CONF_OPERATOR,
|
|
"Operator information." },
|
|
{ 'p', "ports", (STAT_FLAG_OPERFEAT | STAT_FLAG_VARPARAM), FEAT_HIS_STATS_p,
|
|
show_ports, 0,
|
|
"Listening ports." },
|
|
{ 'q', "quarantines", (STAT_FLAG_OPERONLY | STAT_FLAG_VARPARAM), FEAT_HIS_STATS_q,
|
|
stats_quarantine, 0,
|
|
"Quarantined channels list." },
|
|
{ 'R', "mappings", (STAT_FLAG_OPERFEAT | STAT_FLAG_CASESENS), FEAT_HIS_STATS_R,
|
|
stats_mapping, 0,
|
|
"Service mappings." },
|
|
#ifdef DEBUGMODE
|
|
{ 'r', "usage", (STAT_FLAG_OPERFEAT | STAT_FLAG_CASESENS), FEAT_HIS_STATS_r,
|
|
send_usage, 0,
|
|
"System resource usage (Debug only)." },
|
|
#endif
|
|
{ 'S', "shuns", (STAT_FLAG_OPERFEAT | STAT_FLAG_VARPARAM | STAT_FLAG_CASESENS), FEAT_HIS_STATS_S,
|
|
shun_stats, 0,
|
|
"Global Shuns." },
|
|
{ 's', "spoofhosts", (STAT_FLAG_OPERFEAT | STAT_FLAG_VARPARAM | STAT_FLAG_CASESENS), FEAT_HIS_STATS_s,
|
|
stats_spoofhost, 0,
|
|
"Spoofed hosts information." },
|
|
{ 'T', "motds", (STAT_FLAG_OPERFEAT | STAT_FLAG_CASESENS), FEAT_HIS_STATS_T,
|
|
motd_report, 0,
|
|
"Configured Message Of The Day files." },
|
|
{ 't', "locals", (STAT_FLAG_OPERFEAT | STAT_FLAG_CASESENS), FEAT_HIS_STATS_t,
|
|
tstats, 0,
|
|
"Local connection statistics (Total SND/RCV, etc)." },
|
|
{ 'U', "uworld", (STAT_FLAG_OPERFEAT | STAT_FLAG_CASESENS), FEAT_HIS_STATS_U,
|
|
stats_configured_links, CONF_UWORLD,
|
|
"Service server information." },
|
|
{ 'u', "uptime", (STAT_FLAG_OPERFEAT | STAT_FLAG_CASESENS), FEAT_HIS_STATS_u,
|
|
stats_uptime, 0,
|
|
"Current uptime & highest connection count." },
|
|
{ 'v', "vservers", (STAT_FLAG_OPERFEAT | STAT_FLAG_VARPARAM | STAT_FLAG_CASESENS), FEAT_HIS_STATS_v,
|
|
stats_servers_verbose, 1,
|
|
"Verbose server information." },
|
|
{ 'V', "vserversmach", (STAT_FLAG_OPERFEAT | STAT_FLAG_VARPARAM | STAT_FLAG_CASESENS), FEAT_HIS_STATS_v,
|
|
stats_servers_verbose, 0,
|
|
"Verbose server information." },
|
|
{ 'w', "userload", (STAT_FLAG_OPERFEAT | STAT_FLAG_CASESENS), FEAT_HIS_STATS_w,
|
|
calc_load, 0,
|
|
"Userload statistics." },
|
|
{ 'W', "webirc", (STAT_FLAG_OPERFEAT | STAT_FLAG_CASESENS), FEAT_HIS_STATS_W,
|
|
stats_webirc, 0,
|
|
"WEBIRC configuration." },
|
|
{ 'x', "memusage", STAT_FLAG_OPERFEAT, FEAT_HIS_STATS_x,
|
|
stats_meminfo, 0,
|
|
"List usage information." },
|
|
{ 'y', "classes", STAT_FLAG_OPERFEAT, FEAT_HIS_STATS_y,
|
|
report_classes, 0,
|
|
"Connection classes." },
|
|
{ 'z', "memory", (STAT_FLAG_OPERFEAT | STAT_FLAG_CASESENS), FEAT_HIS_STATS_z,
|
|
count_memory, 0,
|
|
"Memory/Structure allocation information." },
|
|
{ 'Z', "zlines", (STAT_FLAG_OPERFEAT | STAT_FLAG_CASESENS), FEAT_HIS_STATS_Z,
|
|
zline_stats, 0,
|
|
"Global IP bans (Z-lines)." },
|
|
{ ' ', "iauth", STAT_FLAG_OPERFEAT, FEAT_HIS_STATS_IAUTH,
|
|
report_iauth_stats, 0,
|
|
"IAuth statistics." },
|
|
{ ' ', "iauthconf", STAT_FLAG_OPERFEAT, FEAT_HIS_STATS_IAUTH,
|
|
report_iauth_conf, 0,
|
|
"IAuth configuration." },
|
|
{ '*', "help", STAT_FLAG_CASESENS, FEAT_LAST_F,
|
|
stats_help, 0,
|
|
"Send help for stats." },
|
|
{ '\0', 0, FEAT_LAST_F, 0, 0, 0 }
|
|
};
|
|
|
|
/** Maps from characters to statistics descriptors.
|
|
* Statistics descriptors with no single-character alias are not included.
|
|
*/
|
|
static struct StatDesc *statsmap[256];
|
|
/** Number of statistics descriptors. */
|
|
static int statscount;
|
|
|
|
/** Compare two StatDesc structures by long name (StatDesc::sd_name).
|
|
* @param[in] a_ Pointer to a StatDesc.
|
|
* @param[in] b_ Pointer to a StatDesc.
|
|
* @return Less than, equal to, or greater than zero if \a a_ is
|
|
* lexicographically less than, equal to, or greater than \a b_.
|
|
*/
|
|
static int
|
|
stats_cmp(const void *a_, const void *b_)
|
|
{
|
|
const struct StatDesc *a = a_;
|
|
const struct StatDesc *b = b_;
|
|
return ircd_strcmp(a->sd_name, b->sd_name);
|
|
}
|
|
|
|
/** Compare a StatDesc's name against a string.
|
|
* @param[in] key Pointer to a null-terminated string.
|
|
* @param[in] sd_ Pointer to a StatDesc.
|
|
* @return Less than, equal to, or greater than zero if \a key is
|
|
* lexicographically less than, equal to, or greater than \a
|
|
* sd_->sd_name.
|
|
*/
|
|
static int
|
|
stats_search(const void *key, const void *sd_)
|
|
{
|
|
const struct StatDesc *sd = sd_;
|
|
return ircd_strcmp(key, sd->sd_name);
|
|
}
|
|
|
|
/** Look up a stats handler. If name_or_char is just one character
|
|
* long, use that as a character index; otherwise, look it up by name
|
|
* in #statsinfo.
|
|
* @param[in] name_or_char Null-terminated string to look up.
|
|
* @return The statistics descriptor for \a name_or_char (NULL if none).
|
|
*/
|
|
const struct StatDesc *
|
|
stats_find(const char *name_or_char)
|
|
{
|
|
if (!name_or_char[1])
|
|
return statsmap[name_or_char[0] - CHAR_MIN];
|
|
else
|
|
return bsearch(name_or_char, statsinfo, statscount, sizeof(statsinfo[0]), stats_search);
|
|
}
|
|
|
|
/** Build statsmap from the statsinfo array. */
|
|
void
|
|
stats_init(void)
|
|
{
|
|
struct StatDesc *sd;
|
|
|
|
/* Count number of stats entries and sort them. */
|
|
for (statscount = 0, sd = statsinfo; sd->sd_name; sd++, statscount++) {}
|
|
qsort(statsinfo, statscount, sizeof(statsinfo[0]), stats_cmp);
|
|
|
|
/* Build the mapping */
|
|
for (sd = statsinfo; sd->sd_name; sd++)
|
|
{
|
|
if (!sd->sd_c)
|
|
continue;
|
|
else if (sd->sd_flags & STAT_FLAG_CASESENS)
|
|
/* case sensitive character... */
|
|
statsmap[sd->sd_c - CHAR_MIN] = sd;
|
|
else
|
|
{
|
|
/* case insensitive--make sure to put in two entries */
|
|
statsmap[ToLower(sd->sd_c) - CHAR_MIN] = sd;
|
|
statsmap[ToUpper(sd->sd_c) - CHAR_MIN] = sd;
|
|
}
|
|
}
|
|
}
|