[solanum.git] / extensions / override.c

/*
 * oper-override for charybdis.
 *
 * adds usermode +p and has a timer event that is iterated over to disable
 * usermode +p after a while...
 *
 * you need to have oper:override permission on the opers you want to be
 * able to use this extension.
 */

#include "stdinc.h"
#include "modules.h"
#include "hook.h"
#include "client.h"
#include "ircd.h"
#include "send.h"
#include "hash.h"
#include "s_conf.h"
#include "s_user.h"
#include "s_serv.h"
#include "numeric.h"
#include "privilege.h"
#include "s_newconf.h"

static const char override_desc[] =
	"Adds user mode +p, an operator-only user mode that grants temporary privileges to override anything";

static void check_umode_change(void *data);
static void hack_channel_access(void *data);
static void hack_can_join(void *data);
static void hack_can_kick(void *data);
static void hack_can_send(void *data);
static void handle_client_exit(void *data);

mapi_hfn_list_av1 override_hfnlist[] = {
	{ "umode_changed", (hookfn) check_umode_change },
	{ "get_channel_access", (hookfn) hack_channel_access },
	{ "can_join", (hookfn) hack_can_join },
	{ "can_kick", (hookfn) hack_can_kick },
	{ "can_send", (hookfn) hack_can_send },
	{ "client_exit", (hookfn) handle_client_exit },
	{ NULL, NULL }
};

#define CHFL_OVERRIDE		0x0004
#define IsOperOverride(x)	(HasPrivilege((x), "oper:override"))

struct OverrideSession {
	rb_dlink_node node;

	struct Client *client;
	time_t deadline;
};

rb_dlink_list overriding_opers = { NULL, NULL, 0 };

static void
update_session_deadline(struct Client *source_p, struct OverrideSession *session_p)
{
	if (session_p == NULL)
	{
		rb_dlink_node *n;

		RB_DLINK_FOREACH(n, overriding_opers.head)
		{
			struct OverrideSession *s = n->data;

			if (s->client == source_p)
			{
				session_p = s;
				break;
			}
		}
	}

	if (session_p == NULL)
	{
		session_p = rb_malloc(sizeof(struct OverrideSession));
		session_p->client = source_p;
	}

	session_p->deadline = rb_current_time() + 1800;

	rb_dlinkDelete(&session_p->node, &overriding_opers);
	rb_dlinkAdd(session_p, &session_p->node, &overriding_opers);
}

static void
expire_override_deadlines(void *unused)
{
	rb_dlink_node *n, *tn;

	RB_DLINK_FOREACH_SAFE(n, tn, overriding_opers.head)
	{
		struct OverrideSession *session_p = n->data;

		if (session_p->deadline > rb_current_time())
			break;
		else if (session_p->deadline < rb_current_time())
		{
			const char *parv[4] = {session_p->client->name, session_p->client->name, "-p", NULL};
			user_mode(session_p->client, session_p->client, 3, parv);
		}
	}
}

static void
check_umode_change(void *vdata)
{
	hook_data_umode_changed *data = (hook_data_umode_changed *)vdata;
	struct Client *source_p = data->client;

	if (!MyClient(source_p))
		return;

	if (data->oldumodes & UMODE_OPER && !IsOper(source_p))
		source_p->umodes &= ~user_modes['p'];

	/* didn't change +p umode, we don't need to do anything */
	if (!((data->oldumodes ^ source_p->umodes) & user_modes['p']))
		return;

	if (source_p->umodes & user_modes['p'])
	{
		if (!IsOperOverride(source_p))
		{
			sendto_one_notice(source_p, ":*** You need oper:override privilege for +p");
			source_p->umodes &= ~user_modes['p'];
			return;
		}

		update_session_deadline(source_p, NULL);

		sendto_realops_snomask(SNO_GENERAL, L_NETWIDE, "%s has enabled oper-override (+p)",
				       get_oper_name(source_p));
	}
	else if (!(source_p->umodes & user_modes['p']))
	{
		rb_dlink_node *n, *tn;

		RB_DLINK_FOREACH_SAFE(n, tn, overriding_opers.head)
		{
			struct OverrideSession *session_p = n->data;

			if (session_p->client != source_p)
				continue;

			sendto_realops_snomask(SNO_GENERAL, L_NETWIDE, "%s has disabled oper-override (+p)",
					       get_oper_name(session_p->client));

			rb_dlinkDelete(n, &overriding_opers);
			rb_free(session_p);
		}
	}
}

