/*
  * Easily remove *-Lines in bulk
  * (C) Copyright 2019 Gottem and the UnrealIRCd 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 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 "unrealircd.h"
 
 ModuleHeader MOD_HEADER = {
 	"rmtkl",
 	"1.4",
 	"Adds /rmtkl command to easily remove *-Lines in bulk",
 	"Gottem and the UnrealIRCd Team",
 	"unrealircd-6",
 };
 
 #define IsParam(x) (parc > (x) && !BadPtr(parv[(x)]))
 #define IsNotParam(x) (parc <= (x) || BadPtr(parv[(x)]))
 
 typedef struct {
 	int type;
 	char flag;
 	char *txt;
 	char *operpriv;
 } TKLType;
 
 static void dump_str(Client *client, const char **buf);
 static TKLType *find_TKLType_by_flag(char flag);
 void rmtkl_check_options(const char *param, int *skipperm, int *silent);
 int rmtkl_tryremove(Client *client, TKLType *tkltype, TKL *tkl, const char *uhmask, const char *commentmask, int skipperm, int silent);
 CMD_FUNC(rmtkl);
 
 TKLType tkl_types[] = {
 	{ TKL_KILL, 'k', "K-Line", "server-ban:kline:remove" },
 	{ TKL_ZAP, 'z',	"Z-Line", "server-ban:zline:local:remove" },
 	{ TKL_KILL | TKL_GLOBAL, 'G', "G-Line", "server-ban:gline:remove" },
 	{ TKL_ZAP | TKL_GLOBAL, 'Z', "Global Z-Line", "server-ban:zline:global:remove" },
 	{ TKL_SHUN | TKL_GLOBAL, 's', "Shun", "server-ban:shun:remove" },
 //	{ TKL_SPAMF | TKL_GLOBAL, 'F', "Global Spamfilter", "server-ban:spamfilter:remove" }, TODO: re-add spamfilter support
 	{ 0, 0, "Unknown *-Line", 0 },
 };
 
 static const char *rmtkl_help[] = {
 	"*** \002Help on /rmtkl\002 *** ",
 	"Removes all TKLs matching the given conditions from the local server, or the entire",
 	"network if it's a global-type ban.",
 	"Syntax:",
 	"    \002/rmtkl\002 \037user@host\037 \037type\037 [\037comment\037] [\037-skipperm\037] [\037-silent\037]",
 	"The \037user@host\037 field is a wildcard mask to match the target of a ban.",
 	"The \037type\037 field may contain any number of the following characters:",
 	"    k, z, G, Z, s, F and *",
 	"    These correspond to (local) K-Line, (local) Z-Line, G-Line, Global Z-Line, (global) Shun and (global) Spamfilter",
 	"    (asterisk includes every type besides F)",
 	"The \037comment\037 field is also a wildcard mask to match the reason text of a ban. If specified, it must always",
 	"come \037before\037 the options starting with \002-\002.",
 	"Examples:",
 	"    - \002/rmtkl * *\002",
 	"        [remove \037all\037 supported TKLs except spamfilters]",
 	"    - \002/rmtkl *@*.mx GZ\002 * -skipperm",
 	"        [remove all Mexican G/Z-Lines while skipping over permanent ones]",
 /*	"    - \002/rmtkl * * *Zombie*\002",
 	"        [remove all non-spamfilter bans having \037Zombie\037 in the reason field]", TODO: re-add spamfilter support  */
 	"*** \002End of help\002 ***",
 	NULL
 };
 
 MOD_INIT()
 {
 	MARK_AS_OFFICIAL_MODULE(modinfo);
 	if (CommandExists("RMTKL"))
 	{
 		config_error("Command RMTKL already exists");
 		return MOD_FAILED;
 	}
 	CommandAdd(modinfo->handle, "RMTKL", rmtkl, 5, CMD_USER);
 	return MOD_SUCCESS;
 }
 
 MOD_LOAD()
 {
 	if (ModuleGetError(modinfo->handle) != MODERR_NOERROR)
 	{
 		config_error("A critical error occurred when loading module %s: %s", MOD_HEADER.name, ModuleGetErrorStr(modinfo->handle));
 		return MOD_FAILED;
 	}
 	return MOD_SUCCESS;
 }
 
 MOD_UNLOAD()
 {
 	return MOD_SUCCESS;
 }
 
 static void dump_str(Client *client, const char **buf)
 {
 	if (!MyUser(client))
 		return;
 
 	// Using sendto_one() instead of sendnumericfmt() because the latter strips indentation and stuff ;]
 	for (; *buf != NULL; buf++)
 		sendto_one(client, NULL, ":%s %03d %s :%s", me.name, RPL_TEXT, client->name, *buf);
 
 	// Let user take 8 seconds to read it
 	add_fake_lag(client, 8000);
 }
 
 static TKLType *find_TKLType_by_flag(char flag)
 {
 	TKLType *t;
 	for (t = tkl_types; t->type; t++)
 		if (t->flag == flag)
 			break;
 	return t;
 }
 
 void rmtkl_check_options(const char *param, int *skipperm, int *silent) {
 	if (!strcasecmp("-skipperm", param))
 		*skipperm = 1;
 	if (!strcasecmp("-silent", param))
 		*silent = 1;
 }
 
 int rmtkl_tryremove(Client *client, TKLType *tkltype, TKL *tkl, const char *uhmask, const char *commentmask, int skipperm, int silent)
 {
 	if (tkl->type != tkltype->type)
 		return 0;
 
 	// Let's not touch Q-Lines
 	if (tkl->type & TKL_NAME)
 		return 0;
 
 	/* Don't touch TKL's that were added through config */
 	if (tkl->flags & TKL_FLAG_CONFIG)
 		return 0;
 
 	if (TKLIsSpamfilter(tkl))
 	{
 #if 0
 //FIXME: re-add spamfilter support
 		// Is a spamfilter added through IRC, we can remove this if the "user" mask matches the reason
 		if (!match_simple(uhmask, tkl->reason))
 			return 0;
 #endif
 	} else
 	if (TKLIsServerBan(tkl))
 	{
 		if (!match_simple(uhmask, make_user_host(tkl->ptr.serverban->usermask, tkl->ptr.serverban->hostmask)))
 			return 0;
 
 		if (commentmask && !match_simple(commentmask, tkl->ptr.serverban->reason))
 			return 0;
 	} else
 		return 0;
 
 	if (skipperm && tkl->expire_at == 0)
 		return 0;
 
 	if (!silent)
 		sendnotice_tkl_del(client->name, tkl);
 
 	RunHook(HOOKTYPE_TKL_DEL, client, tkl);
 
 	if (tkl->type & TKL_SHUN)
 		tkl_check_local_remove_shun(tkl);
 	tkl_del_line(tkl);
 	return 1;
 }
 
 CMD_FUNC(rmtkl)
 {
 	TKL *tkl, *next;
 	TKLType *tkltype;
 	const char *types, *uhmask, *commentmask, *p;
 	char tklchar;
 	int tklindex, tklindex2, skipperm, silent;
 	unsigned int count;
 	char broadcast[BUFSIZE];
 
 	if (!IsULine(client) && !IsOper(client))
 	{
 		sendnumeric(client, ERR_NOPRIVILEGES);
 		return;
 	}
 
 	if (IsNotParam(1))
 	{
 		dump_str(client, rmtkl_help);
 		return;
 	}
 
 	if (IsNotParam(2))
 	{
 		sendnotice(client, "Not enough parameters. Type /RMTKL for help.");
 		return;
 	}
 
 	uhmask = parv[1];
 	types = parv[2];
 	commentmask = NULL;
 	skipperm = 0;
 	silent = 0;
 	count = 0;
 	snprintf(broadcast, sizeof(broadcast), ":%s RMTKL %s %s", client->name, types, uhmask);
 
 	// Check for optionals
 	if (IsParam(3))
 	{
 		// Comment mask, if specified, always goes third
 		if (*parv[3] != '-')
 			commentmask = parv[3];
 		else
 			rmtkl_check_options(parv[3], &skipperm, &silent);
 		ircsnprintf(broadcast, sizeof(broadcast), "%s %s", broadcast, parv[3]);
 	}
 	if (IsParam(4))
 	{
 		rmtkl_check_options(parv[4], &skipperm, &silent);
 		ircsnprintf(broadcast, sizeof(broadcast), "%s %s", broadcast, parv[4]);
 	}
 	if (IsParam(5))
 	{
 		rmtkl_check_options(parv[5], &skipperm, &silent);
 		ircsnprintf(broadcast, sizeof(broadcast), "%s %s", broadcast, parv[5]);
 	}
 
 	// Wildcard resolves to everything but 'F', since spamfilters are a bit special
 	if (strchr(types, '*'))
 		types = "kzGZs";
 
 	// Make sure the oper actually has the privileges to remove the *-Lines he wants
 	if (!IsULine(client))
 	{
 		for (p = types; *p; p++)
 		{
 			tkltype = find_TKLType_by_flag(*p);
 			if (!tkltype->type)
 				continue;
 
 			if (!ValidatePermissionsForPath(tkltype->operpriv, client, NULL, NULL, NULL))
 			{
 				sendnumeric(client, ERR_NOPRIVILEGES);
 				return;
 			}
 		}
 	}
 
 	// Broadcast the command to other servers *before* we proceed with removal
 	sendto_server(NULL, 0, 0, NULL, "%s", broadcast);
 
 	// Loop over all supported types
 	for (tkltype = tkl_types; tkltype->type; tkltype++) {
 		if (!strchr(types, tkltype->flag))
 			continue;
 
 		// Loop over all TKL entries, first try the ones in the hash table
 		tklchar = tkl_typetochar(tkltype->type);
 		tklindex = tkl_ip_hash_type(tklchar);
 		if (tklindex >= 0)
 		{
 			for (tklindex2 = 0; tklindex2 < TKLIPHASHLEN2; tklindex2++)
 			{
 				for (tkl = tklines_ip_hash[tklindex][tklindex2]; tkl; tkl = next)
 				{
 					next = tkl->next;
 					count += rmtkl_tryremove(client, tkltype, tkl, uhmask, commentmask, skipperm, silent);
 				}
 			}
 		}
 
 		// Then the regular *-Lines (not an else because certain TKLs might have a hash as well as a plain linked list)
 		tklindex = tkl_hash(tklchar);
 		for (tkl = tklines[tklindex]; tkl; tkl = next)
 		{
 			next = tkl->next;
 			count += rmtkl_tryremove(client, tkltype, tkl, uhmask, commentmask, skipperm, silent);
 		}
 	}
 
 	unreal_log(ULOG_INFO, "tkl", "RMTKL_COMMAND", client,
 	           "[rmtkl] $client removed $tkl_removed_count TKLine(s) using /RMTKL",
 	           log_data_integer("tkl_removed_count", count));
 }

© 2023 acidvegas, inc • generated with stagit