/*
 * 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;
    }
  }
}