static void
hack_channel_access(void *vdata)
{
	hook_data_channel_approval *data = (hook_data_channel_approval *) vdata;

	if (data->dir == MODE_QUERY)
		return;

	if (data->approved == CHFL_CHANOP)
		return;

	if (data->client->umodes & user_modes['p'])
	{
		update_session_deadline(data->client, NULL);
		data->approved = CHFL_OVERRIDE;

		/* we only want to report modehacks, which are always non-NULL */
		if (data->modestr)
			sendto_realops_snomask(SNO_GENERAL, L_NETWIDE, "%s is using oper-override on %s (modehacking: %s)",
					       get_oper_name(data->client), data->chptr->chname, data->modestr);
	}
}

static void
hack_can_join(void *vdata)
{
	hook_data_channel *data = (hook_data_channel *) vdata;

	if (data->approved == 0)
		return;

	if (data->client->umodes & user_modes['p'])
	{
		update_session_deadline(data->client, NULL);
		data->approved = 0;

		sendto_realops_snomask(SNO_GENERAL, L_NETWIDE, "%s is using oper-override on %s (banwalking)",
				       get_oper_name(data->client), data->chptr->chname);
	}
}

static void
hack_can_kick(void *vdata)
{
	hook_data_channel_approval *data = (hook_data_channel_approval *) vdata;
	int alevel;

	if (data->target->umodes & user_modes['p'])
	{
		if (data->client->umodes & user_modes['p'])
		{
			/* Using oper-override to kick an oper
			 * who's also using oper-override, better
			 * report what happened.
			 */
			update_session_deadline(data->client, NULL);
			sendto_realops_snomask(SNO_GENERAL, L_NETWIDE, "%s is using oper-override on %s (KICK %s)",
					       get_oper_name(data->client), data->chptr->chname, data->target->name);
		}
		else
		{
			/* Like cmode +M, let's report any attempt
			 * to kick the immune oper.
			 */
			update_session_deadline(data->target, NULL);
			sendto_realops_snomask(SNO_GENERAL, L_NETWIDE, "%s attempted to kick %s from %s (who is +p)",
				data->client->name, data->target->name, data->chptr->chname);
			sendto_one_numeric(data->client, ERR_ISCHANSERVICE, "%s %s :Cannot kick immune IRC operators.",
				data->target->name, data->chptr->chname);
			data->approved = 0;
		}
		return;
	}

	alevel = get_channel_access(data->client, data->chptr, data->msptr, data->dir, NULL);
	if (alevel != CHFL_OVERRIDE)
		return;

	if (data->client->umodes & user_modes['p'])
	{
		update_session_deadline(data->client, NULL);
		sendto_realops_snomask(SNO_GENERAL, L_NETWIDE, "%s is using oper-override on %s (KICK %s)",
				       get_oper_name(data->client), data->chptr->chname, data->target->name);
	}
}

static void
hack_can_send(void *vdata)
{
	hook_data_channel_approval *data = (hook_data_channel_approval *) vdata;

	if (data->dir == MODE_QUERY)
		return;

	if (data->approved == CAN_SEND_NONOP || data->approved == CAN_SEND_OPV)
		return;

	if (data->client->umodes & user_modes['p'])
	{
		data->approved = CAN_SEND_NONOP;

		if (MyClient(data->client))
		{
			update_session_deadline(data->client, NULL);
			sendto_realops_snomask(SNO_GENERAL, L_NETWIDE, "%s is using oper-override on %s (forcing message)",
					       get_oper_name(data->client), data->chptr->chname);
		}
	}
}

static void
handle_client_exit(void *vdata)
{
	hook_data_client_exit *data = (hook_data_client_exit *) vdata;
	rb_dlink_node *n, *tn;
	struct Client *source_p = data->target;

	RB_DLINK_FOREACH_SAFE(n, tn, overriding_opers.head)
	{
		struct OverrideSession *session_p = n->data;

		if (session_p->client != source_p)
			continue;

		rb_dlinkDelete(n, &overriding_opers);
		rb_free(session_p);
	}
}

struct ev_entry *expire_override_deadlines_ev = NULL;

