[solanum.git] / extensions / helpops.c

/*
 * Helpops system.
 *   -- kaniini
 */

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

static const char helpops_desc[] = "The helpops system as used by freenode";

static rb_dlink_list helper_list = { NULL, NULL, 0 };
static void h_hdl_stats_request(hook_data_int *hdata);
static void h_hdl_new_remote_user(struct Client *client_p);
static void h_hdl_client_exit(hook_data_client_exit *hdata);
static void h_hdl_umode_changed(hook_data_umode_changed *hdata);
static void h_hdl_whois(hook_data_client *hdata);
static void recurse_client_exit(struct Client *client_p);
static void helper_add(struct Client *client_p);
static void helper_delete(struct Client *client_p);
static void mo_dehelper(struct MsgBuf *, struct Client *, struct Client *, int, const char **);
static void me_dehelper(struct MsgBuf *, struct Client *, struct Client *, int, const char **);
static void do_dehelper(struct Client *source_p, struct Client *target_p);

mapi_hfn_list_av1 helpops_hfnlist[] = {
	{ "doing_stats", (hookfn) h_hdl_stats_request },
	{ "new_remote_user", (hookfn) h_hdl_new_remote_user },
	{ "client_exit", (hookfn) h_hdl_client_exit },
	{ "umode_changed", (hookfn) h_hdl_umode_changed },
	{ "doing_whois", (hookfn) h_hdl_whois },
	{ "doing_whois_global", (hookfn) h_hdl_whois },
	{ NULL, NULL }
};

#define UMODECHAR_HELPOPS 'H'

struct Message dehelper_msgtab = {
	"DEHELPER", 0, 0, 0, 0,
	{mg_unreg, mg_not_oper, mg_not_oper, mg_ignore, {me_dehelper, 2}, {mo_dehelper, 2}}
};

mapi_clist_av1 helpops_clist[] = { &dehelper_msgtab, NULL };

static void
mo_dehelper(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source_p, int parc, const char **parv)
{
	struct Client *target_p;

	if (!IsOperAdmin(source_p))
	{
		sendto_one(source_p, form_str(ERR_NOPRIVS), me.name, source_p->name, "admin");
		return;
	}

	if(!(target_p = find_named_person(parv[1])))
	{
		sendto_one_numeric(source_p, ERR_NOSUCHNICK, form_str(ERR_NOSUCHNICK), parv[1]);
		return;
	}

	if(MyClient(target_p))
		do_dehelper(source_p, target_p);
	else
		sendto_one(target_p, ":%s ENCAP %s DEHELPER %s",
				use_id(source_p), target_p->servptr->name, use_id(target_p));
}

static void
me_dehelper(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source_p, int parc, const char **parv)
{
	struct Client *target_p = find_person(parv[1]);
	if(!target_p)
	{
		sendto_one_numeric(source_p, ERR_NOSUCHNICK, form_str(ERR_NOSUCHNICK), parv[1]);
		return;
	}
	if(!MyClient(target_p))
		return;

	do_dehelper(source_p, target_p);
}

static void
do_dehelper(struct Client *source_p, struct Client *target_p)
{
	const char *fakeparv[4];

	if(!(target_p->umodes & user_modes[UMODECHAR_HELPOPS]))
		return;

	sendto_realops_snomask(SNO_GENERAL, L_NETWIDE, "%s is using DEHELPER on %s",
			source_p->name, target_p->name);
	sendto_one_notice(target_p, ":*** %s is using DEHELPER on you", source_p->name);

	fakeparv[0] = fakeparv[1] = target_p->name;
	fakeparv[2] = "-H";
	fakeparv[3] = NULL;
	user_mode(target_p, target_p, 3, fakeparv);
}

static int
_modinit(void)
{
	rb_dlink_node *ptr;

	user_modes[UMODECHAR_HELPOPS] = find_umode_slot();
	construct_umodebuf();

	RB_DLINK_FOREACH (ptr, global_client_list.head)
	{
		struct Client *client_p = ptr->data;
		if (IsPerson(client_p) && (client_p->umodes & user_modes[UMODECHAR_HELPOPS]))
			helper_add(client_p);
	}

	return 0;
}

