1136 lines
25 KiB
C
1136 lines
25 KiB
C
/*
|
|
* ircd-ratbox: A slightly useful ircd.
|
|
* m_info.c: Sends information about the server.
|
|
*
|
|
* Copyright (C) 1990 Jarkko Oikarinen and University of Oulu, Co Center
|
|
* Copyright (C) 1996-2002 Hybrid Development Team
|
|
* Copyright (C) 2002-2012 ircd-ratbox development team
|
|
*
|
|
* 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 2 of the License, 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
|
|
* USA
|
|
*
|
|
* $Id: m_info.c 29271 2015-12-29 02:38:25Z androsyn $
|
|
*/
|
|
|
|
#include "stdinc.h"
|
|
#include "ratbox_lib.h"
|
|
#include "struct.h"
|
|
#include "client.h"
|
|
#include "match.h"
|
|
#include "ircd.h"
|
|
#include "hook.h"
|
|
#include "numeric.h"
|
|
#include "s_serv.h"
|
|
#include "send.h"
|
|
#include "s_conf.h"
|
|
#include "parse.h"
|
|
#include "modules.h"
|
|
|
|
static void send_conf_options(struct Client *source_p);
|
|
static void send_birthdate_online_time(struct Client *source_p);
|
|
static void send_info_text(struct Client *source_p);
|
|
static void info_spy(struct Client *);
|
|
|
|
static int m_info(struct Client *, struct Client *, int, const char **);
|
|
static int mo_info(struct Client *, struct Client *, int, const char **);
|
|
|
|
struct Message info_msgtab = {
|
|
"INFO", 0, 0, 0, MFLG_SLOW,
|
|
{mg_unreg, {m_info, 0}, {mo_info, 0}, mg_ignore, mg_ignore, {mo_info, 0}}
|
|
};
|
|
|
|
int doing_info_hook;
|
|
|
|
mapi_clist_av1 info_clist[] = { &info_msgtab, NULL };
|
|
|
|
mapi_hlist_av1 info_hlist[] = {
|
|
{"doing_info", &doing_info_hook},
|
|
{NULL, NULL}
|
|
};
|
|
|
|
DECLARE_MODULE_AV1(info, NULL, NULL, info_clist, info_hlist, NULL, "$Revision: 29271 $");
|
|
|
|
/*
|
|
* jdc -- Structure for our configuration value table
|
|
*/
|
|
struct InfoStruct
|
|
{
|
|
const char *name; /* Displayed variable name */
|
|
unsigned int output_type; /* See below #defines */
|
|
union
|
|
{
|
|
const void *ptr;
|
|
int decimal;
|
|
const int *decimal_ptr;
|
|
const char *string;
|
|
const char **pstring;
|
|
} option;
|
|
const char *desc; /* ASCII description of the variable */
|
|
};
|
|
/* Types for output_type in InfoStruct */
|
|
#define OUTPUT_STRING 0x0001 /* Output option as %s w/ dereference */
|
|
#define OUTPUT_STRING_PTR 0x0002 /* Output option as %s w/out deference */
|
|
#define OUTPUT_DECIMAL 0x0004 /* Output option as decimal (%d) */
|
|
#define OUTPUT_DECIMAL_RAW 0x0008 /* Output option as decimal (%d) w/out dereference */
|
|
#define OUTPUT_BOOLEAN 0x0010 /* Output option as "ON" or "OFF" */
|
|
#define OUTPUT_BOOLEAN_YN 0x0020 /* Output option as "YES" or "NO" */
|
|
#define OUTPUT_BOOLEAN_RAW 0x0040 /* Output option as "ON" or "OFF" */
|
|
#define OUTPUT_BOOLEAN_RAW_YN 0x0080 /* Output option as "YES" or "NO" */
|
|
#define OUTPUT_BOOLEAN2 0x0100 /* Output option as "YES/NO/MASKED" */
|
|
|
|
|
|
#ifdef SOMAXCONN
|
|
#undef RATBOX_SOMAXCONN
|
|
#define RATBOX_SOMAXCONN SOMAXCONN
|
|
#endif
|
|
|
|
#if !defined(CPATH) || !defined(DPATH) || !defined(HPATH) || \
|
|
!defined(UHPATH) || !defined(LPATH) || !defined(MPATH) || \
|
|
!defined(OPATH) || !defined(SPATH)
|
|
static const char *none = "NONE"; /* because we don't need a bunch of NONEs in the executables */
|
|
#endif
|
|
|
|
#ifndef CPATH
|
|
#define CPATH none
|
|
#endif
|
|
|
|
#ifndef DPATH
|
|
#define DPATH none
|
|
#endif
|
|
|
|
#ifndef HPATH
|
|
#define HPATH none
|
|
#endif
|
|
|
|
#ifndef UHPATH
|
|
#define UHPATH none
|
|
#endif
|
|
|
|
#ifndef LPATH
|
|
#define LPATH none
|
|
#endif
|
|
#ifndef MPATH
|
|
#define MPATH none
|
|
#endif
|
|
#ifndef OPATH
|
|
#define OPATH none
|
|
#endif
|
|
#ifndef SPATH
|
|
#define SPATH none
|
|
#endif
|
|
|
|
|
|
/* *INDENT-OFF* */
|
|
static struct InfoStruct info_table[] = {
|
|
|
|
{
|
|
"CPATH",
|
|
OUTPUT_STRING_PTR,
|
|
{ CPATH },
|
|
"Path to Main Configuration File"
|
|
},
|
|
{
|
|
"DPATH",
|
|
OUTPUT_STRING_PTR,
|
|
{ DPATH },
|
|
"Directory Containing Configuration Files"
|
|
},
|
|
{
|
|
"ENABLE_SERVICES",
|
|
OUTPUT_BOOLEAN_RAW,
|
|
#ifdef ENABLE_SERVICES
|
|
{ (void *)1 },
|
|
#else
|
|
{ (void *)0 },
|
|
#endif
|
|
"ratbox-services compatibility code",
|
|
},
|
|
{
|
|
"HPATH",
|
|
OUTPUT_STRING_PTR,
|
|
{ HPATH } ,
|
|
"Path to Operator Help Files",
|
|
},
|
|
{
|
|
"UHPATH",
|
|
OUTPUT_STRING_PTR,
|
|
{ UHPATH },
|
|
"Path to User Help Files",
|
|
},
|
|
{
|
|
"RATBOX_SOMAXCONN",
|
|
OUTPUT_DECIMAL_RAW,
|
|
{ (void *)RATBOX_SOMAXCONN },
|
|
"Maximum Queue Length of Pending Connections"
|
|
},
|
|
{
|
|
"IPV6",
|
|
OUTPUT_BOOLEAN_RAW,
|
|
#ifdef RB_IPV6
|
|
{ (void *)1 },
|
|
#else
|
|
{ (void *)0 },
|
|
#endif
|
|
"IPv6 Support"
|
|
},
|
|
{
|
|
"MAX_CONNECTIONS",
|
|
OUTPUT_DECIMAL,
|
|
{ &maxconnections },
|
|
"Max number connections"
|
|
},
|
|
{
|
|
"JOIN_LEAVE_COUNT_EXPIRE_TIME",
|
|
OUTPUT_DECIMAL_RAW,
|
|
{ (void *)JOIN_LEAVE_COUNT_EXPIRE_TIME },
|
|
"Anti SpamBot Parameter"
|
|
},
|
|
{
|
|
"KILLCHASETIMELIMIT",
|
|
OUTPUT_DECIMAL_RAW,
|
|
{ (void *)KILLCHASETIMELIMIT },
|
|
"Nick Change Tracker for KILL"
|
|
},
|
|
{
|
|
"LPATH",
|
|
OUTPUT_STRING_PTR,
|
|
{ LPATH },
|
|
"Path to Log File"
|
|
},
|
|
{
|
|
"MAX_BUFFER",
|
|
OUTPUT_DECIMAL_RAW,
|
|
{ (void *)MAX_BUFFER },
|
|
"Maximum Buffer Connections Allowed"
|
|
},
|
|
{
|
|
"MAX_JOIN_LEAVE_COUNT",
|
|
OUTPUT_DECIMAL_RAW,
|
|
{ (void *)MAX_JOIN_LEAVE_COUNT },
|
|
"Anti SpamBot Parameter"
|
|
},
|
|
{
|
|
"MIN_JOIN_LEAVE_TIME",
|
|
OUTPUT_DECIMAL_RAW,
|
|
{ (void *)MIN_JOIN_LEAVE_TIME },
|
|
"Anti SpamBot Parameter"
|
|
},
|
|
{
|
|
"MPATH",
|
|
OUTPUT_STRING_PTR,
|
|
{ MPATH },
|
|
"Path to MOTD File"
|
|
},
|
|
{
|
|
"NICKNAMEHISTORYLENGTH",
|
|
OUTPUT_DECIMAL_RAW,
|
|
{ (void *)NICKNAMEHISTORYLENGTH },
|
|
"Size of WHOWAS Array"
|
|
},
|
|
{
|
|
"OPATH",
|
|
OUTPUT_STRING_PTR,
|
|
{ OPATH },
|
|
"Path to Operator MOTD File"
|
|
},
|
|
{
|
|
"OPER_SPAM_COUNTDOWN",
|
|
OUTPUT_DECIMAL_RAW,
|
|
{ (void *)OPER_SPAM_COUNTDOWN },
|
|
"Anti SpamBot Parameter"
|
|
},
|
|
{
|
|
"USE_CHALLENGE",
|
|
OUTPUT_BOOLEAN_RAW,
|
|
#ifdef USE_CHALLENGE
|
|
{ (void *)1 },
|
|
#else
|
|
{ (void *)0 },
|
|
#endif
|
|
"OpenSSL CHALLENGE Support"
|
|
},
|
|
{
|
|
"HAVE_ZLIB",
|
|
OUTPUT_BOOLEAN_RAW_YN,
|
|
#ifdef HAVE_ZLIB
|
|
{ (void *)1 },
|
|
#else
|
|
{ (void *)0 },
|
|
#endif
|
|
"zlib (ziplinks) support"
|
|
},
|
|
{
|
|
"PPATH",
|
|
OUTPUT_STRING_PTR,
|
|
{ PPATH },
|
|
"Path to Pid File"
|
|
},
|
|
{
|
|
"SPATH",
|
|
OUTPUT_STRING_PTR,
|
|
{ SPATH },
|
|
"Path to Server Executable"
|
|
},
|
|
{
|
|
"TS_MAX_DELTA_DEFAULT",
|
|
OUTPUT_DECIMAL_RAW,
|
|
{ (void *)TS_MAX_DELTA_DEFAULT },
|
|
"Maximum Allowed TS Delta from another Server"
|
|
},
|
|
{
|
|
"USE_IODEBUG_HOOKS",
|
|
OUTPUT_BOOLEAN_RAW_YN,
|
|
#ifdef USE_IODEBUG_HOOKS
|
|
{ (void *)1 },
|
|
#else
|
|
{ (void *)0 },
|
|
#endif
|
|
"IO Debugging support"
|
|
},
|
|
{
|
|
"anti_nick_flood",
|
|
OUTPUT_BOOLEAN,
|
|
{ &ConfigFileEntry.anti_nick_flood },
|
|
"NICK flood protection"
|
|
},
|
|
{
|
|
"anti_spam_exit_message_time",
|
|
OUTPUT_DECIMAL,
|
|
{ &ConfigFileEntry.anti_spam_exit_message_time },
|
|
"Duration a client must be connected for to have an exit message"
|
|
},
|
|
{
|
|
"burst_away",
|
|
OUTPUT_BOOLEAN,
|
|
{ &ConfigFileEntry.burst_away },
|
|
"Burst away messages on server joins"
|
|
},
|
|
{
|
|
"caller_id_wait",
|
|
OUTPUT_DECIMAL,
|
|
{ &ConfigFileEntry.caller_id_wait },
|
|
"Minimum delay between notifying UMODE +g users of messages"
|
|
},
|
|
{
|
|
"client_exit",
|
|
OUTPUT_BOOLEAN,
|
|
{ &ConfigFileEntry.client_exit },
|
|
"Prepend 'Client Exit:' to user QUIT messages"
|
|
},
|
|
{
|
|
"client_flood",
|
|
OUTPUT_DECIMAL,
|
|
{ &ConfigFileEntry.client_flood },
|
|
"Number of lines before a client Excess Flood's",
|
|
},
|
|
{
|
|
"collision_fnc",
|
|
OUTPUT_BOOLEAN_YN,
|
|
{ &ConfigFileEntry.collision_fnc },
|
|
"Forced nick change on collision"
|
|
},
|
|
{
|
|
"connect_timeout",
|
|
OUTPUT_DECIMAL,
|
|
{ &ConfigFileEntry.connect_timeout },
|
|
"Connect timeout for connections to servers"
|
|
},
|
|
{
|
|
"default_floodcount",
|
|
OUTPUT_DECIMAL,
|
|
{ &ConfigFileEntry.default_floodcount },
|
|
"Startup value of FLOODCOUNT",
|
|
},
|
|
{
|
|
"default_adminstring",
|
|
OUTPUT_STRING,
|
|
{ &ConfigFileEntry.default_adminstring },
|
|
"Default adminstring at startup.",
|
|
},
|
|
{
|
|
"default_operstring",
|
|
OUTPUT_STRING,
|
|
{ &ConfigFileEntry.default_operstring },
|
|
"Default operstring at startup.",
|
|
},
|
|
{
|
|
"default_invisible",
|
|
OUTPUT_BOOLEAN_YN,
|
|
{ &ConfigFileEntry.default_invisible },
|
|
"Clients are set +i on connect"
|
|
},
|
|
{
|
|
"disable_auth",
|
|
OUTPUT_BOOLEAN_YN,
|
|
{ &ConfigFileEntry.disable_auth },
|
|
"Controls whether auth checking is disabled or not"
|
|
},
|
|
{
|
|
"disable_fake_channels",
|
|
OUTPUT_BOOLEAN_YN,
|
|
{ &ConfigFileEntry.disable_fake_channels },
|
|
"Controls whether bold etc are disabled for JOIN"
|
|
},
|
|
{
|
|
"dot_in_ip6_addr",
|
|
OUTPUT_BOOLEAN,
|
|
{ &ConfigFileEntry.dot_in_ip6_addr },
|
|
"Suffix a . to ip6 addresses",
|
|
},
|
|
{
|
|
"dots_in_ident",
|
|
OUTPUT_DECIMAL,
|
|
{ &ConfigFileEntry.dots_in_ident },
|
|
"Number of permissable dots in an ident"
|
|
},
|
|
{
|
|
"failed_oper_notice",
|
|
OUTPUT_BOOLEAN,
|
|
{ &ConfigFileEntry.failed_oper_notice },
|
|
"Inform opers if someone /oper's with the wrong password"
|
|
},
|
|
{
|
|
"fname_userlog",
|
|
OUTPUT_STRING,
|
|
{ &ConfigFileEntry.fname_userlog },
|
|
"User log file"
|
|
},
|
|
{
|
|
"fname_fuserlog",
|
|
OUTPUT_STRING,
|
|
{ &ConfigFileEntry.fname_fuserlog },
|
|
"Failed user log file"
|
|
},
|
|
|
|
{
|
|
"fname_operlog",
|
|
OUTPUT_STRING,
|
|
{ &ConfigFileEntry.fname_operlog },
|
|
"Operator log file"
|
|
},
|
|
{
|
|
"fname_foperlog",
|
|
OUTPUT_STRING,
|
|
{ &ConfigFileEntry.fname_foperlog },
|
|
"Failed operator log file"
|
|
},
|
|
{
|
|
"fname_serverlog",
|
|
OUTPUT_STRING,
|
|
{ &ConfigFileEntry.fname_serverlog },
|
|
"Server connect/disconnect log file"
|
|
},
|
|
{
|
|
"fname_klinelog",
|
|
OUTPUT_STRING,
|
|
{ &ConfigFileEntry.fname_klinelog },
|
|
"KLINE etc log file"
|
|
},
|
|
{
|
|
"fname_glinelog",
|
|
OUTPUT_STRING,
|
|
{ &ConfigFileEntry.fname_glinelog },
|
|
"GLINE log file"
|
|
},
|
|
{
|
|
"fname_operspylog",
|
|
OUTPUT_STRING,
|
|
{ &ConfigFileEntry.fname_operspylog },
|
|
"Oper spy log file"
|
|
},
|
|
{
|
|
"fname_ioerrorlog",
|
|
OUTPUT_STRING,
|
|
{ &ConfigFileEntry.fname_ioerrorlog },
|
|
"IO error log file"
|
|
},
|
|
{
|
|
"glines",
|
|
OUTPUT_BOOLEAN,
|
|
{ &ConfigFileEntry.glines },
|
|
"G-line (network-wide K-line) support"
|
|
},
|
|
{
|
|
"gline_time",
|
|
OUTPUT_DECIMAL,
|
|
{ &ConfigFileEntry.gline_time },
|
|
"Expiry time for G-lines"
|
|
},
|
|
{
|
|
"gline_min_cidr",
|
|
OUTPUT_DECIMAL,
|
|
{ &ConfigFileEntry.gline_min_cidr },
|
|
"Minimum CIDR bitlen for ipv4 glines"
|
|
},
|
|
{
|
|
"gline_min_cidr6",
|
|
OUTPUT_DECIMAL,
|
|
{ &ConfigFileEntry.gline_min_cidr6 },
|
|
"Minimum CIDR bitlen for ipv6 glines"
|
|
},
|
|
{
|
|
"hide_error_messages",
|
|
OUTPUT_BOOLEAN2,
|
|
{ &ConfigFileEntry.hide_error_messages },
|
|
"Hide ERROR messages coming from servers"
|
|
},
|
|
{
|
|
"hide_spoof_ips",
|
|
OUTPUT_BOOLEAN_YN,
|
|
{ &ConfigFileEntry.hide_spoof_ips },
|
|
"Hide IPs of spoofed users"
|
|
},
|
|
{
|
|
"hub",
|
|
OUTPUT_BOOLEAN_YN,
|
|
{ &ServerInfo.hub },
|
|
"Server is a hub"
|
|
},
|
|
{
|
|
"kline_delay",
|
|
OUTPUT_DECIMAL,
|
|
{ &ConfigFileEntry.kline_delay },
|
|
"Duration of time to delay kline checking"
|
|
},
|
|
{
|
|
"kline_reason",
|
|
OUTPUT_STRING,
|
|
{ &ConfigFileEntry.kline_reason },
|
|
"K-lined clients sign off with this reason"
|
|
},
|
|
{
|
|
"dline_with_reason",
|
|
OUTPUT_BOOLEAN_YN,
|
|
{ &ConfigFileEntry.dline_with_reason },
|
|
"Display D-line reason to client on disconnect"
|
|
},
|
|
{
|
|
"kline_with_reason",
|
|
OUTPUT_BOOLEAN_YN,
|
|
{ &ConfigFileEntry.kline_with_reason },
|
|
"Display K-line reason to client on disconnect"
|
|
},
|
|
{
|
|
"map_oper_only",
|
|
OUTPUT_BOOLEAN_YN,
|
|
{ &ConfigFileEntry.map_oper_only },
|
|
"MAP is oper only"
|
|
},
|
|
{
|
|
"max_accept",
|
|
OUTPUT_DECIMAL,
|
|
{ &ConfigFileEntry.max_accept },
|
|
"Maximum nicknames on accept list",
|
|
},
|
|
{
|
|
"max_monitor",
|
|
OUTPUT_DECIMAL,
|
|
{ &ConfigFileEntry.max_monitor },
|
|
"Maximum nicknames on monitor list"
|
|
},
|
|
{
|
|
"max_nick_changes",
|
|
OUTPUT_DECIMAL,
|
|
{ &ConfigFileEntry.max_nick_changes },
|
|
"NICK change threshhold setting"
|
|
},
|
|
{
|
|
"max_nick_time",
|
|
OUTPUT_DECIMAL,
|
|
{ &ConfigFileEntry.max_nick_time },
|
|
"NICK flood protection time interval"
|
|
},
|
|
{
|
|
"max_targets",
|
|
OUTPUT_DECIMAL,
|
|
{ &ConfigFileEntry.max_targets },
|
|
"The maximum number of PRIVMSG/NOTICE targets"
|
|
},
|
|
{
|
|
"min_nonwildcard",
|
|
OUTPUT_DECIMAL,
|
|
{ &ConfigFileEntry.min_nonwildcard },
|
|
"Minimum non-wildcard chars in K/G lines",
|
|
},
|
|
{
|
|
"min_nonwildcard_simple",
|
|
OUTPUT_DECIMAL,
|
|
{ &ConfigFileEntry.min_nonwildcard_simple },
|
|
"Minimum non-wildcard chars in xlines/resvs",
|
|
},
|
|
{
|
|
"network_name",
|
|
OUTPUT_STRING,
|
|
{ &ServerInfo.network_name },
|
|
"Network name"
|
|
},
|
|
{
|
|
"network_desc",
|
|
OUTPUT_STRING,
|
|
{ &ServerInfo.network_desc },
|
|
"Network description"
|
|
},
|
|
{
|
|
"nick_delay",
|
|
OUTPUT_DECIMAL,
|
|
{ &ConfigFileEntry.nick_delay },
|
|
"Delay nicks are locked for on split",
|
|
},
|
|
{
|
|
"no_oper_flood",
|
|
OUTPUT_BOOLEAN,
|
|
{ &ConfigFileEntry.no_oper_flood },
|
|
"Disable flood control for operators",
|
|
},
|
|
{
|
|
"non_redundant_klines",
|
|
OUTPUT_BOOLEAN,
|
|
{ &ConfigFileEntry.non_redundant_klines },
|
|
"Check for and disallow redundant K-lines"
|
|
},
|
|
{
|
|
"operspy_admin_only",
|
|
OUTPUT_BOOLEAN,
|
|
{ &ConfigFileEntry.operspy_admin_only },
|
|
"Send +Z operspy notices to admins only"
|
|
},
|
|
{
|
|
"pace_wait",
|
|
OUTPUT_DECIMAL,
|
|
{ &ConfigFileEntry.pace_wait },
|
|
"Minimum delay between uses of certain commands"
|
|
},
|
|
{
|
|
"pace_wait_simple",
|
|
OUTPUT_DECIMAL,
|
|
{ &ConfigFileEntry.pace_wait_simple },
|
|
"Minimum delay between less intensive commands"
|
|
},
|
|
{
|
|
"ping_cookie",
|
|
OUTPUT_BOOLEAN,
|
|
{ &ConfigFileEntry.ping_cookie },
|
|
"Require ping cookies to connect",
|
|
},
|
|
{
|
|
"reject_after_count",
|
|
OUTPUT_DECIMAL,
|
|
{ &ConfigFileEntry.reject_after_count },
|
|
"Client rejection threshold setting",
|
|
},
|
|
{
|
|
"reject_duration",
|
|
OUTPUT_DECIMAL,
|
|
{ &ConfigFileEntry.reject_duration },
|
|
"Client rejection cache duration",
|
|
},
|
|
{
|
|
"short_motd",
|
|
OUTPUT_BOOLEAN_YN,
|
|
{ &ConfigFileEntry.short_motd },
|
|
"Do not show MOTD; only tell clients they should read it"
|
|
},
|
|
{
|
|
"stats_e_disabled",
|
|
OUTPUT_BOOLEAN_YN,
|
|
{ &ConfigFileEntry.stats_e_disabled },
|
|
"STATS e output is disabled",
|
|
},
|
|
{
|
|
"stats_c_oper_only",
|
|
OUTPUT_BOOLEAN_YN,
|
|
{ &ConfigFileEntry.stats_c_oper_only },
|
|
"STATS C output is only shown to operators",
|
|
},
|
|
{
|
|
"stats_h_oper_only",
|
|
OUTPUT_BOOLEAN_YN,
|
|
{ &ConfigFileEntry.stats_h_oper_only },
|
|
"STATS H output is only shown to operators",
|
|
},
|
|
{
|
|
"stats_i_oper_only",
|
|
OUTPUT_BOOLEAN2,
|
|
{ &ConfigFileEntry.stats_i_oper_only },
|
|
"STATS I output is only shown to operators",
|
|
},
|
|
{
|
|
"stats_k_oper_only",
|
|
OUTPUT_BOOLEAN2,
|
|
{ &ConfigFileEntry.stats_k_oper_only },
|
|
"STATS K output is only shown to operators",
|
|
},
|
|
{
|
|
"stats_o_oper_only",
|
|
OUTPUT_BOOLEAN_YN,
|
|
{ &ConfigFileEntry.stats_o_oper_only },
|
|
"STATS O output is only shown to operators",
|
|
},
|
|
{
|
|
"stats_P_oper_only",
|
|
OUTPUT_BOOLEAN_YN,
|
|
{ &ConfigFileEntry.stats_P_oper_only },
|
|
"STATS P is only shown to operators",
|
|
},
|
|
{
|
|
"stats_y_oper_only",
|
|
OUTPUT_BOOLEAN_YN,
|
|
{ &ConfigFileEntry.stats_y_oper_only },
|
|
"STATS Y is only shown to operators",
|
|
},
|
|
{
|
|
"target_change",
|
|
OUTPUT_BOOLEAN,
|
|
{ &ConfigFileEntry.target_change },
|
|
"Target change anti-spam system"
|
|
},
|
|
{
|
|
"throttle_count",
|
|
OUTPUT_DECIMAL,
|
|
{ &ConfigFileEntry.throttle_count },
|
|
"Connection throttle threshold",
|
|
},
|
|
{
|
|
"throttle_duration",
|
|
OUTPUT_DECIMAL,
|
|
{ &ConfigFileEntry.throttle_duration },
|
|
"Connection throttle duration",
|
|
},
|
|
{
|
|
"tkline_expire_notices",
|
|
OUTPUT_BOOLEAN,
|
|
{ &ConfigFileEntry.tkline_expire_notices },
|
|
"Notices given to opers when tklines expire"
|
|
},
|
|
{
|
|
"ts_max_delta",
|
|
OUTPUT_DECIMAL,
|
|
{ &ConfigFileEntry.ts_max_delta },
|
|
"Maximum permitted TS delta from another server"
|
|
},
|
|
{
|
|
"ts_warn_delta",
|
|
OUTPUT_DECIMAL,
|
|
{ &ConfigFileEntry.ts_warn_delta },
|
|
"Maximum permitted TS delta before displaying a warning"
|
|
},
|
|
{
|
|
"use_whois_actually",
|
|
OUTPUT_BOOLEAN_YN,
|
|
{ &ConfigFileEntry.use_whois_actually },
|
|
"RPL_WHOISACTUALLY sent in reply to whois requests"
|
|
},
|
|
{
|
|
"warn_no_nline",
|
|
OUTPUT_BOOLEAN,
|
|
{ &ConfigFileEntry.warn_no_nline },
|
|
"Display warning if connecting server lacks N-line"
|
|
},
|
|
{
|
|
"default_split_server_count",
|
|
OUTPUT_DECIMAL,
|
|
{ &ConfigChannel.default_split_server_count },
|
|
"Startup value of SPLITNUM",
|
|
},
|
|
{
|
|
"default_split_user_count",
|
|
OUTPUT_DECIMAL,
|
|
{ &ConfigChannel.default_split_user_count },
|
|
"Startup value of SPLITUSERS",
|
|
},
|
|
{
|
|
"knock_delay",
|
|
OUTPUT_DECIMAL,
|
|
{ &ConfigChannel.knock_delay },
|
|
"Delay between a users KNOCK attempts"
|
|
},
|
|
{
|
|
"knock_delay_channel",
|
|
OUTPUT_DECIMAL,
|
|
{ &ConfigChannel.knock_delay_channel },
|
|
"Delay between KNOCK attempts to a channel",
|
|
},
|
|
{
|
|
"invite_ops_only",
|
|
OUTPUT_BOOLEAN_YN,
|
|
{ &ConfigChannel.invite_ops_only },
|
|
"INVITE is restricted to channelops only"
|
|
},
|
|
{
|
|
"max_bans",
|
|
OUTPUT_DECIMAL,
|
|
{ &ConfigChannel.max_bans },
|
|
"Total +b/e/I modes allowed in a channel",
|
|
},
|
|
{
|
|
"max_chans_per_user",
|
|
OUTPUT_DECIMAL,
|
|
{ &ConfigChannel.max_chans_per_user },
|
|
"Maximum number of channels a user can join",
|
|
},
|
|
{
|
|
"no_create_on_split",
|
|
OUTPUT_BOOLEAN_YN,
|
|
{ &ConfigChannel.no_create_on_split },
|
|
"Disallow creation of channels when split",
|
|
},
|
|
{
|
|
"no_join_on_split",
|
|
OUTPUT_BOOLEAN_YN,
|
|
{ &ConfigChannel.no_join_on_split },
|
|
"Disallow joining channels when split",
|
|
},
|
|
{
|
|
"quiet_on_ban",
|
|
OUTPUT_BOOLEAN_YN,
|
|
{ &ConfigChannel.quiet_on_ban },
|
|
"Banned users may not send text to a channel"
|
|
},
|
|
{
|
|
"use_except",
|
|
OUTPUT_BOOLEAN_YN,
|
|
{ &ConfigChannel.use_except },
|
|
"Enable chanmode +e (ban exceptions)",
|
|
},
|
|
{
|
|
"use_invex",
|
|
OUTPUT_BOOLEAN_YN,
|
|
{ &ConfigChannel.use_invex },
|
|
"Enable chanmode +I (invite exceptions)",
|
|
},
|
|
{
|
|
"use_knock",
|
|
OUTPUT_BOOLEAN_YN,
|
|
{ &ConfigChannel.use_knock },
|
|
"Enable /KNOCK",
|
|
},
|
|
{
|
|
"disable_hidden",
|
|
OUTPUT_BOOLEAN_YN,
|
|
{ &ConfigServerHide.disable_hidden },
|
|
"Prevent servers from hiding themselves from a flattened /links",
|
|
},
|
|
{
|
|
"flatten_links",
|
|
OUTPUT_BOOLEAN_YN,
|
|
{ &ConfigServerHide.flatten_links },
|
|
"Flatten /links list",
|
|
},
|
|
{
|
|
"hidden",
|
|
OUTPUT_BOOLEAN_YN,
|
|
{ &ConfigServerHide.hidden },
|
|
"Hide this server from a flattened /links on remote servers",
|
|
},
|
|
{
|
|
"links_delay",
|
|
OUTPUT_DECIMAL,
|
|
{ &ConfigServerHide.links_delay },
|
|
"Links rehash delay"
|
|
},
|
|
{ (char *) 0, (unsigned int) 0, { (void *) 0 }, (char *) 0}
|
|
};
|
|
/* *INDENT-ON* */
|
|
|
|
/*
|
|
** m_info
|
|
** parv[0] = sender prefix
|
|
** parv[1] = servername
|
|
*/
|
|
static int
|
|
m_info(struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
|
|
{
|
|
static time_t last_used = 0L;
|
|
|
|
if((last_used + ConfigFileEntry.pace_wait) > rb_current_time())
|
|
{
|
|
/* safe enough to give this on a local connect only */
|
|
sendto_one(source_p, form_str(RPL_LOAD2HI), me.name, source_p->name, "INFO");
|
|
sendto_one_numeric(source_p, RPL_ENDOFINFO, form_str(RPL_ENDOFINFO));
|
|
return 0;
|
|
}
|
|
else
|
|
last_used = rb_current_time();
|
|
|
|
if(hunt_server(client_p, source_p, ":%s INFO :%s", 1, parc, parv) != HUNTED_ISME)
|
|
return 0;
|
|
|
|
info_spy(source_p);
|
|
SetCork(source_p);
|
|
send_info_text(source_p);
|
|
send_birthdate_online_time(source_p);
|
|
ClearCork(source_p);
|
|
sendto_one_numeric(source_p, RPL_ENDOFINFO, form_str(RPL_ENDOFINFO));
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
** mo_info
|
|
** parv[0] = sender prefix
|
|
** parv[1] = servername
|
|
*/
|
|
static int
|
|
mo_info(struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
|
|
{
|
|
if(hunt_server(client_p, source_p, ":%s INFO :%s", 1, parc, parv) == HUNTED_ISME)
|
|
{
|
|
info_spy(source_p);
|
|
SetCork(source_p);
|
|
send_info_text(source_p);
|
|
|
|
if(IsOper(source_p)) {
|
|
send_conf_options(source_p);
|
|
sendto_one(source_p, ":%s %d %s :%s",
|
|
get_id(&me, source_p), RPL_INFO, get_id(source_p, source_p), rb_lib_version());
|
|
}
|
|
send_birthdate_online_time(source_p);
|
|
ClearCork(source_p);
|
|
sendto_one_numeric(source_p, RPL_ENDOFINFO, form_str(RPL_ENDOFINFO));
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* send_info_text
|
|
*
|
|
* inputs - client pointer to send info text to
|
|
* output - none
|
|
* side effects - info text is sent to client
|
|
*/
|
|
static void
|
|
send_info_text(struct Client *source_p)
|
|
{
|
|
const char **text = infotext;
|
|
|
|
while(*text)
|
|
{
|
|
sendto_one_numeric(source_p, RPL_INFO, form_str(RPL_INFO), *text++);
|
|
}
|
|
|
|
sendto_one_numeric(source_p, RPL_INFO, form_str(RPL_INFO), "");
|
|
}
|
|
|
|
/*
|
|
* send_birthdate_online_time
|
|
*
|
|
* inputs - client pointer to send to
|
|
* output - none
|
|
* side effects - birthdate and online time are sent
|
|
*/
|
|
static void
|
|
send_birthdate_online_time(struct Client *source_p)
|
|
{
|
|
char tbuf[26]; /* this needs to be 26 - see ctime_r manpage */
|
|
sendto_one(source_p, ":%s %d %s :Birth Date: %s, compile # %s",
|
|
get_id(&me, source_p), RPL_INFO,
|
|
get_id(source_p, source_p), creation, generation);
|
|
|
|
sendto_one(source_p, ":%s %d %s :On-line since %s",
|
|
get_id(&me, source_p), RPL_INFO,
|
|
get_id(source_p, source_p), rb_ctime(startup_time, tbuf, sizeof(tbuf)));
|
|
}
|
|
|
|
/*
|
|
* send_conf_options
|
|
*
|
|
* inputs - client pointer to send to
|
|
* output - none
|
|
* side effects - send config options to client
|
|
*/
|
|
static void
|
|
send_conf_options(struct Client *source_p)
|
|
{
|
|
int i = 0;
|
|
|
|
/*
|
|
* Parse the info_table[] and do the magic.
|
|
*/
|
|
for(i = 0; info_table[i].name; i++)
|
|
{
|
|
switch (info_table[i].output_type)
|
|
{
|
|
/*
|
|
* For "char *" references
|
|
*/
|
|
case OUTPUT_STRING:
|
|
{
|
|
const char *option = *(info_table[i].option.pstring);
|
|
|
|
sendto_one(source_p, ":%s %d %s :%-30s %-5s [%-30s]",
|
|
get_id(&me, source_p), RPL_INFO,
|
|
get_id(source_p, source_p),
|
|
info_table[i].name,
|
|
option ? option : "NONE",
|
|
info_table[i].desc ? info_table[i].desc : "<none>");
|
|
|
|
break;
|
|
}
|
|
/*
|
|
* For "char foo[]" references
|
|
*/
|
|
case OUTPUT_STRING_PTR:
|
|
{
|
|
const char *option = info_table[i].option.string;
|
|
|
|
sendto_one(source_p, ":%s %d %s :%-30s %-5s [%-30s]",
|
|
get_id(&me, source_p), RPL_INFO,
|
|
get_id(source_p, source_p),
|
|
info_table[i].name,
|
|
EmptyString(option) ? "NONE" : option,
|
|
info_table[i].desc ? info_table[i].desc : "<none>");
|
|
|
|
break;
|
|
}
|
|
/*
|
|
* Output info_table[i].option as a decimal value.
|
|
*/
|
|
case OUTPUT_DECIMAL:
|
|
{
|
|
int option = *info_table[i].option.decimal_ptr;
|
|
|
|
sendto_one(source_p, ":%s %d %s :%-30s %-5d [%-30s]",
|
|
get_id(&me, source_p), RPL_INFO,
|
|
get_id(source_p, source_p),
|
|
info_table[i].name,
|
|
option,
|
|
info_table[i].desc ? info_table[i].desc : "<none>");
|
|
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* Output info_table[i].option as a decimal value.
|
|
*/
|
|
case OUTPUT_DECIMAL_RAW:
|
|
{
|
|
int option = info_table[i].option.decimal;
|
|
|
|
sendto_one(source_p, ":%s %d %s :%-30s %-5d [%-30s]",
|
|
get_id(&me, source_p), RPL_INFO,
|
|
get_id(source_p, source_p),
|
|
info_table[i].name,
|
|
option,
|
|
info_table[i].desc ? info_table[i].desc : "<none>");
|
|
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* Output info_table[i].option as "ON" or "OFF"
|
|
*/
|
|
case OUTPUT_BOOLEAN:
|
|
{
|
|
int option = *(info_table[i].option.decimal_ptr);
|
|
|
|
sendto_one(source_p, ":%s %d %s :%-30s %-5s [%-30s]",
|
|
get_id(&me, source_p), RPL_INFO,
|
|
get_id(source_p, source_p),
|
|
info_table[i].name,
|
|
option ? "ON" : "OFF",
|
|
info_table[i].desc ? info_table[i].desc : "<none>");
|
|
|
|
break;
|
|
}
|
|
/*
|
|
* Output info_table[i].option as "YES" or "NO"
|
|
*/
|
|
case OUTPUT_BOOLEAN_YN:
|
|
{
|
|
int option = *(info_table[i].option.decimal_ptr);
|
|
|
|
sendto_one(source_p, ":%s %d %s :%-30s %-5s [%-30s]",
|
|
get_id(&me, source_p), RPL_INFO,
|
|
get_id(source_p, source_p),
|
|
info_table[i].name,
|
|
option ? "YES" : "NO",
|
|
info_table[i].desc ? info_table[i].desc : "<none>");
|
|
|
|
break;
|
|
}
|
|
|
|
|
|
case OUTPUT_BOOLEAN_RAW:
|
|
{
|
|
int option = info_table[i].option.decimal;
|
|
|
|
sendto_one(source_p, ":%s %d %s :%-30s %-5s [%-30s]",
|
|
get_id(&me, source_p), RPL_INFO,
|
|
get_id(source_p, source_p),
|
|
info_table[i].name,
|
|
option ? "ON" : "OFF",
|
|
info_table[i].desc ? info_table[i].desc : "<none>");
|
|
|
|
break;
|
|
}
|
|
/*
|
|
* Output info_table[i].option as "YES" or "NO"
|
|
*/
|
|
case OUTPUT_BOOLEAN_RAW_YN:
|
|
{
|
|
int option = info_table[i].option.decimal;
|
|
|
|
sendto_one(source_p, ":%s %d %s :%-30s %-5s [%-30s]",
|
|
get_id(&me, source_p), RPL_INFO,
|
|
get_id(source_p, source_p),
|
|
info_table[i].name,
|
|
option ? "YES" : "NO",
|
|
info_table[i].desc ? info_table[i].desc : "<none>");
|
|
|
|
break;
|
|
}
|
|
|
|
case OUTPUT_BOOLEAN2:
|
|
{
|
|
int option = *info_table[i].option.decimal_ptr;
|
|
|
|
sendto_one(source_p, ":%s %d %s :%-30s %-5s [%-30s]",
|
|
me.name, RPL_INFO, source_p->name,
|
|
info_table[i].name,
|
|
option ? ((option == 1) ? "MASK" : "YES") : "NO",
|
|
info_table[i].desc ? info_table[i].desc : "<none>");
|
|
} /* switch (info_table[i].output_type) */
|
|
}
|
|
} /* forloop */
|
|
|
|
sendto_one(source_p, ":%s %d %s :%-30s %-5s [%-30s]",
|
|
get_id(&me, source_p), RPL_INFO,
|
|
get_id(source_p, source_p),
|
|
"io_type", rb_get_iotype(), "Method of Multiplexed I/O");
|
|
|
|
/* Don't send oper_only_umodes...it's a bit mask, we will have to decode it
|
|
** in order for it to show up properly to opers who issue INFO
|
|
*/
|
|
|
|
sendto_one_numeric(source_p, RPL_INFO, form_str(RPL_INFO), "");
|
|
}
|
|
|
|
/* info_spy()
|
|
*
|
|
* input - pointer to client
|
|
* output - none
|
|
* side effects - hook doing_info is called
|
|
*/
|
|
static void
|
|
info_spy(struct Client *source_p)
|
|
{
|
|
hook_data hd;
|
|
|
|
hd.client = source_p;
|
|
hd.arg1 = hd.arg2 = NULL;
|
|
|
|
call_hook(doing_info_hook, &hd);
|
|
}
|