static int
_modinit(void)
{
	rb_dlink_node *ptr;

	/* add the usermode to the available slot */
	user_modes['p'] = find_umode_slot();
	construct_umodebuf();

	RB_DLINK_FOREACH(ptr, lclient_list.head)
	{
		struct Client *client_p = ptr->data;
		if (IsPerson(client_p) && (client_p->umodes & user_modes['p']))
			update_session_deadline(client_p, NULL);
	}

	expire_override_deadlines_ev = rb_event_add("expire_override_deadlines", expire_override_deadlines, NULL, 60);

	return 0;
}

static void
_moddeinit(void)
{
	/* disable the umode and remove it from the available list */
	user_modes['p'] = 0;
	construct_umodebuf();

	rb_event_delete(expire_override_deadlines_ev);
}

DECLARE_MODULE_AV2(override, _modinit, _moddeinit, NULL, NULL,
			override_hfnlist, NULL, NULL, override_desc);
Commit	Line	Data
429cf1b7 AC	1	/*
	2	* oper-override for charybdis.
	3	*
	4	* adds usermode +p and has a timer event that is iterated over to disable
	5	* usermode +p after a while...
	6	*
	7	* you need to have oper:override permission on the opers you want to be
	8	* able to use this extension.
	9	*/
	10
	11	#include "stdinc.h"
	12	#include "modules.h"
	13	#include "hook.h"
	14	#include "client.h"
	15	#include "ircd.h"
	16	#include "send.h"
	17	#include "hash.h"
	18	#include "s_conf.h"
	19	#include "s_user.h"
	20	#include "s_serv.h"
	21	#include "numeric.h"
	22	#include "privilege.h"
	23	#include "s_newconf.h"
	24
3fd3d7e1 EM	25	static const char override_desc[] =
	26	"Adds user mode +p, an operator-only user mode that grants temporary privileges to override anything";
	27
429cf1b7 AC	28	static void check_umode_change(void *data);
429cf1b7 AC	29	static void hack_channel_access(void *data);
d3076881	30	static void hack_can_join(void *data);
f69d7feb	31	static void hack_can_kick(void *data);
9101dbcd	32	static void hack_can_send(void *data);
5c3014d0	33	static void handle_client_exit(void *data);
429cf1b7 AC	34
	35	mapi_hfn_list_av1 override_hfnlist[] = {
	36	{ "umode_changed", (hookfn) check_umode_change },
	37	{ "get_channel_access", (hookfn) hack_channel_access },
d3076881	38	{ "can_join", (hookfn) hack_can_join },
f69d7feb	39	{ "can_kick", (hookfn) hack_can_kick },
9101dbcd	40	{ "can_send", (hookfn) hack_can_send },
5c3014d0	41	{ "client_exit", (hookfn) handle_client_exit },
429cf1b7 AC	42	{ NULL, NULL }
	43	};
	44