static void
_moddeinit(void)
{
	rb_dlink_node *n, *tn;

	user_modes[UMODECHAR_HELPOPS] = 0;
	construct_umodebuf();

	RB_DLINK_FOREACH_SAFE(n, tn, helper_list.head)
		rb_dlinkDestroy(n, &helper_list);
}

static void
h_hdl_stats_request(hook_data_int *hdata)
{
	struct Client *target_p;
	rb_dlink_node *helper_ptr;
	unsigned int count = 0;

	if (hdata->arg2 != 'p')
		return;

	RB_DLINK_FOREACH (helper_ptr, helper_list.head)
	{
		target_p = helper_ptr->data;

		if(target_p->user->away)
			continue;

		count++;

		sendto_one_numeric(hdata->client, RPL_STATSDEBUG,
				   "p :%s (%s@%s)",
				   target_p->name, target_p->username,
				   target_p->host);
	}

	sendto_one_numeric(hdata->client, RPL_STATSDEBUG,
		"p :%u staff members", count);

	hdata->result = 1;
}

static void
helper_add(struct Client *client_p)
{
	if (rb_dlinkFind(client_p, &helper_list) != NULL)
		return;

	rb_dlinkAddAlloc(client_p, &helper_list);
}

static void
helper_delete(struct Client *client_p)
{
	rb_dlinkFindDestroy(client_p, &helper_list);
}

static void
h_hdl_new_remote_user(struct Client *client_p)
{
	if (client_p->umodes & user_modes[UMODECHAR_HELPOPS])
		helper_add(client_p);
}

static void
recurse_client_exit(struct Client *client_p)
{
	if (IsPerson(client_p))
	{
		if (client_p->umodes & user_modes[UMODECHAR_HELPOPS])
			helper_delete(client_p);
	}
	else if (IsServer(client_p))
	{
		rb_dlink_node *nptr;

		RB_DLINK_FOREACH(nptr, client_p->serv->users.head)
			recurse_client_exit(nptr->data);

		RB_DLINK_FOREACH(nptr, client_p->serv->servers.head)
			recurse_client_exit(nptr->data);
	}
}

static void
h_hdl_client_exit(hook_data_client_exit *hdata)
{
	recurse_client_exit(hdata->target);
}

static void
h_hdl_umode_changed(hook_data_umode_changed *hdata)
{
	struct Client *source_p = hdata->client;

	/* didn't change +H umode, we don't need to do anything */
	bool changed = (hdata->oldumodes ^ source_p->umodes) & user_modes[UMODECHAR_HELPOPS];

	if (source_p->umodes & user_modes[UMODECHAR_HELPOPS])
	{
		if (MyClient(source_p) && !HasPrivilege(source_p, "usermode:helpops"))
		{
			source_p->umodes &= ~user_modes[UMODECHAR_HELPOPS];
			sendto_one(source_p, form_str(ERR_NOPRIVS), me.name, source_p->name, "usermode:helpops");
			/* they didn't ask for +H so we must be removing it */
			if (!changed)
				helper_delete(source_p);
			return;
		}

		if (changed)
			helper_add(source_p);
	}
	else if (changed)
	{
		helper_delete(source_p);
	}
}

static void
h_hdl_whois(hook_data_client *hdata)
{
	struct Client *source_p = hdata->client;
	struct Client *target_p = hdata->target;

	if ((target_p->umodes & user_modes[UMODECHAR_HELPOPS]) && EmptyString(target_p->user->away))
	{
		sendto_one_numeric(source_p, RPL_WHOISHELPOP, form_str(RPL_WHOISHELPOP), target_p->name);
	}
}

