/* Main OperServ module.
*
* IRC Services is copyright (c) 1996-2007 Andrew Church.
* E-mail: <achurch@achurch.org>
* Parts written by Andrew Kempe and others.
* This program is free but copyrighted software; see the file COPYING for
* details.
*/
#include "services.h"
#include "modules.h"
#include "conffile.h"
#include "language.h"
#include "commands.h"
#include "timeout.h"
#include "encrypt.h"
#include "ignore.h"
#include "modules/nickserv/nickserv.h"
#ifdef DEBUG_COMMANDS
# include "modules/chanserv/chanserv.h" /* for send_user_info */
#endif
#include "operserv.h"
#include "maskdata.h"
#include "akill.h"
#include "news.h"
/* Maximum depth for SERVERMAP command */
#define MAXMAPLEVEL 64
/*************************************************************************/
static Module *module;
static Module *module_akill;
static Module *module_nickserv;
char *s_OperServ;
static char *desc_OperServ;
char *s_GlobalNoticer;
static char *desc_GlobalNoticer;
static char *OperDBName;
EXPORT_VAR(char *,s_OperServ)
EXPORT_VAR(char *,s_GlobalNoticer)
char * ServicesRoot;
static int WallOper;
static int WallBadOS;
static int WallOSChannel;
static int WallSU;
static int KillClonesAutokill;
static time_t KillClonesAutokillExpire;
static int AllowRaw;
EXPORT_VAR(char *,ServicesRoot)
static int cb_command = -1;
static int cb_expire_md = -1;
static int cb_help = -1;
static int cb_help_cmds = -1;
static int cb_set = -1;
static int cb_stats = -1;
static int cb_stats_all = -1;
static int db_opened = 0;
/* Services super-user password */
static char supass[PASSMAX];
/* Is the password currently unset? */
static int8 no_supass = 1;
/*************************************************************************/
static void do_help(User *u);
static void do_global(User *u);
static void do_stats(User *u);
static void do_servermap(User *u);
static void do_admin(User *u);
static void do_oper(User *u);
static void do_os_mode(User *u);
static void do_clearmodes(User *u);
static void do_clearchan(User *u);
static void do_os_kick(User *u);
static void do_su(User *u);
static void do_set(User *u);
static void do_jupe(User *u);
static void do_raw(User *u);
static void do_update(User *u);
static void do_os_quit(User *u);
static void do_shutdown(User *u);
static void do_restart(User *u);
static void do_rehash(User *u);
static void do_listignore(User *u);
static void do_killclones(User *u);
#ifdef DEBUG_COMMANDS
static void send_server_list(User *u);
static void send_channel_list(User *u);
static void send_channel_users(User *u);
static void send_user_list(User *u);
static void send_user_info(User *u);
static void do_matchwild(User *u);
static void do_setcmode(User *u);
#endif
/*************************************************************************/
static Command cmds[] = {
{"HELP", do_help, NULL, -1, -1,-1},
{"GLOBAL", do_global, NULL, OPER_HELP_GLOBAL, -1,-1},
{"STATS", do_stats, NULL, OPER_HELP_STATS, -1,-1},
{"UPTIME", do_stats, NULL, OPER_HELP_STATS, -1,-1},
{"SERVERMAP", do_servermap, NULL, OPER_HELP_SERVERMAP, -1,-1},
/* Anyone can use the LIST option to the ADMIN and OPER commands; those
* routines check privileges to ensure that only authorized users
* modify the list. */
{"ADMIN", do_admin, NULL, OPER_HELP_ADMIN, -1,-1},
{"OPER", do_oper, NULL, OPER_HELP_OPER, -1,-1},
/* Commands for Services opers: */
{"MODE", do_os_mode, is_services_oper, OPER_HELP_MODE, -1,-1},
{"KICK", do_os_kick, is_services_oper, OPER_HELP_KICK, -1,-1},
{"CLEARMODES",do_clearmodes,is_services_oper, OPER_HELP_CLEARMODES,-1,-1},
{"CLEARCHAN", do_clearchan, is_services_oper, OPER_HELP_CLEARCHAN, -1,-1},
{"KILLCLONES",do_killclones,is_services_oper, OPER_HELP_KILLCLONES,-1,-1},
/* Commands for Services admins: */
{"SU", do_su, NULL, OPER_HELP_SU, -1,-1},
{"SET", do_set, is_services_admin,OPER_HELP_SET, -1,-1},
{"SET READONLY",NULL, NULL, OPER_HELP_SET_READONLY,-1,-1},
{"SET DEBUG", NULL, NULL, OPER_HELP_SET_DEBUG, -1,-1},
{"SET SUPASS",NULL, NULL, OPER_HELP_SET_SUPASS,-1,-1},
{"JUPE", do_jupe, is_services_admin,OPER_HELP_JUPE, -1,-1},
{"UPDATE", do_update, is_services_admin,OPER_HELP_UPDATE, -1,-1},
{"QUIT", do_os_quit, is_services_admin,OPER_HELP_QUIT, -1,-1},
{"SHUTDOWN", do_shutdown, is_services_admin,OPER_HELP_SHUTDOWN, -1,-1},
{"RESTART", do_restart, is_services_admin,OPER_HELP_RESTART, -1,-1},
{"REHASH", do_rehash, is_services_admin,OPER_HELP_REHASH, -1,-1,
IRCSERVICES_CONF },
{"LISTIGNORE",do_listignore,is_services_admin,-1, -1,-1},
/* Commands for Services super-user: */
{"RAW", do_raw, is_services_root, OPER_HELP_RAW, -1,-1},
#ifdef DEBUG_COMMANDS
{"LISTSERVERS", send_server_list, is_services_root, -1,-1,-1},
{"LISTCHANS", send_channel_list, is_services_root, -1,-1,-1},
{"LISTCHAN", send_channel_users, is_services_root, -1,-1,-1},
{"LISTUSERS", send_user_list, is_services_root, -1,-1,-1},
{"LISTUSER", send_user_info, is_services_root, -1,-1,-1},
{"LISTTIMERS", send_timeout_list, is_services_root, -1,-1,-1},
{"MATCHWILD", do_matchwild, is_services_root, -1,-1,-1},
{"SETCMODE", do_setcmode, is_services_root, -1,-1,-1},
#endif
/* Fencepost: */
{ NULL }
};
/*************************************************************************/
/*************************** NickServ imports ****************************/
/*************************************************************************/
/* This is somewhat inefficient, but since it's not called often it should
* do for the time being. FIXME: find a more general way to implement
* intermodule function imports. (cf. database/version4's extsyms.[ch])
*/
#define _get_ngi local__get_ngi
static NickGroupInfo *local__get_ngi(NickInfo *ni, const char *file, int line)
{
typeof(_get_ngi) *p__get_ngi;
if (!module_nickserv)
return NULL;
p__get_ngi = get_module_symbol(module_nickserv, "_get_ngi");
if (!p__get_ngi) {
module_log("Unable to find symbol `_get_ngi' in module"
" `nickserv/main' (called from %s:%d)", file, line);
return NULL;
}
return p__get_ngi(ni, file, line);
}
/*************************************************************************/
/***************************** Main routines *****************************/
/*************************************************************************/
/* Introduce the OperServ pseudoclient and related clients. */
static int introduce_operserv(const char *nick)
{
if (!nick || irc_stricmp(nick, s_OperServ) == 0) {
char modebuf[BUFSIZE];
snprintf(modebuf, sizeof(modebuf), "oi%s", pseudoclient_modes);
send_nick(s_OperServ, ServiceUser, ServiceHost, ServerName,
desc_OperServ, modebuf);
if (nick)
return 1;
}
if (!nick || irc_stricmp(nick, s_GlobalNoticer) == 0) {
char modebuf[BUFSIZE];
snprintf(modebuf, sizeof(modebuf), "oi%s", pseudoclient_modes);
send_nick(s_GlobalNoticer, ServiceUser, ServiceHost, ServerName,
desc_GlobalNoticer, modebuf);
if (nick)
return 1;
}
return 0;
}
/*************************************************************************/
/* Main OperServ routine. */
static int operserv(const char *source, const char *target, char *buf)
{
char *cmd;
const char *s;
User *u = get_user(source);
if (irc_stricmp(target, s_OperServ) != 0)
return 0;
if (!u) {
module_log("user record for %s not found", source);
notice(s_OperServ, source, "Access denied.");
if (WallBadOS)
wallops(s_OperServ, "Denied access to %s from %s (user record"
" missing)", s_OperServ, source);
return 1;
}
if (!is_oper(u)) {
notice_lang(s_OperServ, u, ACCESS_DENIED);
if (WallBadOS)
wallops(s_OperServ, "Denied access to %s from %s (non-oper)",
s_OperServ, source);
module_log("Non-oper %s!%s@%s sent: %s",
u->nick, u->username, u->host, buf);
return 1;
}
/* Don't log stuff that might be passwords */
if (strnicmp(buf, "SU ", 3) == 0) {
module_log("%s: SU xxxxxx", source);
} else if (strnicmp(buf, "SET ", 4) == 0
&& (s = stristr(buf, "SUPASS")) != NULL
&& strspn(buf+4, " ") == s-(buf+4)) {
/* All that was needed to make sure someone doesn't fool us with
* "SET READONLY ON SUPASS". Which wouldn't work anyway, but we
* ought to log it properly... */
module_log("%s: SET SUPASS xxxxxx", source);
} else {
module_log("%s: %s", source, buf);
}
cmd = strtok(buf, " ");
if (!cmd) {
return 1;
} else if (stricmp(cmd, "\1PING") == 0) {
if (!(s = strtok(NULL, "")))
s = "\1";
notice(s_OperServ, source, "\1PING %s", s);
} else {
if (call_callback_2(module, cb_command, u, cmd) <= 0)
run_cmd(s_OperServ, u, module, cmd);
}
return 1;
}
/*************************************************************************/
/* Return a /WHOIS response for OperServ or the global noticer. */
static int operserv_whois(const char *source, char *who, char *extra)
{
if (irc_stricmp(who, s_OperServ) == 0) {
send_cmd(ServerName, "311 %s %s %s %s * :%s", source, who,
ServiceUser, ServiceHost, desc_OperServ);
} else if (irc_stricmp(who, s_GlobalNoticer) == 0) {
send_cmd(ServerName, "311 %s %s %s %s * :%s", source, who,
ServiceUser, ServiceHost, desc_GlobalNoticer);
} else {
return 0;
}
send_cmd(ServerName, "312 %s %s %s :%s", source, who,
ServerName, ServerDesc);
send_cmd(ServerName, "313 %s %s :is a network service", source, who);
send_cmd(ServerName, "318 %s %s End of /WHOIS response.", source, who);
return 1;
}
/*************************************************************************/
/* Watch for umode +o and send wallops. This callback is only activated if
* WallOper is specified in modules.conf.
*/
static int wall_oper_callback(User *u, int modechar, int add)
{
if (modechar == 'o' && add)
wallops(s_OperServ, "\2%s\2 is now an IRC operator.", u->nick);
return 0;
}
/*************************************************************************/
/* Callback for saving data. */
static int do_save_data(void)
{
sync_operserv_db(OperDBName);
return 0;
}
/*************************************************************************/
/* Callback for NickServ REGISTER/LINK check; we disallow
* registration/linking of the OperServ pseudoclient nickname.
*/
static int do_reglink_check(const User *u, const char *nick,
const char *pass, const char *email)
{
return irc_stricmp(nick, s_OperServ) == 0
|| irc_stricmp(nick, s_GlobalNoticer) == 0;
}
/*************************************************************************/
/**************************** Privilege checks ***************************/
/*************************************************************************/
/* Does the given user have Services super-user privileges? */
EXPORT_FUNC(is_services_root)
int is_services_root(User *u)
{
NickInfo *ni;
int rootid;
static int warned_ni = 0, warned_id = 0;
if (u->flags & UF_SERVROOT)
return 1;
if (!(ni = get_nickinfo(ServicesRoot))) {
if (!warned_ni) {
wallops(s_OperServ, "Warning: Services super-user nickname %s"
" is not registered", ServicesRoot);
warned_ni = 1;
}
module_log("warning: ServicesRoot nickname not registered");
return 0;
}
warned_ni = 0;
if (!(rootid = ni->nickgroup)) {
if (!warned_id) {
wallops(s_OperServ, "Warning: Services super-user nickname %s"
" is forbidden or not properly registered", ServicesRoot);
warned_id = 1;
}
module_log("warning: ServicesRoot nickname forbidden or registered"
" data corrupt");
return 0;
}
if (!is_oper(u) || !u->ni || u->ni->nickgroup != rootid)
return 0;
if (user_identified(u))
return 1;
return 0;
}
/*************************************************************************/
/* Does the given user have Services admin privileges? */
EXPORT_FUNC(is_services_admin)
int is_services_admin(User *u)
{
if (!is_oper(u) || !user_identified(u))
return 0;
if (is_services_root(u))
return 1;
return u->ngi && u->ngi != NICKGROUPINFO_INVALID
&& u->ngi->os_priv >= NP_SERVADMIN;
}
/*************************************************************************/
/* Does the given user have Services oper privileges? */
EXPORT_FUNC(is_services_oper)
int is_services_oper(User *u)
{
if (!is_oper(u) || !user_identified(u))
return 0;
if (is_services_root(u))
return 1;
return u->ngi && u->ngi != NICKGROUPINFO_INVALID
&& u->ngi->os_priv >= NP_SERVOPER;
}
/*************************************************************************/
/* Is the given nick a Services admin/root nick? */
/* NOTE: Do not use this to check if a user who is online is a services
* admin or root. This function only checks if a user has the ABILITY to be
* a services admin. Rather use is_services_admin(User *u). -TheShadow */
EXPORT_FUNC(nick_is_services_admin)
int nick_is_services_admin(NickInfo *ni)
{
NickGroupInfo *ngi;
if (!ni || !(ngi = get_ngi(ni)))
return 0;
if (stricmp(ni->nick, ServicesRoot) == 0)
return 1;
return ngi->os_priv >= NP_SERVADMIN;
}
/*************************************************************************/
/********************** Admin/oper list modification *********************/
/*************************************************************************/
#define LIST_ADMIN 0
#define LIST_OPER 1
#define MSG_EXISTS 0
#define MSG_EXISTS_NEXT 1
#define MSG_ADDED 2
#define MSG_TOOMANY 3
#define MSG_REMOVED 4
#define MSG_NOTFOUND 5
static int privlist_msgs[2][6] = {
{ OPER_ADMIN_EXISTS,
0,
OPER_ADMIN_ADDED,
OPER_ADMIN_TOO_MANY,
OPER_ADMIN_REMOVED,
OPER_ADMIN_NOT_FOUND,
},
{ OPER_OPER_EXISTS,
OPER_ADMIN_EXISTS,
OPER_OPER_ADDED,
OPER_OPER_TOO_MANY,
OPER_OPER_REMOVED,
OPER_OPER_NOT_FOUND,
},
};
/*************************************************************************/
/* Add a nick to the Services admin/oper list. u is the command sender. */
static void privlist_add(User *u, int listid, const char *nick)
{
int16 level = (listid==LIST_ADMIN ? NP_SERVADMIN : NP_SERVOPER);
int16 nextlevel = (listid==LIST_ADMIN ? 0 : NP_SERVADMIN);
int *msgs = privlist_msgs[listid];
NickInfo *ni;
NickGroupInfo *ngi;
if (!(ni = get_nickinfo(nick))) {
notice_lang(s_OperServ, u, NICK_X_NOT_REGISTERED, nick);
return;
}
if (!(ngi = get_ngi(ni))) {
notice_lang(s_OperServ, u, INTERNAL_ERROR);
return;
}
if (nextlevel && ngi->os_priv >= nextlevel) {
notice_lang(s_OperServ, u, msgs[MSG_EXISTS_NEXT], nick);
return;
} else if (ngi->os_priv >= level) {
notice_lang(s_OperServ, u, msgs[MSG_EXISTS], nick);
return;
}
ngi->os_priv = level;
put_nickgroupinfo(ngi);
notice_lang(s_OperServ, u, msgs[MSG_ADDED], nick);
if (readonly)
notice_lang(s_OperServ, u, READ_ONLY_MODE);
else
put_nickgroupinfo(ngi);
}
/*************************************************************************/
/* Remove a nick from the Services admin/oper list. */
static void privlist_rem(User *u, int listid, const char *nick)
{
int16 level = (listid==LIST_ADMIN ? NP_SERVADMIN : NP_SERVOPER);
int16 nextlevel = (listid==LIST_ADMIN ? 0 : NP_SERVADMIN);
int *msgs = privlist_msgs[listid];
NickInfo *ni;
NickGroupInfo *ngi;
if (!(ni = get_nickinfo(nick))) {
notice_lang(s_OperServ, u, NICK_X_NOT_REGISTERED, nick);
return;
}
if (!(ngi = get_ngi(ni))) {
notice_lang(s_OperServ, u, INTERNAL_ERROR);
return;
}
if (ngi->os_priv < level || (nextlevel && ngi->os_priv >= nextlevel)) {
notice_lang(s_OperServ, u, msgs[MSG_NOTFOUND], nick);
return;
}
ngi->os_priv = 0;
put_nickgroupinfo(ngi);
notice_lang(s_OperServ, u, msgs[MSG_REMOVED], nick);
if (readonly)
notice_lang(s_OperServ, u, READ_ONLY_MODE);
else
put_nickgroupinfo(ngi);
}
/*************************************************************************/
/*********************** OperServ command functions **********************/
/*************************************************************************/
/* HELP command. */
static void do_help(User *u)
{
char *cmd = strtok_remaining();
Module *mod;
if (!cmd) {
notice_help(s_OperServ, u, OPER_HELP);
} else if (call_callback_2(module, cb_help, u, cmd) > 0) {
return;
} else if (stricmp(cmd, "COMMANDS") == 0) {
notice_help(s_OperServ, u, OPER_HELP_COMMANDS);
call_callback_2(module, cb_help_cmds, u, 0);
notice_help(s_OperServ, u, OPER_HELP_COMMANDS_SERVOPER);
if ((mod = find_module("operserv/akill"))) {
int *p_EnableExclude;
notice_help(s_OperServ, u, OPER_HELP_COMMANDS_AKILL);
p_EnableExclude = get_module_symbol(mod, "EnableExclude");
if (p_EnableExclude && *p_EnableExclude)
notice_help(s_OperServ, u, OPER_HELP_COMMANDS_EXCLUDE);
}
if (find_module("operserv/sline"))
notice_help(s_OperServ, u, OPER_HELP_COMMANDS_SLINE);
if (find_module("operserv/sessions"))
notice_help(s_OperServ, u, OPER_HELP_COMMANDS_SESSION);
if (find_module("operserv/news"))
notice_help(s_OperServ, u, OPER_HELP_COMMANDS_NEWS);
call_callback_2(module, cb_help_cmds, u, 1);
notice_help(s_OperServ, u, OPER_HELP_COMMANDS_SERVADMIN);
call_callback_2(module, cb_help_cmds, u, 2);
notice_help(s_OperServ, u, OPER_HELP_COMMANDS_SERVROOT);
if (AllowRaw)
notice_help(s_OperServ, u, OPER_HELP_COMMANDS_RAW);
call_callback_2(module, cb_help_cmds, u, 3);
} else {
help_cmd(s_OperServ, u, module, cmd);
}
}
/*************************************************************************/
/* Global notice sending via GlobalNoticer. */
static void do_global(User *u)
{
char *msg = strtok_remaining();
if (!msg) {
syntax_error(s_OperServ, u, "GLOBAL", OPER_GLOBAL_SYNTAX);
return;
}
notice_all(s_GlobalNoticer, "%s", msg);
}
/*************************************************************************/
/* STATS command. */
static void do_stats(User *u)
{
time_t uptime = time(NULL) - start_time;
char *extra = strtok_remaining();
int days = uptime/86400, hours = (uptime/3600)%24,
mins = (uptime/60)%60, secs = uptime%60;
char timebuf[BUFSIZE];
if (extra && stricmp(extra, "UPTIME") == 0)
extra = NULL;
if (extra && stricmp(extra, "ALL") != 0) {
if (stricmp(extra, "RESET") == 0) {
int i;
maxusercnt = usercnt;
maxusertime = time(NULL);
notice_lang(s_OperServ, u, OPER_STATS_RESET_USER_COUNT);
if ((i = OSDATA_MAXUSERCNT, !put_operserv_data(i, &maxusercnt))
|| (i = OSDATA_MAXUSERTIME, !put_operserv_data(i, &maxusertime))
) {
module_log("STATS RESET: put_operserv_data(%d) failed", i);
wallops(s_OperServ, "Unable to update OperServ data!");
}
} else if (call_callback_2(module, cb_stats, u, extra) > 0) {
/* nothing */
} else if (stricmp(extra, "NETWORK") == 0) {
uint32 read, written, socksize, totalsize;
int ratio1, ratio2;
sock_rwstat(servsock, &read, &written);
sock_bufstat(servsock, &socksize, &totalsize, &ratio1, &ratio2);
socksize /= 1024;
totalsize /= 1024;
notice_lang(s_OperServ, u, OPER_STATS_KBYTES_READ, read);
notice_lang(s_OperServ, u, OPER_STATS_KBYTES_WRITTEN, written);
if (ratio1)
notice_lang(s_OperServ, u, OPER_STATS_NETBUF_SOCK_PERCENT,
socksize, ratio1);
else
notice_lang(s_OperServ, u, OPER_STATS_NETBUF_SOCK, socksize);
if (ratio2)
notice_lang(s_OperServ, u, OPER_STATS_NETBUF_TOTAL_PERCENT,
totalsize, ratio2);
else
notice_lang(s_OperServ, u, OPER_STATS_NETBUF_TOTAL, totalsize);
} else {
notice_lang(s_OperServ, u, OPER_STATS_UNKNOWN_OPTION,
strupper(extra));
}
return;
}
notice_lang(s_OperServ, u, OPER_STATS_CURRENT_USERS, usercnt, opcnt);
strftime_lang(timebuf, sizeof(timebuf), u->ngi,
STRFTIME_DATE_TIME_FORMAT, maxusertime);
notice_lang(s_OperServ, u, OPER_STATS_MAX_USERS, maxusercnt, timebuf);
if (days >= 1) {
const char *str = getstring(u->ngi, days!=1 ? STR_DAYS : STR_DAY);
notice_lang(s_OperServ, u, OPER_STATS_UPTIME_DHMS,
days, str, hours, mins, secs);
} else {
notice_lang(s_OperServ, u, OPER_STATS_UPTIME_HM_MS,
maketime(u->ngi, uptime, MT_DUALUNIT|MT_SECONDS));
}
if (extra && stricmp(extra, "ALL") == 0 && is_services_admin(u)) {
long count, mem;
get_user_stats(&count, &mem);
notice_lang(s_OperServ, u, OPER_STATS_ALL_USER_MEM,
count, (mem+512) / 1024);
get_channel_stats(&count, &mem);
notice_lang(s_OperServ, u, OPER_STATS_ALL_CHANNEL_MEM,
count, (mem+512) / 1024);
get_server_stats(&count, &mem);
notice_lang(s_OperServ, u, OPER_STATS_ALL_SERVER_MEM,
count, (mem+512) / 1024);
call_callback_2(module, cb_stats_all, u, s_OperServ);
}
}
/*************************************************************************/
/* Server map display. */
static void map_server(User *u, Server *s, int level); /* defined below */
static void do_servermap(User *u)
{
Server *root = get_server("");
if (!root) {
module_log("BUG: root server not found for SERVERMAP");
notice_lang(s_OperServ, u, INTERNAL_ERROR);
return;
}
map_server(u, root, 0);
}
/* Recursively print the server map. This routine prints the given server
* at level `level' of indentation (0 = left margin), then prints its
* children in child->sibling->sibling... order.
*/
static void map_server(User *u, Server *s, int level)
{
static int need_bar[MAXMAPLEVEL]; /* which levs need a continuation bar? */
static const char *indentstr = " +-- ";
static const char *barstr = " | ";
static const char *nobarstr = " ";
char buf[BUFSIZE], *ptr;
int i;
ptr = buf;
*ptr = 0;
i = 0;
while (i < level-1) {
ptr += snprintf(ptr, sizeof(buf)-(ptr-buf), "%s",
need_bar[i] ? barstr : nobarstr);
i++;
}
if (level)
ptr += snprintf(ptr, sizeof(buf)-(ptr-buf), "%s", indentstr);
notice(s_OperServ, u->nick, "%s%s%s", buf,
s ? (*s->name ? s->name : ServerName) : "...",
(s && s->fake) ? "(*)" : "");
if (s && s->child) {
if (level+1 >= MAXMAPLEVEL) {
map_server(u, NULL, level+1);
return;
}
for (s = s->child; s; s = s->sibling) {
need_bar[level] = (s->sibling != NULL);
map_server(u, s, level+1);
}
}
}
/*************************************************************************/
/* Channel mode changing (MODE command). */
static void do_os_mode(User *u)
{
int argc;
char **argv;
char *s = strtok_remaining();
char *chan, *modes;
Channel *c;
if (!s) {
syntax_error(s_OperServ, u, "MODE", OPER_MODE_SYNTAX);
return;
}
chan = s;
s += strcspn(s, " ");
if (!*s) {
syntax_error(s_OperServ, u, "MODE", OPER_MODE_SYNTAX);
return;
}
*s = 0;
modes = (s+1) + strspn(s+1, " ");
if (!*modes) {
syntax_error(s_OperServ, u, "MODE", OPER_MODE_SYNTAX);
return;
}
if (!(c = get_channel(chan))) {
notice_lang(s_OperServ, u, CHAN_X_NOT_IN_USE, chan);
} else if (c->bouncy_modes) {
notice_lang(s_OperServ, u, OPER_BOUNCY_MODES);
return;
} else {
send_cmd(s_OperServ, "MODE %s %s", chan, modes);
if (WallOSChannel)
wallops(s_OperServ, "%s used MODE %s on %s", u->nick, modes, chan);
*s = ' ';
argc = split_buf(chan, &argv, 1);
do_cmode(s_OperServ, argc, argv);
}
}
/*************************************************************************/
/* Clear all modes from a channel. */
static void do_clearmodes(User *u)
{
char *s;
char *chan = strtok(NULL, " ");
Channel *c;
int all = 0;
if (!chan) {
syntax_error(s_OperServ, u, "CLEARMODES", OPER_CLEARMODES_SYNTAX);
} else if (!(c = get_channel(chan))) {
notice_lang(s_OperServ, u, CHAN_X_NOT_IN_USE, chan);
} else if (c->bouncy_modes) {
notice_lang(s_OperServ, u, OPER_BOUNCY_MODES);
return;
} else {
s = strtok(NULL, " ");
if (s) {
if (stricmp(s, "ALL") == 0) {
all = 1;
} else {
syntax_error(s_OperServ,u,"CLEARMODES",OPER_CLEARMODES_SYNTAX);
return;
}
}
if (WallOSChannel)
wallops(s_OperServ, "%s used CLEARMODES%s on %s",
u->nick, all ? " ALL" : "", chan);
if (all) {
clear_channel(c, CLEAR_UMODES, (void *)MODE_ALL);
clear_channel(c, CLEAR_CMODES, NULL);
notice_lang(s_OperServ, u, OPER_CLEARMODES_ALL_DONE, chan);
} else {
clear_channel(c, CLEAR_CMODES, NULL);
notice_lang(s_OperServ, u, OPER_CLEARMODES_DONE, chan);
}
}
}
/*************************************************************************/
/* Remove all users from a channel. */
static void do_clearchan(User *u)
{
char *chan = strtok(NULL, " ");
Channel *c;
char buf[BUFSIZE];
if (!chan) {
syntax_error(s_OperServ, u, "CLEARCHAN", OPER_CLEARCHAN_SYNTAX);
} else if (!(c = get_channel(chan))) {
notice_lang(s_OperServ, u, CHAN_X_NOT_IN_USE, chan);
} else if (c->bouncy_modes) {
notice_lang(s_OperServ, u, OPER_BOUNCY_MODES);
return;
} else {
if (WallOSChannel)
wallops(s_OperServ, "%s used CLEARCHAN on %s", u->nick, chan);
snprintf(buf, sizeof(buf), "CLEARCHAN by %s", u->nick);
clear_channel(c, CLEAR_USERS, buf);
notice_lang(s_OperServ, u, OPER_CLEARCHAN_DONE, chan);
}
}
/*************************************************************************/
/* Kick a user from a channel (KICK command). */
static void do_os_kick(User *u)
{
char *argv[3];
char *chan, *nick, *s;
Channel *c;
chan = strtok(NULL, " ");
nick = strtok(NULL, " ");
s = strtok_remaining();
if (!chan || !nick || !s) {
syntax_error(s_OperServ, u, "KICK", OPER_KICK_SYNTAX);
return;
}
if (!(c = get_channel(chan))) {
notice_lang(s_OperServ, u, CHAN_X_NOT_IN_USE, chan);
} else if (c->bouncy_modes) {
notice_lang(s_OperServ, u, OPER_BOUNCY_MODES);
return;
}
send_cmd(s_OperServ, "KICK %s %s :%s (%s)", chan, nick, u->nick, s);
if (WallOSChannel)
wallops(s_OperServ, "%s used KICK on %s/%s", u->nick, nick, chan);
argv[0] = chan;
argv[1] = nick;
argv[2] = s;
do_kick(s_OperServ, 3, argv);
}
/*************************************************************************/
/* Services admin list viewing/modification. */
static void do_admin(User *u)
{
const char *cmd, *nick;
if (!module_nickserv) {
notice_lang(s_OperServ, u, OPER_ADMIN_NO_NICKSERV);
return;
}
cmd = strtok(NULL, " ");
if (!cmd)
cmd = "";
if (stricmp(cmd, "ADD") == 0) {
if (!is_services_root(u)) {
notice_lang(s_OperServ, u, PERMISSION_DENIED);
return;
}
nick = strtok(NULL, " ");
if (nick)
privlist_add(u, LIST_ADMIN, nick);
else
syntax_error(s_OperServ, u, "ADMIN", OPER_ADMIN_ADD_SYNTAX);
} else if (stricmp(cmd, "DEL") == 0) {
if (!is_services_root(u)) {
notice_lang(s_OperServ, u, PERMISSION_DENIED);
return;
}
nick = strtok(NULL, " ");
if (nick)
privlist_rem(u, LIST_ADMIN, nick);
else
syntax_error(s_OperServ, u, "ADMIN", OPER_ADMIN_DEL_SYNTAX);
} else if (stricmp(cmd, "LIST") == 0) {
NickGroupInfo *ngi;
notice_lang(s_OperServ, u, OPER_ADMIN_LIST_HEADER);
for (ngi = first_nickgroupinfo(); ngi; ngi = next_nickgroupinfo()) {
if (ngi->os_priv >= NP_SERVADMIN)
notice(s_OperServ, u->nick, "%s", ngi_mainnick(ngi));
}
} else {
syntax_error(s_OperServ, u, "ADMIN", OPER_ADMIN_SYNTAX);
}
}
/*************************************************************************/
/* Services oper list viewing/modification. */
static void do_oper(User *u)
{
const char *cmd, *nick;
if (!module_nickserv) {
notice_lang(s_OperServ, u, OPER_OPER_NO_NICKSERV);
return;
}
cmd = strtok(NULL, " ");
if (!cmd)
cmd = "";
if (stricmp(cmd, "ADD") == 0) {
if (!is_services_admin(u)) {
notice_lang(s_OperServ, u, PERMISSION_DENIED);
return;
}
nick = strtok(NULL, " ");
if (nick)
privlist_add(u, LIST_OPER, nick);
else
syntax_error(s_OperServ, u, "OPER", OPER_OPER_ADD_SYNTAX);
} else if (stricmp(cmd, "DEL") == 0) {
if (!is_services_admin(u)) {
notice_lang(s_OperServ, u, PERMISSION_DENIED);
return;
}
nick = strtok(NULL, " ");
if (nick)
privlist_rem(u, LIST_OPER, nick);
else
syntax_error(s_OperServ, u, "OPER", OPER_OPER_DEL_SYNTAX);
} else if (stricmp(cmd, "LIST") == 0) {
NickGroupInfo *ngi;
notice_lang(s_OperServ, u, OPER_OPER_LIST_HEADER);
for (ngi = first_nickgroupinfo(); ngi; ngi = next_nickgroupinfo()) {
if (ngi->os_priv >= NP_SERVOPER && ngi->os_priv < NP_SERVADMIN)
notice(s_OperServ, u->nick, "%s", ngi_mainnick(ngi));
}
} else {
syntax_error(s_OperServ, u, "OPER", OPER_OPER_SYNTAX);
}
}
/*************************************************************************/
/* Obtain Services root privileges. We check permissions here instead of
* letting run_cmd() do it for us so we can send out warnings when a
* non-admin tries to use the command, and allow anyone to use it when
* NickServ isn't loaded.
*/
static void do_su(User *u)
{
char *password = strtok_remaining();
int res;
if (module_nickserv && !is_services_admin(u)) {
wallops(s_OperServ, "\2NOTICE:\2 %s!%s@%s attempted to use SU "
"command (not Services admin)",
u->nick, u->username, u->host);
notice_lang(s_OperServ, u, PERMISSION_DENIED);
return;
}
if (!password) {
syntax_error(s_OperServ, u, "SU", OPER_SU_SYNTAX);
} else if (no_supass) {
notice_lang(s_OperServ, u, OPER_SU_NO_PASSWORD);
} else if ((res = check_password(password, supass)) < 0) {
notice_lang(s_OperServ, u, OPER_SU_FAILED);
} else if (res == 0) {
module_log("Failed SU by %s!%s@%s", u->nick, u->username, u->host);
wallops(s_OperServ, "\2NOTICE:\2 Failed SU by %s!%s@%s",
u->nick, u->username, u->host);
bad_password(s_OperServ, u, "Services root");
} else {
u->flags |= UF_SERVROOT;
if (WallSU)
wallops(s_OperServ,
"%s!%s@%s obtained Services super-user privileges",
u->nick, u->username, u->host);
notice_lang(s_OperServ, u, OPER_SU_SUCCEEDED);
}
}
/*************************************************************************/
/* Set various Services runtime options. */
static void do_set(User *u)
{
char *option = strtok(NULL, " ");
char *setting = strtok_remaining();
if (!option || (!setting && stricmp(option, "SUPASS") != 0)) {
syntax_error(s_OperServ, u, "SET", OPER_SET_SYNTAX);
return;
}
if (call_callback_3(module, cb_set, u, option, setting) > 0)
return;
if (stricmp(option, "IGNORE") == 0) {
if (stricmp(setting, "on") == 0) {
allow_ignore = 1;
notice_lang(s_OperServ, u, OPER_SET_IGNORE_ON);
} else if (stricmp(setting, "off") == 0) {
allow_ignore = 0;
notice_lang(s_OperServ, u, OPER_SET_IGNORE_OFF);
} else {
notice_lang(s_OperServ, u, OPER_SET_IGNORE_ERROR);
}
} else if (stricmp(option, "READONLY") == 0) {
if (stricmp(setting, "on") == 0) {
readonly = 1;
log("Read-only mode activated");
close_log();
notice_lang(s_OperServ, u, OPER_SET_READONLY_ON);
} else if (stricmp(setting, "off") == 0) {
readonly = 0;
open_log();
log("Read-only mode deactivated");
notice_lang(s_OperServ, u, OPER_SET_READONLY_OFF);
} else {
notice_lang(s_OperServ, u, OPER_SET_READONLY_ERROR);
}
} else if (stricmp(option, "DEBUG") == 0) {
if (stricmp(setting, "on") == 0) {
debug = 1;
log("Debug mode activated");
notice_lang(s_OperServ, u, OPER_SET_DEBUG_ON);
} else if (stricmp(setting, "off") == 0 ||
(*setting == '0' && atoi(setting) == 0)) {
log("Debug mode deactivated");
debug = 0;
notice_lang(s_OperServ, u, OPER_SET_DEBUG_OFF);
} else if (isdigit(*setting) && atoi(setting) > 0) {
debug = atoi(setting);
log("Debug mode activated (level %d)", debug);
notice_lang(s_OperServ, u, OPER_SET_DEBUG_LEVEL, debug);
} else {
notice_lang(s_OperServ, u, OPER_SET_DEBUG_ERROR);
}
} else if (stricmp(option, "SUPASS") == 0) {
int len;
char newpass[PASSMAX];
if (!is_services_root(u)) {
notice_lang(s_OperServ, u, PERMISSION_DENIED);
return;
}
if (!setting) {
no_supass = 1;
put_operserv_data(OSDATA_SUPASS, NULL);
notice_lang(s_OperServ, u, OPER_SET_SUPASS_NONE);
return;
}
len = strlen(setting);
if (len >= PASSMAX) {
memset(setting+PASSMAX-1, 0, len-(PASSMAX-1));
len = PASSMAX-1;
notice_lang(s_OperServ, u, PASSWORD_TRUNCATED, len);
}
if (encrypt(setting, len, newpass, PASSMAX) < 0) {
notice_lang(s_OperServ, u, OPER_SET_SUPASS_FAILED);
} else {
no_supass = 0;
memcpy(supass, newpass, PASSMAX);
put_operserv_data(OSDATA_SUPASS, supass);
notice_lang(s_OperServ, u, OPER_SET_SUPASS_OK);
}
} else {
notice_lang(s_OperServ, u, OPER_SET_UNKNOWN_OPTION, option);
}
}
/*************************************************************************/
static void do_jupe(User *u)
{
char *jserver = strtok(NULL, " ");
char *reason = strtok_remaining();
char buf[BUFSIZE];
Server *server;
if (!jserver) {
syntax_error(s_OperServ, u, "JUPE", OPER_JUPE_SYNTAX);
} else if (!strchr(jserver, '.')) {
notice_lang(s_OperServ, u, OPER_JUPE_INVALID_NAME);
} else if ((server = get_server(jserver)) != NULL && server->fake) {
notice_lang(s_OperServ, u, OPER_JUPE_ALREADY_JUPED, jserver);
} else {
wallops(s_OperServ, "\2Juping\2 %s by request of \2%s\2.",
jserver, u->nick);
if (reason)
snprintf(buf, sizeof(buf), "%s (%s)", reason, u->nick);
else
snprintf(buf, sizeof(buf), "Jupitered by %s", u->nick);
if (server) {
char *argv[2];
argv[0] = jserver;
argv[1] = buf;
send_cmd(ServerName, "SQUIT %s :%s", jserver, buf);
do_squit(ServerName, 2, argv);
}
send_server_remote(jserver, buf);
do_server("", -1, &jserver);
}
}
/*************************************************************************/
static void do_raw(User *u)
{
char *text = strtok_remaining();
if (!text)
syntax_error(s_OperServ, u, "RAW", OPER_RAW_SYNTAX);
else
send_cmd(NULL, "%s", text);
}
/*************************************************************************/
/* Callback and data used to send "update complete" message */
static int do_update_complete(int successful);
static User *update_sender = NULL;
static void do_update(User *u)
{
char *param = strtok_remaining();
if (param && *param) {
if (stricmp(param, "FORCE") != 0) {
syntax_error(s_OperServ, u, "UPDATE", OPER_UPDATE_SYNTAX);
return;
} else if (!is_services_admin(u)) {
notice_lang(s_OperServ, u, PERMISSION_DENIED);
return;
}
switch (is_data_locked()) {
case 1:
if (!unlock_data()) {
module_log_perror("UPDATE FORCE lock removal failed");
notice_lang(s_OperServ, u, OPER_UPDATE_FORCE_FAILED);
return;
}
break;
case -1:
module_log_perror("UPDATE FORCE lock check failed");
break;
}
}
notice_lang(s_OperServ, u, OPER_UPDATING);
save_data = 1;
update_sender = u; /* to send to when the update completes--it's safe
* to save this pointer since no more data will be
* processed before we use it again */
add_callback(NULL, "save data complete", do_update_complete);
}
static int do_update_complete(int successful)
{
if (update_sender) {
if (successful)
notice_lang(s_OperServ, update_sender, OPER_UPDATE_COMPLETE);
else
notice_lang(s_OperServ, update_sender, OPER_UPDATE_FAILED);
update_sender = NULL;
} else {
log("BUG: no sender in do_update_complete()");
}
remove_callback(NULL, "save data complete", do_update_complete);
return 0;
}
/*************************************************************************/
static void do_os_quit(User *u)
{
snprintf(quitmsg, sizeof(quitmsg),
"QUIT command received from %s", u->nick);
quitting = 1;
}
/*************************************************************************/
static void do_shutdown(User *u)
{
snprintf(quitmsg, sizeof(quitmsg),
"SHUTDOWN command received from %s", u->nick);
save_data = 1;
delayed_quit = 1;
}
/*************************************************************************/
static void do_restart(User *u)
{
snprintf(quitmsg, sizeof(quitmsg),
"RESTART command received from %s", u->nick);
save_data = 1;
delayed_quit = 2;
}
/*************************************************************************/
static void do_rehash(User *u)
{
/* Don't let ourselves be unloaded */
modules_allow_use_self++;
use_module(module);
notice_lang(s_OperServ, u, OPER_REHASHING);
wallops(NULL, "Rehashing configuration files (REHASH from %s)", u->nick);
if (reconfigure())
notice_lang(s_OperServ, u, OPER_REHASHED);
else
notice_lang(s_OperServ, u, OPER_REHASH_ERROR);
/* Restore normal module behavior */
unuse_module(module);
modules_allow_use_self--;
}
/*************************************************************************/
static void do_listignore(User *u)
{
int sent_header = 0;
IgnoreData *id;
for (id = first_ignore(); id; id = next_ignore()) {
if (!sent_header) {
notice_lang(s_OperServ, u, OPER_IGNORE_LIST);
sent_header = 1;
}
notice(s_OperServ, u->nick, "%ld %s", (long)id->time, id->who);
}
if (!sent_header)
notice_lang(s_OperServ, u, OPER_IGNORE_LIST_EMPTY);
}
/*************************************************************************/
/* Kill all users matching a certain host. The host is obtained from the
* supplied nick. The raw hostmask is not supplied with the command in an
* effort to prevent abuse and mistakes from being made--which might cause
* *.com to be killed. It also makes it very quick and simple to use--which
* is usually what you want when someone starts loading numerous clones. In
* addition to killing the clones, we add a temporary autokill to prevent
* them from immediately reconnecting.
* Syntax: KILLCLONES nick
* -TheShadow (29 Mar 1999)
*
* Added KillClonesAutokill support --AC
*/
static void do_killclones(User *u)
{
char *clonenick = strtok(NULL, " ");
User *cloneuser;
typeof(create_akill) *p_create_akill =
module_akill ? get_module_symbol(module_akill,"create_akill") : NULL;
if (!clonenick) {
notice_lang(s_OperServ, u, OPER_KILLCLONES_SYNTAX);
} else if (!(cloneuser = get_user(clonenick))) {
notice_lang(s_OperServ, u, OPER_KILLCLONES_UNKNOWN_NICK, clonenick);
} else {
char clonemask[BUFSIZE];
User *user;
int count = 0;
snprintf(clonemask, sizeof(clonemask), "*!*@%s", cloneuser->host);
for (user = first_user(); user; user = next_user()) {
if (match_usermask(clonemask, user) != 0) {
char killreason[32];
count++;
snprintf(killreason, sizeof(killreason),
"Cloning [%d]", count);
kill_user(NULL, user->nick, killreason);
}
}
module_log("KILLCLONES: %d clone(s) matching %s killed.",
count, clonemask);
if (KillClonesAutokill && p_create_akill) {
/* Add autokill if it doesn't exist. Use get_matching_maskdata()
* so that we find both exact matches and more general masks. */
if (!get_matching_maskdata(MD_AKILL, clonemask+2)) {
/* No mask fits these clones, so add a new one. */
const char akillreason[] = "Temporary KILLCLONES akill.";
p_create_akill(clonemask+2, akillreason, u->nick,
time(NULL) + KillClonesAutokillExpire);
wallops(s_OperServ,
getstring(NULL,OPER_KILLCLONES_KILLED_AKILL),
u->nick, clonemask, count, clonemask+2);
} else {
/* There's already a matching mask, so don't add a new one. */
wallops(s_OperServ, getstring(NULL,OPER_KILLCLONES_KILLED),
u->nick, clonemask, count);
}
} else {
/* Autokill option not set or module not available. */
wallops(s_OperServ, getstring(NULL,OPER_KILLCLONES_KILLED),
u->nick, clonemask, count);
}
}
}
/*************************************************************************/
#ifdef DEBUG_COMMANDS
/* All commands from here down are enabled only when DEBUG_COMMANDS is
* also enabled. */
/*************************************************************************/
/* Send the current list of servers to the given user. */
void send_server_list(User *user)
{
Server *server;
for (server = first_server(); server; server = next_server()) {
notice(s_OperServ, user->nick, "%s fake:%d hub:%s child:%s sibling:%s",
server->name, server->fake,
server->hub ? server->hub->name : "-",
server->child ? server->child->name : "-",
server->sibling ? server->sibling->name : "-");
}
}
/*************************************************************************/
/* Send the current list of channels to the named user. */
static void send_channel_list(User *user)
{
Channel *c;
char buf[BUFSIZE], *end;
struct c_userlist *u;
const char *source = user->nick;
for (c = first_channel(); c; c = next_channel()) {
notice(s_OperServ, source, "%s %ld +%s %d %s :%s",
c->name, (long)c->creation_time,
mode_flags_to_string(c->mode, MODE_CHANNEL),
c->limit, c->key ? c->key : "-",
c->topic ? c->topic : "");
end = buf;
end += snprintf(end, sizeof(buf)-(end-buf), "%s", c->name);
LIST_FOREACH (u, c->users) {
end += snprintf(end, sizeof(buf)-(end-buf), " +%s/%s",
mode_flags_to_string(u->mode,MODE_CHANUSER),
u->user->nick);
}
notice(s_OperServ, source, buf);
}
}
/*************************************************************************/
/* Send list of users on a single channel, taken from strtok(). */
static void send_channel_users(User *user)
{
char *chan = strtok(NULL, " ");
Channel *c = chan ? get_channel(chan) : NULL;
struct c_userlist *u;
const char *source = user->nick;
if (!c) {
notice(s_OperServ, source, "Channel %s not found!",
chan ? chan : "(null)");
return;
}
notice(s_OperServ, source, "Channel %s users:", chan);
LIST_FOREACH (u, c->users)
notice(s_OperServ, source, "%x/%s", u->mode, u->user->nick);
}
/*************************************************************************/
/* Send the current list of users to the given user. */
static void send_user_list(User *user)
{
User *u;
const char *source = user->nick;
for (u = first_user(); u; u = next_user()) {
char buf[5];
if (u->ni)
snprintf(buf, sizeof(buf), "%04X", u->ni->status & 0xFFFF);
else
strcpy(buf, "-");
notice(s_OperServ, source, "%s!%s@%s %s %s +%s %ld %u %s %s :%s",
u->nick, u->username, u->host, u->fakehost ? u->fakehost : "-",
u->ipaddr ? u->ipaddr : "-",
mode_flags_to_string(u->mode, MODE_USER), (long)u->signon,
u->servicestamp, u->server->name, buf, u->realname);
}
}
/*************************************************************************/
/* Send information about a single user to the given user. Target nick is
* taken from strtok(). */
static void send_user_info(User *user)
{
char *nick = strtok(NULL, " ");
User *u = nick ? get_user(nick) : NULL;
char buf[BUFSIZE], *s;
struct u_chanlist *c;
struct u_chaninfolist *ci;
const char *source = user->nick;
if (!u) {
notice(s_OperServ, source, "User %s not found!",
nick ? nick : "(null)");
return;
}
if (u->ni)
snprintf(buf, sizeof(buf), "%04X", u->ni->status & 0xFFFF);
else
strcpy(buf, "-");
notice(s_OperServ, source, "%s!%s@%s %s %s +%s %ld %u %s %s :%s",
u->nick, u->username, u->host, u->fakehost ? u->fakehost : "-",
u->ipaddr, mode_flags_to_string(u->mode, MODE_USER),
(long)u->signon, u->servicestamp, u->server->name, buf,
u->realname);
buf[0] = 0;
s = buf;
LIST_FOREACH (c, u->chans)
s += snprintf(s, sizeof(buf)-(s-buf), " %s", c->chan->name);
notice(s_OperServ, source, "%s%s", u->nick, buf);
buf[0] = 0;
s = buf;
LIST_FOREACH (ci, u->id_chans)
s += snprintf(s, sizeof(buf)-(s-buf), " %s", ci->chan);
notice(s_OperServ, source, "%s%s", u->nick, buf);
}
/*************************************************************************/
/* Perform a wildcard match and report the result (either 0 or 1) to the
* given user. */
static void do_matchwild(User *u)
{
char *pat = strtok(NULL, " ");
char *str = strtok(NULL, " ");
if (pat && str)
notice(s_OperServ, u->nick, "%d", match_wild(pat, str));
else
notice(s_OperServ, u->nick, "Syntax error.");
}
/*************************************************************************/
/* Call set_cmode() with ServerName and parameters taken from strtok() (up
* to SETCMODE_NPARAMS). */
#define SETCMODE_NPARAMS 10
static void do_setcmode(User *u)
{
char *channame, *params[SETCMODE_NPARAMS];
Channel *channel;
int i;
channame = strtok(NULL, " ");
for (i = 0; i < SETCMODE_NPARAMS; i++)
params[i] = strtok(NULL, " ");
if (!channame) {
notice(s_OperServ, u->nick, "SETCMODE: not enough parameters");
return;
}
if (strcmp(channame, "-") == 0) {
channel = NULL;
} else {
channel = get_channel(channame);
if (!channel) {
notice(s_OperServ, u->nick, "SETCMODE: channel not found (%s)",
channame);
return;
}
}
set_cmode(channel ? ServerName : NULL, channel,
params[0], params[1], params[2], params[3], params[4],
params[5], params[6], params[7], params[8], params[9]);
notice(s_OperServ, u->nick, "SETCMODE: done");
}
/*************************************************************************/
#endif /* DEBUG_COMMANDS */
/*************************************************************************/
/*********** MaskData expiration check (for database modules) ************/
/*************************************************************************/
/* Check for expiration of a MaskData; delete it and return 1 if expired,
* and return 0 if not expired.
*/
EXPORT_FUNC(check_expire_maskdata)
int check_expire_maskdata(uint8 type, MaskData *md)
{
if (md->expires && md->expires <= time(NULL)) {
call_callback_2(module, cb_expire_md, type, md);
del_maskdata(type, md);
return 1;
}
return 0;
}
/*************************************************************************/
/***************************** Module stuff ******************************/
/*************************************************************************/
const int32 module_version = MODULE_VERSION_CODE;
ConfigDirective module_config[] = {
{ "AllowRaw", { { CD_SET, 0, &AllowRaw } } },
{ "GlobalName", { { CD_STRING, CF_DIRREQ, &s_GlobalNoticer },
{ CD_STRING, 0, &desc_GlobalNoticer } } },
{ "KillClonesAutokill",{{ CD_SET, 0, &KillClonesAutokill },
{ CD_TIME, 0, &KillClonesAutokillExpire } } },
{ "OperServDB", { { CD_STRING, CF_DIRREQ, &OperDBName } } },
{ "OperServName", { { CD_STRING, CF_DIRREQ, &s_OperServ },
{ CD_STRING, 0, &desc_OperServ } } },
{ "ServicesRoot", { { CD_STRING, CF_DIRREQ, &ServicesRoot } } },
{ "WallBadOS", { { CD_SET, 0, &WallBadOS } } },
{ "WallOper", { { CD_SET, 0, &WallOper } } },
{ "WallOSChannel", { { CD_SET, 0, &WallOSChannel } } },
{ "WallSU", { { CD_SET, 0, &WallSU } } },
{ NULL }
};
/* For enabling/disabling RAW command (AllowRaw) */
static Command *cmd_RAW = NULL;
/* Previous value of clear_channel() sender */
static char old_clearchan_sender[NICKMAX];
static int old_clearchan_sender_set = 0;
/*************************************************************************/
static int do_load_module(Module *mod, const char *modname)
{
if (strcmp(modname, "operserv/akill") == 0) {
module_akill = mod;
} else if (strcmp(modname, "nickserv/main") == 0) {
char **p_s_NickServ;
Command *cmd;
module_nickserv = mod;
p_s_NickServ = get_module_symbol(mod, "s_NickServ");
if (p_s_NickServ) {
cmd = lookup_cmd(module, "ADMIN");
if (cmd)
cmd->help_param1 = *p_s_NickServ;
cmd = lookup_cmd(module, "OPER");
if (cmd)
cmd->help_param1 = *p_s_NickServ;
} else {
module_log("Unable to resolve NickServ symbol `s_NickServ'");
}
if (!add_callback(mod, "REGISTER/LINK check", do_reglink_check))
module_log("Unable to register NickServ REGISTER/LINK check"
" callback");
}
return 0;
}
/*************************************************************************/
static int do_unload_module(Module *mod)
{
if (mod == module_akill) {
module_akill = NULL;
} else if (mod == module_nickserv) {
Command *cmd;
cmd = lookup_cmd(module, "ADMIN");
if (cmd)
cmd->help_param1 = "NickServ";
cmd = lookup_cmd(module, "OPER");
if (cmd)
cmd->help_param1 = "NickServ";
remove_callback(module_nickserv, "REGISTER/LINK check",
do_reglink_check);
module_nickserv = NULL;
}
return 0;
}
/*************************************************************************/
static int do_reconfigure(int after_configure)
{
static char old_s_OperServ[NICKMAX];
static char *old_desc_OperServ = NULL;
static char *old_OperDBName = NULL;
if (!after_configure) {
/* Before reconfiguration: save old values. */
free(old_desc_OperServ); /* these might be non-NULL if a */
free(old_OperDBName); /* previous reconfigure failed */
strscpy(old_s_OperServ, s_OperServ, NICKMAX);
old_desc_OperServ = strdup(desc_OperServ);
old_OperDBName = strdup(OperDBName);
} else {
Command *cmd;
/* After reconfiguration: handle value changes. */
if (strcmp(old_s_OperServ, s_OperServ) != 0) {
if (strcmp(set_clear_channel_sender(PTR_INVALID),old_s_OperServ)==0)
set_clear_channel_sender(s_OperServ);
send_nickchange(old_s_OperServ, s_OperServ);
}
if (!old_desc_OperServ || strcmp(old_desc_OperServ,desc_OperServ) != 0)
send_namechange(s_OperServ, desc_OperServ);
if (!old_OperDBName || strcmp(old_OperDBName, OperDBName) != 0) {
module_log("reconfigure: new database name will only take"
" effect after restart");
/* Restore the old database name */
free(OperDBName);
OperDBName = old_OperDBName;
/* Make sure the old name isn't freed below */
old_OperDBName = NULL;
}
/* Free and clear old values */
free(old_desc_OperServ);
free(old_OperDBName);
old_desc_OperServ = NULL;
old_OperDBName = NULL;
/* Activate/deactivate commands */
if (cmd_RAW) {
if (AllowRaw)
cmd_RAW->name = "RAW";
else
cmd_RAW->name = "";
}
/* Update command help parameters */
if (module_nickserv) {
char **p_s_NickServ;
p_s_NickServ = get_module_symbol(module_nickserv, "s_NickServ");
if (p_s_NickServ) {
cmd = lookup_cmd(module, "ADMIN");
if (cmd)
cmd->help_param1 = *p_s_NickServ;
cmd = lookup_cmd(module, "OPER");
if (cmd)
cmd->help_param1 = *p_s_NickServ;
} else {
module_log("reconfigure: Unable to resolve NickServ symbol:"
" s_NickServ");
}
}
cmd = lookup_cmd(module, "GLOBAL");
if (cmd)
cmd->help_param1 = s_GlobalNoticer;
} /* if (!after_configure) */
return 0;
}
/*************************************************************************/
int init_module(Module *module_)
{
Command *cmd;
int i;
char *supass_ret;
module = module_;
if (!new_commandlist(module) || !register_commands(module, cmds)) {
module_log("Unable to register commands");
exit_module(0);
return 0;
}
cb_command = register_callback(module, "command");
cb_expire_md = register_callback(module, "expire maskdata");
cb_help = register_callback(module, "HELP");
cb_help_cmds = register_callback(module, "HELP COMMANDS");
cb_set = register_callback(module, "SET");
cb_stats = register_callback(module, "STATS");
cb_stats_all = register_callback(module, "STATS ALL");
if (cb_command < 0 || cb_help < 0 || cb_help_cmds < 0 || cb_set < 0
|| cb_stats < 0 || cb_stats_all < 0
) {
module_log("Unable to register callbacks");
exit_module(0);
return 0;
}
if (!add_callback(NULL, "load module", do_load_module)
|| !add_callback(NULL, "unload module", do_unload_module)
|| !add_callback(NULL, "reconfigure", do_reconfigure)
|| !add_callback(NULL, "save data", do_save_data)
|| !add_callback(NULL, "introduce_user", introduce_operserv)
|| !add_callback(NULL, "m_privmsg", operserv)
|| !add_callback(NULL, "m_whois", operserv_whois)
|| (WallOper && !add_callback(NULL, "user MODE", wall_oper_callback))
) {
module_log("Unable to add callbacks");
exit_module(0);
return 0;
}
if ((i = -1, !open_operserv_db(OperDBName))
|| (i = OSDATA_MAXUSERCNT, !get_operserv_data(i, &maxusercnt))
|| (i = OSDATA_MAXUSERTIME, !get_operserv_data(i, &maxusertime))
|| (i = OSDATA_SUPASS, !get_operserv_data(i, &supass_ret))
) {
module_log("Unable to read from database! (code %d)", i);
exit_module(0);
return 0;
}
if (supass_ret) {
no_supass = 0;
memcpy(supass, supass_ret, PASSMAX);
} else {
no_supass = 1;
}
db_opened = 1;
cmd_RAW = lookup_cmd(module, "RAW");
if (cmd_RAW && !AllowRaw)
cmd_RAW->name = "";
cmd = lookup_cmd(module, "GLOBAL");
if (cmd)
cmd->help_param1 = s_GlobalNoticer;
if (linked)
introduce_operserv(NULL);
strscpy(old_clearchan_sender, set_clear_channel_sender(s_OperServ),
sizeof(old_clearchan_sender));
old_clearchan_sender_set = 1;
return 1;
}
/*************************************************************************/
int exit_module(int shutdown_unused)
{
#ifdef CLEAN_COMPILE
shutdown_unused = shutdown_unused;
#endif
if (old_clearchan_sender_set) {
set_clear_channel_sender(old_clearchan_sender);
old_clearchan_sender_set = 0;
}
if (linked) {
send_cmd(s_OperServ, "QUIT :");
send_cmd(s_GlobalNoticer, "QUIT :");
}
if (cmd_RAW)
cmd_RAW->name = "RAW";
if (db_opened)
close_operserv_db(OperDBName);
if (module_nickserv)
do_unload_module(module_nickserv);
if (module_akill)
do_unload_module(module_akill);
remove_callback(NULL, "user MODE", wall_oper_callback);
remove_callback(NULL, "m_whois", operserv_whois);
remove_callback(NULL, "m_privmsg", operserv);
remove_callback(NULL, "introduce_user", introduce_operserv);
remove_callback(NULL, "save data", do_save_data);
remove_callback(NULL, "reconfigure", do_reconfigure);
remove_callback(NULL, "unload module", do_unload_module);
remove_callback(NULL, "load module", do_load_module);
unregister_callback(module, cb_stats_all);
unregister_callback(module, cb_stats);
unregister_callback(module, cb_set);
unregister_callback(module, cb_help_cmds);
unregister_callback(module, cb_help);
unregister_callback(module, cb_expire_md);
unregister_callback(module, cb_command);
unregister_commands(module, cmds);
del_commandlist(module);
return 1;
}
/*************************************************************************/
syntax highlighted by Code2HTML, v. 0.9.1