f69d7feb	45	#define CHFL_OVERRIDE 0x0004
429cf1b7 AC	46	#define IsOperOverride(x) (HasPrivilege((x), "oper:override"))
	47
	48	struct OverrideSession {
	49	rb_dlink_node node;
	50
	51	struct Client *client;
	52	time_t deadline;
	53	};
	54
	55	rb_dlink_list overriding_opers = { NULL, NULL, 0 };
	56
	57	static void
	58	update_session_deadline(struct Client source_p, struct OverrideSession session_p)
	59	{
	60	if (session_p == NULL)
	61	{
	62	rb_dlink_node *n;
	63
	64	RB_DLINK_FOREACH(n, overriding_opers.head)
	65	{
	66	struct OverrideSession *s = n->data;
	67
	68	if (s->client == source_p)
	69	{
	70	session_p = s;
	71	break;
	72	}
	73	}
	74	}
	75
	76	if (session_p == NULL)
	77	{
	78	session_p = rb_malloc(sizeof(struct OverrideSession));
	79	session_p->client = source_p;
	80	}
	81
	82	session_p->deadline = rb_current_time() + 1800;
	83
	84	rb_dlinkDelete(&session_p->node, &overriding_opers);
	85	rb_dlinkAdd(session_p, &session_p->node, &overriding_opers);
	86	}
	87
	88	static void
	89	expire_override_deadlines(void *unused)
	90	{
	91	rb_dlink_node n, tn;
	92
	93	RB_DLINK_FOREACH_SAFE(n, tn, overriding_opers.head)
	94	{
	95	struct OverrideSession *session_p = n->data;
	96
	97	if (session_p->deadline > rb_current_time())
	98	break;
	99	else if (session_p->deadline < rb_current_time())
	100	{
bd2c29f7	101	const char *parv[4] = {session_p->client->name, session_p->client->name, "-p", NULL};
429cf1b7 AC	102	user_mode(session_p->client, session_p->client, 3, parv);
	103	}
	104	}
	105	}
	106
	107	static void
	108	check_umode_change(void *vdata)
	109	{
	110	hook_data_umode_changed data = (hook_data_umode_changed )vdata;
	111	struct Client *source_p = data->client;
	112
	113	if (!MyClient(source_p))
	114	return;
	115
e5c254d7 JT	116	if (data->oldumodes & UMODE_OPER && !IsOper(source_p))
	117	source_p->umodes &= ~user_modes['p'];
	118
429cf1b7 AC	119	/* didn't change +p umode, we don't need to do anything */
	120	if (!((data->oldumodes ^ source_p->umodes) & user_modes['p']))
	121	return;
	122
429cf1b7 AC	123	if (source_p->umodes & user_modes['p'])
429cf1b7 AC	124	{
e5c254d7 JT	125	if (!IsOperOverride(source_p))
	126	{
	127	sendto_one_notice(source_p, ":*** You need oper:override privilege for +p");
	128	source_p->umodes &= ~user_modes['p'];
	129	return;
	130	}
	131
429cf1b7 AC	132	update_session_deadline(source_p, NULL);
	133
	134	sendto_realops_snomask(SNO_GENERAL, L_NETWIDE, "%s has enabled oper-override (+p)",
	135	get_oper_name(source_p));
	136	}
	137	else if (!(source_p->umodes & user_modes['p']))
	138	{
	139	rb_dlink_node n, tn;
	140
	141	RB_DLINK_FOREACH_SAFE(n, tn, overriding_opers.head)
	142	{
	143	struct OverrideSession *session_p = n->data;
	144
	145	if (session_p->client != source_p)
	146	continue;
	147
	148	sendto_realops_snomask(SNO_GENERAL, L_NETWIDE, "%s has disabled oper-override (+p)",
	149	get_oper_name(session_p->client));
	150
	151	rb_dlinkDelete(n, &overriding_opers);
	152	rb_free(session_p);
	153	}
	154	}
	155	}
	156
	157	static void
	158	hack_channel_access(void *vdata)
	159	{
	160	hook_data_channel_approval data = (hook_data_channel_approval ) vdata;
	161
202d4966 AC	162	if (data->dir == MODE_QUERY)
	163	return;
	164
429cf1b7 AC	165	if (data->approved == CHFL_CHANOP)
	166	return;
	167
	168	if (data->client->umodes & user_modes['p'])
	169	{
	170	update_session_deadline(data->client, NULL);
f69d7feb	171	data->approved = CHFL_OVERRIDE;
429cf1b7	172
b870a5f8 AC	173	/* we only want to report modehacks, which are always non-NULL */
	174	if (data->modestr)
	175	sendto_realops_snomask(SNO_GENERAL, L_NETWIDE, "%s is using oper-override on %s (modehacking: %s)",
	176	get_oper_name(data->client), data->chptr->chname, data->modestr);
429cf1b7 AC	177	}
	178	}
	179
d3076881 AC	180	static void
	181	hack_can_join(void *vdata)
	182	{
	183	hook_data_channel data = (hook_data_channel ) vdata;
	184
	185	if (data->approved == 0)
	186	return;
	187
	188	if (data->client->umodes & user_modes['p'])
	189	{
	190	update_session_deadline(data->client, NULL);
	191	data->approved = 0;
	192
	193	sendto_realops_snomask(SNO_GENERAL, L_NETWIDE, "%s is using oper-override on %s (banwalking)",
	194	get_oper_name(data->client), data->chptr->chname);
	195	}
	196	}
	197