DECLARE_MODULE_AV2(helpops, _modinit, _moddeinit, helpops_clist, NULL, helpops_hfnlist, NULL, NULL, helpops_desc);
Commit	Line	Data
4d21f1e8 AC	1	/*
	2	* Helpops system.
	3	* -- kaniini
	4	*/
	5
	6	#include "stdinc.h"
	7	#include "modules.h"
	8	#include "client.h"
	9	#include "hook.h"
	10	#include "ircd.h"
	11	#include "send.h"
	12	#include "s_conf.h"
	13	#include "s_user.h"
	14	#include "s_newconf.h"
	15	#include "numeric.h"
	16
eeabf33a EM	17	static const char helpops_desc[] = "The helpops system as used by freenode";
eeabf33a EM	18
4d21f1e8 AC	19	static rb_dlink_list helper_list = { NULL, NULL, 0 };
	20	static void h_hdl_stats_request(hook_data_int *hdata);
	21	static void h_hdl_new_remote_user(struct Client *client_p);
	22	static void h_hdl_client_exit(hook_data_client_exit *hdata);
	23	static void h_hdl_umode_changed(hook_data_umode_changed *hdata);
	24	static void h_hdl_whois(hook_data_client *hdata);
4d3f8ead	25	static void recurse_client_exit(struct Client *client_p);
b1c32af9 AC	26	static void helper_add(struct Client *client_p);
b1c32af9 AC	27	static void helper_delete(struct Client *client_p);
3c7d6fcc EM	28	static void mo_dehelper(struct MsgBuf , struct Client , struct Client , int, const char *);
	29	static void me_dehelper(struct MsgBuf , struct Client , struct Client , int, const char *);
	30	static void do_dehelper(struct Client source_p, struct Client target_p);
4d21f1e8 AC	31
	32	mapi_hfn_list_av1 helpops_hfnlist[] = {
	33	{ "doing_stats", (hookfn) h_hdl_stats_request },
	34	{ "new_remote_user", (hookfn) h_hdl_new_remote_user },
	35	{ "client_exit", (hookfn) h_hdl_client_exit },
	36	{ "umode_changed", (hookfn) h_hdl_umode_changed },
	37	{ "doing_whois", (hookfn) h_hdl_whois },
	38	{ "doing_whois_global", (hookfn) h_hdl_whois },
	39	{ NULL, NULL }
	40	};
	41
6c639159	42	#define UMODECHAR_HELPOPS 'H'
4d21f1e8	43
161ac1c8	44	struct Message dehelper_msgtab = {
7baa37a9	45	"DEHELPER", 0, 0, 0, 0,
161ac1c8 AC	46	{mg_unreg, mg_not_oper, mg_not_oper, mg_ignore, {me_dehelper, 2}, {mo_dehelper, 2}}
	47	};
	48
	49	mapi_clist_av1 helpops_clist[] = { &dehelper_msgtab, NULL };
	50
