[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 (!HasPrivilege(source_p, "oper:dehelper"))
	{
		sendto_one(source_p, form_str(ERR_NOPRIVS), me.name, source_p->name, "dehelper");
		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];
	static const char minus_helpops[3] = {'-', UMODECHAR_HELPOPS, '\0'};

	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] = minus_helpops;
	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
0f8ec938	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
4a4b2095	56	if (!HasPrivilege(source_p, "oper:dehelper"))
161ac1c8	57	{
4a4b2095	58	sendto_one(source_p, form_str(ERR_NOPRIVS), me.name, source_p->name, "dehelper");
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	{
161ac1c8 AC	93	const char *fakeparv[4];
0f8ec938	94	static const char minus_helpops[3] = {'-', UMODECHAR_HELPOPS, '\0'};
161ac1c8	95
6c639159	96	if(!(target_p->umodes & user_modes[UMODECHAR_HELPOPS]))
3c7d6fcc	97	return;
161ac1c8 AC	98
	99	sendto_realops_snomask(SNO_GENERAL, L_NETWIDE, "%s is using DEHELPER on %s",
	100	source_p->name, target_p->name);
	101	sendto_one_notice(target_p, ":*** %s is using DEHELPER on you", source_p->name);
	102
	103	fakeparv[0] = fakeparv[1] = target_p->name;
0f8ec938	104	fakeparv[2] = minus_helpops;
161ac1c8 AC	105	fakeparv[3] = NULL;
161ac1c8 AC	106	user_mode(target_p, target_p, 3, fakeparv);
161ac1c8 AC	107	}
161ac1c8 AC	108
4d21f1e8 AC	109	static int
	110	_modinit(void)
	111	{
0c5dd86c EK	112	rb_dlink_node *ptr;
0c5dd86c EK	113
6c639159	114	user_modes[UMODECHAR_HELPOPS] = find_umode_slot();
4d21f1e8 AC	115	construct_umodebuf();
4d21f1e8 AC	116
0c5dd86c EK	117	RB_DLINK_FOREACH (ptr, global_client_list.head)
	118	{
	119	struct Client *client_p = ptr->data;
	120	if (IsPerson(client_p) && (client_p->umodes & user_modes[UMODECHAR_HELPOPS]))
	121	helper_add(client_p);
	122	}
	123
4d21f1e8 AC	124	return 0;
	125	}
	126
	127	static void
	128	_moddeinit(void)
	129	{
0c5dd86c EK	130	rb_dlink_node n, tn;
0c5dd86c EK	131
6c639159	132	user_modes[UMODECHAR_HELPOPS] = 0;
4d21f1e8	133	construct_umodebuf();
0c5dd86c EK	134
	135	RB_DLINK_FOREACH_SAFE(n, tn, helper_list.head)
	136	rb_dlinkDestroy(n, &helper_list);
4d21f1e8 AC	137	}
	138
	139	static void
	140	h_hdl_stats_request(hook_data_int *hdata)
	141	{
	142	struct Client *target_p;
	143	rb_dlink_node *helper_ptr;
	144	unsigned int count = 0;
	145
	146	if (hdata->arg2 != 'p')
	147	return;
	148
	149	RB_DLINK_FOREACH (helper_ptr, helper_list.head)
	150	{
	151	target_p = helper_ptr->data;
	152
4d21f1e8 AC	153	if(target_p->user->away)
	154	continue;
	155
	156	count++;
	157
	158	sendto_one_numeric(hdata->client, RPL_STATSDEBUG,
	159	"p :%s (%s@%s)",
	160	target_p->name, target_p->username,
	161	target_p->host);
	162	}
	163
	164	sendto_one_numeric(hdata->client, RPL_STATSDEBUG,
	165	"p :%u staff members", count);
	166
	167	hdata->result = 1;
	168	}
	169
b1c32af9 AC	170	static void
	171	helper_add(struct Client *client_p)
	172	{
	173	if (rb_dlinkFind(client_p, &helper_list) != NULL)
	174	return;
	175
	176	rb_dlinkAddAlloc(client_p, &helper_list);
	177	}
	178
	179	static void
	180	helper_delete(struct Client *client_p)
	181	{
	182	rb_dlinkFindDestroy(client_p, &helper_list);
	183	}
	184
4d21f1e8 AC	185	static void
	186	h_hdl_new_remote_user(struct Client *client_p)
	187	{
6c639159	188	if (client_p->umodes & user_modes[UMODECHAR_HELPOPS])
b1c32af9	189	helper_add(client_p);
4d21f1e8 AC	190	}
	191
	192	static void
4d3f8ead	193	recurse_client_exit(struct Client *client_p)
4d21f1e8	194	{
4d3f8ead	195	if (IsPerson(client_p))
8093dc5f	196	{
6c639159	197	if (client_p->umodes & user_modes[UMODECHAR_HELPOPS])
b1c32af9	198	helper_delete(client_p);
8093dc5f	199	}
4d3f8ead	200	else if (IsServer(client_p))
8093dc5f AC	201	{
	202	rb_dlink_node *nptr;
	203
4d3f8ead AC	204	RB_DLINK_FOREACH(nptr, client_p->serv->users.head)
4d3f8ead AC	205	recurse_client_exit(nptr->data);
8093dc5f	206
4d3f8ead AC	207	RB_DLINK_FOREACH(nptr, client_p->serv->servers.head)
4d3f8ead AC	208	recurse_client_exit(nptr->data);
8093dc5f	209	}
4d21f1e8 AC	210	}
4d21f1e8 AC	211
4d3f8ead AC	212	static void
	213	h_hdl_client_exit(hook_data_client_exit *hdata)
	214	{
	215	recurse_client_exit(hdata->target);
	216	}
	217
4d21f1e8 AC	218	static void
	219	h_hdl_umode_changed(hook_data_umode_changed *hdata)
	220	{
	221	struct Client *source_p = hdata->client;
	222
0f8ec938	223	/* didn't change +h umode, we don't need to do anything */
53390430	224	bool changed = (hdata->oldumodes ^ source_p->umodes) & user_modes[UMODECHAR_HELPOPS];
4d21f1e8	225
6c639159	226	if (source_p->umodes & user_modes[UMODECHAR_HELPOPS])
4d21f1e8 AC	227	{
	228	if (MyClient(source_p) && !HasPrivilege(source_p, "usermode:helpops"))
	229	{
6c639159	230	source_p->umodes &= ~user_modes[UMODECHAR_HELPOPS];
4d21f1e8	231	sendto_one(source_p, form_str(ERR_NOPRIVS), me.name, source_p->name, "usermode:helpops");
0f8ec938	232	/* they didn't ask for +h so we must be removing it */
53390430 EK	233	if (!changed)
53390430 EK	234	helper_delete(source_p);
4d21f1e8 AC	235	return;
	236	}
	237
53390430 EK	238	if (changed)
53390430 EK	239	helper_add(source_p);
4d21f1e8	240	}
53390430 EK	241	else if (changed)
53390430 EK	242	{
b1c32af9	243	helper_delete(source_p);
53390430	244	}
4d21f1e8 AC	245	}
	246
	247	static void
	248	h_hdl_whois(hook_data_client *hdata)
	249	{
	250	struct Client *source_p = hdata->client;
	251	struct Client *target_p = hdata->target;
	252
6c639159	253	if ((target_p->umodes & user_modes[UMODECHAR_HELPOPS]) && EmptyString(target_p->user->away))
4d21f1e8 AC	254	{
	255	sendto_one_numeric(source_p, RPL_WHOISHELPOP, form_str(RPL_WHOISHELPOP), target_p->name);
	256	}
	257	}
	258
a278a4fc	259	DECLARE_MODULE_AV2(helpops, _modinit, _moddeinit, helpops_clist, NULL, helpops_hfnlist, NULL, NULL, helpops_desc);