f69d7feb AC	198	static void
	199	hack_can_kick(void *vdata)
	200	{
	201	hook_data_channel_approval data = (hook_data_channel_approval ) vdata;
	202	int alevel;
	203
bd2c29f7 X	204	if (data->target->umodes & user_modes['p'])
	205	{
	206	if (data->client->umodes & user_modes['p'])
	207	{
	208	/* Using oper-override to kick an oper
	209	* who's also using oper-override, better
	210	* report what happened.
	211	*/
	212	update_session_deadline(data->client, NULL);
	213	sendto_realops_snomask(SNO_GENERAL, L_NETWIDE, "%s is using oper-override on %s (KICK %s)",
	214	get_oper_name(data->client), data->chptr->chname, data->target->name);
	215	}
	216	else
	217	{
	218	/* Like cmode +M, let's report any attempt
	219	* to kick the immune oper.
	220	*/
	221	update_session_deadline(data->target, NULL);
	222	sendto_realops_snomask(SNO_GENERAL, L_NETWIDE, "%s attempted to kick %s from %s (who is +p)",
	223	data->client->name, data->target->name, data->chptr->chname);
	224	sendto_one_numeric(data->client, ERR_ISCHANSERVICE, "%s %s :Cannot kick immune IRC operators.",
	225	data->target->name, data->chptr->chname);
	226	data->approved = 0;
	227	}
	228	return;
	229	}
	230
103a1bfd	231	alevel = get_channel_access(data->client, data->chptr, data->msptr, data->dir, NULL);
f69d7feb AC	232	if (alevel != CHFL_OVERRIDE)
	233	return;
	234
	235	if (data->client->umodes & user_modes['p'])
	236	{
	237	update_session_deadline(data->client, NULL);
	238	sendto_realops_snomask(SNO_GENERAL, L_NETWIDE, "%s is using oper-override on %s (KICK %s)",
	239	get_oper_name(data->client), data->chptr->chname, data->target->name);
	240	}
	241	}
	242
9101dbcd AC	243	static void
	244	hack_can_send(void *vdata)
	245	{
	246	hook_data_channel_approval data = (hook_data_channel_approval ) vdata;
	247
202d4966 AC	248	if (data->dir == MODE_QUERY)
	249	return;
	250
9101dbcd AC	251	if (data->approved == CAN_SEND_NONOP \|\| data->approved == CAN_SEND_OPV)
	252	return;
	253
	254	if (data->client->umodes & user_modes['p'])
	255	{
0d165b52	256	data->approved = CAN_SEND_NONOP;
9101dbcd	257
b4cdedaa JT	258	if (MyClient(data->client))
	259	{
	260	update_session_deadline(data->client, NULL);
	261	sendto_realops_snomask(SNO_GENERAL, L_NETWIDE, "%s is using oper-override on %s (forcing message)",
	262	get_oper_name(data->client), data->chptr->chname);
	263	}
9101dbcd AC	264	}
	265	}
	266
5c3014d0 AC	267	static void
	268	handle_client_exit(void *vdata)
	269	{
	270	hook_data_client_exit data = (hook_data_client_exit ) vdata;
	271	rb_dlink_node n, tn;
	272	struct Client *source_p = data->target;
	273
	274	RB_DLINK_FOREACH_SAFE(n, tn, overriding_opers.head)
	275	{
	276	struct OverrideSession *session_p = n->data;
	277
	278	if (session_p->client != source_p)
	279	continue;
	280
	281	rb_dlinkDelete(n, &overriding_opers);
	282	rb_free(session_p);
55abcbb2	283	}
5c3014d0 AC	284	}
5c3014d0 AC	285
429cf1b7 AC	286	struct ev_entry *expire_override_deadlines_ev = NULL;
	287
	288	static int
	289	_modinit(void)
	290	{
cc75db3f EK	291	rb_dlink_node *ptr;
cc75db3f EK	292
429cf1b7 AC	293	/* add the usermode to the available slot */
	294	user_modes['p'] = find_umode_slot();
	295	construct_umodebuf();
	296
cc75db3f EK	297	RB_DLINK_FOREACH(ptr, lclient_list.head)
	298	{
	299	struct Client *client_p = ptr->data;
	300	if (IsPerson(client_p) && (client_p->umodes & user_modes['p']))
	301	update_session_deadline(client_p, NULL);
	302	}
	303
bd2c29f7	304	expire_override_deadlines_ev = rb_event_add("expire_override_deadlines", expire_override_deadlines, NULL, 60);
429cf1b7 AC	305
	306	return 0;
	307	}
	308
	309	static void
	310	_moddeinit(void)
	311	{
	312	/* disable the umode and remove it from the available list */
	313	user_modes['p'] = 0;
	314	construct_umodebuf();
	315
	316	rb_event_delete(expire_override_deadlines_ev);
	317	}
	318
3fd3d7e1 EM	319	DECLARE_MODULE_AV2(override, _modinit, _moddeinit, NULL, NULL,
3fd3d7e1 EM	320	override_hfnlist, NULL, NULL, override_desc);