3c7d6fcc EM	51	static void
3c7d6fcc EM	52	mo_dehelper(struct MsgBuf msgbuf_p, struct Client client_p, struct Client source_p, int parc, const char *parv)
161ac1c8 AC	53	{
	54	struct Client *target_p;
	55
	56	if (!IsOperAdmin(source_p))
	57	{
	58	sendto_one(source_p, form_str(ERR_NOPRIVS), me.name, source_p->name, "admin");
3c7d6fcc	59	return;
161ac1c8 AC	60	}
	61
	62	if(!(target_p = find_named_person(parv[1])))
	63	{
	64	sendto_one_numeric(source_p, ERR_NOSUCHNICK, form_str(ERR_NOSUCHNICK), parv[1]);
3c7d6fcc	65	return;
161ac1c8 AC	66	}
	67
	68	if(MyClient(target_p))
	69	do_dehelper(source_p, target_p);
	70	else
	71	sendto_one(target_p, ":%s ENCAP %s DEHELPER %s",
	72	use_id(source_p), target_p->servptr->name, use_id(target_p));
161ac1c8 AC	73	}
161ac1c8 AC	74
3c7d6fcc EM	75	static void
3c7d6fcc EM	76	me_dehelper(struct MsgBuf msgbuf_p, struct Client client_p, struct Client source_p, int parc, const char *parv)
161ac1c8 AC	77	{
	78	struct Client *target_p = find_person(parv[1]);
	79	if(!target_p)
	80	{
	81	sendto_one_numeric(source_p, ERR_NOSUCHNICK, form_str(ERR_NOSUCHNICK), parv[1]);
3c7d6fcc	82	return;
161ac1c8 AC	83	}
161ac1c8 AC	84	if(!MyClient(target_p))
3c7d6fcc	85	return;
161ac1c8 AC	86
161ac1c8 AC	87	do_dehelper(source_p, target_p);
161ac1c8 AC	88	}
161ac1c8 AC	89
3c7d6fcc EM	90	static void
3c7d6fcc EM	91	do_dehelper(struct Client source_p, struct Client target_p)
161ac1c8 AC	92	{
	93	const char *fakeparv[4];
	94
6c639159	95	if(!(target_p->umodes & user_modes[UMODECHAR_HELPOPS]))
3c7d6fcc	96	return;
161ac1c8 AC	97
	98	sendto_realops_snomask(SNO_GENERAL, L_NETWIDE, "%s is using DEHELPER on %s",
	99	source_p->name, target_p->name);
	100	sendto_one_notice(target_p, ":*** %s is using DEHELPER on you", source_p->name);
	101
	102	fakeparv[0] = fakeparv[1] = target_p->name;
	103	fakeparv[2] = "-H";
	104	fakeparv[3] = NULL;
	105	user_mode(target_p, target_p, 3, fakeparv);
161ac1c8 AC	106	}
161ac1c8 AC	107
4d21f1e8 AC	108	static int
	109	_modinit(void)
	110	{
0c5dd86c EK	111	rb_dlink_node *ptr;
0c5dd86c EK	112
6c639159	113	user_modes[UMODECHAR_HELPOPS] = find_umode_slot();
4d21f1e8 AC	114	construct_umodebuf();
4d21f1e8 AC	115
0c5dd86c EK	116	RB_DLINK_FOREACH (ptr, global_client_list.head)
	117	{
	118	struct Client *client_p = ptr->data;
	119	if (IsPerson(client_p) && (client_p->umodes & user_modes[UMODECHAR_HELPOPS]))
	120	helper_add(client_p);
	121	}
	122
4d21f1e8 AC	123	return 0;
	124	}
	125
	126	static void
	127	_moddeinit(void)
	128	{
0c5dd86c EK	129	rb_dlink_node n, tn;
0c5dd86c EK	130
6c639159	131	user_modes[UMODECHAR_HELPOPS] = 0;
4d21f1e8	132	construct_umodebuf();
0c5dd86c EK	133
	134	RB_DLINK_FOREACH_SAFE(n, tn, helper_list.head)
	135	rb_dlinkDestroy(n, &helper_list);
4d21f1e8 AC	136	}
	137
	138	static void
	139	h_hdl_stats_request(hook_data_int *hdata)
	140	{
	141	struct Client *target_p;
	142	rb_dlink_node *helper_ptr;
	143	unsigned int count = 0;
	144
	145	if (hdata->arg2 != 'p')
	146	return;
	147
	148	RB_DLINK_FOREACH (helper_ptr, helper_list.head)
	149	{
	150	target_p = helper_ptr->data;
	151
4d21f1e8 AC	152	if(target_p->user->away)
	153	continue;
	154
	155	count++;
	156
	157	sendto_one_numeric(hdata->client, RPL_STATSDEBUG,
	158	"p :%s (%s@%s)",
	159	target_p->name, target_p->username,
	160	target_p->host);
	161	}
	162
	163	sendto_one_numeric(hdata->client, RPL_STATSDEBUG,
	164	"p :%u staff members", count);
	165
	166	hdata->result = 1;
	167	}
	168
b1c32af9 AC	169	static void
	170	helper_add(struct Client *client_p)
	171	{
	172	if (rb_dlinkFind(client_p, &helper_list) != NULL)
	173	return;
	174
	175	rb_dlinkAddAlloc(client_p, &helper_list);
	176	}
	177
	178	static void
	179	helper_delete(struct Client *client_p)
	180	{
	181	rb_dlinkFindDestroy(client_p, &helper_list);
	182	}
	183
4d21f1e8 AC	184	static void
	185	h_hdl_new_remote_user(struct Client *client_p)
	186	{
6c639159	187	if (client_p->umodes & user_modes[UMODECHAR_HELPOPS])
b1c32af9	188	helper_add(client_p);
4d21f1e8 AC	189	}
	190
	191	static void
4d3f8ead	192	recurse_client_exit(struct Client *client_p)
4d21f1e8	193	{
4d3f8ead	194	if (IsPerson(client_p))
8093dc5f	195	{
6c639159	196	if (client_p->umodes & user_modes[UMODECHAR_HELPOPS])
b1c32af9	197	helper_delete(client_p);
8093dc5f	198	}
4d3f8ead	199	else if (IsServer(client_p))
8093dc5f AC	200	{
	201	rb_dlink_node *nptr;
	202
4d3f8ead AC	203	RB_DLINK_FOREACH(nptr, client_p->serv->users.head)
4d3f8ead AC	204	recurse_client_exit(nptr->data);
8093dc5f	205
4d3f8ead AC	206	RB_DLINK_FOREACH(nptr, client_p->serv->servers.head)
4d3f8ead AC	207	recurse_client_exit(nptr->data);
8093dc5f	208	}
4d21f1e8 AC	209	}
4d21f1e8 AC	210
4d3f8ead AC	211	static void
	212	h_hdl_client_exit(hook_data_client_exit *hdata)
	213	{
	214	recurse_client_exit(hdata->target);
	215	}
	216
4d21f1e8 AC	217	static void
	218	h_hdl_umode_changed(hook_data_umode_changed *hdata)
	219	{
	220	struct Client *source_p = hdata->client;
	221
	222	/* didn't change +H umode, we don't need to do anything */
53390430	223	bool changed = (hdata->oldumodes ^ source_p->umodes) & user_modes[UMODECHAR_HELPOPS];
4d21f1e8	224
6c639159	225	if (source_p->umodes & user_modes[UMODECHAR_HELPOPS])
4d21f1e8 AC	226	{
	227	if (MyClient(source_p) && !HasPrivilege(source_p, "usermode:helpops"))
	228	{
6c639159	229	source_p->umodes &= ~user_modes[UMODECHAR_HELPOPS];
4d21f1e8	230	sendto_one(source_p, form_str(ERR_NOPRIVS), me.name, source_p->name, "usermode:helpops");
53390430 EK	231	/* they didn't ask for +H so we must be removing it */
	232	if (!changed)
	233	helper_delete(source_p);
4d21f1e8 AC	234	return;
	235	}
	236
53390430 EK	237	if (changed)
53390430 EK	238	helper_add(source_p);
4d21f1e8	239	}
53390430 EK	240	else if (changed)
53390430 EK	241	{
b1c32af9	242	helper_delete(source_p);
53390430	243	}
4d21f1e8 AC	244	}
	245
	246	static void
	247	h_hdl_whois(hook_data_client *hdata)
	248	{
	249	struct Client *source_p = hdata->client;
	250	struct Client *target_p = hdata->target;
	251
6c639159	252	if ((target_p->umodes & user_modes[UMODECHAR_HELPOPS]) && EmptyString(target_p->user->away))
4d21f1e8 AC	253	{
	254	sendto_one_numeric(source_p, RPL_WHOISHELPOP, form_str(RPL_WHOISHELPOP), target_p->name);
	255	}
	256	}
	257
a278a4fc	258	DECLARE_MODULE_AV2(helpops, _modinit, _moddeinit, helpops_clist, NULL, helpops_hfnlist, NULL, NULL, helpops_desc);